@onchaindb/sdk 0.4.0 → 0.4.2

package/src/query-sdk/tests/comprehensive.test.ts

@@ -0,0 +1,279 @@
+import { QueryBuilder, FieldConditionBuilder, LogicalOperator, createQueryResult } from '../index';
+import { MockHttpClient, createMockResponse } from './setup';
+
+describe('Comprehensive SDK Integration Tests', () => {
+  let mockClient: MockHttpClient;
+  let queryBuilder: QueryBuilder;
+
+  beforeEach(() => {
+    mockClient = new MockHttpClient();
+    queryBuilder = new QueryBuilder(mockClient, 'http://localhost:3000', 'testApp');
+  });
+
+  afterEach(() => {
+    mockClient.clear();
+  });
+
+  describe('Complete query building workflow', () => {
+    test('should build complex nested query with dot notation', () => {
+      const rawQuery = queryBuilder
+        .collection('users')
+        .whereField('user.profile.bio').contains('Developer')
+        .limit(10)
+        .selectFields(['id', 'name'])
+        .buildRawQuery();
+
+      expect(rawQuery.find).toEqual({
+        user: {
+          profile: {
+            bio: {
+              includes: 'Developer'
+            }
+          }
+        }
+      });
+
+      expect(rawQuery.limit).toBe(10);
+      expect(rawQuery.select).toEqual({ fields: ['id', 'name'] });
+    });
+
+    test('should handle deep nesting scenarios', () => {
+      const deepCondition = new FieldConditionBuilder('user.profile.settings.preferences.theme').equals('dark');
+      const logicalOp = LogicalOperator.Condition(deepCondition);
+      const composable = logicalOp.toComposable();
+
+      const expected = {
+        user: {
+          profile: {
+            settings: {
+              preferences: {
+                theme: {
+                  is: 'dark'
+                }
+              }
+            }
+          }
+        }
+      };
+
+      expect(composable).toEqual(expected);
+    });
+
+    test('should execute full workflow with mock client', async () => {
+      const mockData = [
+        { id: 1, name: 'John Doe', user: { profile: { bio: 'Developer' } } },
+        { id: 2, name: 'Jane Smith', user: { profile: { bio: 'Designer' } } }
+      ];
+
+      mockClient.setResponse('/list', createMockResponse(mockData));
+
+      const response = await queryBuilder
+        .collection('users')
+        .whereField('user.profile.bio').contains('Developer')
+        .limit(10)
+        .selectFields(['id', 'name'])
+        .execute();
+
+      expect(response.records).toEqual(mockData);
+      expect(response.total).toBe(2);
+    });
+  });
+
+  describe('QueryResult advanced operations', () => {
+    test('should perform complex join operations', () => {
+      const users = createQueryResult([
+        { id: 1, name: 'John', departmentId: 1 },
+        { id: 2, name: 'Jane', departmentId: 2 }
+      ]);
+
+      const departments = createQueryResult([
+        { id: 1, name: 'Engineering' },
+        { id: 2, name: 'Design' }
+      ]);
+
+      const joined = users.innerJoin(departments, 'departmentId', 'id');
+      expect(joined.length).toBe(2);
+      expect(joined[0].name).toBe('Engineering'); // Department name merged
+      expect(joined[1].name).toBe('Design');
+    });
+
+    test('should export to CSV with proper formatting', () => {
+      const users = createQueryResult([
+        { id: 1, name: 'John', age: 30, score: 95.5 },
+        { id: 2, name: 'Jane', age: 25, score: 87.2 },
+        { id: 3, name: 'Bob', age: 35, score: 92.8 }
+      ]);
+
+      const csv = users.toCsv();
+      const lines = csv.split('\n');
+      
+      expect(lines.length).toBe(4); // header + 3 data rows
+      expect(lines[0]).toContain('id');
+      expect(lines[0]).toContain('name');
+      expect(lines[0]).toContain('age');
+      expect(lines[0]).toContain('score');
+    });
+
+    test('should provide comprehensive numeric summaries', () => {
+      const testData = [
+        { id: 1, name: 'John', age: 30, score: 95.5 },
+        { id: 2, name: 'Jane', age: 25, score: 87.2 },
+        { id: 3, name: 'Bob', age: 35, score: 92.8 }
+      ];
+
+      const result = createQueryResult(testData);
+      const scoreSummary = result.summarizeNumeric('score');
+      
+      expect(scoreSummary).not.toBeNull();
+      expect(scoreSummary!.count).toBe(3);
+      expect(scoreSummary!.mean).toBeCloseTo((95.5 + 87.2 + 92.8) / 3, 2);
+      expect(scoreSummary!.min).toBe(87.2);
+      expect(scoreSummary!.max).toBe(95.5);
+    });
+
+    test('should handle sorting and filtering', () => {
+      const testData = [
+        { id: 1, name: 'John', age: 30 },
+        { id: 2, name: 'Jane', age: 25 },
+        { id: 3, name: 'Bob', age: 35 }
+      ];
+
+      const result = createQueryResult(testData);
+      
+      const sortedByAge = result.sortBy('age');
+      expect(sortedByAge[0].age).toBe(25);
+      expect(sortedByAge[2].age).toBe(35);
+
+      const filtered = result.filter(item => item.age > 30);
+      expect(filtered.length).toBe(1);
+      expect(filtered[0].name).toBe('Bob');
+
+      const grouped = result.groupBy('age');
+      expect(Object.keys(grouped).length).toBe(3);
+    });
+  });
+
+  describe('Error handling and validation', () => {
+    test('should handle empty QueryResult operations gracefully', () => {
+      const emptyResult = createQueryResult([]);
+      
+      expect(emptyResult.isEmpty()).toBe(true);
+      expect(emptyResult.first()).toBeUndefined();
+      expect(emptyResult.len()).toBe(0);
+      expect(emptyResult.summarizeNumeric('field')).toBeNull();
+    });
+
+    test('should validate QueryBuilder state', () => {
+      const emptyBuilder = new QueryBuilder();
+      expect(emptyBuilder.isValid()).toBe(false);
+
+      const builderWithCondition = new QueryBuilder()
+        .whereField('name').equals('test');
+      expect(builderWithCondition.isValid()).toBe(true);
+    });
+
+    test('should handle invalid field references', () => {
+      expect(() => {
+        const condition = new FieldConditionBuilder('').equals('test');
+        LogicalOperator.Condition(condition).toComposable();
+      }).not.toThrow();
+    });
+  });
+
+  describe('All operators comprehensive coverage', () => {
+    test('should support all field condition operators', () => {
+      const builder = new FieldConditionBuilder('test_field');
+
+      // Only test operators that actually exist in the Rust implementation
+      const operators = [
+        'equals', 'notEquals', 'greaterThan', 'lessThan', 'greaterThanOrEqual', 'lessThanOrEqual',
+        'contains', 'startsWith', 'endsWith', 'in', 'notIn', 'exists', 'notExists', 
+        'isNull', 'isNotNull', 'regExpMatches', 'includesCaseInsensitive', 
+        'startsWithCaseInsensitive', 'endsWithCaseInsensitive', 'between',
+        'isLocalIp', 'isExternalIp', 'b64', 'inDataset', 'inCountry', 'cidr',
+        'isTrue', 'isFalse'
+      ];
+
+      operators.forEach(op => {
+        expect(typeof (builder as any)[op]).toBe('function');
+      });
+    });
+
+    test('should create correct conditions for advanced operators', () => {
+      const builder = new FieldConditionBuilder('test_field');
+
+      // String operators
+      const regexCondition = builder.regExpMatches('^test.*');
+      expect(regexCondition.operator).toBe('regExpMatches');
+
+      const caseInsensitiveCondition = builder.includesCaseInsensitive('Test');
+      expect(caseInsensitiveCondition.operator).toBe('includesCaseInsensitive');
+
+      // IP operators
+      const ipBuilder = new FieldConditionBuilder('ip_address');
+      const ipLocalCondition = ipBuilder.isLocalIp();
+      expect(ipLocalCondition.operator).toBe('isLocalIp');
+      
+      const ipExternalCondition = ipBuilder.isExternalIp();
+      expect(ipExternalCondition.operator).toBe('isExternalIp');
+
+      // Misc operators
+      const b64Condition = builder.b64('dGVzdA==');
+      expect(b64Condition.operator).toBe('b64');
+      
+      const countryCondition = builder.inCountry('US');
+      expect(countryCondition.operator).toBe('inCountry');
+
+      const cidrCondition = builder.cidr('192.168.1.0/24');
+      expect(cidrCondition.operator).toBe('CIDR');
+
+      const datasetCondition = builder.inDataset('malware_ips');
+      expect(datasetCondition.operator).toBe('inDataset');
+
+      const betweenCondition = builder.between(5, 15);
+      expect(betweenCondition.operator).toBe('betweenOp');
+    });
+  });
+
+  describe('Performance and memory scenarios', () => {
+    test('should handle large datasets efficiently', () => {
+      const largeDataset = Array.from({ length: 1000 }, (_, i) => ({
+        id: i,
+        name: `User${i}`,
+        value: Math.random() * 100
+      }));
+
+      const result = createQueryResult(largeDataset);
+      expect(result.len()).toBe(1000);
+
+      const filtered = result.filter(item => item.value > 50);
+      expect(filtered.length).toBeGreaterThan(0);
+
+      const summary = result.summarizeNumeric('value');
+      expect(summary).not.toBeNull();
+      expect(summary!.count).toBe(1000);
+    });
+
+    test('should handle complex nested structures', () => {
+      const complexData = Array.from({ length: 100 }, (_, i) => ({
+        id: i,
+        user: {
+          profile: {
+            details: {
+              settings: {
+                preferences: {
+                  theme: i % 2 === 0 ? 'dark' : 'light'
+                }
+              }
+            }
+          }
+        }
+      }));
+
+      const result = createQueryResult(complexData);
+      const themes = result.pluck('user.profile.details.settings.preferences.theme');
+      expect(themes.filter(theme => theme === 'dark')).toHaveLength(50);
+      expect(themes.filter(theme => theme === 'light')).toHaveLength(50);
+    });
+  });
+});