sfcc-dev-mcp 1.0.19 → 1.0.21

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

@@ -1,875 +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_custom_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 all buffers to prevent leaking into next tests
-    client.clearAllBuffers();
-  });
-
-  // ============================================================================
-  // HELPER FUNCTIONS - Custom Assertion Helpers for SFCC-specific validation
-  // ============================================================================
-
-  /**
-   * Assert that a result is a valid MCP response
-   */
-  function assertValidMCPResponse(result, shouldBeError = false) {
-    assert.ok(result.content, 'Result should have content');
-    assert.ok(Array.isArray(result.content), 'Content should be array');
-    assert.equal(typeof result.isError, 'boolean', 'isError should be boolean');
-    assert.equal(result.isError, shouldBeError, `isError should be ${shouldBeError}`);
-  }
-
-  /**
-   * Assert that a result contains valid SFCC attribute definition search response
-   */
-  function assertValidAttributeSearchResponse(result) {
-    assertValidMCPResponse(result, false);
-    assert.equal(result.content[0].type, 'text');
-    
-    const responseData = JSON.parse(result.content[0].text);
-    assert.equal(responseData._type, 'object_attribute_definition_search_result');
-    assert.ok(typeof responseData.count === 'number', 'Should have count');
-    assert.ok(typeof responseData.total === 'number', 'Should have total');
-    assert.ok(Array.isArray(responseData.hits), 'Should have hits array');
-    assert.ok(responseData.query, 'Should have query object');
-    
-    return responseData;
-  }
-
-  /**
-   * Assert that an attribute definition has required SFCC fields
-   */
-  function assertValidAttributeDefinition(attribute) {
-    assert.equal(attribute._type, 'object_attribute_definition');
-    assert.ok(attribute.id, 'Attribute should have id');
-    assert.ok(attribute.value_type, 'Attribute should have value_type');
-    assert.ok(typeof attribute.mandatory === 'boolean', 'Attribute should have mandatory boolean');
-    assert.ok(typeof attribute.queryable === 'boolean', 'Attribute should have queryable boolean');
-    assert.ok(typeof attribute.system === 'boolean', 'Attribute should have system boolean');
-    assert.ok(attribute.creation_date, 'Attribute should have creation_date');
-    assert.ok(attribute.last_modified, 'Attribute should have last_modified');
-  }
-
-  /**
-   * Assert that error response contains expected SFCC error structure
-   */
-  function assertSFCCErrorResponse(result, errorType = null) {
-    assertValidMCPResponse(result, true);
-    
-    const errorText = result.content[0].text;
-    if (errorType) {
-      assert.ok(errorText.includes(errorType), `Error should contain ${errorType}`);
-    }
-    
-    // Check if it's a structured SFCC error (JSON format)
-    if (errorText.startsWith('Error: Request failed:')) {
-      const jsonMatch = errorText.match(/\{.*\}/s);
-      if (jsonMatch) {
-        const errorData = JSON.parse(jsonMatch[0]);
-        assert.ok(errorData.fault, 'SFCC error should have fault object');
-        assert.ok(errorData.fault.type, 'SFCC error should have fault type');
-        assert.ok(errorData.fault.message, 'SFCC error should have fault message');
-      }
-    }
-  }
-
-  // ============================================================================
-  // PROTOCOL COMPLIANCE TESTS
-  // ============================================================================
-
-  describe('Protocol Compliance', () => {
-    test('should complete MCP handshake successfully', async () => {
-      assert.ok(client.connected, 'Client should be connected after handshake');
-    });
-
-    test('should list search_custom_object_attribute_definitions in available tools', async () => {
-      const tools = await client.listTools();
-      assert.ok(Array.isArray(tools), 'Tools should be an array');
-      
-      const targetTool = tools.find(tool => tool.name === 'search_custom_object_attribute_definitions');
-      assert.ok(targetTool, 'search_custom_object_attribute_definitions should be available');
-      assert.ok(targetTool.description, 'Tool should have description');
-      assert.ok(targetTool.inputSchema, 'Tool should have input schema');
-      assert.equal(targetTool.inputSchema.type, 'object', 'Schema should be object type');
-      
-      // Validate required parameters
-      const requiredParams = targetTool.inputSchema.required || [];
-      assert.ok(requiredParams.includes('objectType'), 'objectType should be required');
-    });
-  });
-
-  // ============================================================================
-  // BASIC FUNCTIONALITY TESTS
-  // ============================================================================
-
-  describe('Basic Functionality', () => {
-    test('should search VersionHistory custom object attributes successfully', async () => {
-      const result = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          query: {
-            match_all_query: {}
-          },
-          start: 0,
-          count: 10
-        }
-      });
-
-      const responseData = assertValidAttributeSearchResponse(result);
-      assert.ok(responseData.hits.length > 0, 'Should return some attributes');
-      
-      // Validate each attribute definition
-      responseData.hits.forEach(attribute => {
-        assertValidAttributeDefinition(attribute);
-      });
-    });
-
-    test('should handle minimal parameters with default search', async () => {
-      const result = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory'
-      });
-
-      const responseData = assertValidAttributeSearchResponse(result);
-      assert.ok(responseData.hits.length > 0, 'Should return attributes with default search');
-      assert.equal(responseData.query.match_all_query._type, 'match_all_query');
-    });
-  });
-
-  // ============================================================================
-  // COMPLEX QUERY BUILDING AND FILTERING TESTS
-  // ============================================================================
-
-  describe('Complex Query Building', () => {
-    test('should execute text search queries correctly', async () => {
-      const result = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          query: {
-            text_query: {
-              fields: ['id', 'display_name'],
-              search_phrase: 'UUID'
-            }
-          },
-          start: 0,
-          count: 5
-        }
-      });
-
-      const responseData = assertValidAttributeSearchResponse(result);
-      
-      // Should find UUID attribute
-      const uuidAttribute = responseData.hits.find(attr => attr.id === 'UUID');
-      if (uuidAttribute) {
-        assertValidAttributeDefinition(uuidAttribute);
-        assert.equal(uuidAttribute.value_type, 'string');
-        assert.equal(uuidAttribute.system, true);
-      }
-    });
-
-    test('should handle complex boolean queries with multiple conditions', async () => {
-      const result = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          query: {
-            bool_query: {
-              must: [
-                {
-                  term_query: {
-                    fields: ['value_type'],
-                    operator: 'is',
-                    values: ['string']
-                  }
-                }
-              ],
-              should: [
-                {
-                  text_query: {
-                    fields: ['id'],
-                    search_phrase: 'user'
-                  }
-                },
-                {
-                  text_query: {
-                    fields: ['id'],
-                    search_phrase: 'locale'
-                  }
-                }
-              ]
-            }
-          }
-        }
-      });
-
-      const responseData = assertValidAttributeSearchResponse(result);
-      
-      // Check that we get attributes and can distinguish types
-      responseData.hits.forEach(attribute => {
-        assertValidAttributeDefinition(attribute);
-        assert.ok(['string', 'datetime', 'text', 'int', 'double', 'boolean'].includes(attribute.value_type), 
-                  `Attribute should have valid value_type, got: ${attribute.value_type}`);
-      });
-      
-      // Log type distribution for debugging
-      const stringAttrs = responseData.hits.filter(attr => attr.value_type === 'string').length;
-      const totalAttrs = responseData.hits.length;
-      console.log(`Found ${stringAttrs} string attributes out of ${totalAttrs} total attributes`);
-    });
-
-    test('should support pagination with different start and count values', async () => {
-      // Get first page
-      const firstPage = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          query: {
-            match_all_query: {}
-          },
-          start: 0,
-          count: 3
-        }
-      });
-
-      const firstPageData = assertValidAttributeSearchResponse(firstPage);
-      assert.ok(firstPageData.hits.length <= 3, 'First page should have max 3 results');
-
-      // Get second page
-      const secondPage = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          query: {
-            match_all_query: {}
-          },
-          start: 3,
-          count: 3
-        }
-      });
-
-      const secondPageData = assertValidAttributeSearchResponse(secondPage);
-      
-      // Verify pagination consistency
-      assert.equal(firstPageData.total, secondPageData.total, 'Total count should be consistent');
-      assert.equal(firstPageData.start, 0, 'First page start should be 0');
-      assert.equal(secondPageData.start, 3, 'Second page start should be 3');
-
-      // Ensure no overlap between pages
-      const firstPageIds = firstPageData.hits.map(attr => attr.id);
-      const secondPageIds = secondPageData.hits.map(attr => attr.id);
-      const overlap = firstPageIds.filter(id => secondPageIds.includes(id));
-      assert.equal(overlap.length, 0, 'Pages should not have overlapping results');
-    });
-
-    test('should apply sorting parameters correctly', async () => {
-      const result = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          query: {
-            match_all_query: {}
-          },
-          sorts: [
-            {
-              field: 'id',
-              sort_order: 'asc'
-            }
-          ],
-          count: 10
-        }
-      });
-
-      const responseData = assertValidAttributeSearchResponse(result);
-      
-      if (responseData.hits.length > 1) {
-        // Verify ascending sort order by id
-        for (let i = 1; i < responseData.hits.length; i++) {
-          const current = responseData.hits[i].id;
-          const previous = responseData.hits[i - 1].id;
-          assert.ok(current >= previous, `Results should be sorted ascending: ${previous} <= ${current}`);
-        }
-      }
-    });
-  });
-
-  // ============================================================================
-  // MULTI-STEP WORKFLOW TESTS
-  // ============================================================================
-
-  describe('Multi-Step Workflows', () => {
-    test('should support discovery and detailed analysis workflow', async () => {
-      // Step 1: Discover all custom objects first (this would typically use get_system_object_definitions)
-      // For this test, we'll use known custom objects from our mock
-      const knownCustomObjects = ['VersionHistory', 'CustomAPI', 'GlobalSettings'];
-      
-      const attributesByObjectType = new Map();
-      
-      // Step 2: For each custom object, get its attribute definitions
-      for (const objectType of knownCustomObjects) {
-        try {
-          const result = await client.callTool('search_custom_object_attribute_definitions', {
-            objectType: objectType,
-            searchRequest: {
-              query: {
-                match_all_query: {}
-              }
-            }
-          });
-          
-          if (!result.isError) {
-            const responseData = assertValidAttributeSearchResponse(result);
-            attributesByObjectType.set(objectType, responseData.hits);
-          }
-        } catch (error) {
-          // Some objects might not exist, continue with others
-          console.log(`Skipping ${objectType}: ${error.message}`);
-        }
-      }
-      
-      // Step 3: Analyze collected attributes for patterns
-      let totalAttributes = 0;
-      let systemAttributes = 0;
-      let mandatoryAttributes = 0;
-      const valueTypeDistribution = new Map();
-      
-      for (const [, attributes] of attributesByObjectType) {
-        totalAttributes += attributes.length;
-        
-        attributes.forEach(attr => {
-          if (attr.system) systemAttributes++;
-          if (attr.mandatory) mandatoryAttributes++;
-          
-          const valueType = attr.value_type;
-          valueTypeDistribution.set(valueType, (valueTypeDistribution.get(valueType) || 0) + 1);
-        });
-      }
-      
-      // Step 4: Validate analysis results
-      assert.ok(totalAttributes > 0, 'Should have found some attributes');
-      assert.ok(systemAttributes > 0, 'Should have some system attributes');
-      assert.ok(valueTypeDistribution.has('string'), 'Should have string type attributes');
-      
-      console.log(`Analysis complete: ${totalAttributes} total attributes across ${attributesByObjectType.size} objects`);
-      console.log(`System attributes: ${systemAttributes}, Mandatory: ${mandatoryAttributes}`);
-      console.log('Value type distribution:', Object.fromEntries(valueTypeDistribution));
-    });
-
-    test('should support attribute comparison across different custom objects', async () => {
-      const comparisonResults = [];
-      const objectTypes = ['VersionHistory', 'CustomAPI'];
-      
-      // Collect attributes for each object type
-      for (const objectType of objectTypes) {
-        try {
-          const result = await client.callTool('search_custom_object_attribute_definitions', {
-            objectType: objectType,
-            searchRequest: {
-              query: {
-                match_all_query: {}
-              }
-            }
-          });
-          
-          if (!result.isError) {
-            const responseData = assertValidAttributeSearchResponse(result);
-            comparisonResults.push({
-              objectType,
-              attributes: responseData.hits,
-              count: responseData.total
-            });
-          }
-        } catch {
-          // Continue with available objects
-        }
-      }
-      
-      assert.ok(comparisonResults.length >= 1, 'Should have results for at least one object type');
-      
-      // Compare common attributes across object types
-      if (comparisonResults.length > 1) {
-        const [first, second] = comparisonResults;
-        const firstIds = new Set(first.attributes.map(attr => attr.id));
-        const secondIds = new Set(second.attributes.map(attr => attr.id));
-        
-        const commonAttributes = [...firstIds].filter(id => secondIds.has(id));
-        console.log(`Common attributes between ${first.objectType} and ${second.objectType}:`, commonAttributes);
-        
-        // System attributes like 'ID', 'UUID' should be common
-        assert.ok(commonAttributes.includes('ID'), 'ID should be common across custom objects');
-      }
-    });
-  });
-
-  // ============================================================================
-  // ERROR RECOVERY AND RESILIENCE TESTS
-  // ============================================================================
-
-  describe('Error Recovery and Resilience', () => {
-    test('should handle unknown custom object types gracefully', async () => {
-      const result = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'NonExistentCustomObject',
-        searchRequest: {
-          query: {
-            match_all_query: {}
-          }
-        }
-      });
-
-      assertSFCCErrorResponse(result, 'ObjectTypeNotFoundException');
-    });
-
-    test('should recover from invalid queries and continue working', async () => {
-      // Try invalid query structure
-      const invalidResult = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          invalidStructure: 'badData'
-        }
-      });
-
-      assertSFCCErrorResponse(invalidResult, 'PropertyConstraintViolationException');
-
-      // Verify system still works with valid query
-      const validResult = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          query: {
-            match_all_query: {}
-          }
-        }
-      });
-
-      assertValidAttributeSearchResponse(validResult);
-    });
-
-    test('should handle parameter validation errors consistently', async () => {
-      const testCases = [
-        { params: {}, expectedError: 'objectType' },
-        { params: { objectType: '' }, expectedError: 'objectType must be a non-empty string' },
-        { params: { objectType: null }, expectedError: 'objectType' },
-        { params: { objectType: 123 }, expectedError: 'objectType' }
-      ];
-
-      for (const testCase of testCases) {
-        const result = await client.callTool('search_custom_object_attribute_definitions', testCase.params);
-        assertValidMCPResponse(result, true);
-        assert.ok(
-          result.content[0].text.includes(testCase.expectedError),
-          `Should contain error message about ${testCase.expectedError}`
-        );
-      }
-    });
-
-    test('should maintain consistency across multiple rapid requests', async () => {
-      const results = [];
-      const requestCount = 5;
-      
-      // Execute multiple sequential requests (no Promise.all as per guidelines)
-      for (let i = 0; i < requestCount; i++) {
-        const result = await client.callTool('search_custom_object_attribute_definitions', {
-          objectType: 'VersionHistory',
-          searchRequest: {
-            query: {
-              match_all_query: {}
-            }
-          }
-        });
-        
-        assertValidAttributeSearchResponse(result);
-        results.push(JSON.parse(result.content[0].text));
-      }
-      
-      // Verify consistency across all requests
-      const firstResult = results[0];
-      for (let i = 1; i < results.length; i++) {
-        assert.equal(results[i].total, firstResult.total, 'Total count should be consistent');
-        assert.equal(results[i].count, firstResult.count, 'Result count should be consistent');
-        assert.deepEqual(results[i].hits, firstResult.hits, 'Results should be identical');
-      }
-    });
-  });
-
-  // ============================================================================
-  // DYNAMIC VALIDATION AND BUSINESS LOGIC TESTS
-  // ============================================================================
-
-  describe('Dynamic Validation and Business Logic', () => {
-    test('should validate SFCC attribute definition constraints', async () => {
-      const result = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          query: {
-            match_all_query: {}
-          }
-        }
-      });
-
-      const responseData = assertValidAttributeSearchResponse(result);
-      
-      // Validate SFCC business rules
-      responseData.hits.forEach(attribute => {
-        assertValidAttributeDefinition(attribute);
-        
-        // Key attributes should be mandatory
-        if (attribute.key) {
-          assert.equal(attribute.mandatory, true, 'Key attributes should be mandatory');
-        }
-        
-        // System attributes should be read-only
-        if (attribute.system) {
-          assert.equal(attribute.read_only, true, 'System attributes should be read-only');
-        }
-        
-        // Validate effective_id patterns
-        if (attribute.id !== 'ID' && attribute.id !== 'UUID' && !attribute.system) {
-          assert.ok(
-            attribute.effective_id.startsWith('c_'),
-            `Custom attribute ${attribute.id} should have effective_id starting with c_`
-          );
-        }
-        
-        // Validate value types
-        const validValueTypes = ['string', 'number', 'boolean', 'datetime', 'date', 'text', 'email', 'password'];
-        assert.ok(
-          validValueTypes.includes(attribute.value_type),
-          `${attribute.value_type} should be a valid SFCC value type`
-        );
-        
-        // String attributes with field_length should be reasonable
-        if (attribute.value_type === 'string' && attribute.field_length) {
-          assert.ok(
-            attribute.field_length > 0 && attribute.field_length <= 4000,
-            'String field length should be reasonable'
-          );
-        }
-      });
-    });
-
-    test('should analyze attribute relationships and dependencies', async () => {
-      const result = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          query: {
-            match_all_query: {}
-          }
-        }
-      });
-
-      const responseData = assertValidAttributeSearchResponse(result);
-      
-      // Analyze attribute patterns
-      const analysis = {
-        totalAttributes: responseData.hits.length,
-        systemAttributes: responseData.hits.filter(attr => attr.system).length,
-        customAttributes: responseData.hits.filter(attr => !attr.system).length,
-        mandatoryAttributes: responseData.hits.filter(attr => attr.mandatory).length,
-        queryableAttributes: responseData.hits.filter(attr => attr.queryable).length,
-        searchableAttributes: responseData.hits.filter(attr => attr.searchable).length,
-        localizableAttributes: responseData.hits.filter(attr => attr.localizable).length
-      };
-      
-      // Validate basic patterns for custom object attributes
-      assert.ok(analysis.totalAttributes > 0, 'Should have some attributes');
-      
-      // Log actual attribute names for debugging
-      const attributeNames = responseData.hits.map(attr => attr.id);
-      console.log(`Found attributes: ${attributeNames.join(', ')}`);
-      
-      // Check for common SFCC patterns (flexible validation based on actual mock data)
-      const hasIdAttribute = responseData.hits.some(attr => attr.id === 'ID' || attr.id.toLowerCase().includes('id'));
-      const hasDateAttributes = responseData.hits.some(attr => attr.value_type === 'datetime');
-      
-      if (hasIdAttribute) {
-        console.log('✓ Found ID-related attributes');
-      }
-      if (hasDateAttributes) {
-        console.log('✓ Found datetime attributes');
-      }
-      
-      // System attributes should be a subset of mandatory and queryable (if any exist)
-      const systemAttrs = responseData.hits.filter(attr => attr.system);
-      if (systemAttrs.length > 0) {
-        const mandatorySystemAttrs = systemAttrs.filter(attr => attr.mandatory);
-        assert.ok(mandatorySystemAttrs.length >= 0, 'System attributes should have consistent mandatory status');
-      }
-      
-      console.log('Attribute analysis for VersionHistory:', analysis);
-    });
-
-    test('should validate search query effectiveness', async () => {
-      // Test different query types and compare effectiveness
-      const queryTests = [
-        {
-          name: 'match_all',
-          query: { match_all_query: {} }
-        },
-        {
-          name: 'text_search_id',
-          query: {
-            text_query: {
-              fields: ['id'],
-              search_phrase: 'component'
-            }
-          }
-        },
-        {
-          name: 'term_search_string_type',
-          query: {
-            term_query: {
-              fields: ['value_type'],
-              operator: 'is',
-              values: ['string']
-            }
-          }
-        }
-      ];
-      
-      const queryResults = [];
-      
-      for (const queryTest of queryTests) {
-        const result = await client.callTool('search_custom_object_attribute_definitions', {
-          objectType: 'VersionHistory',
-          searchRequest: {
-            query: queryTest.query
-          }
-        });
-        
-        if (!result.isError) {
-          const responseData = assertValidAttributeSearchResponse(result);
-          queryResults.push({
-            name: queryTest.name,
-            resultCount: responseData.count,
-            totalCount: responseData.total
-          });
-        }
-      }
-      
-      assert.ok(queryResults.length > 0, 'Should have successful query results');
-      
-      // match_all should return the most results
-      const matchAllResult = queryResults.find(r => r.name === 'match_all');
-      if (matchAllResult) {
-        queryResults.forEach(result => {
-          if (result.name !== 'match_all') {
-            assert.ok(
-              result.resultCount <= matchAllResult.resultCount,
-              `${result.name} should return <= results than match_all`
-            );
-          }
-        });
-      }
-      
-      console.log('Query effectiveness results:', queryResults);
-    });
-  });
-
-  // ============================================================================
-  // EDGE CASES AND BOUNDARY CONDITIONS
-  // ============================================================================
-
-  describe('Edge Cases and Boundary Conditions', () => {
-    test('should handle empty search results gracefully', async () => {
-      const result = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          query: {
-            text_query: {
-              fields: ['id'],
-              search_phrase: 'NonExistentAttributeName'
-            }
-          }
-        }
-      });
-
-      const responseData = assertValidAttributeSearchResponse(result);
-      
-      // Mock server may not implement proper filtering, so we need flexible validation
-      console.log(`Search for non-existent attribute returned ${responseData.count} results`);
-      
-      if (responseData.count === 0) {
-        // Ideal behavior - search properly filters
-        assert.equal(responseData.hits.length, 0, 'Hits array should be empty');
-        assert.equal(responseData.total, 0, 'Total should be 0');
-        console.log('✓ Mock server properly filters non-existent attributes');
-      } else {
-        // Mock server returns all results regardless of filter
-        console.log('⚠ Mock server does not filter search results - this is acceptable for testing');
-        assert.ok(responseData.hits.length >= 0, 'Should return valid hits array');
-        assert.ok(responseData.total >= 0, 'Should return valid total count');
-      }
-    });
-
-    test('should handle large count parameters appropriately', async () => {
-      const result = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          query: {
-            match_all_query: {}
-          },
-          count: 1000 // Large count
-        }
-      });
-
-      const responseData = assertValidAttributeSearchResponse(result);
-      // Should either return all available attributes or handle large count gracefully
-      assert.ok(responseData.count <= responseData.total, 'Count should not exceed total');
-      assert.ok(responseData.hits.length <= 1000, 'Should not return more than requested');
-    });
-
-    test('should handle extreme pagination boundaries', async () => {
-      // First, get total count
-      const countResult = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          query: {
-            match_all_query: {}
-          },
-          count: 1
-        }
-      });
-
-      const countData = assertValidAttributeSearchResponse(countResult);
-      const totalCount = countData.total;
-
-      if (totalCount > 1) {
-        // Test pagination beyond available results
-        const beyondResult = await client.callTool('search_custom_object_attribute_definitions', {
-          objectType: 'VersionHistory',
-          searchRequest: {
-            query: {
-              match_all_query: {}
-            },
-            start: totalCount + 10,
-            count: 5
-          }
-        });
-
-        const beyondData = assertValidAttributeSearchResponse(beyondResult);
-        assert.equal(beyondData.count, 0, 'Should return 0 results when start > total');
-        assert.equal(beyondData.hits.length, 0, 'Should have empty hits array');
-      }
-    });
-
-    test('should handle special characters in object type names', async () => {
-      // Test with object type that might have special characters (if any exist in mock)
-      const specialCases = ['Version-History', 'Version_History', 'version history'];
-      
-      for (const objectType of specialCases) {
-        const result = await client.callTool('search_custom_object_attribute_definitions', {
-          objectType: objectType,
-          searchRequest: {
-            query: {
-              match_all_query: {}
-            }
-          }
-        });
-        
-        // These should typically fail with ObjectTypeNotFoundException
-        if (result.isError) {
-          assertSFCCErrorResponse(result, 'ObjectTypeNotFoundException');
-        }
-      }
-    });
-
-    test('should validate property selector functionality', async () => {
-      const result = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          query: {
-            match_all_query: {}
-          },
-          select: '(id,value_type,mandatory)' // Limited property selection
-        }
-      });
-
-      // Note: Property selector might not be fully implemented in mock,
-      // but should not cause errors
-      assertValidAttributeSearchResponse(result);
-    });
-  });
-
-  // ============================================================================
-  // INTEGRATION AND FUNCTIONAL MONITORING
-  // ============================================================================
-
-  describe('Integration and Functional Monitoring', () => {
-    test('should maintain response time consistency', async () => {
-      const responseTimes = [];
-      const iterations = 3;
-      
-      for (let i = 0; i < iterations; i++) {
-        const startTime = Date.now();
-        
-        const result = await client.callTool('search_custom_object_attribute_definitions', {
-          objectType: 'VersionHistory',
-          searchRequest: {
-            query: {
-              match_all_query: {}
-            }
-          }
-        });
-        
-        const endTime = Date.now();
-        const responseTime = endTime - startTime;
-        
-        assertValidAttributeSearchResponse(result);
-        responseTimes.push(responseTime);
-      }
-      
-      // Calculate response time statistics (functional monitoring)
-      const avgResponseTime = responseTimes.reduce((a, b) => a + b, 0) / responseTimes.length;
-      const maxResponseTime = Math.max(...responseTimes);
-      const minResponseTime = Math.min(...responseTimes);
-      
-      console.log(`Response time stats: avg=${avgResponseTime}ms, min=${minResponseTime}ms, max=${maxResponseTime}ms`);
-      
-      // Functional validation rather than strict performance requirements
-      assert.ok(avgResponseTime > 0, 'Should have measurable response time');
-      assert.ok(maxResponseTime < 10000, 'Should complete within reasonable time (10s)');
-    });
-
-    test('should validate complete tool lifecycle', async () => {
-      // Full lifecycle test: discovery -> parameter validation -> execution -> analysis
-      
-      // 1. Tool discovery
-      const tools = await client.listTools();
-      const targetTool = tools.find(tool => tool.name === 'search_custom_object_attribute_definitions');
-      assert.ok(targetTool, 'Tool should be discoverable');
-      
-      // 2. Parameter validation (schema-based)
-      const schema = targetTool.inputSchema;
-      assert.ok(schema.properties.objectType, 'Should have objectType parameter');
-      assert.ok(schema.properties.searchRequest, 'Should have searchRequest parameter');
-      
-      // 3. Successful execution
-      const successResult = await client.callTool('search_custom_object_attribute_definitions', {
-        objectType: 'VersionHistory',
-        searchRequest: {
-          query: {
-            match_all_query: {}
-          }
-        }
-      });
-      
-      const responseData = assertValidAttributeSearchResponse(successResult);
-      
-      // 4. Response analysis and validation
-      assert.ok(responseData.hits.every(attr => attr._type === 'object_attribute_definition'));
-      assert.ok(responseData.query.match_all_query._type === 'match_all_query');
-      assert.equal(responseData.start, 0);
-      assert.ok(responseData.total >= responseData.count);
-      
-      console.log(`Lifecycle test complete: Found ${responseData.total} attributes for VersionHistory`);
-    });
-  });
-});