p-elements-core 1.2.32-rc1 → 1.2.32-rc11

package/src/maquette/mapping.test.ts

@@ -0,0 +1,294 @@
+/**
+ * Tests for Maquette mapping module
+ */
+
+import { describe, it, expect } from 'vitest';
+import { createMapping } from './mapping.js';
+
+describe('Maquette mapping', () => {
+  describe('createMapping', () => {
+    interface TestSource {
+      id: number;
+      name: string;
+    }
+
+    interface TestTarget {
+      sourceId: number;
+      displayName: string;
+    }
+
+    it('should create a mapping instance', () => {
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => ({ sourceId: source.id, displayName: source.name }),
+        (source, target) => {
+          target.displayName = source.name;
+        }
+      );
+
+      expect(mapping).toBeDefined();
+      expect(mapping.results).toBeDefined();
+      expect(mapping.map).toBeDefined();
+      expect(Array.isArray(mapping.results)).toBe(true);
+    });
+
+    it('should create initial results from sources', () => {
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => ({ sourceId: source.id, displayName: source.name }),
+        (source, target) => {
+          target.displayName = source.name;
+        }
+      );
+
+      const sources = [
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ];
+
+      mapping.map(sources);
+
+      expect(mapping.results.length).toBe(3);
+      expect(mapping.results[0].sourceId).toBe(1);
+      expect(mapping.results[0].displayName).toBe('Alice');
+      expect(mapping.results[1].sourceId).toBe(2);
+      expect(mapping.results[2].sourceId).toBe(3);
+    });
+
+    it('should update existing results when sources change', () => {
+      let createCount = 0;
+      let updateCount = 0;
+
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => {
+          createCount++;
+          return { sourceId: source.id, displayName: source.name };
+        },
+        (source, target) => {
+          updateCount++;
+          target.displayName = source.name;
+        }
+      );
+
+      // Initial mapping
+      mapping.map([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+      ]);
+
+      expect(createCount).toBe(2);
+      expect(updateCount).toBe(0);
+
+      // Update with same keys but different names
+      mapping.map([
+        { id: 1, name: 'Alice Updated' },
+        { id: 2, name: 'Bob Updated' },
+      ]);
+
+      expect(createCount).toBe(2); // No new creates
+      expect(updateCount).toBe(2); // Both updated
+      expect(mapping.results[0].displayName).toBe('Alice Updated');
+      expect(mapping.results[1].displayName).toBe('Bob Updated');
+    });
+
+    it('should add new items', () => {
+      let createCount = 0;
+
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => {
+          createCount++;
+          return { sourceId: source.id, displayName: source.name };
+        },
+        (source, target) => {
+          target.displayName = source.name;
+        }
+      );
+
+      mapping.map([{ id: 1, name: 'Alice' }]);
+      expect(createCount).toBe(1);
+
+      mapping.map([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ]);
+
+      expect(createCount).toBe(3);
+      expect(mapping.results.length).toBe(3);
+      expect(mapping.results[2].sourceId).toBe(3);
+    });
+
+    it('should remove items', () => {
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => ({ sourceId: source.id, displayName: source.name }),
+        (source, target) => {
+          target.displayName = source.name;
+        }
+      );
+
+      mapping.map([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ]);
+
+      expect(mapping.results.length).toBe(3);
+
+      mapping.map([{ id: 2, name: 'Bob' }]);
+
+      expect(mapping.results.length).toBe(1);
+      expect(mapping.results[0].sourceId).toBe(2);
+    });
+
+    it('should handle reordering of items', () => {
+      let createCount = 0;
+      let updateCount = 0;
+
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => {
+          createCount++;
+          return { sourceId: source.id, displayName: source.name };
+        },
+        (source, target) => {
+          updateCount++;
+          target.displayName = source.name;
+        }
+      );
+
+      mapping.map([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ]);
+
+      const originalResults = [...mapping.results];
+
+      // Reverse order
+      mapping.map([
+        { id: 3, name: 'Charlie' },
+        { id: 2, name: 'Bob' },
+        { id: 1, name: 'Alice' },
+      ]);
+
+      // Should reuse existing results, not create new ones
+      expect(createCount).toBe(3);
+      expect(mapping.results.length).toBe(3);
+      expect(mapping.results[0].sourceId).toBe(3);
+      expect(mapping.results[1].sourceId).toBe(2);
+      expect(mapping.results[2].sourceId).toBe(1);
+      
+      // Results should be reordered, not recreated
+      expect(mapping.results[0]).toBe(originalResults[2]);
+      expect(mapping.results[1]).toBe(originalResults[1]);
+      expect(mapping.results[2]).toBe(originalResults[0]);
+    });
+
+    it('should handle mixed add, remove, reorder operations', () => {
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => ({ sourceId: source.id, displayName: source.name }),
+        (source, target) => {
+          target.displayName = source.name;
+        }
+      );
+
+      mapping.map([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ]);
+
+      mapping.map([
+        { id: 4, name: 'David' },  // New
+        { id: 2, name: 'Bob' },     // Existing, reordered
+        { id: 5, name: 'Eve' },     // New
+      ]);
+
+      expect(mapping.results.length).toBe(3);
+      expect(mapping.results[0].sourceId).toBe(4);
+      expect(mapping.results[1].sourceId).toBe(2);
+      expect(mapping.results[2].sourceId).toBe(5);
+    });
+
+    it('should handle string keys', () => {
+      interface StringKeySource {
+        key: string;
+        value: number;
+      }
+
+      const mapping = createMapping<StringKeySource, { val: number }>(
+        (source) => source.key,
+        (source) => ({ val: source.value }),
+        (source, target) => {
+          target.val = source.value;
+        }
+      );
+
+      mapping.map([
+        { key: 'a', value: 1 },
+        { key: 'b', value: 2 },
+      ]);
+
+      expect(mapping.results.length).toBe(2);
+      expect(mapping.results[0].val).toBe(1);
+      expect(mapping.results[1].val).toBe(2);
+    });
+
+    it('should pass correct index to createResult and updateResult', () => {
+      const createdIndexes: number[] = [];
+      const updatedIndexes: number[] = [];
+
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source, index) => {
+          createdIndexes.push(index);
+          return { sourceId: source.id, displayName: source.name };
+        },
+        (source, target, index) => {
+          updatedIndexes.push(index);
+          target.displayName = source.name;
+        }
+      );
+
+      mapping.map([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ]);
+
+      expect(createdIndexes).toEqual([0, 1, 2]);
+
+      mapping.map([
+        { id: 1, name: 'Alice' },
+        { id: 2, name: 'Bob' },
+        { id: 3, name: 'Charlie' },
+      ]);
+
+      expect(updatedIndexes).toEqual([0, 1, 2]);
+    });
+
+    it('should handle empty arrays', () => {
+      const mapping = createMapping<TestSource, TestTarget>(
+        (source) => source.id,
+        (source) => ({ sourceId: source.id, displayName: source.name }),
+        (source, target) => {
+          target.displayName = source.name;
+        }
+      );
+
+      mapping.map([]);
+      expect(mapping.results.length).toBe(0);
+
+      mapping.map([{ id: 1, name: 'Alice' }]);
+      expect(mapping.results.length).toBe(1);
+
+      mapping.map([]);
+      expect(mapping.results.length).toBe(0);
+    });
+  });
+});