sfcc-dev-mcp 1.0.16 → 1.0.20

package/tests/mcp/node/get-system-object-definition.full-mode.programmatic.test.js

@@ -1,389 +0,0 @@
-/**
- * ==================================================================================
- * SFCC MCP Server - get_system_object_definition Tool Programmatic Tests (Full Mode)
- * Streamlined programmatic testing focused on tool functionality and critical workflows
- * 
- * These tests require SFCC credentials and use the mock server for realistic testing
- * Focus on complex business logic, multi-step workflows, and advanced error handling
- * that cannot be effectively tested in YAML format
- * 
- * Quick Test Commands:
- * node --test tests/mcp/node/get-system-object-definition.full-mode.programmatic.test.js
- * npm test -- --grep "get_system_object_definition"
- * ==================================================================================
- */
-
-import { test, describe, before, after, beforeEach } from 'node:test';
-import { strict as assert } from 'node:assert';
-import { connect } from 'mcp-aegis';
-
-describe('get_system_object_definition Tool - Full Mode Programmatic Tests', () => {
-  let client;
-  
-  // Streamlined test data - focus on representative objects
-  const coreObjectTypes = ['Product', 'Customer', 'Order'];
-  const expectedSystemObjectFlags = {
-    'Product': { content_object: true, queryable: false, read_only: false },
-    'Customer': { content_object: false, queryable: true, read_only: false },
-    'Order': { content_object: false, queryable: true, read_only: true }
-  };
-
-  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 test interference
-    client.clearAllBuffers();
-  });
-
-  // ==================================================================================
-  // CONSOLIDATED TOOL DISCOVERY AND FUNCTIONALITY
-  // ==================================================================================
-
-  describe('Tool Discovery and Core Functionality', () => {
-    test('should discover tool with comprehensive schema and execute successfully', async () => {
-      // Tool discovery with schema validation
-      const tools = await client.listTools();
-      const systemObjectTool = tools.find(tool => tool.name === 'get_system_object_definition');
-      
-      assert.ok(systemObjectTool, 'get_system_object_definition tool should be available in full mode');
-      assert.ok(systemObjectTool.description.includes('system object'), 'Description should mention system objects');
-      
-      const schema = systemObjectTool.inputSchema;
-      assert.equal(schema.type, 'object', 'Schema should be object type');
-      assert.ok(schema.properties?.objectType, 'Schema should have objectType property');
-      assert.equal(schema.properties.objectType.type, 'string', 'objectType should be string type');
-      assert.ok(schema.required.includes('objectType'), 'objectType should be required');
-      
-      // Functional validation - execute tool successfully
-      const result = await client.callTool('get_system_object_definition', { objectType: 'Product' });
-      assert.equal(result.isError, false, 'Should execute successfully with valid parameters');
-      assert.ok(result.content?.[0]?.text, 'Should return content');
-      
-      // Validate response structure
-      const objectData = JSON.parse(result.content[0].text);
-      assertValidObjectDefinition(objectData, 'Product');
-    });
-
-    test('should validate tool context and availability with other system tools', async () => {
-      const tools = await client.listTools();
-      const toolNames = tools.map(t => t.name);
-      
-      // Should have related system object tools
-      assert.ok(toolNames.includes('get_system_object_definition'), 'Should have single object tool');
-      assert.ok(toolNames.includes('get_system_object_definitions'), 'Should have multi-object tool');
-      assert.ok(toolNames.includes('search_system_object_attribute_definitions'), 'Should have attribute search tool');
-      
-      // Should have substantial tool count in full mode
-      assert.ok(tools.length >= 30, `Should have many tools in full mode, got ${tools.length}`);
-    });
-  });
-
-  // ==================================================================================
-  // STREAMLINED BUSINESS LOGIC VALIDATION
-  // ==================================================================================
-
-  describe('Business Logic and System Object Validation', () => {
-    test('should validate core SFCC object characteristics and flag logic', async () => {
-      const results = new Map();
-      
-      // Test core object types sequentially (streamlined from 5 to 3 objects)
-      for (const objectType of coreObjectTypes) {
-        const result = await client.callTool('get_system_object_definition', { objectType });
-        
-        assert.equal(result.isError, false, `${objectType} should be retrieved successfully`);
-        const objectData = JSON.parse(result.content[0].text);
-        results.set(objectType, objectData);
-        
-        // Use helper function for comprehensive validation
-        assertValidObjectDefinition(objectData, objectType);
-        
-        // Validate expected flags (resilient to mock data changes)
-        const expectedFlags = expectedSystemObjectFlags[objectType];
-        if (expectedFlags) {
-          assert.equal(objectData.content_object, expectedFlags.content_object,
-            `${objectType} content_object should match expected value`);
-          assert.equal(objectData.queryable, expectedFlags.queryable,
-            `${objectType} queryable should match expected value`);
-          assert.equal(objectData.read_only, expectedFlags.read_only,
-            `${objectType} read_only should match expected value`);
-        }
-      }
-      
-      // Cross-object business rule validation
-      const productData = results.get('Product');
-      const customerData = results.get('Customer');
-      const orderData = results.get('Order');
-      
-      // Validate business rules (resilient assertions)
-      assert.ok(productData.attribute_definition_count > 0, 'Product should have attributes');
-      assert.ok(customerData.attribute_definition_count > 0, 'Customer should have attributes');
-      assert.equal(orderData.read_only, true, 'Order should be read-only');
-      assert.equal(customerData.queryable, true, 'Customer should be queryable');
-    });
-
-    test('should validate localization structure and metadata consistency', async () => {
-      const result = await client.callTool('get_system_object_definition', { objectType: 'Product' });
-      const objectData = JSON.parse(result.content[0].text);
-      
-      // Validate localization structure (flexible assertions)
-      validateLocalizationStructure(objectData.display_name, 'display_name');
-      assert.ok(objectData.description?.default, 'Should have default description');
-      
-      // Validate timestamps and metadata
-      assert.ok(objectData.creation_date, 'Should have creation date');
-      assert.ok(objectData.last_modified, 'Should have last modified date');
-      assert.ok(!isNaN(Date.parse(objectData.creation_date)), 'Creation date should be valid');
-      assert.ok(!isNaN(Date.parse(objectData.last_modified)), 'Last modified should be valid');
-    });
-  });
-
-  // ==================================================================================
-  // ESSENTIAL WORKFLOW VALIDATION 
-  // ==================================================================================
-
-  describe('Multi-Tool Integration Workflows', () => {
-    test('should support object discovery and analysis workflow', async () => {
-      // Step 1: Get all system object definitions
-      const allObjectsResult = await client.callTool('get_system_object_definitions', {});
-      assert.equal(allObjectsResult.isError, false, 'Should retrieve all object definitions');
-      
-      const allObjects = JSON.parse(allObjectsResult.content[0].text);
-      assert.ok(Array.isArray(allObjects.data), 'Should return array of objects');
-      assert.ok(allObjects.data.length > 0, 'Should have multiple object types');
-      
-      // Step 2: Analyze representative objects in detail
-      const analysisResults = [];
-      const testObjects = ['Product', 'Customer']; // Streamlined from 3 to 2 objects
-      
-      for (const objectType of testObjects) {
-        const detailResult = await client.callTool('get_system_object_definition', { objectType });
-        assert.equal(detailResult.isError, false, `Should get details for ${objectType}`);
-        
-        const detailData = JSON.parse(detailResult.content[0].text);
-        analysisResults.push({
-          objectType,
-          attributes: detailData.attribute_definition_count,
-          groups: detailData.attribute_group_count,
-          flags: {
-            content_object: detailData.content_object,
-            queryable: detailData.queryable,
-            read_only: detailData.read_only
-          }
-        });
-      }
-      
-      // Step 3: Validate workflow results
-      assert.equal(analysisResults.length, 2, 'Should analyze expected objects');
-      
-      // At least one should be queryable
-      const queryableCount = analysisResults.filter(r => r.flags.queryable).length;
-      assert.ok(queryableCount > 0, 'Should have at least one queryable object (Customer)');
-    });
-
-    test('should support attribute discovery and cross-tool integration', async () => {
-      // Step 1: Get object definition for context
-      const productResult = await client.callTool('get_system_object_definition', { objectType: 'Product' });
-      assert.equal(productResult.isError, false, 'Should get Product definition successfully');
-      
-      // Step 2: Search for Product attributes using integration tool
-      const attributeSearchResult = await client.callTool('search_system_object_attribute_definitions', {
-        objectType: 'Product',
-        searchRequest: {
-          query: { match_all_query: {} },
-          count: 10  // Reduced from 20 to 10 for efficiency
-        }
-      });
-      
-      assert.equal(attributeSearchResult.isError, false, 'Should search attributes successfully');
-      const attributeData = JSON.parse(attributeSearchResult.content[0].text);
-      
-      // Step 3: Validate cross-tool consistency
-      assert.ok(attributeData.hits !== undefined, 'Should have search results structure');
-      assert.ok(attributeData.total >= 0, 'Should have reasonable total count');
-      
-      // Validate attribute structure if results exist
-      if (attributeData.hits.length > 0) {
-        const sampleAttribute = attributeData.hits[0];
-        assert.ok(sampleAttribute.id, 'Attribute should have ID');
-        assert.ok(sampleAttribute._type === 'object_attribute_definition', 'Should have correct type');
-      }
-    });
-  });
-
-  // ==================================================================================
-  // COMPREHENSIVE ERROR HANDLING
-  // ==================================================================================
-
-  describe('Advanced Error Handling and Edge Cases', () => {
-    test('should handle comprehensive parameter validation scenarios', async () => {
-      const invalidCases = [
-        { args: {}, description: 'missing objectType', shouldError: true },
-        { args: { objectType: null }, description: 'null objectType', shouldError: true },
-        { args: { objectType: 123 }, description: 'numeric objectType', shouldError: true },
-        { args: { objectType: '' }, description: 'empty objectType', shouldError: true },
-        { args: { objectType: 'NonExistentObject' }, description: 'unknown object', shouldError: false }, // Fallback response
-        { args: { objectType: 'Product123' }, description: 'object with numbers', shouldError: false }, // Fallback response
-      ];
-      
-      for (const testCase of invalidCases) {
-        const result = await client.callTool('get_system_object_definition', testCase.args);
-        
-        if (testCase.shouldError) {
-          assert.equal(result.isError, true, 
-            `Should return error for ${testCase.description}`);
-          assert.ok(result.content[0].text.includes('Error'), 
-            `Error message should contain 'Error' for ${testCase.description}`);
-        } else {
-          // Fallback responses are acceptable for unknown object types
-          if (result.isError) {
-            assert.ok(result.content[0].text.includes('Error'), 
-              `Should have error message for ${testCase.description}`);
-          } else {
-            const data = JSON.parse(result.content[0].text);
-            assert.ok(data.object_type, 'Should have fallback object type');
-          }
-        }
-      }
-    });
-
-    test('should maintain performance and reliability under moderate load', async () => {
-      const testObjects = ['Product', 'Customer', 'Order'];
-      const results = [];
-      const startTime = Date.now();
-      
-      // Streamlined stress test (reduced from 10 to 5 iterations)
-      for (let i = 0; i < 5; i++) {
-        const objectType = testObjects[i % testObjects.length];
-        const iterationStart = Date.now();
-        
-        const result = await client.callTool('get_system_object_definition', { objectType });
-        const iterationTime = Date.now() - iterationStart;
-        
-        results.push({
-          iteration: i,
-          objectType,
-          success: !result.isError,
-          responseTime: iterationTime
-        });
-        
-        assert.equal(result.isError, false, 
-          `Iteration ${i} should succeed for ${objectType}`);
-      }
-      
-      const totalTime = Date.now() - startTime;
-      const successRate = results.filter(r => r.success).length / results.length;
-      
-      // Functional validation focused on reliability
-      assert.equal(successRate, 1.0, 'All stress test iterations should succeed');
-      assert.ok(totalTime < 20000, 'Load test should complete within 20 seconds');
-      
-      // Validate response consistency
-      const responseTimes = results.map(r => r.responseTime);
-      const avgResponseTime = responseTimes.reduce((sum, time) => sum + time, 0) / responseTimes.length;
-      assert.ok(avgResponseTime < 3000, 'Average response time should be reasonable');
-    });
-  });
-
-  // ==================================================================================
-  // FOCUSED INTEGRATION VALIDATION
-  // ==================================================================================
-
-  describe('Integration and Context Validation', () => {
-    test('should validate mock server integration and SFCC API compliance', async () => {
-      const result = await client.callTool('get_system_object_definition', { objectType: 'Product' });
-      const data = JSON.parse(result.content[0].text);
-      
-      // Validate SFCC API compliance (essential checks only)
-      assert.ok(data._v && data._v.match(/^\d+\.\d+$/), 'Should have valid API version format');
-      assert.ok(data.link && data.link.includes('/dw/data/'), 'Should have SFCC-style API link');
-      
-      // Validate realistic data structure
-      assert.ok(!isNaN(Date.parse(data.creation_date)), 'Should have valid creation date');
-      assert.ok(!isNaN(Date.parse(data.last_modified)), 'Should have valid last modified date');
-      assert.ok(data.attribute_definition_count >= 0, 'Should have realistic attribute count');
-      assert.ok(data.attribute_group_count >= 0, 'Should have realistic group count');
-    });
-
-    test('should validate cross-tool integration consistency', async () => {
-      // Single object definition
-      const singleResult = await client.callTool('get_system_object_definition', { objectType: 'Customer' });
-      const singleData = JSON.parse(singleResult.content[0].text);
-      
-      // Bulk object definitions (for context)
-      const allResult = await client.callTool('get_system_object_definitions', {});
-      const allData = JSON.parse(allResult.content[0].text);
-      
-      // Validate integration consistency
-      assert.equal(singleData.object_type, 'Customer', 'Should access Customer directly');
-      assert.ok(Array.isArray(allData.data), 'Bulk tool should return array');
-      
-      // Find Customer in bulk results if present (pagination may affect this)
-      const customerFromAll = allData.data.find(obj => obj.object_type === 'Customer');
-      if (customerFromAll) {
-        assert.equal(singleData.object_type, customerFromAll.object_type, 
-          'Object type should match between single and bulk operations');
-      }
-    });
-  });
-
-  // ==================================================================================
-  // HELPER FUNCTIONS
-  // ==================================================================================
-
-  function assertValidObjectDefinition(data, objectType) {
-    assert.equal(data._type, 'object_type_definition', 'Should have correct type');
-    assert.equal(data.object_type, objectType, 'Should match requested object type');
-    assert.ok(data.display_name, 'Should have display name');
-    assert.ok(data.description, 'Should have description');
-    assert.ok(typeof data.attribute_definition_count === 'number', 'Should have attribute count');
-    assert.ok(typeof data.attribute_group_count === 'number', 'Should have group count');
-    assert.ok(typeof data.content_object === 'boolean', 'Should have content_object flag');
-    assert.ok(typeof data.queryable === 'boolean', 'Should have queryable flag');
-    assert.ok(typeof data.read_only === 'boolean', 'Should have read_only flag');
-  }
-
-  function validateLocalizationStructure(localizationObject, fieldName) {
-    assert.ok(localizationObject, `Should have ${fieldName}`);
-    assert.ok(typeof localizationObject === 'object', `${fieldName} should be object`);
-    assert.ok(localizationObject.default, `${fieldName} should have default value`);
-    
-    const locales = Object.keys(localizationObject);
-    assert.ok(locales.length >= 1, `${fieldName} should have at least default locale`);
-    
-    locales.forEach(locale => {
-      assert.ok(typeof localizationObject[locale] === 'string', 
-        `${fieldName}.${locale} should be string`);
-      assert.ok(localizationObject[locale].length > 0, 
-        `${fieldName}.${locale} should not be empty`);
-    });
-  }
-});
-
-// ==================================================================================
-// OPTIMIZATION NOTES
-// ==================================================================================
-// This programmatic test suite has been optimized for focused, essential testing.
-// 
-// OPTIMIZATIONS APPLIED:
-// - Consolidated tool discovery tests (2 tests → 1 comprehensive test)
-// - Streamlined business logic validation (3 tests → 2 focused tests)  
-// - Simplified multi-step workflows (3 tests → 2 essential workflows)
-// - Reduced stress testing iterations (10 → 5 iterations)
-// - Consolidated error handling patterns (3 tests → 2 comprehensive tests)
-// - Focused integration testing (3 tests → 2 targeted tests)
-// - Removed mock-data-specific assertions for resilience
-// - Reduced object type testing (5 objects → 3 core objects)
-// 
-// TOTAL REDUCTION: 14 tests → 9 focused tests
-// FOCUS: Tool functionality, critical workflows, error handling
-// RESILIENCE: Tests adapt to mock data changes
-// EFFICIENCY: Reduced API calls while maintaining comprehensive coverage
-// ==================================================================================