sfcc-dev-mcp 1.0.19 → 1.0.21

package/tests/mcp/node/search-isml-elements.programmatic.test.js

@@ -1,325 +0,0 @@
-/**
- * Programmatic tests for the MCP tool: search_isml_elements
- * Mirrors YAML tests but adds deeper JSON parsing & resilience checks.
- *
- * Validates:
- * 1. Tool is registered
- * 2. Successful search with various queries (loop, format, cache, condition)
- * 3. Search result structure (element, relevance, matchedSections, preview)
- * 4. Category filtering
- * 5. Result limit enforcement
- * 6. Relevance scoring
- * 7. Empty result handling
- * 8. Error handling for missing parameters
- * 9. Preview quality and content
- */
-
-import { test, describe, before, after, beforeEach } from 'node:test';
-import { strict as assert } from 'node:assert';
-import { connect } from 'mcp-aegis';
-
-describe('search_isml_elements (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 = 'search_isml_elements';
-  const RESULT_KEYS = ['document', 'relevance', 'matchedSections', 'preview'];
-  const ELEMENT_KEYS = ['name', 'title', 'description', '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(query, options = {}) {
-    const result = await client.callTool(TOOL_NAME, { query, ...options });
-    return { result, raw: result.content[0]?.text };
-  }
-
-  function safeParseResults(raw) {
-    let results;
-    try {
-      results = JSON.parse(raw);
-    } catch (err) {
-      assert.fail(`Failed to parse response as JSON: ${err.message}\nRaw: ${raw.substring(0, 500)}`);
-    }
-    assert.ok(Array.isArray(results), 'Parsed results should be array');
-    return results;
-  }
-
-  test('search for loop-related elements', async () => {
-    const { result, raw } = await invoke('loop');
-    assert.equal(result.isError, false, 'Should not be error');
-    
-    const results = safeParseResults(raw);
-    assert.ok(results.length > 0, 'Should find loop-related elements');
-    
-    // Check if isloop is in results
-    const elementNames = results.map(r => r.document.name);
-    assert.ok(elementNames.includes('isloop'), 'Should include isloop element');
-  });
-
-  test('search for formatting elements', async () => {
-    const { result, raw } = await invoke('format');
-    assert.equal(result.isError, false, 'Should not be error');
-    
-    const results = safeParseResults(raw);
-    assert.ok(results.length > 0, 'Should find formatting-related elements');
-    
-    const elementNames = results.map(r => r.document.name);
-    assert.ok(elementNames.includes('isprint'), 'Should include isprint element');
-  });
-
-  test('search for cache elements', async () => {
-    const { result, raw } = await invoke('cache');
-    assert.equal(result.isError, false, 'Should not be error');
-    
-    const results = safeParseResults(raw);
-    assert.ok(results.length > 0, 'Should find cache-related elements');
-    
-    const elementNames = results.map(r => r.document.name);
-    assert.ok(elementNames.includes('iscache'), 'Should include iscache element');
-  });
-
-  test('search for conditional elements', async () => {
-    const { result, raw } = await invoke('condition');
-    assert.equal(result.isError, false, 'Should not be error');
-    
-    const results = safeParseResults(raw);
-    assert.ok(results.length > 0, 'Should find conditional-related elements');
-    
-    const elementNames = results.map(r => r.document.name);
-    assert.ok(elementNames.includes('isif'), 'Should include isif element');
-  });
-
-  test('search result structure validation', async () => {
-    const { raw } = await invoke('loop');
-    const results = safeParseResults(raw);
-    
-    for (const searchResult of results.slice(0, 5)) {
-      // Check top-level keys
-      for (const key of RESULT_KEYS) {
-        assert.ok(Object.prototype.hasOwnProperty.call(searchResult, key), `Result should have ${key}`);
-      }
-      
-      // Check document structure
-      for (const key of ELEMENT_KEYS) {
-        assert.ok(Object.prototype.hasOwnProperty.call(searchResult.document, key), `Document should have ${key}`);
-      }
-      
-      // Check types
-      assert.ok(typeof searchResult.relevance === 'number', 'Relevance should be number');
-      assert.ok(Array.isArray(searchResult.matchedSections), 'matchedSections should be array');
-      assert.ok(typeof searchResult.preview === 'string', 'Preview should be string');
-    }
-  });
-
-  test('relevance scoring is present and positive', async () => {
-    const { raw } = await invoke('loop');
-    const results = safeParseResults(raw);
-    
-    for (const result of results) {
-      assert.ok(result.relevance > 0, `Relevance should be positive, got ${result.relevance}`);
-    }
-  });
-
-  test('results sorted by relevance (descending)', async () => {
-    const { raw } = await invoke('loop');
-    const results = safeParseResults(raw);
-    
-    if (results.length > 1) {
-      const relevances = results.map(r => r.relevance);
-      for (let i = 0; i < relevances.length - 1; i++) {
-        assert.ok(relevances[i] >= relevances[i + 1], `Results should be sorted by relevance descending`);
-      }
-    }
-  });
-
-  test('filter search by category', async () => {
-    const { result, raw } = await invoke('condition', { category: 'control-flow' });
-    assert.equal(result.isError, false, 'Should not be error');
-    
-    const results = safeParseResults(raw);
-    assert.ok(results.length > 0, 'Should find elements in control-flow category');
-    
-    // All results should be control-flow category
-    for (const searchResult of results) {
-      assert.equal(searchResult.document.category, 'control-flow', 'All results should be control-flow category');
-    }
-  });
-
-  test('respect limit parameter', async () => {
-    const { result, raw } = await invoke('element', { limit: 5 });
-    assert.equal(result.isError, false, 'Should not be error');
-    
-    const results = safeParseResults(raw);
-    assert.ok(results.length <= 5, `Should respect limit of 5, got ${results.length}`);
-  });
-
-  test('preview snippets are present and reasonable', async () => {
-    const { raw } = await invoke('loop');
-    const results = safeParseResults(raw);
-    
-    for (const searchResult of results.slice(0, 5)) {
-      assert.ok(searchResult.preview.length >= 50, `Preview should be at least 50 chars, got ${searchResult.preview.length}`);
-      assert.ok(searchResult.preview.length <= 300, `Preview should be at most 300 chars, got ${searchResult.preview.length}`);
-    }
-  });
-
-  test('matchedSections array structure', async () => {
-    const { raw } = await invoke('loop');
-    const results = safeParseResults(raw);
-    
-    for (const searchResult of results) {
-      assert.ok(Array.isArray(searchResult.matchedSections), 'matchedSections should be array');
-      // Array may be empty or contain strings
-      if (searchResult.matchedSections.length > 0) {
-        assert.ok(searchResult.matchedSections.every(s => typeof s === 'string'), 'All matchedSections should be strings');
-      }
-    }
-  });
-
-  test('return empty array for no matches', async () => {
-    const { result, raw } = await invoke('zzznothingfound');
-    assert.equal(result.isError, false, 'Should not be error for no matches');
-    
-    const results = safeParseResults(raw);
-    assert.equal(results.length, 0, 'Should return empty array for no matches');
-  });
-
-  test('error for missing query parameter', async () => {
-    const result = await client.callTool(TOOL_NAME, {});
-    assert.equal(result.isError, true, 'Should be error for missing query');
-    assert.match(result.content[0].text, /query/i, 'Error should mention query');
-  });
-
-  test('case insensitive search', async () => {
-    const lowerResults = safeParseResults((await invoke('loop')).raw);
-    const upperResults = safeParseResults((await invoke('LOOP')).raw);
-    
-    assert.equal(upperResults.length, lowerResults.length, 'Case should not affect result count');
-  });
-
-  test('partial word matching', async () => {
-    const { raw } = await invoke('scri');
-    const results = safeParseResults(raw);
-    
-    const elementNames = results.map(r => r.document.name);
-    assert.ok(elementNames.includes('isscript'), 'Should find isscript with partial match');
-  });
-
-  test('search for scripting elements', async () => {
-    const { result, raw } = await invoke('script');
-    assert.equal(result.isError, false, 'Should not be error');
-    
-    const results = safeParseResults(raw);
-    const elementNames = results.map(r => r.document.name);
-    assert.ok(elementNames.includes('isscript'), 'Should include isscript');
-  });
-
-  test('multiple category filtering combinations', async () => {
-    const categories = ['control-flow', 'output', 'scripting'];
-    
-    for (const category of categories) {
-      const { result, raw } = await invoke('element', { category });
-      assert.equal(result.isError, false, `Should search in ${category} category`);
-      
-      const results = safeParseResults(raw);
-      if (results.length > 0) {
-        for (const searchResult of results) {
-          assert.equal(searchResult.document.category, category, `All results should be ${category} category`);
-        }
-      }
-    }
-  });
-
-  test('filename pattern in results', async () => {
-    const { raw } = await invoke('loop');
-    const results = safeParseResults(raw);
-    
-    for (const searchResult of results.slice(0, 5)) {
-      assert.match(searchResult.document.filename, /^[a-z0-9-]+\.md$/, 'Filename should be kebab-case .md');
-    }
-  });
-
-  test('round-trip JSON parse reproducibility', async () => {
-    const { raw } = await invoke('loop');
-    const results = safeParseResults(raw);
-    const roundTrip = JSON.parse(JSON.stringify(results));
-    assert.deepEqual(roundTrip, results, 'Round trip serialization must preserve results');
-  });
-
-  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: { query: 'loop' } }
-    });
-    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 1500ms', async () => {
-    const start = Date.now();
-    await invoke('loop');
-    const duration = Date.now() - start;
-    assert.ok(duration < 1500, `Response should be under 1500ms, got ${duration}ms`);
-  });
-
-  test('extraneous parameters are ignored', async () => {
-    const { result, raw } = await invoke('loop', { unused: 'value', extra: 123 });
-    assert.equal(result.isError, false, 'Should ignore extraneous params');
-    const results = safeParseResults(raw);
-    assert.ok(results.length > 0, 'Should still return results');
-  });
-
-  test('default limit behavior (should have reasonable max)', async () => {
-    const { raw } = await invoke('element');
-    const results = safeParseResults(raw);
-    
-    // Default limit should be reasonable (not thousands of results)
-    assert.ok(results.length <= 50, `Default limit should be reasonable, got ${results.length} results`);
-  });
-
-  test('query with special characters', async () => {
-    const { result } = await invoke('loop-test');
-    assert.equal(result.isError, false, 'Should handle special characters in query');
-  });
-
-  test('very short query (1 char)', async () => {
-    const { result } = await invoke('l');
-    assert.equal(result.isError, false, 'Should handle very short query');
-  });
-
-  test('very long query', async () => {
-    const longQuery = 'loop iteration control flow template rendering scripting';
-    const { result, raw } = await invoke(longQuery);
-    assert.equal(result.isError, false, 'Should handle long query');
-    const results = safeParseResults(raw);
-    assert.ok(results.length >= 0, 'Should return results for long query');
-  });
-
-  test('search result consistency across invocations', async () => {
-    const first = safeParseResults((await invoke('loop')).raw);
-    const second = safeParseResults((await invoke('loop')).raw);
-    
-    assert.equal(second.length, first.length, 'Result count should be consistent');
-    assert.deepEqual(second.map(r => r.document.name), first.map(r => r.document.name), 'Result order should be consistent');
-  });
-});

package/tests/mcp/node/search-job-logs-by-name.full-mode.programmatic.test.js

@@ -1,330 +0,0 @@
-import { test, describe, before, after, beforeEach } from 'node:test';
-import { strict as assert } from 'node:assert';
-import { connect } from 'mcp-aegis';
-
-describe('search_job_logs_by_name - Optimized Programmatic Tests', () => {
-  let client;
-  let discoveredJobNames = [];
-
-  before(async () => {
-    client = await connect('./aegis.config.with-dw.json');
-    
-    // Discover available job names for dynamic testing
-    await discoverJobNames();
-  });
-
-  after(async () => {
-    if (client?.connected) {
-      await client.disconnect();
-    }
-  });
-
-  beforeEach(() => {
-    // CRITICAL: Clear all buffers to prevent leaking into next tests
-    client.clearAllBuffers();
-  });
-
-  // Simplified helper functions focused on essential validation
-  function assertValidMCPResponse(result) {
-    assert.ok(result.content, 'Should have content');
-    assert.ok(Array.isArray(result.content), 'Content should be array');
-    assert.equal(typeof result.isError, 'boolean', 'isError should be boolean');
-  }
-
-  function parseResponseText(text) {
-    return text.startsWith('"') && text.endsWith('"') ? JSON.parse(text) : text;
-  }
-
-  function assertSuccessResponse(result) {
-    assertValidMCPResponse(result);
-    assert.equal(result.isError, false, 'Should not be an error response');
-    assert.equal(result.content[0].type, 'text');
-  }
-
-  function assertErrorResponse(result, expectedErrorText) {
-    assertValidMCPResponse(result);
-    assert.equal(result.isError, true, 'Should be an error response');
-    if (expectedErrorText) {
-      const text = parseResponseText(result.content[0].text);
-      assert.ok(text.includes(expectedErrorText), 
-        `Expected "${expectedErrorText}" in "${text}"`);
-    }
-  }
-
-  function assertJobSearchResults(result) {
-    assertSuccessResponse(result);
-    const text = parseResponseText(result.content[0].text);
-    
-    if (text.includes('No job logs found')) {
-      return 0; // Valid empty result
-    }
-    
-    // Extract count and validate basic structure
-    const countMatch = text.match(/Found (\d+) job logs:/);
-    assert.ok(countMatch, 'Should contain job count message');
-    
-    const actualCount = parseInt(countMatch[1]);
-    assert.ok(actualCount > 0, 'Should have positive count when jobs found');
-    
-    // Validate key components are present
-    assert.ok(text.includes('🔧 Job:'), 'Should contain job emoji');
-    assert.ok(text.includes('ID:'), 'Should contain job ID');
-    assert.ok(text.includes('File:'), 'Should contain file name');
-    assert.ok(text.includes('Modified:'), 'Should contain modification time');
-    assert.ok(text.includes('Size:'), 'Should contain file size');
-    
-    return actualCount;
-  }
-
-  async function discoverJobNames() {
-    try {
-      const result = await client.callTool('search_job_logs_by_name', { 
-        jobName: 'Import', // Use common search term to find jobs
-        limit: 5
-      });
-      
-      if (!result.isError && result.content?.[0]?.text) {
-        const text = parseResponseText(result.content[0].text);
-        if (!text.includes('No job logs found')) {
-          // Extract job names from the response
-          const jobMatches = text.match(/🔧 Job: ([A-Za-z0-9]+)/g) || [];
-          discoveredJobNames = [...new Set(jobMatches.map(match => 
-            match.replace('🔧 Job: ', '')))];
-        }
-      }
-    } catch (error) {
-      console.warn('Could not discover job names:', error.message);
-    }
-  }
-
-  // Core functionality tests
-  describe('Core Functionality', () => {
-    test('should search for job logs and return structured results', async () => {
-      const result = await client.callTool('search_job_logs_by_name', { 
-        jobName: 'Import' 
-      });
-      
-      const count = assertJobSearchResults(result);
-      
-      if (count > 0) {
-        const text = parseResponseText(result.content[0].text);
-        // Verify partial matching works (job names containing "Import")
-        const jobMatches = text.match(/🔧 Job: ([A-Za-z0-9]+)/g) || [];
-        const containsImport = jobMatches.some(match => 
-          match.toLowerCase().includes('import'));
-        assert.ok(containsImport, 'Should find jobs containing "Import"');
-      }
-    });
-
-    test('should respect limit parameter and handle various values', async () => {
-      const testCases = [
-        { limit: 1, desc: 'single result' },
-        { limit: 3, desc: 'multiple results' },
-        { limit: 1000, desc: 'large limit' }
-      ];
-      
-      for (const { limit, desc } of testCases) {
-        const result = await client.callTool('search_job_logs_by_name', { 
-          jobName: 'Import',
-          limit 
-        });
-        
-        assertSuccessResponse(result);
-        const text = parseResponseText(result.content[0].text);
-        
-        if (!text.includes('No job logs found')) {
-          const countMatch = text.match(/Found (\d+) job logs:/);
-          if (countMatch) {
-            const actualCount = parseInt(countMatch[1]);
-            assert.ok(actualCount <= limit, 
-              `${desc}: actual count ${actualCount} should not exceed limit ${limit}`);
-          }
-        }
-      }
-    });
-
-    test('should return no results for non-existent job name', async () => {
-      const result = await client.callTool('search_job_logs_by_name', { 
-        jobName: 'NonExistentJobXYZ123'
-      });
-      
-      assertSuccessResponse(result);
-      const text = parseResponseText(result.content[0].text);
-      assert.ok(text.includes('No job logs found'), 'Should indicate no results found');
-    });
-  });
-
-  // Parameter validation tests
-  describe('Parameter Validation', () => {
-    test('should reject empty job name', async () => {
-      const result = await client.callTool('search_job_logs_by_name', { 
-        jobName: '' 
-      });
-      
-      assertErrorResponse(result, 'jobName must be a non-empty string');
-    });
-
-    test('should reject missing jobName parameter', async () => {
-      const result = await client.callTool('search_job_logs_by_name', {});
-      
-      assertErrorResponse(result, 'jobName must be a non-empty string');
-    });
-
-    test('should handle invalid limit parameter', async () => {
-      const invalidLimits = [-1, 0, 'invalid'];
-      
-      for (const limit of invalidLimits) {
-        const result = await client.callTool('search_job_logs_by_name', { 
-          jobName: 'Import',
-          limit 
-        });
-        
-        assertErrorResponse(result); // Should be an error, don't need to check exact message
-      }
-    });
-  });
-
-  // Dynamic discovery tests
-  describe('Dynamic Discovery Tests', () => {
-    test('should handle discovered job names effectively', async () => {
-      if (discoveredJobNames.length === 0) {
-        console.log('⚠️ Skipping dynamic discovery test - no job names found');
-        return;
-      }
-
-      // Test with discovered job names
-      const testJobName = discoveredJobNames[0];
-      const result = await client.callTool('search_job_logs_by_name', { 
-        jobName: testJobName,
-        limit: 2
-      });
-      
-      const count = assertJobSearchResults(result);
-      assert.ok(count >= 0, 'Should return valid count for discovered job name');
-    });
-
-    test('should support case-insensitive search with discovered names', async () => {
-      if (discoveredJobNames.length === 0) {
-        console.log('⚠️ Skipping case-insensitive test - no job names discovered');
-        return;
-      }
-      
-      const testJobName = discoveredJobNames[0];
-      const variations = [
-        testJobName.toLowerCase(),
-        testJobName.substring(0, 3).toLowerCase()
-      ];
-      
-      for (const variation of variations) {
-        const result = await client.callTool('search_job_logs_by_name', { 
-          jobName: variation
-        });
-        
-        assertSuccessResponse(result);
-        // Should find results or return no results message
-        const text = parseResponseText(result.content[0].text);
-        assert.ok(text.includes('Found') || text.includes('No job logs found'),
-          `Should return valid response for case variation "${variation}"`);
-      }
-    });
-  });
-
-  // Multi-step workflow tests
-  describe('Multi-Step Workflows', () => {
-    test('should support workflow: discover -> search -> validate', async () => {
-      // Step 1: Search with broad term to discover available jobs
-      const discoveryResult = await client.callTool('search_job_logs_by_name', { 
-        jobName: 'Job',
-        limit: 5
-      });
-      
-      assertSuccessResponse(discoveryResult);
-      
-      const discoveryText = parseResponseText(discoveryResult.content[0].text);
-      if (!discoveryText.includes('No job logs found')) {
-        // Step 2: Extract a specific job name for targeted search
-        const jobMatch = discoveryText.match(/🔧 Job: ([A-Za-z0-9]+)/);
-        
-        if (jobMatch) {
-          const specificJobName = jobMatch[1];
-          
-          // Step 3: Search for that specific job
-          const specificResult = await client.callTool('search_job_logs_by_name', { 
-            jobName: specificJobName,
-            limit: 1
-          });
-          
-          const specificCount = assertJobSearchResults(specificResult);
-          assert.ok(specificCount >= 0, 'Specific search should return valid results');
-          
-          // Step 4: Validate the targeted search found the job
-          if (specificCount > 0) {
-            const specificText = parseResponseText(specificResult.content[0].text);
-            assert.ok(specificText.includes(specificJobName),
-              `Targeted search should include job name "${specificJobName}"`);
-          }
-        }
-      }
-    });
-
-    test('should handle sequential searches consistently', async () => {
-      const searchTerms = ['Import', 'Job', 'Process'];
-      const results = [];
-      
-      // Perform sequential searches
-      for (const term of searchTerms) {
-        const result = await client.callTool('search_job_logs_by_name', { 
-          jobName: term,
-          limit: 2
-        });
-        
-        assertSuccessResponse(result);
-        results.push({ term, result });
-      }
-      
-      // Validate all searches completed successfully
-      assert.equal(results.length, searchTerms.length, 
-        'All sequential searches should complete');
-      
-      // Each result should be valid
-      for (const { term, result } of results) {
-        const text = parseResponseText(result.content[0].text);
-        assert.ok(text.includes('Found') || text.includes('No job logs found'),
-          `Search for "${term}" should return valid response format`);
-      }
-    });
-  });
-
-  // Edge cases and error handling
-  describe('Edge Cases', () => {
-    test('should handle various edge case inputs', async () => {
-      const edgeCases = [
-        { jobName: 'a', desc: 'single character' },
-        { jobName: 'Job-With-Hyphens', desc: 'special characters' },
-        { jobName: '   Import   ', desc: 'whitespace padding' }
-      ];
-      
-      for (const { jobName, desc } of edgeCases) {
-        const result = await client.callTool('search_job_logs_by_name', { 
-          jobName,
-          limit: 1
-        });
-        
-        // Should not throw errors, should return valid response
-        assertValidMCPResponse(result);
-        
-        if (result.isError) {
-          // If it's an error, should be a validation error
-          const text = parseResponseText(result.content[0].text);
-          assert.ok(text.includes('Error'), 
-            `${desc}: Error response should contain "Error"`);
-        } else {
-          // If successful, should have valid format
-          const text = parseResponseText(result.content[0].text);
-          assert.ok(text.includes('Found') || text.includes('No job logs found'),
-            `${desc}: Should return valid search response`);
-        }
-      }
-    });
-  });
-});