diff --git a/frontend/src/components/metadata/metadata-header.vue b/frontend/src/components/metadata/metadata-header.vue
index 9632226f2..a5e4801e3 100644
--- a/frontend/src/components/metadata/metadata-header.vue
+++ b/frontend/src/components/metadata/metadata-header.vue
@@ -24,6 +24,8 @@
collection="series"
:highlight="'series' === md.collection"
/>
+
+
{
expect(metron.vm.isFieldDisabled("country")).toBe(true);
});
});
+
+describe("EditPanel — series start year", () => {
+ test("it seeds from the series and renders its own input", async () => {
+ const wrapper = await mountPanel({ md: { seriesStartYear: 1963 } });
+ expect(wrapper.vm.patch.start_year).toBe(1963);
+ const labels = wrapper.findAll("label").map((el) => el.text());
+ expect(labels).toContain("Start Year");
+ });
+
+ test("it rides the series object with the volume count", async () => {
+ const wrapper = await mountPanel({
+ md: { seriesList: [{ name: "S", ids: [1] }], seriesVolumeCount: 3 },
+ });
+ await setField(wrapper, "start_year", "1963");
+ expect(wrapper.vm.buildPatch().patch.series).toEqual({
+ name: "S",
+ volume_count: 3,
+ start_year: 1963,
+ });
+ });
+
+ test("clearing it drops it from the series object", async () => {
+ const wrapper = await mountPanel({
+ md: { seriesList: [{ name: "S", ids: [1] }], seriesStartYear: 1963 },
+ });
+ wrapper.vm.toggleClear("start_year");
+ await flushPromises();
+ expect(wrapper.vm.buildPatch().patch.series).toEqual({ name: "S" });
+ });
+
+ test("it is METRON_INFO-only", async () => {
+ const comicInfo = await mountPanel({ formats: ["COMIC_INFO"] });
+ const metron = await mountPanel({ formats: ["METRON_INFO"] });
+ expect(comicInfo.vm.isFieldDisabled("start_year")).toBe(true);
+ expect(metron.vm.isFieldDisabled("start_year")).toBe(false);
+ });
+});
diff --git a/frontend/tests/unit/metadata-header.test.js b/frontend/tests/unit/metadata-header.test.js
index 7221d95f6..a7cf7eb6d 100644
--- a/frontend/tests/unit/metadata-header.test.js
+++ b/frontend/tests/unit/metadata-header.test.js
@@ -18,7 +18,7 @@ import MetadataHeader from "@/components/metadata/metadata-header.vue";
import vuetify from "@/plugins/vuetify";
import { useMetadataStore } from "@/stores/metadata";
-function mountHeader({ multiSelect = false, editing = false } = {}) {
+function mountHeader({ multiSelect = false, editing = false, md = {} } = {}) {
const pinia = createTestingPinia({
initialState: { browser: { settings: { search: "" } } },
});
@@ -28,6 +28,7 @@ function mountHeader({ multiSelect = false, editing = false } = {}) {
collection: "comics",
ids: [1, 2, 3],
pageCount: 3,
+ ...md,
};
return mount(MetadataHeader, {
global: {
@@ -65,4 +66,32 @@ describe("MetadataHeader — controls toolbar gate", () => {
});
});
+const seriesYears = (md) => mountHeader({ md }).vm.seriesYears;
+
+describe("MetadataHeader — series years", () => {
+ test("shows a closed range", () => {
+ expect(seriesYears({ seriesStartYear: 1963, seriesEndYear: 1996 })).toBe(
+ "(1963–1996)",
+ );
+ });
+
+ test("leaves an ongoing range open", () => {
+ expect(seriesYears({ seriesStartYear: 1963 })).toBe("(1963– )");
+ });
+
+ test("collapses a single-year run", () => {
+ expect(seriesYears({ seriesStartYear: 1963, seriesEndYear: 1963 })).toBe(
+ "(1963)",
+ );
+ });
+
+ test("shows an end year with no known start", () => {
+ expect(seriesYears({ seriesEndYear: 1996 })).toBe("(–1996)");
+ });
+
+ test("shows nothing when neither year is known", () => {
+ expect(seriesYears({})).toBe("");
+ });
+});
+
export default {};
diff --git a/tests/importer/test_basic.py b/tests/importer/test_basic.py
index acbafd697..a90270262 100644
--- a/tests/importer/test_basic.py
+++ b/tests/importer/test_basic.py
@@ -143,7 +143,9 @@
"TestImprint",
"Captain Science",
): {
- (None, None),
+ # identifier, volume_count, start_year, end_year, status,
+ # summary
+ (None, None, None, None, None, None),
}
},
SeriesGroup: {("science comics",): set()},
@@ -418,6 +420,10 @@
"Captain Science",
None,
None,
+ None,
+ None,
+ None,
+ None,
)
},
Volume: {
diff --git a/tests/importer/test_series_attrs.py b/tests/importer/test_series_attrs.py
new file mode 100644
index 000000000..260356f53
--- /dev/null
+++ b/tests/importer/test_series_attrs.py
@@ -0,0 +1,190 @@
+"""
+Comics of one series combine their series attributes in an import batch.
+
+Every comic proposes its own values for its series row. Within a batch
+they merge per attribute: the earliest start year, the latest end year,
+the largest count and the first comic's status and text. Against the
+stored row a
+later batch's values win and missing ones leave it alone.
+"""
+
+import shutil
+import zipfile
+from pathlib import Path
+from threading import Event, Lock
+from typing import Final, override
+
+from django.core.cache import cache
+from django.test import TestCase
+from loguru import logger
+
+from codex.librarian.mp_queue import LIBRARIAN_QUEUE
+from codex.librarian.scribe.importer.const import (
+ CREATE_FKS,
+ EXTRACTED,
+ FIS,
+ UPDATE_FKS,
+)
+from codex.librarian.scribe.importer.importer import ComicImporter
+from codex.librarian.scribe.importer.tasks import ImportTask
+from codex.models import Series, Volume
+from codex.models.library import Library
+from codex.startup import codex_init
+from tests.tmp_dirs import tmp_dir
+
+TMP_DIR: Final = tmp_dir(Path(__file__).stem)
+_VOLUME_NUMBER: Final = 1963
+_EARLY: Final = 1963
+_MIDDLE: Final = 1970
+_LATE: Final = 1996
+_FEW: Final = 3
+_MANY: Final = 7
+_SUMMARY_B: Final = "The second comic's series summary."
+_SUMMARY_C: Final = "The third comic's series summary."
+_ONGOING: Final = "Ongoing"
+_COMPLETED: Final = "Completed"
+
+
+_ARCHIVE_YAML: Final = f"""comicbox:
+ publisher:
+ name: P
+ series:
+ name: S
+ start_year: {_EARLY}
+ end_year: {_LATE}
+ status: completed
+ summary: {_SUMMARY_B}
+"""
+
+
+def _md(series: dict | None = None, volume: dict | None = None) -> dict:
+ """Comicbox metadata for one comic of series S."""
+ return {
+ "publisher": {"name": "P"},
+ "series": {"name": "S", **(series or {})},
+ "volume": {"number": _VOLUME_NUMBER, **(volume or {})},
+ }
+
+
+class TestSeriesAttrs(TestCase):
+ """Series attributes merge in a batch and update the stored row."""
+
+ @override
+ @classmethod
+ def setUpTestData(cls):
+ super().setUpTestData()
+ cache.clear()
+ codex_init()
+ TMP_DIR.mkdir(exist_ok=True, parents=True)
+
+ @override
+ @classmethod
+ def tearDownClass(cls):
+ try:
+ shutil.rmtree(TMP_DIR, ignore_errors=True)
+ finally:
+ super().tearDownClass()
+
+ @override
+ def setUp(self):
+ cache.clear()
+ self.library = Library.objects.create(path=TMP_DIR) # pyright: ignore[reportUninitializedInstanceVariable]
+
+ def _importer(self, paths) -> ComicImporter:
+ task = ImportTask(library_id=self.library.pk, files_modified=frozenset(paths))
+ return ComicImporter(task, logger, LIBRARIAN_QUEUE, Lock(), Event())
+
+ @staticmethod
+ def _create_collections(importer: ComicImporter) -> None:
+ importer.metadata[CREATE_FKS] = {}
+ importer.metadata[UPDATE_FKS] = {}
+ importer.query_all_missing_models()
+ importer.create_all_fks()
+ importer.update_all_fks()
+
+ def _import(self, *mds: dict) -> None:
+ """Aggregate, query and create the collections for one batch."""
+ paths = {str(TMP_DIR / f"c{index}.cbz"): md for index, md in enumerate(mds)}
+ importer = self._importer(paths)
+ importer.metadata[FIS] = {}
+ importer.metadata[EXTRACTED] = paths
+ importer.aggregate_metadata()
+ self._create_collections(importer)
+
+ def test_archive_series_attrs(self) -> None:
+ """The attributes come through from an archive's comicbox metadata."""
+ path = TMP_DIR / "archive.cbz"
+ with zipfile.ZipFile(path, "w") as zf:
+ zf.writestr("comicbox.yaml", _ARCHIVE_YAML)
+ zf.writestr("page1.jpg", b"\xff\xd8\xff\xe0not-a-real-jpeg")
+ importer = self._importer({str(path)})
+ importer.read()
+ self._create_collections(importer)
+
+ series = Series.objects.get(name="S")
+ assert series.start_year == _EARLY
+ assert series.end_year == _LATE
+ assert series.status == _COMPLETED
+ assert series.summary == _SUMMARY_B
+
+ def test_batch_merges_series_attrs(self) -> None:
+ """Earliest start, latest end, largest count, first status and text."""
+ self._import(
+ _md({"start_year": _MIDDLE, "volume_count": _MANY}),
+ _md(
+ {
+ "start_year": _EARLY,
+ "end_year": _LATE,
+ "status": _ONGOING,
+ "summary": _SUMMARY_B,
+ },
+ {"issue_count": _MANY},
+ ),
+ _md(
+ {
+ "end_year": _MIDDLE,
+ "volume_count": _FEW,
+ "status": _COMPLETED,
+ "summary": _SUMMARY_C,
+ },
+ {"issue_count": _FEW},
+ ),
+ )
+
+ series = Series.objects.get(name="S")
+ assert series.start_year == _EARLY
+ assert series.end_year == _LATE
+ assert series.volume_count == _MANY
+ assert series.status == _ONGOING
+ assert series.summary == _SUMMARY_B
+ assert Volume.objects.get(series=series).issue_count == _MANY
+
+ def test_missing_attrs_create_empty(self) -> None:
+ """A series with no attributes gets nulls and empty text."""
+ self._import(_md())
+
+ series = Series.objects.get(name="S")
+ assert series.start_year is None
+ assert series.end_year is None
+ assert series.status == ""
+ assert series.summary == ""
+
+ def test_later_batch_updates_stored_series(self) -> None:
+ """A later batch's values replace stored ones; missing ones don't."""
+ self._import(
+ _md(
+ {
+ "start_year": _EARLY,
+ "end_year": _MIDDLE,
+ "status": _ONGOING,
+ "summary": _SUMMARY_B,
+ }
+ )
+ )
+ self._import(_md({"end_year": _LATE, "status": _COMPLETED}))
+
+ series = Series.objects.get(name="S")
+ assert series.start_year == _EARLY
+ assert series.end_year == _LATE
+ assert series.status == _COMPLETED
+ assert series.summary == _SUMMARY_B
diff --git a/tests/importer/test_update_all.py b/tests/importer/test_update_all.py
index 22c3f1731..21fb76317 100644
--- a/tests/importer/test_update_all.py
+++ b/tests/importer/test_update_all.py
@@ -225,6 +225,10 @@
(
("comicvine", "series", "333"),
None,
+ None,
+ None,
+ None,
+ None,
),
}
},
@@ -498,6 +502,11 @@
"Captain Science",
("comicvine", "series", "333"),
None,
+ None,
+ None,
+ # The stored status and summary stand.
+ "",
+ "",
)
},
Character: {("Captain Science", ("metron", "character", "123"))},
diff --git a/tests/test_metadata_series_fields.py b/tests/test_metadata_series_fields.py
new file mode 100644
index 000000000..784f11a2d
--- /dev/null
+++ b/tests/test_metadata_series_fields.py
@@ -0,0 +1,109 @@
+"""The metadata pane carries the series' year range, status and summary."""
+
+import shutil
+from typing import Final, override
+
+from django.contrib.auth.models import User
+from django.test import Client, TestCase
+
+from codex.models import Comic, Imprint, Library, Publisher, Series, Volume
+from codex.startup import init_admin_flags
+from tests.tmp_dirs import tmp_dir
+
+TMP_DIR = tmp_dir("codex.tests.metadata_series_fields")
+_TEST_PASSWORD: Final = "test-pw-hush-S106" # noqa: S105
+_HTTP_OK: Final = 200
+_START_YEAR: Final = 1963
+_END_YEAR: Final = 1996
+_STATUS: Final = "Completed"
+_SUMMARY: Final = "A friendly neighborhood series."
+_COMIC_SUMMARY: Final = "One issue of it."
+
+
+def _v4(response):
+ """Unwrap the v4 ``{data, meta, errors}`` envelope and return ``data``."""
+ body = response.json()
+ if isinstance(body, dict) and "data" in body and "meta" in body:
+ return body["data"]
+ return body
+
+
+class MetadataSeriesFieldsTestCase(TestCase):
+ """The series attributes reach the metadata payload."""
+
+ @override
+ def setUp(self) -> None:
+ """Seed one comic in a series with every attribute set."""
+ init_admin_flags()
+ TMP_DIR.mkdir(exist_ok=True, parents=True)
+ library = Library.objects.create(path=str(TMP_DIR))
+ publisher = Publisher.objects.create(name="Pub")
+ imprint = Imprint.objects.create(name="Imp", publisher=publisher)
+ self.series = Series.objects.create( # pyright: ignore[reportUninitializedInstanceVariable]
+ name="Ser",
+ imprint=imprint,
+ publisher=publisher,
+ start_year=_START_YEAR,
+ end_year=_END_YEAR,
+ status=_STATUS,
+ summary=_SUMMARY,
+ )
+ volume = Volume.objects.create(
+ name="1963", series=self.series, imprint=imprint, publisher=publisher
+ )
+ path = TMP_DIR / "c1.cbz"
+ path.touch()
+ self.comic = Comic.objects.create( # pyright: ignore[reportUninitializedInstanceVariable]
+ library=library,
+ path=path,
+ issue_number=1,
+ name="C1",
+ publisher=publisher,
+ imprint=imprint,
+ series=self.series,
+ volume=volume,
+ size=42,
+ summary=_COMIC_SUMMARY,
+ )
+ user = User.objects.create_user(
+ username="series_reader", password=_TEST_PASSWORD, is_staff=True
+ )
+ self.client = Client()
+ self.client.force_login(user)
+
+ @override
+ def tearDown(self) -> None:
+ """Remove the temp comic tree."""
+ shutil.rmtree(TMP_DIR, ignore_errors=True)
+
+ def _get_metadata(self, collection: str, pk: int) -> dict:
+ response = self.client.get(f"/api/v4/browse/{collection}/{pk}/metadata")
+ assert response.status_code == _HTTP_OK, response.content
+ return _v4(response)
+
+ def test_comic_metadata_has_series_attrs(self) -> None:
+ data = self._get_metadata("comics", self.comic.pk)
+ assert data["seriesStartYear"] == _START_YEAR
+ assert data["seriesEndYear"] == _END_YEAR
+ assert data["seriesStatus"] == _STATUS
+ assert data["seriesSummary"] == _SUMMARY
+
+ def test_series_metadata_has_series_attrs(self) -> None:
+ """
+ A collection's pane reads the attributes through its comics.
+
+ The comics' own summary keeps its key there too, though Series now
+ has a summary column of its own.
+ """
+ data = self._get_metadata("series", self.series.pk)
+ assert data["seriesStartYear"] == _START_YEAR
+ assert data["seriesEndYear"] == _END_YEAR
+ assert data["seriesStatus"] == _STATUS
+ assert data["seriesSummary"] == _SUMMARY
+ assert data["summary"] == _COMIC_SUMMARY
+
+ def test_unknown_years_are_omitted(self) -> None:
+ Series.objects.filter(pk=self.series.pk).update(start_year=None, end_year=None)
+ data = self._get_metadata("comics", self.comic.pk)
+ assert "seriesStartYear" not in data
+ assert "seriesEndYear" not in data
diff --git a/tests/test_tag_write_date.py b/tests/test_tag_write_date.py
index 2058757a1..adb323d24 100644
--- a/tests/test_tag_write_date.py
+++ b/tests/test_tag_write_date.py
@@ -39,6 +39,7 @@
_ISSUE_NUMBER: Final = "1"
_ALTERNATIVE_ISSUE: Final = MappingProxyType({"number": 5, "suffix": "AU"})
_COLLECTION_TITLE: Final = "The Dark Phoenix Saga"
+_START_YEAR: Final = 1963
def _double(stub: object) -> Any:
@@ -105,6 +106,7 @@ def test_format_exclusive_fields(self) -> None:
"collection_title",
"alternative_issue_number",
"alternative_issue_suffix",
+ "start_year",
}
assert metron_only <= metron
assert not (metron_only & comic_info)
@@ -206,3 +208,11 @@ def test_write_collection_title(self) -> None:
sub_md = self._write_metron({"collection_title": _COLLECTION_TITLE})
assert sub_md.get("collection_title") == _COLLECTION_TITLE
+
+ def test_write_series_start_year(self) -> None:
+ """The editor's Start Year rides the series object into MetronInfo."""
+ sub_md = self._write_metron(
+ {"series": {"name": "S", "start_year": _START_YEAR}}
+ )
+
+ assert sub_md.get("series", {}).get("start_year") == _START_YEAR