sfcc-dev-mcp 1.0.19 → 1.0.21

package/tests/mcp/node/search-system-object-attribute-definitions.full-mode.programmatic.test.js

@@ -1,744 +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_system_object_attribute_definitions - 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 stderr to prevent test interference
-    client.clearStderr();
-  });
-
-  // Helper functions for common validations
-  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 assertValidSearchResponse(result) {
-    assertValidMCPResponse(result);
-    assert.equal(result.isError, false, 'Should not be error');
-    
-    const responseText = result.content[0].text;
-    const responseData = JSON.parse(responseText);
-    
-    assert.ok(responseData.hits !== undefined, 'Should have hits array');
-    assert.ok(Array.isArray(responseData.hits), 'Hits should be array');
-    assert.ok(typeof responseData.total === 'number', 'Should have total count');
-    
-    return responseData;
-  }
-
-  function assertValidAttributeDefinition(attribute) {
-    assert.ok(typeof attribute.id === 'string', 'Attribute should have id');
-    assert.ok(typeof attribute._type === 'string', 'Should have _type');
-    assert.equal(attribute._type, 'object_attribute_definition', 'Should be object_attribute_definition type');
-    assert.ok(typeof attribute._resource_state === 'string', 'Should have _resource_state');
-    assert.ok(typeof attribute.link === 'string', 'Should have link');
-    
-    // Note: OCAPI search results only return basic info (id, link, _type, _resource_state)
-    // Detailed fields like display_name, value_type, mandatory are only available 
-    // when fetching individual attributes via the link
-  }
-
-  describe('Protocol Compliance and Tool Availability', () => {
-    test('should be connected to MCP server', async () => {
-      assert.ok(client.connected, 'Client should be connected');
-    });
-
-    test('should have search_system_object_attribute_definitions tool available', async () => {
-      const tools = await client.listTools();
-      const toolNames = tools.map(tool => tool.name);
-      assert.ok(toolNames.includes('search_system_object_attribute_definitions'), 
-        'Tool should be available in full mode');
-    });
-
-    test('should have proper tool schema definition', async () => {
-      const tools = await client.listTools();
-      const tool = tools.find(t => t.name === 'search_system_object_attribute_definitions');
-      
-      assert.ok(tool, 'Tool should exist');
-      assert.ok(tool.description, 'Tool should have description');
-      assert.ok(tool.inputSchema, 'Tool should have input schema');
-      assert.equal(tool.inputSchema.type, 'object', 'Schema should be object type');
-      
-      // Validate required parameters
-      const required = tool.inputSchema.required || [];
-      assert.ok(required.includes('objectType'), 'objectType should be required');
-      assert.ok(required.includes('searchRequest'), 'searchRequest should be required');
-    });
-  });
-
-  describe('Dynamic Test Case Generation', () => {
-    test('should generate and validate test cases for known object types', async () => {
-      const knownObjectTypes = ['Product', 'Customer', 'Order', 'Category', 'Site'];
-      
-      for (const objectType of knownObjectTypes) {
-        // Test with match_all_query for each object type
-        const result = await client.callTool('search_system_object_attribute_definitions', {
-          objectType: objectType,
-          searchRequest: {
-            query: { match_all_query: {} },
-            count: 5
-          }
-        });
-        
-        const responseData = assertValidSearchResponse(result);
-        
-        // Validate each attribute in the response
-        responseData.hits.forEach(attribute => {
-          assertValidAttributeDefinition(attribute);
-          
-          // Business logic validation - verify attribute IDs are reasonable
-          assert.ok(attribute.id.length > 0, 'Attribute ID should not be empty');
-          assert.ok(!/\s/.test(attribute.id), 'Attribute ID should not contain spaces');
-          
-          // Note: Detailed validation of Product-specific fields would require
-          // fetching individual attributes via their links, which is beyond
-          // the scope of search functionality testing
-        });
-        
-        assert.ok(responseData.total >= 0, `${objectType} should have non-negative attribute count`);
-      }
-    });
-
-    test('should validate query type combinations dynamically', async () => {
-      const queryTypes = [
-        { match_all_query: {} },
-        { 
-          text_query: {
-            fields: ['id', 'display_name', 'description'],
-            search_phrase: 'name'
-          }
-        },
-        {
-          term_query: {
-            fields: ['value_type'],
-            operator: 'is',
-            values: ['string']
-          }
-        }
-      ];
-      
-      for (const query of queryTypes) {
-        const result = await client.callTool('search_system_object_attribute_definitions', {
-          objectType: 'Product',
-          searchRequest: { query, count: 3 }
-        });
-        
-        const responseData = assertValidSearchResponse(result);
-        
-        // Validate that query type affects results appropriately
-        if (query.text_query && query.text_query.search_phrase === 'name') {
-          // Should return attributes related to 'name'
-          // Note: Not asserting as it depends on actual data and fuzzy matching
-          responseData.hits.some(attr => 
-            attr.id.toLowerCase().includes('name') ||
-            Object.values(attr.display_name).some(name => 
-              name.toLowerCase().includes('name')
-            )
-          );
-        }
-        
-        if (query.term_query && query.term_query.values.includes('string')) {
-          // Note: OCAPI search results don't include value_type in basic response
-          // This would require fetching individual attributes to validate
-          // For search testing, we focus on verifying the search request/response structure
-          assert.ok(responseData.hits.length >= 0, 'Should return non-negative results');
-        }
-      }
-    });
-  });
-
-  describe('Complex Query Combinations', () => {
-    test('should handle bool_query with multiple clauses', async () => {
-      const complexQuery = {
-        bool_query: {
-          must: [
-            {
-              term_query: {
-                fields: ['mandatory'],
-                operator: 'is',
-                values: ['true']
-              }
-            },
-            {
-              term_query: {
-                fields: ['searchable'],
-                operator: 'is', 
-                values: ['true']
-              }
-            }
-          ],
-          should: [
-            {
-              text_query: {
-                fields: ['id'],
-                search_phrase: 'custom'
-              }
-            }
-          ],
-          must_not: [
-            {
-              term_query: {
-                fields: ['system'],
-                operator: 'is',
-                values: ['true']
-              }
-            }
-          ]
-        }
-      };
-
-      const result = await client.callTool('search_system_object_attribute_definitions', {
-        objectType: 'Product',
-        searchRequest: {
-          query: complexQuery,
-          count: 10
-        }
-      });
-
-      const responseData = assertValidSearchResponse(result);
-      
-      // Validate that results match the complex query criteria
-      responseData.hits.forEach(attr => {
-        // Note: OCAPI search results only return basic attribute info (id, link, _type)
-        // Detailed validation of mandatory, searchable, system flags would require
-        // fetching individual attributes via their links. For search API testing,
-        // we focus on validating the search request/response structure and pagination.
-        assertValidAttributeDefinition(attr);
-        assert.ok(attr.id.length > 0, 'Attribute should have valid ID');
-      });
-    });
-
-    test('should handle nested bool_query structures', async () => {
-      const nestedQuery = {
-        bool_query: {
-          must: [
-            {
-              bool_query: {
-                should: [
-                  {
-                    term_query: {
-                      fields: ['value_type'],
-                      operator: 'one_of',
-                      values: ['string', 'text']
-                    }
-                  },
-                  {
-                    term_query: {
-                      fields: ['value_type'],
-                      operator: 'is',
-                      values: ['enum-of-string']
-                    }
-                  }
-                ]
-              }
-            }
-          ]
-        }
-      };
-
-      const result = await client.callTool('search_system_object_attribute_definitions', {
-        objectType: 'Customer',
-        searchRequest: {
-          query: nestedQuery,
-          count: 5,
-          sorts: [
-            { field: 'id', sort_order: 'asc' }
-          ]
-        }
-      });
-
-      const responseData = assertValidSearchResponse(result);
-      
-      // Validate nested query results
-      responseData.hits.forEach(attr => {
-        // Note: OCAPI search results don't include value_type in basic response
-        // For search API testing, we validate the structure and response format
-        assertValidAttributeDefinition(attr);
-        assert.ok(attr.id.length > 0, 'Should have valid attribute ID');
-      });
-
-      // Validate sorting is applied
-      if (responseData.hits.length > 1) {
-        for (let i = 1; i < responseData.hits.length; i++) {
-          assert.ok(responseData.hits[i].id >= responseData.hits[i-1].id, 
-            'Results should be sorted by id in ascending order');
-        }
-      }
-    });
-  });
-
-  describe('Pagination and Large Dataset Handling', () => {
-    test('should handle pagination correctly across multiple requests', async () => {
-      const pageSize = 5;
-      const maxPages = 3;
-      const allResults = [];
-      let totalCount = 0;
-
-      for (let page = 0; page < maxPages; page++) {
-        const result = await client.callTool('search_system_object_attribute_definitions', {
-          objectType: 'Product',
-          searchRequest: {
-            query: { match_all_query: {} },
-            count: pageSize,
-            start: page * pageSize,
-            sorts: [{ field: 'id', sort_order: 'asc' }]
-          }
-        });
-
-        const responseData = assertValidSearchResponse(result);
-        
-        if (page === 0) {
-          totalCount = responseData.total;
-        } else {
-          assert.equal(responseData.total, totalCount, 
-            'Total count should be consistent across pages');
-        }
-
-        // Validate page results
-        assert.ok(responseData.hits.length <= pageSize, 
-          'Page should not exceed requested size');
-        
-        // Check for duplicates across pages
-        responseData.hits.forEach(attr => {
-          const isDuplicate = allResults.some(existing => existing.id === attr.id);
-          assert.equal(isDuplicate, false, `Attribute ${attr.id} should not appear in multiple pages`);
-          allResults.push(attr);
-        });
-
-        // Break if we've reached the end
-        if (responseData.hits.length < pageSize || 
-            allResults.length >= responseData.total) {
-          break;
-        }
-      }
-
-      // Validate overall pagination consistency
-      assert.ok(allResults.length > 0, 'Should have retrieved some results');
-      
-      // Validate sorting consistency across pages
-      if (allResults.length > 1) {
-        for (let i = 1; i < allResults.length; i++) {
-          assert.ok(allResults[i].id >= allResults[i-1].id, 
-            'Results should maintain sort order across pages');
-        }
-      }
-    });
-
-    test('should handle large count requests appropriately', async () => {
-      const largeCount = 200;
-      
-      const result = await client.callTool('search_system_object_attribute_definitions', {
-        objectType: 'Product',
-        searchRequest: {
-          query: { match_all_query: {} },
-          count: largeCount
-        }
-      });
-
-      const responseData = assertValidSearchResponse(result);
-      
-      // Validate that server handles large requests (may return fewer than requested)
-      assert.ok(responseData.hits.length <= largeCount, 
-        'Should not return more than requested');
-      assert.ok(responseData.hits.length >= 0, 
-        'Should return non-negative number of results');
-      
-      // Validate that all returned results are valid
-      responseData.hits.forEach((attr, index) => {
-        try {
-          assertValidAttributeDefinition(attr);
-        } catch (error) {
-          throw new Error(`Invalid attribute at index ${index}: ${error.message}`);
-        }
-      });
-    });
-  });
-
-  describe('Cross-Field Validation and Business Logic', () => {
-    test('should validate attribute relationships and constraints', async () => {
-      const result = await client.callTool('search_system_object_attribute_definitions', {
-        objectType: 'Product',
-        searchRequest: {
-          query: { match_all_query: {} },
-          count: 50
-        }
-      });
-
-      const responseData = assertValidSearchResponse(result);
-      
-      // Business logic validations - based on OCAPI search response structure
-      responseData.hits.forEach(attr => {
-        assertValidAttributeDefinition(attr);
-        
-        // Validate basic structure returned by OCAPI search
-        assert.ok(attr.id.length > 0, 'Attribute ID should not be empty');
-        assert.ok(attr.link.includes('/attribute_definitions/'), 'Link should be valid');
-        assert.ok(attr._resource_state.length > 0, 'Should have resource state');
-        
-        // Note: Detailed attribute properties (value_type, mandatory, searchable, system, 
-        // display_name) are not included in search results. They would need to be 
-        // fetched individually via the attribute's link for detailed validation.
-      });
-    });
-
-    test('should validate search result consistency across different sort orders', async () => {
-      const sortFields = ['id']; // Only test 'id' since it's available in OCAPI search results
-      const sortOrders = ['asc', 'desc'];
-      const resultSets = new Map();
-
-      for (const field of sortFields) {
-        for (const order of sortOrders) {
-          const result = await client.callTool('search_system_object_attribute_definitions', {
-            objectType: 'Customer',
-            searchRequest: {
-              query: { match_all_query: {} },
-              count: 10,
-              sorts: [{ field, sort_order: order }]
-            }
-          });
-
-          const responseData = assertValidSearchResponse(result);
-          const key = `${field}_${order}`;
-          resultSets.set(key, responseData);
-
-          // Validate sort order is applied - OCAPI search results are sorted by ID
-          if (responseData.hits.length > 1) {
-            for (let i = 1; i < responseData.hits.length; i++) {
-              const current = responseData.hits[i];
-              const previous = responseData.hits[i-1];
-              
-              // For OCAPI search results, we can only sort by 'id' reliably
-              // since other detailed fields are not included in search response
-              if (field === 'id') {
-                const currentValue = current.id;
-                const previousValue = previous.id;
-
-                if (order === 'asc') {
-                  assert.ok(currentValue >= previousValue, 
-                    `${field} should be in ascending order: ${previousValue} <= ${currentValue}`);
-                } else {
-                  assert.ok(currentValue <= previousValue, 
-                    `${field} should be in descending order: ${previousValue} >= ${currentValue}`);
-                }
-              }
-              // Note: Other sort fields (display_name, value_type) are not available 
-              // in OCAPI search results, so we skip detailed validation for those
-            }
-          }
-        }
-      }
-
-      // Validate that different sort orders return same total count
-      const totalCounts = Array.from(resultSets.values()).map(data => data.total);
-      const uniqueTotals = [...new Set(totalCounts)];
-      assert.equal(uniqueTotals.length, 1, 
-        'All sort variations should return same total count');
-    });
-  });
-
-  describe('Error Recovery and Edge Cases', () => {
-    test('should handle invalid object types gracefully', async () => {
-      // Test non-existent object types (return empty results)
-      const invalidObjectTypes = ['InvalidObject', 'NonExistent'];
-      
-      for (const objectType of invalidObjectTypes) {
-        const result = await client.callTool('search_system_object_attribute_definitions', {
-          objectType: objectType,
-          searchRequest: {
-            query: { match_all_query: {} },
-            count: 5
-          }
-        });
-
-        // OCAPI returns successful response with empty results for invalid object types
-        const responseData = assertValidSearchResponse(result);
-        assert.equal(responseData.total, 0, 
-          `Should return 0 results for invalid object type: ${objectType}`);
-        assert.equal(responseData.hits.length, 0, 
-          `Should return empty hits array for invalid object type: ${objectType}`);
-      }
-
-      // Test empty object type (returns validation error)
-      const emptyResult = await client.callTool('search_system_object_attribute_definitions', {
-        objectType: '',
-        searchRequest: {
-          query: { match_all_query: {} },
-          count: 5
-        }
-      });
-
-      assert.equal(emptyResult.isError, true, 'Should return error for empty object type');
-      const errorText = emptyResult.content[0].text;
-      assert.ok(errorText.includes('objectType must be a non-empty string'), 
-        'Error message should indicate objectType validation issue');
-    });
-
-    test('should handle malformed queries gracefully', async () => {
-      const malformedQueries = [
-        { invalid_query_type: {} },
-        { text_query: { missing_required_fields: true } },
-        { term_query: { fields: [], operator: 'invalid', values: [] } },
-        { bool_query: { invalid_clause: [] } }
-      ];
-
-      for (const query of malformedQueries) {
-        const result = await client.callTool('search_system_object_attribute_definitions', {
-          objectType: 'Product',
-          searchRequest: { query, count: 5 }
-        });
-
-        // Should handle malformed queries gracefully
-        if (result.isError) {
-          const errorText = result.content[0].text;
-          assert.ok(errorText.length > 0, 'Error message should not be empty');
-        } else {
-          // If not an error, should return valid response structure
-          assertValidSearchResponse(result);
-        }
-      }
-    });
-
-    test('should recover from network issues and continue working', async () => {
-      // Test normal operation
-      const normalResult = await client.callTool('search_system_object_attribute_definitions', {
-        objectType: 'Product',
-        searchRequest: {
-          query: { match_all_query: {} },
-          count: 3
-        }
-      });
-
-      assertValidSearchResponse(normalResult);
-      
-      // Test with missing query field - OCAPI provides default behavior (match_all_query)
-      const missingQueryResult = await client.callTool('search_system_object_attribute_definitions', {
-        objectType: 'Product',
-        searchRequest: {
-          // Missing query field - OCAPI defaults to match_all_query
-          count: 3
-        }
-      });
-
-      // OCAPI provides graceful defaults rather than errors
-      const missingQueryData = assertValidSearchResponse(missingQueryResult);
-      assert.ok(missingQueryData.total >= 0, 'Should return valid results with default query');
-      
-      // Test that service continues to work normally after edge case
-      const recoveryResult = await client.callTool('search_system_object_attribute_definitions', {
-        objectType: 'Customer',
-        searchRequest: {
-          query: { match_all_query: {} },
-          count: 3
-        }
-      });
-
-      assertValidSearchResponse(recoveryResult);
-      assert.ok(recoveryResult.content[0].text.length > 0, 
-        'Service should continue working normally');
-    });
-  });
-
-  describe('Multi-Step Workflow Validation', () => {
-    test('should support attribute discovery and detailed analysis workflow', async () => {
-      // Step 1: Discover all attributes for an object type
-      const discoveryResult = await client.callTool('search_system_object_attribute_definitions', {
-        objectType: 'Product',
-        searchRequest: {
-          query: { match_all_query: {} },
-          count: 10,
-          select: '(**)'
-        }
-      });
-
-      const discoveryData = assertValidSearchResponse(discoveryResult);
-      assert.ok(discoveryData.hits.length > 0, 'Should discover some attributes');
-
-      // Step 2: Analyze specific attribute types found in step 1
-      const valueTypes = [...new Set(discoveryData.hits.map(attr => attr.value_type))];
-      
-      for (const valueType of valueTypes.slice(0, 3)) { // Test first 3 types
-        const typeAnalysisResult = await client.callTool('search_system_object_attribute_definitions', {
-          objectType: 'Product',
-          searchRequest: {
-            query: {
-              term_query: {
-                fields: ['value_type'],
-                operator: 'is',
-                values: [valueType]
-              }
-            },
-            count: 5
-          }
-        });
-
-        const typeData = assertValidSearchResponse(typeAnalysisResult);
-        
-        // Validate that all results have the expected value type
-        typeData.hits.forEach(attr => {
-          // Note: OCAPI search results don't include value_type field
-          // The query filtering happens server-side, so we validate structure instead
-          assertValidAttributeDefinition(attr);
-          assert.ok(attr.id.length > 0, `Should have valid attribute ID for type search: ${valueType}`);
-        });
-      }
-
-      // Step 3: Analyze attribute relationships (mandatory vs optional)
-      const mandatoryResult = await client.callTool('search_system_object_attribute_definitions', {
-        objectType: 'Product',
-        searchRequest: {
-          query: {
-            term_query: {
-              fields: ['mandatory'],
-              operator: 'is',
-              values: ['true']
-            }
-          },
-          count: 10
-        }
-      });
-
-      const mandatoryData = assertValidSearchResponse(mandatoryResult);
-      
-      mandatoryData.hits.forEach(attr => {
-        // Note: OCAPI search results don't include mandatory field in basic response
-        // The query filtering happens server-side, so we validate the response structure
-        assertValidAttributeDefinition(attr);
-        assert.ok(attr.id.length > 0, 'Should have valid attribute ID');
-      });
-
-      // Validate workflow consistency
-      const totalMandatory = mandatoryData.total;
-      assert.ok(totalMandatory >= 0, 'Should have non-negative mandatory attribute count');
-      assert.ok(totalMandatory <= discoveryData.total, 
-        'Mandatory attributes should be subset of all attributes');
-    });
-
-    test('should support complex search refinement workflow', async () => {
-      // Step 1: Broad search
-      const broadResult = await client.callTool('search_system_object_attribute_definitions', {
-        objectType: 'Customer',
-        searchRequest: {
-          query: {
-            text_query: {
-              fields: ['id', 'display_name'],
-              search_phrase: 'address'
-            }
-          },
-          count: 20
-        }
-      });
-
-      const broadData = assertValidSearchResponse(broadResult);
-      
-      // Step 2: Refine to only searchable address-related attributes
-      const refinedResult = await client.callTool('search_system_object_attribute_definitions', {
-        objectType: 'Customer',
-        searchRequest: {
-          query: {
-            bool_query: {
-              must: [
-                {
-                  text_query: {
-                    fields: ['id', 'display_name'],
-                    search_phrase: 'address'
-                  }
-                },
-                {
-                  term_query: {
-                    fields: ['searchable'],
-                    operator: 'is',
-                    values: ['true']
-                  }
-                }
-              ]
-            }
-          },
-          count: 20
-        }
-      });
-
-      const refinedData = assertValidSearchResponse(refinedResult);
-      
-      // Validate refinement logic
-      assert.ok(refinedData.total <= broadData.total, 
-        'Refined search should return same or fewer results');
-      
-      refinedData.hits.forEach(attr => {
-        // Note: OCAPI search results don't include searchable field in basic response
-        // The query filtering happens server-side, so we validate response structure
-        assertValidAttributeDefinition(attr);
-        assert.ok(attr.id.length > 0, 'Should have valid attribute ID');
-        
-        // Should contain address-related terms - validating with expression
-        // Note: This validation works with attribute IDs which are available
-        const containsAddressTerm = attr.id.toLowerCase().includes('address');
-        // Expression evaluated for documentation purposes
-        assert.ok(typeof containsAddressTerm === 'boolean', 'Should evaluate address term check');
-      });
-
-      // Step 3: Further refine to only custom (non-system) attributes
-      const customResult = await client.callTool('search_system_object_attribute_definitions', {
-        objectType: 'Customer',
-        searchRequest: {
-          query: {
-            bool_query: {
-              must: [
-                {
-                  text_query: {
-                    fields: ['id', 'display_name'],
-                    search_phrase: 'address'
-                  }
-                },
-                {
-                  term_query: {
-                    fields: ['searchable'],
-                    operator: 'is',
-                    values: ['true']
-                  }
-                }
-              ],
-              must_not: [
-                {
-                  term_query: {
-                    fields: ['system'],
-                    operator: 'is',
-                    values: ['true']
-                  }
-                }
-              ]
-            }
-          },
-          count: 20
-        }
-      });
-
-      const customData = assertValidSearchResponse(customResult);
-      
-      // Validate final refinement
-      assert.ok(customData.total <= refinedData.total, 
-        'Custom search should return same or fewer results than refined search');
-      
-      customData.hits.forEach(attr => {
-        // Note: OCAPI search results don't include searchable/system fields in basic response
-        // The query filtering happens server-side, so we validate response structure
-        assertValidAttributeDefinition(attr);
-        assert.ok(attr.id.length > 0, 'Should have valid attribute ID');
-      });
-    });
-  });
-});