@onchaindb/sdk 0.4.0 → 0.4.2

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

@@ -0,0 +1,464 @@
+import { createQueryResult, QueryResult } from '../QueryResult';
+
+describe('QueryResult', () => {
+  const testData = [
+    { id: 1, name: 'Alice', age: 30, department: 'Engineering', salary: 75000, active: true },
+    { id: 2, name: 'Bob', age: 25, department: 'Design', salary: 65000, active: true },
+    { id: 3, name: 'Carol', age: 35, department: 'Engineering', salary: 85000, active: false },
+    { id: 4, name: 'David', age: 28, department: 'Marketing', salary: 55000, active: true },
+    { id: 5, name: 'Eve', age: 32, department: 'Engineering', salary: 95000, active: true }
+  ];
+
+  let result: QueryResult<any>;
+
+  beforeEach(() => {
+    result = createQueryResult(testData);
+  });
+
+  describe('Basic operations', () => {
+    test('should return correct length', () => {
+      expect(result.len()).toBe(5);
+      expect(result.length()).toBe(5);
+    });
+
+    test('should identify empty results', () => {
+      const emptyResult = createQueryResult([]);
+      expect(emptyResult.isEmpty()).toBe(true);
+      expect(result.isEmpty()).toBe(false);
+    });
+
+    test('should return first and last items', () => {
+      expect(result.first()?.name).toBe('Alice');
+      expect(result.last()?.name).toBe('Eve');
+    });
+
+    test('should get item by index', () => {
+      expect(result.get(0)?.name).toBe('Alice');
+      expect(result.get(2)?.name).toBe('Carol');
+      expect(result.get(10)).toBeUndefined();
+    });
+
+    test('should handle single item input', () => {
+      const singleResult = createQueryResult({ id: 1, name: 'Test' } as any);
+      expect(singleResult.len()).toBe(1);
+      expect(singleResult.first()?.name).toBe('Test');
+    });
+  });
+
+  describe('Iteration methods', () => {
+    test('any should work correctly', () => {
+      expect(result.any(item => item.age > 30)).toBe(true);
+      expect(result.any(item => item.age > 100)).toBe(false);
+    });
+
+    test('all should work correctly', () => {
+      expect(result.all(item => item.id > 0)).toBe(true);
+      expect(result.all(item => item.active)).toBe(false);
+    });
+
+    test('find should return correct item', () => {
+      const found = result.find(item => item.name === 'Carol');
+      expect(found?.id).toBe(3);
+      expect(result.find(item => item.name === 'Unknown')).toBeUndefined();
+    });
+
+    test('filter should return correct items', () => {
+      const activeUsers = result.filter(item => item.active);
+      expect(activeUsers).toHaveLength(4);
+      
+      const engineers = result.filter(item => item.department === 'Engineering');
+      expect(engineers).toHaveLength(3);
+    });
+
+    test('map should transform items correctly', () => {
+      const names = result.map(item => item.name);
+      expect(names).toEqual(['Alice', 'Bob', 'Carol', 'David', 'Eve']);
+      
+      const ages = result.map(item => item.age);
+      expect(ages).toEqual([30, 25, 35, 28, 32]);
+    });
+
+    test('forEach should iterate over all items', () => {
+      const mockCallback = jest.fn();
+      result.forEach(mockCallback);
+      expect(mockCallback).toHaveBeenCalledTimes(5);
+    });
+
+    test('reduce should accumulate correctly', () => {
+      const totalAge = result.reduce((sum, item) => sum + item.age, 0);
+      expect(totalAge).toBe(150);
+      
+      const nameList = result.reduce((names, item) => names + item.name + ',', '');
+      expect(nameList).toBe('Alice,Bob,Carol,David,Eve,');
+    });
+  });
+
+  describe('Data extraction', () => {
+    test('pluck should extract field values', () => {
+      const names = result.pluck('name');
+      expect(names).toEqual(['Alice', 'Bob', 'Carol', 'David', 'Eve']);
+      
+      const ages = result.pluck('age');
+      expect(ages).toEqual([30, 25, 35, 28, 32]);
+    });
+
+    test('pluckStrings should extract and convert to strings', () => {
+      const ageStrings = result.pluckStrings('age');
+      expect(ageStrings).toEqual(['30', '25', '35', '28', '32']);
+      
+      const names = result.pluckStrings('name');
+      expect(names).toEqual(['Alice', 'Bob', 'Carol', 'David', 'Eve']);
+    });
+
+    test('pluckNumbers should extract and convert to numbers', () => {
+      const ages = result.pluckNumbers('age');
+      expect(ages).toEqual([30, 25, 35, 28, 32]);
+      
+      const salaries = result.pluckNumbers('salary');
+      expect(salaries).toEqual([75000, 65000, 85000, 55000, 95000]);
+    });
+
+    test('pluckNumbers should handle non-numeric values', () => {
+      const testDataWithNulls = [
+        { id: 1, score: 85 },
+        { id: 2, score: null },
+        { id: 3, score: '90' },
+        { id: 4, score: 'invalid' }
+      ];
+      
+      const resultWithNulls = createQueryResult(testDataWithNulls);
+      const scores = resultWithNulls.pluckNumbers('score');
+      expect(scores).toEqual([85, null, 90, null]);
+    });
+  });
+
+  describe('Numeric summary', () => {
+    test('should calculate numeric summary correctly', () => {
+      const ageSummary = result.summarizeNumeric('age');
+      
+      expect(ageSummary).not.toBeNull();
+      expect(ageSummary!.count).toBe(5);
+      expect(ageSummary!.sum).toBe(150);
+      expect(ageSummary!.mean).toBe(30);
+      expect(ageSummary!.min).toBe(25);
+      expect(ageSummary!.max).toBe(35);
+    });
+
+    test('should calculate median correctly', () => {
+      const ageSummary = result.summarizeNumeric('age');
+      expect(ageSummary!.median).toBe(30); // [25, 28, 30, 32, 35]
+    });
+
+    test('should calculate standard deviation correctly', () => {
+      const ageSummary = result.summarizeNumeric('age');
+      expect(ageSummary!.standardDeviation).toBeCloseTo(3.74, 2);
+    });
+
+    test('should return null for non-numeric fields', () => {
+      const nameSummary = result.summarizeNumeric('name');
+      expect(nameSummary).toBeNull();
+    });
+
+    test('should handle empty data', () => {
+      const emptyResult = createQueryResult([]);
+      const summary = emptyResult.summarizeNumeric('age');
+      expect(summary).toBeNull();
+    });
+  });
+
+  describe('Grouping and aggregation', () => {
+    test('groupBy should group items correctly', () => {
+      const byDepartment = result.groupBy('department');
+      
+      expect(byDepartment['Engineering']).toHaveLength(3);
+      expect(byDepartment['Design']).toHaveLength(1);
+      expect(byDepartment['Marketing']).toHaveLength(1);
+    });
+
+    test('countBy should count values correctly', () => {
+      const departmentCounts = result.countBy('department');
+      
+      expect(departmentCounts['Engineering']).toBe(3);
+      expect(departmentCounts['Design']).toBe(1);
+      expect(departmentCounts['Marketing']).toBe(1);
+    });
+
+    test('count with predicate should work correctly', () => {
+      const activeCount = result.count(item => item.active);
+      expect(activeCount).toBe(4);
+      
+      const engineerCount = result.count(item => item.department === 'Engineering');
+      expect(engineerCount).toBe(3);
+    });
+
+    test('count without predicate should return total count', () => {
+      expect(result.count()).toBe(5);
+    });
+  });
+
+  describe('Sorting', () => {
+    test('sortBy should sort correctly', () => {
+      const sortedByAge = result.sortBy('age');
+      const ages = sortedByAge.map(item => item.age);
+      expect(ages).toEqual([25, 28, 30, 32, 35]);
+      
+      const sortedByName = result.sortBy('name');
+      const names = sortedByName.map(item => item.name);
+      expect(names).toEqual(['Alice', 'Bob', 'Carol', 'David', 'Eve']);
+    });
+
+    test('sortBy should handle descending order', () => {
+      const sortedByAgeDesc = result.sortBy('age', false);
+      const ages = sortedByAgeDesc.map(item => item.age);
+      expect(ages).toEqual([35, 32, 30, 28, 25]);
+    });
+
+    test('sortByMultiple should handle multiple sort fields', () => {
+      const sorted = result.sortByMultiple([
+        { field: 'department', ascending: true },
+        { field: 'salary', ascending: false }
+      ]);
+      
+      // Should sort by department first, then by salary descending
+      expect(sorted[0].department).toBe('Design');
+      expect(sorted[1].department).toBe('Engineering');
+      expect(sorted[1].salary).toBe(95000); // Highest paid engineer first
+    });
+
+    test('sortBy should handle null values', () => {
+      const dataWithNulls = [
+        { id: 1, score: 10 },
+        { id: 2, score: null },
+        { id: 3, score: 5 }
+      ];
+      
+      const resultWithNulls = createQueryResult(dataWithNulls);
+      const sorted = resultWithNulls.sortBy('score');
+      
+      // Null values should sort first in ascending order
+      expect(sorted[0].score).toBeNull();
+      expect(sorted[1].score).toBe(5);
+      expect(sorted[2].score).toBe(10);
+    });
+  });
+
+  describe('Pagination and chunking', () => {
+    test('paginate should return correct page', () => {
+      const page1 = result.paginate(1, 2);
+      expect(page1).toHaveLength(2);
+      expect(page1[0].name).toBe('Alice');
+      expect(page1[1].name).toBe('Bob');
+      
+      const page2 = result.paginate(2, 2);
+      expect(page2).toHaveLength(2);
+      expect(page2[0].name).toBe('Carol');
+      expect(page2[1].name).toBe('David');
+      
+      const page3 = result.paginate(3, 2);
+      expect(page3).toHaveLength(1);
+      expect(page3[0].name).toBe('Eve');
+    });
+
+    test('chunk should split data into chunks', () => {
+      const chunks = result.chunk(2);
+      expect(chunks).toHaveLength(3);
+      expect(chunks[0]).toHaveLength(2);
+      expect(chunks[1]).toHaveLength(2);
+      expect(chunks[2]).toHaveLength(1);
+      
+      expect(chunks[0][0].name).toBe('Alice');
+      expect(chunks[2][0].name).toBe('Eve');
+    });
+  });
+
+  describe('Distinct and unique', () => {
+    test('distinctBy should return unique values', () => {
+      const uniqueDepartments = result.distinctBy('department');
+      const departments = uniqueDepartments.map(item => item.department);
+      expect(departments).toEqual(['Engineering', 'Design', 'Marketing']);
+    });
+
+    test('unique should remove duplicates', () => {
+      const duplicateData = [1, 2, 2, 3, 3, 3, 4];
+      const duplicateResult = createQueryResult(duplicateData);
+      const unique = duplicateResult.unique();
+      expect(unique).toEqual([1, 2, 3, 4]);
+    });
+  });
+
+  describe('Joining', () => {
+    const departments = createQueryResult([
+      { id: 'Engineering', budget: 100000, manager: 'John' },
+      { id: 'Design', budget: 75000, manager: 'Jane' },
+      { id: 'Marketing', budget: 50000, manager: 'Mike' }
+    ]);
+
+    test('innerJoin should join matching records', () => {
+      const joined = result.innerJoin(departments, 'department', 'id');
+      
+      expect(joined).toHaveLength(5);
+      expect(joined[0].budget).toBe(100000); // Alice from Engineering
+      expect(joined[1].budget).toBe(75000);  // Bob from Design
+    });
+
+    test('leftJoin should include all left records', () => {
+      const leftJoined = result.leftJoin(departments, 'department', 'id');
+      
+      expect(leftJoined).toHaveLength(5);
+      // All original records should be present
+      expect(leftJoined.map(r => r.name)).toEqual(['Alice', 'Bob', 'Carol', 'David', 'Eve']);
+    });
+  });
+
+  describe('Export functions', () => {
+    test('toArray should return array copy', () => {
+      const array = result.toArray();
+      expect(Array.isArray(array)).toBe(true);
+      expect(array).toHaveLength(5);
+      expect(array[0]).toEqual(testData[0]);
+    });
+
+    test('toJSON should return JSON string', () => {
+      const json = result.toJSON();
+      const parsed = JSON.parse(json);
+      expect(parsed).toEqual(testData);
+    });
+
+    test('toCsv should generate CSV format', () => {
+      const csv = result.toCsv();
+      const lines = csv.split('\n');
+      
+      expect(lines.length).toBe(6); // Header + 5 data rows
+      expect(lines[0]).toContain('id,name,age,department,salary,active');
+      expect(lines[1]).toContain('1,Alice,30,Engineering,75000,true');
+    });
+
+    test('toCsv should handle custom delimiter', () => {
+      const tsv = result.toCsv('\t');
+      expect(tsv).toContain('\t');
+      expect(tsv.split('\n')[0]).toContain('id\tname\tage');
+    });
+
+    test('toCsv should escape values with delimiters', () => {
+      const dataWithCommas = [
+        { name: 'Smith, John', description: 'A person, who works' }
+      ];
+      const resultWithCommas = createQueryResult(dataWithCommas);
+      const csv = resultWithCommas.toCsv();
+      
+      expect(csv).toContain('"Smith, John"');
+      expect(csv).toContain('"A person, who works"');
+    });
+  });
+
+  describe('Nested field access', () => {
+    const nestedData = [
+      {
+        id: 1,
+        user: {
+          profile: {
+            name: 'Alice',
+            age: 30
+          },
+          settings: {
+            theme: 'dark'
+          }
+        }
+      },
+      {
+        id: 2,
+        user: {
+          profile: {
+            name: 'Bob',
+            age: 25
+          },
+          settings: {
+            theme: 'light'
+          }
+        }
+      }
+    ];
+
+    test('should handle nested field plucking', () => {
+      const nestedResult = createQueryResult(nestedData);
+      
+      const names = nestedResult.pluck('user.profile.name');
+      expect(names).toEqual(['Alice', 'Bob']);
+      
+      const ages = nestedResult.pluck('user.profile.age');
+      expect(ages).toEqual([30, 25]);
+    });
+
+    test('should handle nested field sorting', () => {
+      const nestedResult = createQueryResult(nestedData);
+      const sorted = nestedResult.sortBy('user.profile.age');
+      
+      expect(sorted[0].user.profile.name).toBe('Bob');
+      expect(sorted[1].user.profile.name).toBe('Alice');
+    });
+
+    test('should handle nested field grouping', () => {
+      const nestedResult = createQueryResult(nestedData);
+      const grouped = nestedResult.groupBy('user.settings.theme');
+      
+      expect(grouped['dark']).toHaveLength(1);
+      expect(grouped['light']).toHaveLength(1);
+    });
+
+    test('should handle missing nested fields gracefully', () => {
+      const dataWithMissing = [
+        { id: 1, user: { profile: { name: 'Alice' } } },
+        { id: 2, user: { name: 'Bob' } }, // Missing profile
+        { id: 3 } // Missing user entirely
+      ];
+      
+      const resultWithMissing = createQueryResult(dataWithMissing);
+      const names = resultWithMissing.pluck('user.profile.name');
+      
+      expect(names).toEqual(['Alice', undefined, undefined]);
+    });
+  });
+
+  describe('Type casting and transformation', () => {
+    test('cast should change type', () => {
+      const casted = result.cast<{ id: number; name: string }>();
+      expect(casted).toBeInstanceOf(QueryResult);
+      expect(casted.len()).toBe(5);
+    });
+  });
+
+  describe('Debugging and inspection', () => {
+    test('inspect should not throw error', () => {
+      // Mock console.log to prevent output during tests
+      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+      
+      result.inspect();
+      expect(consoleSpy).toHaveBeenCalled();
+      
+      result.inspect(2); // Limited output
+      expect(consoleSpy).toHaveBeenCalledTimes(2);
+      
+      consoleSpy.mockRestore();
+    });
+  });
+
+  describe('Edge cases', () => {
+    test('should handle empty arrays gracefully', () => {
+      const emptyResult = createQueryResult([]);
+      
+      expect(emptyResult.len()).toBe(0);
+      expect(emptyResult.isEmpty()).toBe(true);
+      expect(emptyResult.first()).toBeUndefined();
+      expect(emptyResult.summarizeNumeric('age')).toBeNull();
+      expect(emptyResult.groupBy('department')).toEqual({});
+    });
+
+    test('should handle invalid field names', () => {
+      const invalidSummary = result.summarizeNumeric('nonexistent');
+      expect(invalidSummary).toBeNull();
+      
+      const invalidPluck = result.pluck('nonexistent');
+      expect(invalidPluck.every(val => val === undefined)).toBe(true);
+    });
+  });
+});