# SPDX-License-Identifier: Apache-2.0 # Copyright 2026 Scienting # # Source Code: https://git.scient.ing/papers/paperspec # See the LICENSE.md file for full license terms. """Rights records, policies, stage checks and backend conditions (spec/14).""" from typing import ClassVar import pytest from helpers_lib1 import case_params, read_cases from paperspec import rights SHA = "a" * 64 OTHER_SHA = "b" * 64 NOW = "2026-10-11T00:00:00Z" ALL_KEYS = [ *rights.USES, *(f"ai/{p}/{q}" for p in rights.PURPOSES for q in rights.PROCESSORS), ] def witness(uses=None, **extra): """A witness whose rights record holds `uses` and the extra record members.""" record = {"basis": "subscription", "uses": uses or {}} record.update({k: v for k, v in extra.items() if k not in ("origin", "sha256")}) return { "rights": record, "origin": extra.get("origin", {"doi": "10.5555/x"}), "sha256": extra.get("sha256", SHA), } def policy(uses, **applies): """A policy granting `uses`, applying to the witnesses `applies` describes.""" out = {"uses": uses} if applies: out["applies_to"] = applies return out @pytest.mark.parametrize( "case", case_params([c for c in read_cases("rights") if "stage" in c]) ) def test_stage_vector(case): w = { "rights": case["rights"], "origin": case["origin"], "sha256": case["witness_sha256"], } uses, expired = rights.effective(w, case["policies"], case["now"]) allowed, lacking = rights.check(case["requires"], case["processor"], uses) assert {"allowed": allowed, "lacking": lacking, "expired": expired} == case[ "expect" ] @pytest.mark.parametrize( "case", case_params([c for c in read_cases("rights") if "backend" in c]) ) def test_backend_vector(case): allowed, failed = rights.backend_allowed(case["backend"], case["profile"]) assert {"allowed": allowed, "failed": failed} == case["expect"] def test_combining_vector(): case = next(c for c in read_cases("rights") if c["id"] == "combine") assert rights.combine([rights.flat(r) for r in case["rights"]]) == case["expect"] class TestFlat: def test_an_empty_record_is_unknown_everywhere(self): flat = rights.flat({}) assert list(flat) == ALL_KEYS assert set(flat.values()) == {"unknown"} def test_there_are_five_uses_and_eight_ai_pairs(self): assert len(rights.USES) == 5 assert len(rights.AI_PAIRS) == 8 assert len(rights.flat({})) == 13 def test_values_are_kept_and_anything_but_a_boolean_is_unknown(self): flat = rights.flat( { "uses": { "read": True, "tdm": False, "redistribute": "unknown", "quote-public": "yes", "accessible-copy": None, "ai": {"internal/local": True, "external/outside": False}, } } ) assert flat["read"] is True assert flat["tdm"] is False assert flat["redistribute"] == "unknown" assert flat["quote-public"] == "unknown" assert flat["accessible-copy"] == "unknown" assert flat["ai/internal/local"] is True assert flat["ai/external/outside"] is False assert flat["ai/internal/tenancy"] == "unknown" class TestEffective: def test_without_policies_the_flat_uses_are_returned(self): w = witness({"read": True, "tdm": False}) uses, expired = rights.effective(w, [], NOW) assert uses == rights.flat(w["rights"]) assert expired is False def test_an_expired_record_allows_nothing(self): w = witness({"read": True}, valid_until="2026-10-11T00:00:00Z") uses, expired = rights.effective(w, [policy({"tdm": True})], NOW) assert expired is True assert set(uses) == set(ALL_KEYS) assert set(uses.values()) == {False} def test_a_record_is_current_until_the_instant_it_expires(self): w = witness({"read": True}, valid_until="2026-10-11T00:00:01Z") assert rights.effective(w, [], NOW)[1] is False assert rights.effective(w, [], "2026-10-11T00:00:01Z")[1] is True def test_a_null_expiry_never_expires(self): w = witness({"read": True}, valid_until=None) assert rights.effective(w, [], "9999-01-01T00:00:00Z")[1] is False def test_a_policy_settles_an_unknown_use(self): w = witness({"read": True}) uses, _ = rights.effective( w, [policy({"tdm": True, "ai": {"internal/tenancy": True}})], NOW ) assert uses["tdm"] is True assert uses["ai/internal/tenancy"] is True assert uses["redistribute"] == "unknown" def test_a_policy_never_overrides_a_known_use(self): w = witness({"read": False, "tdm": True}) uses, _ = rights.effective(w, [policy({"read": True, "tdm": False})], NOW) assert uses["read"] is False assert uses["tdm"] is True def test_a_policy_can_settle_a_use_as_false(self): uses, _ = rights.effective(witness(), [policy({"read": False})], NOW) assert uses["read"] is False def test_the_first_applicable_policy_to_speak_wins(self): policies = [policy({"read": True}), policy({"read": False, "tdm": True})] uses, _ = rights.effective(witness(), policies, NOW) assert uses["read"] is True assert uses["tdm"] is True def test_a_policy_that_says_unknown_settles_nothing(self): uses, _ = rights.effective(witness(), [policy({"read": "unknown"})], NOW) assert uses["read"] == "unknown" def test_a_policy_without_uses_changes_nothing(self): uses, _ = rights.effective(witness({"read": True}), [{"applies_to": {}}], NOW) assert uses == rights.flat({"uses": {"read": True}}) @pytest.mark.parametrize( ("when", "applies"), [ ({"at": "2026-10-11T00:00:00Z"}, True), ({"at": "2026-10-11T00:00:01Z"}, False), ({"valid_until": "2026-10-11T00:00:00Z"}, False), ({"valid_until": "2026-10-11T00:00:01Z"}, True), ({"valid_until": None, "at": None}, True), ], ) def test_a_policy_applies_from_its_time_to_its_expiry(self, when, applies): p = dict(policy({"read": True}), **when) uses, _ = rights.effective(witness(), [p], NOW) assert (uses["read"] is True) is applies @pytest.mark.parametrize( ("applies", "w", "expected"), [ ({"basis": ["subscription"]}, witness(), True), ({"basis": ["open-license"]}, witness(), False), ({"license": ["CC-BY-4.0"]}, witness(license={"spdx": "CC-BY-4.0"}), True), ({"license": ["CC-BY-4.0"]}, witness(license={"spdx": "MIT"}), False), ({"license": ["CC-BY-4.0"]}, witness(license={"text": "terms"}), False), ({"license": ["CC-BY-4.0"]}, witness(license=None), False), ({"license": ["CC-BY-4.0"]}, witness(), False), ({"doi_prefixes": ["10.5555/"]}, witness(), True), ({"doi_prefixes": ["10.1/", "10.5555/"]}, witness(), True), ({"doi_prefixes": ["10.1/"]}, witness(), False), ({"doi_prefixes": ["10.5555/"]}, witness(origin={}), False), ({"doi_prefixes": ["10.5555/"]}, witness(origin=None), False), ({"doi_prefixes": ["10.5555/"]}, witness(origin={"doi": None}), False), ({"witnesses": [SHA]}, witness(), True), ({"witnesses": [OTHER_SHA]}, witness(), False), ({}, witness(), True), ( {"basis": ["subscription"], "doi_prefixes": ["10.1/"]}, witness(), False, ), ], ) def test_a_policy_applies_to_the_witnesses_it_describes(self, applies, w, expected): p = policy({"read": True}) p["applies_to"] = applies uses, _ = rights.effective(w, [p], NOW) assert (uses["read"] is True) is expected class TestCombine: @pytest.mark.parametrize( ("values", "combined"), [ ([True, True], True), ([True, False], False), ([True, "unknown"], "unknown"), ([False, "unknown"], False), (["unknown", "unknown"], "unknown"), ([False, False], False), ([True], True), (["unknown", True, False], False), ], ) def test_false_beats_unknown_beats_true(self, values, combined): flats = [dict.fromkeys(ALL_KEYS, v) for v in values] assert set(rights.combine(flats).values()) == {combined} def test_it_combines_each_use_separately(self): a = rights.flat({"uses": {"read": True, "tdm": True}}) b = rights.flat({"uses": {"read": True, "tdm": False}}) out = rights.combine([a, b]) assert out["read"] is True assert out["tdm"] is False assert out["redistribute"] == "unknown" def test_combining_one_record_is_that_record(self): flat = rights.flat({"uses": {"read": True, "tdm": False}}) assert rights.combine([flat]) == flat class TestCheck: ALL_TRUE = dict.fromkeys(ALL_KEYS, True) def test_a_stage_with_no_requirements_is_allowed(self): assert rights.check({}, "outside", {}) == (True, []) def test_a_use_that_is_true_is_met(self): assert rights.check({"uses": ["read", "tdm"]}, "local", self.ALL_TRUE) == ( True, [], ) def test_false_and_unknown_uses_are_lacking_and_unknown_is_marked(self): uses = dict(self.ALL_TRUE, tdm=False, read="unknown") allowed, lacking = rights.check( {"uses": ["tdm", "read", "redistribute"]}, "local", uses ) assert allowed is False assert lacking == ["tdm", "read?"] def test_an_ai_stage_needs_the_purpose_and_processor_pair(self): stage = {"ai": {"purpose": "external"}} assert rights.check(stage, "tenancy", self.ALL_TRUE) == (True, []) uses = dict(self.ALL_TRUE, **{"ai/external/tenancy": False}) assert rights.check(stage, "tenancy", uses) == (False, ["ai/external/tenancy"]) uses = dict(self.ALL_TRUE, **{"ai/external/tenancy": "unknown"}) assert rights.check(stage, "tenancy", uses) == (False, ["ai/external/tenancy?"]) def test_a_processor_the_stage_does_not_allow_is_lacking_before_its_pair(self): stage = {"ai": {"purpose": "internal", "processors": ["local", "tenancy"]}} uses = dict(self.ALL_TRUE, **{"ai/internal/outside": "unknown"}) assert rights.check(stage, "outside", uses) == ( False, ["processor:outside", "ai/internal/outside?"], ) assert rights.check(stage, "local", uses) == (True, []) def test_an_empty_list_of_allowed_processors_allows_any(self): stage = {"ai": {"purpose": "internal", "processors": []}} assert rights.check(stage, "outside", self.ALL_TRUE) == (True, []) def test_lacking_lists_uses_before_the_ai_pair(self): stage = {"uses": ["tdm"], "ai": {"purpose": "internal"}} uses = dict(self.ALL_TRUE, tdm="unknown", **{"ai/internal/local": False}) assert rights.check(stage, "local", uses)[1] == ["tdm?", "ai/internal/local"] class TestBackendAllowed: CAP: ClassVar[dict] = {"id": "cap", "kind": "revenue-cap", "usd": 100} COMPETE: ClassVar[dict] = { "id": "rival", "kind": "no-competition", "vendor": "acme", } PURPOSE: ClassVar[dict] = { "id": "why", "kind": "purpose", "allowed": ["research", "education"], } def test_a_backend_without_conditions_is_allowed_to_anyone(self): assert rights.backend_allowed({}, {}) == (True, []) assert rights.backend_allowed( {"conditions": []}, {"purpose": "commercial"} ) == ( True, [], ) @pytest.mark.parametrize( ("profile", "passes"), [ ({"revenue_or_funding_usd": {"at_most": 100}}, True), ({"revenue_or_funding_usd": {"at_most": 99}}, True), ({"revenue_or_funding_usd": {"at_most": 101}}, False), ({"revenue_or_funding_usd": {"at_most": None}}, False), ({"revenue_or_funding_usd": {}}, False), ({"revenue_or_funding_usd": None}, False), ({}, False), ], ) def test_a_revenue_cap_needs_a_known_bound_within_it(self, profile, passes): assert rights.backend_allowed({"conditions": [self.CAP]}, profile) == ( (True, []) if passes else (False, ["cap"]) ) @pytest.mark.parametrize( ("competes_with", "passes"), [ ([], True), (["other"], True), (["other", "acme"], False), (["acme"], False), (None, False), ], ) def test_a_no_competition_condition_needs_a_known_list_without_the_vendor( self, competes_with, passes ): profile = {"competes_with": competes_with} assert rights.backend_allowed({"conditions": [self.COMPETE]}, profile) == ( (True, []) if passes else (False, ["rival"]) ) assert rights.backend_allowed({"conditions": [self.COMPETE]}, {}) == ( False, ["rival"], ) @pytest.mark.parametrize( ("purpose", "passes"), [("research", True), ("education", True), ("commercial", False), (None, False)], ) def test_a_purpose_condition_needs_a_listed_purpose(self, purpose, passes): assert rights.backend_allowed( {"conditions": [self.PURPOSE]}, {"purpose": purpose} ) == ((True, []) if passes else (False, ["why"])) def test_a_condition_of_an_unknown_kind_always_fails(self): backend = {"conditions": [{"id": "novel", "kind": "from-the-future"}]} assert rights.backend_allowed(backend, {"purpose": "research"}) == ( False, ["novel"], ) def test_every_failed_condition_is_listed_in_order(self): backend = {"conditions": [self.PURPOSE, self.CAP, self.COMPETE]} profile = {"purpose": "commercial", "revenue_or_funding_usd": {"at_most": 5}} assert rights.backend_allowed(backend, profile) == (False, ["why", "rival"])