github.com/soulteary/pocket-bookcase@v0.0.0-20240428065142-0b5a9a0fc98a/internal/core/ebook_test.go (about)

     1  package core_test
     2  
     3  import (
     4  	"context"
     5  	"os"
     6  	fp "path/filepath"
     7  	"testing"
     8  
     9  	"github.com/sirupsen/logrus"
    10  	"github.com/soulteary/pocket-bookcase/internal/core"
    11  	"github.com/soulteary/pocket-bookcase/internal/domains"
    12  	"github.com/soulteary/pocket-bookcase/internal/model"
    13  	"github.com/soulteary/pocket-bookcase/internal/testutil"
    14  	"github.com/spf13/afero"
    15  	"github.com/stretchr/testify/assert"
    16  )
    17  
    18  func TestGenerateEbook(t *testing.T) {
    19  	logger := logrus.New()
    20  	_, deps := testutil.GetTestConfigurationAndDependencies(t, context.TODO(), logger)
    21  
    22  	t.Run("Successful ebook generate", func(t *testing.T) {
    23  		t.Run("valid bookmarkId that return HasEbook true", func(t *testing.T) {
    24  			dstFile := "/ebook/1.epub"
    25  			tmpDir := t.TempDir()
    26  
    27  			deps.Domains.Storage = domains.NewStorageDomain(deps, afero.NewBasePathFs(afero.NewOsFs(), tmpDir))
    28  
    29  			mockRequest := core.ProcessRequest{
    30  				Bookmark: model.BookmarkDTO{
    31  					ID:       1,
    32  					Title:    "Example Bookmark",
    33  					HTML:     "<html><body>Example HTML</body></html>",
    34  					HasEbook: false,
    35  				},
    36  				DataDir:     tmpDir,
    37  				ContentType: "text/html",
    38  			}
    39  			bookmark, err := core.GenerateEbook(deps, mockRequest, dstFile)
    40  
    41  			assert.True(t, bookmark.HasEbook)
    42  			assert.NoError(t, err)
    43  		})
    44  		t.Run("ebook generate with valid BookmarkID EbookExist ImagePathExist ReturnWithHasEbookTrue", func(t *testing.T) {
    45  			dstFile := "/ebook/2.epub"
    46  			tmpDir := t.TempDir()
    47  
    48  			deps.Domains.Storage = domains.NewStorageDomain(deps, afero.NewBasePathFs(afero.NewOsFs(), tmpDir))
    49  
    50  			bookmark := model.BookmarkDTO{
    51  				ID:       2,
    52  				HasEbook: false,
    53  			}
    54  			mockRequest := core.ProcessRequest{
    55  				Bookmark:    bookmark,
    56  				DataDir:     tmpDir,
    57  				ContentType: "text/html",
    58  			}
    59  			// Create the thumbnail file
    60  			imagePath := model.GetThumbnailPath(&bookmark)
    61  			imagedirPath := fp.Dir(imagePath)
    62  			deps.Domains.Storage.FS().MkdirAll(imagedirPath, os.ModePerm)
    63  			file, err := deps.Domains.Storage.FS().Create(imagePath)
    64  			if err != nil {
    65  				t.Fatal(err)
    66  			}
    67  			defer file.Close()
    68  
    69  			bookmark, err = core.GenerateEbook(deps, mockRequest, dstFile)
    70  			expectedImagePath := string(fp.Separator) + fp.Join("bookmark", "2", "thumb")
    71  			assert.NoError(t, err)
    72  			assert.True(t, bookmark.HasEbook)
    73  			assert.Equalf(t, expectedImagePath, bookmark.ImageURL, "Expected imageURL %s, but got %s", expectedImagePath, bookmark.ImageURL)
    74  		})
    75  		t.Run("generate ebook valid BookmarkID EbookExist ReturnHasArchiveTrue", func(t *testing.T) {
    76  			dstFile := "/ebook/3.epub"
    77  			tmpDir := t.TempDir()
    78  
    79  			deps.Domains.Storage = domains.NewStorageDomain(deps, afero.NewBasePathFs(afero.NewOsFs(), tmpDir))
    80  
    81  			bookmark := model.BookmarkDTO{
    82  				ID:       3,
    83  				HasEbook: false,
    84  			}
    85  			mockRequest := core.ProcessRequest{
    86  				Bookmark:    bookmark,
    87  				DataDir:     tmpDir,
    88  				ContentType: "text/html",
    89  			}
    90  			// Create the archive file
    91  			archivePath := model.GetArchivePath(&bookmark)
    92  			archiveDirPath := fp.Dir(archivePath)
    93  			deps.Domains.Storage.FS().MkdirAll(archiveDirPath, os.ModePerm)
    94  			file, err := deps.Domains.Storage.FS().Create(archivePath)
    95  			if err != nil {
    96  				t.Fatal(err)
    97  			}
    98  			defer file.Close()
    99  
   100  			bookmark, err = core.GenerateEbook(deps, mockRequest, fp.Join(dstFile, "1"))
   101  			assert.True(t, bookmark.HasArchive)
   102  			assert.NoError(t, err)
   103  		})
   104  	})
   105  	t.Run("specific ebook generate case", func(t *testing.T) {
   106  		t.Run("invalid bookmarkId that return Error", func(t *testing.T) {
   107  			dstFile := "/ebook/0.epub"
   108  			tmpDir := t.TempDir()
   109  			mockRequest := core.ProcessRequest{
   110  				Bookmark: model.BookmarkDTO{
   111  					ID:       0,
   112  					HasEbook: false,
   113  				},
   114  				DataDir:     tmpDir,
   115  				ContentType: "text/html",
   116  			}
   117  
   118  			bookmark, err := core.GenerateEbook(deps, mockRequest, dstFile)
   119  
   120  			assert.Equal(t, model.BookmarkDTO{
   121  				ID:       0,
   122  				HasEbook: false,
   123  			}, bookmark)
   124  			assert.EqualError(t, err, "bookmark ID is not valid")
   125  		})
   126  		t.Run("ebook exist return HasEbook true", func(t *testing.T) {
   127  			dstFile := "/ebook/1.epub"
   128  			tmpDir := t.TempDir()
   129  
   130  			deps.Domains.Storage = domains.NewStorageDomain(deps, afero.NewBasePathFs(afero.NewOsFs(), tmpDir))
   131  
   132  			bookmark := model.BookmarkDTO{
   133  				ID:       1,
   134  				HasEbook: false,
   135  			}
   136  			mockRequest := core.ProcessRequest{
   137  				Bookmark:    bookmark,
   138  				DataDir:     tmpDir,
   139  				ContentType: "text/html",
   140  			}
   141  			// Create the ebook file
   142  			ebookPath := model.GetEbookPath(&bookmark)
   143  			ebookDirPath := fp.Dir(ebookPath)
   144  			deps.Domains.Storage.FS().MkdirAll(ebookDirPath, os.ModePerm)
   145  			file, err := deps.Domains.Storage.FS().Create(ebookPath)
   146  			if err != nil {
   147  				t.Fatal(err)
   148  			}
   149  			defer file.Close()
   150  
   151  			bookmark, err = core.GenerateEbook(deps, mockRequest, dstFile)
   152  
   153  			assert.True(t, bookmark.HasEbook)
   154  			assert.NoError(t, err)
   155  		})
   156  		t.Run("generate ebook valid BookmarkID RetuenError for PDF file", func(t *testing.T) {
   157  			dstFile := "/ebook/1.epub"
   158  			tmpDir := t.TempDir()
   159  
   160  			mockRequest := core.ProcessRequest{
   161  				Bookmark: model.BookmarkDTO{
   162  					ID:       1,
   163  					HasEbook: false,
   164  				},
   165  				DataDir:     tmpDir,
   166  				ContentType: "application/pdf",
   167  			}
   168  
   169  			bookmark, err := core.GenerateEbook(deps, mockRequest, dstFile)
   170  
   171  			assert.False(t, bookmark.HasEbook)
   172  			assert.Error(t, err)
   173  			assert.EqualError(t, err, "can't create ebook for pdf")
   174  		})
   175  	})
   176  }