flowquery 1.0.46 → 1.0.48

package/flowquery-py/tests/graph/__init__.py

@@ -1 +0,0 @@
-"""Graph tests package."""

package/flowquery-py/tests/graph/test_create.py

@@ -1,56 +0,0 @@
-"""Tests for graph node and relationship creation."""
-
-import pytest
-from flowquery.graph.database import Database
-from flowquery.graph.physical_node import PhysicalNode
-from flowquery.graph.physical_relationship import PhysicalRelationship
-from flowquery.parsing.operations.create_node import CreateNode
-from flowquery.parsing.operations.create_relationship import CreateRelationship
-from flowquery.parsing.parser import Parser
-
-
-class TestCreateNode:
-    """Test cases for CreateNode operation."""
-
-    @pytest.mark.asyncio
-    async def test_create_node_operation(self):
-        """Test CreateNode operation."""
-        node = PhysicalNode(None, "Person")
-        assert node.label == "Person"
-        assert node.statement is None
-        
-        parser = Parser()
-        statement = parser.parse("WITH 1 as x RETURN x")
-        op = CreateNode(node, statement)
-        await op.run()
-        
-        db = Database.get_instance()
-        found = db.get_node(node)
-        assert found is not None
-        assert found.label == node.label
-        
-        data = await found.data()
-        assert data == [{"x": 1}]
-
-
-class TestCreateRelationship:
-    """Test cases for CreateRelationship operation."""
-
-    @pytest.mark.asyncio
-    async def test_create_relationship_operation(self):
-        """Test CreateRelationship operation."""
-        relationship = PhysicalRelationship()
-        relationship.type = "KNOWS"
-        assert relationship.type == "KNOWS"
-        assert relationship.statement is None
-        
-        parser = Parser()
-        statement = parser.parse("WITH 1 as x RETURN x")
-        op = CreateRelationship(relationship, statement)
-        await op.run()
-        
-        db = Database.get_instance()
-        found = db.get_relationship(relationship)
-        
-        data = await found.data()
-        assert data == [{"x": 1}]

package/flowquery-py/tests/graph/test_data.py

@@ -1,73 +0,0 @@
-"""Tests for graph data iteration."""
-
-import pytest
-from flowquery.graph.data import Data
-from flowquery.graph.node_data import NodeData
-from flowquery.graph.relationship_data import RelationshipData
-
-
-class TestDataIteration:
-    """Test cases for Data class iteration."""
-
-    def test_data_iteration(self):
-        """Test data iteration."""
-        records = [
-            {"id": "1", "name": "Alice"},
-            {"id": "2", "name": "Bob"},
-            {"id": "3", "name": "Charlie"},
-        ]
-        data = Data(records)
-        assert data.next() is True
-        assert data.next() is True
-        assert data.next() is True
-        assert data.next() is False
-
-
-class TestNodeDataFind:
-    """Test cases for NodeData find operations."""
-
-    def test_data_find(self):
-        """Test data find."""
-        records = [
-            {"id": "1", "name": "Alice"},
-            {"id": "2", "name": "Bob"},
-            {"id": "3", "name": "Charlie"},
-            {"id": "2", "name": "Bob Duplicate"},
-        ]
-        data = NodeData(records)
-        data.find("2")
-        assert data.current() == {"id": "2", "name": "Bob"}
-        assert data.find("2") is True
-        assert data.current() == {"id": "2", "name": "Bob Duplicate"}
-        assert data.find("2") is False
-
-    def test_data_find_non_existing(self):
-        """Test data find non-existing."""
-        records = [
-            {"id": "1", "name": "Alice"},
-            {"id": "2", "name": "Bob"},
-        ]
-        data = NodeData(records)
-        assert data.find("3") is False
-
-
-class TestRelationshipDataFind:
-    """Test cases for RelationshipData find operations."""
-
-    def test_relationship_data_find(self):
-        """Test RelationshipData find."""
-        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"},
-        ]
-        data = RelationshipData(records)
-        data.find("1")
-        assert data.current() == {"left_id": "1", "right_id": "2", "type": "FRIEND", "id": "r1"}
-        assert data.find("1") is True
-        assert data.current() == {"left_id": "1", "right_id": "3", "type": "FRIEND", "id": "r3"}
-        assert data.find("1") is False
-        assert data.find("2") is True
-        assert data.current() == {"left_id": "2", "right_id": "3", "type": "COLLEAGUE", "id": "r2"}
-        assert data.find("2") is False
-        assert data.find("4") is False

package/flowquery-py/tests/graph/test_match.py

@@ -1,40 +0,0 @@
-"""Tests for graph pattern matching."""
-
-import pytest
-from flowquery.compute.runner import Runner
-from flowquery.graph.physical_node import PhysicalNode
-from flowquery.parsing.operations.create_node import CreateNode
-from flowquery.parsing.parser import Parser
-
-
-class TestMatch:
-    """Test cases for Match operation."""
-
-    @pytest.mark.asyncio
-    async def test_create_node_and_match_operations(self):
-        """Test CreateNode and match operations."""
-        node = PhysicalNode(None, "Person")
-        assert node.label == "Person"
-        assert node.statement is None
-        
-        parser = Parser()
-        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
-        """)
-        op = CreateNode(node, statement)
-        await op.run()
-        
-        runner = Runner("match (n:Person) RETURN n")
-        await runner.run()
-        
-        assert len(runner.results) == 2
-        assert runner.results[0]["n"] is not None
-        assert runner.results[0]["n"]["id"] == 1
-        assert runner.results[0]["n"]["name"] == "Person 1"
-        assert runner.results[1]["n"] is not None
-        assert runner.results[1]["n"]["id"] == 2
-        assert runner.results[1]["n"]["name"] == "Person 2"

package/flowquery-py/tests/parsing/__init__.py

@@ -1 +0,0 @@
-"""Parsing tests package."""

package/flowquery-py/tests/parsing/test_context.py

@@ -1,34 +0,0 @@
-"""Tests for the parsing context."""
-
-import pytest
-from flowquery.parsing.context import Context
-from flowquery.parsing.functions.sum import Sum
-from flowquery.parsing.functions.aggregate_function import AggregateFunction
-
-
-class TestContext:
-    """Test cases for the Context class."""
-
-    def test_context_contains_type(self):
-        """Test Context containsType."""
-        context = Context()
-        sum_func = Sum()
-        context.push(sum_func)
-        assert context.contains_type(AggregateFunction) is True
-
-    def test_context_contains_type_false(self):
-        """Test Context containsType false."""
-        context = Context()
-        assert context.contains_type(AggregateFunction) is False
-
-    def test_context_push_and_pop(self):
-        """Test Context push and pop."""
-        context = Context()
-        sum_func = Sum()
-        context.push(sum_func)
-        assert context.pop() is sum_func
-
-    def test_context_pop_none(self):
-        """Test Context pop returns None when empty."""
-        context = Context()
-        assert context.pop() is None

package/flowquery-py/tests/parsing/test_expression.py

@@ -1,248 +0,0 @@
-"""Tests for expression evaluation."""
-
-import pytest
-from flowquery.parsing.expressions.expression import Expression
-from flowquery.parsing.expressions.operator import (
-    Add, Subtract, Multiply, Power, GreaterThan, And, Is, IsNot,
-    Contains, NotContains, StartsWith, NotStartsWith, EndsWith, NotEndsWith,
-    Equals, NotEquals,
-)
-from flowquery.parsing.expressions.number import Number
-from flowquery.parsing.expressions.string import String
-from flowquery.parsing.components.null import Null
-from flowquery.parsing.ast_node import ASTNode
-
-
-class ObjectValue(ASTNode):
-    """Test helper that wraps an arbitrary value as an ASTNode operand."""
-
-    def __init__(self, val):
-        super().__init__()
-        self._val = val
-
-    def value(self):
-        return self._val
-
-
-class TestExpression:
-    """Test cases for the Expression class."""
-
-    def test_expression_shunting_yard_algorithm(self):
-        """Test Expression Shunting Yard algorithm."""
-        expression = Expression()
-        expression.add_node(Number("2"))
-        expression.add_node(Add())
-        expression.add_node(Number("3"))
-        expression.add_node(Multiply())
-        expression.add_node(Number("4"))
-        expression.add_node(Subtract())
-        expression.add_node(Number("2"))
-        expression.add_node(Power())
-        expression.add_node(Number("2"))
-        expression.finish()
-        assert expression.value() == 10
-
-    def test_expression_with_and_operator(self):
-        """Test Expression with and operator."""
-        expression = Expression()
-        expression.add_node(Number("2"))
-        expression.add_node(And())
-        expression.add_node(Number("3"))
-        expression.finish()
-        assert expression.value() == 1
-
-    def test_comparison_with_and(self):
-        """Test 1 > 0 and 2 > 1."""
-        expression = Expression()
-        expression.add_node(Number("1"))
-        expression.add_node(GreaterThan())
-        expression.add_node(Number("0"))
-        expression.add_node(And())
-        expression.add_node(Number("2"))
-        expression.add_node(GreaterThan())
-        expression.add_node(Number("1"))
-        expression.finish()
-        assert expression.value() == 1
-
-    def test_is_null_with_null_value(self):
-        """Test IS NULL with null value."""
-        expression = Expression()
-        expression.add_node(Null())
-        expression.add_node(Is())
-        expression.add_node(Null())
-        expression.finish()
-        assert expression.value() == 1
-
-    def test_is_null_with_non_null_value(self):
-        """Test IS NULL with non-null value."""
-        expression = Expression()
-        expression.add_node(Number("42"))
-        expression.add_node(Is())
-        expression.add_node(Null())
-        expression.finish()
-        assert expression.value() == 0
-
-    def test_is_not_null_with_non_null_value(self):
-        """Test IS NOT NULL with non-null value."""
-        expression = Expression()
-        expression.add_node(Number("42"))
-        expression.add_node(IsNot())
-        expression.add_node(Null())
-        expression.finish()
-        assert expression.value() == 1
-
-    def test_is_not_null_with_null_value(self):
-        """Test IS NOT NULL with null value."""
-        expression = Expression()
-        expression.add_node(Null())
-        expression.add_node(IsNot())
-        expression.add_node(Null())
-        expression.finish()
-        assert expression.value() == 0
-
-    def test_contains_with_matching_substring(self):
-        """Test CONTAINS with matching substring."""
-        expression = Expression()
-        expression.add_node(String("pineapple"))
-        expression.add_node(Contains())
-        expression.add_node(String("apple"))
-        expression.finish()
-        assert expression.value() == 1
-
-    def test_contains_with_non_matching_substring(self):
-        """Test CONTAINS with non-matching substring."""
-        expression = Expression()
-        expression.add_node(String("banana"))
-        expression.add_node(Contains())
-        expression.add_node(String("apple"))
-        expression.finish()
-        assert expression.value() == 0
-
-    def test_not_contains(self):
-        """Test NOT CONTAINS."""
-        expression = Expression()
-        expression.add_node(String("banana"))
-        expression.add_node(NotContains())
-        expression.add_node(String("apple"))
-        expression.finish()
-        assert expression.value() == 1
-
-    def test_starts_with_matching_prefix(self):
-        """Test STARTS WITH matching prefix."""
-        expression = Expression()
-        expression.add_node(String("pineapple"))
-        expression.add_node(StartsWith())
-        expression.add_node(String("pine"))
-        expression.finish()
-        assert expression.value() == 1
-
-    def test_starts_with_non_matching_prefix(self):
-        """Test STARTS WITH non-matching prefix."""
-        expression = Expression()
-        expression.add_node(String("pineapple"))
-        expression.add_node(StartsWith())
-        expression.add_node(String("apple"))
-        expression.finish()
-        assert expression.value() == 0
-
-    def test_not_starts_with(self):
-        """Test NOT STARTS WITH."""
-        expression = Expression()
-        expression.add_node(String("pineapple"))
-        expression.add_node(NotStartsWith())
-        expression.add_node(String("apple"))
-        expression.finish()
-        assert expression.value() == 1
-
-    def test_ends_with_matching_suffix(self):
-        """Test ENDS WITH matching suffix."""
-        expression = Expression()
-        expression.add_node(String("pineapple"))
-        expression.add_node(EndsWith())
-        expression.add_node(String("apple"))
-        expression.finish()
-        assert expression.value() == 1
-
-    def test_ends_with_non_matching_suffix(self):
-        """Test ENDS WITH non-matching suffix."""
-        expression = Expression()
-        expression.add_node(String("pineapple"))
-        expression.add_node(EndsWith())
-        expression.add_node(String("banana"))
-        expression.finish()
-        assert expression.value() == 0
-
-    def test_not_ends_with(self):
-        """Test NOT ENDS WITH."""
-        expression = Expression()
-        expression.add_node(String("pineapple"))
-        expression.add_node(NotEndsWith())
-        expression.add_node(String("banana"))
-        expression.finish()
-        assert expression.value() == 1
-
-    # Equals / NotEquals tests
-
-    def test_equals_with_equal_numbers(self):
-        """Test Equals with equal numbers."""
-        expression = Expression()
-        expression.add_node(Number("42"))
-        expression.add_node(Equals())
-        expression.add_node(Number("42"))
-        expression.finish()
-        assert expression.value() == 1
-
-    def test_equals_with_different_numbers(self):
-        """Test Equals with different numbers."""
-        expression = Expression()
-        expression.add_node(Number("42"))
-        expression.add_node(Equals())
-        expression.add_node(Number("99"))
-        expression.finish()
-        assert expression.value() == 0
-
-    def test_equals_with_structurally_equal_objects(self):
-        """Test Equals with structurally equal objects (different references)."""
-        expression = Expression()
-        expression.add_node(ObjectValue({"id": "1", "name": "Alice"}))
-        expression.add_node(Equals())
-        expression.add_node(ObjectValue({"id": "1", "name": "Alice"}))
-        expression.finish()
-        assert expression.value() == 1
-
-    def test_equals_with_different_objects(self):
-        """Test Equals with different objects."""
-        expression = Expression()
-        expression.add_node(ObjectValue({"id": "1", "name": "Alice"}))
-        expression.add_node(Equals())
-        expression.add_node(ObjectValue({"id": "2", "name": "Bob"}))
-        expression.finish()
-        assert expression.value() == 0
-
-    def test_not_equals_with_structurally_equal_objects(self):
-        """Test NotEquals with structurally equal objects."""
-        expression = Expression()
-        expression.add_node(ObjectValue({"id": "1", "name": "Alice"}))
-        expression.add_node(NotEquals())
-        expression.add_node(ObjectValue({"id": "1", "name": "Alice"}))
-        expression.finish()
-        assert expression.value() == 0
-
-    def test_not_equals_with_different_objects(self):
-        """Test NotEquals with different objects."""
-        expression = Expression()
-        expression.add_node(ObjectValue({"id": "1", "name": "Alice"}))
-        expression.add_node(NotEquals())
-        expression.add_node(ObjectValue({"id": "2", "name": "Bob"}))
-        expression.finish()
-        assert expression.value() == 1
-
-    def test_equals_with_same_reference_object(self):
-        """Test Equals with the same reference object."""
-        obj = {"id": "1", "name": "Alice"}
-        expression = Expression()
-        expression.add_node(ObjectValue(obj))
-        expression.add_node(Equals())
-        expression.add_node(ObjectValue(obj))
-        expression.finish()
-        assert expression.value() == 1