Fix tests

Author: Buried-In-Code

perdoo/comic/archives/sevenzip.py

@@ -7,7 +7,7 @@
 from tempfile import TemporaryDirectory
 from typing import ClassVar
 
-from perdoo.comic.archive._base import Archive
+from perdoo.comic.archives._base import Archive
 from perdoo.comic.errors import ComicArchiveError
 from perdoo.utils import list_files
 

perdoo/comic/archives/zip.py

@@ -82,7 +82,7 @@ def rename_file(self, filename: str, new_name: str, override: bool = False) -> N
                 if new_name in archive.namelist():
                     if not override:
                         raise ComicArchiveError(
-                            f"Unable to rename {filename} as {new_name} already extsts in {self.filepath.name}."
+                            f"Unable to rename {filename} as {new_name} already exists in {self.filepath.name}."
                         )
                     removed.append(archive.remove(new_name))
                 removed.append(archive.remove(archive.copy(filename, new_name)))

perdoo/comic/comic.py

@@ -37,15 +37,13 @@ def convert_to(self, extension: Literal["cbz", "cbt", "cb7"]) -> None:
             self._archive = cls.convert_from(old_archive=self.archive)
 
     def read_metadata(self, session: ArchiveSession) -> tuple[MetronInfo | None, ComicInfo | None]:
-        metroninfo = None
+        metron_info = None
         if session.contains(filename=MetronInfo.FILENAME):
-            metroninfo = MetronInfo.from_bytes(content=session.read(filename=MetronInfo.FILENAME))
-
-        comicinfo = None
+            metron_info = MetronInfo.from_bytes(content=session.read(filename=MetronInfo.FILENAME))
+        comic_info = None
         if session.contains(filename=ComicInfo.FILENAME):
-            comicinfo = ComicInfo.from_bytes(content=session.read(filename=ComicInfo.FILENAME))
-
-        return metroninfo, comicinfo
+            comic_info = ComicInfo.from_bytes(content=session.read(filename=ComicInfo.FILENAME))
+        return metron_info, comic_info
 
     def list_images(self) -> list[Path]:
         return humansorted(
@@ -73,7 +71,7 @@ def validate_naming(self, naming: str) -> bool:
         return all(img.name.startswith(template) for img in self.list_images())
 
     def move_to(self, naming: str, output_folder: Path) -> None:
-        output = output_folder / f"{naming}{self.archive.EXTENSION}"
+        output = output_folder / (naming + self.archive.EXTENSION)
         if output.exists():
             LOGGER.warning("'%s' already exists, skipping", output)
             return

tests/comic/archives/__init__.py

@@ -0,0 +1,62 @@
+from pathlib import Path
+
+import pytest
+
+from perdoo.comic.archives import CB7Archive, CBTArchive, CBZArchive
+
+
+@pytest.fixture
+def archive_files() -> dict[str, bytes]:
+    return {"info.txt": b"Fake data", "001.jpg": b"Fake image"}
+
+
+@pytest.fixture
+def src(tmp_path: Path) -> Path:
+    src = tmp_path / "src"
+    src.mkdir(parents=True, exist_ok=True)
+    return src
+
+
+@pytest.fixture
+def cbz_path(src: Path, archive_files: dict[str, bytes]) -> Path:
+    created: list[Path] = []
+    for filename, data in archive_files.items():
+        tmp = src / filename
+        tmp.write_bytes(data)
+        created.append(tmp)
+    return CBZArchive.archive_files(src=src, output_name="sample", files=created)
+
+
+@pytest.fixture
+def cbz_archive(cbz_path: Path) -> CBZArchive:
+    return CBZArchive(filepath=cbz_path)
+
+
+@pytest.fixture
+def cbt_path(src: Path, archive_files: dict[str, bytes]) -> Path:
+    created: list[Path] = []
+    for filename, data in archive_files.items():
+        tmp = src / filename
+        tmp.write_bytes(data)
+        created.append(tmp)
+    return CBTArchive.archive_files(src=src, output_name="sample", files=created)
+
+
+@pytest.fixture
+def cbt_archive(cbt_path: Path) -> CBTArchive:
+    return CBTArchive(filepath=cbt_path)
+
+
+@pytest.fixture
+def cb7_path(src: Path, archive_files: dict[str, bytes]) -> Path:
+    created: list[Path] = []
+    for filename, data in archive_files.items():
+        tmp = src / filename
+        tmp.write_bytes(data)
+        created.append(tmp)
+    return CB7Archive.archive_files(src=src, output_name="sample", files=created)
+
+
+@pytest.fixture
+def cb7_archive(cb7_path: Path) -> CB7Archive:
+    return CB7Archive(filepath=cb7_path)

tests/comic/archives/conftest.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+from typing import ClassVar
+
+import pytest
+
+from perdoo.comic.archives import Archive, CBTArchive, CBZArchive
+from perdoo.comic.errors import ComicArchiveError
+
+
+def test_load_selects_cbz(cbz_path: Path) -> None:
+    loaded = Archive.load(filepath=cbz_path)
+
+    assert isinstance(loaded, CBZArchive)
+    assert loaded.filepath == cbz_path
+
+
+def test_load_selects_cbt(cbt_path: Path) -> None:
+    loaded = Archive.load(filepath=cbt_path)
+
+    assert isinstance(loaded, CBTArchive)
+    assert loaded.filepath == cbt_path
+
+
+def test_load_unsupported(tmp_path: Path) -> None:
+    tmp = tmp_path / "sample.xyz"
+    tmp.write_bytes(b"Unsupported")
+
+    with pytest.raises(ComicArchiveError, match=r"Unsupported archive format"):
+        Archive.load(filepath=tmp)
+
+
+def test_default_operations(tmp_path: Path, cbz_archive: CBZArchive) -> None:
+    class DummyArchive(Archive):
+        EXTENSION: ClassVar[str] = ".xyz"
+        IS_READABLE: ClassVar[bool] = False
+        IS_WRITEABLE: ClassVar[bool] = False
+        IS_EDITABLE: ClassVar[bool] = False
+
+        @classmethod
+        def is_archive(cls, path: Path) -> bool:  # noqa: ARG003
+            return False
+
+        def list_filenames(self) -> list[str]:
+            return []
+
+        def extract_files(self, destination: Path) -> None:  # noqa: ARG002
+            return None
+
+    tmp = DummyArchive(filepath=tmp_path / "sample.xyz")
+    with pytest.raises(ComicArchiveError, match=r"Unable to read"):
+        tmp.read_file(filename="info.txt")
+    with pytest.raises(ComicArchiveError, match=r"Unable to write"):
+        tmp.write_file(filename="info.txt", data=b"Hello World")
+    with pytest.raises(ComicArchiveError, match=r"Unable to delete"):
+        tmp.delete_file(filename="info.txt")
+    with pytest.raises(ComicArchiveError, match=r"Unable to rename"):
+        tmp.rename_file(filename="info.txt", new_name="new.txt")
+    with pytest.raises(ComicArchiveError, match=r"Unable to archive"):
+        DummyArchive.archive_files(src=tmp_path, output_name="sample", files=[])
+    with pytest.raises(ComicArchiveError, match=r"Unable to convert"):
+        DummyArchive.convert_from(old_archive=cbz_archive)

tests/comic/archives/test_base.py

@@ -0,0 +1,44 @@
+import pytest
+
+from perdoo.comic.archives import ArchiveSession, CBTArchive, CBZArchive
+from perdoo.comic.errors import ComicArchiveError
+
+
+def test_editable_session(cbz_archive: CBZArchive) -> None:
+    with ArchiveSession(archive=cbz_archive) as session:
+        assert session.contains(filename="info.txt")
+        assert session.read(filename="info.txt") == b"Fake data"
+
+        session.write(filename="info.txt", data="Updated data")
+        session.write(filename="src.txt", data=b"Hello World")
+        session.rename(filename="src.txt", new_name="new.txt")
+        session.delete(filename="001.jpg")
+
+        assert cbz_archive.read_file(filename="info.txt") == b"Updated data"
+        assert "001.jpg" not in cbz_archive.list_filenames()
+        assert "src.txt" not in cbz_archive.list_filenames()
+        assert "new.txt" in cbz_archive.list_filenames()
+
+
+def test_non_editable_session(cbt_archive: CBTArchive) -> None:
+    with ArchiveSession(archive=cbt_archive) as session:
+        assert session.contains(filename="info.txt")
+        assert session.read(filename="info.txt") == b"Fake data"
+
+        session.write(filename="info.txt", data="Updated data")
+        session.write(filename="src.txt", data=b"Hello World")
+        session.rename(filename="src.txt", new_name="new.txt")
+        session.delete(filename="001.jpg")
+
+        # TODO: assert cbt_archive.read_file(filename="info.txt") != b"Updated data"
+        assert "001.jpg" in cbt_archive.list_filenames()
+        assert "src.txt" not in cbt_archive.list_filenames()
+        assert "new.txt" not in cbt_archive.list_filenames()
+
+
+def test_session_rename_raises_exception(cbz_archive: CBZArchive) -> None:
+    with ArchiveSession(cbz_archive) as session:
+        with pytest.raises(ComicArchiveError, match=r"Unable to rename"):
+            session.rename(filename="new.txt", new_name="info.txt")
+        with pytest.raises(ComicArchiveError, match=r"Unable to rename"):
+            session.rename(filename="info.txt", new_name="001.jpg", override=False)

tests/comic/archives/test_session.py

@@ -0,0 +1,64 @@
+from pathlib import Path
+
+import pytest
+
+from perdoo.comic.archives import CB7Archive, CBZArchive
+from perdoo.comic.archives.sevenzip import PY7ZR_AVAILABLE
+from perdoo.comic.errors import ComicArchiveError
+from perdoo.utils import list_files
+
+pytestmark = pytest.mark.skipif(not PY7ZR_AVAILABLE, reason="py7zr not installed")
+
+
+def test_is_archive(cb7_path: Path) -> None:
+    assert CB7Archive.is_archive(path=cb7_path) is True
+
+
+def test_list_filenames(cb7_archive: CB7Archive) -> None:
+    assert set(cb7_archive.list_filenames()) == {"info.txt", "001.jpg"}
+
+
+def test_read_file(cb7_archive: CB7Archive) -> None:
+    assert cb7_archive.read_file(filename="info.txt") == b"Fake data"
+    assert cb7_archive.read_file(filename="001.jpg") == b"Fake image"
+
+
+def test_unsupported_functions(cb7_archive: CB7Archive) -> None:
+    with pytest.raises(ComicArchiveError, match=r"Unable to write"):
+        cb7_archive.write_file(filename="info.txt", data=b"Updated data")
+    with pytest.raises(ComicArchiveError, match=r"Unable to delete"):
+        cb7_archive.delete_file(filename="info.txt")
+    with pytest.raises(ComicArchiveError, match=r"Unable to rename"):
+        cb7_archive.rename_file(filename="info.txt", new_name="new.txt")
+
+
+def test_extract_files(cb7_archive: CB7Archive, tmp_path: Path) -> None:
+    dest = tmp_path / "out"
+    dest.mkdir(parents=True, exist_ok=True)
+    cb7_archive.extract_files(destination=dest)
+
+    assert (dest / "info.txt").read_text(encoding="UTF-8") == "Fake data"
+    assert (dest / "001.jpg").read_bytes() == b"Fake image"
+
+
+def test_archive_files(cb7_archive: CB7Archive, tmp_path: Path) -> None:
+    dest = tmp_path / "out"
+    dest.mkdir(parents=True, exist_ok=True)
+    cb7_archive.extract_files(destination=dest)
+    archive = CB7Archive.archive_files(
+        src=dest, output_name=cb7_archive.filepath.stem, files=list_files(path=dest)
+    )
+
+    assert cb7_archive.filepath == archive
+
+
+def test_convert_from(cbz_archive: CBZArchive) -> None:
+    old_filenames = cbz_archive.list_filenames()
+    archive = CB7Archive.convert_from(old_archive=cbz_archive)
+
+    assert isinstance(archive, CB7Archive)
+    assert archive.filepath.suffix == ".cb7"
+    assert archive.filepath.exists()
+    assert not cbz_archive.filepath.exists()
+    assert archive.list_filenames() == old_filenames
+    assert archive.read_file(filename="info.txt") == b"Fake data"

tests/comic/archives/test_sevenzip.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+
+import pytest
+
+from perdoo.comic.archives import CBTArchive, CBZArchive
+from perdoo.comic.errors import ComicArchiveError
+from perdoo.utils import list_files
+
+
+def test_is_archive(cbt_path: Path) -> None:
+    assert CBTArchive.is_archive(path=cbt_path) is True
+
+
+def test_list_filenames(cbt_archive: CBTArchive) -> None:
+    assert set(cbt_archive.list_filenames()) == {"info.txt", "001.jpg"}
+
+
+def test_unsupported_functions(cbt_archive: CBTArchive) -> None:
+    with pytest.raises(ComicArchiveError, match=r"Unable to read"):
+        cbt_archive.read_file(filename="info.txt")
+    with pytest.raises(ComicArchiveError, match=r"Unable to write"):
+        cbt_archive.write_file(filename="info.txt", data=b"Updated data")
+    with pytest.raises(ComicArchiveError, match=r"Unable to delete"):
+        cbt_archive.delete_file(filename="info.txt")
+    with pytest.raises(ComicArchiveError, match=r"Unable to rename"):
+        cbt_archive.rename_file(filename="info.txt", new_name="new.txt")
+
+
+def test_extract_files(cbt_archive: CBTArchive, tmp_path: Path) -> None:
+    dest = tmp_path / "out"
+    dest.mkdir(parents=True, exist_ok=True)
+    cbt_archive.extract_files(destination=dest)
+
+    assert (dest / "info.txt").read_text(encoding="UTF-8") == "Fake data"
+    assert (dest / "001.jpg").read_bytes() == b"Fake image"
+
+
+def test_archive_files(cbt_archive: CBTArchive, tmp_path: Path) -> None:
+    dest = tmp_path / "out"
+    dest.mkdir(parents=True, exist_ok=True)
+    cbt_archive.extract_files(destination=dest)
+    archive = CBTArchive.archive_files(
+        src=dest, output_name=cbt_archive.filepath.stem, files=list_files(path=dest)
+    )
+
+    assert cbt_archive.filepath == archive
+
+
+def test_convert_from(cbz_archive: CBZArchive) -> None:
+    old_filenames = cbz_archive.list_filenames()
+    archive = CBTArchive.convert_from(old_archive=cbz_archive)
+
+    assert isinstance(archive, CBTArchive)
+    assert archive.filepath.suffix == ".cbt"
+    assert archive.filepath.exists()
+    assert not cbz_archive.filepath.exists()
+    assert archive.list_filenames() == old_filenames
+    # TODO: assert archive.read_file(filename="info.txt") == b"Fake data"