@hamak/navigation-utils 0.4.0

package/src/itinerary/itinerary.spec.ts

@@ -0,0 +1,388 @@
+import { describe, it, expect } from 'vitest';
+import {
+  areSameItineraryStep,
+  constructiveItinerary,
+  Itinerary,
+  itineraryOf,
+  itineraryOverlay,
+  itineraryToStepArray,
+  navigate,
+  navigationDepth,
+  overlayNavigator,
+  positionStep,
+  propertyStep,
+  xpathFromStack
+} from './itinerary';
+import stack from './stack';
+import { hyperReflect } from './hyper-layer-node';
+
+interface Address {
+  street: string
+  lines: string[]
+  country: string
+}
+
+interface Person {
+  name: string
+  age?: number
+  address?: Address
+  children?: Person[]
+}
+
+describe('Navigate itinerary', () => {
+  it('should work', () => {
+    const itinerary: Itinerary = {
+      "value": {
+        "type": "property",
+        "propertyName": "schema"
+      },
+      "parent": {
+        "value": {
+          "type": "position",
+          "position": 0
+        }
+      }
+    }
+
+    const actual = navigate(sampleData(), itinerary);
+    const expected = schemaEntry1.schema
+
+    expect(actual).toBe(expected);
+  });
+
+  it('Conversion to array should work', () => {
+    const path = [0, 'schema']
+    const itinerary = itineraryOf(...path)
+    const actual = itineraryToStepArray(itinerary!);
+    const expected = path.map(e => typeof e === 'string' ? propertyStep(e) : positionStep(e))
+
+    expect(actual).toStrictEqual(expected);
+  });
+
+  it('Ensure path should work', () => {
+    const person: Person[] = [{
+      name: "Elon MUSK",
+    }]
+    const path = [0, 'address']
+    const itinerary = itineraryOf(...path)
+    const proto = { street: "Wall Street" } as Address;
+    const result = navigate(person, itinerary, stack.fromArray([proto]));
+
+    expect(result).toBe(proto);
+    expect(person[0].address).toBe(proto);
+  });
+
+  it('Deep navigation with constructiveItinerary should work', () => {
+    const person: Person[] = [{
+      name: "Guezo",
+      children: []
+    }]
+
+    const { itinerary, prototypes } = constructiveItinerary(["children", [], 0, { name: "Glélé" }, "children", [], 0, { name: "Béhanzin" }])
+    const result = navigate(person, stack.concat(itineraryOf(0), itinerary), prototypes) as Person;
+
+    expect(person[0]?.name).toBe("Guezo");
+    expect(result.name).toBe("Béhanzin");
+  });
+
+  it("Overlay navigation should work", () => {
+    const person: Person = {
+      name: "John Doe",
+      age: 40,
+      address: {
+        street: "123 Main Street",
+        lines: ["Apt 4B", "2nd Floor"],
+        country: "USA"
+      },
+      children: [
+        {
+          name: "Jane Doe",
+          age: 10,
+          address: {
+            street: "456 Maple Avenue",
+            lines: ["House 12"],
+            country: "USA"
+          }
+        },
+        {
+          name: "Jack Doe",
+          age: 8
+        }
+      ]
+    };
+
+    const personOverlay = hyperReflect(person)
+
+    const itinerary = itineraryOf("children", 0, "address", "lines", 0)
+
+    expect(navigate(person, itinerary)).toBe("House 12")
+    expect(navigate(personOverlay, itineraryOverlay(itinerary))).toBe("House 12")
+    expect(overlayNavigator.navigate(personOverlay, itinerary)?.data).toBe("House 12")
+  })
+
+  it("Overlay itinerary rewrite should work", () => {
+    const toOverlay = (...path: (string | number)[]) => {
+      return xpathFromStack(itineraryOverlay(itineraryOf(...path)))
+    }
+
+    expect(toOverlay()).toBe("/data")
+    expect(toOverlay("name")).toBe("/children/name/data")
+    expect(toOverlay("persons", 0)).toBe("/children/persons/children/*[1]/data")
+  })
+});
+
+const schemaEntry1 = {
+  "id": "schema:User",
+  "schema": {
+    "schemaNodeType": "object",
+    "operator": false,
+    "facets": {},
+    "properties": [
+      {
+        "uuid": "172302fe-29de-462a-9e27-053463b6d118",
+        "schemaNodeType": "property",
+        "facets": {},
+        "name": "uuid",
+        "valueSchema": {
+          "schemaNodeType": "scalar",
+          "operator": false,
+          "facets": {},
+          "type": "string"
+        }
+      },
+      {
+        "uuid": "733675e6-543e-4013-a071-a9a45145321b",
+        "schemaNodeType": "property",
+        "facets": {},
+        "name": "name",
+        "valueSchema": {
+          "schemaNodeType": "scalar",
+          "operator": false,
+          "facets": {},
+          "type": "string"
+        }
+      },
+      {
+        "uuid": "8376b829-459a-4b40-b2f9-71a6aea506e5",
+        "schemaNodeType": "property",
+        "facets": {},
+        "name": "firstName",
+        "valueSchema": {
+          "schemaNodeType": "scalar",
+          "operator": false,
+          "facets": {},
+          "type": "string"
+        }
+      },
+      {
+        "uuid": "3c39bfc4-90ae-4525-9366-47c7866265f3",
+        "schemaNodeType": "property",
+        "facets": {},
+        "name": "lastName",
+        "valueSchema": {
+          "schemaNodeType": "scalar",
+          "operator": false,
+          "facets": {},
+          "type": "string"
+        }
+      },
+      {
+        "uuid": "a5f05908-8a9f-4879-8dc9-f5214a6aa693",
+        "schemaNodeType": "property",
+        "facets": {},
+        "name": "age",
+        "valueSchema": {
+          "schemaNodeType": "scalar",
+          "operator": false,
+          "facets": {},
+          "type": "integer"
+        }
+      }
+    ]
+  }
+};
+
+function sampleData(): any {
+  return [
+    schemaEntry1,
+    {
+      "id": "schema:Car",
+      "schema": {
+        "schemaNodeType": "object",
+        "operator": false,
+        "facets": {},
+        "properties": [
+          {
+            "uuid": "50fa33fe-03b4-45f2-b5df-da00e742bb89",
+            "schemaNodeType": "property",
+            "facets": {},
+            "name": "uuid",
+            "valueSchema": {
+              "schemaNodeType": "scalar",
+              "operator": false,
+              "facets": {},
+              "type": "string"
+            }
+          },
+          {
+            "uuid": "6ff05784-dde5-4a70-a57b-d93cba8afb00",
+            "schemaNodeType": "property",
+            "facets": {},
+            "name": "name",
+            "valueSchema": {
+              "schemaNodeType": "scalar",
+              "operator": false,
+              "facets": {},
+              "type": "string"
+            }
+          },
+          {
+            "uuid": "a8dae1ce-a82f-46f4-a2a0-4fc177988e3c",
+            "schemaNodeType": "property",
+            "facets": {},
+            "name": "brand",
+            "valueSchema": {
+              "schemaNodeType": "scalar",
+              "operator": false,
+              "facets": {},
+              "type": "string"
+            }
+          },
+          {
+            "uuid": "85342429-673f-420e-b0d0-7e019e7bea2a",
+            "schemaNodeType": "property",
+            "facets": {},
+            "name": "color",
+            "valueSchema": {
+              "schemaNodeType": "scalar",
+              "operator": false,
+              "facets": {},
+              "type": "string"
+            }
+          }
+        ]
+      }
+    }
+  ]
+}
+
+// Unit tests for areSameItineraryStep
+describe('areSameItineraryStep', () => {
+  it('returns true for two position steps with the same position', () => {
+    expect(
+      areSameItineraryStep(positionStep(3), positionStep(3))
+    ).toBe(true);
+  });
+
+  it('returns false for two position steps with different positions', () => {
+    expect(
+      areSameItineraryStep(
+        positionStep(2),
+        positionStep(5)
+      )
+    ).toBe(false);
+  });
+
+  it('returns true for two property steps with the same propertyName', () => {
+    expect(
+      areSameItineraryStep(propertyStep('foo'), propertyStep('foo'))
+    ).toBe(true);
+  });
+
+  it('returns false for two property steps with different propertyNames', () => {
+    expect(
+      areSameItineraryStep(
+        propertyStep('foo'),
+        propertyStep('bar')
+      )
+    ).toBe(false);
+  });
+
+  it('returns false for steps of different types', () => {
+    expect(
+      areSameItineraryStep(
+        positionStep(1),
+        propertyStep('1')
+      )
+    ).toBe(false);
+  });
+
+  it('returns false if one or both steps are null or undefined', () => {
+    expect(
+      areSameItineraryStep(
+        positionStep(1),
+        null as any
+      )
+    ).toBe(false);
+    expect(
+      areSameItineraryStep(
+        undefined as any,
+        propertyStep('foo')
+      )
+    ).toBe(false);
+    expect(
+      areSameItineraryStep(
+        undefined as any,
+        undefined as any
+      )
+    ).toBe(false);
+  });
+});
+
+describe('navigationDepth with itineraryOf', () => {
+  it('should return root when itinerary is undefined', () => {
+    const obj = { a: 1 };
+    const result = navigationDepth(obj, undefined);
+    expect(result.value).toBe(obj);
+    expect(result.path).toBe('');
+  });
+
+  it('should navigate fully when path exists', () => {
+    const obj = { a: { b: { c: 42 } } };
+    const itinerary = itineraryOf('a', 'b', 'c');
+
+    const result = navigationDepth(obj, itinerary);
+    expect(result.value).toBe(42);
+    expect(result.path).toBe('/a/b/c');
+  });
+
+  it('should stop at last defined property (null)', () => {
+    const obj = { a: { b: null } };
+    const itinerary = itineraryOf('a', 'b', 'c');
+
+    const result = navigationDepth(obj, itinerary);
+    expect(result.value).toEqual({ b: null });
+    expect(result.path).toBe('/a/b');
+  });
+
+  it('should stop when root is undefined', () => {
+    const result = navigationDepth(undefined, itineraryOf('a', 'b'));
+    expect(result.value).toBeUndefined();
+    expect(result.path).toBe('');
+  });
+
+  it('should navigate inside array with position step', () => {
+    const obj = { list: [{ id: 1 }, { id: 2 }] };
+    const itinerary = itineraryOf('list', 1);
+
+    const result = navigationDepth(obj, itinerary);
+    expect(result.value).toEqual({ id: 2 });
+    expect(result.path).toBe('/list/*[2]');
+  });
+
+  it('should stop when lookup fails', () => {
+    const obj = { list: [{ id: 1 }, { id: 2 }] };
+    const lookupStep = {
+      type: 'lookup' as const,
+      keys: [{ propertyName: 'id', propertyValue: 3 }]
+    };
+    const itinerary = {
+      value: lookupStep,
+      parent: itineraryOf('list')
+    };
+
+    const result = navigationDepth(obj, itinerary);
+    expect(result.value).toEqual(obj.list);
+    expect(result.path).toBe('/list');
+  });
+});