spanner-graph-notebook 1.1.2__tar.gz → 1.1.3__tar.gz

{spanner_graph_notebook-1.1.2/spanner_graph_notebook.egg-info → spanner_graph_notebook-1.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: spanner-graph-notebook
-Version: 1.1.2
+Version: 1.1.3
 Summary: Visually query Spanner Graph data in notebooks.
 Description-Content-Type: text/markdown
 License-File: LICENSE

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.3}/frontend/src/app.js

@@ -164,6 +164,11 @@ class SpannerApp {
                                     return;
                                 }
 
+                                if (data.error) {
+                                    this.graph.showErrorStateForNode(node, error);
+                                    return;
+                                }
+
                                 const newData = this.store.appendGraphData(data.response.nodes, data.response.edges)
                                 if (newData) {
                                     // Show success message before appending data

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.3}/frontend/src/graph-server.js

@@ -109,10 +109,7 @@ class GraphServer {
             }
         }
 
-        const {project, instance, database, graph} = JSON.parse(this.params);
-
         const request = {
-            project, instance, database, graph,
             uid: node.uid,
             node_labels: node.labels,
             node_properties: validProperties,
@@ -131,15 +128,12 @@ class GraphServer {
                 .finally(() => this.isFetching = false);
         }
 
-        // For non-Colab environment, combine params and request
-        const fullRequest = {
-            ...JSON.parse(this.params),
-            ...request
-        };
-
         return fetch(this.buildRoute(this.endpoints.postNodeExpansion), {
             method: 'POST',
-            body: JSON.stringify(fullRequest)
+            body: JSON.stringify({
+                params: this.params,
+                request
+            })
         })
             .then(response => {
                 if (!response.ok) {

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.3}/frontend/tests/unit/graph-server.test.ts

@@ -148,19 +148,23 @@ describe('GraphServer', () => {
                 {
                     method: 'POST',
                     body: JSON.stringify({
-                        project: 'test-project',
-                        instance: 'test-instance',
-                        database: 'test-database',
-                        graph: 'test-graph',
-                        mock: false,
-                        uid: 'node1',
-                        node_labels: ['TestLabel1'],
-                        node_properties: [{
-                            key: 'name',
-                            value: 'my-node-name',
-                            type: 'STRING'
-                        }],
-                        direction: 'OUTGOING'
+                        params: JSON.stringify({
+                            project: 'test-project',
+                            instance: 'test-instance',
+                            database: 'test-database',
+                            graph: 'test-graph',
+                            mock: false
+                        }),
+                        request: {
+                            uid: 'node1',
+                            node_labels: ['TestLabel1'],
+                            node_properties: [{
+                                key: 'name',
+                                value: 'my-node-name',
+                                type: 'STRING'
+                            }],
+                            direction: 'OUTGOING'
+                        }
                     })
                 }
             );

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.3}/setup.py

@@ -32,7 +32,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name="spanner-graph-notebook",
-    version="v1.1.2",
+    version="v1.1.3",
     packages=find_packages(),
     install_requires=[
         "networkx", "numpy", "google-cloud-spanner", "ipython",

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.3/spanner_graph_notebook.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: spanner-graph-notebook
-Version: 1.1.2
+Version: 1.1.3
 Summary: Visually query Spanner Graph data in notebooks.
 Description-Content-Type: text/markdown
 License-File: LICENSE

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.3}/spanner_graphs/graph_server.py

@@ -42,6 +42,17 @@ PROPERTY_TYPE_MAP = {
     'TIMESTAMP': TypeCode.TIMESTAMP
 }
 
+class NodePropertyForDataExploration:
+    def __init__(self, key: str, value: Union[str, int, float, bool], type: TypeCode):
+        self.key = key
+        self.value = value
+        self.type = type
+
+
+class EdgeDirection(Enum):
+    INCOMING = "INCOMING"
+    OUTGOING = "OUTGOING"
+
 def validate_property_type(property_type: str) -> TypeCode:
     """
     Validates and converts a property type string to a Spanner TypeCode.
@@ -68,26 +79,95 @@ def validate_property_type(property_type: str) -> TypeCode:
     
     return PROPERTY_TYPE_MAP[property_type]
 
-class EdgeDirection(Enum):
-    INCOMING = "INCOMING"
-    OUTGOING = "OUTGOING"
+def validate_node_expansion_request(data) -> (list[NodePropertyForDataExploration], EdgeDirection):
+    required_fields = ["project", "instance", "database", "graph", "uid", "node_labels", "direction"]
+    missing_fields = [field for field in required_fields if data.get(field) is None]
 
-class NodeProperty:
-    def __init__(self, key: str, value: Union[str, int, float, bool], type: TypeCode):
-        self.key = key
-        self.value = value
-        self.type = type
+    if missing_fields:
+        raise ValueError(f"Missing required fields: {', '.join(missing_fields)}")
+
+    node_labels = data.get("node_labels")
+    node_properties = data.get("node_properties", [])
+
+    # Validate node_labels
+    if not isinstance(node_labels, list):
+        raise ValueError("node_labels must be an array")
+
+    for label in node_labels:
+        if not isinstance(label, str):
+            raise ValueError("Each node label must be a string")
+
+    # Validate node_properties
+    if not isinstance(node_properties, list):
+        raise ValueError("node_properties must be an array")
+
+    validated_properties: list[NodePropertyForDataExploration] = []
+    for idx, prop in enumerate(node_properties):
+        if not isinstance(prop, dict):
+            raise ValueError(f"Property at index {idx} must be an object")
+
+        if not all(field in prop for field in ["key", "value", "type"]):
+            raise ValueError(f"Property at index {idx} is missing required fields (key, value, type)")
+
+        try:
+            prop_type_str = prop["type"]
+            if isinstance(prop_type_str, str):
+                prop_type = validate_property_type(prop_type_str)
+
+                value = prop["value"]
+                if prop_type in (TypeCode.INT64, TypeCode.NUMERIC):
+                    if not (isinstance(value, int) or (isinstance(value, str) and value.isdigit())):
+                        raise ValueError(f"Property '{prop['key']}' value must be a number for type {prop_type_str}")
+                elif prop_type in (TypeCode.FLOAT32, TypeCode.FLOAT64):
+                    try:
+                        float(value)
+                    except (ValueError, TypeError):
+                        raise ValueError(
+                            f"Property '{prop['key']}' value must be a valid float for type {prop_type_str}")
+                elif prop_type == TypeCode.BOOL:
+                    if not isinstance(value, bool) and not (isinstance(value, str) and value.lower() in ["true", "false"]):
+                        raise ValueError(f"Property '{prop['key']}' value must be a boolean for type {prop_type_str}")
+
+                validated_properties.append(NodePropertyForDataExploration(
+                    key=prop["key"],
+                    value=prop["value"],
+                    type=prop_type
+                ))
+            else:
+                raise ValueError(f"Property type at index {idx} must be a string")
+        except ValueError as e:
+            raise ValueError(f"Invalid property type in property at index {idx}: {str(e)}")
+
+    try:
+        direction = EdgeDirection(data.get("direction"))
+    except ValueError:
+        raise ValueError(f"Invalid direction: must be INCOMING or OUTGOING, got \"{data.get('direction')}\"")
+
+    return validated_properties, direction
 
 def execute_node_expansion(
-    project: str,
-    instance: str,
-    database: str,
-    node_labels: list[str],
-    node_properties: list[NodeProperty],
-    graph: str,
-    uid: str,
-    direction: EdgeDirection,
-    edge_label: str = None):
+    params_str: str,
+    request: dict) -> dict:
+    """Execute a node expansion query to find connected nodes and edges.
+    
+    Args:
+        params_str: A JSON string containing connection parameters (project, instance, database, graph, mock).
+        request: A dictionary containing node expansion request details (uid, node_labels, node_properties, direction, edge_label).
+    
+    Returns:
+        dict: A dictionary containing the query response with nodes and edges.
+    """
+
+    params = json.loads(params_str)
+    node_properties, direction = validate_node_expansion_request(params | request)
+
+    project = params.get("project")
+    instance = params.get("instance")
+    database = params.get("database")
+    graph = params.get("graph")
+    uid = request.get("uid")
+    node_labels = request.get("node_labels")
+    edge_label = request.get("edge_label")
 
     edge = "e" if not edge_label else f"e:{edge_label}"
 
@@ -232,6 +312,8 @@ class GraphServerHandler(http.server.SimpleHTTPRequestHandler):
         self.do_json_response(data)
 
     def do_error_response(self, message):
+        if isinstance(message, Exception):
+            message = str(message)
         self.do_json_response({'error': message})
 
     def parse_post_data(self):
@@ -259,99 +341,26 @@ class GraphServerHandler(http.server.SimpleHTTPRequestHandler):
         self.do_data_response(response)
 
     def handle_post_node_expansion(self):
-        data = self.parse_post_data()
-        required_fields = ["project", "instance", "database", "graph", "uid", "node_labels", "direction"]
-        missing_fields = [field for field in required_fields if data.get(field) is None]
-        
-        if missing_fields:
-            self.do_error_response(f"Missing required fields: {', '.join(missing_fields)}")
-            return
-
-        project = data.get("project")
-        instance = data.get("instance")
-        database = data.get("database")
-        graph = data.get("graph")
-        uid = data.get("uid")
-        node_labels = data.get("node_labels")
-        node_properties = data.get("node_properties", [])
-        edge_label = data.get("edge_label")
-
-        # Validate node_labels
-        if not isinstance(node_labels, list):
-            self.do_error_response("node_labels must be an array")
-            return
-
-        for label in node_labels:
-            if not isinstance(label, str):
-                self.do_error_response("Each node label must be a string")
-                return
-
-        # Validate node_properties
-        if not isinstance(node_properties, list):
-            self.do_error_response("node_properties must be an array")
-            return
-            
-        validated_properties: list[NodeProperty] = []
-        for idx, prop in enumerate(node_properties):
-            if not isinstance(prop, dict):
-                self.do_error_response(f"Property at index {idx} must be an object")
-                return
-                
-            if not all(field in prop for field in ["key", "value", "type"]):
-                self.do_error_response(f"Property at index {idx} is missing required fields (key, value, type)")
-                return
-                
-            try:
-                prop_type_str = prop["type"]
-                if isinstance(prop_type_str, str):
-                    prop_type = validate_property_type(prop_type_str)
-                    
-                    value = prop["value"]
-                    if prop_type in (TypeCode.INT64, TypeCode.NUMERIC):
-                        if not (isinstance(value, int) or (isinstance(value, str) and value.isdigit())):
-                            self.do_error_response(f"Property '{prop['key']}' value must be a number for type {prop_type_str}")
-                            return
-                    elif prop_type in (TypeCode.FLOAT32, TypeCode.FLOAT64):
-                        try:
-                            float(value)
-                        except (ValueError, TypeError):
-                            self.do_error_response(f"Property '{prop['key']}' value must be a valid float for type {prop_type_str}")
-                            return
-                    elif prop_type == TypeCode.BOOL:
-                        if not isinstance(value, bool) and not (isinstance(value, str) and value.lower() in ["true", "false"]):
-                            self.do_error_response(f"Property '{prop['key']}' value must be a boolean for type {prop_type_str}")
-                            return
-                    
-                    validated_properties.append(NodeProperty(
-                        key=prop["key"],
-                        value=prop["value"],
-                        type=prop_type
-                    ))
-                else:
-                    self.do_error_response(f"Property type at index {idx} must be a string")
-                    return
-            except ValueError as e:
-                self.do_error_response(f"Invalid property type in property at index {idx}: {str(e)}")
-                return
+        """Handle POST requests for node expansion.
         
+        Expects a JSON payload with:
+        - params: A JSON string containing connection parameters (project, instance, database, graph)
+        - request: A dictionary with node details (uid, node_labels, node_properties, direction, edge_label)
+        """
         try:
-            direction = EdgeDirection(data.get("direction"))
-        except ValueError:
-            self.do_error_response(f"Invalid direction: must be INCOMING or OUTGOING, got \"{data.get('direction')}\"")
+            data = self.parse_post_data()
+
+            # Execute node expansion with:
+            # - params_str: JSON string with connection parameters (project, instance, database, graph)
+            # - request: Dict with node details (uid, node_labels, node_properties, direction, edge_label)
+            self.do_data_response(execute_node_expansion(
+                params_str=data.get("params"),
+                request=data.get("request")
+            ))
+        except BaseException as e:
+            self.do_error_response(e)
             return
 
-        self.do_data_response(execute_node_expansion(
-            project=project, 
-            instance=instance, 
-            database=database,
-            node_labels=node_labels,
-            node_properties=validated_properties,
-            graph=graph, 
-            uid=uid,
-            direction=direction,
-            edge_label=edge_label,
-        ))
-
     def do_GET(self):
         if self.path == GraphServer.endpoints["get_ping"]:
             self.handle_get_ping()

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.3}/spanner_graphs/magics.py

@@ -35,8 +35,8 @@ from jinja2 import Template
 
 from spanner_graphs.database import get_database_instance
 from spanner_graphs.graph_server import (
-    GraphServer, execute_query, execute_node_expansion, 
-    EdgeDirection, validate_property_type
+    GraphServer, execute_query, execute_node_expansion,
+    validate_node_expansion_request
 )
 from spanner_graphs.graph_visualization import generate_visualization_html
 
@@ -92,21 +92,32 @@ def receive_query_request(query: str, params: str):
                               query=query,
                               mock=params_dict["mock"]))
 
-def receive_node_expansion_request(request: dict, params: str):
-    """Handle node expansion requests in Google Colab environment"""
-    params_dict = json.loads(params)
-    return JSON(execute_node_expansion(
-        project=params_dict["project"],
-        instance=params_dict["instance"],
-        database=params_dict["database"],
-        graph=params_dict["graph"],
-        uid=request["uid"],
-        node_key_property_name=request["node_key_property_name"],
-        node_key_property_value=request["node_key_property_value"],
-        direction=EdgeDirection(request["direction"]),
-        edge_label=request.get("edge_label"),
-        property_type=validate_property_type(request["node_key_property_type"])
-    ))
+def receive_node_expansion_request(request: dict, params_str: str):
+    """Handle node expansion requests in Google Colab environment
+    
+    Args:
+        request: A dictionary containing node expansion details including:
+            - uid: str - Unique identifier of the node to expand
+            - node_labels: List[str] - Labels of the node
+            - node_properties: List[Dict] - Properties of the node with key, value, and type
+            - direction: str - Direction of expansion ("INCOMING" or "OUTGOING")
+            - edge_label: Optional[str] - Label of edges to filter by
+        params_str: A JSON string containing connection parameters:
+            - project: str - GCP project ID
+            - instance: str - Spanner instance ID
+            - database: str - Spanner database ID
+            - graph: str - Graph name
+            - mock: bool - Whether to use mock data
+    
+    Returns:
+        JSON: A JSON-serialized response containing either:
+            - The query results with nodes and edges
+            - An error message if the request failed
+    """
+    try:
+        return JSON(execute_node_expansion(params_str, request))
+    except BaseException as e:
+        return JSON({"error": e})
 
 @magics_class
 class NetworkVisualizationMagics(Magics):

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.3}/tests/graph_server_test.py

@@ -1,12 +1,11 @@
 import unittest
 from unittest.mock import patch, MagicMock
 from google.cloud.spanner_v1 import TypeCode
+import json
 
 from spanner_graphs.graph_server import (
     validate_property_type,
     execute_node_expansion,
-    EdgeDirection,
-    PROPERTY_TYPE_MAP
 )
 
 class TestPropertyTypeHandling(unittest.TestCase):
@@ -64,36 +63,42 @@ class TestPropertyTypeHandling(unittest.TestCase):
         
         test_cases = [
             # Numeric types (unquoted)
-            (TypeCode.INT64, "123", "123"),
-            (TypeCode.NUMERIC, "123.45", "123.45"),
-            (TypeCode.FLOAT32, "123.45", "123.45"),
-            (TypeCode.FLOAT64, "123.45", "123.45"),
+            ("INT64", "123", "123"),
+            ("NUMERIC", "123", "123"),
+            ("FLOAT32", "123.45", "123.45"),
+            ("FLOAT64", "123.45", "123.45"),
             # Boolean (unquoted)
-            (TypeCode.BOOL, "true", "true"),
+            ("BOOL", "true", "true"),
             # String types (quoted)
-            (TypeCode.STRING, "hello", '"hello"'),
-            (TypeCode.DATE, "2024-03-14", '"2024-03-14"'),
-            (TypeCode.TIMESTAMP, "2024-03-14T12:00:00Z", '"2024-03-14T12:00:00Z"'),
-            (TypeCode.BYTES, "base64data", '"base64data"'),
-            (TypeCode.ENUM, "ENUM_VALUE", '"ENUM_VALUE"'),
+            ("STRING", "hello", '"hello"'),
+            ("DATE", "2024-03-14", '"2024-03-14"'),
+            ("TIMESTAMP", "2024-03-14T12:00:00Z", '"2024-03-14T12:00:00Z"'),
+            ("BYTES", "base64data", '"base64data"'),
+            ("ENUM", "ENUM_VALUE", '"ENUM_VALUE"'),
         ]
         
-        base_args = {
+        params = json.dumps({
             "project": "test-project",
             "instance": "test-instance",
             "database": "test-database",
             "graph": "test-graph",
-            "uid": "test-uid",
-            "node_key_property_name": "test_property",
-            "direction": EdgeDirection.OUTGOING,
-        }
+        })
         
-        for type_code, value, expected_format in test_cases:
-            with self.subTest(type=type_code, value=value):
+        for type_str, value, expected_format in test_cases:
+            with self.subTest(type=type_str, value=value):
+                # Create a property dictionary
+                prop_dict = {"key": "test_property", "value": value, "type": type_str}
+                
+                request = {
+                    "uid": "test-uid",
+                    "node_labels": ["Person"],
+                    "node_properties": [prop_dict],
+                    "direction": "OUTGOING"
+                }
+                
                 execute_node_expansion(
-                    **base_args,
-                    node_key_property_value=value,
-                    property_type=type_code
+                    params_str=params,
+                    request=request
                 )
                 
                 # Extract the actual formatted value from the query
@@ -102,32 +107,44 @@ class TestPropertyTypeHandling(unittest.TestCase):
                 
                 # Find the WHERE clause in the query and extract the value
                 where_line = [line for line in query.split('\n') if 'WHERE' in line][0]
-                self.assertIn(f"= {expected_format}", where_line,
-                    f"Expected value {value} to be formatted as {expected_format} for type {type_code}")
-
+                expected_pattern = f"n.test_property={expected_format}"
+                self.assertIn(expected_pattern, where_line,
+                    f"Expected property value pattern {expected_pattern} not found in WHERE clause for type {type_str}")
+                    
     @patch('spanner_graphs.graph_server.execute_query')
     def test_property_value_formatting_no_type(self, mock_execute_query):
         """Test that property values are quoted when no type is provided."""
         mock_execute_query.return_value = {"response": {"nodes": [], "edges": []}}
         
+        # Create a property dictionary with string type (since null type is not allowed)
+        prop_dict = {"key": "test_property", "value": "test_value", "type": "STRING"}
+        
+        params = json.dumps({
+            "project": "test-project",
+            "instance": "test-instance",
+            "database": "test-database",
+            "graph": "test-graph",
+        })
+        
+        request = {
+            "uid": "test-uid",
+            "node_labels": ["Person"],
+            "node_properties": [prop_dict],
+            "direction": "OUTGOING"
+        }
+        
         execute_node_expansion(
-            project="test-project",
-            instance="test-instance",
-            database="test-database",
-            graph="test-graph",
-            uid="test-uid",
-            node_key_property_name="test_property",
-            node_key_property_value="test_value",
-            direction=EdgeDirection.OUTGOING,
-            property_type=None
+            params_str=params,
+            request=request
         )
         
         # Extract the actual formatted value from the query
         last_call = mock_execute_query.call_args[0]
         query = last_call[3]
         where_line = [line for line in query.split('\n') if 'WHERE' in line][0]
-        self.assertIn('= "test_value"', where_line,
-            "Value should be quoted when no type is provided")
+        expected_pattern = 'n.test_property="test_value"'
+        self.assertIn(expected_pattern, where_line,
+            "Property value should be quoted when string type is provided")
 
 if __name__ == '__main__':
     unittest.main() 

spanner_graph_notebook-1.1.3/tests/node_expansion_test.py

@@ -0,0 +1,165 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import json
+
+from spanner_graphs.magics import receive_node_expansion_request
+from spanner_graphs.graph_server import EdgeDirection, TypeCode
+
+class TestNodeExpansion(unittest.TestCase):
+    def setUp(self):
+        self.sample_request = {
+            "uid": "node-123",
+            "node_key_property_name": "id",
+            "node_key_property_value": "123",
+            "node_key_property_type": "INT64",
+            "direction": "OUTGOING",
+            "edge_label": "CONNECTS_TO"
+        }
+        self.sample_params = json.dumps({
+            "project": "test-project",
+            "instance": "test-instance",
+            "database": "test-database",
+            "graph": "test_graph",
+            "mock": False
+        })
+
+    @patch('spanner_graphs.magics.validate_node_expansion_request')
+    @patch('spanner_graphs.magics.execute_node_expansion')
+    def test_receive_node_expansion_request(self, mock_execute, mock_validate):
+        """Test that the receive_node_expansion_request function correctly processes requests."""
+        # Setup mock return values
+        mock_validate.return_value = ([], EdgeDirection.OUTGOING)
+        mock_execute.return_value = {
+            "response": {
+                "nodes": [],
+                "edges": []
+            }
+        }
+        
+        # Create request and params objects
+        request = {
+            "uid": "node-123",
+            "node_labels": ["Person"],
+            "node_properties": [
+                {"key": "id", "value": "123", "type": "INT64"}
+            ],
+            "direction": "OUTGOING",
+            "edge_label": "CONNECTS_TO"
+        }
+        
+        params = json.dumps({
+            "project": "test-project",
+            "instance": "test-instance",
+            "database": "test-database",
+            "graph": "test_graph",
+            "mock": False
+        })
+        
+        # Call the function
+        result = receive_node_expansion_request(request, params)
+        
+        # Verify execute_node_expansion was called with correct parameters
+        mock_execute.assert_called_once_with(params, request)
+        
+        # Verify the result is wrapped in JSON
+        self.assertEqual(result.data, mock_execute.return_value)
+
+    @patch('spanner_graphs.magics.validate_node_expansion_request')
+    @patch('spanner_graphs.magics.execute_node_expansion')
+    def test_receive_node_expansion_request_without_edge_label(self, mock_execute, mock_validate):
+        """Test that the receive_node_expansion_request function correctly handles missing edge_label."""
+        # Setup mock return values
+        mock_validate.return_value = ([], EdgeDirection.OUTGOING)
+        mock_execute.return_value = {
+            "response": {
+                "nodes": [],
+                "edges": []
+            }
+        }
+        
+        # Create request without edge_label and params objects
+        request = {
+            "uid": "node-123",
+            "node_labels": ["Person"],
+            "node_properties": [
+                {"key": "id", "value": "123", "type": "INT64"}
+            ],
+            "direction": "OUTGOING"
+            # No edge_label
+        }
+        
+        params = json.dumps({
+            "project": "test-project",
+            "instance": "test-instance",
+            "database": "test-database",
+            "graph": "test_graph",
+            "mock": False
+        })
+        
+        # Call the function
+        result = receive_node_expansion_request(request, params)
+        
+        # Verify execute_node_expansion was called with correct parameters
+        mock_execute.assert_called_once_with(params, request)
+        
+        # Verify the result is wrapped in JSON
+        self.assertEqual(result.data, mock_execute.return_value)
+        
+    @patch('spanner_graphs.magics.validate_node_expansion_request')
+    def test_invalid_property_type(self, mock_validate):
+        """Test that invalid property types are correctly caught."""
+        # Set up the mock to raise a ValueError when called with invalid data
+        mock_validate.side_effect = ValueError("Invalid property type")
+        
+        # Create a request with invalid property type
+        request = {
+            "uid": "node-123",
+            "node_labels": ["Person"],
+            "node_properties": [
+                {"key": "id", "value": "123", "type": "INVALID_TYPE"}
+            ],
+            "direction": "OUTGOING"
+        }
+        
+        params = json.dumps({
+            "project": "test-project",
+            "instance": "test-instance",
+            "database": "test-database",
+            "graph": "test_graph",
+            "mock": False
+        })
+
+        # Call the function and verify it returns an error response
+        result = receive_node_expansion_request(request, params)
+        self.assertIn("error", result.data)
+        
+    @patch('spanner_graphs.magics.validate_node_expansion_request')
+    def test_invalid_direction(self, mock_validate):
+        """Test that invalid directions are correctly caught."""
+        # Set up the mock to raise a ValueError when called with invalid data
+        mock_validate.side_effect = ValueError("Invalid direction")
+        
+        # Create a request with invalid direction
+        request = {
+            "uid": "node-123",
+            "node_labels": ["Person"],
+            "node_properties": [
+                {"key": "id", "value": "123", "type": "INT64"}
+            ],
+            "direction": "INVALID_DIRECTION"
+        }
+        
+        params = json.dumps({
+            "project": "test-project",
+            "instance": "test-instance",
+            "database": "test-database",
+            "graph": "test_graph",
+            "mock": False
+        })
+
+        # Call the function and verify it returns an error response
+        result = receive_node_expansion_request(request, params)
+        self.assertIn("error", result.data)
+
+if __name__ == '__main__':
+    unittest.main() 

{spanner_graph_notebook-1.1.2 → spanner_graph_notebook-1.1.3}/tests/server_test.py

@@ -14,6 +14,7 @@
 
 import unittest
 import requests
+import json
 from spanner_graphs.graph_server import GraphServer
 
 class TestSpannerServer(unittest.TestCase):
@@ -39,13 +40,17 @@ class TestSpannerServer(unittest.TestCase):
         # Build the request URL
         route = GraphServer.build_route(GraphServer.endpoints["post_query"])
         
-        # Create request data
-        request_data = {
+        # Create request data with the new structure
+        params = json.dumps({
             "project": "test-project",
             "instance": "test-instance",
             "database": "test-database",
-            "query": "GRAPH TestGraph MATCH (n) RETURN n",
             "mock": True
+        })
+        
+        request_data = {
+            "params": params,
+            "query": "GRAPH TestGraph MATCH (n) RETURN n"
         }
 
         # Send POST request
@@ -82,5 +87,32 @@ class TestSpannerServer(unittest.TestCase):
         self.assertIn("source_node_identifier", edge)
         self.assertIn("destination_node_identifier", edge)
 
+    def test_node_expansion_error_handling(self):
+        """Test that errors in node expansion are properly handled and returned."""
+        # Build the request URL
+        route = GraphServer.build_route(GraphServer.endpoints["post_node_expansion"])
+        
+        # Create request data with invalid fields to trigger validation error
+        request_data = {
+            "project": "test-project",
+            "instance": "test-instance",
+            "database": "test-database",
+            "graph": "test-graph",
+            "uid": "test-uid",
+            # Missing required node_labels field
+            "direction": "INVALID_DIRECTION"  # Invalid direction
+        }
+
+        # Send POST request
+        response = requests.post(route, json=request_data)
+        
+        # Verify response
+        self.assertEqual(response.status_code, 200)  # Server still returns 200 but with error data
+        response_data = response.json()
+        
+        # Check error presence
+        self.assertIn("error", response_data)
+        self.assertIsNotNone(response_data["error"])
+
 if __name__ == '__main__':
     unittest.main()

spanner_graph_notebook-1.1.2/tests/node_expansion_test.py

@@ -1,106 +0,0 @@
-import unittest
-from unittest.mock import patch, MagicMock
-import json
-
-from spanner_graphs.magics import receive_node_expansion_request
-from spanner_graphs.graph_server import EdgeDirection, TypeCode
-
-class TestNodeExpansion(unittest.TestCase):
-    def setUp(self):
-        self.sample_request = {
-            "uid": "node-123",
-            "node_key_property_name": "id",
-            "node_key_property_value": "123",
-            "node_key_property_type": "INT64",
-            "direction": "OUTGOING",
-            "edge_label": "CONNECTS_TO"
-        }
-        self.sample_params = json.dumps({
-            "project": "test-project",
-            "instance": "test-instance",
-            "database": "test-database",
-            "graph": "test_graph",
-            "mock": False
-        })
-
-    @patch('spanner_graphs.magics.execute_node_expansion')
-    def test_receive_node_expansion_request(self, mock_execute):
-        # Setup mock return value
-        mock_execute.return_value = {
-            "response": {
-                "nodes": [],
-                "edges": []
-            }
-        }
-
-        # Call the function
-        result = receive_node_expansion_request(self.sample_request, self.sample_params)
-
-        # Verify execute_node_expansion was called with correct parameters
-        mock_execute.assert_called_once_with(
-            project="test-project",
-            instance="test-instance",
-            database="test-database",
-            graph="test_graph",
-            uid="node-123",
-            node_key_property_name="id",
-            node_key_property_value="123",
-            direction=EdgeDirection.OUTGOING,
-            edge_label="CONNECTS_TO",
-            property_type=TypeCode.INT64
-        )
-
-        # Verify the result is wrapped in JSON
-        self.assertEqual(result.data, mock_execute.return_value)
-
-    @patch('spanner_graphs.magics.execute_node_expansion')
-    def test_receive_node_expansion_request_without_edge_label(self, mock_execute):
-        # Remove edge_label from request
-        request = dict(self.sample_request)
-        del request["edge_label"]
-
-        # Setup mock return value
-        mock_execute.return_value = {
-            "response": {
-                "nodes": [],
-                "edges": []
-            }
-        }
-
-        # Call the function
-        result = receive_node_expansion_request(request, self.sample_params)
-
-        # Verify execute_node_expansion was called with correct parameters
-        mock_execute.assert_called_once_with(
-            project="test-project",
-            instance="test-instance",
-            database="test-database",
-            graph="test_graph",
-            uid="node-123",
-            node_key_property_name="id",
-            node_key_property_value="123",
-            direction=EdgeDirection.OUTGOING,
-            edge_label=None,
-            property_type=TypeCode.INT64
-        )
-
-    def test_invalid_property_type(self):
-        # Modify request to have invalid property type
-        request = dict(self.sample_request)
-        request["node_key_property_type"] = "INVALID_TYPE"
-
-        # Verify it raises ValueError
-        with self.assertRaises(ValueError):
-            receive_node_expansion_request(request, self.sample_params)
-
-    def test_invalid_direction(self):
-        # Modify request to have invalid direction
-        request = dict(self.sample_request)
-        request["direction"] = "INVALID_DIRECTION"
-
-        # Verify it raises ValueError
-        with self.assertRaises(ValueError):
-            receive_node_expansion_request(request, self.sample_params)
-
-if __name__ == '__main__':
-    unittest.main()