golang/repo-pattern
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Tests

Browse Source
This commit is contained in:
Eden Kirin
2024-06-22 23:48:42 +02:00
parent 35082b1f6a
commit 6e31c8eb98
1 changed files with 543 additions and 212 deletions
Download Patch File Download Diff File Expand all files Collapse all files

755
app/repository/smartfilter/handlers_test.go
View File

@ -34,246 +34,577 @@ type MyModel struct {
Value string Value string
} }
func (m MyModel) TableName() string {
return "my_models"
}
type TestCase struct {
name string
filterField FilterField
expected string
}
var (
boolTrue bool = true
boolFalse bool = false
int64Value int64 = -123456
uint64Value uint64 = 123456
floatValue float64 = -123456.789
strValue string = "Some Value"
boolValues = []bool{true, false}
int64Values = []int64{-123456, 1, 123456}
uint64Values = []uint64{123456, 1234567, 1234568}
floatValues = []float64{-123456.789, -1, 123456.789}
strValues = []string{"First Value", "Second Value", "Third Value"}
)
func TestHandleOperatorEQ(t *testing.T) { func TestHandleOperatorEQ(t *testing.T) {
db, _ := NewMockDB() db, _ := NewMockDB()
testFunc := handleOperatorEQ testFunc := handleOperatorEQ
t.Run("Test handleOperatorEQ bool true", func(t *testing.T) { testCases := []TestCase{
var value bool = true {
filterField := FilterField{ name: "handleOperatorEQ bool true",
Name: "my_field", filterField: FilterField{
boolValue: &value, Name: "my_field",
valueKind: reflect.Bool, boolValue: &boolTrue,
} valueKind: reflect.Bool,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field = true ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorEQ bool false",
filterField: FilterField{
Name: "my_field",
boolValue: &boolFalse,
valueKind: reflect.Bool,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field = false ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorEQ int64",
filterField: FilterField{
Name: "my_field",
intValue: &int64Value,
valueKind: reflect.Int64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field = -123456 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorEQ uint64",
filterField: FilterField{
Name: "my_field",
uintValue: &uint64Value,
valueKind: reflect.Uint64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field = 123456 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorEQ float",
filterField: FilterField{
Name: "my_field",
floatValue: &floatValue,
valueKind: reflect.Float64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field = -123456.789 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorEQ string",
filterField: FilterField{
Name: "my_field",
strValue: &strValue,
valueKind: reflect.String,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field = 'Some Value' ORDER BY `my_models`.`id` LIMIT 1",
},
}
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB { for _, testCase := range testCases {
query := tx.Model(&MyModel{}) t.Run(testCase.name, func(t *testing.T) {
query = testFunc(query, "my_table", &filterField) sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
return query.First(&MyModel{}) query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &testCase.filterField)
return query.First(&MyModel{})
})
assert.Equal(t, testCase.expected, sql)
}) })
assert.Equal(t, "SELECT * FROM `my_models` WHERE my_table.my_field = true ORDER BY `my_models`.`id` LIMIT 1", sql) }
})
t.Run("Test handleOperatorEQ bool false", func(t *testing.T) {
var value bool = false
filterField := FilterField{
Name: "my_field",
boolValue: &value,
valueKind: reflect.Bool,
}
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &filterField)
return query.First(&MyModel{})
})
assert.Equal(t, "SELECT * FROM `my_models` WHERE my_table.my_field = false ORDER BY `my_models`.`id` LIMIT 1", sql)
})
t.Run("Test handleOperatorEQ int64", func(t *testing.T) {
var value int64 = -123456
filterField := FilterField{
Name: "my_field",
intValue: &value,
valueKind: reflect.Int64,
}
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &filterField)
return query.First(&MyModel{})
})
assert.Equal(t, "SELECT * FROM `my_models` WHERE my_table.my_field = -123456 ORDER BY `my_models`.`id` LIMIT 1", sql)
})
t.Run("Test handleOperatorEQ uint64", func(t *testing.T) {
var value uint64 = 123456
filterField := FilterField{
Name: "my_field",
uintValue: &value,
valueKind: reflect.Uint64,
}
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &filterField)
return query.First(&MyModel{})
})
assert.Equal(t, "SELECT * FROM `my_models` WHERE my_table.my_field = 123456 ORDER BY `my_models`.`id` LIMIT 1", sql)
})
t.Run("Test handleOperatorEQ float", func(t *testing.T) {
var value float64 = -123456.789
filterField := FilterField{
Name: "my_field",
floatValue: &value,
valueKind: reflect.Float64,
}
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &filterField)
return query.First(&MyModel{})
})
assert.Equal(t, "SELECT * FROM `my_models` WHERE my_table.my_field = -123456.789 ORDER BY `my_models`.`id` LIMIT 1", sql)
})
t.Run("Test handleOperatorEQ string", func(t *testing.T) {
var value string = "Some Value"
filterField := FilterField{
Name: "my_field",
strValue: &value,
valueKind: reflect.String,
}
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &filterField)
return query.First(&MyModel{})
})
assert.Equal(t, "SELECT * FROM `my_models` WHERE my_table.my_field = 'Some Value' ORDER BY `my_models`.`id` LIMIT 1", sql)
})
} }
func TestHandleOperatorNE(t *testing.T) { func TestHandleOperatorNE(t *testing.T) {
db, _ := NewMockDB() db, _ := NewMockDB()
testFunc := handleOperatorNE testFunc := handleOperatorNE
t.Run("Test handleOperatorNE bool true", func(t *testing.T) { testCases := []TestCase{
var value bool = true {
filterField := FilterField{ name: "handleOperatorNE bool true",
Name: "my_field", filterField: FilterField{
boolValue: &value, Name: "my_field",
valueKind: reflect.Bool, boolValue: &boolTrue,
} valueKind: reflect.Bool,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field != true ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorNE bool false",
filterField: FilterField{
Name: "my_field",
boolValue: &boolFalse,
valueKind: reflect.Bool,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field != false ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorNE int64",
filterField: FilterField{
Name: "my_field",
intValue: &int64Value,
valueKind: reflect.Int64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field != -123456 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorNE uint64",
filterField: FilterField{
Name: "my_field",
uintValue: &uint64Value,
valueKind: reflect.Uint64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field != 123456 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorNE float",
filterField: FilterField{
Name: "my_field",
floatValue: &floatValue,
valueKind: reflect.Float64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field != -123456.789 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorNE string",
filterField: FilterField{
Name: "my_field",
strValue: &strValue,
valueKind: reflect.String,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field != 'Some Value' ORDER BY `my_models`.`id` LIMIT 1",
},
}
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB { for _, testCase := range testCases {
query := tx.Model(&MyModel{}) t.Run(testCase.name, func(t *testing.T) {
query = testFunc(query, "my_table", &filterField) sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
return query.First(&MyModel{}) query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &testCase.filterField)
return query.First(&MyModel{})
})
assert.Equal(t, testCase.expected, sql)
}) })
assert.Equal(t, "SELECT * FROM `my_models` WHERE my_table.my_field != true ORDER BY `my_models`.`id` LIMIT 1", sql) }
})
t.Run("Test handleOperatorNE bool false", func(t *testing.T) {
var value bool = false
filterField := FilterField{
Name: "my_field",
boolValue: &value,
valueKind: reflect.Bool,
}
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &filterField)
return query.First(&MyModel{})
})
assert.Equal(t, "SELECT * FROM `my_models` WHERE my_table.my_field != false ORDER BY `my_models`.`id` LIMIT 1", sql)
})
t.Run("Test handleOperatorNE int64", func(t *testing.T) {
var value int64 = -123456
filterField := FilterField{
Name: "my_field",
intValue: &value,
valueKind: reflect.Int64,
}
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &filterField)
return query.First(&MyModel{})
})
assert.Equal(t, "SELECT * FROM `my_models` WHERE my_table.my_field != -123456 ORDER BY `my_models`.`id` LIMIT 1", sql)
})
t.Run("Test handleOperatorNE uint64", func(t *testing.T) {
var value uint64 = 123456
filterField := FilterField{
Name: "my_field",
uintValue: &value,
valueKind: reflect.Uint64,
}
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &filterField)
return query.First(&MyModel{})
})
assert.Equal(t, "SELECT * FROM `my_models` WHERE my_table.my_field != 123456 ORDER BY `my_models`.`id` LIMIT 1", sql)
})
t.Run("Test handleOperatorNE float", func(t *testing.T) {
var value float64 = -123456.789
filterField := FilterField{
Name: "my_field",
floatValue: &value,
valueKind: reflect.Float64,
}
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &filterField)
return query.First(&MyModel{})
})
assert.Equal(t, "SELECT * FROM `my_models` WHERE my_table.my_field != -123456.789 ORDER BY `my_models`.`id` LIMIT 1", sql)
})
t.Run("Test handleOperatorNE string", func(t *testing.T) {
var value string = "Some Value"
filterField := FilterField{
Name: "my_field",
strValue: &value,
valueKind: reflect.String,
}
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &filterField)
return query.First(&MyModel{})
})
assert.Equal(t, "SELECT * FROM `my_models` WHERE my_table.my_field != 'Some Value' ORDER BY `my_models`.`id` LIMIT 1", sql)
})
} }
func TestHandleOperatorLIKE(t *testing.T) { func TestHandleOperatorLIKE(t *testing.T) {
db, _ := NewMockDB() db, _ := NewMockDB()
testFunc := handleOperatorLIKE testFunc := handleOperatorLIKE
t.Run("Test handleOperatorLIKE", func(t *testing.T) { testCases := []TestCase{
var value string = "Some Value" {
filterField := FilterField{ name: "handleOperatorLIKE",
Name: "my_field", filterField: FilterField{
strValue: &value, Name: "my_field",
valueKind: reflect.String, strValue: &strValue,
} valueKind: reflect.String,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field LIKE '%Some Value%' ORDER BY `my_models`.`id` LIMIT 1",
},
}
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB { for _, testCase := range testCases {
query := tx.Model(&MyModel{}) t.Run(testCase.name, func(t *testing.T) {
query = testFunc(query, "my_table", &filterField) sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
return query.First(&MyModel{}) query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &testCase.filterField)
return query.First(&MyModel{})
})
assert.Equal(t, testCase.expected, sql)
}) })
assert.Equal(t, "SELECT * FROM `my_models` WHERE my_table.my_field LIKE '%Some Value%' ORDER BY `my_models`.`id` LIMIT 1", sql) }
})
} }
func TestHandleOperatorILIKE(t *testing.T) { func TestHandleOperatorILIKE(t *testing.T) {
db, _ := NewMockDB() db, _ := NewMockDB()
testFunc := handleOperatorILIKE testFunc := handleOperatorILIKE
t.Run("Test handleOperatorLIKE", func(t *testing.T) { testCases := []TestCase{
var value string = "Some Value" {
filterField := FilterField{ name: "handleOperatorILIKE",
Name: "my_field", filterField: FilterField{
strValue: &value, Name: "my_field",
valueKind: reflect.String, strValue: &strValue,
} valueKind: reflect.String,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field ILIKE '%Some Value%' ORDER BY `my_models`.`id` LIMIT 1",
},
}
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB { for _, testCase := range testCases {
query := tx.Model(&MyModel{}) t.Run(testCase.name, func(t *testing.T) {
query = testFunc(query, "my_table", &filterField) sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
return query.First(&MyModel{}) query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &testCase.filterField)
return query.First(&MyModel{})
})
assert.Equal(t, testCase.expected, sql)
}) })
assert.Equal(t, "SELECT * FROM `my_models` WHERE my_table.my_field ILIKE '%Some Value%' ORDER BY `my_models`.`id` LIMIT 1", sql) }
}) }
func TestHandleOperatorGT(t *testing.T) {
db, _ := NewMockDB()
testFunc := handleOperatorGT
testCases := []TestCase{
{
name: "handleOperatorGT int64",
filterField: FilterField{
Name: "my_field",
intValue: &int64Value,
valueKind: reflect.Int64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field > -123456 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorGT uint64",
filterField: FilterField{
Name: "my_field",
uintValue: &uint64Value,
valueKind: reflect.Uint64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field > 123456 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorGT float",
filterField: FilterField{
Name: "my_field",
floatValue: &floatValue,
valueKind: reflect.Float64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field > -123456.789 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorGT string",
filterField: FilterField{
Name: "my_field",
strValue: &strValue,
valueKind: reflect.String,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field > 'Some Value' ORDER BY `my_models`.`id` LIMIT 1",
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &testCase.filterField)
return query.First(&MyModel{})
})
assert.Equal(t, testCase.expected, sql)
})
}
}
func TestHandleOperatorGE(t *testing.T) {
db, _ := NewMockDB()
testFunc := handleOperatorGE
testCases := []TestCase{
{
name: "handleOperatorGE int64",
filterField: FilterField{
Name: "my_field",
intValue: &int64Value,
valueKind: reflect.Int64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field >= -123456 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorGE uint64",
filterField: FilterField{
Name: "my_field",
uintValue: &uint64Value,
valueKind: reflect.Uint64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field >= 123456 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorGE float",
filterField: FilterField{
Name: "my_field",
floatValue: &floatValue,
valueKind: reflect.Float64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field >= -123456.789 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorGE string",
filterField: FilterField{
Name: "my_field",
strValue: &strValue,
valueKind: reflect.String,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field >= 'Some Value' ORDER BY `my_models`.`id` LIMIT 1",
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &testCase.filterField)
return query.First(&MyModel{})
})
assert.Equal(t, testCase.expected, sql)
})
}
}
func TestHandleOperatorLT(t *testing.T) {
db, _ := NewMockDB()
testFunc := handleOperatorLT
testCases := []TestCase{
{
name: "handleOperatorLT int64",
filterField: FilterField{
Name: "my_field",
intValue: &int64Value,
valueKind: reflect.Int64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field < -123456 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorLT uint64",
filterField: FilterField{
Name: "my_field",
uintValue: &uint64Value,
valueKind: reflect.Uint64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field < 123456 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorLT float",
filterField: FilterField{
Name: "my_field",
floatValue: &floatValue,
valueKind: reflect.Float64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field < -123456.789 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorLT string",
filterField: FilterField{
Name: "my_field",
strValue: &strValue,
valueKind: reflect.String,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field < 'Some Value' ORDER BY `my_models`.`id` LIMIT 1",
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &testCase.filterField)
return query.First(&MyModel{})
})
assert.Equal(t, testCase.expected, sql)
})
}
}
func TestHandleOperatorLE(t *testing.T) {
db, _ := NewMockDB()
testFunc := handleOperatorLE
testCases := []TestCase{
{
name: "handleOperatorLE int64",
filterField: FilterField{
Name: "my_field",
intValue: &int64Value,
valueKind: reflect.Int64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field <= -123456 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorLE uint64",
filterField: FilterField{
Name: "my_field",
uintValue: &uint64Value,
valueKind: reflect.Uint64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field <= 123456 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorLE float",
filterField: FilterField{
Name: "my_field",
floatValue: &floatValue,
valueKind: reflect.Float64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field <= -123456.789 ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorLE string",
filterField: FilterField{
Name: "my_field",
strValue: &strValue,
valueKind: reflect.String,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field <= 'Some Value' ORDER BY `my_models`.`id` LIMIT 1",
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &testCase.filterField)
return query.First(&MyModel{})
})
assert.Equal(t, testCase.expected, sql)
})
}
}
func TestHandleOperatorIN(t *testing.T) {
db, _ := NewMockDB()
testFunc := handleOperatorIN
testCases := []TestCase{
{
name: "handleOperatorIN bool",
filterField: FilterField{
Name: "my_field",
boolValues: &boolValues,
valueKind: reflect.Bool,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field IN (true,false) ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorIN int64",
filterField: FilterField{
Name: "my_field",
intValues: &int64Values,
valueKind: reflect.Int64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field IN (-123456,1,123456) ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorIN uint64",
filterField: FilterField{
Name: "my_field",
uintValues: &uint64Values,
valueKind: reflect.Uint64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field IN (123456,1234567,1234568) ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorIN float",
filterField: FilterField{
Name: "my_field",
floatValues: &floatValues,
valueKind: reflect.Float64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field IN (-123456.789,-1,123456.789) ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorIN string",
filterField: FilterField{
Name: "my_field",
strValues: &strValues,
valueKind: reflect.String,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field IN ('First Value','Second Value','Third Value') ORDER BY `my_models`.`id` LIMIT 1",
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &testCase.filterField)
return query.First(&MyModel{})
})
assert.Equal(t, testCase.expected, sql)
})
}
}
func TestHandleOperatorNOT_IN(t *testing.T) {
db, _ := NewMockDB()
testFunc := handleOperatorNOT_IN
testCases := []TestCase{
{
name: "handleOperatorNOT_IN bool",
filterField: FilterField{
Name: "my_field",
boolValues: &boolValues,
valueKind: reflect.Bool,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field NOT IN (true,false) ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorNOT_IN int64",
filterField: FilterField{
Name: "my_field",
intValues: &int64Values,
valueKind: reflect.Int64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field NOT IN (-123456,1,123456) ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorNOT_IN uint64",
filterField: FilterField{
Name: "my_field",
uintValues: &uint64Values,
valueKind: reflect.Uint64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field NOT IN (123456,1234567,1234568) ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorNOT_IN float",
filterField: FilterField{
Name: "my_field",
floatValues: &floatValues,
valueKind: reflect.Float64,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field NOT IN (-123456.789,-1,123456.789) ORDER BY `my_models`.`id` LIMIT 1",
},
{
name: "handleOperatorNOT_IN string",
filterField: FilterField{
Name: "my_field",
strValues: &strValues,
valueKind: reflect.String,
},
expected: "SELECT * FROM `my_models` WHERE my_table.my_field NOT IN ('First Value','Second Value','Third Value') ORDER BY `my_models`.`id` LIMIT 1",
},
}
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
sql := db.ToSQL(func(tx *gorm.DB) *gorm.DB {
query := tx.Model(&MyModel{})
query = testFunc(query, "my_table", &testCase.filterField)
return query.First(&MyModel{})
})
assert.Equal(t, testCase.expected, sql)
})
}
} }