datumesh 0.2.0__tar.gz → 0.2.1__tar.gz

{datumesh-0.2.0/src/datumesh.egg-info → datumesh-0.2.1}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: datumesh
-Version: 0.2.0
-Summary: Verify Datumesh receipts (spec-0.2.0): RFC 8785 canonical JSON, Ed25519 signatures, blobs, units, cell URIs, response envelopes, key documents.
+Version: 0.2.1
+Summary: Verify Datumesh receipts (spec-0.2.1): RFC 8785 canonical JSON, Ed25519 signatures, blobs, units, cell URIs, response envelopes, key documents.
 Author: Datumesh
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://datumesh.com
 Project-URL: Repository, https://github.com/datumesh-com/datumesh-verify-py
-Project-URL: Specification (spec-0.2.0), https://github.com/datumesh-com/datumesh-spec/blob/spec-0.2.0/SPEC.md
-Keywords: datumesh,spec-0.2.0,receipt,verification,ed25519,rfc8785,jcs,canonical-json
+Project-URL: Specification (spec-0.2.1), https://github.com/datumesh-com/datumesh-spec/blob/spec-0.2.1/SPEC.md
+Keywords: datumesh,spec-0.2.1,receipt,verification,ed25519,rfc8785,jcs,canonical-json
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
@@ -27,11 +27,11 @@ Dynamic: license-file
 
 # datumesh
 
-Verify [Datumesh](https://datumesh.com) receipts in Python. A receipt is a signed answer for one addressable data cell; this library checks its canonical form (RFC 8785 JSON) and its Ed25519 signature against the signer's published keys, and optionally the recomputation checks (function descriptor, input receipts, and a value you computed) and the content of a blob value, as the [Datumesh specification](https://github.com/datumesh-com/datumesh-spec/blob/spec-0.2.0/SPEC.md) (revision `spec-0.2.0`) defines. It also checks a mesh's response envelope and resolves the unit of a cell's value.
+Verify [Datumesh](https://datumesh.com) receipts in Python. A receipt is a signed answer for one addressable data cell; this library checks its canonical form (RFC 8785 JSON) and its Ed25519 signature against the signer's published keys, and optionally the recomputation checks (function descriptor, input receipts, and a value you computed) and the content of a blob value, as the [Datumesh specification](https://github.com/datumesh-com/datumesh-spec/blob/spec-0.2.1/SPEC.md) (revision `spec-0.2.1`) defines. It also checks a mesh's response envelope and resolves the unit of a cell's value.
 
 ```sh
 pip install datumesh
-git clone --depth 1 --branch spec-0.2.0 https://github.com/datumesh-com/datumesh-spec && cd datumesh-spec
+git clone --depth 1 --branch spec-0.2.1 https://github.com/datumesh-com/datumesh-spec && cd datumesh-spec
 ```
 
 ```python

{datumesh-0.2.0 → datumesh-0.2.1}/README.md

@@ -1,10 +1,10 @@
 # datumesh
 
-Verify [Datumesh](https://datumesh.com) receipts in Python. A receipt is a signed answer for one addressable data cell; this library checks its canonical form (RFC 8785 JSON) and its Ed25519 signature against the signer's published keys, and optionally the recomputation checks (function descriptor, input receipts, and a value you computed) and the content of a blob value, as the [Datumesh specification](https://github.com/datumesh-com/datumesh-spec/blob/spec-0.2.0/SPEC.md) (revision `spec-0.2.0`) defines. It also checks a mesh's response envelope and resolves the unit of a cell's value.
+Verify [Datumesh](https://datumesh.com) receipts in Python. A receipt is a signed answer for one addressable data cell; this library checks its canonical form (RFC 8785 JSON) and its Ed25519 signature against the signer's published keys, and optionally the recomputation checks (function descriptor, input receipts, and a value you computed) and the content of a blob value, as the [Datumesh specification](https://github.com/datumesh-com/datumesh-spec/blob/spec-0.2.1/SPEC.md) (revision `spec-0.2.1`) defines. It also checks a mesh's response envelope and resolves the unit of a cell's value.
 
 ```sh
 pip install datumesh
-git clone --depth 1 --branch spec-0.2.0 https://github.com/datumesh-com/datumesh-spec && cd datumesh-spec
+git clone --depth 1 --branch spec-0.2.1 https://github.com/datumesh-com/datumesh-spec && cd datumesh-spec
 ```
 
 ```python

{datumesh-0.2.0 → datumesh-0.2.1}/pyproject.toml

@@ -4,14 +4,14 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "datumesh"
-version = "0.2.0"
-description = "Verify Datumesh receipts (spec-0.2.0): RFC 8785 canonical JSON, Ed25519 signatures, blobs, units, cell URIs, response envelopes, key documents."
+version = "0.2.1"
+description = "Verify Datumesh receipts (spec-0.2.1): RFC 8785 canonical JSON, Ed25519 signatures, blobs, units, cell URIs, response envelopes, key documents."
 readme = "README.md"
 requires-python = ">=3.10"
 license = "Apache-2.0"
 license-files = ["LICENSE"]
 authors = [{ name = "Datumesh" }]
-keywords = ["datumesh", "spec-0.2.0", "receipt", "verification", "ed25519", "rfc8785", "jcs", "canonical-json"]
+keywords = ["datumesh", "spec-0.2.1", "receipt", "verification", "ed25519", "rfc8785", "jcs", "canonical-json"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Intended Audience :: Developers",
@@ -30,7 +30,7 @@ dependencies = ["pynacl>=1.5.0"]
 [project.urls]
 Homepage = "https://datumesh.com"
 Repository = "https://github.com/datumesh-com/datumesh-verify-py"
-"Specification (spec-0.2.0)" = "https://github.com/datumesh-com/datumesh-spec/blob/spec-0.2.0/SPEC.md"
+"Specification (spec-0.2.1)" = "https://github.com/datumesh-com/datumesh-spec/blob/spec-0.2.1/SPEC.md"
 
 [tool.setuptools.packages.find]
 where = ["src"]

{datumesh-0.2.0 → datumesh-0.2.1}/src/datumesh/__init__.py

@@ -1,6 +1,6 @@
 """datumesh: verify Datumesh receipts (signed answers for addressable data cells).
 
-Implements the Datumesh protocol specification, revision ``spec-0.2.0``
+Implements the Datumesh protocol specification, revision ``spec-0.2.1``
 (https://github.com/datumesh-com/datumesh-spec): RFC 8785 canonical JSON,
 SHA-256 hashes, Ed25519 receipt signatures, blob content, units, cell URIs,
 response envelopes and key documents. Only :func:`fetch_keys` touches the network.
@@ -19,9 +19,9 @@ from ._keys import Key, KeysResult, fetch_keys, key_id, keys_from_response
 from ._uri import format_uri, parse_uri, uri_to_https
 from ._verify import VerifyResult, load, payload_bytes, verify
 
-__version__ = "0.2.0"
+__version__ = "0.2.1"
 #: The specification revision this package conforms to.
-SPEC_VERSION = "spec-0.2.0"
+SPEC_VERSION = "spec-0.2.1"
 #: Every literal unit listed in units.md (index units, ``index:<period>=<value>``, are a pattern and not listed).
 UNITS = tuple(sorted(_units.LITERALS))
 #: The currency codes of units.md 2.1.

{datumesh-0.2.0 → datumesh-0.2.1}/src/datumesh/_json.py

@@ -4,12 +4,31 @@ from __future__ import annotations
 
 import json
 import math
+import re
 from typing import Any, Dict, List, Tuple, Union
 
 from ._errors import DatumeshError, fail
 
 JSONText = Union[str, bytes, bytearray, memoryview]
 
+#: SPEC 6.1: at most 64 levels of ``[`` and ``{`` open at once, counted outside strings.
+MAX_DEPTH = 64
+# A string (possibly unterminated) or a bracket; brackets inside strings are skipped with the string.
+_DEPTH_TOKEN = re.compile(r'"(?:[^"\\]|\\.)*"?|[\[\]{}]', re.S)
+
+
+def _too_deep(text: str) -> bool:
+    depth = 0
+    for m in _DEPTH_TOKEN.finditer(text):
+        c = m.group()
+        if c in "[{":
+            depth += 1
+            if depth > MAX_DEPTH:
+                return True
+        elif c in "]}":
+            depth -= 1
+    return False
+
 
 class _Duplicate(Exception):
     def __init__(self, key: str) -> None:
@@ -49,7 +68,11 @@ def parse_json(data: JSONText, path: str = "$") -> Any:
     ``data`` is bytes (must be UTF-8 without a byte order mark) or str (must not
     start with U+FEFF). Duplicate member names raise E_PARSE_DUPLICATE_KEY; every
     other failure (syntax, lone surrogates, NaN/Infinity, numbers outside the
-    double range, invalid UTF-8) raises E_PARSE_JSON. Numbers become floats.
+    double range, invalid UTF-8, nesting deeper than 64) raises E_PARSE_JSON.
+    Numbers become floats. Failures are reported in the order of SPEC 6.1: byte
+    order mark, invalid UTF-8, nesting, then the first in text order of a syntax
+    error, NaN/Infinity, an overflowing number or a duplicate member (detected when
+    its object closes), and lone surrogates last.
     """
     if isinstance(data, (bytes, bytearray, memoryview)):
         raw = bytes(data)
@@ -65,6 +88,8 @@ def parse_json(data: JSONText, path: str = "$") -> Any:
             fail("E_PARSE_JSON", "byte order mark", path)
     else:
         raise TypeError(f"JSON text must be str or bytes, not {type(data).__name__}")
+    if _too_deep(text):
+        fail("E_PARSE_JSON", f"nesting deeper than {MAX_DEPTH} levels", path)
     try:
         value = json.loads(
             text,
@@ -102,10 +127,15 @@ def number_texts(data: JSONText) -> Dict[str, str]:
 
 def check_json_value(value: Any, path: str = "$") -> None:
     """Check that an already-parsed value is I-JSON: dict/list/str/float/int/bool/None only,
-    string keys, no lone surrogates, finite numbers within the double range."""
-    stack: List[Tuple[Any, str]] = [(value, path)]
+    string keys, no lone surrogates, finite numbers within the double range, and at most
+    64 levels of arrays and objects (as its text would be, SPEC 6.1)."""
+    stack: List[Tuple[Any, str, int]] = [(value, path, 0)]
     while stack:
-        v, p = stack.pop()
+        v, p, depth = stack.pop()
+        if isinstance(v, (dict, list)):
+            depth += 1
+            if depth > MAX_DEPTH:
+                fail("E_PARSE_JSON", f"nesting deeper than {MAX_DEPTH} levels", p)
         if v is None or isinstance(v, bool):
             continue
         if isinstance(v, str):
@@ -125,10 +155,10 @@ def check_json_value(value: Any, path: str = "$") -> None:
                     fail("E_PARSE_JSON", f"member name {k!r} is not a string", p)
                 if _has_surrogate(k):
                     fail("E_PARSE_JSON", "lone surrogate in member name", p)
-                stack.append((item, f"{p}.{k}"))
+                stack.append((item, f"{p}.{k}", depth))
         elif isinstance(v, list):
             for i, item in enumerate(v):
-                stack.append((item, f"{p}[{i}]"))
+                stack.append((item, f"{p}[{i}]", depth))
         else:
             fail("E_PARSE_JSON", f"{type(v).__name__} is not a JSON value", p)
 

{datumesh-0.2.0 → datumesh-0.2.1}/src/datumesh/_keys.py

@@ -123,18 +123,20 @@ def keys_from_response(host: str, status: Optional[int], body: Union[str, bytes,
     ``status`` is the HTTP status, or None for a network, DNS, TLS or timeout
     failure. Any status other than 200 (redirects and 404 included) is
     E_KEY_UNAVAILABLE; a 200 whose body is not a valid key document for
-    ``host`` is E_KEY_DOC. Never raises.
+    ``host``, or any 200 for a host that is not a DNS name, is E_KEY_DOC.
+    Never raises.
     """
     if not isinstance(host, str):
         return KeysResult(False, "E_KEY_UNAVAILABLE", None, f"host must be a str, not {type(host).__name__}")
-    try:
-        lx.check_dns_name(host, "host")
-    except DatumeshError as e:
-        return KeysResult(False, "E_KEY_UNAVAILABLE", host, f"cannot retrieve keys for an invalid host: {e.detail}")
     if status is None:
         return KeysResult(False, "E_KEY_UNAVAILABLE", host, "network, DNS, TLS or timeout failure")
     if isinstance(status, bool) or not isinstance(status, int) or status != 200:
         return KeysResult(False, "E_KEY_UNAVAILABLE", host, f"HTTP status {status!r}")
+    try:
+        lx.check_dns_name(host, "host")
+    except DatumeshError as e:
+        # SPEC 9.3: a response offered for a host that is not a DNS name cannot satisfy 9.2.
+        return _doc_error(host, f"a document for a host that is not a DNS name cannot satisfy 9.2: {e.detail}")
     if body is None:
         return _doc_error(host, "200 response without a body")
     if not isinstance(body, (str, bytes, bytearray, memoryview)):

{datumesh-0.2.0 → datumesh-0.2.1}/src/datumesh/_uri.py

@@ -6,6 +6,7 @@ from typing import Any, Dict, List, Optional, Tuple
 
 from . import _lexical as lx
 from ._errors import fail
+from ._json import sort_key
 from ._model import SLICE, validate_ref
 
 SCHEME = "cell://"
@@ -48,10 +49,17 @@ def _encode(text: str) -> str:
 
 
 def _declared_types(signature: Any) -> Dict[str, str]:
-    args = signature.get("args") if isinstance(signature, dict) else None
-    if not isinstance(args, dict) or not all(
-            isinstance(a, dict) and isinstance(a.get("type"), str) for a in args.values()):
-        raise TypeError('signature must be {"args": {<name>: {"type": <type name>, ...}}, ...}')
+    """SPEC 5.4 step 5: read the argument types; an unreadable signature is E_SCHEMA."""
+    if not isinstance(signature, dict):
+        fail("E_SCHEMA", "the signature is an object", "signature")
+    args = signature.get("args")
+    if not isinstance(args, dict):
+        fail("E_SCHEMA", "the signature has an args object", "signature" if "args" not in signature
+             else "signature.args")
+    for name in sorted(args, key=sort_key):
+        a = args[name]
+        if not isinstance(a, dict) or not isinstance(a.get("type"), str):
+            fail("E_SCHEMA", "an argument declaration is an object with a string type", f"signature.args.{name}")
     return {name: a["type"] for name, a in args.items()}
 
 
@@ -61,12 +69,11 @@ def parse_uri(uri: str, signature: Dict[str, Any]) -> Dict[str, Any]:
     ``signature`` is the ``signature`` member of the function's descriptor; it
     supplies each argument's type. As SPEC 5.4 says, it is taken as given (it comes
     from a descriptor already checked under section 7): only its argument types are
-    read, and a signature from which they cannot be read is a TypeError. Checks run
-    in the order of SPEC 5.4 and the first failure is raised as DatumeshError.
+    read, in step 5, and a signature from which they cannot be read is E_SCHEMA.
+    Checks run in the order of SPEC 5.4 and the first failure is raised as DatumeshError.
     """
     if not isinstance(uri, str):
         raise TypeError(f"uri must be a str, not {type(uri).__name__}")
-    declared = _declared_types(signature)
 
     # 1. Outer grammar.
     if not uri.startswith(SCHEME) or "#" in uri:
@@ -120,7 +127,8 @@ def parse_uri(uri: str, signature: Dict[str, Any]) -> Dict[str, Any]:
     if len(params) > lx.LIMIT_ARGS:
         fail("E_CANON_LIMIT", f"more than {lx.LIMIT_ARGS} arguments", "uri.query")
 
-    # 5. Arguments against the signature: unknown, then missing.
+    # 5. The signature (read, not checked: SPEC 5.4), then the arguments against it: unknown, then missing.
+    declared = _declared_types(signature)
     present = {name for name, _ in params}
     for name, _ in params:
         if name not in declared:

{datumesh-0.2.0 → datumesh-0.2.1/src/datumesh.egg-info}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: datumesh
-Version: 0.2.0
-Summary: Verify Datumesh receipts (spec-0.2.0): RFC 8785 canonical JSON, Ed25519 signatures, blobs, units, cell URIs, response envelopes, key documents.
+Version: 0.2.1
+Summary: Verify Datumesh receipts (spec-0.2.1): RFC 8785 canonical JSON, Ed25519 signatures, blobs, units, cell URIs, response envelopes, key documents.
 Author: Datumesh
 License-Expression: Apache-2.0
 Project-URL: Homepage, https://datumesh.com
 Project-URL: Repository, https://github.com/datumesh-com/datumesh-verify-py
-Project-URL: Specification (spec-0.2.0), https://github.com/datumesh-com/datumesh-spec/blob/spec-0.2.0/SPEC.md
-Keywords: datumesh,spec-0.2.0,receipt,verification,ed25519,rfc8785,jcs,canonical-json
+Project-URL: Specification (spec-0.2.1), https://github.com/datumesh-com/datumesh-spec/blob/spec-0.2.1/SPEC.md
+Keywords: datumesh,spec-0.2.1,receipt,verification,ed25519,rfc8785,jcs,canonical-json
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: OS Independent
@@ -27,11 +27,11 @@ Dynamic: license-file
 
 # datumesh
 
-Verify [Datumesh](https://datumesh.com) receipts in Python. A receipt is a signed answer for one addressable data cell; this library checks its canonical form (RFC 8785 JSON) and its Ed25519 signature against the signer's published keys, and optionally the recomputation checks (function descriptor, input receipts, and a value you computed) and the content of a blob value, as the [Datumesh specification](https://github.com/datumesh-com/datumesh-spec/blob/spec-0.2.0/SPEC.md) (revision `spec-0.2.0`) defines. It also checks a mesh's response envelope and resolves the unit of a cell's value.
+Verify [Datumesh](https://datumesh.com) receipts in Python. A receipt is a signed answer for one addressable data cell; this library checks its canonical form (RFC 8785 JSON) and its Ed25519 signature against the signer's published keys, and optionally the recomputation checks (function descriptor, input receipts, and a value you computed) and the content of a blob value, as the [Datumesh specification](https://github.com/datumesh-com/datumesh-spec/blob/spec-0.2.1/SPEC.md) (revision `spec-0.2.1`) defines. It also checks a mesh's response envelope and resolves the unit of a cell's value.
 
 ```sh
 pip install datumesh
-git clone --depth 1 --branch spec-0.2.0 https://github.com/datumesh-com/datumesh-spec && cd datumesh-spec
+git clone --depth 1 --branch spec-0.2.1 https://github.com/datumesh-com/datumesh-spec && cd datumesh-spec
 ```
 
 ```python

{datumesh-0.2.0 → datumesh-0.2.1}/src/datumesh.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ tests/test_conformance.py
 tests/test_envelope.py
 tests/test_jcs.py
 tests/test_keys.py
+tests/test_spec_0_2_1.py
 tests/test_unicode.py
 tests/test_units.py
 tests/test_uri.py

{datumesh-0.2.0 → datumesh-0.2.1}/tests/test_api.py

@@ -18,8 +18,8 @@ LINEAGE = next(v for v in vectors_of("receipt", True) if v["id"] == "receipt/com
 
 class ApiTest(unittest.TestCase):
     def test_constants(self) -> None:
-        self.assertEqual(datumesh.SPEC_VERSION, "spec-0.2.0")
-        self.assertEqual(datumesh.__version__, "0.2.0")
+        self.assertEqual(datumesh.SPEC_VERSION, "spec-0.2.1")
+        self.assertEqual(datumesh.__version__, "0.2.1")
         self.assertEqual(len(datumesh.ERROR_CODES), 41)
         self.assertEqual(len(set(datumesh.ERROR_CODES)), 41)
         for code in ("E_CANON_UNIT", "E_CANON_BLOB", "E_BLOB_MISMATCH", "E_ENVELOPE"):

{datumesh-0.2.0 → datumesh-0.2.1}/tests/test_conformance.py

@@ -16,7 +16,7 @@ import datumesh
 class ConformanceTest(unittest.TestCase):
     def test_vector_count(self) -> None:
         counts = collections.Counter(v["kind"] for v in load_vectors())
-        self.assertEqual(sum(counts.values()), 319, counts)
+        self.assertEqual(sum(counts.values()), 339, counts)
         self.assertEqual(counts["unit"], 13, counts)
         self.assertEqual(counts["envelope"], 50, counts)
         # every vector's id is its path, and every kind is one the runner knows

{datumesh-0.2.0 → datumesh-0.2.1}/tests/test_jcs.py

@@ -103,7 +103,12 @@ class JcsTest(unittest.TestCase):
     def test_jcs_vectors(self) -> None:
         for v in vectors_of("jcs"):
             with self.subTest(v["id"]):
-                self.assertEqual(jcs(v["input"]).decode("utf-8"), v["canonical"])
+                if v["valid"]:
+                    self.assertEqual(jcs(v["input"]).decode("utf-8"), v["canonical"])
+                else:
+                    with self.assertRaises(DatumeshError) as cm:
+                        jcs(v["input"])
+                    self.assertEqual(cm.exception.code, v["error"])
 
     def test_strict_parsing(self) -> None:
         cases = {
@@ -123,7 +128,7 @@ class JcsTest(unittest.TestCase):
             self.assertEqual(cm.exception.code, "E_PARSE_JSON")
         # Underflow is not out of range: 1e-400 is the double 0.
         self.assertEqual(jcs("[1e-400, -0, 0e999999]"), b"[0,0,0]")
-        self.assertEqual(jcs("[" * 500 + "]" * 500), b"[" * 500 + b"]" * 500)
+        self.assertEqual(jcs("[" * 64 + "]" * 64), b"[" * 64 + b"]" * 64)  # SPEC 6.1: at most 64 levels
         self.assertEqual(jcs('"\\u00e9\\/"'), '"é/"'.encode())
         self.assertEqual(jcs("123456789012345678901234567890"), b"1.2345678901234568e+29")
 

{datumesh-0.2.0 → datumesh-0.2.1}/tests/test_keys.py

@@ -282,6 +282,18 @@ class FetchKeysTest(unittest.TestCase):
         with mock.patch.object(_keys, "_fetch_url", lambda *a, **k: (None, None)):
             self.assertEqual(datumesh.fetch_keys(HOST).code, "E_KEY_UNAVAILABLE")
 
+    def test_response_for_a_host_that_is_not_a_dns_name(self) -> None:
+        # SPEC 9.3 (spec-0.2.1): a response offered for a host that is not a DNS name
+        # cannot satisfy 9.2, so a 200 is E_KEY_DOC whatever its body; any other status is still
+        # E_KEY_UNAVAILABLE. Confirmed against the reference tool.
+        for host in ("Rates.example.org", "localhost", "10.0.0.1", "rates.example.org:443", "Bad Host"):
+            doc = DOC_TEXT.replace(HOST, host)
+            for status, body, code in ((200, doc, "E_KEY_DOC"), (200, DOC_TEXT, "E_KEY_DOC"), (200, None, "E_KEY_DOC"),
+                                       (200, "x", "E_KEY_DOC"), (404, None, "E_KEY_UNAVAILABLE"),
+                                       (301, None, "E_KEY_UNAVAILABLE"), (None, None, "E_KEY_UNAVAILABLE")):
+                with self.subTest(host=host, status=status, body=str(body)[:10]):
+                    self.assertEqual(keys_from_response(host, status, body).code, code)
+
     def test_fetch_keys_invalid_host_without_network(self) -> None:
         with mock.patch.object(_keys, "_fetch_url", side_effect=AssertionError("network used")):
             for host in ("localhost", "Rates.example.org", "127.0.0.1", "a/b.example"):

datumesh-0.2.1/tests/test_spec_0_2_1.py

@@ -0,0 +1,198 @@
+"""Statements written down in spec-0.2.1 (a text-only revision): each is tested here.
+
+Codes were confirmed against the reference tool, used as a black box.
+"""
+
+from __future__ import annotations
+
+import copy
+import json
+import unittest
+
+from util import env_keys, vectors_of
+
+import datumesh
+from datumesh import DatumeshError, canonicalize, parse_uri, verify
+
+STORED = next(v for v in vectors_of("receipt", True) if v["id"] == "receipt/stored-number")
+R = json.loads(STORED["input"])
+
+
+def code_of(fn, *args):
+    try:
+        fn(*args)
+        return None
+    except DatumeshError as e:
+        return e.code
+
+
+def receipt_code(**changes) -> object:
+    r = copy.deepcopy(R)
+    for k, v in changes.items():
+        r[k] = v
+    return code_of(canonicalize, r, "receipt")
+
+
+class JsonParsingTest(unittest.TestCase):
+    """SPEC 6.1: nesting at most 64 levels, and the order in which parse failures are reported."""
+
+    CASES = [
+        ("[" * 64 + "]" * 64, None),
+        ("[" * 65 + "]" * 65, "E_PARSE_JSON"),
+        ('{"a":' * 63 + "[]" + "}" * 63, None),  # 63 objects + 1 array = 64
+        ('{"a":' * 64 + "[]" + "}" * 64, "E_PARSE_JSON"),
+        ("[" * 65, "E_PARSE_JSON"),  # unclosed, too deep
+        ("[" * 100000, "E_PARSE_JSON"),
+        # brackets inside strings, escaped quotes included, do not count
+        ('{"a": "' + "[" * 100 + '", "a": 2}', "E_PARSE_DUPLICATE_KEY"),
+        ('["\\"' + "[" * 100 + '", 1]', None),
+        ('["\\\\", ' + "[" * 63 + "]" * 63 + "]", None),
+        ('["\\\\", ' + "[" * 64 + "]" * 64 + "]", "E_PARSE_JSON"),
+        # depth before anything else in the text
+        ('{"a": 1, "a": 2, "b": ' + "[" * 64 + "]" * 64 + "}", "E_PARSE_JSON"),
+        ('{"a": 1, "a": 2, "b": ' + "[" * 63 + "]" * 63 + "}", "E_PARSE_DUPLICATE_KEY"),
+        # then the first in text order of syntax error, NaN/Infinity, overflow, duplicate (at its close)
+        ('[{"a": 1, "a": 2}, NaN]', "E_PARSE_DUPLICATE_KEY"),
+        ('[NaN, {"a": 1, "a": 2}]', "E_PARSE_JSON"),
+        ('[1e400, {"a": 1, "a": 2}]', "E_PARSE_JSON"),
+        ('[{"a": 1, "a": 2}, 1e400]', "E_PARSE_DUPLICATE_KEY"),
+        ('[{"a": 1, "a": 2}, x]', "E_PARSE_DUPLICATE_KEY"),
+        ('{"a": 1, "a": 2, x}', "E_PARSE_JSON"),
+        ('{"a": {"b": 1, "b": 2}, "a": 3}', "E_PARSE_DUPLICATE_KEY"),
+        # lone surrogates last
+        ('{"a": "\\ud800", "a": 1}', "E_PARSE_DUPLICATE_KEY"),
+        ('["\\ud800", NaN]', "E_PARSE_JSON"),
+        ("[1e-400]", None),  # underflow is not an error
+    ]
+
+    def test_cases(self) -> None:
+        for text, code in self.CASES:
+            with self.subTest(text[:60]):
+                self.assertEqual(code_of(datumesh.jcs, text), code)
+                self.assertEqual(code_of(datumesh.jcs, text.encode()), code)
+
+    def test_bom_and_utf8_come_first(self) -> None:
+        deep = "[" * 70 + "]" * 70
+        self.assertEqual(code_of(datumesh.jcs, b"\xef\xbb\xbf" + deep.encode()), "E_PARSE_JSON")
+        self.assertEqual(code_of(datumesh.jcs, b'["\xff"' + deep.encode() + b"]"), "E_PARSE_JSON")
+
+    def test_depth_through_verify_and_envelopes(self) -> None:
+        self.assertEqual(verify("[" * 65 + "]" * 65, {}).code, "E_PARSE_JSON")
+        body = '{"outcome": "not_covered", "x": ' + "[" * 64 + "]" * 64 + "}"
+        res = datumesh.check_envelope(404, body, [], {"cell_id": "0" * 64})
+        self.assertEqual(res.code, "E_PARSE_JSON")
+
+    def test_parsed_values_too_deep(self) -> None:
+        # A parsed value that would be more than 64 levels deep as text is refused the same way.
+        v: list = []
+        for _ in range(64):
+            v = [v]
+        self.assertEqual(code_of(datumesh.jcs, v), "E_PARSE_JSON")
+        self.assertIsNone(code_of(datumesh.jcs, v[0]))
+
+
+class UriSignatureTest(unittest.TestCase):
+    """SPEC 5.4 step 5: an unreadable signature is E_SCHEMA, after steps 1-4."""
+
+    def test_unreadable(self) -> None:
+        uri = "cell://m.example/f?n=1"
+        for sig, path in [
+            (None, "signature"), ([], "signature"), ("x", "signature"), ({}, "signature"),
+            ({"args": []}, "signature.args"), ({"args": {"n": 5}}, "signature.args.n"),
+            ({"args": {"n": {}}}, "signature.args.n"), ({"args": {"n": {"type": 5}}}, "signature.args.n"),
+            ({"args": {"z": {"type": "number"}, "b": 5, "a": {}}}, "signature.args.a"),  # JCS order
+        ]:
+            with self.subTest(sig=sig):
+                with self.assertRaises(DatumeshError) as cm:
+                    parse_uri(uri, sig)  # type: ignore[arg-type]
+                self.assertEqual((cm.exception.code, cm.exception.path), ("E_SCHEMA", path))
+
+    def test_steps_1_to_4_first(self) -> None:
+        for uri, code in [("cell://m.example/f#x", "E_PARSE_URI"), ("cell://M.example/f", "E_CANON_NAME"),
+                          ("cell://m.example/f?b=1&a=1", "E_CANON_ARG_ORDER"),
+                          ("cell://m.example/f?" + "&".join("a%02d=1" % i for i in range(33)), "E_CANON_LIMIT")]:
+            with self.subTest(uri[:40]):
+                self.assertEqual(code_of(parse_uri, uri, None), code)
+        self.assertEqual(code_of(parse_uri, "cell://m.example/f?n=1", {"args": {"n": {"type": "decimal"}}}),
+                         "E_CANON_TYPE")
+        self.assertIsNone(code_of(parse_uri, "cell://m.example/f?n=*", {"args": {"n": {"type": "decimal"}}}))
+
+    def test_asof_and_repeats(self) -> None:
+        sig = {"args": {"a": {"type": "number"}, "b": {"type": "number"}}}
+        self.assertEqual(code_of(parse_uri, "cell://m.example/f?a=1&b=1&a=1", sig), "E_CANON_ARG_ORDER")
+        self.assertEqual(code_of(parse_uri, "cell://m.example/f?a=1&b=1&asof=*", sig), "E_CANON_PERCENT")
+
+
+class ReceiptStatementsTest(unittest.TestCase):
+    def test_licence_grammar(self) -> None:
+        for lic, code in [("CC-BY-4.0", None), ("Not-A-Real-Licence", None), ("a.b+c", None),
+                          ("-x", "E_CANON_LICENCE"), ("CC BY", "E_CANON_LICENCE"), ("", "E_CANON_LICENCE"),
+                          ("a" * 64, None), ("a" * 65, "E_CANON_LIMIT"), ("-" * 65, "E_CANON_LICENCE"),
+                          ("https://x.example/l", None), ("https://", "E_CANON_LICENCE"),
+                          ("HTTPS://x.example/l", "E_CANON_LICENCE"), ("https://x.example/a b", "E_CANON_LICENCE"),
+                          ("https://" + "a" * 504, None), ("https://" + "a" * 505, "E_CANON_LIMIT"),
+                          ("https://" + "a" * 600 + " ", "E_CANON_LICENCE"), ("http://x.example", "E_CANON_LICENCE")]:
+            with self.subTest(lic[:40]):
+                self.assertEqual(receipt_code(licence=lic), code)
+
+    def test_key_reference_codes(self) -> None:
+        for ref, code in [("rates.example.org", "E_CANON_NAME"), ("Rates.example.org#d712b32a2cc5cb7c", "E_CANON_NAME"),
+                          ("rates#d712b32a2cc5cb7c", "E_CANON_NAME"), ("rates.example.org#D712B32A2CC5CB7C", "E_CANON_HEX"),
+                          ("rates.example.org#d712b32a2cc5cb7", "E_CANON_HEX"),
+                          ("rates.example.org#d712b32a2cc5cb7c#x", "E_CANON_HEX")]:
+            with self.subTest(ref):
+                self.assertEqual(receipt_code(computed_by=ref), code)
+
+    def test_instant_failures(self) -> None:
+        for t in ("2023-02-29T00:00:00.000000Z", "2024-13-01T00:00:00.000000Z", "2024-03-15T23:59:60.000000Z",
+                  "0000-01-01T00:00:00.000000Z"):
+            with self.subTest(t):
+                self.assertEqual(receipt_code(issued=t), "E_CANON_INSTANT")
+
+    def test_value_json_types(self) -> None:
+        self.assertEqual(receipt_code(value=1.0892), "E_SCHEMA")
+        self.assertEqual(receipt_code(value=None), "E_SCHEMA")
+        self.assertEqual(receipt_code(value=[]), "E_SCHEMA")
+        self.assertEqual(receipt_code(value=True), "E_CANON_TYPE")
+        s = {"type": "boolean", "value": "true"}
+        self.assertEqual(code_of(canonicalize, s, "scalar"), "E_CANON_TYPE")
+        self.assertEqual(code_of(canonicalize, {"type": "string", "value": 1}, "scalar"), "E_SCHEMA")
+
+    def test_consistency_order(self) -> None:
+        # Step 4 runs in the listed order: slices, publisher, valid, time.
+        args = dict(R["cell"]["args"], base="*")
+        later = "2025-01-01T00:00:00.000000Z"
+        self.assertEqual(receipt_code(cell=dict(R["cell"], args=args), publisher="other.example.org"), "E_SLICE")
+        self.assertEqual(receipt_code(publisher="other.example.org", valid={"date": {"type": "date", "value": "2024-01-01"}}),
+                         "E_PUBLISHER_MISMATCH")
+        self.assertEqual(receipt_code(valid={"date": {"type": "date", "value": "2024-01-01"}}, tx=later),
+                         "E_VALID_MISMATCH")
+
+    def test_container_order(self) -> None:
+        r_inputs = ["f" * 64, "0" * 64]
+        self.assertEqual(receipt_code(inputs=r_inputs), "E_CANON_SET")
+        self.assertEqual(receipt_code(inputs=["F" * 64, "0" * 64]), "E_CANON_HEX")
+        self.assertEqual(receipt_code(inputs=["%064x" % i for i in range(4097)][::-1]), "E_CANON_SET")
+        self.assertEqual(receipt_code(inputs=["%064x" % i for i in range(4097)]), "E_CANON_LIMIT")
+        args = {"a%02d" % i: {"type": "string", "value": "x"} for i in range(33)}
+        args["A"] = {"type": "string", "value": "x"}
+        self.assertEqual(code_of(canonicalize, {"args": args, "fn": "f", "ns": "m.example"}, "ref"), "E_CANON_LIMIT")
+
+    def test_stored_convention_not_enforced(self) -> None:
+        d = {"code": {"body": "x + 1\n", "lang": "stored"}, "inputs": ["m.example/f"],
+             "signature": {"args": {}, "returns": "boolean"}}
+        self.assertIsNone(code_of(datumesh.function_hash, d))
+
+    def test_ed25519_vectors(self) -> None:
+        names = {v["id"]: v for v in vectors_of("receipt") if "ed25519" in v["id"]}
+        self.assertEqual(sorted(names), ["invalid/receipt-ed25519-negative-zero-r", "invalid/receipt-ed25519-non-canonical-r",
+                                         "invalid/receipt-ed25519-s-not-reduced", "invalid/receipt-ed25519-small-order-key",
+                                         "invalid/receipt-ed25519-small-order-r", "receipt/ed25519-mixed-order-key"])
+        for vid, v in names.items():
+            with self.subTest(vid):
+                res = verify(v["input"], env_keys(v["keys"]))
+                self.assertEqual(res.code, "OK" if v["valid"] else v["error"])
+
+
+if __name__ == "__main__":
+    unittest.main()

{datumesh-0.2.0 → datumesh-0.2.1}/tests/test_uri.py

@@ -29,7 +29,7 @@ class UriTest(unittest.TestCase):
                 self.assertEqual(parse_uri(format_uri(v["object"]), v["signature"]), v["object"])
                 n += 1
         self.assertEqual(n, 11)
-        self.assertEqual(len(vectors_of("uri", False)), 27)
+        self.assertEqual(len(vectors_of("uri", False)), 32)
 
     def test_invalid_vectors(self) -> None:
         for v in vectors_of("uri", False):
@@ -60,10 +60,11 @@ class UriTest(unittest.TestCase):
         with self.assertRaises(DatumeshError) as cm:
             parse_uri("cell://math.example/f?n=1", {"args": {"n": {"type": "decimal", "valid": False}}})
         self.assertEqual(cm.exception.code, "E_CANON_TYPE")
-        # Only a signature whose argument types cannot be read at all is a caller error.
+        # A signature whose argument types cannot be read is E_SCHEMA (SPEC 5.4 step 5, spec-0.2.1).
         for bad in (None, {}, {"args": []}, {"args": {"n": {}}}, {"args": {"n": {"type": 5}}}):
-            with self.subTest(bad=bad), self.assertRaises(TypeError):
+            with self.subTest(bad=bad), self.assertRaises(DatumeshError) as cm:
                 parse_uri("cell://math.example/f?n=1", bad)  # type: ignore[arg-type]
+            self.assertEqual(cm.exception.code, "E_SCHEMA")
         with self.assertRaises(TypeError):
             parse_uri(b"cell://math.example/pi", {"args": {}, "returns": "boolean"})  # type: ignore[arg-type]