Allow for client to provide records with newer version to the server

Server might need then to either wait until upgrade it becomes capable of
validating them or we might in the future to allow client to downgrade them (on
client; loselessly only) since server cannot yet handle them.

This behavior would facilitate testing of new releases of dandi-schema which now
would fail since we require 1-to-1 correspondence. See e.g.

    dandi/dandi-schema#342 (comment)

Author: yarikoptic

dandi/dandiapi.py

@@ -18,6 +18,7 @@
 
 import click
 from dandischema import models
+from packaging.version import Version as PackagingVersion
 from pydantic import BaseModel, Field, PrivateAttr
 import requests
 import tenacity
@@ -646,8 +647,12 @@ def create_dandiset(
 
     def check_schema_version(self, schema_version: str | None = None) -> None:
         """
-        Confirms that the server is using the same version of the DANDI schema
-        as the client.  If it is not, a `SchemaVersionError` is raised.
+        Confirms that the server is using a "compatible" version of the DANDI schema.
+        Compatibility here means that the server's schema version can be lower than
+        client has, but within the same MAJOR.MINOR component of the version number
+        for 0.x series, and same MAJOR version for/after 1.x series.
+
+        If it is not, a `SchemaVersionError` is raised.
 
         :param schema_version: the schema version to confirm that the server
             uses; if not set, the schema version for the installed
@@ -662,12 +667,30 @@ def check_schema_version(self, schema_version: str | None = None) -> None:
                 "Server did not provide schema_version in /info/;"
                 f" returned {server_info!r}"
             )
-        if server_schema_version != schema_version:
+        server_ver, our_ver = PackagingVersion(server_schema_version), PackagingVersion(
+            schema_version
+        )
+        if server_ver > our_ver:
             raise SchemaVersionError(
-                f"Server requires schema version {server_schema_version};"
-                f" client only supports {schema_version}.  You may need to"
+                f"Server uses schema version {server_schema_version};"
+                f" client only supports prior {schema_version}.  You may need to"
                 " upgrade dandi and/or dandischema."
             )
+            # NOTE: here we could in theory support older schema versions as long as they
+            # could be migrated, but client would not know how to migrate -- server "might"
+            # as it is the one having newer version!
+            # TODO: check current server behavior which is likely to just not care!
+            # So that is where server might need to provide support for upgrades upon
+            # providing metadata.
+        elif (
+            server_ver.major == 0 and server_ver.release[:2] != our_ver.release[:2]
+        ) or (
+            server_ver.major != our_ver.major
+        ):  # MAJOR, MINOR within 0.x.y and MAJOR within 1.x.y
+            raise SchemaVersionError(
+                f"Server uses older incompatible schema version {server_schema_version};"
+                f" client supports {schema_version}."
+            )
 
     def get_asset(self, asset_id: str) -> BaseRemoteAsset:
         """

dandi/tests/test_dandiapi.py

@@ -272,35 +272,56 @@ def test_remote_asset_json_dict(text_dandiset: SampleDandiset) -> None:
     }
 
 
+@pytest.mark.parametrize(
+    "server_schema_version,local_schema_version,should_raise,expected_message_start",
+    [
+        # Current/identity matching -- always ok
+        (get_schema_version(), None, False, None),
+        (get_schema_version(), get_schema_version(), False, None),
+        ("0.6.7", "0.6.7", False, None),
+        # Less - is not good since we  might be missing fields and it is easy
+        # for client to upgrade.
+        (
+            "4.5.6",
+            "4.5.5",
+            True,
+            "Server uses schema version 4.5.6; client only supports prior 4.5.5.  "
+            "You may need to upgrade dandi and/or dandischema.",
+        ),
+        (
+            "0.6.7",
+            "0.6.6",
+            True,
+            "Server uses schema version 0.6.7; client only supports prior 0.6.6",
+        ),
+        # Now - incompatible, for 0.x -- rely on MAJOR.MINOR
+        (
+            "0.6.7",
+            "0.7.0",
+            True,
+            "Server uses older incompatible schema version 0.6.7; client supports 0.7.0",
+        ),
+        # After 1.x -- rely on MAJOR.
+        ("1.0.0", "1.2.3", False, None),
+        ("1.6.7", "1.7.0", False, None),
+        ("1.6.7", "1.8.3", False, None),
+        (
+            "1.6.7",
+            "2.7.0",
+            True,
+            "Server uses older incompatible schema version 1.6.7; client supports 2.7.0",
+        ),
+    ],
+)
 @responses.activate
-def test_check_schema_version_matches_default() -> None:
-    server_info = {
-        "schema_version": get_schema_version(),
-        "version": "0.0.0",
-        "services": {
-            "api": {"url": "https://test.nil/api"},
-        },
-        "cli-minimal-version": "0.0.0",
-        "cli-bad-versions": [],
-    }
-    responses.add(
-        responses.GET,
-        "https://test.nil/server-info",
-        json=server_info,
-    )
-    responses.add(
-        responses.GET,
-        "https://test.nil/api/info/",
-        json=server_info,
-    )
-    client = DandiAPIClient("https://test.nil/api")
-    client.check_schema_version()
-
-
-@responses.activate
-def test_check_schema_version_mismatch() -> None:
+def test_check_schema_version(
+    server_schema_version: str,
+    local_schema_version: str | None,
+    should_raise: bool,
+    expected_message_start: str | None,
+) -> None:
     server_info = {
-        "schema_version": "4.5.6",
+        "schema_version": server_schema_version,
         "version": "0.0.0",
         "services": {
             "api": {"url": "https://test.nil/api"},
@@ -319,13 +340,12 @@ def test_check_schema_version_mismatch() -> None:
         json=server_info,
     )
     client = DandiAPIClient("https://test.nil/api")
-    with pytest.raises(SchemaVersionError) as excinfo:
-        client.check_schema_version("1.2.3")
-    assert (
-        str(excinfo.value)
-        == "Server requires schema version 4.5.6; client only supports 1.2.3.  "
-        "You may need to upgrade dandi and/or dandischema."
-    )
+    if should_raise:
+        with pytest.raises(SchemaVersionError) as excinfo:
+            client.check_schema_version(local_schema_version)
+        assert str(excinfo.value).startswith(expected_message_start)
+    else:
+        client.check_schema_version(local_schema_version)
 
 
 def test_get_dandisets(text_dandiset: SampleDandiset) -> None: