mirror of
https://github.com/stashapp/stash.git
synced 2025-12-17 20:34:37 +03:00
Fix performer validation (#4248)
* Fix performer validation * Add tests * Rename QueryCount argument * Minor refactoring * Add duplicate alias validation * Make UI alias validation also case-insensitive
This commit is contained in:
DingDongSoLong4
@@ -4,58 +4,310 @@ import (
|
||||
"testing"
|
||||
|
||||
"github.com/stashapp/stash/pkg/models"
|
||||
"github.com/stashapp/stash/pkg/models/mocks"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/mock"
|
||||
)
|
||||
|
||||
func TestValidateDeathDate(t *testing.T) {
|
||||
assert := assert.New(t)
|
||||
|
||||
date1 := "2001-01-01"
|
||||
date2 := "2002-01-01"
|
||||
date3 := "2003-01-01"
|
||||
date4 := "2004-01-01"
|
||||
empty := ""
|
||||
|
||||
md2, _ := models.ParseDate(date2)
|
||||
md3, _ := models.ParseDate(date3)
|
||||
|
||||
emptyPerformer := models.Performer{}
|
||||
invalidPerformer := models.Performer{
|
||||
Birthdate: &md3,
|
||||
DeathDate: &md2,
|
||||
func nameFilter(n string) *models.PerformerFilterType {
|
||||
return &models.PerformerFilterType{
|
||||
Name: &models.StringCriterionInput{
|
||||
Value: n,
|
||||
Modifier: models.CriterionModifierEquals,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func disambigFilter(n string, d string) *models.PerformerFilterType {
|
||||
return &models.PerformerFilterType{
|
||||
Name: &models.StringCriterionInput{
|
||||
Value: n,
|
||||
Modifier: models.CriterionModifierEquals,
|
||||
},
|
||||
Disambiguation: &models.StringCriterionInput{
|
||||
Value: d,
|
||||
Modifier: models.CriterionModifierEquals,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateName(t *testing.T) {
|
||||
db := mocks.NewDatabase()
|
||||
|
||||
const (
|
||||
name1 = "name 1"
|
||||
name2 = "name 2"
|
||||
disambig = "disambiguation"
|
||||
newName = "new name"
|
||||
newDisambig = "new disambiguation"
|
||||
)
|
||||
// existing1 := models.Performer{
|
||||
// Name: name1,
|
||||
// }
|
||||
// existing2 := models.Performer{
|
||||
// Name: name2,
|
||||
// Disambiguation: disambig,
|
||||
// }
|
||||
|
||||
pp := 1
|
||||
findFilter := &models.FindFilterType{
|
||||
PerPage: &pp,
|
||||
}
|
||||
|
||||
db.Performer.On("QueryCount", testCtx, nameFilter(name1), findFilter).Return(1, nil)
|
||||
db.Performer.On("QueryCount", testCtx, nameFilter(name2), findFilter).Return(1, nil)
|
||||
db.Performer.On("QueryCount", testCtx, disambigFilter(name2, disambig), findFilter).Return(1, nil)
|
||||
db.Performer.On("QueryCount", testCtx, mock.Anything, findFilter).Return(0, nil)
|
||||
|
||||
tests := []struct {
|
||||
tName string
|
||||
name string
|
||||
disambig string
|
||||
want error
|
||||
}{
|
||||
{"missing name", "", newDisambig, ErrNameMissing},
|
||||
{"new name", newName, "", nil},
|
||||
{"new name new disambig", newName, newDisambig, nil},
|
||||
{"new name existing disambig", newName, disambig, nil},
|
||||
{"existing name", name1, "", &NameExistsError{name1, ""}},
|
||||
{"existing name new disambig", name1, newDisambig, nil},
|
||||
{"existing name existing disambig", name1, disambig, nil},
|
||||
{"existing name and disambig", name2, disambig, &NameExistsError{name2, disambig}},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.tName, func(t *testing.T) {
|
||||
got := ValidateName(testCtx, tt.name, tt.disambig, db.Performer)
|
||||
assert.Equal(t, tt.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateUpdateName(t *testing.T) {
|
||||
db := mocks.NewDatabase()
|
||||
|
||||
const (
|
||||
name1 = "name 1"
|
||||
name2 = "name 2"
|
||||
disambig1 = "disambiguation 1"
|
||||
disambig2 = "disambiguation 2"
|
||||
newName = "new name"
|
||||
newDisambig = "new disambiguation"
|
||||
)
|
||||
|
||||
osUnset := models.OptionalString{}
|
||||
osNull := models.OptionalString{Set: true, Null: true}
|
||||
osName1 := models.NewOptionalString(name1)
|
||||
osName2 := models.NewOptionalString(name2)
|
||||
osDisambig1 := models.NewOptionalString(disambig1)
|
||||
osDisambig2 := models.NewOptionalString(disambig2)
|
||||
osNewName := models.NewOptionalString(newName)
|
||||
osNewDisambig := models.NewOptionalString(newDisambig)
|
||||
|
||||
existing1 := models.Performer{
|
||||
ID: 1,
|
||||
Name: name1,
|
||||
}
|
||||
existing2 := models.Performer{
|
||||
ID: 2,
|
||||
Name: name2,
|
||||
Disambiguation: disambig1,
|
||||
}
|
||||
existing3 := models.Performer{
|
||||
ID: 3,
|
||||
Name: name2,
|
||||
Disambiguation: disambig2,
|
||||
}
|
||||
|
||||
pp := 2
|
||||
findFilter := &models.FindFilterType{
|
||||
PerPage: &pp,
|
||||
}
|
||||
|
||||
db.Performer.On("Query", testCtx, nameFilter(name1), findFilter).Return([]*models.Performer{&existing1}, 1, nil)
|
||||
db.Performer.On("Query", testCtx, nameFilter(name2), findFilter).Return([]*models.Performer{&existing2, &existing3}, 2, nil)
|
||||
db.Performer.On("Query", testCtx, disambigFilter(name2, disambig1), findFilter).Return([]*models.Performer{&existing2}, 1, nil)
|
||||
db.Performer.On("Query", testCtx, disambigFilter(name2, disambig2), findFilter).Return([]*models.Performer{&existing3}, 1, nil)
|
||||
db.Performer.On("Query", testCtx, mock.Anything, findFilter).Return(nil, 0, nil)
|
||||
|
||||
tests := []struct {
|
||||
tName string
|
||||
performer models.Performer
|
||||
name models.OptionalString
|
||||
disambig models.OptionalString
|
||||
want error
|
||||
}{
|
||||
{"missing name", existing1, osNull, osUnset, ErrNameMissing},
|
||||
{"same name", existing3, osName2, osUnset, nil},
|
||||
{"same disambig", existing2, osUnset, osDisambig1, nil},
|
||||
{"same name same disambig", existing2, osName2, osDisambig1, nil},
|
||||
{"new name", existing1, osNewName, osUnset, nil},
|
||||
{"new disambig", existing1, osUnset, osNewDisambig, nil},
|
||||
{"new name new disambig", existing1, osNewName, osNewDisambig, nil},
|
||||
{"remove disambig", existing3, osUnset, osNull, &NameExistsError{name2, ""}},
|
||||
{"existing name keep disambig", existing3, osName1, osUnset, nil},
|
||||
{"existing name remove disambig", existing3, osName1, osNull, &NameExistsError{name1, ""}},
|
||||
{"existing disambig", existing2, osUnset, osDisambig2, &NameExistsError{name2, disambig2}},
|
||||
{"existing name and disambig", existing1, osName2, osDisambig1, &NameExistsError{name2, disambig1}},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.tName, func(t *testing.T) {
|
||||
got := ValidateUpdateName(testCtx, tt.performer, tt.name, tt.disambig, db.Performer)
|
||||
assert.Equal(t, tt.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateAliases(t *testing.T) {
|
||||
const (
|
||||
name1 = "name 1"
|
||||
name1U = "NAME 1"
|
||||
name2 = "name 2"
|
||||
name3 = "name 3"
|
||||
name4 = "name 4"
|
||||
)
|
||||
|
||||
tests := []struct {
|
||||
tName string
|
||||
name string
|
||||
aliases []string
|
||||
want error
|
||||
}{
|
||||
{"no aliases", name1, nil, nil},
|
||||
{"valid aliases", name2, []string{name3, name4}, nil},
|
||||
{"duplicate alias", name1, []string{name2, name3, name2}, &DuplicateAliasError{name2}},
|
||||
{"duplicate name", name4, []string{name4, name3}, &DuplicateAliasError{name4}},
|
||||
{"duplicate alias caps", name2, []string{name1, name1U}, &DuplicateAliasError{name1U}},
|
||||
{"duplicate name caps", name1U, []string{name1}, &DuplicateAliasError{name1}},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.tName, func(t *testing.T) {
|
||||
got := ValidateAliases(tt.name, models.NewRelatedStrings(tt.aliases))
|
||||
assert.Equal(t, tt.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateUpdateAliases(t *testing.T) {
|
||||
const (
|
||||
name1 = "name 1"
|
||||
name1U = "NAME 1"
|
||||
name2 = "name 2"
|
||||
name3 = "name 3"
|
||||
name4 = "name 4"
|
||||
)
|
||||
|
||||
existing := models.Performer{
|
||||
Name: name1,
|
||||
Aliases: models.NewRelatedStrings([]string{name2}),
|
||||
}
|
||||
|
||||
osUnset := models.OptionalString{}
|
||||
os1 := models.NewOptionalString(name1)
|
||||
os2 := models.NewOptionalString(name2)
|
||||
os3 := models.NewOptionalString(name3)
|
||||
os4 := models.NewOptionalString(name4)
|
||||
|
||||
tests := []struct {
|
||||
tName string
|
||||
name models.OptionalString
|
||||
aliases []string
|
||||
want error
|
||||
}{
|
||||
{"both unset", osUnset, nil, nil},
|
||||
{"invalid name set", os2, nil, &DuplicateAliasError{name2}},
|
||||
{"valid name set", os3, nil, nil},
|
||||
{"valid aliases empty", os1, []string{}, nil},
|
||||
{"invalid aliases set", osUnset, []string{name1U}, &DuplicateAliasError{name1U}},
|
||||
{"valid aliases set", osUnset, []string{name3, name2}, nil},
|
||||
{"invalid both set", os4, []string{name4}, &DuplicateAliasError{name4}},
|
||||
{"valid both set", os2, []string{name1}, nil},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.tName, func(t *testing.T) {
|
||||
var aliases *models.UpdateStrings
|
||||
if tt.aliases != nil {
|
||||
aliases = &models.UpdateStrings{
|
||||
Values: tt.aliases,
|
||||
Mode: models.RelationshipUpdateModeSet,
|
||||
}
|
||||
}
|
||||
got := ValidateUpdateAliases(existing, tt.name, aliases)
|
||||
assert.Equal(t, tt.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateDeathDate(t *testing.T) {
|
||||
date1, _ := models.ParseDate("2001-01-01")
|
||||
date2, _ := models.ParseDate("2002-01-01")
|
||||
date3, _ := models.ParseDate("2003-01-01")
|
||||
date4, _ := models.ParseDate("2004-01-01")
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
birthdate *models.Date
|
||||
deathdate *models.Date
|
||||
want error
|
||||
}{
|
||||
{"both nil", nil, nil, nil},
|
||||
{"birthdate nil", nil, &date1, nil},
|
||||
{"deathdate nil", nil, &date2, nil},
|
||||
{"valid", &date3, &date4, nil},
|
||||
{"invalid", &date3, &date2, &DeathDateError{date3, date2}},
|
||||
{"same date", &date1, &date1, nil},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got := ValidateDeathDate(tt.birthdate, tt.deathdate)
|
||||
assert.Equal(t, tt.want, got)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestValidateUpdateDeathDate(t *testing.T) {
|
||||
date1, _ := models.ParseDate("2001-01-01")
|
||||
date2, _ := models.ParseDate("2002-01-01")
|
||||
date3, _ := models.ParseDate("2003-01-01")
|
||||
date4, _ := models.ParseDate("2004-01-01")
|
||||
|
||||
existing := models.Performer{
|
||||
Birthdate: &date2,
|
||||
DeathDate: &date3,
|
||||
}
|
||||
|
||||
odUnset := models.OptionalDate{}
|
||||
odNull := models.OptionalDate{Set: true, Null: true}
|
||||
od1 := models.NewOptionalDate(date1)
|
||||
od2 := models.NewOptionalDate(date2)
|
||||
od3 := models.NewOptionalDate(date3)
|
||||
od4 := models.NewOptionalDate(date4)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
birthdate models.OptionalDate
|
||||
deathdate models.OptionalDate
|
||||
want error
|
||||
}{
|
||||
{"both unset", odUnset, odUnset, nil},
|
||||
{"invalid birthdate set", od4, odUnset, &DeathDateError{date4, date3}},
|
||||
{"valid birthdate set", od1, odUnset, nil},
|
||||
{"valid birthdate set null", odNull, odUnset, nil},
|
||||
{"invalid deathdate set", odUnset, od1, &DeathDateError{date2, date1}},
|
||||
{"valid deathdate set", odUnset, od4, nil},
|
||||
{"valid deathdate set null", odUnset, odNull, nil},
|
||||
{"invalid both set", od3, od2, &DeathDateError{date3, date2}},
|
||||
{"valid both set", od2, od3, nil},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
got := ValidateUpdateDeathDate(existing, tt.birthdate, tt.deathdate)
|
||||
assert.Equal(t, tt.want, got)
|
||||
})
|
||||
}
|
||||
validPerformer := models.Performer{
|
||||
Birthdate: &md2,
|
||||
DeathDate: &md3,
|
||||
}
|
||||
|
||||
// nil values should always return nil
|
||||
assert.Nil(ValidateDeathDate(nil, nil, &date1))
|
||||
assert.Nil(ValidateDeathDate(nil, &date2, nil))
|
||||
assert.Nil(ValidateDeathDate(&emptyPerformer, nil, &date1))
|
||||
assert.Nil(ValidateDeathDate(&emptyPerformer, &date2, nil))
|
||||
|
||||
// empty strings should always return nil
|
||||
assert.Nil(ValidateDeathDate(nil, &empty, &date1))
|
||||
assert.Nil(ValidateDeathDate(nil, &date2, &empty))
|
||||
assert.Nil(ValidateDeathDate(&emptyPerformer, &empty, &date1))
|
||||
assert.Nil(ValidateDeathDate(&emptyPerformer, &date2, &empty))
|
||||
assert.Nil(ValidateDeathDate(&validPerformer, &empty, &date1))
|
||||
assert.Nil(ValidateDeathDate(&validPerformer, &date2, &empty))
|
||||
|
||||
// nil inputs should return nil even if performer is invalid
|
||||
assert.Nil(ValidateDeathDate(&invalidPerformer, nil, nil))
|
||||
|
||||
// invalid input values should return error
|
||||
assert.NotNil(ValidateDeathDate(nil, &date2, &date1))
|
||||
assert.NotNil(ValidateDeathDate(&validPerformer, &date2, &date1))
|
||||
|
||||
// valid input values should return nil
|
||||
assert.Nil(ValidateDeathDate(nil, &date1, &date2))
|
||||
|
||||
// use performer values if performer set and values available
|
||||
assert.NotNil(ValidateDeathDate(&validPerformer, nil, &date1))
|
||||
assert.NotNil(ValidateDeathDate(&validPerformer, &date4, nil))
|
||||
assert.Nil(ValidateDeathDate(&validPerformer, nil, &date4))
|
||||
assert.Nil(ValidateDeathDate(&validPerformer, &date1, nil))
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user