Move json utils tests

Author: simonkurtz-MSFT

shared/python/utils.py

@@ -628,7 +628,6 @@ def get_azure_role_guid(role_name: str) -> Optional[str]:
 
         return None
 
-
 def create_bicep_deployment_group(rg_name: str, rg_location: str, deployment: str | INFRASTRUCTURE, bicep_parameters: dict, bicep_parameters_file: str = 'params.json', rg_tags: dict | None = None, is_debug: bool = False) -> Output:
     """
     Create a Bicep deployment in a resource group, writing parameters to a file and running the deployment.
@@ -693,7 +692,6 @@ def create_bicep_deployment_group(rg_name: str, rg_location: str, deployment: st
     print('\nDeploying bicep...\n')
     return run(cmd, f"Deployment '{deployment_name}' succeeded", f"Deployment '{deployment_name}' failed.", print_command_to_run = False)
 
-
 # TODO: Reconcile this with apimtypes.py _get_project_root
 def find_project_root() -> str:
     """
@@ -720,7 +718,6 @@ def find_project_root() -> str:
     # If we can't find the project root, raise an error
     raise FileNotFoundError('Could not determine project root directory')
 
-
 def create_bicep_deployment_group_for_sample(sample_name: str, rg_name: str, rg_location: str, bicep_parameters: dict, bicep_parameters_file: str = 'params.json', rg_tags: dict | None = None, is_debug: bool = False) -> Output:
     """
     Create a Bicep deployment for a sample, handling the working directory change automatically.
@@ -774,7 +771,6 @@ def create_bicep_deployment_group_for_sample(sample_name: str, rg_name: str, rg_
         os.chdir(original_cwd)
         print(f'📁 Restored working directory to: {original_cwd}')
 
-
 def create_resource_group(rg_name: str, resource_group_location: str | None = None, tags: dict | None = None) -> None:
     """
     Create a resource group in Azure if it does not already exist.
@@ -1065,80 +1061,6 @@ def read_policy_xml(policy_xml_filepath_or_filename: str, named_values: dict[str
 
     return policy_template_xml
 
-def extract_json(text: str) -> Any:
-    """
-    Extract the first valid JSON object or array from a string and return it as a Python object.
-
-    This function searches the input string for the first occurrence of a JSON object or array (delimited by '{' or '['),
-    and attempts to decode it using json.JSONDecoder().raw_decode. If the input is already valid JSON, it is returned as a Python object.
-    If no valid JSON is found, None is returned.
-
-    Args:
-        text (str): The string to search for a JSON object or array.
-
-    Returns:
-        Any | None: The extracted JSON as a Python object (dict or list), or None if not found or not valid.
-    """
-
-    if not isinstance(text, str):
-        return None
-
-    # If the string is already valid JSON, parse and return it as a Python object.
-    if is_string_json(text):
-        try:
-            return json.loads(text)
-        except json.JSONDecodeError:
-            # If JSON parsing fails despite is_string_json returning True,
-            # fall through to substring search
-            pass
-
-    decoder = json.JSONDecoder()
-
-    for start in range(len(text)):
-        if text[start] in ('{', '['):
-            try:
-                obj, _ = decoder.raw_decode(text[start:])
-                return obj
-            except Exception:
-                continue
-
-    return None
-
-def is_string_json(text: str) -> bool:
-    """
-    Check if the provided string is a valid JSON object or array.
-
-    Args:
-        text (str): The string to check.
-
-    Returns:
-        bool: True if the string is valid JSON, False otherwise.
-    """
-
-    # Accept only str, bytes, or bytearray as valid input for JSON parsing.
-    if not isinstance(text, (str, bytes, bytearray)):
-        return False
-
-    # Skip empty or whitespace-only strings
-    if not text or not text.strip():
-        return False
-
-    # First try JSON parsing (handles double quotes)
-    try:
-        json.loads(text)
-        return True
-    except json.JSONDecodeError:
-        pass
-
-    # If JSON fails, try Python literal evaluation (handles single quotes)
-    try:
-        ast.literal_eval(text)
-        return True
-    except (ValueError, SyntaxError):
-        pass
-
-    return False
-
 def get_account_info() -> Tuple[str, str, str, str]:
     """
     Retrieve the current Azure account information using the Azure CLI.
@@ -1225,7 +1147,6 @@ def get_frontdoor_url(deployment_name: INFRASTRUCTURE, rg_name: str) -> str | No
 
     return afd_endpoint_url
 
-
 def get_apim_url(rg_name: str) -> str | None:
     """
     Retrieve the gateway URL for the API Management service in the specified resource group.
@@ -1255,7 +1176,6 @@ def get_apim_url(rg_name: str) -> str | None:
 
     return apim_endpoint_url
 
-
 def get_appgw_endpoint(rg_name: str) -> tuple[str | None, str | None]:
     """
     Retrieve the hostname and public IP address for the Application Gateway in the specified resource group.
@@ -1661,8 +1581,6 @@ def test_url_preflight_check(deployment: INFRASTRUCTURE, rg_name: str, apim_gate
 
     return endpoint_url
 
-
-
 def get_endpoints(deployment: INFRASTRUCTURE, rg_name: str) -> Endpoints:
     print_message(f'Identifying possible endpoints for infrastructure {deployment}...')
 

tests/python/test_json_utils.py

@@ -0,0 +1,81 @@
+"""
+Unit tests for test_utils.py.
+"""
+
+import pytest
+import json
+import json_utils
+
+
+# ------------------------------
+#    is_string_json
+# ------------------------------
+
+@pytest.mark.parametrize(
+    'input_str,expected',
+    [
+        ('{\"a\": 1}', True),
+        ('[1, 2, 3]', True),
+        ('not json', False),
+        ('{\"a\": 1', False),
+        ('', False),
+        (None, False),
+        (123, False),
+    ]
+)
+def test_is_string_json(input_str, expected):
+    assert json_utils.is_string_json(input_str) is expected
+
+
+# ------------------------------
+#    EXTRACT_JSON EDGE CASES
+# ------------------------------
+
+@pytest.mark.parametrize(
+    'input_val,expected',
+    [
+        (None, None),
+        (123, None),
+        ([], None),
+        ('', None),
+        ('   ', None),
+        ('not json', None),
+        ('{\"a\": 1}', {'a': 1}),
+        ('[1, 2, 3]', [1, 2, 3]),
+        ('  {\"a\": 1}  ', {'a': 1}),
+        ('prefix {\"foo\": 42} suffix', {'foo': 42}),
+        ('prefix [1, 2, 3] suffix', [1, 2, 3]),
+        ('{\"a\": 1}{\"b\": 2}', {'a': 1}),  # Only first JSON object
+        ('[1, 2, 3][4, 5, 6]', [1, 2, 3]),  # Only first JSON array
+        ('{\"a\": [1, 2, {\"b\": 3}]}', {'a': [1, 2, {'b': 3}]}),
+        ('\n\t{\"a\": 1}\n', {'a': 1}),
+        ('{\"a\": \"b \\u1234\"}', {'a': 'b \u1234'}),
+        ('{\"a\": 1} [2, 3]', {'a': 1}),  # Object before array
+        ('[2, 3] {\"a\": 1}', [2, 3]),  # Array before object
+        ('{\"a\": 1, \"b\": {\"c\": 2}}', {'a': 1, 'b': {'c': 2}}),
+        ('{\"a\": 1, \"b\": [1, 2, 3]}', {'a': 1, 'b': [1, 2, 3]}),
+        ('\n\n[\n1, 2, 3\n]\n', [1, 2, 3]),
+        ('{\"a\": 1, \"b\": null}', {'a': 1, 'b': None}),
+        ('{\"a\": true, \"b\": false}', {'a': True, 'b': False}),
+        ('{\"a\": 1, \"b\": \"c\"}', {'a': 1, 'b': 'c'}),
+        ('{\"a\": 1, \"b\": [1, 2, {\"c\": 3}]} ', {'a': 1, 'b': [1, 2, {'c': 3}]}),
+        ('{\"a\": 1, \"b\": [1, 2, {\"c\": 3, \"d\": [4, 5]}]} ', {'a': 1, 'b': [1, 2, {'c': 3, 'd': [4, 5]}]}),
+    ]
+)
+def test_extract_json_edge_cases(input_val, expected):
+    """Test extract_json with a wide range of edge cases and malformed input."""
+    result = json_utils.extract_json(input_val)
+    assert result == expected
+
+def test_extract_json_large_object():
+    """Test extract_json with a large JSON object."""
+    large_obj = {'a': list(range(1000)), 'b': {'c': 'x' * 1000}}
+    s = json.dumps(large_obj)
+    assert json_utils.extract_json(s) == large_obj
+
+def test_extract_json_multiple_json_types():
+    """Test extract_json returns the first valid JSON (object or array) in the string."""
+    s = '[1,2,3]{"a": 1}'
+    assert json_utils.extract_json(s) == [1, 2, 3]
+    s2 = '{"a": 1}[1,2,3]'
+    assert json_utils.extract_json(s2) == {'a': 1}

tests/python/test_utils.py

@@ -11,25 +11,7 @@
 import pytest
 from apimtypes import INFRASTRUCTURE, APIM_SKU
 import utils
-
-# ------------------------------
-#    is_string_json
-# ------------------------------
-
-@pytest.mark.parametrize(
-    'input_str,expected',
-    [
-        ('{\"a\": 1}', True),
-        ('[1, 2, 3]', True),
-        ('not json', False),
-        ('{\"a\": 1', False),
-        ('', False),
-        (None, False),
-        (123, False),
-    ]
-)
-def test_is_string_json(input_str, expected):
-    assert utils.is_string_json(input_str) is expected
+import json_utils
 
 # ------------------------------
 #    get_account_info
@@ -234,59 +216,6 @@ def mock_inspect_currentframe():
         utils.read_policy_xml('policy.xml', {'key': 'value'})
 
 
-# ------------------------------
-#    EXTRACT_JSON EDGE CASES
-# ------------------------------
-
-@pytest.mark.parametrize(
-    'input_val,expected',
-    [
-        (None, None),
-        (123, None),
-        ([], None),
-        ('', None),
-        ('   ', None),
-        ('not json', None),
-        ('{\"a\": 1}', {'a': 1}),
-        ('[1, 2, 3]', [1, 2, 3]),
-        ('  {\"a\": 1}  ', {'a': 1}),
-        ('prefix {\"foo\": 42} suffix', {'foo': 42}),
-        ('prefix [1, 2, 3] suffix', [1, 2, 3]),
-        ('{\"a\": 1}{\"b\": 2}', {'a': 1}),  # Only first JSON object
-        ('[1, 2, 3][4, 5, 6]', [1, 2, 3]),  # Only first JSON array
-        ('{\"a\": [1, 2, {\"b\": 3}]}', {'a': [1, 2, {'b': 3}]}),
-        ('\n\t{\"a\": 1}\n', {'a': 1}),
-        ('{\"a\": \"b \\u1234\"}', {'a': 'b \u1234'}),
-        ('{\"a\": 1} [2, 3]', {'a': 1}),  # Object before array
-        ('[2, 3] {\"a\": 1}', [2, 3]),  # Array before object
-        ('{\"a\": 1, \"b\": {\"c\": 2}}', {'a': 1, 'b': {'c': 2}}),
-        ('{\"a\": 1, \"b\": [1, 2, 3]}', {'a': 1, 'b': [1, 2, 3]}),
-        ('\n\n[\n1, 2, 3\n]\n', [1, 2, 3]),
-        ('{\"a\": 1, \"b\": null}', {'a': 1, 'b': None}),
-        ('{\"a\": true, \"b\": false}', {'a': True, 'b': False}),
-        ('{\"a\": 1, \"b\": \"c\"}', {'a': 1, 'b': 'c'}),
-        ('{\"a\": 1, \"b\": [1, 2, {\"c\": 3}]} ', {'a': 1, 'b': [1, 2, {'c': 3}]}),
-        ('{\"a\": 1, \"b\": [1, 2, {\"c\": 3, \"d\": [4, 5]}]} ', {'a': 1, 'b': [1, 2, {'c': 3, 'd': [4, 5]}]}),
-    ]
-)
-def test_extract_json_edge_cases(input_val, expected):
-    """Test extract_json with a wide range of edge cases and malformed input."""
-    result = utils.extract_json(input_val)
-    assert result == expected
-
-def test_extract_json_large_object():
-    """Test extract_json with a large JSON object."""
-    large_obj = {'a': list(range(1000)), 'b': {'c': 'x' * 1000}}
-    s = json.dumps(large_obj)
-    assert utils.extract_json(s) == large_obj
-
-def test_extract_json_multiple_json_types():
-    """Test extract_json returns the first valid JSON (object or array) in the string."""
-    s = '[1,2,3]{"a": 1}'
-    assert utils.extract_json(s) == [1, 2, 3]
-    s2 = '{"a": 1}[1,2,3]'
-    assert utils.extract_json(s2) == {'a': 1}
-
 # ------------------------------
 #    validate_infrastructure
 # ------------------------------
@@ -801,10 +730,10 @@ def mock_chdir(path):
 
 def test_extract_json_invalid_input():
     """Test extract_json with various invalid inputs."""
-    assert utils.extract_json(None) is None
-    assert utils.extract_json(123) is None
-    assert utils.extract_json([1, 2, 3]) is None
-    assert utils.extract_json('not json at all') is None
+    assert json_utils.extract_json(None) is None
+    assert json_utils.extract_json(123) is None
+    assert json_utils.extract_json([1, 2, 3]) is None
+    assert json_utils.extract_json('not json at all') is None
 
 
 def test_generate_signing_key_format():