Subarashimo
505 lines
16 KiB
JavaScript
505 lines
16 KiB
JavaScript
/**
|
|
* JSON Format Tests for RPG Companion
|
|
*
|
|
* These tests can be run in two ways:
|
|
* 1. In browser console: Copy/paste or load as module in SillyTavern
|
|
* 2. Via Node.js: Run with `node tests/jsonFormat.test.js`
|
|
*
|
|
* Tests cover:
|
|
* - JSON prompt generation
|
|
* - JSON response parsing
|
|
* - Data structure validation
|
|
*/
|
|
|
|
// Mock SillyTavern context for Node.js testing
|
|
const isBrowser = typeof window !== 'undefined';
|
|
|
|
// Sample mock data for testing
|
|
const mockTrackerConfig = {
|
|
userStats: {
|
|
customStats: [
|
|
{ id: 'health', name: 'Health', enabled: true },
|
|
{ id: 'energy', name: 'Energy', enabled: true }
|
|
],
|
|
showRPGAttributes: true,
|
|
rpgAttributes: [
|
|
{ id: 'str', name: 'Strength', enabled: true },
|
|
{ id: 'dex', name: 'Dexterity', enabled: true }
|
|
],
|
|
statusSection: {
|
|
enabled: true,
|
|
showMoodEmoji: true,
|
|
customFields: ['Conditions']
|
|
},
|
|
skillsSection: {
|
|
enabled: true,
|
|
customFields: ['Combat', 'Stealth', 'Magic']
|
|
}
|
|
},
|
|
infoBox: {
|
|
widgets: {
|
|
date: { enabled: true },
|
|
weather: { enabled: true },
|
|
temperature: { enabled: true, unit: 'C' },
|
|
time: { enabled: true },
|
|
location: { enabled: true },
|
|
recentEvents: { enabled: true }
|
|
}
|
|
},
|
|
presentCharacters: {
|
|
showEmoji: true,
|
|
relationshipFields: ['Enemy', 'Neutral', 'Friend', 'Lover'],
|
|
customFields: [
|
|
{ id: 'appearance', name: 'Appearance', enabled: true },
|
|
{ id: 'demeanor', name: 'Demeanor', enabled: true }
|
|
],
|
|
thoughts: { enabled: true, name: 'Thoughts' },
|
|
characterStats: {
|
|
enabled: true,
|
|
customStats: [
|
|
{ id: 'health', name: 'Health', enabled: true },
|
|
{ id: 'arousal', name: 'Arousal', enabled: true }
|
|
]
|
|
}
|
|
}
|
|
};
|
|
|
|
// Sample JSON responses for testing parser
|
|
const sampleValidJSONResponse = `
|
|
Here's an interesting development in the story...
|
|
|
|
\`\`\`json
|
|
{
|
|
"userStats": {
|
|
"health": 85,
|
|
"energy": 60,
|
|
"str": 14,
|
|
"dex": 12,
|
|
"status": {
|
|
"mood": "😊",
|
|
"conditions": "Well-rested"
|
|
}
|
|
},
|
|
"skills": {
|
|
"combat": [
|
|
{ "name": "Sword Fighting", "description": "Basic melee combat with swords", "linkedItem": "Iron Sword" },
|
|
{ "name": "Parry", "description": "Deflect incoming attacks" }
|
|
],
|
|
"stealth": [
|
|
{ "name": "Sneak", "description": "Move quietly" }
|
|
],
|
|
"magic": []
|
|
},
|
|
"inventory": {
|
|
"onPerson": [
|
|
{ "name": "Iron Sword", "description": "A sturdy blade" },
|
|
{ "name": "Leather Armor", "description": "Basic protection" },
|
|
{ "name": "Health Potion", "description": "Restores 50 HP" }
|
|
],
|
|
"stored": {
|
|
"Backpack": [
|
|
{ "name": "Rope", "description": "50 feet of hemp rope" }
|
|
]
|
|
},
|
|
"assets": [
|
|
{ "name": "Small Cottage", "description": "A humble dwelling in the village" }
|
|
]
|
|
},
|
|
"quests": {
|
|
"main": "Find the Lost Artifact",
|
|
"optional": ["Gather herbs for the healer", "Clear the rat infestation"]
|
|
},
|
|
"infoBox": {
|
|
"date": "15th of Sunstone, Year 1423",
|
|
"weather": "☀️ Sunny",
|
|
"temperature": "22°C",
|
|
"time": "Midday",
|
|
"location": "Village Square",
|
|
"recentEvents": ["Met the village elder", "Bought supplies"]
|
|
},
|
|
"presentCharacters": [
|
|
{
|
|
"name": "Elena",
|
|
"description": "A young healer with kind eyes",
|
|
"emoji": "😊",
|
|
"relationship": "Friend",
|
|
"stats": { "health": 100, "arousal": 10 },
|
|
"appearance": "Long brown hair, green robes",
|
|
"demeanor": "Cheerful and helpful",
|
|
"thoughts": "I hope they can help me find the rare herbs..."
|
|
}
|
|
]
|
|
}
|
|
\`\`\`
|
|
|
|
The village was bustling with activity...
|
|
`;
|
|
|
|
const sampleMalformedJSONResponse = `
|
|
Some story text here...
|
|
|
|
\`\`\`json
|
|
{
|
|
"userStats": {
|
|
"health": 85,
|
|
"energy": 60,
|
|
},
|
|
"inventory": {
|
|
"onPerson": [
|
|
{ "name": "Sword", "description": "Sharp" }
|
|
]
|
|
}
|
|
}
|
|
\`\`\`
|
|
`;
|
|
|
|
const sampleSimplifiedInventoryResponse = `
|
|
\`\`\`json
|
|
{
|
|
"userStats": {
|
|
"health": 75,
|
|
"energy": 50
|
|
},
|
|
"inventory": {
|
|
"simplified": [
|
|
{ "name": "Magic Staff", "description": "Channels arcane energy" },
|
|
{ "name": "Spell Book", "description": "Contains basic spells" },
|
|
{ "name": "Mana Potion", "description": "Restores magical energy" }
|
|
]
|
|
}
|
|
}
|
|
\`\`\`
|
|
`;
|
|
|
|
// Test results accumulator
|
|
const testResults = {
|
|
passed: 0,
|
|
failed: 0,
|
|
errors: []
|
|
};
|
|
|
|
/**
|
|
* Simple assertion helper
|
|
*/
|
|
function assert(condition, message) {
|
|
if (condition) {
|
|
testResults.passed++;
|
|
console.log(`✅ PASS: ${message}`);
|
|
} else {
|
|
testResults.failed++;
|
|
testResults.errors.push(message);
|
|
console.error(`❌ FAIL: ${message}`);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test JSON extraction from markdown code blocks
|
|
*/
|
|
function testJSONExtraction() {
|
|
console.log('\n📋 Testing JSON Extraction from Code Blocks...\n');
|
|
|
|
// Test 1: Extract valid JSON from code block
|
|
const jsonRegex = /```(?:json)?\s*([\s\S]*?)```/i;
|
|
const match = sampleValidJSONResponse.match(jsonRegex);
|
|
assert(match !== null, 'Should find JSON code block in response');
|
|
|
|
if (match) {
|
|
let parsed;
|
|
try {
|
|
parsed = JSON.parse(match[1].trim());
|
|
assert(true, 'Should parse extracted JSON successfully');
|
|
assert(parsed.userStats !== undefined, 'Parsed JSON should have userStats');
|
|
assert(parsed.inventory !== undefined, 'Parsed JSON should have inventory');
|
|
assert(parsed.skills !== undefined, 'Parsed JSON should have skills');
|
|
assert(parsed.quests !== undefined, 'Parsed JSON should have quests');
|
|
assert(parsed.infoBox !== undefined, 'Parsed JSON should have infoBox');
|
|
assert(parsed.presentCharacters !== undefined, 'Parsed JSON should have presentCharacters');
|
|
} catch (e) {
|
|
assert(false, `Should not throw parsing error: ${e.message}`);
|
|
}
|
|
}
|
|
|
|
// Test 2: Handle malformed JSON (trailing comma)
|
|
const malformedMatch = sampleMalformedJSONResponse.match(jsonRegex);
|
|
assert(malformedMatch !== null, 'Should find malformed JSON code block');
|
|
|
|
if (malformedMatch) {
|
|
try {
|
|
JSON.parse(malformedMatch[1].trim());
|
|
assert(false, 'Malformed JSON should throw parsing error');
|
|
} catch (e) {
|
|
assert(true, 'Malformed JSON correctly throws parsing error');
|
|
|
|
// Test JSON fixing (remove trailing commas)
|
|
const fixed = malformedMatch[1].trim()
|
|
.replace(/,\s*}/g, '}')
|
|
.replace(/,\s*]/g, ']');
|
|
try {
|
|
const fixedParsed = JSON.parse(fixed);
|
|
assert(fixedParsed.userStats.health === 85, 'Fixed JSON should parse correctly');
|
|
} catch (e2) {
|
|
assert(false, `JSON fixing should work: ${e2.message}`);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Test inventory data structure validation
|
|
*/
|
|
function testInventoryStructure() {
|
|
console.log('\n📦 Testing Inventory Structure...\n');
|
|
|
|
const jsonRegex = /```(?:json)?\s*([\s\S]*?)```/i;
|
|
const match = sampleValidJSONResponse.match(jsonRegex);
|
|
const data = JSON.parse(match[1].trim());
|
|
|
|
const inv = data.inventory;
|
|
|
|
// Test onPerson array structure
|
|
assert(Array.isArray(inv.onPerson), 'onPerson should be an array');
|
|
assert(inv.onPerson.length > 0, 'onPerson should have items');
|
|
assert(inv.onPerson[0].name !== undefined, 'Items should have name property');
|
|
assert(inv.onPerson[0].description !== undefined, 'Items should have description property');
|
|
|
|
// Test stored object structure
|
|
assert(typeof inv.stored === 'object', 'stored should be an object');
|
|
assert(inv.stored.Backpack !== undefined, 'stored should have location keys');
|
|
assert(Array.isArray(inv.stored.Backpack), 'stored locations should be arrays');
|
|
|
|
// Test assets array
|
|
assert(Array.isArray(inv.assets), 'assets should be an array');
|
|
|
|
// Test simplified inventory
|
|
const simplifiedMatch = sampleSimplifiedInventoryResponse.match(jsonRegex);
|
|
const simplifiedData = JSON.parse(simplifiedMatch[1].trim());
|
|
assert(Array.isArray(simplifiedData.inventory.simplified), 'simplified inventory should be an array');
|
|
}
|
|
|
|
/**
|
|
* Test skills data structure validation
|
|
*/
|
|
function testSkillsStructure() {
|
|
console.log('\n⚔️ Testing Skills Structure...\n');
|
|
|
|
const jsonRegex = /```(?:json)?\s*([\s\S]*?)```/i;
|
|
const match = sampleValidJSONResponse.match(jsonRegex);
|
|
const data = JSON.parse(match[1].trim());
|
|
|
|
const skills = data.skills;
|
|
|
|
// Test skill categories
|
|
assert(typeof skills === 'object', 'skills should be an object');
|
|
assert(skills.combat !== undefined, 'skills should have combat category');
|
|
assert(Array.isArray(skills.combat), 'skill categories should be arrays');
|
|
|
|
// Test ability structure
|
|
const ability = skills.combat[0];
|
|
assert(ability.name !== undefined, 'Abilities should have name');
|
|
assert(ability.description !== undefined, 'Abilities should have description');
|
|
|
|
// Test linked item
|
|
assert(ability.linkedItem === 'Iron Sword', 'First combat ability should be linked to Iron Sword');
|
|
assert(skills.combat[1].linkedItem === undefined || skills.combat[1].linkedItem === null,
|
|
'Second combat ability should not have linkedItem');
|
|
}
|
|
|
|
/**
|
|
* Test quests data structure
|
|
*/
|
|
function testQuestsStructure() {
|
|
console.log('\n📜 Testing Quests Structure...\n');
|
|
|
|
const jsonRegex = /```(?:json)?\s*([\s\S]*?)```/i;
|
|
const match = sampleValidJSONResponse.match(jsonRegex);
|
|
const data = JSON.parse(match[1].trim());
|
|
|
|
const quests = data.quests;
|
|
|
|
assert(typeof quests.main === 'string', 'main quest should be a string');
|
|
assert(Array.isArray(quests.optional), 'optional quests should be an array');
|
|
assert(quests.optional.length === 2, 'Should have 2 optional quests');
|
|
}
|
|
|
|
/**
|
|
* Test characters data structure
|
|
*/
|
|
function testCharactersStructure() {
|
|
console.log('\n👥 Testing Characters Structure...\n');
|
|
|
|
const jsonRegex = /```(?:json)?\s*([\s\S]*?)```/i;
|
|
const match = sampleValidJSONResponse.match(jsonRegex);
|
|
const data = JSON.parse(match[1].trim());
|
|
|
|
const chars = data.presentCharacters;
|
|
|
|
assert(Array.isArray(chars), 'presentCharacters should be an array');
|
|
assert(chars.length > 0, 'Should have at least one character');
|
|
|
|
const char = chars[0];
|
|
assert(char.name === 'Elena', 'Character should have name');
|
|
assert(char.description !== undefined, 'Character should have description');
|
|
assert(char.emoji !== undefined, 'Character should have emoji');
|
|
assert(char.relationship !== undefined, 'Character should have relationship');
|
|
assert(char.stats !== undefined, 'Character should have stats');
|
|
assert(char.thoughts !== undefined, 'Character should have thoughts');
|
|
}
|
|
|
|
/**
|
|
* Test info box data structure
|
|
*/
|
|
function testInfoBoxStructure() {
|
|
console.log('\n📍 Testing Info Box Structure...\n');
|
|
|
|
const jsonRegex = /```(?:json)?\s*([\s\S]*?)```/i;
|
|
const match = sampleValidJSONResponse.match(jsonRegex);
|
|
const data = JSON.parse(match[1].trim());
|
|
|
|
const info = data.infoBox;
|
|
|
|
assert(typeof info.date === 'string', 'date should be a string');
|
|
assert(typeof info.weather === 'string', 'weather should be a string');
|
|
assert(typeof info.temperature === 'string', 'temperature should be a string');
|
|
assert(typeof info.time === 'string', 'time should be a string');
|
|
assert(typeof info.location === 'string', 'location should be a string');
|
|
assert(Array.isArray(info.recentEvents), 'recentEvents should be an array');
|
|
}
|
|
|
|
/**
|
|
* Test JSON prompt schema generation (mock)
|
|
*/
|
|
function testPromptSchemaGeneration() {
|
|
console.log('\n📝 Testing Prompt Schema Generation...\n');
|
|
|
|
// This tests the expected schema structure that generateJSONTrackerInstructions should produce
|
|
const expectedSchemaProperties = [
|
|
'userStats',
|
|
'skills',
|
|
'inventory',
|
|
'quests',
|
|
'infoBox',
|
|
'presentCharacters'
|
|
];
|
|
|
|
// Mock schema generation based on config
|
|
const schema = {
|
|
type: 'object',
|
|
properties: {}
|
|
};
|
|
|
|
// User stats
|
|
if (mockTrackerConfig.userStats) {
|
|
schema.properties.userStats = { type: 'object', properties: {} };
|
|
|
|
// Custom stats
|
|
mockTrackerConfig.userStats.customStats.forEach(stat => {
|
|
if (stat.enabled) {
|
|
schema.properties.userStats.properties[stat.id] = {
|
|
type: 'integer',
|
|
minimum: 0,
|
|
maximum: 100
|
|
};
|
|
}
|
|
});
|
|
|
|
// RPG attributes
|
|
if (mockTrackerConfig.userStats.showRPGAttributes) {
|
|
mockTrackerConfig.userStats.rpgAttributes.forEach(attr => {
|
|
if (attr.enabled) {
|
|
schema.properties.userStats.properties[attr.id] = {
|
|
type: 'integer',
|
|
minimum: 1
|
|
};
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
// Skills
|
|
if (mockTrackerConfig.userStats.skillsSection?.enabled) {
|
|
schema.properties.skills = { type: 'object', properties: {} };
|
|
mockTrackerConfig.userStats.skillsSection.customFields.forEach(field => {
|
|
const fieldId = field.toLowerCase();
|
|
schema.properties.skills.properties[fieldId] = {
|
|
type: 'array',
|
|
items: {
|
|
type: 'object',
|
|
properties: {
|
|
name: { type: 'string' },
|
|
description: { type: 'string' },
|
|
linkedItem: { type: 'string', nullable: true }
|
|
}
|
|
}
|
|
};
|
|
});
|
|
}
|
|
|
|
// Inventory
|
|
schema.properties.inventory = {
|
|
type: 'object',
|
|
properties: {
|
|
onPerson: { type: 'array' },
|
|
stored: { type: 'object' },
|
|
assets: { type: 'array' }
|
|
}
|
|
};
|
|
|
|
// Validate schema structure
|
|
assert(schema.properties.userStats !== undefined, 'Schema should include userStats');
|
|
assert(schema.properties.userStats.properties.health !== undefined, 'Schema should include health stat');
|
|
assert(schema.properties.skills !== undefined, 'Schema should include skills');
|
|
assert(schema.properties.skills.properties.combat !== undefined, 'Schema should include combat skill');
|
|
assert(schema.properties.inventory !== undefined, 'Schema should include inventory');
|
|
|
|
console.log('Generated schema structure:', JSON.stringify(schema, null, 2).substring(0, 500) + '...');
|
|
}
|
|
|
|
/**
|
|
* Run all tests
|
|
*/
|
|
function runAllTests() {
|
|
console.log('🧪 RPG Companion JSON Format Tests\n');
|
|
console.log('='.repeat(50));
|
|
|
|
try {
|
|
testJSONExtraction();
|
|
testInventoryStructure();
|
|
testSkillsStructure();
|
|
testQuestsStructure();
|
|
testCharactersStructure();
|
|
testInfoBoxStructure();
|
|
testPromptSchemaGeneration();
|
|
} catch (e) {
|
|
console.error('💥 Test suite error:', e);
|
|
testResults.failed++;
|
|
testResults.errors.push(e.message);
|
|
}
|
|
|
|
console.log('\n' + '='.repeat(50));
|
|
console.log(`\n📊 Results: ${testResults.passed} passed, ${testResults.failed} failed`);
|
|
|
|
if (testResults.errors.length > 0) {
|
|
console.log('\n❌ Failed tests:');
|
|
testResults.errors.forEach(err => console.log(` - ${err}`));
|
|
}
|
|
|
|
return testResults;
|
|
}
|
|
|
|
// Export for module usage
|
|
if (typeof module !== 'undefined' && module.exports) {
|
|
module.exports = {
|
|
runAllTests,
|
|
sampleValidJSONResponse,
|
|
sampleMalformedJSONResponse,
|
|
sampleSimplifiedInventoryResponse,
|
|
mockTrackerConfig
|
|
};
|
|
}
|
|
|
|
// Auto-run if executed directly
|
|
if (!isBrowser || (isBrowser && window.RPG_RUN_TESTS)) {
|
|
runAllTests();
|
|
}
|
|
|