update tests

Author: SageGJ

tests/unit/synapseclient/extensions/unit_test_create_json_schema.py

@@ -6,18 +6,23 @@
 import json
 import logging
 import os
+import tempfile
+from time import sleep
 from typing import Any, Optional
 from unittest import mock
 from unittest.mock import Mock
 
+import pandas as pd
 import pytest
 from jsonschema import Draft7Validator
 from jsonschema.exceptions import ValidationError
 
 from synapseclient.extensions.curator.schema_generation import (
     AtomicColumnType,
     ColumnType,
+    DataModelGraph,
     DataModelGraphExplorer,
+    DataModelParser,
     GraphTraversalState,
     JSONSchema,
     JSONSchemaFormat,
@@ -408,6 +413,48 @@ def test_node_init(
         assert warning_message in test_nodes[node_name].logger.mock_calls[0][1][0]
 
 
+def test_invalid_regex_columntype_traversalnode(
+    helpers,
+) -> None:
+    """
+    Tests for TraversalNode class initialization.
+
+    Verifies that when TransversalNode objects are initialized with a patter specified and an incompatible column type, a ValueError is raised.
+    """
+    node = "Check Regex Single"
+
+    path_to_data_model = helpers.get_schema_file_path("data_models/example.model.csv")
+
+    fullpath = helpers.get_schema_file_path(path_to_data_model)
+
+    # Instantiate DataModelParser
+    data_model_parser = DataModelParser(path_to_data_model=fullpath, logger=Mock())
+
+    # Parse Model
+    parsed_data_model = data_model_parser.parse_model()
+
+    # Change column type to imcompatible type
+    parsed_data_model[node]["Relationships"]["ColumnType"] = "integer"
+
+    # Instantiate DataModelGraph
+    data_model_grapher = DataModelGraph(
+        parsed_data_model, data_model_labels="class_label", logger=Mock()
+    )
+
+    # Generate graph
+    graph_data_model = data_model_grapher.graph
+
+    # Instantiate DataModelGraphExplorer
+    dmge = DataModelGraphExplorer(graph_data_model, logger=Mock())
+
+    # A value error should be raised when using pattern specification with non-string column type
+    error_message = "Column type must be set to 'string' to use column pattern specification for regex validation."
+    with pytest.raises(ValueError, match=error_message):
+        node = TraversalNode(
+            node.replace(" ", ""), "JSONSchemaComponent", dmge, logger=Mock()
+        )
+
+
 @pytest.mark.parametrize(
     "node_name, expected_node_type, expected_max, expected_min",
     [

tests/unit/synapseclient/extensions/unit_test_data_model_graph_explorer.py

@@ -69,6 +69,20 @@ def test_get_node_column_type(
     assert dmge.get_node_column_type(node_label) == column_type
 
 
+@pytest.mark.parametrize(
+    "node_label, pattern",
+    [
+        ("CheckRegexSingle", "[a-b]"),
+        ("CheckRegexFormat", "^[a-b]"),
+        ("CheckRegexInteger", None),
+    ],
+)
+def test_get_node_pattern(
+    dmge: DataModelGraphExplorer, node_label: str, pattern: str
+) -> None:
+    assert dmge.get_node_column_pattern(node_label) == pattern
+
+
 @pytest.mark.parametrize(
     "node_label, column_type",
     [("String", None), ("Date", JSONSchemaFormat.DATE), ("URL", JSONSchemaFormat.URI)],

tests/unit/synapseclient/extensions/unit_test_data_model_parser.py

@@ -1,6 +1,9 @@
+import tempfile
+from time import sleep
 from typing import Any, Union
 
 import numpy as np
+import pandas as pd
 import pytest
 
 from synapseclient.extensions.curator.schema_generation import (
@@ -87,6 +90,23 @@ def test_parse_format(
     ) -> None:
         assert csv_dmp.parse_format(attribute_dict) == expected_dict
 
+    @pytest.mark.parametrize(
+        "attribute_dict, expected_dict",
+        [
+            ({}, {}),
+            ({"Pattern": np.nan}, {}),
+            ({"Pattern": "^[a-b]"}, {"Pattern": "^[a-b]"}),
+            ({"Pattern": "  [a-b]  "}, {"Pattern": "[a-b]"}),
+        ],
+    )
+    def test_parse_regex_pattern(
+        self,
+        csv_dmp: DataModelCSVParser,
+        attribute_dict: dict[str, Any],
+        expected_dict: dict[str, str],
+    ) -> None:
+        assert csv_dmp.parse_pattern(attribute_dict) == expected_dict
+
     @pytest.mark.parametrize(
         "attribute_dict, relationship, expected_dict",
         [
@@ -132,7 +152,6 @@ def test_parse_minimum_maximum(
                 == expected_dict
             )
 
-
 class TestDataModelJsonLdParser:
     def test_gather_jsonld_attributes_relationships(
         self,
@@ -143,8 +162,6 @@ def test_gather_jsonld_attributes_relationships(
         assert csv_dmp.parse_minimum_maximum(attribute_dict, "Minimum") == expected_dict
         assert csv_dmp.parse_minimum_maximum(attribute_dict, "Maximum") == expected_dict
 
-
-class TestDataModelJsonLdParser:
     def test_gather_jsonld_attributes_relationships(
         self,
         helpers,

tests/unit/synapseclient/extensions/unit_test_data_model_relationships.py

@@ -71,6 +71,7 @@ def test_retrieve_rel_headers_dict(self, dmr: DataModelRelationships, edge: bool
                 "id": "Source",
                 "maximum": "Maximum",
                 "minimum": "Minimum",
+                "pattern": "Pattern",
             }
 
     def test_get_relationship_value(self, dmr: DataModelRelationships) -> None: