feat: Improve filters and add integration tests (reloaded). (#521)

* feat: Improve filters and add integration tests.

* fix: Use random name for execution id in mongo tests.

* fix: Pass by value for filter dates.

.github/workflows/test.yml

@@ -10,7 +10,12 @@ jobs:
 
  build:
  runs-on: ubuntu-latest
-
+ services:
+ mongo:
+ image: bitnami/mongodb
+ ports:
+ - 27017:27017
+
  steps:
  - uses: actions/checkout@v2
 

internal/pkg/api/repository/result/filter.go

@@ -75,7 +75,7 @@ func (f filter) EndDate() time.Time {
 }
 
 func (f filter) StatusDefined() bool {
- return f.endDate != nil
+ return f.status != nil
 }
 
 func (f filter) Status() testkube.ExecutionStatus {

internal/pkg/api/repository/result/mongo.go

@@ -48,7 +48,6 @@ func (r *MongoRepository) GetNewestExecutions(ctx context.Context, limit int) (r
 func (r *MongoRepository) GetExecutions(ctx context.Context, filter Filter) (result []testkube.Execution, err error) {
  query, opts := composeQueryAndOpts(filter)
  cursor, err := r.Coll.Find(ctx, query, opts)
-
  if err != nil {
  return
  }
@@ -59,34 +58,57 @@ func (r *MongoRepository) GetExecutions(ctx context.Context, filter Filter) (res
 func (r *MongoRepository) GetExecutionTotals(ctx context.Context, filter Filter) (result testkube.ExecutionsTotals, err error) {
 
  query, _ := composeQueryAndOpts(filter)
- query["scriptType"] = bson.M{"$exists": true}
  total, err := r.Coll.CountDocuments(ctx, query)
  if err != nil {
- return
+ return result, err
  }
  result.Results = int32(total)
 
- query["executionResult"] = bson.M{"status": testkube.QUEUED_ExecutionStatus}
- queued, err := r.Coll.CountDocuments(ctx, query)
- if err != nil {
- return
- }
- result.Queued = int32(queued)
-
- query["executionResult"] = bson.M{"status": testkube.PENDING_ExecutionStatus}
- pending, err := r.Coll.CountDocuments(ctx, query)
- if err != nil {
- return
+ if status, ok := query["executionresult.status"]; ok {
+ count, err := r.Coll.CountDocuments(ctx, query)
+ if err != nil {
+ return result, err
+ }
+ switch status {
+ case testkube.QUEUED_ExecutionStatus:
+ result.Queued = int32(count)
+ case testkube.PENDING_ExecutionStatus:
+ result.Pending = int32(count)
+ case testkube.SUCCESS_ExecutionStatus:
+ result.Passed = int32(count)
+ case testkube.ERROR__ExecutionStatus:
+ result.Failed = int32(count)
+ }
+ } else {
+ query["executionresult.status"] = testkube.ExecutionStatusQueued
+ queued, err := r.Coll.CountDocuments(ctx, query)
+ if err != nil {
+ return result, err
+ }
+ result.Queued = int32(queued)
+
+ query["executionresult.status"] = testkube.ExecutionStatusPending
+ pending, err := r.Coll.CountDocuments(ctx, query)
+ if err != nil {
+ return result, err
+ }
+ result.Pending = int32(pending)
+
+ query["executionresult.status"] = testkube.ExecutionStatusSuccess
+ passed, err := r.Coll.CountDocuments(ctx, query)
+ if err != nil {
+ return result, err
+ }
+ result.Passed = int32(passed)
+
+ query["executionresult.status"] = testkube.ExecutionStatusError
+ failed, err := r.Coll.CountDocuments(ctx, query)
+ if err != nil {
+ return result, err
+ }
+ result.Failed = int32(failed)
  }
- result.Pending = int32(pending)
-
- query["executionResult"] = bson.M{"status": testkube.ERROR__ExecutionStatus}
- failed, err := r.Coll.CountDocuments(ctx, query)
- if err != nil {
- return
- }
- result.Failed = int32(failed)
- return
+ return result, err
 }
 
 func (r *MongoRepository) Insert(ctx context.Context, result testkube.Execution) (err error) {
@@ -135,11 +157,11 @@ func composeQueryAndOpts(filter Filter) (bson.M, *options.FindOptions) {
  }
 
  if len(startTimeQuery) > 0 {
- query["startTime"] = startTimeQuery
+ query["starttime"] = startTimeQuery
  }
 
  if filter.StatusDefined() {
- query["executionResult"] = bson.M{"status": filter.Status()}
+ query["executionresult.status"] = filter.Status()
  }
 
  opts.SetSkip(int64(filter.Page() * filter.PageSize()))

internal/pkg/api/repository/result/mongo_test.go

@@ -0,0 +1,229 @@
+package result
+
+import (
+ "context"
+ "testing"
+ "time"
+
+ "github.com/kubeshop/testkube/internal/pkg/api/repository/storage"
+ "github.com/kubeshop/testkube/pkg/api/v1/testkube"
+ "github.com/kubeshop/testkube/pkg/rand"
+ "github.com/stretchr/testify/require"
+)
+
+const (
+ mongoDns = "mongodb://localhost:27017"
+ mongoDbName = "testkube"
+)
+
+func TestFilters(t *testing.T) {
+ assert := require.New(t)
+
+ repository, err := getRepository()
+ assert.NoError(err)
+
+ err = repository.Coll.Drop(context.TODO())
+ assert.NoError(err)
+
+ oneDayAgo := time.Now().Add(-24 * time.Hour)
+ twoDaysAgo := time.Now().Add(-48 * time.Hour)
+ defaultName := "name"
+ err = repository.insertExecutionResult(defaultName, testkube.ERROR__ExecutionStatus, time.Now())
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.ERROR__ExecutionStatus, time.Now())
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.ERROR__ExecutionStatus, time.Now())
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.ERROR__ExecutionStatus, time.Now())
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.SUCCESS_ExecutionStatus, time.Now())
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.QUEUED_ExecutionStatus, time.Now())
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.PENDING_ExecutionStatus, time.Now())
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.ERROR__ExecutionStatus, oneDayAgo)
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.ERROR__ExecutionStatus, oneDayAgo)
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.ERROR__ExecutionStatus, oneDayAgo)
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.ERROR__ExecutionStatus, oneDayAgo)
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.SUCCESS_ExecutionStatus, oneDayAgo)
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.QUEUED_ExecutionStatus, oneDayAgo)
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.PENDING_ExecutionStatus, oneDayAgo)
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.ERROR__ExecutionStatus, twoDaysAgo)
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.ERROR__ExecutionStatus, twoDaysAgo)
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.ERROR__ExecutionStatus, twoDaysAgo)
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.ERROR__ExecutionStatus, twoDaysAgo)
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.SUCCESS_ExecutionStatus, twoDaysAgo)
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.QUEUED_ExecutionStatus, twoDaysAgo)
+ assert.NoError(err)
+ err = repository.insertExecutionResult(defaultName, testkube.PENDING_ExecutionStatus, twoDaysAgo)
+ assert.NoError(err)
+
+ t.Run("filter with status should return only executions with that status", func(t *testing.T) {
+
+ executions, err := repository.GetExecutions(context.Background(), NewExecutionsFilter().WithStatus(testkube.ERROR__ExecutionStatus))
+ assert.NoError(err)
+ assert.Len(executions, 12)
+ assert.Equal(*executions[0].ExecutionResult.Status, testkube.ERROR__ExecutionStatus)
+ })
+
+ t.Run("filter with status should return only totals with that status", func(t *testing.T) {
+ filteredTotals, err := repository.GetExecutionTotals(context.Background(), NewExecutionsFilter().WithStatus(testkube.ERROR__ExecutionStatus))
+
+ assert.NoError(err)
+ assert.Equal(int32(12), filteredTotals.Results)
+ assert.Equal(int32(12), filteredTotals.Failed)
+ assert.Equal(int32(0), filteredTotals.Passed)
+ assert.Equal(int32(0), filteredTotals.Queued)
+ assert.Equal(int32(0), filteredTotals.Pending)
+ })
+
+ t.Run("getting totals without filters should return all the executions", func(t *testing.T) {
+ totals, err := repository.GetExecutionTotals(context.Background(), NewExecutionsFilter())
+
+ assert.NoError(err)
+ assert.Equal(int32(21), totals.Results)
+ assert.Equal(int32(12), totals.Failed)
+ assert.Equal(int32(3), totals.Passed)
+ assert.Equal(int32(3), totals.Queued)
+ assert.Equal(int32(3), totals.Pending)
+ })
+
+ t.Run("filter with startDate should return only executions after that day", func(t *testing.T) {
+
+ executions, err := repository.GetExecutions(context.Background(), NewExecutionsFilter().WithStartDate(oneDayAgo))
+ assert.NoError(err)
+ assert.Len(executions, 14)
+ assert.True(executions[0].StartTime.After(oneDayAgo) || executions[0].StartTime.Equal(oneDayAgo))
+ })
+
+ t.Run("getting totals with filter by date start date should return only the results after this date", func(t *testing.T) {
+ totals, err := repository.GetExecutionTotals(context.Background(), NewExecutionsFilter().WithStartDate(oneDayAgo))
+
+ assert.NoError(err)
+ assert.Equal(int32(14), totals.Results)
+ assert.Equal(int32(8), totals.Failed)
+ assert.Equal(int32(2), totals.Passed)
+ assert.Equal(int32(2), totals.Queued)
+ assert.Equal(int32(2), totals.Pending)
+ })
+
+ t.Run("filter with endDate should return only executions before that day", func(t *testing.T) {
+
+ executions, err := repository.GetExecutions(context.Background(), NewExecutionsFilter().WithEndDate(oneDayAgo))
+ assert.NoError(err)
+ assert.Len(executions, 14)
+ assert.True(executions[0].StartTime.Before(oneDayAgo) || executions[0].StartTime.Equal(oneDayAgo))
+ })
+
+ t.Run("getting totals with filter by date start date should return only the results before this date", func(t *testing.T) {
+ totals, err := repository.GetExecutionTotals(context.Background(), NewExecutionsFilter().WithEndDate(oneDayAgo))
+
+ assert.NoError(err)
+ assert.Equal(int32(14), totals.Results)
+ assert.Equal(int32(8), totals.Failed)
+ assert.Equal(int32(2), totals.Passed)
+ assert.Equal(int32(2), totals.Queued)
+ assert.Equal(int32(2), totals.Pending)
+ })
+
+ t.Run("filter with script name that doesn't exist should return 0 results", func(t *testing.T) {
+
+ executions, err := repository.GetExecutions(context.Background(), NewExecutionsFilter().WithScriptName("noneExisting"))
+ assert.NoError(err)
+ assert.Empty(executions)
+ })
+
+ t.Run("getting totals with script name that doesn't exist should return 0 results", func(t *testing.T) {
+ totals, err := repository.GetExecutionTotals(context.Background(), NewExecutionsFilter().WithScriptName("noneExisting"))
+
+ assert.NoError(err)
+ assert.Equal(int32(0), totals.Results)
+ assert.Equal(int32(0), totals.Failed)
+ assert.Equal(int32(0), totals.Passed)
+ assert.Equal(int32(0), totals.Queued)
+ assert.Equal(int32(0), totals.Pending)
+ })
+
+ t.Run("filter with ccombined filter should return corresponding results", func(t *testing.T) {
+ filter := NewExecutionsFilter().
+ WithStatus(testkube.SUCCESS_ExecutionStatus).
+ WithStartDate(twoDaysAgo).
+ WithEndDate(oneDayAgo).
+ WithScriptName(defaultName)
+ executions, err := repository.GetExecutions(context.Background(), filter)
+ assert.NoError(err)
+ assert.Len(executions, 2)
+ })
+
+ t.Run("getting totals with ccombined filter should return corresponding results", func(t *testing.T) {
+ filter := NewExecutionsFilter().
+ WithStatus(testkube.SUCCESS_ExecutionStatus).
+ WithStartDate(twoDaysAgo).
+ WithEndDate(oneDayAgo).
+ WithScriptName(defaultName)
+ totals, err := repository.GetExecutionTotals(context.Background(), filter)
+
+ assert.NoError(err)
+ assert.Equal(int32(2), totals.Results)
+ assert.Equal(int32(0), totals.Failed)
+ assert.Equal(int32(2), totals.Passed)
+ assert.Equal(int32(0), totals.Queued)
+ assert.Equal(int32(0), totals.Pending)
+ })
+
+ name := "someDifferentName"
+ err = repository.insertExecutionResult(name, testkube.PENDING_ExecutionStatus, twoDaysAgo)
+ assert.NoError(err)
+
+ t.Run("filter with script name should return result only for that script name", func(t *testing.T) {
+
+ executions, err := repository.GetExecutions(context.Background(), NewExecutionsFilter().WithScriptName(name))
+ assert.NoError(err)
+ assert.Len(executions, 1)
+ assert.Equal(executions[0].ScriptName, name)
+ })
+
+ t.Run("getting totals with script name should return result only for that script name", func(t *testing.T) {
+ totals, err := repository.GetExecutionTotals(context.Background(), NewExecutionsFilter().WithScriptName(name))
+
+ assert.NoError(err)
+ assert.Equal(int32(1), totals.Results)
+ assert.Equal(int32(0), totals.Failed)
+ assert.Equal(int32(0), totals.Passed)
+ assert.Equal(int32(0), totals.Queued)
+ assert.Equal(int32(1), totals.Pending)
+ })
+
+}
+
+func getRepository() (*MongoRepository, error) {
+ db, err := storage.GetMongoDataBase(mongoDns, mongoDbName)
+ repository := NewMongoRespository(db)
+ return repository, err
+}
+
+func (repository *MongoRepository) insertExecutionResult(scriptName string, execStatus testkube.ExecutionStatus, startTime time.Time) error {
+ return repository.Insert(context.Background(),
+ testkube.Execution{
+ Id: rand.Name(),
+ ScriptName: scriptName,
+ Name: "dummyName",
+ ScriptType: "test/curl",
+ StartTime: startTime,
+ EndTime: time.Now(),
+ ExecutionResult: &testkube.ExecutionResult{Status: &execStatus},
+ })
+}