add version to delete methods

Author: andrewelamb

synapseclient/models/schema_organization.py

@@ -638,17 +638,23 @@ def store(
         """
         return self
 
-    def delete(self) -> None:
+    def delete(
+        self, version: Optional[str] = None, synapse_client: Optional["Synapse"] = None
+    ) -> None:
         """
         Deletes this JSONSchema
 
         Arguments:
+            version: Defaults to None.
+            - If a version is supplied, that version will be deleted.
+            - If no version is supplied the whole schema will be deleted.
             synapse_client: If not passed in and caching was not disabled by
                 `Synapse.allow_client_caching(False)` this will use the last created
                 instance from the Synapse class constructor
 
-        Example: Delete this JSONSchema from Synapse
-             
+        Example: Delete from Synapse
+
+            Delete the entire schema
 
             ```python
             from synapseclient.models import JSONSchema
@@ -660,6 +666,19 @@ def delete(self) -> None:
             js = JSONSchema("my.schema.name", "my.org.name")
             js.delete()
             ```
+
+            Delete a specific version from Synapse
+
+            ```python
+            from synapseclient.models import JSONSchema
+            from synapseclient import Synapse
+
+            syn = Synapse()
+            syn.login()
+
+            js = JSONSchema("my.schema.name", "my.org.name")
+            js.delete(version="0.0.1")
+            ```
         """
         return None
 
@@ -750,7 +769,7 @@ class JSONSchema(JSONSchemaProtocol):
         id: The ID of the schema
         created_on: The date this schema was created
         created_by: The ID of the user that created this schema
-        uri: The uri of this schema
+        uri: The schema identifier in format: <organization_name>-<schema_name>
     """
 
     name: Optional[str] = None
@@ -772,7 +791,7 @@ class JSONSchema(JSONSchemaProtocol):
     """The ID of the user that created this schema"""
 
     uri: Optional[str] = field(init=False)
-    """The uri of this schema"""
+    """The schema identifier in format: <organization_name>-<schema_name>"""
 
     def __post_init__(self) -> None:
         if self.name:
@@ -883,7 +902,20 @@ async def store_schema():
                 syn.login()
 
                 schema = JSONSchema(organization_name="my.org", name="test.schema")
-                await schema.store_async(schema_body = {})
+                schema_body = {
+                    {
+                        "properties": {
+                            "Component": {
+                                "description": "TBD",
+                                "not": {
+                                    "type": "null"
+                                },
+                                "title": "Component"
+                            }
+                        }
+                    }
+                }
+                await schema.store_async(schema_body = schema_body)
 
             asyncio.run(store_schema())
             ```
@@ -910,17 +942,24 @@ async def store_schema():
         self.created_on = new_version_info.created_on
         return self
 
-    async def delete_async(self, synapse_client: Optional["Synapse"] = None) -> None:
+    async def delete_async(
+        self, version: Optional[str] = None, synapse_client: Optional["Synapse"] = None
+    ) -> None:
         """
-        Deletes this JSONSchema from Synapse
+        If a version is supplied the specific version is deleted from Synapse.
+        Otherwise the entire schema is deleted from Synapse
 
         Arguments:
+            version: Defaults to None.
+            - If a version is supplied, that version will be deleted.
+            - If no version is supplied the whole schema will be deleted.
             synapse_client: If not passed in and caching was not disabled by
                 `Synapse.allow_client_caching(False)` this will use the last created
                 instance from the Synapse class constructor
 
         Example: Delete an existing JSONSchema
-            &nbsp;
+
+            Delete the whole schema
 
             ```python
             from synapseclient.models import JSONSchema
@@ -933,7 +972,25 @@ async def delete_schema():
                 syn.login()
 
                 schema = JSONSchema(organization_name="my.org", name="test.schema")
-                await schema.delete_async(schema_body = {})
+                await schema.delete_async()
+
+            asyncio.run(delete_schema())
+            ```
+
+            Delete a specific version of the schema
+
+            ```python
+            from synapseclient.models import JSONSchema
+            from synapseclient import Synapse
+            import asyncio
+
+            async def delete_schema():
+
+                syn = Synapse()
+                syn.login()
+
+                schema = JSONSchema(organization_name="my.org", name="test.schema")
+                await schema.delete_async(version = "0.0.1")
 
             asyncio.run(delete_schema())
             ```
@@ -943,7 +1000,12 @@ async def delete_schema():
         if not self.organization_name:
             raise ValueError("JSONSchema must have a organization_name")
 
-        await delete_json_schema(self.uri, synapse_client=synapse_client)
+        uri = self.uri
+        if version:
+            self._check_semantic_version(version)
+            uri = f"{uri}-{version}"
+
+        await delete_json_schema(uri, synapse_client=synapse_client)
 
     @skip_async_to_sync
     async def get_versions_async(

tests/integration/synapseclient/models/async/test_schema_organization.py

@@ -12,6 +12,7 @@
 from synapseclient.models.schema_organization import (
     SYNAPSE_SCHEMA_URL,
     CreateSchemaRequest,
+    JSONSchemaVersionInfo,
     list_json_schema_organizations,
 )
 
@@ -238,6 +239,50 @@ async def test_store_and_get(self, json_schema: JSONSchema) -> None:
         assert js2.created_by
         assert js2.created_on
 
+    async def test_delete(self, organization_with_schema: SchemaOrganization) -> None:
+        # GIVEN an organization with 3 schema
+        schemas: list[JSONSchema] = []
+        async for item in organization_with_schema.get_json_schemas_async():
+            schemas.append(item)
+        assert len(schemas) == 3
+        # WHEN deleting one of those schemas
+        schema = schemas[0]
+        await schema.delete_async()
+        # THEN there should be only two left
+        schemas2: list[JSONSchema] = []
+        async for item in organization_with_schema.get_json_schemas_async():
+            schemas2.append(item)
+        assert len(schemas2) == 2
+
+    async def test_delete_version(self, json_schema: JSONSchema) -> None:
+        # GIVEN an organization and a JSONSchema
+        await json_schema.store_async(schema_body={}, version="0.0.1")
+        # THEN that schema should have one version
+        js_versions: list[JSONSchemaVersionInfo] = []
+        async for item in json_schema.get_versions_async():
+            js_versions.append(item)
+        assert len(js_versions) == 1
+        # WHEN storing a second version
+        await json_schema.store_async(schema_body={}, version="0.0.2")
+        # THEN that schema should have two versions
+        js_versions = []
+        async for item in json_schema.get_versions_async():
+            js_versions.append(item)
+        assert len(js_versions) == 2
+        # AND they should be the ones stored
+        versions = [js_version.semantic_version for js_version in js_versions]
+        assert versions == ["0.0.1", "0.0.2"]
+        # WHEN deleting the first schema version
+        await json_schema.delete_async(version="0.0.1")
+        # THEN there should only be one version left
+        js_versions = []
+        async for item in json_schema.get_versions_async():
+            js_versions.append(item)
+        assert len(js_versions) == 1
+        # AND it should be the second version
+        versions = [js_version.semantic_version for js_version in js_versions]
+        assert versions == ["0.0.2"]
+
     async def test_get_versions(self, json_schema: JSONSchema) -> None:
         # GIVEN an schema that hasn't been created
         # THEN get_versions should return an empty list

tests/integration/synapseclient/models/synchronous/test_schema_organization.py

@@ -224,6 +224,40 @@ async def test_store_and_get(self, json_schema: JSONSchema) -> None:
         assert js2.created_by
         assert js2.created_on
 
+    async def test_delete(self, organization_with_schema: SchemaOrganization) -> None:
+        # GIVEN an organization with 3 schema
+        schemas = list(organization_with_schema.get_json_schemas())
+        assert len(schemas) == 3
+        # WHEN deleting one of those schemas
+        schema = schemas[0]
+        schema.delete()
+        # THEN there should be only two left
+        schemas = list(organization_with_schema.get_json_schemas())
+        assert len(schemas) == 2
+
+    async def test_delete_version(self, json_schema: JSONSchema) -> None:
+        # GIVEN an organization and a JSONSchema
+        json_schema.store(schema_body={}, version="0.0.1")
+        # THEN that schema should have one version
+        js_versions = list(json_schema.get_versions())
+        assert len(js_versions) == 1
+        # WHEN storing a second version
+        json_schema.store(schema_body={}, version="0.0.2")
+        # THEN that schema should have two versions
+        js_versions = list(json_schema.get_versions())
+        assert len(js_versions) == 2
+        # AND they should be the ones stored
+        versions = [js_version.semantic_version for js_version in js_versions]
+        assert versions == ["0.0.1", "0.0.2"]
+        # WHEN deleting the first schema version
+        json_schema.delete(version="0.0.1")
+        # THEN there should only be one version left
+        js_versions = list(json_schema.get_versions())
+        assert len(js_versions) == 1
+        # AND it should be the second version
+        versions = [js_version.semantic_version for js_version in js_versions]
+        assert versions == ["0.0.2"]
+
     async def test_get_versions(self, json_schema: JSONSchema) -> None:
         # GIVEN an schema that hasn't been created
         # THEN get_versions should return an empty list