test: add test for page type

pkg/converter/converter_test.go

@@ -10,53 +10,39 @@ import (
 
 	"github.com/belphemur/CBZOptimizer/v2/internal/manga"
 	"github.com/belphemur/CBZOptimizer/v2/internal/utils/errs"
-	"github.com/belphemur/CBZOptimizer/v2/pkg/converter/constant"
-	"golang.org/x/exp/slices"
 )
 
 func TestConvertChapter(t *testing.T) {
 
 	testCases := []struct {
-		name                 string
+		name           string
-		genTestChapter       func(path string) (*manga.Chapter, error)
+		genTestChapter func(path string, isSplit bool) (*manga.Chapter, []string, error)
-		split                bool
+		split          bool
-		expectFailure        []constant.ConversionFormat
-		expectPartialSuccess []constant.ConversionFormat
 	}{
 		{
-			name:                 "All split pages",
+			name:           "All split pages",
-			genTestChapter:       genHugePage,
+			genTestChapter: genHugePage,
-			split:                true,
+			split:          true,
-			expectFailure:        []constant.ConversionFormat{},
-			expectPartialSuccess: []constant.ConversionFormat{},
 		},
 		{
-			name:                 "Big Pages, no split",
+			name:           "Big Pages, no split",
-			genTestChapter:       genHugePage,
+			genTestChapter: genHugePage,
-			split:                false,
+			split:          false,
-			expectFailure:        []constant.ConversionFormat{constant.WebP},
-			expectPartialSuccess: []constant.ConversionFormat{},
 		},
 		{
-			name:                 "No split pages",
+			name:           "No split pages",
-			genTestChapter:       genSmallPages,
+			genTestChapter: genSmallPages,
-			split:                false,
+			split:          false,
-			expectFailure:        []constant.ConversionFormat{},
-			expectPartialSuccess: []constant.ConversionFormat{},
 		},
 		{
-			name:                 "Mix of split and no split pages",
+			name:           "Mix of split and no split pages",
-			genTestChapter:       genMixSmallBig,
+			genTestChapter: genMixSmallBig,
-			split:                true,
+			split:          true,
-			expectFailure:        []constant.ConversionFormat{},
-			expectPartialSuccess: []constant.ConversionFormat{},
 		},
 		{
-			name:                 "Mix of Huge and small page",
+			name:           "Mix of Huge and small page",
-			genTestChapter:       genMixSmallHuge,
+			genTestChapter: genMixSmallHuge,
-			split:                false,
+			split:          false,
-			expectFailure:        []constant.ConversionFormat{},
-			expectPartialSuccess: []constant.ConversionFormat{constant.WebP},
 		},
 	}
 	// Load test genTestChapter from testdata
@@ -74,7 +60,7 @@ func TestConvertChapter(t *testing.T) {
 		t.Run(converter.Format().String(), func(t *testing.T) {
 			for _, tc := range testCases {
 				t.Run(tc.name, func(t *testing.T) {
-					chapter, err := tc.genTestChapter(temp.Name())
+					chapter, expectedExtensions, err := tc.genTestChapter(temp.Name(), tc.split)
 					if err != nil {
 						t.Fatalf("failed to load test genTestChapter: %v", err)
 					}
@@ -87,30 +73,22 @@ func TestConvertChapter(t *testing.T) {
 
 					convertedChapter, err := converter.ConvertChapter(context.Background(), chapter, quality, tc.split, progress)
 					if err != nil {
-						if convertedChapter != nil && slices.Contains(tc.expectPartialSuccess, converter.Format()) {
-							t.Logf("Partial success to convert genTestChapter: %v", err)
-							return
-						}
-						if slices.Contains(tc.expectFailure, converter.Format()) {
-							t.Logf("Expected failure to convert genTestChapter: %v", err)
-							return
-						}
 						t.Fatalf("failed to convert genTestChapter: %v", err)
-					} else if slices.Contains(tc.expectFailure, converter.Format()) {
-						t.Fatalf("expected failure to convert genTestChapter didn't happen")
 					}
 
 					if len(convertedChapter.Pages) == 0 {
 						t.Fatalf("no pages were converted")
 					}
 
-					if len(convertedChapter.Pages) != len(chapter.Pages) {
+					if len(convertedChapter.Pages) != len(expectedExtensions) {
-						t.Fatalf("converted chapter has different number of pages")
+						t.Fatalf("converted chapter has %d pages but expected %d", len(convertedChapter.Pages), len(expectedExtensions))
 					}
 
-					for _, page := range convertedChapter.Pages {
+					// Check each page's extension against the expected array
-						if page.Extension != ".webp" {
+					for i, page := range convertedChapter.Pages {
-							t.Errorf("page %d was not converted to webp format", page.Index)
+						expectedExt := expectedExtensions[i]
+						if page.Extension != expectedExt {
+							t.Errorf("page %d has extension %s but expected %s", page.Index, page.Extension, expectedExt)
 						}
 					}
 				})
@@ -119,39 +97,43 @@ func TestConvertChapter(t *testing.T) {
 	}
 }
 
-func genHugePage(path string) (*manga.Chapter, error) {
+func genHugePage(path string, isSplit bool) (*manga.Chapter, []string, error) {
 	file, err := os.Open(path)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	defer errs.Capture(&err, file.Close, "failed to close file")
 
 	var pages []*manga.Page
-	for i := 0; i < 1; i++ { // Assuming there are 5 pages for the test
+	expectedExtensions := []string{".jpg"} // One image that's generated as JPEG
-		img := image.NewRGBA(image.Rect(0, 0, 1, 17000))
+	if isSplit {
-		buf := new(bytes.Buffer)
+		expectedExtensions = []string{".webp", ".webp", ".webp", ".webp", ".webp", ".webp", ".webp", ".webp", ".webp"}
-		err := jpeg.Encode(buf, img, nil)
-		if err != nil {
-			return nil, err
-		}
-		page := &manga.Page{
-			Index:     uint16(i),
-			Contents:  buf,
-			Extension: ".jpg",
-		}
-		pages = append(pages, page)
 	}
 
+	// Create one tall page
+	img := image.NewRGBA(image.Rect(0, 0, 1, 17000))
+	buf := new(bytes.Buffer)
+	err = jpeg.Encode(buf, img, nil)
+	if err != nil {
+		return nil, nil, err
+	}
+	page := &manga.Page{
+		Index:     0,
+		Contents:  buf,
+		Extension: ".jpg",
+	}
+	pages = append(pages, page)
+
 	return &manga.Chapter{
 		FilePath: path,
 		Pages:    pages,
-	}, nil
+	}, expectedExtensions, nil
 }
 
-func genSmallPages(path string) (*manga.Chapter, error) {
+func genSmallPages(path string, isSplit bool) (*manga.Chapter, []string, error) {
 	file, err := os.Open(path)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	defer errs.Capture(&err, file.Close, "failed to close file")
 
@@ -159,9 +141,9 @@ func genSmallPages(path string) (*manga.Chapter, error) {
 	for i := 0; i < 5; i++ { // Assuming there are 5 pages for the test
 		img := image.NewRGBA(image.Rect(0, 0, 300, 1000))
 		buf := new(bytes.Buffer)
-		err := jpeg.Encode(buf, img, nil)
+		err = jpeg.Encode(buf, img, nil)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		page := &manga.Page{
 			Index:     uint16(i),
@@ -174,13 +156,13 @@ func genSmallPages(path string) (*manga.Chapter, error) {
 	return &manga.Chapter{
 		FilePath: path,
 		Pages:    pages,
-	}, nil
+	}, []string{".webp", ".webp", ".webp", ".webp", ".webp"}, nil
 }
 
-func genMixSmallBig(path string) (*manga.Chapter, error) {
+func genMixSmallBig(path string, isSplit bool) (*manga.Chapter, []string, error) {
 	file, err := os.Open(path)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	defer errs.Capture(&err, file.Close, "failed to close file")
 
@@ -190,7 +172,7 @@ func genMixSmallBig(path string) (*manga.Chapter, error) {
 		buf := new(bytes.Buffer)
 		err := jpeg.Encode(buf, img, nil)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		page := &manga.Page{
 			Index:     uint16(i),
@@ -199,17 +181,21 @@ func genMixSmallBig(path string) (*manga.Chapter, error) {
 		}
 		pages = append(pages, page)
 	}
+	expectedExtensions := []string{".webp", ".webp", ".webp", ".webp", ".webp"}
+	if isSplit {
+		expectedExtensions = []string{".webp", ".webp", ".webp", ".webp", ".webp", ".webp", ".webp", ".webp"}
+	}
 
 	return &manga.Chapter{
 		FilePath: path,
 		Pages:    pages,
-	}, nil
+	}, expectedExtensions, nil
 }
 
-func genMixSmallHuge(path string) (*manga.Chapter, error) {
+func genMixSmallHuge(path string, isSplit bool) (*manga.Chapter, []string, error) {
 	file, err := os.Open(path)
 	if err != nil {
-		return nil, err
+		return nil, nil, err
 	}
 	defer errs.Capture(&err, file.Close, "failed to close file")
 
@@ -219,7 +205,7 @@ func genMixSmallHuge(path string) (*manga.Chapter, error) {
 		buf := new(bytes.Buffer)
 		err := jpeg.Encode(buf, img, nil)
 		if err != nil {
-			return nil, err
+			return nil, nil, err
 		}
 		page := &manga.Page{
 			Index:     uint16(i),
@@ -232,5 +218,5 @@ func genMixSmallHuge(path string) (*manga.Chapter, error) {
 	return &manga.Chapter{
 		FilePath: path,
 		Pages:    pages,
-	}, nil
+	}, []string{".webp", ".webp", ".webp", ".webp", ".webp", ".webp", ".webp", ".webp", ".jpg", ".jpg"}, nil
 }

pkg/converter/webp/webp_converter_test.go

@@ -236,30 +236,35 @@ func TestConverter_convertPage(t *testing.T) {
 		format          string
 		isToBeConverted bool
 		expectWebP      bool
+		expectError     bool
 	}{
 		{
 			name:            "Convert PNG to WebP",
 			format:          "png",
 			isToBeConverted: true,
 			expectWebP:      true,
+			expectError:     false,
 		},
 		{
 			name:            "Convert GIF to WebP",
 			format:          "gif",
 			isToBeConverted: true,
 			expectWebP:      true,
+			expectError:     false,
 		},
 		{
 			name:            "Already WebP",
 			format:          "webp",
 			isToBeConverted: true,
 			expectWebP:      true,
+			expectError:     false,
 		},
 		{
 			name:            "Skip conversion",
 			format:          "png",
 			isToBeConverted: false,
 			expectWebP:      false,
+			expectError:     false,
 		},
 	}
 
@@ -271,19 +276,47 @@ func TestConverter_convertPage(t *testing.T) {
 			container := manga.NewContainer(page, img, tt.format, tt.isToBeConverted)
 
 			converted, err := converter.convertPage(container, 80)
-			require.NoError(t, err)
-			assert.NotNil(t, converted)
 
-			if tt.expectWebP {
+			if tt.expectError {
-				assert.Equal(t, ".webp", converted.Page.Extension)
+				assert.Error(t, err)
-				validateConvertedImage(t, converted.Page)
+				assert.Nil(t, converted)
 			} else {
-				assert.NotEqual(t, ".webp", converted.Page.Extension)
+				require.NoError(t, err)
+				assert.NotNil(t, converted)
+
+				if tt.expectWebP {
+					assert.Equal(t, ".webp", converted.Page.Extension)
+					validateConvertedImage(t, converted.Page)
+				} else {
+					assert.NotEqual(t, ".webp", converted.Page.Extension)
+				}
 			}
 		})
 	}
 }
 
+func TestConverter_convertPage_WithCorruptedImage(t *testing.T) {
+	converter := New()
+	err := converter.PrepareConverter()
+	require.NoError(t, err)
+
+	// Create a corrupted PNG image by creating a page with invalid data
+	corruptedPage := &manga.Page{
+		Index:     1,
+		Contents:  &bytes.Buffer{}, // Empty buffer - should cause decode error
+		Extension: ".png",
+		Size:      0,
+	}
+
+	container := manga.NewContainer(corruptedPage, nil, "png", true)
+
+	converted, err := converter.convertPage(container, 80)
+
+	// This should return nil container and error because decode will fail with "image: unknown format"
+	assert.Error(t, err)
+	assert.Nil(t, converted)
+}
+
 func TestConverter_checkPageNeedsSplit(t *testing.T) {
 	converter := New()