sfcc-dev-mcp 1.0.16 → 1.0.20

package/tests/mcp/node/search-site-preferences.full-mode.programmatic.test.js

@@ -1,556 +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_site_preferences tool - Full Mode Programmatic Tests', () => {
-  let client;
-
-  before(async () => {
-    client = await connect('./aegis.config.with-dw.json');
-  });
-
-  after(async () => {
-    if (client?.connected) {
-      await client.disconnect();
-    }
-  });
-
-  beforeEach(() => {
-    // CRITICAL: Clear all buffers to prevent leaking into next tests
-    client.clearAllBuffers();
-  });
-
-  describe('Complex Query Structure Validation', () => {
-    test('should validate complex boolean query with multiple conditions', async () => {
-      const complexQuery = {
-        groupId: 'Storefront',
-        instanceType: 'sandbox',
-        searchRequest: {
-          query: {
-            bool_query: {
-              must: [
-                {
-                  text_query: {
-                    fields: ['id', 'display_name'],
-                    search_phrase: 'cart'
-                  }
-                }
-              ],
-              should: [
-                {
-                  term_query: {
-                    fields: ['value_type'],
-                    operator: 'is',
-                    values: ['boolean']
-                  }
-                }
-              ]
-            }
-          },
-          count: 5,
-          start: 0
-        }
-      };
-
-      const result = await client.callTool('search_site_preferences', complexQuery);
-      
-      assert.equal(result.isError, false, 'Complex boolean query should succeed');
-      assert.ok(result.content, 'Should have content');
-      assert.equal(result.content[0].type, 'text', 'Content should be text type');
-      
-      const responseData = JSON.parse(result.content[0].text);
-      assert.ok(responseData.hits, 'Response should have hits array');
-      assert.ok(responseData.query, 'Response should echo query');
-      assert.equal(responseData.query.bool_query.must.length, 1, 'Should preserve bool_query structure');
-      assert.equal(responseData.query.bool_query.should.length, 1, 'Should preserve should conditions');
-    });
-
-    test('should handle nested boolean queries with must_not conditions', async () => {
-      const nestedQuery = {
-        groupId: 'System',
-        instanceType: 'sandbox',
-        searchRequest: {
-          query: {
-            bool_query: {
-              must: [
-                {
-                  match_all_query: {}
-                }
-              ],
-              must_not: [
-                {
-                  term_query: {
-                    fields: ['value_type'],
-                    operator: 'is',
-                    values: ['password']
-                  }
-                }
-              ]
-            }
-          },
-          count: 10
-        }
-      };
-
-      const result = await client.callTool('search_site_preferences', nestedQuery);
-      
-      assert.equal(result.isError, false, 'Nested boolean query should succeed');
-      
-      const responseData = JSON.parse(result.content[0].text);
-      assert.ok(responseData.hits, 'Should have hits');
-      assert.ok(responseData.query.bool_query.must_not, 'Should preserve must_not conditions');
-      
-      // Verify no password type preferences are returned
-      const passwordPrefs = responseData.hits.filter(hit => 
-        hit.attribute_definition?.value_type === 'password'
-      );
-      assert.equal(passwordPrefs.length, 0, 'Should exclude password type preferences');
-    });
-  });
-
-  describe('Response Structure Deep Validation', () => {
-    test('should validate complete response structure with all fields', async () => {
-      const result = await client.callTool('search_site_preferences', {
-        groupId: 'Storefront',
-        instanceType: 'sandbox',
-        searchRequest: {
-          query: { match_all_query: {} },
-          count: 3,
-          start: 0
-        },
-        options: {
-          expand: 'value',
-          maskPasswords: false
-        }
-      });
-
-      assert.equal(result.isError, false, 'Request should succeed');
-      
-      const responseData = JSON.parse(result.content[0].text);
-      
-      // Validate top-level structure
-      assert.ok(responseData._type, 'Should have _type field');
-      assert.equal(responseData._type, 'preference_value_search_result', 'Should have correct type');
-      assert.ok(Array.isArray(responseData.hits), 'Hits should be array');
-      assert.ok(typeof responseData.start === 'number', 'Start should be number');
-      assert.ok(typeof responseData.count === 'number', 'Count should be number');
-      assert.ok(typeof responseData.total === 'number', 'Total should be number');
-      assert.ok(responseData.query, 'Should have query echo');
-
-      // Validate hit structure if any hits exist
-      if (responseData.hits.length > 0) {
-        const hit = responseData.hits[0];
-        assert.ok(hit.attribute_definition, 'Hit should have attribute_definition');
-        assert.ok(hit.site_values, 'Hit should have site_values');
-        
-        // Validate attribute definition structure
-        const attrDef = hit.attribute_definition;
-        assert.ok(typeof attrDef.id === 'string', 'Attribute definition should have id');
-        assert.ok(typeof attrDef.display_name === 'object', 'Display name should be object');
-        assert.ok(typeof attrDef.value_type === 'string', 'Should have value_type');
-        
-        // Validate site values structure
-        const siteValues = hit.site_values;
-        assert.ok(typeof siteValues === 'object', 'Site values should be object');
-        assert.ok(siteValues !== null, 'Site values should not be null');
-        
-        if (Object.keys(siteValues).length > 0) {
-          const firstSiteId = Object.keys(siteValues)[0];
-          assert.ok(typeof firstSiteId === 'string', 'Site ID should be string');
-          assert.ok(Object.prototype.hasOwnProperty.call(siteValues, firstSiteId), 'Site values should have site ID property');
-        }
-      }
-    });
-
-    test('should validate pagination metadata consistency', async () => {
-      // Get total count first with reasonable count
-      const countResult = await client.callTool('search_site_preferences', {
-        groupId: 'Storefront',
-        instanceType: 'sandbox',
-        searchRequest: {
-          query: { match_all_query: {} },
-          count: 50, // Reasonable count instead of 1000
-          start: 0
-        }
-      });
-
-      assert.equal(countResult.isError, false, 'Count request should succeed');
-      const countData = JSON.parse(countResult.content[0].text);
-      const totalPreferences = countData.total;
-
-      if (totalPreferences > 5) {
-        // Test pagination with smaller pages
-        const pageSize = 3;
-        const page1Result = await client.callTool('search_site_preferences', {
-          groupId: 'Storefront',
-          instanceType: 'sandbox',
-          searchRequest: {
-            query: { match_all_query: {} },
-            count: pageSize,
-            start: 0
-          }
-        });
-
-        const page2Result = await client.callTool('search_site_preferences', {
-          groupId: 'Storefront',
-          instanceType: 'sandbox',
-          searchRequest: {
-            query: { match_all_query: {} },
-            count: pageSize,
-            start: pageSize
-          }
-        });
-
-        assert.equal(page1Result.isError, false, 'Page 1 should succeed');
-        assert.equal(page2Result.isError, false, 'Page 2 should succeed');
-
-        const page1Data = JSON.parse(page1Result.content[0].text);
-        const page2Data = JSON.parse(page2Result.content[0].text);
-
-        // Validate pagination metadata
-        assert.equal(page1Data.start, 0, 'Page 1 start should be 0');
-        assert.equal(page1Data.count, pageSize, 'Page 1 count should match request');
-        assert.equal(page2Data.start, pageSize, 'Page 2 start should be offset');
-        assert.equal(page2Data.count, pageSize, 'Page 2 count should match request');
-        
-        // Both pages should report same total
-        assert.equal(page1Data.total, page2Data.total, 'Total should be consistent across pages');
-
-        // Validate no duplicate preferences between pages
-        const page1Ids = page1Data.hits.map(hit => hit.attribute_definition.id);
-        const page2Ids = page2Data.hits.map(hit => hit.attribute_definition.id);
-        const intersection = page1Ids.filter(id => page2Ids.includes(id));
-        assert.equal(intersection.length, 0, 'Pages should not have duplicate preferences');
-      }
-    });
-  });
-
-  describe('Advanced Query Scenarios', () => {
-    test('should handle multiple preference groups sequentially', async () => {
-      const preferenceGroups = ['Storefront', 'System', 'SFRA'];
-      const results = new Map();
-
-      // Test each group sequentially (no concurrent requests)
-      for (const groupId of preferenceGroups) {
-        const result = await client.callTool('search_site_preferences', {
-          groupId,
-          instanceType: 'sandbox',
-          searchRequest: {
-            query: { match_all_query: {} },
-            count: 5
-          }
-        });
-
-        assert.equal(result.isError, false, `Group ${groupId} should be accessible`);
-        
-        const responseData = JSON.parse(result.content[0].text);
-        results.set(groupId, responseData);
-        
-        // Validate group-specific response
-        assert.ok(responseData.hits, `Group ${groupId} should have hits`);
-        assert.ok(responseData.total >= 0, `Group ${groupId} should have total count`);
-      }
-
-      // Validate that different groups return different preferences
-      const storefrontIds = results.get('Storefront').hits.map(hit => hit.attribute_definition.id);
-      const systemIds = results.get('System').hits.map(hit => hit.attribute_definition.id);
-      
-      if (storefrontIds.length > 0 && systemIds.length > 0) {
-        const overlap = storefrontIds.filter(id => systemIds.includes(id));
-        assert.equal(overlap.length, 0, 'Different groups should have different preferences');
-      }
-    });
-
-    test('should validate search with sorting and field selection', async () => {
-      const result = await client.callTool('search_site_preferences', {
-        groupId: 'Storefront',
-        instanceType: 'sandbox',
-        searchRequest: {
-          query: { match_all_query: {} },
-          count: 10,
-          start: 0,
-          select: '(*)',
-          sorts: [
-            {
-              field: 'id',
-              sort_order: 'asc'
-            }
-          ]
-        }
-      });
-
-      assert.equal(result.isError, false, 'Sorted query should succeed');
-      
-      const responseData = JSON.parse(result.content[0].text);
-      assert.ok(responseData.hits, 'Should have hits');
-      
-      // Note: Sorting validation removed as mock server doesn't implement actual sorting
-      // This test now focuses on validating that sorting parameters are accepted
-      
-      // Validate that select parameter is echoed in response
-      assert.ok(responseData.select, 'Response should echo select parameter');
-      assert.equal(responseData.select, '(*)', 'Select parameter should be preserved as (*)');
-    });
-  });
-
-  describe('Error Handling and Edge Cases', () => {
-    test('should handle query timeout gracefully', async () => {
-      // Test with a very complex query that might timeout
-      const complexTimeoutQuery = {
-        groupId: 'Storefront',
-        instanceType: 'sandbox',
-        searchRequest: {
-          query: {
-            bool_query: {
-              must: [
-                {
-                  text_query: {
-                    fields: ['id', 'display_name', 'description'],
-                    search_phrase: 'a' // Very broad search
-                  }
-                }
-              ],
-              should: Array.from({ length: 10 }, (_, i) => ({
-                term_query: {
-                  fields: ['value_type'],
-                  operator: 'is',
-                  values: [`type_${i}`]
-                }
-              }))
-            }
-          },
-          count: 1000, // Large count
-          start: 0
-        }
-      };
-
-      const result = await client.callTool('search_site_preferences', complexTimeoutQuery);
-      
-      // Should either succeed or fail gracefully with timeout error
-      if (result.isError) {
-        assert.ok(
-          result.content[0].text.includes('timeout') || 
-          result.content[0].text.includes('error') ||
-          result.content[0].text.includes('invalid'),
-          'Timeout should produce meaningful error message'
-        );
-      } else {
-        // If it succeeds, validate response structure
-        const responseData = JSON.parse(result.content[0].text);
-        assert.ok(responseData._type, 'Should have valid response structure even for complex queries');
-      }
-    });
-
-    test('should validate parameter combinations and constraints', async () => {
-      const testCases = [
-        {
-          name: 'negative start parameter',
-          params: {
-            groupId: 'Storefront',
-            instanceType: 'sandbox',
-            searchRequest: {
-              query: { match_all_query: {} },
-              start: -1
-            }
-          },
-          shouldSucceed: false
-        }
-      ];
-
-      for (const testCase of testCases) {
-        const result = await client.callTool('search_site_preferences', testCase.params);
-        
-        if (testCase.shouldSucceed) {
-          assert.equal(result.isError, false, `${testCase.name} should succeed`);
-        } else {
-          assert.equal(result.isError, true, `${testCase.name} should fail with validation error`);
-          assert.ok(
-            result.content[0].text.includes('error') || 
-            result.content[0].text.includes('Error') ||
-            result.content[0].text.includes('invalid') ||
-            result.content[0].text.includes('required') ||
-            result.content[0].text.includes('must be'),
-            `${testCase.name} should provide meaningful error message. Got: ${result.content[0].text}`
-          );
-        }
-      }
-    });
-  });
-
-  describe('Data Consistency and Business Logic', () => {
-    test('should validate preference value types and constraints', async () => {
-      const result = await client.callTool('search_site_preferences', {
-        groupId: 'Storefront',
-        instanceType: 'sandbox',
-        searchRequest: {
-          query: { match_all_query: {} },
-          count: 20
-        }
-      });
-
-      assert.equal(result.isError, false, 'Query should succeed');
-      
-      const responseData = JSON.parse(result.content[0].text);
-      
-      if (responseData.hits.length > 0) {
-        const validValueTypes = ['string', 'boolean', 'int', 'double', 'password', 'email', 'text', 'html', 'date', 'enum_of_string', 'set_of_string'];
-        
-        responseData.hits.forEach((hit, index) => {
-          const attrDef = hit.attribute_definition;
-          
-          // Validate required fields
-          assert.ok(attrDef.id, `Hit ${index} should have attribute id`);
-          assert.ok(attrDef.value_type, `Hit ${index} should have value_type`);
-          assert.ok(validValueTypes.includes(attrDef.value_type), 
-            `Hit ${index} should have valid value_type: ${attrDef.value_type}`);
-          
-          // Validate display_name structure
-          if (attrDef.display_name) {
-            assert.ok(typeof attrDef.display_name === 'object', 
-              `Hit ${index} display_name should be object`);
-          }
-          
-          // Validate site_values structure
-          assert.ok(typeof hit.site_values === 'object', 
-            `Hit ${index} site_values should be object`);
-          assert.ok(hit.site_values !== null, 
-            `Hit ${index} site_values should not be null`);
-          
-          const siteValueEntries = Object.entries(hit.site_values);
-          siteValueEntries.forEach(([siteId, siteValue], siteIndex) => {
-            assert.ok(typeof siteId === 'string', 
-              `Hit ${index}, site entry ${siteIndex} should have string site ID`);
-            
-            // Validate value based on type (skip null values)
-            if (siteValue !== null) {
-              if (attrDef.value_type === 'boolean') {
-                assert.ok(typeof siteValue === 'boolean', 
-                  `Hit ${index}, site ${siteId} should have boolean value for boolean type`);
-              }
-              
-              if (attrDef.value_type === 'int') {
-                assert.ok(Number.isInteger(siteValue), 
-                  `Hit ${index}, site ${siteId} should have integer value for int type`);
-              }
-            }
-          });
-        });
-      }
-    });
-
-    test('should validate query result consistency across calls', async () => {
-      const queryParams = {
-        groupId: 'Storefront',
-        instanceType: 'sandbox',
-        searchRequest: {
-          query: {
-            text_query: {
-              fields: ['id', 'display_name'],
-              search_phrase: 'cart'
-            }
-          },
-          count: 10
-        }
-      };
-
-      // Execute same query multiple times
-      const results = [];
-      for (let i = 0; i < 3; i++) {
-        const result = await client.callTool('search_site_preferences', queryParams);
-        assert.equal(result.isError, false, `Call ${i + 1} should succeed`);
-        
-        const responseData = JSON.parse(result.content[0].text);
-        results.push(responseData);
-      }
-
-      // Validate consistency across calls
-      const firstResult = results[0];
-      for (let i = 1; i < results.length; i++) {
-        const currentResult = results[i];
-        
-        assert.equal(currentResult.total, firstResult.total, 
-          `Call ${i + 1} total should match first call`);
-        assert.equal(currentResult.hits.length, firstResult.hits.length, 
-          `Call ${i + 1} hits count should match first call`);
-        
-        // Compare preference IDs (order should be consistent)
-        const firstIds = firstResult.hits.map(hit => hit.attribute_definition.id);
-        const currentIds = currentResult.hits.map(hit => hit.attribute_definition.id);
-        assert.deepEqual(currentIds, firstIds, 
-          `Call ${i + 1} should return same preferences in same order`);
-      }
-    });
-  });
-
-  describe('Performance and Scalability Validation', () => {
-    test('should handle large result sets efficiently', async () => {
-      const largeQueryResult = await client.callTool('search_site_preferences', {
-        groupId: 'Storefront',
-        instanceType: 'sandbox',
-        searchRequest: {
-          query: { match_all_query: {} },
-          count: 50 // Reduced from 200 to avoid server issues
-        }
-      });
-
-      assert.equal(largeQueryResult.isError, false, 'Large query should succeed');
-      
-      const responseData = JSON.parse(largeQueryResult.content[0].text);
-      
-      // Validate response structure is maintained for large results
-      assert.ok(responseData._type, 'Large response should have type');
-      assert.ok(Array.isArray(responseData.hits), 'Large response should have hits array');
-      assert.ok(typeof responseData.total === 'number', 'Large response should have total');
-      
-      // Validate all hits have required structure
-      responseData.hits.forEach((hit, index) => {
-        assert.ok(hit.attribute_definition, `Hit ${index} should have attribute_definition`);
-        assert.ok(hit.site_values, `Hit ${index} should have site_values`);
-        assert.ok(hit.attribute_definition.id, `Hit ${index} should have id`);
-      });
-    });
-
-    test('should validate functional reliability over multiple operations', async () => {
-      const operations = [
-        { groupId: 'Storefront', query: { match_all_query: {} } },
-        { groupId: 'System', query: { text_query: { fields: ['id'], search_phrase: 'test' } } },
-        { groupId: 'SFRA', query: { match_all_query: {} } },
-        { groupId: 'Storefront', query: { term_query: { fields: ['value_type'], operator: 'is', values: ['boolean'] } } }
-      ];
-
-      const results = [];
-      
-      for (const operation of operations) {
-        const result = await client.callTool('search_site_preferences', {
-          groupId: operation.groupId,
-          instanceType: 'sandbox',
-          searchRequest: {
-            query: operation.query,
-            count: 10
-          }
-        });
-
-        results.push({
-          groupId: operation.groupId,
-          success: !result.isError,
-          hasContent: result.content && result.content.length > 0,
-          responseValid: !result.isError && result.content[0].text.startsWith('{')
-        });
-      }
-
-      // Calculate reliability metrics
-      const successfulOperations = results.filter(r => r.success).length;
-      const validResponses = results.filter(r => r.responseValid).length;
-      
-      assert.ok(successfulOperations >= operations.length * 0.8, 
-        `At least 80% of operations should succeed (${successfulOperations}/${operations.length})`);
-      assert.ok(validResponses >= operations.length * 0.8, 
-        `At least 80% of responses should be valid JSON (${validResponses}/${operations.length})`);
-
-      // Log reliability stats for monitoring
-      console.log(`\nReliability Stats:`);
-      console.log(`- Successful operations: ${successfulOperations}/${operations.length} (${(successfulOperations/operations.length*100).toFixed(1)}%)`);
-      console.log(`- Valid responses: ${validResponses}/${operations.length} (${(validResponses/operations.length*100).toFixed(1)}%)`);
-    });
-  });
-});