flowquery 1.0.46 → 1.0.47

package/tests/graph/data.test.ts

@@ -1,58 +0,0 @@
-import Data from "../../src/graph/data";
-import NodeData from "../../src/graph/node_data";
-import RelationshipData from "../../src/graph/relationship_data";
-
-test("Data iteration", () => {
-    const records = [
-        { id: "1", name: "Alice" },
-        { id: "2", name: "Bob" },
-        { id: "3", name: "Charlie" },
-    ];
-    const data = new Data(records);
-    expect(data.next()).toBe(true);
-    expect(data.next()).toBe(true);
-    expect(data.next()).toBe(true);
-    expect(data.next()).toBe(false);
-});
-
-test("Data find", () => {
-    const records = [
-        { id: "1", name: "Alice" },
-        { id: "2", name: "Bob" },
-        { id: "3", name: "Charlie" },
-        { id: "2", name: "Bob Duplicate" },
-    ];
-    const data: NodeData = new NodeData(records);
-    data.find("2");
-    expect(data.current()).toEqual({ id: "2", name: "Bob" });
-    expect(data.find("2")).toBe(true);
-    expect(data.current()).toEqual({ id: "2", name: "Bob Duplicate" });
-    expect(data.find("2")).toBe(false);
-});
-
-test("Data find non-existing", () => {
-    const records = [
-        { id: "1", name: "Alice" },
-        { id: "2", name: "Bob" },
-    ];
-    const data: NodeData = new NodeData(records);
-    expect(data.find("3")).toBe(false);
-});
-
-test("RelationshipData find", () => {
-    const records = [
-        { left_id: "1", right_id: "2", type: "FRIEND", id: "r1" },
-        { left_id: "2", right_id: "3", type: "COLLEAGUE", id: "r2" },
-        { left_id: "1", right_id: "3", type: "FRIEND", id: "r3" },
-    ];
-    const data: RelationshipData = new RelationshipData(records);
-    data.find("1");
-    expect(data.current()).toEqual({ left_id: "1", right_id: "2", type: "FRIEND", id: "r1" });
-    expect(data.find("1")).toBe(true);
-    expect(data.current()).toEqual({ left_id: "1", right_id: "3", type: "FRIEND", id: "r3" });
-    expect(data.find("1")).toBe(false);
-    expect(data.find("2")).toBe(true);
-    expect(data.current()).toEqual({ left_id: "2", right_id: "3", type: "COLLEAGUE", id: "r2" });
-    expect(data.find("2")).toBe(false);
-    expect(data.find("4")).toBe(false);
-});

package/tests/graph/match.test.ts

@@ -1,29 +0,0 @@
-import Runner from "../../src/compute/runner";
-import PhysicalNode from "../../src/graph/physical_node";
-import CreateNode from "../../src/parsing/operations/create_node";
-import Parser from "../../src/parsing/parser";
-
-test("Test CreateNode and match operations", async () => {
-    const node = new PhysicalNode(null, "Person");
-    expect(node.label).toBe("Person");
-    expect(node.statement).toBeNull();
-    const parser = new Parser();
-    const statement = parser.parse(`
-        unwind [
-            {id: 1, name: 'Person 1'},
-            {id: 2, name: 'Person 2'}
-        ] as record
-        RETURN record.id as id, record.name as name
-    `);
-    const op = new CreateNode(node, statement);
-    await op.run();
-    const runner = new Runner("match (n:Person) RETURN n");
-    await runner.run();
-    expect(runner.results.length).toBe(2);
-    expect(runner.results[0].n).toBeDefined();
-    expect(runner.results[0].n.id).toBe(1);
-    expect(runner.results[0].n.name).toBe("Person 1");
-    expect(runner.results[1].n).toBeDefined();
-    expect(runner.results[1].n.id).toBe(2);
-    expect(runner.results[1].n.name).toBe("Person 2");
-});

package/tests/parsing/context.test.ts

@@ -1,27 +0,0 @@
-import Context from "../../src/parsing/context";
-import Sum from "../../src/parsing/functions/sum";
-import AggregateFunction from "../../src/parsing/functions/aggregate_function";
-
-test('Test Context containsType', () => {
-    const context = new Context();
-    const sum = new Sum();
-    context.push(sum);
-    expect(context.containsType(AggregateFunction)).toBe(true);
-});
-
-test('Test Context containsType false', () => {
-    const context = new Context();
-    expect(context.containsType(AggregateFunction)).toBe(false);
-});
-
-test('Test Context push and pop', () => {
-    const context = new Context();
-    const sum = new Sum();
-    context.push(sum);
-    expect(context.pop()).toBe(sum);
-});
-
-test('Test Context pop undefined', () => {
-    const context = new Context();
-    expect(context.pop()).toBe(undefined);
-});

package/tests/parsing/expression.test.ts

@@ -1,303 +0,0 @@
-import ASTNode from "../../src/parsing/ast_node";
-import Null from "../../src/parsing/components/null";
-import Expression from "../../src/parsing/expressions/expression";
-import Number from "../../src/parsing/expressions/number";
-import {
-    Add,
-    And,
-    Contains,
-    EndsWith,
-    Equals,
-    GreaterThan,
-    Is,
-    IsNot,
-    Multiply,
-    NotContains,
-    NotEndsWith,
-    NotEquals,
-    NotStartsWith,
-    Power,
-    StartsWith,
-    Subtract,
-    deepEquals,
-} from "../../src/parsing/expressions/operator";
-import String from "../../src/parsing/expressions/string";
-
-class ObjectValue extends ASTNode {
-    private _value: any;
-    constructor(value: any) {
-        super();
-        this._value = value;
-    }
-    public value(): any {
-        return this._value;
-    }
-}
-
-test("Test Expression Shunting Yard algorithm", () => {
-    const expression = new Expression();
-    expression.addNode(new Number("2"));
-    expression.addNode(new Add());
-    expression.addNode(new Number("3"));
-    expression.addNode(new Multiply());
-    expression.addNode(new Number("4"));
-    expression.addNode(new Subtract());
-    expression.addNode(new Number("2"));
-    expression.addNode(new Power());
-    expression.addNode(new Number("2"));
-    expression.finish();
-    expect(expression.value()).toBe(10);
-});
-
-test("Test Expression with and operator", () => {
-    const expression = new Expression();
-    expression.addNode(new Number("2"));
-    expression.addNode(new And());
-    expression.addNode(new Number("3"));
-    expression.finish();
-    expect(expression.value()).toBe(1);
-});
-
-test("Test 1 > 0 and 2 > 1", () => {
-    const expression = new Expression();
-    expression.addNode(new Number("1"));
-    expression.addNode(new GreaterThan());
-    expression.addNode(new Number("0"));
-    expression.addNode(new And());
-    expression.addNode(new Number("2"));
-    expression.addNode(new GreaterThan());
-    expression.addNode(new Number("1"));
-    expression.finish();
-    expect(expression.value()).toBe(1);
-});
-
-test("Test IS NULL with null value", () => {
-    const expression = new Expression();
-    expression.addNode(new Null());
-    expression.addNode(new Is());
-    expression.addNode(new Null());
-    expression.finish();
-    expect(expression.value()).toBe(1);
-});
-
-test("Test IS NULL with non-null value", () => {
-    const expression = new Expression();
-    expression.addNode(new Number("42"));
-    expression.addNode(new Is());
-    expression.addNode(new Null());
-    expression.finish();
-    expect(expression.value()).toBe(0);
-});
-
-test("Test IS NOT NULL with non-null value", () => {
-    const expression = new Expression();
-    expression.addNode(new Number("42"));
-    expression.addNode(new IsNot());
-    expression.addNode(new Null());
-    expression.finish();
-    expect(expression.value()).toBe(1);
-});
-
-test("Test IS NOT NULL with null value", () => {
-    const expression = new Expression();
-    expression.addNode(new Null());
-    expression.addNode(new IsNot());
-    expression.addNode(new Null());
-    expression.finish();
-    expect(expression.value()).toBe(0);
-});
-
-test("Test CONTAINS with matching substring", () => {
-    const expression = new Expression();
-    expression.addNode(new String("pineapple"));
-    expression.addNode(new Contains());
-    expression.addNode(new String("apple"));
-    expression.finish();
-    expect(expression.value()).toBe(1);
-});
-
-test("Test CONTAINS with non-matching substring", () => {
-    const expression = new Expression();
-    expression.addNode(new String("banana"));
-    expression.addNode(new Contains());
-    expression.addNode(new String("apple"));
-    expression.finish();
-    expect(expression.value()).toBe(0);
-});
-
-test("Test NOT CONTAINS", () => {
-    const expression = new Expression();
-    expression.addNode(new String("banana"));
-    expression.addNode(new NotContains());
-    expression.addNode(new String("apple"));
-    expression.finish();
-    expect(expression.value()).toBe(1);
-});
-
-test("Test STARTS WITH matching prefix", () => {
-    const expression = new Expression();
-    expression.addNode(new String("pineapple"));
-    expression.addNode(new StartsWith());
-    expression.addNode(new String("pine"));
-    expression.finish();
-    expect(expression.value()).toBe(1);
-});
-
-test("Test STARTS WITH non-matching prefix", () => {
-    const expression = new Expression();
-    expression.addNode(new String("pineapple"));
-    expression.addNode(new StartsWith());
-    expression.addNode(new String("apple"));
-    expression.finish();
-    expect(expression.value()).toBe(0);
-});
-
-test("Test NOT STARTS WITH", () => {
-    const expression = new Expression();
-    expression.addNode(new String("pineapple"));
-    expression.addNode(new NotStartsWith());
-    expression.addNode(new String("apple"));
-    expression.finish();
-    expect(expression.value()).toBe(1);
-});
-
-test("Test ENDS WITH matching suffix", () => {
-    const expression = new Expression();
-    expression.addNode(new String("pineapple"));
-    expression.addNode(new EndsWith());
-    expression.addNode(new String("apple"));
-    expression.finish();
-    expect(expression.value()).toBe(1);
-});
-
-test("Test ENDS WITH non-matching suffix", () => {
-    const expression = new Expression();
-    expression.addNode(new String("pineapple"));
-    expression.addNode(new EndsWith());
-    expression.addNode(new String("banana"));
-    expression.finish();
-    expect(expression.value()).toBe(0);
-});
-
-test("Test NOT ENDS WITH", () => {
-    const expression = new Expression();
-    expression.addNode(new String("pineapple"));
-    expression.addNode(new NotEndsWith());
-    expression.addNode(new String("banana"));
-    expression.finish();
-    expect(expression.value()).toBe(1);
-});
-
-// deepEquals unit tests
-
-test("deepEquals with identical primitives", () => {
-    expect(deepEquals(1, 1)).toBe(true);
-    expect(deepEquals("abc", "abc")).toBe(true);
-    expect(deepEquals(null, null)).toBe(true);
-});
-
-test("deepEquals with different primitives", () => {
-    expect(deepEquals(1, 2)).toBe(false);
-    expect(deepEquals("abc", "def")).toBe(false);
-    expect(deepEquals(null, 1)).toBe(false);
-    expect(deepEquals(1, "1")).toBe(false);
-});
-
-test("deepEquals with identical objects", () => {
-    const obj = { id: "1", name: "Alice" };
-    expect(deepEquals(obj, obj)).toBe(true);
-});
-
-test("deepEquals with structurally equal objects", () => {
-    expect(deepEquals({ id: "1", name: "Alice" }, { id: "1", name: "Alice" })).toBe(true);
-});
-
-test("deepEquals with different objects", () => {
-    expect(deepEquals({ id: "1", name: "Alice" }, { id: "2", name: "Bob" })).toBe(false);
-});
-
-test("deepEquals with nested objects", () => {
-    expect(
-        deepEquals({ id: "1", data: { x: 1, y: [2, 3] } }, { id: "1", data: { x: 1, y: [2, 3] } })
-    ).toBe(true);
-    expect(
-        deepEquals({ id: "1", data: { x: 1, y: [2, 3] } }, { id: "1", data: { x: 1, y: [2, 4] } })
-    ).toBe(false);
-});
-
-test("deepEquals with arrays", () => {
-    expect(deepEquals([1, 2, 3], [1, 2, 3])).toBe(true);
-    expect(deepEquals([1, 2, 3], [1, 2])).toBe(false);
-    expect(deepEquals([1, 2], [1, 2, 3])).toBe(false);
-});
-
-test("deepEquals with objects having different keys", () => {
-    expect(deepEquals({ a: 1 }, { b: 1 })).toBe(false);
-    expect(deepEquals({ a: 1 }, { a: 1, b: 2 })).toBe(false);
-});
-
-// Equals operator with objects
-
-test("Test Equals with equal numbers", () => {
-    const expression = new Expression();
-    expression.addNode(new Number("42"));
-    expression.addNode(new Equals());
-    expression.addNode(new Number("42"));
-    expression.finish();
-    expect(expression.value()).toBe(1);
-});
-
-test("Test Equals with different numbers", () => {
-    const expression = new Expression();
-    expression.addNode(new Number("42"));
-    expression.addNode(new Equals());
-    expression.addNode(new Number("99"));
-    expression.finish();
-    expect(expression.value()).toBe(0);
-});
-
-test("Test Equals with structurally equal objects", () => {
-    const expression = new Expression();
-    expression.addNode(new ObjectValue({ id: "1", name: "Alice" }));
-    expression.addNode(new Equals());
-    expression.addNode(new ObjectValue({ id: "1", name: "Alice" }));
-    expression.finish();
-    expect(expression.value()).toBe(1);
-});
-
-test("Test Equals with different objects", () => {
-    const expression = new Expression();
-    expression.addNode(new ObjectValue({ id: "1", name: "Alice" }));
-    expression.addNode(new Equals());
-    expression.addNode(new ObjectValue({ id: "2", name: "Bob" }));
-    expression.finish();
-    expect(expression.value()).toBe(0);
-});
-
-test("Test NotEquals with structurally equal objects", () => {
-    const expression = new Expression();
-    expression.addNode(new ObjectValue({ id: "1", name: "Alice" }));
-    expression.addNode(new NotEquals());
-    expression.addNode(new ObjectValue({ id: "1", name: "Alice" }));
-    expression.finish();
-    expect(expression.value()).toBe(0);
-});
-
-test("Test NotEquals with different objects", () => {
-    const expression = new Expression();
-    expression.addNode(new ObjectValue({ id: "1", name: "Alice" }));
-    expression.addNode(new NotEquals());
-    expression.addNode(new ObjectValue({ id: "2", name: "Bob" }));
-    expression.finish();
-    expect(expression.value()).toBe(1);
-});
-
-test("Test Equals with same reference object", () => {
-    const obj = { id: "1", name: "Alice" };
-    const expression = new Expression();
-    expression.addNode(new ObjectValue(obj));
-    expression.addNode(new Equals());
-    expression.addNode(new ObjectValue(obj));
-    expression.finish();
-    expect(expression.value()).toBe(1);
-});