Add tests for deprecation warnings

Co-authored-by: Olga Razvenskaia <olga.razvenskaia@neo4j.com>

Author: brs96

graphdatascience/graph/graph_alpha_proc_runner.py

@@ -1,3 +1,4 @@
+import os
 from typing import List, Optional, Union
 
 from pandas import DataFrame
@@ -11,7 +12,6 @@
 from .graph_alpha_project_runner import GraphAlphaProjectRunner
 from .graph_entity_ops_runner import GraphLabelRunner, GraphPropertyRunner
 from .graph_object import Graph
-from .graph_proc_runner import GraphProcRunner
 from .graph_sample_runner import GraphAlphaSampleRunner
 
 
@@ -37,7 +37,7 @@ def project(self) -> GraphAlphaProjectRunner:
         return GraphAlphaProjectRunner(self._query_runner, self._namespace, self._server_version)
 
     @client_only_endpoint("gds.alpha.graph")
-    @deprecation_warning("gds.graph", ServerVersion(2, 1, 0))
+    @deprecation_warning("gds.graph.construct", ServerVersion(2, 1, 0))
     @compatible_with("construct", min_inclusive=ServerVersion(2, 1, 0))
     def construct(
         self,
@@ -47,5 +47,39 @@ def construct(
         concurrency: int = 4,
         undirected_relationship_types: Optional[List[str]] = None,
     ) -> Graph:
-        graph_proc_runner = GraphProcRunner(self._query_runner, f"{self._namespace}.graph", self._server_version)
-        return graph_proc_runner.construct(graph_name, nodes, relationships, concurrency, undirected_relationship_types)
+        nodes = nodes if isinstance(nodes, List) else [nodes]
+        relationships = relationships if isinstance(relationships, List) else [relationships]
+
+        errors = []
+
+        exists = self._query_runner.run_query(
+            f"CALL gds.graph.exists('{graph_name}') YIELD exists", custom_error=False
+        ).squeeze()
+
+        # compare against True as (1) unit tests return None here and (2) numpys True does not work with `is True`.
+        if exists == True:  # noqa: E712
+            errors.append(
+                f"Graph '{graph_name}' already exists. Please drop the existing graph or use a different name."
+            )
+
+        for idx, node_df in enumerate(nodes):
+            if "nodeId" not in node_df.columns.values:
+                errors.append(f"Node dataframe at index {idx} needs to contain a 'nodeId' column.")
+
+        for idx, rel_df in enumerate(relationships):
+            for expected_col in ["sourceNodeId", "targetNodeId"]:
+                if expected_col not in rel_df.columns.values:
+                    errors.append(f"Relationship dataframe at index {idx} needs to contain a '{expected_col}' column.")
+
+        if self._server_version < ServerVersion(2, 3, 0) and undirected_relationship_types:
+            errors.append("The parameter 'undirected_relationship_types' is only supported since GDS 2.3.0.")
+
+        if len(errors) > 0:
+            raise ValueError(os.linesep.join(errors))
+
+        constructor = self._query_runner.create_graph_constructor(
+            graph_name, concurrency, undirected_relationship_types
+        )
+        constructor.run(nodes, relationships)
+
+        return Graph(graph_name, self._query_runner, self._server_version)

graphdatascience/tests/integration/test_graph_construct.py

@@ -188,7 +188,7 @@ def test_roundtrip_with_arrow_encrypted(gds_with_tls: GraphDataScience) -> None:
     rel_df = gds_with_tls.graph.streamRelationshipProperty(G, "relX")
     node_df = gds_with_tls.graph.streamNodeProperty(G, "x")
 
-    G_2 = gds_with_tls.alpha.graph.construct("arrowGraph", node_df, rel_df)
+    G_2 = gds_with_tls.graph.construct("arrowGraph", node_df, rel_df)
 
     try:
         assert G.node_count() == G_2.node_count()
@@ -198,7 +198,7 @@ def test_roundtrip_with_arrow_encrypted(gds_with_tls: GraphDataScience) -> None:
 
 
 @pytest.mark.filterwarnings("ignore: GDS Enterprise users can use Apache Arrow")
-def test_graph_alpha_construct_without_arrow(gds_without_arrow: GraphDataScience) -> None:
+def test_graph_construct_without_arrow(gds_without_arrow: GraphDataScience) -> None:
     nodes = DataFrame(
         {
             "nodeId": [0, 1, 2, 3],
@@ -218,7 +218,7 @@ def test_graph_alpha_construct_without_arrow(gds_without_arrow: GraphDataScience
         }
     )
 
-    G = gds_without_arrow.alpha.graph.construct("hello", nodes, relationships)
+    G = gds_without_arrow.graph.construct("hello", nodes, relationships)
 
     try:
         assert G.name() == "hello"
@@ -234,7 +234,7 @@ def test_graph_alpha_construct_without_arrow(gds_without_arrow: GraphDataScience
 
 @pytest.mark.filterwarnings("ignore: GDS Enterprise users can use Apache Arrow")
 @pytest.mark.compatible_with(min_inclusive=ServerVersion(2, 3, 0))
-def test_graph_alpha_construct_undirected_without_arrow(gds_without_arrow: GraphDataScience) -> None:
+def test_graph_construct_undirected_without_arrow(gds_without_arrow: GraphDataScience) -> None:
     nodes = DataFrame(
         {
             "nodeId": [0, 1, 2, 3],
@@ -249,7 +249,7 @@ def test_graph_alpha_construct_undirected_without_arrow(gds_without_arrow: Graph
         }
     )
 
-    G = gds_without_arrow.alpha.graph.construct("hello", nodes, relationships, undirected_relationship_types=["REL2"])
+    G = gds_without_arrow.graph.construct("hello", nodes, relationships, undirected_relationship_types=["REL2"])
 
     try:
         assert G.name() == "hello"
@@ -262,7 +262,7 @@ def test_graph_alpha_construct_undirected_without_arrow(gds_without_arrow: Graph
 
 @pytest.mark.filterwarnings("ignore: GDS Enterprise users can use Apache Arrow")
 @pytest.mark.compatible_with(max_exclusive=ServerVersion(2, 3, 0))
-def warn_for_graph_alpha_construct_undirected_without_arrow(gds_without_arrow: GraphDataScience) -> None:
+def warn_for_graph_construct_undirected_without_arrow(gds_without_arrow: GraphDataScience) -> None:
     nodes = DataFrame(
         {
             "nodeId": [0, 1, 2, 3],
@@ -277,7 +277,7 @@ def warn_for_graph_alpha_construct_undirected_without_arrow(gds_without_arrow: G
     )
 
     with pytest.raises(ValueError):
-        gds_without_arrow.alpha.graph.construct("hello", nodes, relationships, undirected_relationship_types=["REL2"])
+        gds_without_arrow.graph.construct("hello", nodes, relationships, undirected_relationship_types=["REL2"])
 
 
 @pytest.mark.enterprise
@@ -297,7 +297,7 @@ def test_graph_construct_with_arrow(gds: GraphDataScience) -> None:
 
 @pytest.mark.filterwarnings("ignore: GDS Enterprise users can use Apache Arrow")
 @pytest.mark.compatible_with(max_exlusive=ServerVersion(2, 3, 0))
-def warn_for_graph_alpha_construct_undirected_with_arrow(gds: GraphDataScience) -> None:
+def warn_for_graph_construct_undirected_with_arrow(gds: GraphDataScience) -> None:
     nodes = DataFrame(
         {
             "nodeId": [0, 1, 2, 3],
@@ -400,7 +400,7 @@ def test_graph_construct_without_arrow_enterprise_warning(gds_without_arrow: Gra
     relationships = DataFrame({"sourceNodeId": [0, 1, 2, 3], "targetNodeId": [1, 2, 3, 0]})
 
     with pytest.warns(UserWarning):
-        G = gds_without_arrow.alpha.graph.construct("hello", nodes, relationships)
+        G = gds_without_arrow.graph.construct("hello", nodes, relationships)
         G.drop()
 
 
@@ -416,7 +416,7 @@ def test_graph_construct_without_arrow_multi_dfs(gds_without_arrow: GraphDataSci
         DataFrame({"sourceNodeId": [2, 3], "targetNodeId": [3, 0], "relationshipType": ["B", "B"]}),
     ]
 
-    G = gds_without_arrow.alpha.graph.construct("hello", nodes, relationships)
+    G = gds_without_arrow.graph.construct("hello", nodes, relationships)
 
     assert G.name() == "hello"
     assert G.node_count() == 4
@@ -462,3 +462,24 @@ def test_graph_construct_with_arrow_no_db() -> None:
 
     with pytest.raises(ValueError):
         gds.graph.construct("hello", nodes, relationships)
+
+
+@pytest.mark.filterwarnings("ignore: GDS Enterprise users can use Apache Arrow")
+def test_graph_alpha_construct_backward_compat_without_arrow(gds_without_arrow: GraphDataScience) -> None:
+    nodes = DataFrame({"nodeId": [0, 1, 2, 3], "labels": [["A"], "B", ["C", "A"], ["D"]]})
+    relationships = DataFrame(
+        {"sourceNodeId": [0, 1, 2, 3], "targetNodeId": [1, 2, 3, 0], "relationshipType": ["REL", "REL", "REL", "REL2"]}
+    )
+
+    with pytest.warns(DeprecationWarning):
+        gds_without_arrow.alpha.graph.construct("hello", nodes, relationships)
+
+
+@pytest.mark.enterprise
+@pytest.mark.compatible_with(min_inclusive=ServerVersion(2, 1, 0))
+def test_graph_alpha_construct_backward_compat_with_arrow(gds: GraphDataScience) -> None:
+    nodes = DataFrame({"nodeId": [0, 1, 2, 3]})
+    relationships = DataFrame({"sourceNodeId": [0, 1, 2, 3], "targetNodeId": [1, 2, 3, 0]})
+
+    with pytest.warns(DeprecationWarning):
+        gds.alpha.graph.construct("hello", nodes, relationships)

graphdatascience/tests/unit/test_graph_construct.py

@@ -7,9 +7,7 @@
 
 
 @pytest.mark.parametrize("server_version", [ServerVersion(2, 1, 0)])
-def test_graph_project_based_alpha_construct_without_arrow(
-    runner: CollectingQueryRunner, gds: GraphDataScience
-) -> None:
+def test_graph_project_based_construct_without_arrow(runner: CollectingQueryRunner, gds: GraphDataScience) -> None:
     nodes = DataFrame(
         {
             "nodeId": [0, 1],
@@ -144,7 +142,7 @@ def test_multi_df(
     ],
     ids=["2.3.0 - Alpha Cypher Aggregation", "2.4.0 - New Cypher projection"],
 )
-def test_graph_aggregation_based_alpha_construct_without_arrow(
+def test_graph_aggregation_based_construct_without_arrow(
     runner: CollectingQueryRunner,
     gds: GraphDataScience,
     tier: str,
@@ -210,7 +208,7 @@ def test_graph_aggregation_based_alpha_construct_without_arrow(
 
 
 @pytest.mark.parametrize("server_version", [ServerVersion(2, 3, 0)])
-def test_graph_aggregation_based_alpha_construct_without_arrow_with_overlapping_property_columns(
+def test_graph_aggregation_based_construct_without_arrow_with_overlapping_property_columns(
     runner: CollectingQueryRunner, gds: GraphDataScience
 ) -> None:
     nodes = DataFrame(
@@ -236,9 +234,31 @@ def test_graph_aggregation_based_alpha_construct_without_arrow_with_overlapping_
 
 
 @pytest.mark.parametrize("server_version", [ServerVersion(2, 1, 0)])
-def test_graph_alpha_construct_validate_df_columns(runner: CollectingQueryRunner, gds: GraphDataScience) -> None:
+def test_graph_construct_validate_df_columns(runner: CollectingQueryRunner, gds: GraphDataScience) -> None:
     nodes = DataFrame({"nodeIds": [0, 1]})
     relationships = DataFrame({"sourceNodeId": [0, 1], "TargetNodeIds": [1, 0]})
 
     with pytest.raises(ValueError, match=r"(.*'nodeId'.*\s.*'targetNodeId'.*)|(.*'targetNodeId'.*\s.*'nodeId'.*)"):
         gds.graph.construct("hello", nodes, relationships, concurrency=2)
+
+
+@pytest.mark.parametrize("server_version", [ServerVersion(2, 1, 0)])
+def test_graph_alpha_construct_backward_compat(runner: CollectingQueryRunner, gds: GraphDataScience) -> None:
+    nodes = DataFrame(
+        {
+            "nodeId": [0, 1],
+            "labels": [["A"], ["B"]],
+            "propA": [1337, 42.1],
+        }
+    )
+    relationships = DataFrame(
+        {
+            "sourceNodeId": [0, 1],
+            "targetNodeId": [1, 0],
+            "relationshipType": ["REL", "REL2"],
+            "relPropA": [1337.2, 42],
+        }
+    )
+
+    with pytest.warns(DeprecationWarning):
+        gds.alpha.graph.construct("hello", nodes, relationships, concurrency=2)