Backup_Repos/stash
1
0
Fork 0
mirror of https://github.com/stashapp/stash.git synced 2026-04-22 06:52:39 +02:00
Code Issues Projects Releases Wiki Activity

Fix existing unit tests

Browse source
This commit is contained in:
WithoutPants 2026-02-05 11:17:36 +11:00
parent b3c341007a
commit 1e19388c31
12 changed files with 212 additions and 70 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
internal/autotag/integration_test.go
View file

@ -118,7 +118,7 @@ func createTag(ctx context.Context, qb models.TagWriter) error {
Name: testName,
}
err := qb.Create(ctx, &tag)
err := qb.Create(ctx, &models.CreateTagInput{Tag: &tag})
if err != nil {
return err
}

12
internal/identify/scene_test.go
View file

@ -368,14 +368,14 @@ func Test_sceneRelationships_tags(t *testing.T) {
db := mocks.NewDatabase()
db.Tag.On("Create", testCtx, mock.MatchedBy(func(p *models.Tag) bool {
return p.Name == validName
db.Tag.On("Create", testCtx, mock.MatchedBy(func(p *models.CreateTagInput) bool {
return p.Tag.Name == validName
})).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.Tag)
t.ID = validStoredIDInt
t := args.Get(1).(*models.CreateTagInput)
t.Tag.ID = validStoredIDInt
}).Return(nil)
db.Tag.On("Create", testCtx, mock.MatchedBy(func(p *models.Tag) bool {
return p.Name == invalidName
db.Tag.On("Create", testCtx, mock.MatchedBy(func(p *models.CreateTagInput) bool {
return p.Tag.Name == invalidName
})).Return(errors.New("error creating tag"))
tr := sceneRelationships{

8
pkg/gallery/import_test.go
View file

@ -289,9 +289,9 @@ func TestImporterPreImportWithMissingTag(t *testing.T) {
}
db.Tag.On("FindByNames", testCtx, []string{missingTagName}, false).Return(nil, nil).Times(3)
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.Tag")).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.Tag)
t.ID = existingTagID
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.CreateTagInput")).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.CreateTagInput)
t.Tag.ID = existingTagID
}).Return(nil)
err := i.PreImport(testCtx)
@ -323,7 +323,7 @@ func TestImporterPreImportWithMissingTagCreateErr(t *testing.T) {
}
db.Tag.On("FindByNames", testCtx, []string{missingTagName}, false).Return(nil, nil).Once()
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.Tag")).Return(errors.New("Create error"))
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.CreateTagInput")).Return(errors.New("Create error"))
err := i.PreImport(testCtx)
assert.NotNil(t, err)

8
pkg/group/import_test.go
View file

@ -212,9 +212,9 @@ func TestImporterPreImportWithMissingTag(t *testing.T) {
}
db.Tag.On("FindByNames", testCtx, []string{missingTagName}, false).Return(nil, nil).Times(3)
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.Tag")).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.Tag)
t.ID = existingTagID
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.CreateTagInput")).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.CreateTagInput)
t.Tag.ID = existingTagID
}).Return(nil)
err := i.PreImport(testCtx)
@ -247,7 +247,7 @@ func TestImporterPreImportWithMissingTagCreateErr(t *testing.T) {
}
db.Tag.On("FindByNames", testCtx, []string{missingTagName}, false).Return(nil, nil).Once()
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.Tag")).Return(errors.New("Create error"))
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.CreateTagInput")).Return(errors.New("Create error"))
err := i.PreImport(testCtx)
assert.NotNil(t, err)

8
pkg/image/import_test.go
View file

@ -251,9 +251,9 @@ func TestImporterPreImportWithMissingTag(t *testing.T) {
}
db.Tag.On("FindByNames", testCtx, []string{missingTagName}, false).Return(nil, nil).Times(3)
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.Tag")).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.Tag)
t.ID = existingTagID
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.CreateTagInput")).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.CreateTagInput)
t.Tag.ID = existingTagID
}).Return(nil)
err := i.PreImport(testCtx)
@ -285,7 +285,7 @@ func TestImporterPreImportWithMissingTagCreateErr(t *testing.T) {
}
db.Tag.On("FindByNames", testCtx, []string{missingTagName}, false).Return(nil, nil).Once()
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.Tag")).Return(errors.New("Create error"))
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.CreateTagInput")).Return(errors.New("Create error"))
err := i.PreImport(testCtx)
assert.NotNil(t, err)

68
pkg/models/mocks/TagReaderWriter.go
View file

@ -101,11 +101,11 @@ func (_m *TagReaderWriter) CountByParentTagID(ctx context.Context, parentID int)
}
// Create provides a mock function with given fields: ctx, newTag
func (_m *TagReaderWriter) Create(ctx context.Context, newTag *models.Tag) error {
func (_m *TagReaderWriter) Create(ctx context.Context, newTag *models.CreateTagInput) error {
ret := _m.Called(ctx, newTag)
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, *models.Tag) error); ok {
if rf, ok := ret.Get(0).(func(context.Context, *models.CreateTagInput) error); ok {
r0 = rf(ctx, newTag)
} else {
r0 = ret.Error(0)
@ -542,6 +542,52 @@ func (_m *TagReaderWriter) GetChildIDs(ctx context.Context, relatedID int) ([]in
return r0, r1
}
// GetCustomFields provides a mock function with given fields: ctx, id
func (_m *TagReaderWriter) GetCustomFields(ctx context.Context, id int) (map[string]interface{}, error) {
ret := _m.Called(ctx, id)
var r0 map[string]interface{}
if rf, ok := ret.Get(0).(func(context.Context, int) map[string]interface{}); ok {
r0 = rf(ctx, id)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(map[string]interface{})
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, int) error); ok {
r1 = rf(ctx, id)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetCustomFieldsBulk provides a mock function with given fields: ctx, ids
func (_m *TagReaderWriter) GetCustomFieldsBulk(ctx context.Context, ids []int) ([]models.CustomFieldMap, error) {
ret := _m.Called(ctx, ids)
var r0 []models.CustomFieldMap
if rf, ok := ret.Get(0).(func(context.Context, []int) []models.CustomFieldMap); ok {
r0 = rf(ctx, ids)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).([]models.CustomFieldMap)
}
}
var r1 error
if rf, ok := ret.Get(1).(func(context.Context, []int) error); ok {
r1 = rf(ctx, ids)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// GetImage provides a mock function with given fields: ctx, tagID
func (_m *TagReaderWriter) GetImage(ctx context.Context, tagID int) ([]byte, error) {
ret := _m.Called(ctx, tagID)
@ -699,12 +745,26 @@ func (_m *TagReaderWriter) QueryForAutoTag(ctx context.Context, words []string)
return r0, r1
}
// SetCustomFields provides a mock function with given fields: ctx, id, fields
func (_m *TagReaderWriter) SetCustomFields(ctx context.Context, id int, fields models.CustomFieldsInput) error {
ret := _m.Called(ctx, id, fields)
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, int, models.CustomFieldsInput) error); ok {
r0 = rf(ctx, id, fields)
} else {
r0 = ret.Error(0)
}
return r0
}
// Update provides a mock function with given fields: ctx, updatedTag
func (_m *TagReaderWriter) Update(ctx context.Context, updatedTag *models.Tag) error {
func (_m *TagReaderWriter) Update(ctx context.Context, updatedTag *models.UpdateTagInput) error {
ret := _m.Called(ctx, updatedTag)
var r0 error
if rf, ok := ret.Get(0).(func(context.Context, *models.Tag) error); ok {
if rf, ok := ret.Get(0).(func(context.Context, *models.UpdateTagInput) error); ok {
r0 = rf(ctx, updatedTag)
} else {
r0 = ret.Error(0)

8
pkg/performer/import_test.go
View file

@ -111,9 +111,9 @@ func TestImporterPreImportWithMissingTag(t *testing.T) {
}
db.Tag.On("FindByNames", testCtx, []string{missingTagName}, false).Return(nil, nil).Times(3)
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.Tag")).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.Tag)
t.ID = existingTagID
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.CreateTagInput")).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.CreateTagInput)
t.Tag.ID = existingTagID
}).Return(nil)
err := i.PreImport(testCtx)
@ -146,7 +146,7 @@ func TestImporterPreImportWithMissingTagCreateErr(t *testing.T) {
}
db.Tag.On("FindByNames", testCtx, []string{missingTagName}, false).Return(nil, nil).Once()
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.Tag")).Return(errors.New("Create error"))
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.CreateTagInput")).Return(errors.New("Create error"))
err := i.PreImport(testCtx)
assert.NotNil(t, err)

8
pkg/scene/import_test.go
View file

@ -508,9 +508,9 @@ func TestImporterPreImportWithMissingTag(t *testing.T) {
}
db.Tag.On("FindByNames", testCtx, []string{missingTagName}, false).Return(nil, nil).Times(3)
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.Tag")).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.Tag)
t.ID = existingTagID
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.CreateTagInput")).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.CreateTagInput)
t.Tag.ID = existingTagID
}).Return(nil)
err := i.PreImport(testCtx)
@ -542,7 +542,7 @@ func TestImporterPreImportWithMissingTagCreateErr(t *testing.T) {
}
db.Tag.On("FindByNames", testCtx, []string{missingTagName}, false).Return(nil, nil).Once()
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.Tag")).Return(errors.New("Create error"))
db.Tag.On("Create", testCtx, mock.AnythingOfType("*models.CreateTagInput")).Return(errors.New("Create error"))
err := i.PreImport(testCtx)
assert.NotNil(t, err)

17
pkg/sqlite/setup_test.go
View file

@ -1709,6 +1709,18 @@ func tagStashID(i int) models.StashID {
}
}
func getTagCustomFields(index int) map[string]interface{} {
if index%5 == 0 {
return nil
}
return map[string]interface{}{
"string": getTagStringValue(index, "custom"),
"int": int64(index % 5),
"real": float64(index) / 10,
}
}
// createTags creates n tags with plain Name and o tags with camel cased NaMe included
func createTags(ctx context.Context, tqb models.TagReaderWriter, n int, o int) error {
const namePlain = "Name"
@ -1736,7 +1748,10 @@ func createTags(ctx context.Context, tqb models.TagReaderWriter, n int, o int) e
})
}
err := tqb.Create(ctx, &tag)
err := tqb.Create(ctx, &models.CreateTagInput{
Tag: &tag,
CustomFields: getTagCustomFields(i),
})
if err != nil {
return fmt.Errorf("Error creating tag %v+: %s", tag, err.Error())

26
pkg/sqlite/tag_test.go
View file

@ -1012,8 +1012,10 @@ func TestTagUpdateTagImage(t *testing.T) {
// create tag to test against
const name = "TestTagUpdateTagImage"
tag := models.Tag{
Name: name,
tag := models.CreateTagInput{
Tag: &models.Tag{
Name: name,
},
}
err := qb.Create(ctx, &tag)
if err != nil {
@ -1032,8 +1034,10 @@ func TestTagUpdateAlias(t *testing.T) {
// create tag to test against
const name = "TestTagUpdateAlias"
tag := models.Tag{
Name: name,
tag := models.CreateTagInput{
Tag: &models.Tag{
Name: name,
},
}
err := qb.Create(ctx, &tag)
if err != nil {
@ -1065,8 +1069,10 @@ func TestTagStashIDs(t *testing.T) {
// create tag to test against
const name = "TestTagStashIDs"
tag := models.Tag{
Name: name,
tag := models.CreateTagInput{
Tag: &models.Tag{
Name: name,
},
}
err := qb.Create(ctx, &tag)
if err != nil {
@ -1089,9 +1095,11 @@ func TestTagFindByStashID(t *testing.T) {
const name = "TestTagFindByStashID"
const stashID = "stashid"
const endpoint = "endpoint"
tag := models.Tag{
Name: name,
StashIDs: models.NewRelatedStashIDs([]models.StashID{{StashID: stashID, Endpoint: endpoint}}),
tag := models.CreateTagInput{
Tag: &models.Tag{
Name: name,
StashIDs: models.NewRelatedStashIDs([]models.StashID{{StashID: stashID, Endpoint: endpoint}}),
},
}
err := qb.Create(ctx, &tag)
if err != nil {

83
pkg/tag/export_test.go
View file

@ -14,12 +14,14 @@ import (
)
const (
tagID = 1
noImageID = 2
errImageID = 3
errAliasID = 4
withParentsID = 5
errParentsID = 6
tagID = iota + 1
customFieldsID
noImageID
errImageID
errAliasID
withParentsID
errParentsID
errCustomFieldsID
)
const (
@ -32,6 +34,11 @@ var (
autoTagIgnored = true
createTime = time.Date(2001, 01, 01, 0, 0, 0, 0, time.UTC)
updateTime = time.Date(2002, 01, 01, 0, 0, 0, 0, time.UTC)
emptyCustomFields = make(map[string]interface{})
customFields = map[string]interface{}{
"customField1": "customValue1",
}
)
func createTag(id int) models.Tag {
@ -47,8 +54,8 @@ func createTag(id int) models.Tag {
}
}
func createJSONTag(aliases []string, image string, parents []string) *jsonschema.Tag {
return &jsonschema.Tag{
func createJSONTag(aliases []string, image string, parents []string, withCustomFields bool) *jsonschema.Tag {
ret := &jsonschema.Tag{
Name: tagName,
SortName: sortName,
Favorite: true,
@ -61,15 +68,23 @@ func createJSONTag(aliases []string, image string, parents []string) *jsonschema
UpdatedAt: json.JSONTime{
Time: updateTime,
},
Image: image,
Parents: parents,
Image: image,
Parents: parents,
CustomFields: emptyCustomFields,
}
if withCustomFields {
ret.CustomFields = customFields
}
return ret
}
type testScenario struct {
tag models.Tag
expected *jsonschema.Tag
err bool
tag models.Tag
customFields map[string]interface{}
expected *jsonschema.Tag
err bool
}
var scenarios []testScenario
@ -78,32 +93,50 @@ func initTestTable() {
scenarios = []testScenario{
{
createTag(tagID),
createJSONTag([]string{"alias"}, image, nil),
emptyCustomFields,
createJSONTag([]string{"alias"}, image, nil, false),
false,
},
{
createTag(customFieldsID),
customFields,
createJSONTag([]string{"alias"}, image, nil, true),
false,
},
{
createTag(noImageID),
createJSONTag(nil, "", nil),
emptyCustomFields,
createJSONTag(nil, "", nil, false),
false,
},
{
createTag(errImageID),
createJSONTag(nil, "", nil),
emptyCustomFields,
createJSONTag(nil, "", nil, false),
// getting the image should not cause an error
false,
},
{
createTag(errAliasID),
emptyCustomFields,
nil,
true,
},
{
createTag(withParentsID),
createJSONTag(nil, image, []string{"parent"}),
emptyCustomFields,
createJSONTag(nil, image, []string{"parent"}, false),
false,
},
{
createTag(errParentsID),
emptyCustomFields,
nil,
true,
},
{
createTag(errCustomFieldsID),
customFields,
nil,
true,
},
@ -118,32 +151,48 @@ func TestToJSON(t *testing.T) {
imageErr := errors.New("error getting image")
aliasErr := errors.New("error getting aliases")
parentsErr := errors.New("error getting parents")
customFieldsErr := errors.New("error getting custom fields")
db.Tag.On("GetAliases", testCtx, tagID).Return([]string{"alias"}, nil).Once()
db.Tag.On("GetAliases", testCtx, customFieldsID).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()
db.Tag.On("GetAliases", testCtx, errCustomFieldsID).Return(nil, nil).Once()
db.Tag.On("GetStashIDs", testCtx, tagID).Return(nil, nil).Once()
db.Tag.On("GetStashIDs", testCtx, customFieldsID).Return(nil, nil).Once()
db.Tag.On("GetStashIDs", testCtx, noImageID).Return(nil, nil).Once()
db.Tag.On("GetStashIDs", testCtx, errImageID).Return(nil, nil).Once()
// errAliasID test fails before GetStashIDs is called, so no mock needed
db.Tag.On("GetStashIDs", testCtx, withParentsID).Return(nil, nil).Once()
db.Tag.On("GetStashIDs", testCtx, errParentsID).Return(nil, nil).Once()
db.Tag.On("GetStashIDs", testCtx, errCustomFieldsID).Return(nil, nil).Once()
db.Tag.On("GetImage", testCtx, tagID).Return(imageBytes, nil).Once()
db.Tag.On("GetImage", testCtx, customFieldsID).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()
db.Tag.On("GetImage", testCtx, errCustomFieldsID).Return(nil, nil).Once()
db.Tag.On("FindByChildTagID", testCtx, tagID).Return(nil, nil).Once()
db.Tag.On("FindByChildTagID", testCtx, customFieldsID).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()
db.Tag.On("FindByChildTagID", testCtx, errCustomFieldsID).Return(nil, nil).Once()
db.Tag.On("GetCustomFields", testCtx, tagID).Return(emptyCustomFields, nil).Once()
db.Tag.On("GetCustomFields", testCtx, customFieldsID).Return(customFields, nil).Once()
db.Tag.On("GetCustomFields", testCtx, noImageID).Return(emptyCustomFields, nil).Once()
db.Tag.On("GetCustomFields", testCtx, errImageID).Return(emptyCustomFields, nil).Once()
db.Tag.On("GetCustomFields", testCtx, withParentsID).Return(emptyCustomFields, nil).Once()
db.Tag.On("GetCustomFields", testCtx, errCustomFieldsID).Return(nil, customFieldsErr).Once()
for i, s := range scenarios {
tag := s.tag

34
pkg/tag/import_test.go
View file

@ -154,14 +154,14 @@ func TestImporterPostImportParentMissing(t *testing.T) {
db.Tag.On("UpdateParentTags", testCtx, ignoreID, emptyParents).Return(nil).Once()
db.Tag.On("UpdateParentTags", testCtx, ignoreFoundID, []int{103}).Return(nil).Once()
db.Tag.On("Create", testCtx, mock.MatchedBy(func(t *models.Tag) bool {
return t.Name == "Create"
db.Tag.On("Create", testCtx, mock.MatchedBy(func(input *models.CreateTagInput) bool {
return input.Tag.Name == "Create"
})).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.Tag)
t.ID = 100
input := args.Get(1).(*models.CreateTagInput)
input.Tag.ID = 100
}).Return(nil).Once()
db.Tag.On("Create", testCtx, mock.MatchedBy(func(t *models.Tag) bool {
return t.Name == "CreateError"
db.Tag.On("Create", testCtx, mock.MatchedBy(func(input *models.CreateTagInput) bool {
return input.Tag.Name == "CreateError"
})).Return(errors.New("failed creating parent")).Once()
i.MissingRefBehaviour = models.ImportMissingRefEnumCreate
@ -261,11 +261,15 @@ func TestCreate(t *testing.T) {
}
errCreate := errors.New("Create error")
db.Tag.On("Create", testCtx, &tag).Run(func(args mock.Arguments) {
t := args.Get(1).(*models.Tag)
t.ID = tagID
db.Tag.On("Create", testCtx, mock.MatchedBy(func(input *models.CreateTagInput) bool {
return input.Tag.Name == tag.Name
})).Run(func(args mock.Arguments) {
input := args.Get(1).(*models.CreateTagInput)
input.Tag.ID = tagID
}).Return(nil).Once()
db.Tag.On("Create", testCtx, &tagErr).Return(errCreate).Once()
db.Tag.On("Create", testCtx, mock.MatchedBy(func(input *models.CreateTagInput) bool {
return input.Tag.Name == tagErr.Name
})).Return(errCreate).Once()
id, err := i.Create(testCtx)
assert.Equal(t, tagID, *id)
@ -299,7 +303,10 @@ func TestUpdate(t *testing.T) {
// id needs to be set for the mock input
tag.ID = tagID
db.Tag.On("Update", testCtx, &tag).Return(nil).Once()
tagInput := models.UpdateTagInput{
Tag: &tag,
}
db.Tag.On("Update", testCtx, &tagInput).Return(nil).Once()
err := i.Update(testCtx, tagID)
assert.Nil(t, err)
@ -308,7 +315,10 @@ func TestUpdate(t *testing.T) {
// need to set id separately
tagErr.ID = errImageID
db.Tag.On("Update", testCtx, &tagErr).Return(errUpdate).Once()
errInput := models.UpdateTagInput{
Tag: &tagErr,
}
db.Tag.On("Update", testCtx, &errInput).Return(errUpdate).Once()
err = i.Update(testCtx, errImageID)
assert.NotNil(t, err)