ci: Add testing framework setup

2025-07-10 12:08:28 +08:00
parent 8af1c47e15
commit 0c4aa34f8f
19 changed files with 672 additions and 2 deletions
@@ -0,0 +1,49 @@
+import pytest
+from pathlib import Path
+from cbz.comic import ComicInfo
+from cbz.page import PageInfo
+from cbz.constants import PageType
+
+@pytest.fixture
+def fixtures_dir():
+    """Fixture that provides the path to the test fixtures directory."""
+    return Path(__file__).parent / "fixtures"
+
+@pytest.fixture
+def images_dir(fixtures_dir):
+    """Fixture that provides the path to the test images directory."""
+    return fixtures_dir / "images"
+
+@pytest.fixture
+def sample_image_path(images_dir):
+    """Fixture that provides a sample image path."""
+    return images_dir / "page-000.jpg"
+
+@pytest.fixture
+def sample_cbz_file(tmp_path, images_dir):
+    """Fixture that creates a sample CBZ file for testing."""
+    # Load sample pages
+    image_paths = sorted(list(images_dir.iterdir()))[:3]  # Use first 3 images
+    pages = []
+    
+    for i, path in enumerate(image_paths):
+        page_type = PageType.FRONT_COVER if i == 0 else PageType.STORY
+        page = PageInfo.load(path=path, type=page_type)
+        pages.append(page)
+    
+    # Create comic from pages
+    comic = ComicInfo.from_pages(
+        pages=pages,
+        title="Test Comic",
+        series="Test Series",
+        number=1,
+        volume=1,
+        year=2024
+    )
+    
+    # Save to temporary file
+    cbz_path = tmp_path / "test_comic.cbz"
+    cbz_content = comic.pack()
+    cbz_path.write_bytes(cbz_content)
+    
+    return cbz_path
@@ -0,0 +1,155 @@
+from cbz.comic import ComicInfo
+from cbz.page import PageInfo
+from cbz.constants import PageType, YesNo, Manga, AgeRating, Format
+
+class TestComicInfo:
+    """Test cases for ComicInfo class."""
+
+    def test_from_pages_creation(self, images_dir):
+        """Test creating ComicInfo from pages."""
+        # Load sample pages
+        image_paths = sorted(list(images_dir.iterdir()))[:3]  # Use first 3 images
+        pages = []
+        
+        for i, path in enumerate(image_paths):
+            page_type = PageType.FRONT_COVER if i == 0 else PageType.STORY
+            page = PageInfo.load(path=path, type=page_type)
+            pages.append(page)
+        
+        # Create comic from pages
+        comic = ComicInfo.from_pages(
+            pages=pages,
+            title="Test Comic",
+            series="Test Series",
+            number=1,
+            volume=1,
+            year=2024
+        )
+        
+        assert comic.title == "Test Comic"
+        assert comic.series == "Test Series"
+        assert comic.number == 1
+        assert comic.volume == 1
+        assert comic.year == 2024
+        assert len(comic.pages) == 3
+        assert comic.pages[0].type == PageType.FRONT_COVER
+        assert comic.pages[1].type == PageType.STORY
+
+    def test_from_cbz_file(self, sample_cbz_file):
+        """Test loading ComicInfo from CBZ file."""
+        comic = ComicInfo.from_cbz(sample_cbz_file)
+        
+        assert comic is not None
+        assert hasattr(comic, 'pages')
+        assert len(comic.pages) > 0
+        assert all(isinstance(page, PageInfo) for page in comic.pages)
+
+    def test_pack_cbz(self, images_dir):
+        """Test packing comic into CBZ format."""
+        # Create a simple comic
+        image_paths = sorted(list(images_dir.iterdir()))[:2]
+        pages = [PageInfo.load(path=path) for path in image_paths]
+        
+        comic = ComicInfo.from_pages(
+            pages=pages,
+            title="Pack Test",
+            series="Test Series"
+        )
+        
+        # Pack to CBZ
+        cbz_content = comic.pack()
+        
+        assert isinstance(cbz_content, bytes)
+        assert len(cbz_content) > 0
+
+    def test_pack_with_rename(self, images_dir):
+        """Test packing comic with page renaming."""
+        image_paths = sorted(list(images_dir.iterdir()))[:2]
+        pages = [PageInfo.load(path=path) for path in image_paths]
+        
+        comic = ComicInfo.from_pages(
+            pages=pages,
+            title="Rename Test"
+        )
+        
+        # Pack with rename option
+        cbz_content = comic.pack(rename=True)
+        
+        assert isinstance(cbz_content, bytes)
+        assert len(cbz_content) > 0
+
+    def test_comic_metadata_properties(self, images_dir):
+        """Test comic metadata properties."""
+        image_paths = sorted(list(images_dir.iterdir()))[:1]
+        pages = [PageInfo.load(path=path) for path in image_paths]
+        
+        comic = ComicInfo.from_pages(
+            pages=pages,
+            title="Metadata Test",
+            series="Test Series",
+            number=5,
+            count=10,
+            volume=2,
+            summary="Test summary",
+            year=2023,
+            month=6,
+            day=15,
+            writer="Test Writer",
+            penciller="Test Penciller",
+            inker="Test Inker",
+            colorist="Test Colorist",
+            letterer="Test Letterer",
+            cover_artist="Test Cover Artist",
+            editor="Test Editor",
+            publisher="Test Publisher",
+            imprint="Test Imprint",
+            genre="Test Genre",
+            language_iso="en",
+            format=Format.SERIES,
+            black_white=YesNo.NO,
+            manga=Manga.RIGHT_LEFT,
+            age_rating=AgeRating.TEEN,
+            community_rating=4
+        )
+        
+        assert comic.title == "Metadata Test"
+        assert comic.series == "Test Series"
+        assert comic.number == 5
+        assert comic.count == 10
+        assert comic.volume == 2
+        assert comic.summary == "Test summary"
+        assert comic.year == 2023
+        assert comic.month == 6
+        assert comic.day == 15
+        assert comic.writer == "Test Writer"
+        assert comic.penciller == "Test Penciller"
+        assert comic.inker == "Test Inker"
+        assert comic.colorist == "Test Colorist"
+        assert comic.letterer == "Test Letterer"
+        assert comic.cover_artist == "Test Cover Artist"
+        assert comic.editor == "Test Editor"
+        assert comic.publisher == "Test Publisher"
+        assert comic.imprint == "Test Imprint"
+        assert comic.genre == "Test Genre"
+        assert comic.language_iso == "en"
+        assert comic.format == Format.SERIES
+        assert comic.black_white == YesNo.NO
+        assert comic.manga == Manga.RIGHT_LEFT
+        assert comic.age_rating == AgeRating.TEEN
+        assert comic.community_rating == 4
+
+    def test_page_count_property(self, images_dir):
+        """Test that page count returns correct count."""
+        image_paths = sorted(list(images_dir.iterdir()))[:4]
+        pages = [PageInfo.load(path=path) for path in image_paths]
+        
+        comic = ComicInfo.from_pages(pages=pages, title="Count Test")
+        
+        assert len(comic.pages) == 4
+
+    def test_empty_pages_list(self):
+        """Test creating comic with empty pages list."""
+        comic = ComicInfo.from_pages(pages=[], title="Empty Test")
+        
+        assert comic.title == "Empty Test"
+        assert len(comic.pages) == 0
@@ -0,0 +1,269 @@
+from cbz.models import BaseModel, ComicModel, PageModel
+from cbz.constants import Format, YesNo, Manga, AgeRating, PageType
+
+class TestBaseModel:
+    """Test cases for BaseModel class."""
+
+    def test_base_model_creation(self):
+        """Test creating BaseModel with fields."""
+        test_fields = {
+            'test_str': ('Test String', str),
+            'test_int': ('Test Integer', int),
+            'test_bool': ('Test Boolean', bool)
+        }
+        
+        model = BaseModel(fields=test_fields)
+        
+        # Check default values are set
+        assert hasattr(model, 'test_str')
+        assert hasattr(model, 'test_int')
+        assert hasattr(model, 'test_bool')
+
+    def test_base_model_with_kwargs(self):
+        """Test creating BaseModel with keyword arguments."""
+        test_fields = {
+            'title': ('Title', str),
+            'number': ('Number', int),
+            'published': ('Published', bool)
+        }
+        
+        model = BaseModel(
+            fields=test_fields,
+            title="Test Title",
+            number=42,
+            published=True
+        )
+        
+        assert model.title == "Test Title"
+        assert model.number == 42
+        assert model.published
+
+    def test_attribute_type_verification(self):
+        """Test that attribute types are verified on assignment."""
+        test_fields = {
+            'count': ('Count', int),
+            'name': ('Name', str)
+        }
+        
+        model = BaseModel(fields=test_fields)
+        
+        # Valid assignments
+        model.count = 10
+        model.name = "Test"
+        
+        assert model.count == 10
+        assert model.name == "Test"
+
+    def test_repr_method(self):
+        """Test string representation of BaseModel."""
+        test_fields = {
+            'title': ('Title', str)
+        }
+        
+        model = BaseModel(fields=test_fields, title="Test")
+        repr_str = repr(model)
+        
+        assert isinstance(repr_str, str)
+        assert "BaseModel" in repr_str
+
+
+class TestComicModel:
+    """Test cases for ComicModel class."""
+
+    def test_comic_model_creation(self):
+        """Test creating ComicModel with default values."""
+        model = ComicModel()
+        
+        # Check that comic-specific attributes exist
+        assert hasattr(model, 'title')
+        assert hasattr(model, 'series')
+        assert hasattr(model, 'number')
+        assert hasattr(model, 'volume')
+        assert hasattr(model, 'year')
+        assert hasattr(model, 'month')
+        assert hasattr(model, 'day')
+
+    def test_comic_model_with_values(self):
+        """Test creating ComicModel with specific values."""
+        model = ComicModel(
+            title="Test Comic",
+            series="Test Series",
+            number=1,
+            volume=1,
+            year=2024,
+            month=6,
+            day=15,
+            writer="Test Writer",
+            publisher="Test Publisher",
+            language_iso="en",
+            format=Format.SERIES,
+            black_white=YesNo.NO,
+            manga=Manga.RIGHT_LEFT,
+            age_rating=AgeRating.EVERYONE
+        )
+        
+        assert model.title == "Test Comic"
+        assert model.series == "Test Series"
+        assert model.number == 1
+        assert model.volume == 1
+        assert model.year == 2024
+        assert model.month == 6
+        assert model.day == 15
+        assert model.writer == "Test Writer"
+        assert model.publisher == "Test Publisher"
+        assert model.language_iso == "en"
+        assert model.format == Format.SERIES
+        assert model.black_white == YesNo.NO
+        assert model.manga == Manga.RIGHT_LEFT
+        assert model.age_rating == AgeRating.EVERYONE
+
+    def test_comic_model_enum_properties(self):
+        """Test that enum properties work correctly."""
+        model = ComicModel()
+        
+        # Test format enum
+        model.format = Format.PREVIEW
+        assert model.format == Format.PREVIEW
+        
+        # Test yes/no enum
+        model.black_white = YesNo.YES
+        assert model.black_white == YesNo.YES
+        
+        # Test manga enum
+        model.manga = Manga.RIGHT_LEFT
+        assert model.manga == Manga.RIGHT_LEFT
+        
+        # Test age rating enum
+        model.age_rating = AgeRating.TEEN
+        assert model.age_rating == AgeRating.TEEN
+
+    def test_comic_model_metadata_fields(self):
+        """Test comic metadata fields."""
+        model = ComicModel(
+            summary="Test summary",
+            notes="Test notes",
+            genre="Adventure",
+            web="http://example.com",
+            ean="1234567890123",
+            community_rating=5,
+            main_character_or_team="Hero",
+            characters="Hero, Villain",
+            teams="Justice League",
+            locations="Metropolis",
+            scan_information="Scanned by Test",
+            story_arc="Origin Story",
+            series_group="DC Comics",
+            alternate_series="Alternate Universe",
+            alternate_number=2,
+            alternate_count=10
+        )
+        
+        assert model.summary == "Test summary"
+        assert model.notes == "Test notes"
+        assert model.genre == "Adventure"
+        assert model.web == "http://example.com"
+        assert model.ean == "1234567890123"
+        assert model.community_rating == 5
+        assert model.main_character_or_team == "Hero"
+        assert model.characters == "Hero, Villain"
+        assert model.teams == "Justice League"
+        assert model.locations == "Metropolis"
+        assert model.scan_information == "Scanned by Test"
+        assert model.story_arc == "Origin Story"
+        assert model.series_group == "DC Comics"
+        assert model.alternate_series == "Alternate Universe"
+        assert model.alternate_number == 2
+        assert model.alternate_count == 10
+
+
+class TestPageModel:
+    """Test cases for PageModel class."""
+
+    def test_page_model_creation(self):
+        """Test creating PageModel with default values."""
+        model = PageModel()
+        
+        # Check that page-specific attributes exist
+        assert hasattr(model, 'image')
+        assert hasattr(model, 'type')
+        assert hasattr(model, 'double')
+        assert hasattr(model, 'image_size')
+        assert hasattr(model, 'key')
+        assert hasattr(model, 'bookmark')
+        assert hasattr(model, 'image_width')
+        assert hasattr(model, 'image_height')
+        assert hasattr(model, 'image_size')
+        # Note: format is not a base field in PageModel
+
+    def test_page_model_with_values(self):
+        """Test creating PageModel with specific values."""
+        model = PageModel(
+            image=1,
+            type=PageType.FRONT_COVER,
+            double=True,
+            image_size=1024000,
+            key="cover",
+            bookmark="Chapter 1",
+            image_width=800,
+            image_height=1200,
+        )
+        
+        assert model.image == 1
+        assert model.type == PageType.FRONT_COVER
+        assert model.double
+        assert model.image_size == 1024000
+        assert model.key == "cover"
+        assert model.bookmark == "Chapter 1"
+        assert model.image_width == 800
+        assert model.image_height == 1200
+
+    def test_page_model_page_types(self):
+        """Test different page types."""
+        page_types = [
+            PageType.FRONT_COVER,
+            PageType.INNER_COVER,
+            PageType.ROUNDUP,
+            PageType.STORY,
+            PageType.ADVERTISEMENT,
+            PageType.EDITORIAL,
+            PageType.LETTERS,
+            PageType.PREVIEW,
+            PageType.BACK_COVER,
+            PageType.OTHER,
+            PageType.DELETED
+        ]
+        
+        for page_type in page_types:
+            model = PageModel(type=page_type)
+            assert model.type == page_type
+
+    def test_page_model_boolean_properties(self):
+        """Test boolean properties in PageModel."""
+        model = PageModel()
+        
+        # Test double property
+        model.double = True
+        assert model.double
+        
+        model.double = False
+        assert not model.double
+
+    def test_page_model_numeric_properties(self):
+        """Test numeric properties in PageModel."""
+        model = PageModel(
+            image=5,
+            image_size=2048000,
+            image_width=1920,
+            image_height=1080
+        )
+        
+        assert model.image == 5
+        assert model.image_size == 2048000
+        assert model.image_width == 1920
+        assert model.image_height == 1080
+        
+        # Test that they're integers
+        assert isinstance(model.image, int)
+        assert isinstance(model.image_size, int)
+        assert isinstance(model.image_width, int)
+        assert isinstance(model.image_height, int)
@@ -0,0 +1,139 @@
+import pytest
+from cbz.page import PageInfo
+from cbz.constants import PageType
+
+class TestPageInfo:
+    """Test cases for PageInfo class."""
+
+    def test_load_from_file(self, sample_image_path):
+        """Test loading PageInfo from image file."""
+        page = PageInfo.load(path=sample_image_path)
+        
+        assert page is not None
+        assert isinstance(page.content, bytes)
+        assert len(page.content) > 0
+        assert page.name == sample_image_path.name
+        assert page.image_width > 0
+        assert page.image_height > 0
+        assert page.image_size > 0
+        assert page.suffix is not None
+
+    def test_load_with_page_type(self, sample_image_path):
+        """Test loading PageInfo with specific page type."""
+        page = PageInfo.load(path=sample_image_path, type=PageType.FRONT_COVER)
+        
+        assert page.type == PageType.FRONT_COVER
+
+    def test_load_with_custom_name(self, sample_image_path):
+        """Test loading PageInfo with custom name."""
+        custom_name = "custom_page.jpg"
+        page = PageInfo.load(path=sample_image_path, name=custom_name)
+        
+        assert page.name == custom_name
+
+    def test_page_content_property(self, sample_image_path):
+        """Test page content property getter and setter."""
+        page = PageInfo.load(path=sample_image_path)
+        original_content = page.content
+        
+        # Test getter
+        assert page.content == original_content
+        assert isinstance(page.content, bytes)
+        
+        # Test that content is properly set and metadata extracted
+        assert page.image_width > 0
+        assert page.image_height > 0
+        assert page.image_size > 0
+
+    def test_image_metadata_extraction(self, sample_image_path):
+        """Test that image metadata is correctly extracted."""
+        page = PageInfo.load(path=sample_image_path)
+        
+        # Check that all image metadata properties are set
+        assert hasattr(page, 'image_width') and page.image_width > 0
+        assert hasattr(page, 'image_height') and page.image_height > 0
+        assert hasattr(page, 'image_size') and page.image_size > 0
+        assert hasattr(page, 'suffix') and page.suffix is not None
+        
+        # Verify dimensions make sense for an image
+        assert isinstance(page.image_width, int)
+        assert isinstance(page.image_height, int)
+        assert isinstance(page.image_size, int)
+
+    def test_multiple_image_formats(self, images_dir):
+        """Test loading different image formats."""
+        image_files = list(images_dir.glob("*.jpg"))
+        
+        if not image_files:
+            pytest.skip("No image files found in example directory")
+        
+        for image_path in image_files[:3]:  # Test first 3 images
+            page = PageInfo.load(path=image_path)
+            
+            assert page is not None
+            assert isinstance(page.content, bytes)
+            assert len(page.content) > 0
+            assert page.image_width > 0
+            assert page.image_height > 0
+            assert page.image_size > 0
+
+    def test_page_type_assignment(self, sample_image_path):
+        """Test different page type assignments."""
+        page_types = [
+            PageType.FRONT_COVER,
+            PageType.INNER_COVER,
+            PageType.ROUNDUP,
+            PageType.STORY,
+            PageType.ADVERTISEMENT,
+            PageType.EDITORIAL,
+            PageType.LETTERS,
+            PageType.PREVIEW,
+            PageType.BACK_COVER,
+            PageType.OTHER,
+            PageType.DELETED
+        ]
+        
+        for page_type in page_types:
+            page = PageInfo.load(path=sample_image_path, type=page_type)
+            assert page.type == page_type
+
+    def test_page_creation_from_bytes(self, sample_image_path):
+        """Test creating PageInfo directly from bytes."""
+        # Read image file as bytes
+        with open(sample_image_path, 'rb') as f:
+            image_bytes = f.read()
+        
+        # Create page from bytes
+        page = PageInfo(content=image_bytes, name="test_page.jpg")
+        
+        assert page.content == image_bytes
+        assert page.name == "test_page.jpg"
+        assert page.image_width > 0
+        assert page.image_height > 0
+        assert page.image_size > 0
+
+    def test_repr_string(self, sample_image_path):
+        """Test string representation of PageInfo."""
+        page = PageInfo.load(path=sample_image_path, type=PageType.STORY)
+        
+        repr_str = repr(page)
+        assert "PageInfo" in repr_str
+        assert isinstance(repr_str, str)
+
+    def test_page_bookmark_property(self, sample_image_path):
+        """Test page bookmark property."""
+        # Test with bookmark
+        page = PageInfo.load(path=sample_image_path, bookmark="Chapter 1")
+        assert page.bookmark == "Chapter 1"
+        
+        # Test without bookmark
+        page_no_bookmark = PageInfo.load(path=sample_image_path)
+        assert hasattr(page_no_bookmark, 'bookmark')
+
+    def test_page_double_page_property(self, sample_image_path):
+        """Test page double_page property."""
+        page = PageInfo.load(path=sample_image_path, double=True)
+        assert page.double
+        
+        page_no_double = PageInfo.load(path=sample_image_path)
+        assert hasattr(page_no_double, 'double')