flowquery 1.0.16 → 1.0.17

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

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

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

@@ -0,0 +1,56 @@
+"""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

@@ -0,0 +1,73 @@
+"""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

@@ -0,0 +1,40 @@
+"""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

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

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

@@ -0,0 +1,34 @@
+"""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

@@ -0,0 +1,49 @@
+"""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
+)
+from flowquery.parsing.expressions.number import Number
+
+
+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