add fix_schema_name

Author: andrewelamb

docs/tutorials/command_line_client.md

@@ -575,6 +575,7 @@ synapse register-json-schema [-h] [--schema-version VERSION] schema_path organiz
 | `organization_name`   | Positional | Name of the organization to register the schema under                               |         |
 | `schema_name`         | Positional | The name of the JSON schema                                                         |         |
 | `--schema-version`    | Named      | Version of the schema to register (e.g., '0.0.1'). If not specified, auto-generated | None    |
+| `--fix-schema-name`   | Named      | Replace dashes and underscores in the schema name with periods.                     | False   |
 
 ### `bind-json-schema`
 

synapseclient/__main__.py

@@ -824,6 +824,7 @@ def register_json_schema(args, syn):
         schema_path=args.schema_path,
         organization_name=args.organization_name,
         schema_name=args.schema_name,
+        fix_schema_name=args.fix_schema_name,
         schema_version=args.schema_version,
         synapse_client=syn,
     )
@@ -1892,6 +1893,12 @@ def build_parser():
         type=str,
         help="The name of the JSON schema",
     )
+    parser_register_json_schema.add_argument(
+        "--fix-schema-name",
+        action="store_true",
+        default=False,
+        help="Whether to fix the schema name to meet Synapse requirements",
+    )
     parser_register_json_schema.add_argument(
         "--schema-version",
         dest="schema_version",

synapseclient/extensions/curator/schema_management.py

@@ -20,6 +20,7 @@ def register_jsonschema(
     schema_path: str,
     organization_name: str,
     schema_name: str,
+    fix_schema_name: bool = False,
     schema_version: Optional[str] = None,
     synapse_client: Optional["Synapse"] = None,
 ) -> "JSONSchema":
@@ -33,6 +34,8 @@ def register_jsonschema(
         schema_path: Path to the JSON schema file to register
         organization_name: Name of the organization to register the schema under
         schema_name: Name of the JSON schema
+        fix_schema_name: Whether to fix the schema name to meet Synapse requirements by replacing
+            dashes and underscores with periods. Defaults to False.
         schema_version: Optional version of the schema (e.g., '0.0.1').
                        If not specified, a version will be auto-generated.
         synapse_client: If not passed in and caching was not disabled by
@@ -54,6 +57,7 @@ def register_jsonschema(
             schema_path="/path/to/schema.json",
             organization_name="my.org",
             schema_name="my.schema",
+            fix_schema_name=True,
             schema_version="0.0.1",
             synapse_client=syn
         )
@@ -65,6 +69,7 @@ def register_jsonschema(
         coroutine=register_jsonschema_async(
             schema_path=schema_path,
             organization_name=organization_name,
+            fix_schema_name=fix_schema_name,
             schema_name=schema_name,
             schema_version=schema_version,
             synapse_client=synapse_client,
@@ -76,6 +81,7 @@ async def register_jsonschema_async(
     schema_path: str,
     organization_name: str,
     schema_name: str,
+    fix_schema_name: bool = False,
     schema_version: Optional[str] = None,
     synapse_client: Optional["Synapse"] = None,
 ) -> "JSONSchema":
@@ -89,6 +95,8 @@ async def register_jsonschema_async(
         schema_path: Path to the JSON schema file to register
         organization_name: Name of the organization to register the schema under
         schema_name: The name of the JSON schema
+        fix_schema_name: Whether to fix the schema name to meet Synapse requirements by replacing
+            dashes and underscores with periods. Defaults to False.
         schema_version: Optional version of the schema (e.g., '0.0.1').
                        If not specified, a version will be auto-generated.
         synapse_client: If not passed in and caching was not disabled by
@@ -111,6 +119,7 @@ async def register_jsonschema_async(
             schema_path="/path/to/schema.json",
             organization_name="my.org",
             schema_name="my.schema",
+            fix_schema_name=True,
             schema_version="0.0.1",
             synapse_client=syn
         ))
@@ -121,6 +130,9 @@ async def register_jsonschema_async(
     from synapseclient import Synapse
     from synapseclient.models.schema_organization import JSONSchema
 
+    if fix_schema_name:
+        schema_name = schema_name.replace("-", ".").replace("_", ".")
+
     syn = Synapse.get_client(synapse_client=synapse_client)
 
     with open(schema_path, "r") as f:

tests/integration/synapseclient/test_command_line_client.py

@@ -1333,6 +1333,31 @@ def test_register_json_schema(self, test_state, schema_organization, schema_file
         assert "Successfully registered schema" in output
         assert schema_name in output
         assert schema_organization.name in output
+        assert False
+
+    def test_register_json_schema_fix_schema_name(
+        self, test_state, schema_organization, schema_file
+    ):
+        """Test register-json-schema CLI command"""
+        schema_name = f"test-schema_id{str(uuid.uuid4())[:8]}"
+        fixed_schema_name = schema_name.replace("-", ".").replace("_", ".")
+
+        output = run(
+            test_state,
+            "synapse",
+            "--skip-checks",
+            "register-json-schema",
+            schema_file,
+            schema_organization.name,
+            schema_name,
+            "--schema-version",
+            "1.0.0",
+            "--fix-schema-name",
+        )
+
+        assert "Successfully registered schema" in output
+        assert fixed_schema_name in output
+        assert schema_organization.name in output
 
     def test_bind_json_schema(self, test_state, schema_organization, schema_file):
         """Test bind-json-schema CLI command"""

tests/unit/synapseclient/extensions/test_schema_management.py

@@ -0,0 +1,102 @@
+import json
+from unittest.mock import AsyncMock, MagicMock, mock_open, patch
+
+import pytest
+
+from synapseclient.extensions.curator import register_jsonschema_async
+
+
+@pytest.fixture
+def mock_synapse_client():
+    mock_client = MagicMock()
+    mock_client.logger = MagicMock()
+    return mock_client
+
+
+@pytest.fixture
+def mock_jsonschema():
+    with patch("synapseclient.models.schema_organization.JSONSchema") as MockSchema:
+        instance = MockSchema.return_value
+        instance.store_async = AsyncMock()
+        instance.uri = "syn123.456"
+        yield MockSchema
+
+
+@pytest.mark.asyncio
+async def test_register_jsonschema_async(mock_synapse_client, mock_jsonschema):
+    # Setup
+    schema_path = "mock_path.json"
+    schema_content = {"$id": "test_schema", "type": "object"}
+    org_name = "test.org"
+    schema_name = "my-schema_name"
+    version = "1.0.0"
+
+    # Mock file reading and the Synapse client retrieval
+    m_open = mock_open(read_data=json.dumps(schema_content))
+
+    with patch("builtins.open", m_open), patch(
+        "synapseclient.Synapse.get_client", return_value=mock_synapse_client
+    ), patch("json.load", return_value=schema_content):
+        result = await register_jsonschema_async(
+            schema_path=schema_path,
+            organization_name=org_name,
+            schema_name=schema_name,
+            schema_version=version,
+            synapse_client=mock_synapse_client,
+        )
+
+        # Verify the name was used as-is
+        mock_jsonschema.assert_called_once_with(
+            name=schema_name, organization_name=org_name
+        )
+
+        # Verify the async store was called with the right data
+        result.store_async.assert_awaited_once_with(
+            schema_body=schema_content,
+            version=version,
+            synapse_client=mock_synapse_client,
+        )
+
+        assert result.uri == "syn123.456"
+
+
+@pytest.mark.asyncio
+async def test_register_jsonschema_async_fix_schema_name(
+    mock_synapse_client, mock_jsonschema
+):
+    # Setup
+    schema_path = "mock_path.json"
+    schema_content = {"$id": "test_schema", "type": "object"}
+    org_name = "test.org"
+    schema_name = "my-schema_name"
+    fixed_schema_name = "my.schema.name"
+    version = "1.0.0"
+
+    # Mock file reading and the Synapse client retrieval
+    m_open = mock_open(read_data=json.dumps(schema_content))
+
+    with patch("builtins.open", m_open), patch(
+        "synapseclient.Synapse.get_client", return_value=mock_synapse_client
+    ), patch("json.load", return_value=schema_content):
+        result = await register_jsonschema_async(
+            schema_path=schema_path,
+            organization_name=org_name,
+            schema_name=schema_name,
+            fix_schema_name=True,
+            schema_version=version,
+            synapse_client=mock_synapse_client,
+        )
+
+        # Verify the name was fixed (dashes/underscores to dots)
+        mock_jsonschema.assert_called_once_with(
+            name=fixed_schema_name, organization_name=org_name
+        )
+
+        # Verify the async store was called with the right data
+        result.store_async.assert_awaited_once_with(
+            schema_body=schema_content,
+            version=version,
+            synapse_client=mock_synapse_client,
+        )
+
+        assert result.uri == "syn123.456"