sfcc-dev-mcp 1.0.19 → 1.0.21

package/tests/mcp/node/get-available-sfra-documents.programmatic.test.js

@@ -1,274 +0,0 @@
-import { test, describe, before, after, beforeEach } from 'node:test';
-import { strict as assert } from 'node:assert';
-import { connect } from 'mcp-aegis';
-
-/**
- * Programmatic tests for the MCP tool: get_available_sfra_documents
- * Mirrors YAML tests but adds deeper JSON parsing & resilience checks.
- *
- * Validates:
- * 1. Tool is registered
- * 2. Basic successful invocation returns non-empty array JSON string
- * 3. JSON parse yields objects with required keys (id, name, category, filename)
- * 4. Category coverage (expects at least: core, product, order, customer, pricing, store, other)
- * 5. Extraneous argument tolerance (should ignore unexpected params)
- * 6. Negative invalid method error path via raw JSON-RPC call
- */
-
-describe('get_available_sfra_documents (programmatic)', () => {
-  let client;
-  const CONFIG = './aegis.config.docs-only.json';
-
-  before(async () => {
-    client = await connect(CONFIG);
-  });
-
-  after(async () => {
-    if (client?.connected) await client.disconnect();
-  });
-
-  beforeEach(() => {
-    client.clearAllBuffers(); // Recommended - comprehensive protection
-  });
-
-  const TOOL_NAME = 'get_available_sfra_documents';
-  const REQUIRED_CATEGORIES = ['core', 'product', 'order', 'customer', 'pricing', 'store', 'other'];
-  // Actual response objects do NOT include an explicit 'id' field; we validate name/category/filename
-  const REQUIRED_KEYS = ['name', 'category', 'filename'];
-
-  test('tool should be registered', async () => {
-    const tools = await client.listTools();
-    const names = tools.map(t => t.name);
-    assert.ok(names.includes(TOOL_NAME), 'Tool not found in listTools');
-  });
-
-  async function invoke(extraArgs = {}) {
-    const result = await client.callTool(TOOL_NAME, { ...extraArgs });
-    assert.equal(result.isError, false, 'Tool invocation should not be error');
-    assert.ok(result.content && Array.isArray(result.content) && result.content.length > 0, 'Content array expected');
-    const textBlocks = result.content.filter(c => c.type === 'text');
-    assert.ok(textBlocks.length > 0, 'At least one text block expected');
-    const raw = textBlocks.map(t => t.text).join('\n');
-    return { raw, result };
-  }
-
-  function safeParseDocuments(raw) {
-    let docs;
-    try {
-      docs = JSON.parse(raw);
-  } catch {
-      // Attempt to extract JSON array via regex fallback if wrapping noise present
-      const match = raw.match(/\[[\s\S]*\]/);
-      assert.ok(match, 'Could not locate JSON array in content');
-      docs = JSON.parse(match[0]);
-    }
-    assert.ok(Array.isArray(docs), 'Parsed docs should be array');
-    assert.ok(docs.length >= 15, 'Expect at least 15 SFRA documents');
-    return docs;
-  }
-
-  test('basic invocation returns valid JSON array with required keys', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw);
-    // Validate keys & reasonable string values
-    for (const d of docs.slice(0, 25)) { // sample first 25 to keep runtime low
-      for (const key of REQUIRED_KEYS) {
-        assert.ok(Object.prototype.hasOwnProperty.call(d, key), `Missing key ${key}`);
-        assert.equal(typeof d[key], 'string', `${key} should be string`);
-        assert.ok(d[key].length > 0, `${key} should be non-empty`);
-      }
-    }
-  });
-
-  test('category coverage present', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw);
-    const categories = new Set(docs.map(d => d.category));
-    for (const c of REQUIRED_CATEGORIES) {
-      assert.ok(categories.has(c), `Expected category ${c}`);
-    }
-  });
-
-  test('extraneous argument is ignored', async () => {
-    const { raw } = await invoke({ unused: 'value' });
-    const docs = safeParseDocuments(raw);
-    assert.ok(docs.length >= 15, 'At least 15 docs expected with extraneous argument');
-  });
-
-  test('multiple product-* occurrences and filename pattern sanity', async () => {
-    const { raw } = await invoke();
-    assert.match(raw, /(product-).*(product-).*(product-)/s, 'Expect at least three product- occurrences');
-  assert.match(raw, /"filename"\s*:\s*"[a-z0-9-]+\.md"/, 'Expect filename .md entries');
-  });
-
-  test('negative path: invalid method should return JSON-RPC error', async () => {
-    // Raw JSON-RPC send with invalid method name returns error response (not throw)
-    const response = await client.sendMessage({
-      jsonrpc: '2.0',
-      id: 'bad-method-1',
-      method: 'tools/call_WRONG',
-      params: { name: TOOL_NAME, arguments: {} }
-    });
-    assert.ok(response.error, 'Expected JSON-RPC error object');
-    assert.match(response.error.message || '', /method/i, 'Error message should mention method');
-  });
-
-  test('argument validation error path (null arguments object)', async () => {
-    let caught = null;
-    try {
-      await client.callTool(TOOL_NAME, null);
-    } catch (err) {
-      caught = err;
-    }
-    assert.ok(caught, 'Expected callTool to reject with invalid_type');
-    assert.match(caught.message, /invalid_type|Expected object/i, 'Error should mention invalid type');
-  });
-
-  test('filenames unique and kebab-case', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw);
-    const filenames = docs.map(d => d.filename);
-    const fileSet = new Set(filenames);
-    assert.equal(fileSet.size, filenames.length, 'Filenames must be unique');
-    for (const f of filenames.slice(0, 50)) {
-      assert.match(f, /^[a-z0-9-]+\.md$/, 'filename should be kebab-case .md');
-    }
-  });
-
-  test('filename semantic correlation with name (first token appears in name)', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw);
-    for (const d of docs.slice(0, 40)) {
-      assert.match(d.filename, /^[a-z0-9-]+\.md$/, 'filename must be kebab-case .md');
-      const firstSegment = d.filename.replace(/\.md$/, '').split('-')[0];
-      assert.ok(d.name.toLowerCase().includes(firstSegment), 'name should contain filename first segment');
-    }
-  });
-
-  test('category distribution sanity (no category monopolizes >70%)', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw);
-    const counts = docs.reduce((acc, d) => { acc[d.category] = (acc[d.category]||0)+1; return acc; }, {});
-    const total = docs.length;
-    for (const [cat, cnt] of Object.entries(counts)) {
-      assert.ok(cnt / total <= 0.7, `Category ${cat} dominates with ${(cnt/total*100).toFixed(1)}%`);
-    }
-  });
-
-  test('deterministic ordering (two calls produce identical first 10 IDs)', async () => {
-    const first = safeParseDocuments((await invoke()).raw).slice(0,10).map(d=>d.id);
-    const second = safeParseDocuments((await invoke()).raw).slice(0,10).map(d=>d.id);
-    assert.deepEqual(second, first, 'First 10 IDs should be stable across calls');
-  });
-
-  test('sample documents contain expected semantic keywords', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw);
-    const textBlob = JSON.stringify(docs.slice(0, 30)).toLowerCase();
-    const expected = ['server', 'request', 'response', 'product', 'price', 'cart'];
-    for (const token of expected) {
-      assert.ok(textBlob.includes(token), `Expected token ${token} in first 30 docs blob`);
-    }
-  });
-
-  test('no empty or placeholder names', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw);
-    for (const d of docs) {
-      assert.ok(d.name.trim().length > 2, 'name should be >2 chars');
-      assert.ok(!/^(todo|tbd|placeholder)$/i.test(d.name), 'name should not be placeholder');
-    }
-  });
-
-  test('round-trip JSON parse reproducibility (stringify->parse equality for first 5)', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw).slice(0,5);
-    const roundTrip = JSON.parse(JSON.stringify(docs));
-    assert.deepEqual(roundTrip, docs, 'Round trip serialization must preserve first 5 docs');
-  });
-
-  test('at least one document per required category and each category has <= 50% of docs', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw);
-    const counts = docs.reduce((acc, d) => { acc[d.category] = (acc[d.category]||0)+1; return acc; }, {});
-    const total = docs.length;
-    for (const c of REQUIRED_CATEGORIES) {
-      assert.ok(counts[c] > 0, `Category ${c} missing`);
-      assert.ok((counts[c] / total) <= 0.5, `Category ${c} exceeds 50% threshold`);
-    }
-  });
-
-  test('filename/id pairing uniqueness (no duplicate filename)', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw);
-    const filenames = docs.map(d => d.filename);
-    const fileSet = new Set(filenames);
-    assert.equal(fileSet.size, filenames.length, 'Filenames must be unique');
-  });
-
-  test('sorted by name alpha? (non-fatal heuristic) warn if not mostly sorted', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw).slice(0,30);
-    const names = docs.map(d=>d.name.toLowerCase());
-    const sorted = [...names].sort();
-    let outOfOrder = 0;
-    names.forEach((n,i)=>{ if(n!==sorted[i]) outOfOrder++; });
-    if (outOfOrder > Math.ceil(names.length * 0.4)) {
-      console.warn(`Heuristic: more than 40% (${outOfOrder}/${names.length}) of first 30 names out of alpha order`);
-    }
-  });
-
-  // Removed category/id correlation test (no id field in response)
-
-  // Removed id/filename prefix correlation (id not present)
-
-  test('document count stable across two invocations (delta <= 2)', async () => {
-    const firstLen = safeParseDocuments((await invoke()).raw).length;
-    const secondLen = safeParseDocuments((await invoke()).raw).length;
-    const delta = Math.abs(firstLen - secondLen);
-    assert.ok(delta <= 2, `Doc count changed unexpectedly by ${delta}`);
-  });
-
-  test('category histogram logged for diagnostic insight (non-asserting)', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw);
-    const counts = docs.reduce((acc, d) => { acc[d.category] = (acc[d.category]||0)+1; return acc; }, {});
-    console.info('SFRA docs category histogram:', counts);
-  });
-
-  test('ensure presence of canonical core documents', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw);
-    const names = docs.map(d=>d.name.toLowerCase());
-    const required = ['server', 'request', 'response', 'querystring', 'render'];
-    for (const r of required) {
-      assert.ok(names.some(n=>n.includes(r)), `Missing canonical core doc: ${r}`);
-    }
-  });
-
-  test('ensure presence of key product/order/customer domain docs', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw);
-    const blob = JSON.stringify(docs).toLowerCase();
-    const expected = ['product', 'cart', 'shipping', 'billing', 'account', 'customer', 'price'];
-    for (const token of expected) {
-      assert.ok(blob.includes(token), `Missing expected domain token: ${token}`);
-    }
-  });
-
-  test('no obvious placeholder filenames', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw);
-    for (const d of docs) {
-      assert.ok(!/(placeholder|temp|dummy)/i.test(d.filename), 'Filename should not look placeholder');
-    }
-  });
-
-  test('filename extension enforcement (.md only)', async () => {
-    const { raw } = await invoke();
-    const docs = safeParseDocuments(raw);
-    for (const d of docs) {
-      assert.ok(d.filename.endsWith('.md'), 'All filenames must end with .md');
-    }
-  });
-});

package/tests/mcp/node/get-isml-categories.programmatic.test.js

@@ -1,278 +0,0 @@
-/**
- * Programmatic tests for the MCP tool: get_isml_categories
- * Mirrors YAML tests but adds deeper JSON parsing & resilience checks.
- *
- * Validates:
- * 1. Tool is registered
- * 2. Basic successful invocation returns non-empty array JSON string
- * 3. JSON parse yields objects with required keys (name, displayName, description, elementCount)
- * 4. All expected categories present (analytics, cache, control-flow, decorators, includes, output, payment, scripting, special)
- * 5. Element count accuracy and reasonableness
- * 6. Extraneous argument tolerance
- * 7. Negative error paths
- * 8. Response stability and determinism
- */
-
-import { test, describe, before, after, beforeEach } from 'node:test';
-import { strict as assert } from 'node:assert';
-import { connect } from 'mcp-aegis';
-
-describe('get_isml_categories (programmatic)', () => {
-  let client;
-  const CONFIG = './aegis.config.docs-only.json';
-
-  before(async () => {
-    client = await connect(CONFIG);
-  });
-
-  after(async () => {
-    if (client?.connected) {
-      await client.disconnect();
-    }
-  });
-
-  beforeEach(() => {
-    client.clearAllBuffers();
-  });
-
-  const TOOL_NAME = 'get_isml_categories';
-  const REQUIRED_KEYS = ['name', 'displayName', 'description', 'count'];
-  const EXPECTED_CATEGORIES = [
-    'analytics',
-    'cache',
-    'control-flow',
-    'decorators',
-    'includes',
-    'output',
-    'payment',
-    'scripting',
-    'special'
-  ];
-
-  test('tool should be registered', async () => {
-    const tools = await client.listTools();
-    const names = tools.map(t => t.name);
-    assert.ok(names.includes(TOOL_NAME), 'Tool not found in listTools');
-  });
-
-  async function invoke(extraArgs = {}) {
-    const result = await client.callTool(TOOL_NAME, { ...extraArgs });
-    assert.equal(result.isError, false, 'Tool invocation should not be error');
-    assert.ok(result.content && Array.isArray(result.content) && result.content.length > 0, 'Content array expected');
-    const textBlocks = result.content.filter(c => c.type === 'text');
-    assert.ok(textBlocks.length > 0, 'At least one text block expected');
-    const raw = textBlocks.map(t => t.text).join('\n');
-    return { raw, result };
-  }
-
-  function safeParseCategories(raw) {
-    let categories;
-    try {
-      categories = JSON.parse(raw);
-    } catch (err) {
-      assert.fail(`Failed to parse response as JSON: ${err.message}\nRaw: ${raw.substring(0, 500)}`);
-    }
-    assert.ok(Array.isArray(categories), 'Parsed categories should be array');
-    assert.equal(categories.length, EXPECTED_CATEGORIES.length, `Should have exactly ${EXPECTED_CATEGORIES.length} categories`);
-    return categories;
-  }
-
-  test('basic invocation returns valid JSON array with required keys', async () => {
-    const { raw } = await invoke();
-    const categories = safeParseCategories(raw);
-    
-    for (const cat of categories) {
-      for (const key of REQUIRED_KEYS) {
-        assert.ok(Object.prototype.hasOwnProperty.call(cat, key), `Category should have ${key}: ${JSON.stringify(cat)}`);
-        if (key === 'count') {
-          assert.ok(typeof cat[key] === 'number', `${key} should be number`);
-          assert.ok(cat[key] > 0, `${key} should be positive`);
-        } else {
-          assert.ok(typeof cat[key] === 'string', `${key} should be string`);
-          assert.ok(cat[key].length > 0, `${key} should be non-empty string`);
-        }
-      }
-    }
-  });
-
-  test('all expected categories present', async () => {
-    const { raw } = await invoke();
-    const categories = safeParseCategories(raw);
-    const categoryNames = new Set(categories.map(cat => cat.name));
-    
-    for (const expected of EXPECTED_CATEGORIES) {
-      assert.ok(categoryNames.has(expected), `Expected category ${expected} not found`);
-    }
-  });
-
-  test('no unexpected categories', async () => {
-    const { raw } = await invoke();
-    const categories = safeParseCategories(raw);
-    const categoryNames = categories.map(cat => cat.name);
-    
-    for (const name of categoryNames) {
-      assert.ok(EXPECTED_CATEGORIES.includes(name), `Unexpected category found: ${name}`);
-    }
-  });
-
-  test('category name uniqueness', async () => {
-    const { raw } = await invoke();
-    const categories = safeParseCategories(raw);
-    const names = categories.map(cat => cat.name);
-    const nameSet = new Set(names);
-    assert.equal(nameSet.size, names.length, 'Category names must be unique');
-  });
-
-  test('element count total reasonableness (expect 25-40 total elements)', async () => {
-    const { raw } = await invoke();
-    const categories = safeParseCategories(raw);
-    const totalElements = categories.reduce((sum, cat) => sum + cat.count, 0);
-    assert.ok(totalElements >= 25, `Total element count too low: ${totalElements}`);
-    assert.ok(totalElements <= 40, `Total element count too high: ${totalElements}`);
-  });
-
-  test('control-flow category has expected element count', async () => {
-    const { raw } = await invoke();
-    const categories = safeParseCategories(raw);
-    const controlFlow = categories.find(cat => cat.name === 'control-flow');
-    assert.ok(controlFlow, 'control-flow category should exist');
-    assert.ok(controlFlow.count >= 5, `control-flow should have at least 5 elements, got ${controlFlow.count}`);
-  });
-
-  test('extraneous argument is ignored', async () => {
-    const { raw } = await invoke({ unused: 'value', extra: 123 });
-    const categories = safeParseCategories(raw);
-    assert.equal(categories.length, EXPECTED_CATEGORIES.length, 'Should return same number of categories with extraneous args');
-  });
-
-  test('deterministic ordering (two calls produce identical category order)', async () => {
-    const first = safeParseCategories((await invoke()).raw).map(cat => cat.name);
-    const second = safeParseCategories((await invoke()).raw).map(cat => cat.name);
-    assert.deepEqual(second, first, 'Category order should be stable across calls');
-  });
-
-  test('displayName formatting quality (capitalized, reasonable length)', async () => {
-    const { raw } = await invoke();
-    const categories = safeParseCategories(raw);
-    
-    for (const cat of categories) {
-      assert.ok(cat.displayName.length >= 4, `displayName too short: ${cat.displayName}`);
-      assert.ok(cat.displayName.length <= 30, `displayName too long: ${cat.displayName}`);
-      // Should start with capital letter
-      assert.match(cat.displayName, /^[A-Z]/, `displayName should start with capital: ${cat.displayName}`);
-    }
-  });
-
-  test('description quality (reasonable length 30-150 chars)', async () => {
-    const { raw } = await invoke();
-    const categories = safeParseCategories(raw);
-    
-    for (const cat of categories) {
-      assert.ok(cat.description.length >= 30, `Description too short for ${cat.name}: ${cat.description.length} chars`);
-      assert.ok(cat.description.length <= 150, `Description too long for ${cat.name}: ${cat.description.length} chars`);
-    }
-  });
-
-  test('name format (kebab-case)', async () => {
-    const { raw } = await invoke();
-    const categories = safeParseCategories(raw);
-    
-    for (const cat of categories) {
-      assert.match(cat.name, /^[a-z]+(-[a-z]+)*$/, `Category name should be kebab-case: ${cat.name}`);
-    }
-  });
-
-  test('round-trip JSON parse reproducibility', async () => {
-    const { raw } = await invoke();
-    const categories = safeParseCategories(raw);
-    const roundTrip = JSON.parse(JSON.stringify(categories));
-    assert.deepEqual(roundTrip, categories, 'Round trip serialization must preserve categories');
-  });
-
-  test('no empty or placeholder names/descriptions', async () => {
-    const { raw } = await invoke();
-    const categories = safeParseCategories(raw);
-    
-    for (const cat of categories) {
-      assert.ok(cat.name && cat.name.trim().length > 0, 'Name should not be empty');
-      assert.ok(cat.displayName && cat.displayName.trim().length > 0, 'DisplayName should not be empty');
-      assert.ok(cat.description && cat.description.trim().length > 0, 'Description should not be empty');
-      assert.ok(!cat.name.toLowerCase().includes('placeholder'), `Name should not be placeholder: ${cat.name}`);
-      assert.ok(!cat.description.toLowerCase().includes('todo'), `Description should not be TODO: ${cat.description}`);
-    }
-  });
-
-  test('category count stable across two invocations', async () => {
-    const firstLen = safeParseCategories((await invoke()).raw).length;
-    const secondLen = safeParseCategories((await invoke()).raw).length;
-    assert.equal(secondLen, firstLen, 'Category count should be identical across calls');
-  });
-
-  test('element count histogram logged for diagnostic insight (non-asserting)', async () => {
-    const { raw } = await invoke();
-    const categories = safeParseCategories(raw);
-    const histogram = categories.reduce((acc, cat) => {
-      acc[cat.name] = cat.count;
-      return acc;
-    }, {});
-    console.log('Element Count by Category:', histogram);
-  });
-
-  test('negative path: invalid method should return JSON-RPC error', async () => {
-    const response = await client.sendMessage({
-      jsonrpc: '2.0',
-      id: 'bad-method-1',
-      method: 'tools/call_WRONG',
-      params: { name: TOOL_NAME, arguments: {} }
-    });
-    assert.ok(response.error, 'Expected JSON-RPC error object');
-    assert.match(response.error.message || '', /method/i, 'Error message should mention method');
-  });
-
-  test('performance: response time under 500ms', async () => {
-    const start = Date.now();
-    await invoke();
-    const duration = Date.now() - start;
-    assert.ok(duration < 500, `Response should be under 500ms, got ${duration}ms`);
-  });
-
-  test('alphabetical name sorting verification', async () => {
-    const { raw } = await invoke();
-    const categories = safeParseCategories(raw);
-    const names = categories.map(cat => cat.name);
-    const sorted = [...names].sort();
-    assert.deepEqual(names, sorted, 'Category names should be alphabetically sorted');
-  });
-
-  test('element count consistency with list_isml_elements tool', async () => {
-    // Get categories
-    const { raw: catRaw } = await invoke();
-    const categories = safeParseCategories(catRaw);
-    const totalByCat = categories.reduce((sum, cat) => sum + cat.count, 0);
-    
-    // Get elements
-    const elemResult = await client.callTool('list_isml_elements', {});
-    const elemRaw = elemResult.content[0].text;
-    const elements = JSON.parse(elemRaw);
-    
-    // Counts should match
-    assert.equal(elements.length, totalByCat, 'Total element count should match sum of category counts');
-  });
-
-  test('each category name matches elements in list_isml_elements', async () => {
-    // Get categories
-    const { raw: catRaw } = await invoke();
-    const categories = safeParseCategories(catRaw);
-    
-    // Get elements
-    const elemResult = await client.callTool('list_isml_elements', {});
-    const elemRaw = elemResult.content[0].text;
-    const elements = JSON.parse(elemRaw);
-    const elementCategories = new Set(elements.map(el => el.category));
-    
-    // All categories should be represented in elements
-    for (const cat of categories) {
-      assert.ok(elementCategories.has(cat.name), `Category ${cat.name} should have elements in list_isml_elements`);
-    }
-  });
-});