Add the pytest suite and fix the bugs it found

The suite takes its data from the vectors and fixtures: 3635 tests, 97.9% branch
coverage, and paperspec check and paperspec stress give the same results as before.
Fixed: receipts.verify_signature raised KeyError for a record without a format;
traces.DOC_TAG matched a tag followed by a line feed; paperspec load and paperspec check
left SQLite connections open; the site builder copied the output folder's subfolders into
itself.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B8cL4zN4XpaQF5cBtASzfq
This commit is contained in:
alexmandClaude committed 2026-10-19 04:32:44 -04:00
1 parent 30d310f64d
commit a8fc7237ae
76 files changed
+15564 -80

No files matched your search

+420
View File
@@ -0,0 +1,420 @@
# 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.
"""Data tied to words: kinds of data, quantities, subjects and datasets (paperspec.data)."""
import copy
import json
import pytest
from hypothesis import given, strategies as st
from conftest import FIXTURES, read_jsonl, vector_cases
from helpers_lib2 import (
HALE,
PROPS,
RECORDS,
accepted_by_schema,
rule_chapters,
schema_store,
)
from paperspec import data
CASES = vector_cases("data")
RULES = (
"layer.data.type",
"layer.data.quantity",
"layer.data.subject",
"layer.data.dataset",
)
LAYER = read_jsonl(RECORDS / "data" / "annotations.jsonl")
BOND_PARAMS = json.loads(
(
FIXTURES
/ "packages"
/ HALE
/ "datasets"
/ "ds-hale-bond-params"
/ "datapackage.json"
).read_text(encoding="utf-8")
)
DESCRIPTORS = {
"ds-hale-bond-params": BOND_PARAMS,
"ds-hale-ctct-scan": json.loads(
(RECORDS / "datasets" / "ds-hale-ctct-scan" / "datapackage.json").read_text(
encoding="utf-8"
)
),
}
TABLE = next(c for c in CASES if c["id"] == "valid-a-table-against-its-dataset")[
"annotation"
]
WATER = "XLYOFNOQVPJJNP-UHFFFAOYSA-N"
PEPTIDE = "protein:5807fcbf6d5567ca"
def edited(annotation, **body):
"""A copy of `annotation` whose body has the given fields replaced; None removes a field."""
out = copy.deepcopy(annotation)
for key, value in body.items():
if value is None:
out["body"].pop(key, None)
else:
out["body"][key] = value
return out
def messages(annotation, dataset=None):
"""The (rule, message) pairs `problems` reports for `annotation`."""
return [(x["rule"], x["message"]) for x in data.problems(annotation, dataset)]
# --- the vocabulary ---------------------------------------------------------------------------------------------
def test_the_kinds_of_data_are_those_of_the_annotation_schema():
bodies = schema_store().load("annotation.schema.json")["properties"]["body"][
"oneOf"
]
body = next(b for b in bodies if b["properties"]["kind"]["const"] == "data")
assert set(data.DATA_TYPES) == set(body["properties"]["data_type"]["enum"])
@pytest.mark.parametrize("kind", data.DATA_TYPES)
def test_each_kind_of_data_is_described(kind):
assert data.DATA_TYPES[kind].endswith(".")
def test_the_roles_and_subject_kinds():
assert data.ROLES == ("reports", "uses")
assert set(data.SUBJECT_KINDS) == {"structure", "sequence"}
@pytest.mark.parametrize("rule", RULES)
def test_the_rules_are_registered_in_the_layers_chapter(rule):
assert rule_chapters()[rule] == "spec/18-layers.md"
# --- vectors ----------------------------------------------------------------------------------------------------
@pytest.mark.parametrize("case", CASES, ids=lambda c: c["id"])
def test_data_vectors(case):
got = data.problems(case["annotation"], case.get("dataset"))
assert got == case["expect"]
assert accepted_by_schema(case["annotation"]) is case["schema"]
assert {x["rule"] for x in got} <= set(rule_chapters())
@pytest.mark.parametrize("case", CASES, ids=lambda c: c["id"])
def test_a_vector_is_named_for_the_rule_it_breaks(case):
stem = case["id"].split("-", 1)[0]
rules = {x["rule"] for x in case["expect"]}
if stem == "valid":
assert rules == set()
else:
assert "layer.data." + stem in rules
def test_every_rule_is_broken_by_some_vector():
assert {x["rule"] for c in CASES for x in c["expect"]} == set(RULES)
def test_every_kind_of_data_has_a_valid_vector():
ids = {c["id"] for c in CASES}
assert {"valid-kind-" + kind for kind in data.DATA_TYPES} <= ids
# --- the fixture layer -------------------------------------------------------------------------------------------
@pytest.mark.parametrize("annotation", LAYER, ids=lambda a: a["id"].rsplit("/", 1)[1])
def test_the_data_layer_breaks_no_rule_alone_or_against_its_dataset(annotation):
assert annotation["body"]["kind"] == "data"
assert data.problems(annotation) == []
descriptor = DESCRIPTORS.get(annotation["body"].get("dataset"))
assert data.problems(annotation, descriptor) == []
def test_the_data_layers_datasets_are_held_by_the_project():
project = json.loads((RECORDS / "project.json").read_text(encoding="utf-8"))
named = {a["body"]["dataset"] for a in LAYER if "dataset" in a["body"]}
assert named <= set(project["datasets"])
# --- type and role -----------------------------------------------------------------------------------------------
def test_an_annotation_of_another_kind_is_refused():
with pytest.raises(ValueError, match="not a data annotation"):
data.problems({"body": {"kind": "comment"}})
with pytest.raises(ValueError, match="not a data annotation"):
data.problems({"body": {}})
@pytest.mark.parametrize("value", ["spectroscopy", "Spectrum", None, ""])
def test_a_kind_of_data_that_is_not_listed_is_refused(value):
got = messages(edited(TABLE, data_type=value))
assert [r for r, _ in got] == ["layer.data.type"]
assert got[0][1].startswith("the kind of data is not one of abundance, benchmark")
@pytest.mark.parametrize("role", ["names", None, ""])
def test_a_role_that_is_not_listed_is_refused(role):
assert messages(edited(TABLE, role=role)) == [
("layer.data.type", "the role is not one of reports, uses")
]
def test_both_a_wrong_kind_and_a_wrong_role_are_reported_in_that_order():
got = messages(edited(TABLE, data_type="nope", role="nope"))
assert [m.split(" is not")[0] for _, m in got] == ["the kind of data", "the role"]
# --- quantities ----------------------------------------------------------------------------------------------------
def test_a_field_may_be_given_once():
quantities = [{"field": "a", "name": "A"}, {"field": "b", "name": "B"}]
assert data.problems(edited(TABLE, quantities=quantities, dataset=None)) == []
def test_a_repeated_field_is_reported_at_every_repeat():
quantities = [{"field": "a"}, {"field": "b"}, {"field": "a"}, {"field": "a"}]
got = messages(edited(TABLE, quantities=quantities, dataset=None))
assert got == [
("layer.data.quantity", "quantity 2 repeats the field a"),
("layer.data.quantity", "quantity 3 repeats the field a"),
]
def test_quantities_without_a_field_repeat_the_empty_field():
got = messages(edited(TABLE, quantities=[{}, {}], dataset=None))
assert got == [("layer.data.quantity", "quantity 1 repeats the field ")]
# --- subjects ------------------------------------------------------------------------------------------------------
@pytest.mark.parametrize(
"subject",
[
{"kind": "structure", "identity": WATER},
{"kind": "structure", "identity": "smiles:0123456789ab"},
{"kind": "structure", "identity": "smarts:0123456789ab"},
{"kind": "sequence", "identity": PEPTIDE},
{"kind": "sequence", "identity": "dna:0123456789abcdef"},
{"kind": "sequence", "identity": "rna:0123456789abcdef"},
],
)
def test_subjects_take_the_identities_of_the_structure_and_sequence_bodies(subject):
assert data.problems(edited(TABLE, subjects=[subject], dataset=None)) == []
@pytest.mark.parametrize(
("subject", "fragment"),
[
(
{"kind": "reaction", "identity": WATER},
"is of a kind that is not structure or sequence",
),
({"identity": WATER}, "is of a kind that is not structure or sequence"),
(
{"kind": "structure", "identity": PEPTIDE},
"is not the form of a structure identity",
),
(
{"kind": "sequence", "identity": WATER},
"is not the form of a sequence identity",
),
(
{"kind": "structure", "identity": "smiles:0123456789a"},
"not the form of a structure",
),
(
{"kind": "structure", "identity": "smiles:0123456789ABCDEF"},
"not the form of a structure",
),
({"kind": "structure", "identity": WATER + "X"}, "not the form of a structure"),
({"kind": "structure", "identity": ""}, "not the form of a structure"),
(
{"kind": "sequence", "identity": "protein:0123456789abcdef0"},
"not the form of a sequence",
),
(
{"kind": "sequence", "identity": "peptide:0123456789abcdef"},
"not the form of a sequence",
),
],
)
def test_a_subject_of_the_wrong_kind_or_form_is_refused(subject, fragment):
got = messages(edited(TABLE, subjects=[subject], dataset=None))
assert [r for r, _ in got] == ["layer.data.subject"]
assert fragment in got[0][1]
@pytest.mark.parametrize("suffix", ["\n", " ", "\x00"])
def test_an_identity_is_matched_whole_so_a_trailing_character_is_refused(suffix):
for identity, kind in ((WATER, "structure"), (PEPTIDE, "sequence")):
subject = {"kind": kind, "identity": identity + suffix}
got = messages(edited(TABLE, subjects=[subject], dataset=None))
assert [r for r, _ in got] == ["layer.data.subject"]
def test_a_subject_listed_twice_is_reported_at_its_second_place_only():
first = {"kind": "structure", "identity": WATER}
other = {"kind": "sequence", "identity": PEPTIDE}
got = messages(edited(TABLE, subjects=[first, other, first], dataset=None))
assert got == [("layer.data.subject", "subject 2 repeats the structure " + WATER)]
def test_the_same_identity_under_two_kinds_is_not_a_repeat():
subjects = [
{"kind": "structure", "identity": WATER},
{"kind": "sequence", "identity": WATER},
]
got = messages(edited(TABLE, subjects=subjects, dataset=None))
assert [m for _, m in got] == [
f"subject 1: {WATER} is not the form of a sequence identity"
]
def test_a_wrong_subject_that_is_repeated_is_reported_twice():
bad = {"kind": "structure", "identity": "ethane"}
got = messages(edited(TABLE, subjects=[bad, bad], dataset=None))
assert [m.split(":")[0].split(" repeats")[0] for _, m in got] == [
"subject 0",
"subject 1",
"subject 1",
]
@given(
st.text(alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ", min_size=14, max_size=14),
st.text(alphabet="ABCDEFGHIJKLMNOPQRSTUVWXYZ", min_size=10, max_size=10),
st.sampled_from("ABCDEFGHIJKLMNOPQRSTUVWXYZ"),
)
@PROPS
def test_any_inchikey_shaped_identity_is_a_structure_and_never_a_sequence(
first, second, last
):
identity = f"{first}-{second}-{last}"
assert data.SUBJECT_KINDS["structure"].fullmatch(identity)
assert not data.SUBJECT_KINDS["sequence"].fullmatch(identity)
assert not data.SUBJECT_KINDS["structure"].fullmatch(identity + "-")
# --- datasets ---------------------------------------------------------------------------------------------------------
@pytest.mark.parametrize(
"dataset", ["Table 1", "ds-", "DS-a", "ds-A", "ds-a b", "ds-a\n", "", "dataset-a"]
)
def test_a_dataset_that_is_no_id_is_refused(dataset):
got = messages(edited(TABLE, dataset=dataset))
assert got == [("layer.data.dataset", f"{dataset} is not the ID of a dataset")]
@pytest.mark.parametrize("dataset", ["ds-a", "ds-0", "ds-hale.bond_params-2", "ds-a-"])
def test_a_dataset_id_starts_with_ds_and_a_lower_case_letter_or_digit(dataset):
assert data.problems(edited(TABLE, dataset=dataset, quantities=None)) == []
def test_without_a_dataset_there_is_nothing_to_compare():
annotation = edited(TABLE, dataset=None)
assert data.problems(annotation, BOND_PARAMS) == []
def test_without_a_descriptor_only_the_id_is_checked():
assert data.problems(TABLE) == []
assert data.problems(TABLE, None) == []
def test_the_main_examples_bond_table_agrees_with_its_descriptor():
assert TABLE["body"]["dataset"] == BOND_PARAMS["id"]
assert data.problems(TABLE, BOND_PARAMS) == []
def test_another_dataset_than_the_descriptor_is_named_in_the_message():
got = messages(TABLE, DESCRIPTORS["ds-hale-ctct-scan"])
assert got[0] == (
"layer.data.dataset",
"the dataset is ds-hale-ctct-scan, not ds-hale-bond-params",
)
def test_a_field_the_dataset_lacks_is_reported_by_quantity():
quantities = [{"field": "k_r"}, {"field": "nope", "name": "Nothing"}]
got = messages(edited(TABLE, quantities=quantities), BOND_PARAMS)
assert got == [
(
"layer.data.dataset",
"quantity 1 names the field nope, which ds-hale-bond-params does not have",
)
]
def test_a_unit_that_differs_from_the_datasets_is_reported_with_both():
quantities = [
{"field": "k_r", "unit": "N / m"},
{"field": "r_eq", "unit": "angstrom"},
]
got = messages(edited(TABLE, quantities=quantities), BOND_PARAMS)
assert got == [
(
"layer.data.dataset",
"quantity 0 gives k_r the unit N / m, but ds-hale-bond-params gives it kcal / mol / angstrom ** 2",
)
]
def test_a_quantity_without_a_unit_takes_the_datasets():
quantities = [{"field": "k_r"}, {"field": "r_eq"}]
assert data.problems(edited(TABLE, quantities=quantities), BOND_PARAMS) == []
def test_a_unit_given_for_a_field_that_has_none_in_the_dataset_is_a_difference():
dataset = {"id": "ds-x", "resources": [{"schema": {"fields": [{"name": "point"}]}}]}
annotation = edited(
TABLE, dataset="ds-x", quantities=[{"field": "point", "unit": "m"}]
)
assert messages(annotation, dataset) == [
(
"layer.data.dataset",
"quantity 0 gives point the unit m, but ds-x gives it None",
)
]
def test_the_fields_of_every_resource_of_the_dataset_count():
dataset = {
"id": "ds-x",
"resources": [
{"schema": {"fields": [{"name": "a", "unit": "m"}]}},
{"name": "no schema"},
{"schema": {"fields": [{"name": "b", "unit": "s"}]}},
],
}
annotation = edited(
TABLE,
dataset="ds-x",
quantities=[{"field": "a", "unit": "m"}, {"field": "b", "unit": "s"}],
)
assert data.problems(annotation, dataset) == []
def test_a_descriptor_without_resources_has_no_fields():
annotation = edited(TABLE, dataset="ds-x", quantities=[{"field": "a"}])
got = messages(annotation, {"id": "ds-x"})
assert got == [
("layer.data.dataset", "quantity 0 names the field a, which ds-x does not have")
]
def test_a_descriptor_with_another_id_reports_the_mismatch_before_the_fields():
annotation = edited(TABLE, dataset="ds-x", quantities=[{"field": "a"}])
got = messages(annotation, {"id": "ds-y"})
assert [m.split(" ")[0] for _, m in got] == ["the", "quantity"]