mirror of
https://github.com/crawlab-team/crawlab.git
synced 2026-01-21 17:21:09 +01:00
f86173c973
- Replaced "conditions" parameter with "filter" in various controller methods to unify the filtering approach. - Updated related functions to utilize the new filter parameter, enhancing consistency in query handling. - Improved overall code readability and maintainability by aligning naming conventions and refactoring filter-related logic.
222 lines
7.0 KiB
Go
222 lines
7.0 KiB
Go
package controllers_test
|
|
|
|
import (
|
|
"sort"
|
|
"testing"
|
|
|
|
"github.com/crawlab-team/crawlab/core/controllers"
|
|
"github.com/crawlab-team/crawlab/core/entity"
|
|
"github.com/crawlab-team/crawlab/core/models/models"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"go.mongodb.org/mongo-driver/bson"
|
|
"go.mongodb.org/mongo-driver/bson/primitive"
|
|
)
|
|
|
|
func TestGetFilterFromConditionString(t *testing.T) {
|
|
// Simple condition with string value
|
|
condStr := `[{"key":"name","op":"eq","value":"test"}]`
|
|
filter := controllers.ConvertToFilter(condStr)
|
|
require.NotNil(t, filter)
|
|
require.Len(t, filter.Conditions, 1)
|
|
assert.Equal(t, "name", filter.Conditions[0].Key)
|
|
assert.Equal(t, "eq", filter.Conditions[0].Op)
|
|
assert.Equal(t, "test", filter.Conditions[0].Value)
|
|
|
|
// Multiple conditions with different types
|
|
condStr = `[{"key":"name","op":"eq","value":"test"},{"key":"priority","op":"gt","value":5}]`
|
|
filter = controllers.ConvertToFilter(condStr)
|
|
require.NotNil(t, filter)
|
|
require.Len(t, filter.Conditions, 2)
|
|
assert.Equal(t, "name", filter.Conditions[0].Key)
|
|
assert.Equal(t, "eq", filter.Conditions[0].Op)
|
|
assert.Equal(t, "test", filter.Conditions[0].Value)
|
|
assert.Equal(t, "priority", filter.Conditions[1].Key)
|
|
assert.Equal(t, "gt", filter.Conditions[1].Op)
|
|
assert.Equal(t, int64(5), filter.Conditions[1].Value)
|
|
|
|
// Invalid JSON should return error
|
|
condStr = `[{"key":"name","op":"eq","value":"test"`
|
|
filter = controllers.ConvertToFilter(condStr)
|
|
assert.Nil(t, filter)
|
|
}
|
|
|
|
func TestGetFilterQueryFromConditionString(t *testing.T) {
|
|
// Simple equality condition
|
|
condStr := `[{"key":"name","op":"eq","value":"test"}]`
|
|
query := controllers.ConvertToBsonMFromFilter(condStr)
|
|
require.NotNil(t, query)
|
|
expected := bson.M{"name": "test"}
|
|
assert.Equal(t, expected, query)
|
|
|
|
// Greater than condition
|
|
condStr = `[{"key":"priority","op":"gt","value":5}]`
|
|
query = controllers.ConvertToBsonMFromFilter(condStr)
|
|
require.NotNil(t, query)
|
|
expected = bson.M{"priority": bson.M{"$gt": int64(5)}}
|
|
assert.Equal(t, expected, query)
|
|
|
|
// Multiple conditions
|
|
condStr = `[{"key":"name","op":"eq","value":"test"},{"key":"priority","op":"gt","value":5}]`
|
|
query = controllers.ConvertToBsonMFromFilter(condStr)
|
|
require.NotNil(t, query)
|
|
expected = bson.M{"name": "test", "priority": bson.M{"$gt": int64(5)}}
|
|
assert.Equal(t, expected, query)
|
|
|
|
// Contains operator
|
|
condStr = `[{"key":"name","op":"c","value":"test"}]`
|
|
query = controllers.ConvertToBsonMFromFilter(condStr)
|
|
require.NotNil(t, query)
|
|
expectedRegex := bson.M{"name": bson.M{"$regex": "test", "$options": "i"}}
|
|
assert.Equal(t, expectedRegex, query)
|
|
|
|
// Invalid condition should return error
|
|
condStr = `[{"key":"name","op":"invalid_op","value":"test"}]`
|
|
query = controllers.ConvertToBsonMFromFilter(condStr)
|
|
assert.Nil(t, query)
|
|
}
|
|
|
|
func TestGetFilterQueryFromListParams(t *testing.T) {
|
|
// No conditions
|
|
params := &controllers.GetListParams{}
|
|
query := controllers.ConvertToBsonMFromListParams(params)
|
|
assert.Nil(t, query)
|
|
|
|
// With conditions
|
|
params.Filter = `[{"key":"name","op":"eq","value":"test"}]`
|
|
query = controllers.ConvertToBsonMFromListParams(params)
|
|
require.NotNil(t, query)
|
|
expected := bson.M{"name": "test"}
|
|
assert.Equal(t, expected, query)
|
|
}
|
|
|
|
func TestGetUserFromContext(t *testing.T) {
|
|
// Empty context should return nil
|
|
c := &gin.Context{}
|
|
user := controllers.GetUserFromContext(c)
|
|
assert.Nil(t, user)
|
|
|
|
// Context with non-user value should return nil
|
|
c = &gin.Context{}
|
|
c.Set("user", "not a user object")
|
|
user = controllers.GetUserFromContext(c)
|
|
assert.Nil(t, user)
|
|
|
|
// Context with user should return the user
|
|
c = &gin.Context{}
|
|
expectedUser := &models.User{Username: "test_user"}
|
|
expectedUser.Id = primitive.NewObjectID()
|
|
c.Set("user", expectedUser)
|
|
user = controllers.GetUserFromContext(c)
|
|
assert.NotNil(t, user)
|
|
assert.Equal(t, expectedUser.Id, user.Id)
|
|
assert.Equal(t, expectedUser.Username, user.Username)
|
|
}
|
|
|
|
func TestGetErrorResponse(t *testing.T) {
|
|
// Error response test
|
|
err := assert.AnError
|
|
resp, _ := controllers.GetErrorResponse[models.Task](err)
|
|
assert.Equal(t, err.Error(), resp.Error)
|
|
assert.Equal(t, models.Task{}, resp.Data)
|
|
}
|
|
|
|
func TestGetDataResponse(t *testing.T) {
|
|
// Data response test
|
|
task := models.Task{
|
|
Status: "running",
|
|
Cmd: "python main.py",
|
|
Param: "test param",
|
|
}
|
|
task.Id = primitive.NewObjectID()
|
|
|
|
resp, err := controllers.GetDataResponse(task)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "ok", resp.Status)
|
|
assert.Equal(t, task, resp.Data)
|
|
assert.Empty(t, resp.Error)
|
|
}
|
|
|
|
func TestGetListResponse(t *testing.T) {
|
|
// List response test
|
|
tasks := []models.Task{
|
|
{
|
|
Status: "running",
|
|
Cmd: "python main.py",
|
|
},
|
|
{
|
|
Status: "pending",
|
|
Cmd: "python main.py",
|
|
},
|
|
}
|
|
tasks[0].Id = primitive.NewObjectID()
|
|
tasks[1].Id = primitive.NewObjectID()
|
|
|
|
total := 2
|
|
resp, err := controllers.GetListResponse(tasks, total)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, "ok", resp.Status)
|
|
assert.Equal(t, tasks, resp.Data)
|
|
assert.Equal(t, total, resp.Total)
|
|
assert.Empty(t, resp.Error)
|
|
}
|
|
|
|
func TestGetErrorListResponse(t *testing.T) {
|
|
// Error list response test
|
|
err := assert.AnError
|
|
resp, _ := controllers.GetErrorListResponse[models.Task](err)
|
|
assert.Equal(t, err.Error(), resp.Error)
|
|
assert.Nil(t, resp.Data)
|
|
assert.Equal(t, 0, resp.Total)
|
|
}
|
|
|
|
func TestConvertToFilterMap(t *testing.T) {
|
|
// Simple map with string value
|
|
condStr := `{"name": "test"}`
|
|
filter := controllers.ConvertToFilter(condStr)
|
|
require.NotNil(t, filter)
|
|
require.Len(t, filter.Conditions, 1)
|
|
assert.Equal(t, "name", filter.Conditions[0].Key)
|
|
assert.Equal(t, "eq", filter.Conditions[0].Op)
|
|
assert.Equal(t, "test", filter.Conditions[0].Value)
|
|
|
|
// Map with multiple fields of different types
|
|
condStr = `{"name": "test", "priority": 5, "active": true}`
|
|
filter = controllers.ConvertToFilter(condStr)
|
|
require.NotNil(t, filter)
|
|
require.Len(t, filter.Conditions, 3)
|
|
// Sort conditions to ensure consistent test results
|
|
sortConditions(filter.Conditions)
|
|
assert.Equal(t, "active", filter.Conditions[0].Key)
|
|
assert.Equal(t, "eq", filter.Conditions[0].Op)
|
|
assert.Equal(t, true, filter.Conditions[0].Value)
|
|
assert.Equal(t, "name", filter.Conditions[1].Key)
|
|
assert.Equal(t, "eq", filter.Conditions[1].Op)
|
|
assert.Equal(t, "test", filter.Conditions[1].Value)
|
|
assert.Equal(t, "priority", filter.Conditions[2].Key)
|
|
assert.Equal(t, "eq", filter.Conditions[2].Op)
|
|
assert.Equal(t, int64(5), filter.Conditions[2].Value)
|
|
|
|
// Map with ObjectID string
|
|
id := primitive.NewObjectID()
|
|
condStr = `{"_id": "` + id.Hex() + `"}`
|
|
filter = controllers.ConvertToFilter(condStr)
|
|
require.NotNil(t, filter)
|
|
require.Len(t, filter.Conditions, 1)
|
|
assert.Equal(t, "_id", filter.Conditions[0].Key)
|
|
assert.Equal(t, "eq", filter.Conditions[0].Op)
|
|
assert.Equal(t, id, filter.Conditions[0].Value)
|
|
|
|
// Invalid JSON should return nil
|
|
condStr = `{"name": "test"`
|
|
filter = controllers.ConvertToFilter(condStr)
|
|
assert.Nil(t, filter)
|
|
}
|
|
|
|
func sortConditions(conditions []*entity.Condition) {
|
|
sort.Slice(conditions, func(i, j int) bool {
|
|
return conditions[i].Key < conditions[j].Key
|
|
})
|
|
}
|