git-sync/crawlab
1
0
Fork 0
mirror of https://github.com/crawlab-team/crawlab.git synced 2026-01-30 18:00:56 +01:00
Code Issues Packages Projects Releases Wiki Activity

test: updated test cases

Browse Source
This commit is contained in:
Marvin Zhang
2024-10-20 18:45:54 +08:00
parent fa2b024906
commit d7ac9ebb1f
2 changed files with 245 additions and 239 deletions
Download Patch File Download Diff File Expand all files Collapse all files

449
core/models/service/base_service_v2_test.go
View File

@@ -2,6 +2,9 @@ package service_test
import (
"context"
"testing"
"time"
"github.com/crawlab-team/crawlab/core/models/models/v2"
"github.com/crawlab-team/crawlab/core/models/service"
"github.com/crawlab-team/crawlab/db/mongo"
@@ -10,8 +13,6 @@ import (
"github.com/stretchr/testify/require"
"go.mongodb.org/mongo-driver/bson"
"go.mongodb.org/mongo-driver/bson/primitive"
"testing"
"time"
)
type TestModel struct {
@@ -32,228 +33,230 @@ func teardownTestDB() {
}
}
func TestModelServiceV2_GetById(t *testing.T) {
setupTestDB()
defer teardownTestDB()
func TestModelServiceV2(t *testing.T) {
t.Run("GetById", func(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModel := TestModel{Name: "Test Name"}
svc := service.NewModelServiceV2[TestModel]()
testModel := TestModel{Name: "Test Name"}
id, err := svc.InsertOne(testModel)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
id, err := svc.InsertOne(testModel)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
result, err := svc.GetById(id)
require.Nil(t, err)
assert.Equal(t, testModel.Name, result.Name)
}
func TestModelServiceV2_GetOne(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModel := TestModel{Name: "Test Name"}
_, err := svc.InsertOne(testModel)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
result, err := svc.GetOne(bson.M{"name": "Test Name"}, nil)
require.Nil(t, err)
assert.Equal(t, testModel.Name, result.Name)
}
func TestModelServiceV2_GetMany(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModels := []TestModel{
{Name: "Name1"},
{Name: "Name2"},
}
_, err := svc.InsertMany(testModels)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
results, err := svc.GetMany(bson.M{}, nil)
require.Nil(t, err)
assert.Equal(t, 2, len(results))
}
func TestModelServiceV2_InsertOne(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModel := TestModel{Name: "Test Name"}
id, err := svc.InsertOne(testModel)
require.Nil(t, err)
assert.NotEqual(t, primitive.NilObjectID, id)
}
func TestModelServiceV2_InsertMany(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModels := []TestModel{
{Name: "Name1"},
{Name: "Name2"},
}
ids, err := svc.InsertMany(testModels)
require.Nil(t, err)
assert.Equal(t, 2, len(ids))
}
func TestModelServiceV2_UpdateById(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModel := TestModel{Name: "Old Name"}
id, err := svc.InsertOne(testModel)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
update := bson.M{"$set": bson.M{"name": "New Name"}}
err = svc.UpdateById(id, update)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
result, err := svc.GetById(id)
require.Nil(t, err)
assert.Equal(t, "New Name", result.Name)
}
func TestModelServiceV2_UpdateOne(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModel := TestModel{Name: "Old Name"}
_, err := svc.InsertOne(testModel)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
update := bson.M{"$set": bson.M{"name": "New Name"}}
err = svc.UpdateOne(bson.M{"name": "Old Name"}, update)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
result, err := svc.GetOne(bson.M{"name": "New Name"}, nil)
require.Nil(t, err)
assert.Equal(t, "New Name", result.Name)
}
func TestModelServiceV2_UpdateMany(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModels := []TestModel{
{Name: "Old Name1"},
{Name: "Old Name2"},
}
_, err := svc.InsertMany(testModels)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
update := bson.M{"$set": bson.M{"name": "New Name"}}
err = svc.UpdateMany(bson.M{"name": bson.M{"$regex": "^Old"}}, update)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
results, err := svc.GetMany(bson.M{"name": "New Name"}, nil)
require.Nil(t, err)
assert.Equal(t, 2, len(results))
}
func TestModelServiceV2_DeleteById(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModel := TestModel{Name: "Test Name"}
id, err := svc.InsertOne(testModel)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
err = svc.DeleteById(id)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
result, err := svc.GetById(id)
assert.NotNil(t, err)
assert.Nil(t, result)
}
func TestModelServiceV2_DeleteOne(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModel := TestModel{Name: "Test Name"}
_, err := svc.InsertOne(testModel)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
err = svc.DeleteOne(bson.M{"name": "Test Name"})
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
result, err := svc.GetOne(bson.M{"name": "Test Name"}, nil)
assert.NotNil(t, err)
assert.Nil(t, result)
}
func TestModelServiceV2_DeleteMany(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModels := []TestModel{
{Name: "Test Name1"},
{Name: "Test Name2"},
}
_, err := svc.InsertMany(testModels)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
err = svc.DeleteMany(bson.M{"name": bson.M{"$regex": "^Test Name"}})
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
results, err := svc.GetMany(bson.M{"name": bson.M{"$regex": "^Test Name"}}, nil)
require.Nil(t, err)
assert.Equal(t, 0, len(results))
}
func TestModelServiceV2_Count(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModels := []TestModel{
{Name: "Name1"},
{Name: "Name2"},
}
_, err := svc.InsertMany(testModels)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
total, err := svc.Count(bson.M{})
require.Nil(t, err)
assert.Equal(t, 2, total)
result, err := svc.GetById(id)
require.Nil(t, err)
assert.Equal(t, testModel.Name, result.Name)
})
t.Run("GetOne", func(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModel := TestModel{Name: "Test Name"}
_, err := svc.InsertOne(testModel)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
result, err := svc.GetOne(bson.M{"name": "Test Name"}, nil)
require.Nil(t, err)
assert.Equal(t, testModel.Name, result.Name)
})
t.Run("GetMany", func(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModels := []TestModel{
{Name: "Name1"},
{Name: "Name2"},
}
_, err := svc.InsertMany(testModels)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
results, err := svc.GetMany(bson.M{}, nil)
require.Nil(t, err)
assert.Equal(t, 2, len(results))
})
t.Run("InsertOne", func(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModel := TestModel{Name: "Test Name"}
id, err := svc.InsertOne(testModel)
require.Nil(t, err)
assert.NotEqual(t, primitive.NilObjectID, id)
})
t.Run("InsertMany", func(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModels := []TestModel{
{Name: "Name1"},
{Name: "Name2"},
}
ids, err := svc.InsertMany(testModels)
require.Nil(t, err)
assert.Equal(t, 2, len(ids))
})
t.Run("UpdateById", func(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModel := TestModel{Name: "Old Name"}
id, err := svc.InsertOne(testModel)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
update := bson.M{"$set": bson.M{"name": "New Name"}}
err = svc.UpdateById(id, update)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
result, err := svc.GetById(id)
require.Nil(t, err)
assert.Equal(t, "New Name", result.Name)
})
t.Run("UpdateOne", func(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModel := TestModel{Name: "Old Name"}
_, err := svc.InsertOne(testModel)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
update := bson.M{"$set": bson.M{"name": "New Name"}}
err = svc.UpdateOne(bson.M{"name": "Old Name"}, update)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
result, err := svc.GetOne(bson.M{"name": "New Name"}, nil)
require.Nil(t, err)
assert.Equal(t, "New Name", result.Name)
})
t.Run("UpdateMany", func(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModels := []TestModel{
{Name: "Old Name1"},
{Name: "Old Name2"},
}
_, err := svc.InsertMany(testModels)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
update := bson.M{"$set": bson.M{"name": "New Name"}}
err = svc.UpdateMany(bson.M{"name": bson.M{"$regex": "^Old"}}, update)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
results, err := svc.GetMany(bson.M{"name": "New Name"}, nil)
require.Nil(t, err)
assert.Equal(t, 2, len(results))
})
t.Run("DeleteById", func(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModel := TestModel{Name: "Test Name"}
id, err := svc.InsertOne(testModel)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
err = svc.DeleteById(id)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
result, err := svc.GetById(id)
assert.NotNil(t, err)
assert.Nil(t, result)
})
t.Run("DeleteOne", func(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModel := TestModel{Name: "Test Name"}
_, err := svc.InsertOne(testModel)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
err = svc.DeleteOne(bson.M{"name": "Test Name"})
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
result, err := svc.GetOne(bson.M{"name": "Test Name"}, nil)
assert.NotNil(t, err)
assert.Nil(t, result)
})
t.Run("DeleteMany", func(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModels := []TestModel{
{Name: "Test Name1"},
{Name: "Test Name2"},
}
_, err := svc.InsertMany(testModels)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
err = svc.DeleteMany(bson.M{"name": bson.M{"$regex": "^Test Name"}})
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
results, err := svc.GetMany(bson.M{"name": bson.M{"$regex": "^Test Name"}}, nil)
require.Nil(t, err)
assert.Equal(t, 0, len(results))
})
t.Run("Count", func(t *testing.T) {
setupTestDB()
defer teardownTestDB()
svc := service.NewModelServiceV2[TestModel]()
testModels := []TestModel{
{Name: "Name1"},
{Name: "Name2"},
}
_, err := svc.InsertMany(testModels)
require.Nil(t, err)
time.Sleep(100 * time.Millisecond)
total, err := svc.Count(bson.M{})
require.Nil(t, err)
assert.Equal(t, 2, total)
})
}