Tests

2024-06-22 23:17:37 +02:00
parent b67bc14e5e
commit 35082b1f6a
3 changed files with 289 additions and 1 deletions
--- a/app/repository/smartfilter/handlers_test.go
+++ b/app/repository/smartfilter/handlers_test.go
@ -0,0 +1,279 @@
+package smartfilter
+
+import (
+	"log"
+	"reflect"
+	"testing"
+
+	"github.com/DATA-DOG/go-sqlmock"
+	"github.com/go-playground/assert"
+	"gorm.io/driver/mysql"
+	"gorm.io/gorm"
+)
+
+func NewMockDB() (*gorm.DB, sqlmock.Sqlmock) {
+	db, mock, err := sqlmock.New()
+	if err != nil {
+		log.Fatalf("An error '%s' was not expected when opening a stub database connection", err)
+	}
+
+	gormDB, err := gorm.Open(mysql.New(mysql.Config{
+		Conn:                      db,
+		SkipInitializeWithVersion: true,
+	}), &gorm.Config{})
+
+	if err != nil {
+		log.Fatalf("An error '%s' was not expected when opening gorm database", err)
+	}
+
+	return gormDB, mock
+}
+
+type MyModel struct {
+	Id    int
+	Value string
+}
+
+func TestHandleOperatorEQ(t *testing.T) {
+	db, _ := NewMockDB()
+	testFunc := handleOperatorEQ
+
+	t.Run("Test handleOperatorEQ bool true", func(t *testing.T) {
+		var value bool = true
+		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 = 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) {
+	db, _ := NewMockDB()
+	testFunc := handleOperatorNE
+
+	t.Run("Test handleOperatorNE bool true", func(t *testing.T) {
+		var value bool = true
+		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 != 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) {
+	db, _ := NewMockDB()
+	testFunc := handleOperatorLIKE
+
+	t.Run("Test handleOperatorLIKE", 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 LIKE '%Some Value%' ORDER BY `my_models`.`id` LIMIT 1", sql)
+	})
+}
+
+func TestHandleOperatorILIKE(t *testing.T) {
+	db, _ := NewMockDB()
+	testFunc := handleOperatorILIKE
+
+	t.Run("Test handleOperatorLIKE", 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 ILIKE '%Some Value%' ORDER BY `my_models`.`id` LIMIT 1", sql)
+	})
+}