git-sync/crawlab
1
0
Fork 0
mirror of https://github.com/crawlab-team/crawlab.git synced 2026-01-22 17:31:03 +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

35
core/controllers/spider_v2.go
View File

@@ -432,6 +432,17 @@ func DeleteSpiderList(c *gin.Context) {
return
}
// Fetch spiders before deletion
spiders, err := service.NewModelServiceV2[models2.SpiderV2]().GetMany(bson.M{
"_id": bson.M{
"$in": payload.Ids,
},
}, nil)
if err != nil {
HandleErrorInternalServerError(c, err)
return
}
if err := mongo.RunTransaction(func(context mongo2.SessionContext) (err error) {
// delete spiders
if err := service.NewModelServiceV2[models2.SpiderV2]().DeleteMany(bson.M{
@@ -498,29 +509,21 @@ func DeleteSpiderList(c *gin.Context) {
return
}
// delete spider directories
// Delete spider directories
go func() {
wg := sync.WaitGroup{}
wg.Add(len(payload.Ids))
for _, id := range payload.Ids {
go func(id primitive.ObjectID) {
wg.Add(len(spiders))
for i := range spiders {
go func(s *models2.SpiderV2) {
defer wg.Done()
// spider
s, err := service.NewModelServiceV2[models2.SpiderV2]().GetById(id)
if err != nil {
log.Errorf("failed to get spider: %s", err.Error())
trace.PrintError(err)
return
}
// skip spider with git
// Skip spider with git
if !s.GitId.IsZero() {
return
}
// delete spider directory
fsSvc, err := getSpiderFsSvcById(id)
// Delete spider directory
fsSvc, err := getSpiderFsSvcById(s.Id)
if err != nil {
log.Errorf("failed to get spider fs service: %s", err.Error())
trace.PrintError(err)
@@ -532,7 +535,7 @@ func DeleteSpiderList(c *gin.Context) {
trace.PrintError(err)
return
}
}(id)
}(&spiders[i])
}
wg.Wait()
}()

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)
})
}