Mirrors/stash
1
0
Fork 0
mirror of https://github.com/stashapp/stash.git synced 2025-12-17 04:14:39 +03:00
Code Issues Packages Projects Releases Wiki Activity

Model refactor, part 3 (#4152)

Browse Source 
* Remove manager.Repository
* Refactor other repositories
* Fix tests and add database mock
* Add AssertExpectations method
* Refactor routes
* Move default movie image to internal/static and add convenience methods
* Refactor default performer image boxes
This commit is contained in:
DingDongSoLong4
2023-10-16 05:26:34 +02:00
committed by GitHub
parent 40bcb4baa5
commit 33f2ebf2a3
87 changed files with 1843 additions and 1651 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
pkg/tag/export_test.go
View File

@@ -1,7 +1,6 @@
package tag
import (
"context"
"errors"
"github.com/stashapp/stash/pkg/models"
@@ -109,35 +108,34 @@ func initTestTable() {
func TestToJSON(t *testing.T) {
initTestTable()
ctx := context.Background()
mockTagReader := &mocks.TagReaderWriter{}
db := mocks.NewDatabase()
imageErr := errors.New("error getting image")
aliasErr := errors.New("error getting aliases")
parentsErr := errors.New("error getting parents")
mockTagReader.On("GetAliases", ctx, tagID).Return([]string{"alias"}, nil).Once()
mockTagReader.On("GetAliases", ctx, noImageID).Return(nil, nil).Once()
mockTagReader.On("GetAliases", ctx, errImageID).Return(nil, nil).Once()
mockTagReader.On("GetAliases", ctx, errAliasID).Return(nil, aliasErr).Once()
mockTagReader.On("GetAliases", ctx, withParentsID).Return(nil, nil).Once()
mockTagReader.On("GetAliases", ctx, errParentsID).Return(nil, nil).Once()
db.Tag.On("GetAliases", testCtx, tagID).Return([]string{"alias"}, nil).Once()
db.Tag.On("GetAliases", testCtx, noImageID).Return(nil, nil).Once()
db.Tag.On("GetAliases", testCtx, errImageID).Return(nil, nil).Once()
db.Tag.On("GetAliases", testCtx, errAliasID).Return(nil, aliasErr).Once()
db.Tag.On("GetAliases", testCtx, withParentsID).Return(nil, nil).Once()
db.Tag.On("GetAliases", testCtx, errParentsID).Return(nil, nil).Once()
mockTagReader.On("GetImage", ctx, tagID).Return(imageBytes, nil).Once()
mockTagReader.On("GetImage", ctx, noImageID).Return(nil, nil).Once()
mockTagReader.On("GetImage", ctx, errImageID).Return(nil, imageErr).Once()
mockTagReader.On("GetImage", ctx, withParentsID).Return(imageBytes, nil).Once()
mockTagReader.On("GetImage", ctx, errParentsID).Return(nil, nil).Once()
db.Tag.On("GetImage", testCtx, tagID).Return(imageBytes, nil).Once()
db.Tag.On("GetImage", testCtx, noImageID).Return(nil, nil).Once()
db.Tag.On("GetImage", testCtx, errImageID).Return(nil, imageErr).Once()
db.Tag.On("GetImage", testCtx, withParentsID).Return(imageBytes, nil).Once()
db.Tag.On("GetImage", testCtx, errParentsID).Return(nil, nil).Once()
mockTagReader.On("FindByChildTagID", ctx, tagID).Return(nil, nil).Once()
mockTagReader.On("FindByChildTagID", ctx, noImageID).Return(nil, nil).Once()
mockTagReader.On("FindByChildTagID", ctx, withParentsID).Return([]*models.Tag{{Name: "parent"}}, nil).Once()
mockTagReader.On("FindByChildTagID", ctx, errParentsID).Return(nil, parentsErr).Once()
mockTagReader.On("FindByChildTagID", ctx, errImageID).Return(nil, nil).Once()
db.Tag.On("FindByChildTagID", testCtx, tagID).Return(nil, nil).Once()
db.Tag.On("FindByChildTagID", testCtx, noImageID).Return(nil, nil).Once()
db.Tag.On("FindByChildTagID", testCtx, withParentsID).Return([]*models.Tag{{Name: "parent"}}, nil).Once()
db.Tag.On("FindByChildTagID", testCtx, errParentsID).Return(nil, parentsErr).Once()
db.Tag.On("FindByChildTagID", testCtx, errImageID).Return(nil, nil).Once()
for i, s := range scenarios {
tag := s.tag
json, err := ToJSON(ctx, mockTagReader, &tag)
json, err := ToJSON(testCtx, db.Tag, &tag)
switch {
case !s.err && err != nil:
@@ -149,5 +147,5 @@ func TestToJSON(t *testing.T) {
}
}
mockTagReader.AssertExpectations(t)
db.AssertExpectations(t)
}

108
pkg/tag/import_test.go
View File

@@ -58,10 +58,10 @@ func TestImporterPreImport(t *testing.T) {
}
func TestImporterPostImport(t *testing.T) {
readerWriter := &mocks.TagReaderWriter{}
db := mocks.NewDatabase()
i := Importer{
ReaderWriter: readerWriter,
ReaderWriter: db.Tag,
Input: jsonschema.Tag{
Aliases: []string{"alias"},
},
@@ -72,23 +72,23 @@ func TestImporterPostImport(t *testing.T) {
updateTagAliasErr := errors.New("UpdateAlias error")
updateTagParentsErr := errors.New("UpdateParentTags error")
readerWriter.On("UpdateAliases", testCtx, tagID, i.Input.Aliases).Return(nil).Once()
readerWriter.On("UpdateAliases", testCtx, errAliasID, i.Input.Aliases).Return(updateTagAliasErr).Once()
readerWriter.On("UpdateAliases", testCtx, withParentsID, i.Input.Aliases).Return(nil).Once()
readerWriter.On("UpdateAliases", testCtx, errParentsID, i.Input.Aliases).Return(nil).Once()
db.Tag.On("UpdateAliases", testCtx, tagID, i.Input.Aliases).Return(nil).Once()
db.Tag.On("UpdateAliases", testCtx, errAliasID, i.Input.Aliases).Return(updateTagAliasErr).Once()
db.Tag.On("UpdateAliases", testCtx, withParentsID, i.Input.Aliases).Return(nil).Once()
db.Tag.On("UpdateAliases", testCtx, errParentsID, i.Input.Aliases).Return(nil).Once()
readerWriter.On("UpdateImage", testCtx, tagID, imageBytes).Return(nil).Once()
readerWriter.On("UpdateImage", testCtx, errAliasID, imageBytes).Return(nil).Once()
readerWriter.On("UpdateImage", testCtx, errImageID, imageBytes).Return(updateTagImageErr).Once()
readerWriter.On("UpdateImage", testCtx, withParentsID, imageBytes).Return(nil).Once()
readerWriter.On("UpdateImage", testCtx, errParentsID, imageBytes).Return(nil).Once()
db.Tag.On("UpdateImage", testCtx, tagID, imageBytes).Return(nil).Once()
db.Tag.On("UpdateImage", testCtx, errAliasID, imageBytes).Return(nil).Once()
db.Tag.On("UpdateImage", testCtx, errImageID, imageBytes).Return(updateTagImageErr).Once()
db.Tag.On("UpdateImage", testCtx, withParentsID, imageBytes).Return(nil).Once()
db.Tag.On("UpdateImage", testCtx, errParentsID, imageBytes).Return(nil).Once()
var parentTags []int
readerWriter.On("UpdateParentTags", testCtx, tagID, parentTags).Return(nil).Once()
readerWriter.On("UpdateParentTags", testCtx, withParentsID, []int{100}).Return(nil).Once()
readerWriter.On("UpdateParentTags", testCtx, errParentsID, []int{100}).Return(updateTagParentsErr).Once()
db.Tag.On("UpdateParentTags", testCtx, tagID, parentTags).Return(nil).Once()
db.Tag.On("UpdateParentTags", testCtx, withParentsID, []int{100}).Return(nil).Once()
db.Tag.On("UpdateParentTags", testCtx, errParentsID, []int{100}).Return(updateTagParentsErr).Once()
readerWriter.On("FindByName", testCtx, "Parent", false).Return(&models.Tag{ID: 100}, nil)
db.Tag.On("FindByName", testCtx, "Parent", false).Return(&models.Tag{ID: 100}, nil)
err := i.PostImport(testCtx, tagID)
assert.Nil(t, err)
@@ -106,14 +106,14 @@ func TestImporterPostImport(t *testing.T) {
err = i.PostImport(testCtx, errParentsID)
assert.NotNil(t, err)
readerWriter.AssertExpectations(t)
db.AssertExpectations(t)
}
func TestImporterPostImportParentMissing(t *testing.T) {
readerWriter := &mocks.TagReaderWriter{}
db := mocks.NewDatabase()
i := Importer{
ReaderWriter: readerWriter,
ReaderWriter: db.Tag,
Input: jsonschema.Tag{},
imageData: imageBytes,
}
@@ -133,33 +133,33 @@ func TestImporterPostImportParentMissing(t *testing.T) {
var emptyParents []int
readerWriter.On("UpdateImage", testCtx, mock.Anything, mock.Anything).Return(nil)
readerWriter.On("UpdateAliases", testCtx, mock.Anything, mock.Anything).Return(nil)
db.Tag.On("UpdateImage", testCtx, mock.Anything, mock.Anything).Return(nil)
db.Tag.On("UpdateAliases", testCtx, mock.Anything, mock.Anything).Return(nil)
readerWriter.On("FindByName", testCtx, "Create", false).Return(nil, nil).Once()
readerWriter.On("FindByName", testCtx, "CreateError", false).Return(nil, nil).Once()
readerWriter.On("FindByName", testCtx, "CreateFindError", false).Return(nil, findError).Once()
readerWriter.On("FindByName", testCtx, "CreateFound", false).Return(&models.Tag{ID: 101}, nil).Once()
readerWriter.On("FindByName", testCtx, "Fail", false).Return(nil, nil).Once()
readerWriter.On("FindByName", testCtx, "FailFindError", false).Return(nil, findError)
readerWriter.On("FindByName", testCtx, "FailFound", false).Return(&models.Tag{ID: 102}, nil).Once()
readerWriter.On("FindByName", testCtx, "Ignore", false).Return(nil, nil).Once()
readerWriter.On("FindByName", testCtx, "IgnoreFindError", false).Return(nil, findError)
readerWriter.On("FindByName", testCtx, "IgnoreFound", false).Return(&models.Tag{ID: 103}, nil).Once()
db.Tag.On("FindByName", testCtx, "Create", false).Return(nil, nil).Once()
db.Tag.On("FindByName", testCtx, "CreateError", false).Return(nil, nil).Once()
db.Tag.On("FindByName", testCtx, "CreateFindError", false).Return(nil, findError).Once()
db.Tag.On("FindByName", testCtx, "CreateFound", false).Return(&models.Tag{ID: 101}, nil).Once()
db.Tag.On("FindByName", testCtx, "Fail", false).Return(nil, nil).Once()
db.Tag.On("FindByName", testCtx, "FailFindError", false).Return(nil, findError)
db.Tag.On("FindByName", testCtx, "FailFound", false).Return(&models.Tag{ID: 102}, nil).Once()
db.Tag.On("FindByName", testCtx, "Ignore", false).Return(nil, nil).Once()
db.Tag.On("FindByName", testCtx, "IgnoreFindError", false).Return(nil, findError)
db.Tag.On("FindByName", testCtx, "IgnoreFound", false).Return(&models.Tag{ID: 103}, nil).Once()
readerWriter.On("UpdateParentTags", testCtx, createID, []int{100}).Return(nil).Once()
readerWriter.On("UpdateParentTags", testCtx, createFoundID, []int{101}).Return(nil).Once()
readerWriter.On("UpdateParentTags", testCtx, failFoundID, []int{102}).Return(nil).Once()
readerWriter.On("UpdateParentTags", testCtx, ignoreID, emptyParents).Return(nil).Once()
readerWriter.On("UpdateParentTags", testCtx, ignoreFoundID, []int{103}).Return(nil).Once()
db.Tag.On("UpdateParentTags", testCtx, createID, []int{100}).Return(nil).Once()
db.Tag.On("UpdateParentTags", testCtx, createFoundID, []int{101}).Return(nil).Once()
db.Tag.On("UpdateParentTags", testCtx, failFoundID, []int{102}).Return(nil).Once()
db.Tag.On("UpdateParentTags", testCtx, ignoreID, emptyParents).Return(nil).Once()
db.Tag.On("UpdateParentTags", testCtx, ignoreFoundID, []int{103}).Return(nil).Once()
readerWriter.On("Create", testCtx, mock.MatchedBy(func(t *models.Tag) bool {
db.Tag.On("Create", testCtx, mock.MatchedBy(func(t *models.Tag) bool {
return t.Name == "Create"
})).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.Tag)
t.ID = 100
}).Return(nil).Once()
readerWriter.On("Create", testCtx, mock.MatchedBy(func(t *models.Tag) bool {
db.Tag.On("Create", testCtx, mock.MatchedBy(func(t *models.Tag) bool {
return t.Name == "CreateError"
})).Return(errors.New("failed creating parent")).Once()
@@ -206,25 +206,25 @@ func TestImporterPostImportParentMissing(t *testing.T) {
err = i.PostImport(testCtx, ignoreFoundID)
assert.Nil(t, err)
readerWriter.AssertExpectations(t)
db.AssertExpectations(t)
}
func TestImporterFindExistingID(t *testing.T) {
readerWriter := &mocks.TagReaderWriter{}
db := mocks.NewDatabase()
i := Importer{
ReaderWriter: readerWriter,
ReaderWriter: db.Tag,
Input: jsonschema.Tag{
Name: tagName,
},
}
errFindByName := errors.New("FindByName error")
readerWriter.On("FindByName", testCtx, tagName, false).Return(nil, nil).Once()
readerWriter.On("FindByName", testCtx, existingTagName, false).Return(&models.Tag{
db.Tag.On("FindByName", testCtx, tagName, false).Return(nil, nil).Once()
db.Tag.On("FindByName", testCtx, existingTagName, false).Return(&models.Tag{
ID: existingTagID,
}, nil).Once()
readerWriter.On("FindByName", testCtx, tagNameErr, false).Return(nil, errFindByName).Once()
db.Tag.On("FindByName", testCtx, tagNameErr, false).Return(nil, errFindByName).Once()
id, err := i.FindExistingID(testCtx)
assert.Nil(t, id)
@@ -240,11 +240,11 @@ func TestImporterFindExistingID(t *testing.T) {
assert.Nil(t, id)
assert.NotNil(t, err)
readerWriter.AssertExpectations(t)
db.AssertExpectations(t)
}
func TestCreate(t *testing.T) {
readerWriter := &mocks.TagReaderWriter{}
db := mocks.NewDatabase()
tag := models.Tag{
Name: tagName,
@@ -255,16 +255,16 @@ func TestCreate(t *testing.T) {
}
i := Importer{
ReaderWriter: readerWriter,
ReaderWriter: db.Tag,
tag: tag,
}
errCreate := errors.New("Create error")
readerWriter.On("Create", testCtx, &tag).Run(func(args mock.Arguments) {
db.Tag.On("Create", testCtx, &tag).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.Tag)
t.ID = tagID
}).Return(nil).Once()
readerWriter.On("Create", testCtx, &tagErr).Return(errCreate).Once()
db.Tag.On("Create", testCtx, &tagErr).Return(errCreate).Once()
id, err := i.Create(testCtx)
assert.Equal(t, tagID, *id)
@@ -275,11 +275,11 @@ func TestCreate(t *testing.T) {
assert.Nil(t, id)
assert.NotNil(t, err)
readerWriter.AssertExpectations(t)
db.AssertExpectations(t)
}
func TestUpdate(t *testing.T) {
readerWriter := &mocks.TagReaderWriter{}
db := mocks.NewDatabase()
tag := models.Tag{
Name: tagName,
@@ -290,7 +290,7 @@ func TestUpdate(t *testing.T) {
}
i := Importer{
ReaderWriter: readerWriter,
ReaderWriter: db.Tag,
tag: tag,
}
@@ -298,7 +298,7 @@ func TestUpdate(t *testing.T) {
// id needs to be set for the mock input
tag.ID = tagID
readerWriter.On("Update", testCtx, &tag).Return(nil).Once()
db.Tag.On("Update", testCtx, &tag).Return(nil).Once()
err := i.Update(testCtx, tagID)
assert.Nil(t, err)
@@ -307,10 +307,10 @@ func TestUpdate(t *testing.T) {
// need to set id separately
tagErr.ID = errImageID
readerWriter.On("Update", testCtx, &tagErr).Return(errUpdate).Once()
db.Tag.On("Update", testCtx, &tagErr).Return(errUpdate).Once()
err = i.Update(testCtx, errImageID)
assert.NotNil(t, err)
readerWriter.AssertExpectations(t)
db.AssertExpectations(t)
}

15
pkg/tag/update_test.go
View File

@@ -219,8 +219,7 @@ func TestEnsureHierarchy(t *testing.T) {
}
func testEnsureHierarchy(t *testing.T, tc testUniqueHierarchyCase, queryParents, queryChildren bool) {
mockTagReader := &mocks.TagReaderWriter{}
ctx := context.Background()
db := mocks.NewDatabase()
var parentIDs, childIDs []int
find := make(map[int]*models.Tag)
@@ -247,15 +246,15 @@ func testEnsureHierarchy(t *testing.T, tc testUniqueHierarchyCase, queryParents,
if queryParents {
parentIDs = nil
mockTagReader.On("FindByChildTagID", ctx, tc.id).Return(tc.parents, nil).Once()
db.Tag.On("FindByChildTagID", testCtx, tc.id).Return(tc.parents, nil).Once()
}
if queryChildren {
childIDs = nil
mockTagReader.On("FindByParentTagID", ctx, tc.id).Return(tc.children, nil).Once()
db.Tag.On("FindByParentTagID", testCtx, tc.id).Return(tc.children, nil).Once()
}
mockTagReader.On("FindAllAncestors", ctx, mock.AnythingOfType("int"), []int(nil)).Return(func(ctx context.Context, tagID int, excludeIDs []int) []*models.TagPath {
db.Tag.On("FindAllAncestors", testCtx, mock.AnythingOfType("int"), []int(nil)).Return(func(ctx context.Context, tagID int, excludeIDs []int) []*models.TagPath {
return tc.onFindAllAncestors
}, func(ctx context.Context, tagID int, excludeIDs []int) error {
if tc.onFindAllAncestors != nil {
@@ -264,7 +263,7 @@ func testEnsureHierarchy(t *testing.T, tc testUniqueHierarchyCase, queryParents,
return fmt.Errorf("undefined ancestors for: %d", tagID)
}).Maybe()
mockTagReader.On("FindAllDescendants", ctx, mock.AnythingOfType("int"), []int(nil)).Return(func(ctx context.Context, tagID int, excludeIDs []int) []*models.TagPath {
db.Tag.On("FindAllDescendants", testCtx, mock.AnythingOfType("int"), []int(nil)).Return(func(ctx context.Context, tagID int, excludeIDs []int) []*models.TagPath {
return tc.onFindAllDescendants
}, func(ctx context.Context, tagID int, excludeIDs []int) error {
if tc.onFindAllDescendants != nil {
@@ -273,7 +272,7 @@ func testEnsureHierarchy(t *testing.T, tc testUniqueHierarchyCase, queryParents,
return fmt.Errorf("undefined descendants for: %d", tagID)
}).Maybe()
res := ValidateHierarchy(ctx, testUniqueHierarchyTags[tc.id], parentIDs, childIDs, mockTagReader)
res := ValidateHierarchy(testCtx, testUniqueHierarchyTags[tc.id], parentIDs, childIDs, db.Tag)
assert := assert.New(t)
@@ -285,5 +284,5 @@ func testEnsureHierarchy(t *testing.T, tc testUniqueHierarchyCase, queryParents,
assert.Nil(res)
}
mockTagReader.AssertExpectations(t)
db.AssertExpectations(t)
}