From 3e37cd07d4ffc395fb3c8e01309b88cf7f9dbfa9 Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Wed, 16 Aug 2023 19:43:41 +0530 Subject: [PATCH 01/18] fix: use local mongo operator Signed-off-by: SohamRatnaparkhi --- .../mongodb/chaos_experiment/operations.go | 14 ++++++------ .../chaos_experiment_run/operations.go | 22 +++++++++---------- .../chaos_infrastructure/operations.go | 14 ++++++------ 3 files changed, 25 insertions(+), 25 deletions(-) diff --git a/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment/operations.go b/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment/operations.go index 3112a372e4c..f2956fc788d 100644 --- a/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment/operations.go +++ b/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment/operations.go @@ -34,7 +34,7 @@ func (c *Operator) GetExperiments(query bson.D) ([]ChaosExperimentRequest, error ctx, cancel := context.WithTimeout(backgroundContext, 10*time.Second) defer cancel() - results, err := mongodb.Operator.List(ctx, mongodb.ChaosExperimentCollection, query) + results, err := c.operator.List(ctx, mongodb.ChaosExperimentCollection, query) if err != nil { return nil, err } @@ -51,7 +51,7 @@ func (c *Operator) GetExperiments(query bson.D) ([]ChaosExperimentRequest, error // GetExperiment takes a query parameter to retrieve the experiment details from the database func (c *Operator) GetExperiment(ctx context.Context, query bson.D) (ChaosExperimentRequest, error) { var experiment ChaosExperimentRequest - results, err := mongodb.Operator.Get(ctx, mongodb.ChaosExperimentCollection, query) + results, err := c.operator.Get(ctx, mongodb.ChaosExperimentCollection, query) if err != nil { return ChaosExperimentRequest{}, err } @@ -69,7 +69,7 @@ func (c *Operator) GetAggregateExperiments(pipeline mongo.Pipeline) (*mongo.Curs ctx, cancel := context.WithTimeout(backgroundContext, 10*time.Second) defer cancel() - results, err := mongodb.Operator.Aggregate(ctx, mongodb.ChaosExperimentCollection, pipeline) + results, err := c.operator.Aggregate(ctx, mongodb.ChaosExperimentCollection, pipeline) if err != nil { return nil, err } @@ -83,7 +83,7 @@ func (c *Operator) GetExperimentsByInfraID(infraID string) ([]ChaosExperimentReq defer cancel() query := bson.D{{"infra_id", infraID}} - results, err := mongodb.Operator.List(ctx, mongodb.ChaosExperimentCollection, query) + results, err := c.operator.List(ctx, mongodb.ChaosExperimentCollection, query) if err != nil { return nil, err } @@ -98,7 +98,7 @@ func (c *Operator) GetExperimentsByInfraID(infraID string) ([]ChaosExperimentReq // InsertChaosExperiment takes details of a experiment and inserts into the database collection func (c *Operator) InsertChaosExperiment(ctx context.Context, chaosExperiment ChaosExperimentRequest) error { - err := mongodb.Operator.Create(ctx, mongodb.ChaosExperimentCollection, chaosExperiment) + err := c.operator.Create(ctx, mongodb.ChaosExperimentCollection, chaosExperiment) if err != nil { return err } @@ -107,7 +107,7 @@ func (c *Operator) InsertChaosExperiment(ctx context.Context, chaosExperiment Ch // UpdateChaosExperiment takes query and update parameters to update the experiment details in the database func (c *Operator) UpdateChaosExperiment(ctx context.Context, query bson.D, update bson.D, opts ...*options.UpdateOptions) error { - _, err := mongodb.Operator.Update(ctx, mongodb.ChaosExperimentCollection, query, update, opts...) + _, err := c.operator.Update(ctx, mongodb.ChaosExperimentCollection, query, update, opts...) if err != nil { return err } @@ -117,7 +117,7 @@ func (c *Operator) UpdateChaosExperiment(ctx context.Context, query bson.D, upda // UpdateChaosExperiments takes query and update parameters to updates multiple experiment's details in the database func (c *Operator) UpdateChaosExperiments(ctx context.Context, query bson.D, update bson.D) error { - _, err := mongodb.Operator.UpdateMany(ctx, mongodb.ChaosExperimentCollection, query, update) + _, err := c.operator.UpdateMany(ctx, mongodb.ChaosExperimentCollection, query, update) if err != nil { return err } diff --git a/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment_run/operations.go b/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment_run/operations.go index 3f69e9adc26..9335de30139 100644 --- a/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment_run/operations.go +++ b/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment_run/operations.go @@ -25,7 +25,7 @@ func NewChaosExperimentRunOperator(mongodbOperator mongodb.MongoOperator) *Opera } func (c *Operator) CreateExperimentRun(ctx context.Context, wfRun ChaosExperimentRun) error { - err := mongodb.Operator.Create(ctx, mongodb.ChaosExperimentRunsCollection, wfRun) + err := c.operator.Create(ctx, mongodb.ChaosExperimentRunsCollection, wfRun) if err != nil { return err } @@ -37,7 +37,7 @@ func (c *Operator) GetExperimentRuns(query bson.D) ([]ChaosExperimentRun, error) defer cancel() var experiments []ChaosExperimentRun - results, err := mongodb.Operator.List(ctx, mongodb.ChaosExperimentRunsCollection, query) + results, err := c.operator.List(ctx, mongodb.ChaosExperimentRunsCollection, query) if err != nil { return nil, err } @@ -50,7 +50,7 @@ func (c *Operator) GetExperimentRuns(query bson.D) ([]ChaosExperimentRun, error) } func (c *Operator) CountExperimentRuns(ctx context.Context, query bson.D) (int64, error) { - results, err := mongodb.Operator.CountDocuments(ctx, mongodb.ChaosExperimentRunsCollection, query) + results, err := c.operator.CountDocuments(ctx, mongodb.ChaosExperimentRunsCollection, query) if err != nil { return 0, err } @@ -62,7 +62,7 @@ func (c *Operator) GetExperimentRun(query bson.D) (ChaosExperimentRun, error) { defer cancel() var experimentRun ChaosExperimentRun - results, err := mongodb.Operator.Get(ctx, mongodb.ChaosExperimentRunsCollection, query) + results, err := c.operator.Get(ctx, mongodb.ChaosExperimentRunsCollection, query) if err != nil { return ChaosExperimentRun{}, err } @@ -88,7 +88,7 @@ func (c *Operator) UpdateExperimentRun(ctx context.Context, wfRun ChaosExperimen } } - count, err := mongodb.Operator.CountDocuments(ctx, mongodb.ChaosExperimentRunsCollection, query) + count, err := c.operator.CountDocuments(ctx, mongodb.ChaosExperimentRunsCollection, query) if err != nil { return 0, err } @@ -97,7 +97,7 @@ func (c *Operator) UpdateExperimentRun(ctx context.Context, wfRun ChaosExperimen if count == 0 { //Audit details for first time creation wfRun.CreatedAt = time.Now().UnixMilli() - err := mongodb.Operator.Create(ctx, mongodb.ChaosExperimentRunsCollection, wfRun) + err := c.operator.Create(ctx, mongodb.ChaosExperimentRunsCollection, wfRun) if err != nil { return 0, err } @@ -134,7 +134,7 @@ func (c *Operator) UpdateExperimentRun(ctx context.Context, wfRun ChaosExperimen {"is_removed", wfRun.IsRemoved}, }}} - result, err := mongodb.Operator.Update(ctx, mongodb.ChaosExperimentRunsCollection, updateQuery, update) + result, err := c.operator.Update(ctx, mongodb.ChaosExperimentRunsCollection, updateQuery, update) if err != nil { return 0, err } @@ -145,7 +145,7 @@ func (c *Operator) UpdateExperimentRun(ctx context.Context, wfRun ChaosExperimen } func (c *Operator) UpdateExperimentRunWithQuery(ctx context.Context, query bson.D, update bson.D) error { - _, err := mongodb.Operator.Update(ctx, mongodb.ChaosExperimentRunsCollection, query, update) + _, err := c.operator.Update(ctx, mongodb.ChaosExperimentRunsCollection, query, update) if err != nil { return err } @@ -155,7 +155,7 @@ func (c *Operator) UpdateExperimentRunWithQuery(ctx context.Context, query bson. func (c *Operator) UpdateExperimentRunsWithQuery(ctx context.Context, query bson.D, update bson.D) error { - _, err := mongodb.Operator.UpdateMany(ctx, mongodb.ChaosExperimentRunsCollection, query, update) + _, err := c.operator.UpdateMany(ctx, mongodb.ChaosExperimentRunsCollection, query, update) if err != nil { return err } @@ -169,7 +169,7 @@ func (c *Operator) GetExperimentRunsByInfraID(infraID string) ([]ChaosExperiment defer cancel() query := bson.D{{"infra_id", infraID}} - results, err := mongodb.Operator.List(ctx, mongodb.ChaosExperimentRunsCollection, query) + results, err := c.operator.List(ctx, mongodb.ChaosExperimentRunsCollection, query) if err != nil { return nil, err } @@ -187,7 +187,7 @@ func (c *Operator) GetAggregateExperimentRuns(pipeline mongo.Pipeline) (*mongo.C ctx, cancel := context.WithTimeout(backgroundContext, 10*time.Second) defer cancel() - results, err := mongodb.Operator.Aggregate(ctx, mongodb.ChaosExperimentRunsCollection, pipeline) + results, err := c.operator.Aggregate(ctx, mongodb.ChaosExperimentRunsCollection, pipeline) if err != nil { return nil, err } diff --git a/chaoscenter/graphql/server/pkg/database/mongodb/chaos_infrastructure/operations.go b/chaoscenter/graphql/server/pkg/database/mongodb/chaos_infrastructure/operations.go index 13f4a0e5c9b..19fce69b492 100644 --- a/chaoscenter/graphql/server/pkg/database/mongodb/chaos_infrastructure/operations.go +++ b/chaoscenter/graphql/server/pkg/database/mongodb/chaos_infrastructure/operations.go @@ -28,7 +28,7 @@ func NewInfrastructureOperator(mongodbOperator mongodb.MongoOperator) *Operator // InsertInfra takes details of a chaos_infra and inserts into the database collection func (c *Operator) InsertInfra(ctx context.Context, infra ChaosInfra) error { - err := mongodb.Operator.Create(ctx, mongodb.ChaosInfraCollection, infra) + err := c.operator.Create(ctx, mongodb.ChaosInfraCollection, infra) if err != nil { return err } @@ -44,7 +44,7 @@ func (c *Operator) GetInfra(infraID string) (ChaosInfra, error) { query := bson.D{{"infra_id", infraID}} var infra ChaosInfra - result, err := mongodb.Operator.Get(ctx, mongodb.ChaosInfraCollection, query) + result, err := c.operator.Get(ctx, mongodb.ChaosInfraCollection, query) err = result.Decode(&infra) if err != nil { return ChaosInfra{}, err @@ -61,7 +61,7 @@ func (c *Operator) GetInfraDetails(ctx context.Context, infraID string, projectI } var infra ChaosInfra - result, err := mongodb.Operator.Get(ctx, mongodb.ChaosInfraCollection, query) + result, err := c.operator.Get(ctx, mongodb.ChaosInfraCollection, query) err = result.Decode(&infra) if err != nil { return ChaosInfra{}, err @@ -72,7 +72,7 @@ func (c *Operator) GetInfraDetails(ctx context.Context, infraID string, projectI // UpdateInfra takes query and update parameters to update the chaos_infra details in the database func (c *Operator) UpdateInfra(ctx context.Context, query bson.D, update bson.D) error { - _, err := mongodb.Operator.UpdateMany(ctx, mongodb.ChaosInfraCollection, query, update) + _, err := c.operator.UpdateMany(ctx, mongodb.ChaosInfraCollection, query, update) if err != nil { return err } @@ -93,7 +93,7 @@ func (c *Operator) GetInfraWithProjectID(projectID string) ([]*ChaosInfra, error defer cancel() var infras []*ChaosInfra - results, err := mongodb.Operator.List(ctx, mongodb.ChaosInfraCollection, query) + results, err := c.operator.List(ctx, mongodb.ChaosInfraCollection, query) if err != nil { return []*ChaosInfra{}, err } @@ -109,7 +109,7 @@ func (c *Operator) GetInfraWithProjectID(projectID string) ([]*ChaosInfra, error // GetInfras returns all the infras matching the query func (c *Operator) GetInfras(ctx context.Context, query bson.D) ([]ChaosInfra, error) { var infras []ChaosInfra - results, err := mongodb.Operator.List(ctx, mongodb.ChaosInfraCollection, query) + results, err := c.operator.List(ctx, mongodb.ChaosInfraCollection, query) if err != nil { return []ChaosInfra{}, err } @@ -125,7 +125,7 @@ func (c *Operator) GetAggregateInfras(pipeline mongo.Pipeline) (*mongo.Cursor, e ctx, cancel := context.WithTimeout(backgroundContext, 10*time.Second) defer cancel() - results, err := mongodb.Operator.Aggregate(ctx, mongodb.ChaosInfraCollection, pipeline) + results, err := c.operator.Aggregate(ctx, mongodb.ChaosInfraCollection, pipeline) if err != nil { return nil, err } From a47bfff99d42d4b12230fa01f4527c4fc66b0632 Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Wed, 16 Aug 2023 19:44:23 +0530 Subject: [PATCH 02/18] feat: gitops mocks added Signed-off-by: SohamRatnaparkhi --- .../server/pkg/gitops/model/mocks/service.go | 67 +++++++++++++++++++ 1 file changed, 67 insertions(+) create mode 100644 chaoscenter/graphql/server/pkg/gitops/model/mocks/service.go diff --git a/chaoscenter/graphql/server/pkg/gitops/model/mocks/service.go b/chaoscenter/graphql/server/pkg/gitops/model/mocks/service.go new file mode 100644 index 00000000000..9513acd533d --- /dev/null +++ b/chaoscenter/graphql/server/pkg/gitops/model/mocks/service.go @@ -0,0 +1,67 @@ +package mocks + +import ( + "context" + + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/graph/model" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_infrastructure" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/gitops" + "github.com/stretchr/testify/mock" +) + +// GitOpsService is an autogenerated mock type for the GitOpsService type +type GitOpsService struct { + mock.Mock +} + +// GitOpsNotificationHandler provides a mock function with given fields: ctx, cluster, experimentID +func (g *GitOpsService) GitOpsNotificationHandler(ctx context.Context, infra chaos_infrastructure.ChaosInfra, experimentID string) (string, error) { + args := g.Called(ctx, infra, experimentID) + return args.String(0), args.Error(1) +} + +// EnableGitOpsHandler provides a mock function with given fields: ctx, config +func (g *GitOpsService) EnableGitOpsHandler(ctx context.Context, config model.GitConfig) (bool, error) { + args := g.Called(ctx, config) + return args.Bool(0), args.Error(1) +} + +// DisableGitOpsHandler provides a mock function with given fields: ctx, projectID +func (g *GitOpsService) DisableGitOpsHandler(ctx context.Context, projectID string) (bool, error) { + args := g.Called(ctx, projectID) + return args.Bool(0), args.Error(1) +} + +// UpdateGitOpsDetailsHandler provides a mock function with given fields: ctx, config +func (g *GitOpsService) UpdateGitOpsDetailsHandler(ctx context.Context, config model.GitConfig) (bool, error) { + args := g.Called(ctx, config) + return args.Bool(0), args.Error(1) +} + +// GetGitOpsDetails provides a mock function with given fields: ctx, projectID +func (g *GitOpsService) GetGitOpsDetails(ctx context.Context, projectID string) (*model.GitConfigResponse, error) { + args := g.Called(ctx, projectID) + return args.Get(0).(*model.GitConfigResponse), args.Error(1) +} + +// UpsertWorkflowToGit provides a mock function with given fields: ctx, experiment +func (g *GitOpsService) UpsertExperimentToGit(ctx context.Context, projectID string, experiment *model.ChaosExperimentRequest) error { + args := g.Called(ctx, experiment) + return args.Error(0) +} + +// DeleteWorkflowFromGit provides a mock function with given fields: ctx, experiment +func (g *GitOpsService) DeleteExperimentFromGit(ctx context.Context, projectID string, experiment *model.ChaosExperimentRequest) error { + args := g.Called(ctx, experiment) + return args.Error(0) +} + +// GitOpsSyncHandler provides a mock function with given fields: singleRun +func (g *GitOpsService) GitOpsSyncHandler(singleRun bool) { + g.Called(singleRun) +} + +func (g *GitOpsService) SyncDBToGit(ctx context.Context, config gitops.GitConfig) error { + args := g.Called(ctx, config) + return args.Error(0) +} From 93343974dfb05e68193261fcc88e3e6c543a56ca Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Wed, 16 Aug 2023 19:44:56 +0530 Subject: [PATCH 03/18] feat: mongo mocks added Signed-off-by: SohamRatnaparkhi --- .../mongodb/mocks/mongo_operations.go | 100 ++++++++++++++++++ 1 file changed, 100 insertions(+) create mode 100644 chaoscenter/graphql/server/pkg/database/mongodb/mocks/mongo_operations.go diff --git a/chaoscenter/graphql/server/pkg/database/mongodb/mocks/mongo_operations.go b/chaoscenter/graphql/server/pkg/database/mongodb/mocks/mongo_operations.go new file mode 100644 index 00000000000..97cbe724ee9 --- /dev/null +++ b/chaoscenter/graphql/server/pkg/database/mongodb/mocks/mongo_operations.go @@ -0,0 +1,100 @@ +// Package mocks contains all the mocks for the mongo_operator.go file +package mocks + +import ( + "context" + + "github.com/stretchr/testify/mock" + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/mongo" + "go.mongodb.org/mongo-driver/mongo/options" +) + +// MongoOperator is an autogenerated mock type for the MongoOperator type +type MongoOperator struct { + mock.Mock +} + +// WatchEvents implements mongodb.MongoOperator. +func (m *MongoOperator) WatchEvents(ctx context.Context, client *mongo.Client, collectionType int, pipeline mongo.Pipeline, opts ...*options.ChangeStreamOptions) (*mongo.ChangeStream, error) { + args := m.Called(ctx, client, collectionType, pipeline, opts) + return args.Get(0).(*mongo.ChangeStream), args.Error(1) +} + +// Create provides a mock function with given fields: ctx, collectionType, document +func (m MongoOperator) Create(ctx context.Context, collectionType int, document interface{}) error { + args := m.Called(ctx, collectionType, document) + return args.Error(0) +} + +// CreateMany provides a mock function with given fields: ctx, collectionType, documents +func (m MongoOperator) CreateMany(ctx context.Context, collectionType int, documents []interface{}) error { + args := m.Called(ctx, collectionType, documents) + return args.Error(0) +} + +// Get provides a mock function with given fields: ctx, collectionType, query +func (m MongoOperator) Get(ctx context.Context, collectionType int, query bson.D) (*mongo.SingleResult, error) { + args := m.Called(ctx, collectionType, query) + return args.Get(0).(*mongo.SingleResult), args.Error(1) +} + +// List provides a mock function with given fields: ctx, collectionType, query +func (m MongoOperator) List(ctx context.Context, collectionType int, query bson.D, opts ...*options.FindOptions) (*mongo.Cursor, error) { + args := m.Called(ctx, collectionType, query) + return args.Get(0).(*mongo.Cursor), args.Error(1) +} + +// Update provides a mock function with given fields: ctx, collectionType, query, update, opts +func (m MongoOperator) Update(ctx context.Context, collectionType int, query, update bson.D, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error) { + args := m.Called(ctx, collectionType, query, update, opts) + return args.Get(0).(*mongo.UpdateResult), args.Error(1) +} + +// UpdateMany provides a mock function with given fields: ctx, collectionType, query, update, opts +func (m MongoOperator) UpdateMany(ctx context.Context, collectionType int, query, update bson.D, opts ...*options.UpdateOptions) (*mongo.UpdateResult, error) { + args := m.Called(ctx, collectionType, query, update, opts) + return args.Get(0).(*mongo.UpdateResult), args.Error(1) +} + +// Replace provides a mock function with given fields: ctx, collectionType, query, replacement +func (m MongoOperator) Replace(ctx context.Context, collectionType int, query bson.D, replacement interface{}) (*mongo.UpdateResult, error) { + args := m.Called(ctx, collectionType, query, replacement) + return args.Get(0).(*mongo.UpdateResult), args.Error(1) +} + +// Delete provides a mock function with given fields: ctx, collectionType, query, opts +func (m MongoOperator) Delete(ctx context.Context, collectionType int, query bson.D, opts ...*options.DeleteOptions) (*mongo.DeleteResult, error) { + args := m.Called(ctx, collectionType, query, opts) + return args.Get(0).(*mongo.DeleteResult), args.Error(1) +} + +// CountDocuments provides a mock function with given fields: ctx, collectionType, query, opts +func (m MongoOperator) CountDocuments(ctx context.Context, collectionType int, query bson.D, opts ...*options.CountOptions) (int64, error) { + args := m.Called(ctx, collectionType, query, opts) + return args.Get(0).(int64), args.Error(1) +} + +// Aggregate provides a mock function with given fields: ctx, collectionType, pipeline, opts +func (m MongoOperator) Aggregate(ctx context.Context, collectionType int, pipeline interface{}, opts ...*options.AggregateOptions) (*mongo.Cursor, error) { + args := m.Called(ctx, collectionType, pipeline, opts) + return args.Get(0).(*mongo.Cursor), args.Error(1) +} + +// GetCollection provides a mock function with given fields: collectionType +func (m MongoOperator) GetCollection(collectionType int) (*mongo.Collection, error) { + args := m.Called(collectionType) + return args.Get(0).(*mongo.Collection), args.Error(1) +} + +// ListCollection provides a mock function with given fields: ctx, mclient +func (m MongoOperator) ListCollection(ctx context.Context, mclient *mongo.Client) ([]string, error) { + args := m.Called(ctx, mclient) + return args.Get(0).([]string), args.Error(1) +} + +// ListDataBase provides a mock function with given fields: ctx, mclient +func (m MongoOperator) ListDataBase(ctx context.Context, mclient *mongo.Client) ([]string, error) { + args := m.Called(ctx, mclient) + return args.Get(0).([]string), args.Error(1) +} From 8b46c9175a5721627e508729b1af6e1064925ee8 Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Wed, 16 Aug 2023 19:45:30 +0530 Subject: [PATCH 04/18] feat: chaos experiment run mocks added Signed-off-by: SohamRatnaparkhi --- .../model/mocks/service.go | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 chaoscenter/graphql/server/pkg/choas_experiment_run/model/mocks/service.go diff --git a/chaoscenter/graphql/server/pkg/choas_experiment_run/model/mocks/service.go b/chaoscenter/graphql/server/pkg/choas_experiment_run/model/mocks/service.go new file mode 100644 index 00000000000..4bfe7d3c80c --- /dev/null +++ b/chaoscenter/graphql/server/pkg/choas_experiment_run/model/mocks/service.go @@ -0,0 +1,28 @@ +package mocks + +import ( + "context" + + types "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/choas_experiment_run" + store "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/data-store" + dbChaosExperiment "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment" + dbChaosExperimentRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment_run" + "github.com/stretchr/testify/mock" + "go.mongodb.org/mongo-driver/bson" +) + +type ChaosExperimentRunService struct { + mock.Mock +} + +// ProcessExperimentRunDelete mocks the ProcessExperimentRunDelete of chaos-experiment-run service +func (c *ChaosExperimentRunService) ProcessExperimentRunDelete(ctx context.Context, query bson.D, workflowRunID *string, experimentRun dbChaosExperimentRun.ChaosExperimentRun, workflow dbChaosExperiment.ChaosExperimentRequest, username string, r *store.StateData) error { + args := c.Called(ctx, query, workflowRunID, experimentRun, workflow, username, r) + return args.Error(0) +} + +// ProcessCompletedExperimentRun mocks the ProcessCompletedExperimentRun of chaos-experiment-run service +func (c *ChaosExperimentRunService) ProcessCompletedExperimentRun(execData types.ExecutionData, wfID string, runID string) (types.ExperimentRunMetrics, error) { + args := c.Called(execData, wfID, runID) + return args.Get(0).(types.ExperimentRunMetrics), args.Error(1) +} From 05e51f3bf5726461a884daceeeb7580e44c1cb5b Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Wed, 16 Aug 2023 19:46:28 +0530 Subject: [PATCH 05/18] feat: infra mocks added Signed-off-by: SohamRatnaparkhi --- .../model/mocks/service.go | 99 +++++++++++++++++++ 1 file changed, 99 insertions(+) create mode 100644 chaoscenter/graphql/server/pkg/chaos_infrastructure/model/mocks/service.go diff --git a/chaoscenter/graphql/server/pkg/chaos_infrastructure/model/mocks/service.go b/chaoscenter/graphql/server/pkg/chaos_infrastructure/model/mocks/service.go new file mode 100644 index 00000000000..608340cf178 --- /dev/null +++ b/chaoscenter/graphql/server/pkg/chaos_infrastructure/model/mocks/service.go @@ -0,0 +1,99 @@ +package mocks + +import ( + "context" + + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/graph/model" + store "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/data-store" + dbChaosInfra "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_infrastructure" + "github.com/stretchr/testify/mock" + "go.mongodb.org/mongo-driver/bson" +) + +type InfraService struct { + mock.Mock +} + +func (s *InfraService) RegisterInfra(c context.Context, projectID string, input model.RegisterInfraRequest) (*model.RegisterInfraResponse, error) { + args := s.Called(c, projectID, input) + return args.Get(0).(*model.RegisterInfraResponse), args.Error(1) +} + +func (s *InfraService) ConfirmInfraRegistration(request model.InfraIdentity, r store.StateData) (*model.ConfirmInfraRegistrationResponse, error) { + args := s.Called(request, r) + return args.Get(0).(*model.ConfirmInfraRegistrationResponse), args.Error(1) +} + +func (s *InfraService) VerifyInfra(identity model.InfraIdentity) (*dbChaosInfra.ChaosInfra, error) { + args := s.Called(identity) + return args.Get(0).(*dbChaosInfra.ChaosInfra), args.Error(1) +} + +func (s *InfraService) DeleteInfra(ctx context.Context, projectID string, infraId string, r store.StateData) (string, error) { + args := s.Called(ctx, projectID, infraId, r) + return args.String(0), args.Error(1) +} + +func (s *InfraService) ListInfras(projectID string, request *model.ListInfraRequest) (*model.ListInfraResponse, error) { + args := s.Called(projectID, request) + return args.Get(0).(*model.ListInfraResponse), args.Error(1) +} + +func (s *InfraService) GetInfraDetails(ctx context.Context, infraID string, projectID string) (*model.Infra, error) { + args := s.Called(ctx, infraID, projectID) + return args.Get(0).(*model.Infra), args.Error(1) +} + +func (s *InfraService) SendInfraEvent(eventType, eventName, description string, infra model.Infra, r store.StateData) { + s.Called(eventType, eventName, description, infra, r) +} + +func (s *InfraService) GetManifest(token string) ([]byte, int, error) { + args := s.Called(token) + return args.Get(0).([]byte), args.Int(1), args.Error(2) +} + +func (s *InfraService) GetManifestWithInfraID(infraID string, accessKey string) ([]byte, error) { + args := s.Called(infraID, accessKey) + return args.Get(0).([]byte), args.Error(1) +} + +func (s *InfraService) GetInfra(ctx context.Context, projectID string, infraID string) (*model.Infra, error) { + args := s.Called(ctx, projectID, infraID) + return args.Get(0).(*model.Infra), args.Error(1) +} + +func (s *InfraService) GetInfraStats(ctx context.Context, projectID string) (*model.GetInfraStatsResponse, error) { + args := s.Called(ctx, projectID) + return args.Get(0).(*model.GetInfraStatsResponse), args.Error(1) +} + +func (s *InfraService) GetVersionDetails() (*model.InfraVersionDetails, error) { + args := s.Called() + return args.Get(0).(*model.InfraVersionDetails), args.Error(1) +} + +func (s *InfraService) QueryServerVersion(ctx context.Context) (*model.ServerVersionResponse, error) { + args := s.Called(ctx) + return args.Get(0).(*model.ServerVersionResponse), args.Error(1) +} + +func (s *InfraService) PodLog(request model.PodLog, r store.StateData) (string, error) { + args := s.Called(request, r) + return args.String(0), args.Error(1) +} + +func (s *InfraService) KubeObj(request model.KubeObjectData, r store.StateData) (string, error) { + args := s.Called(request, r) + return args.String(0), args.Error(1) +} + +func (s *InfraService) UpdateInfra(query bson.D, update bson.D) error { + args := s.Called(query, update) + return args.Error(0) +} + +func (s *InfraService) GetDBInfra(infraID string) (dbChaosInfra.ChaosInfra, error) { + args := s.Called(infraID) + return args.Get(0).(dbChaosInfra.ChaosInfra), args.Error(1) +} From 53d2f9f263990f62346ebb79b19463d85dbdceb9 Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Wed, 16 Aug 2023 19:47:01 +0530 Subject: [PATCH 06/18] feat: chaos experiment mocks added Signed-off-by: SohamRatnaparkhi --- .../chaos_experiment/model/mocks/service.go | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/service.go diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/service.go b/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/service.go new file mode 100644 index 00000000000..a45fdc11cc8 --- /dev/null +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/service.go @@ -0,0 +1,35 @@ +package mocks + +import ( + "context" + + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/graph/model" + store "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/data-store" + dbChaosExperiment "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment" + "github.com/stretchr/testify/mock" + "go.mongodb.org/mongo-driver/bson" +) + +type ChaosExperimentService struct { + mock.Mock +} + +func (m *ChaosExperimentService) ProcessExperiment(workflow *model.ChaosExperimentRequest, projectID string, revID string) (*model.ChaosExperimentRequest, *dbChaosExperiment.ChaosExperimentType, error) { + args := m.Called(workflow, projectID, revID) + return args.Get(0).(*model.ChaosExperimentRequest), args.Get(1).(*dbChaosExperiment.ChaosExperimentType), args.Error(2) +} + +func (m *ChaosExperimentService) ProcessExperimentCreation(ctx context.Context, input *model.ChaosExperimentRequest, username string, projectID string, wfType *dbChaosExperiment.ChaosExperimentType, revisionID string, r *store.StateData) error { + args := m.Called(ctx, input, username, projectID, wfType, revisionID, r) + return args.Error(0) +} + +func (m *ChaosExperimentService) ProcessExperimentUpdate(workflow *model.ChaosExperimentRequest, username string, wfType *dbChaosExperiment.ChaosExperimentType, revisionID string, updateRevision bool, projectID string, r *store.StateData) error { + args := m.Called(workflow, username, wfType, revisionID, updateRevision, projectID, r) + return args.Error(0) +} + +func (m *ChaosExperimentService) ProcessExperimentDelete(query bson.D, workflow dbChaosExperiment.ChaosExperimentRequest, username string, r *store.StateData) error { + args := m.Called(query, workflow, username, r) + return args.Error(0) +} From f57f40b830cf136fe705afbaacbfbd25b641e719 Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Fri, 18 Aug 2023 18:33:47 +0530 Subject: [PATCH 07/18] feat: temporary manifests Signed-off-by: SohamRatnaparkhi --- .../model/mocks/chaos_engine.yaml | 34 ++++ .../model/mocks/chaos_schedule.yaml | 33 ++++ .../model/mocks/cron_workflow.yaml | 177 ++++++++++++++++++ .../model/mocks/workflow.yaml | 164 ++++++++++++++++ .../model/mocks/wrong_type.yaml | 4 + 5 files changed, 412 insertions(+) create mode 100644 chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/chaos_engine.yaml create mode 100644 chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/chaos_schedule.yaml create mode 100644 chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/cron_workflow.yaml create mode 100644 chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/workflow.yaml create mode 100644 chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/wrong_type.yaml diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/chaos_engine.yaml b/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/chaos_engine.yaml new file mode 100644 index 00000000000..78f67a13e3b --- /dev/null +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/chaos_engine.yaml @@ -0,0 +1,34 @@ +apiVersion: litmuschaos.io/v1alpha1 +kind: ChaosEngine +metadata: + generateName: nginx-chaos + name: nginx-chaos + namespace: default +spec: + appinfo: + appns: 'default' + applabel: 'app=nginx' + appkind: 'deployment' + # It can be active/stop + engineState: 'active' + chaosServiceAccount: pod-delete-sa + experiments: + - name: pod-delete + spec: + components: + env: + # set chaos duration (in sec) as desired + - name: TOTAL_CHAOS_DURATION + value: '30' + + # set chaos interval (in sec) as desired + - name: CHAOS_INTERVAL + value: '10' + + # pod failures without '--force' & default terminationGracePeriodSeconds + - name: FORCE + value: 'false' + + ## percentage of total pods to target + - name: PODS_AFFECTED_PERC + value: '' \ No newline at end of file diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/chaos_schedule.yaml b/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/chaos_schedule.yaml new file mode 100644 index 00000000000..1d089f30b0b --- /dev/null +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/chaos_schedule.yaml @@ -0,0 +1,33 @@ +apiVersion: litmuschaos.io/v1alpha1 +kind: ChaosSchedule +metadata: + name: schedule-nginx + generateName: schedule-nginx +spec: + schedule: + now: true + engineTemplateSpec: + engineState: 'active' + appinfo: + appns: 'default' + applabel: 'app=nginx' + appkind: 'deployment' + annotationCheck: 'true' + chaosServiceAccount: pod-delete-sa + jobCleanUpPolicy: 'delete' + experiments: + - name: pod-delete + spec: + components: + env: + # set chaos duration (in sec) as desired + - name: TOTAL_CHAOS_DURATION + value: '30' + + # set chaos interval (in sec) as desired + - name: CHAOS_INTERVAL + value: '10' + + # pod failures without '--force' & default terminationGracePeriodSeconds + - name: FORCE + value: 'false' \ No newline at end of file diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/cron_workflow.yaml b/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/cron_workflow.yaml new file mode 100644 index 00000000000..d5797bb818c --- /dev/null +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/cron_workflow.yaml @@ -0,0 +1,177 @@ +kind: CronWorkflow +apiVersion: argoproj.io/v1alpha1 +metadata: + name: test-podtato-head-1682669740 + namespace: litmus + creationTimestamp: null + labels: + subject: podtato-head_litmus + workflows.argoproj.io/controller-instanceid: 83c20016-f7ec-4c5d-bb84-3a067a7010c2 +spec: + workflowSpec: + templates: + - name: argowf-chaos + inputs: {} + outputs: {} + metadata: {} + steps: + - - name: install-application + template: install-application + arguments: {} + - - name: install-chaos-experiments + template: install-chaos-experiments + arguments: {} + - - name: pod-delete + template: pod-delete + arguments: {} + - - name: revert-chaos + template: revert-chaos + arguments: {} + - name: delete-application + template: delete-application + arguments: {} + - name: install-application + inputs: {} + outputs: {} + metadata: {} + container: + name: "" + image: litmuschaos/litmus-app-deployer:latest + args: + - -namespace={{workflow.parameters.adminModeNamespace}} + - -typeName=resilient + - -operation=apply + - -timeout=400 + - -app=podtato-head + - -scope=namespace + resources: {} + - name: install-chaos-experiments + inputs: {} + outputs: {} + metadata: {} + container: + name: "" + image: litmuschaos/k8s:latest + command: + - sh + - -c + args: + - kubectl apply -f + https://hub.litmuschaos.io/api/chaos/3.0.0-beta3?file=charts/generic/experiments.yaml + -n {{workflow.parameters.adminModeNamespace}} ; sleep 30 + resources: {} + - name: pod-delete + inputs: + artifacts: + - name: pod-delete + path: /tmp/chaosengine.yaml + raw: + data: > + apiVersion: litmuschaos.io/v1alpha1 + + kind: ChaosEngine + + metadata: + namespace: "{{workflow.parameters.adminModeNamespace}}" + labels: + workflow_run_id: "{{workflow.uid}}" + workflow_name: podtato-head-1683012309 + generateName: podtato-main-pod-delete-chaos + spec: + appinfo: + appns: "{{workflow.parameters.adminModeNamespace}}" + applabel: name=podtato-main + appkind: deployment + engineState: active + chaosServiceAccount: litmus-admin + jobCleanUpPolicy: retain + components: + runner: + imagePullPolicy: Always + experiments: + - name: pod-delete + spec: + probe: + - name: check-podtato-main-access-url + type: httpProbe + httpProbe/inputs: + url: http://podtato-main.{{workflow.parameters.adminModeNamespace}}.svc.cluster.local:9000 + insecureSkipVerify: false + method: + get: + criteria: == + responseCode: "200" + mode: Continuous + runProperties: + probeTimeout: 1 + interval: 1 + retry: 1 + components: + env: + - name: TOTAL_CHAOS_DURATION + value: "30" + - name: CHAOS_INTERVAL + value: "10" + - name: FORCE + value: "false" + outputs: {} + metadata: + labels: + weight: "10" + container: + name: "" + image: litmuschaos/litmus-checker:latest + args: + - -file=/tmp/chaosengine.yaml + - -saveName=/tmp/engine-name + resources: {} + - name: delete-application + inputs: {} + outputs: {} + metadata: {} + container: + name: "" + image: litmuschaos/litmus-app-deployer:latest + args: + - -namespace={{workflow.parameters.adminModeNamespace}} + - -typeName=resilient + - -operation=delete + - -app=podtato-head + resources: {} + - name: revert-chaos + inputs: {} + outputs: {} + metadata: {} + container: + name: "" + image: litmuschaos/k8s:latest + command: + - sh + - -c + args: + - kubectl delete chaosengine -l workflow_run_id={{workflow.uid}} -n + {{workflow.parameters.adminModeNamespace}} + resources: {} + entrypoint: argowf-chaos + arguments: + parameters: + - name: adminModeNamespace + value: litmus + serviceAccountName: argo-chaos + securityContext: + runAsUser: 1000 + runAsNonRoot: true + schedule: 28 16 * * 0-6 + concurrencyPolicy: Forbid + startingDeadlineSeconds: 0 + timezone: Asia/Seoul + workflowMetadata: + creationTimestamp: null + labels: + cluster_id: 83c20016-f7ec-4c5d-bb84-3a067a7010c2 + workflow_id: eb7eb07f-5a60-470a-89e8-7b98ab7e6b11 + workflows.argoproj.io/controller-instanceid: 83c20016-f7ec-4c5d-bb84-3a067a7010c2 +status: + ? active + ? lastScheduledTime + ? conditions diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/workflow.yaml b/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/workflow.yaml new file mode 100644 index 00000000000..994bc5891ba --- /dev/null +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/workflow.yaml @@ -0,0 +1,164 @@ +kind: Workflow +apiVersion: argoproj.io/v1alpha1 +metadata: + name: test-podtato-head-1682669740 + namespace: litmus + creationTimestamp: null + labels: + subject: podtato-head_litmus + workflows.argoproj.io/controller-instanceid: 83c20016-f7ec-4c5d-bb84-3a067a7010c2 +spec: + templates: + - name: argowf-chaos + inputs: {} + outputs: {} + metadata: {} + steps: + - - name: install-application + template: install-application + arguments: {} + - - name: install-chaos-experiments + template: install-chaos-experiments + arguments: {} + - - name: pod-delete + template: pod-delete + arguments: {} + - - name: revert-chaos + template: revert-chaos + arguments: {} + - name: delete-application + template: delete-application + arguments: {} + - name: install-application + inputs: {} + outputs: {} + metadata: {} + container: + name: "" + image: litmuschaos/litmus-app-deployer:latest + args: + - -namespace={{workflow.parameters.adminModeNamespace}} + - -typeName=resilient + - -operation=apply + - -timeout=400 + - -app=podtato-head + - -scope=namespace + resources: {} + - name: install-chaos-experiments + inputs: {} + outputs: {} + metadata: {} + container: + name: "" + image: litmuschaos/k8s:latest + command: + - sh + - -c + args: + - kubectl apply -f + https://hub.litmuschaos.io/api/chaos/3.0.0-beta3?file=charts/generic/experiments.yaml + -n {{workflow.parameters.adminModeNamespace}} ; sleep 30 + resources: {} + - name: pod-delete + inputs: + artifacts: + - name: pod-delete + path: /tmp/chaosengine.yaml + raw: + data: > + apiVersion: litmuschaos.io/v1alpha1 + + kind: ChaosEngine + + metadata: + namespace: "{{workflow.parameters.adminModeNamespace}}" + labels: + workflow_run_id: "{{workflow.uid}}" + generateName: podtato-main-pod-delete-chaos + spec: + appinfo: + appns: "{{workflow.parameters.adminModeNamespace}}" + applabel: name=podtato-main + appkind: deployment + engineState: active + chaosServiceAccount: litmus-admin + jobCleanUpPolicy: retain + components: + runner: + imagePullPolicy: Always + experiments: + - name: pod-delete + spec: + probe: + - name: check-podtato-main-access-url + type: httpProbe + httpProbe/inputs: + url: http://podtato-main.{{workflow.parameters.adminModeNamespace}}.svc.cluster.local:9000 + insecureSkipVerify: false + method: + get: + criteria: == + responseCode: "200" + mode: Continuous + runProperties: + probeTimeout: 1 + interval: 1 + retry: 1 + components: + env: + - name: TOTAL_CHAOS_DURATION + value: "30" + - name: CHAOS_INTERVAL + value: "10" + - name: FORCE + value: "false" + outputs: {} + metadata: + labels: + weight: "10" + container: + name: "" + image: litmuschaos/litmus-checker:latest + args: + - -file=/tmp/chaosengine.yaml + - -saveName=/tmp/engine-name + resources: {} + - name: delete-application + inputs: {} + outputs: {} + metadata: {} + container: + name: "" + image: litmuschaos/litmus-app-deployer:latest + args: + - -namespace={{workflow.parameters.adminModeNamespace}} + - -typeName=resilient + - -operation=delete + - -app=podtato-head + resources: {} + - name: revert-chaos + inputs: {} + outputs: {} + metadata: {} + container: + name: "" + image: litmuschaos/k8s:latest + command: + - sh + - -c + args: + - kubectl delete chaosengine -l workflow_run_id={{workflow.uid}} -n + {{workflow.parameters.adminModeNamespace}} + resources: {} + entrypoint: argowf-chaos + arguments: + parameters: + - name: adminModeNamespace + value: litmus + serviceAccountName: argo-chaos + securityContext: + runAsUser: 1000 + runAsNonRoot: true +status: + ? startedAt + ? finishedAt diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/wrong_type.yaml b/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/wrong_type.yaml new file mode 100644 index 00000000000..b1dab642dc0 --- /dev/null +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks/wrong_type.yaml @@ -0,0 +1,4 @@ +apiVersion: litmuschaos.io/v1alpha1 +kind: Unknown +metadata: + name: wrong \ No newline at end of file From 8147ebd240f5dcaa6d262b43d641dbb9e22e9f1c Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Fri, 18 Aug 2023 18:34:25 +0530 Subject: [PATCH 08/18] fix: missing exp-run operator Signed-off-by: SohamRatnaparkhi --- chaoscenter/graphql/server/graph/resolver.go | 2 +- chaoscenter/graphql/server/pkg/chaos_experiment/service.go | 3 ++- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/chaoscenter/graphql/server/graph/resolver.go b/chaoscenter/graphql/server/graph/resolver.go index 93e249fd938..3d6547c6e75 100644 --- a/chaoscenter/graphql/server/graph/resolver.go +++ b/chaoscenter/graphql/server/graph/resolver.go @@ -50,7 +50,7 @@ func NewConfig(mongodbOperator mongodb.MongoOperator) generated.Config { //service chaosHubService := chaoshub.NewService(chaosHubOperator) chaosInfrastructureService := chaos_infrastructure.NewChaosInfrastructureService(chaosInfraOperator) - chaosExperimentService := chaos_experiment2.NewChaosExperimentService(chaosExperimentOperator, chaosInfraOperator) + chaosExperimentService := chaos_experiment2.NewChaosExperimentService(chaosExperimentOperator, chaosInfraOperator, chaosExperimentRunOperator) chaosExperimentRunService := chaos_experiment_run2.NewChaosExperimentRunService(chaosExperimentOperator, chaosInfraOperator, chaosExperimentRunOperator) gitOpsService := gitops3.NewGitOpsService(gitopsOperator, chaosExperimentService, *chaosExperimentOperator) imageRegistryService := image_registry.NewImageRegistryService(imageRegistryOperator) diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/service.go b/chaoscenter/graphql/server/pkg/chaos_experiment/service.go index ba0409a412f..4abc52d683d 100644 --- a/chaoscenter/graphql/server/pkg/chaos_experiment/service.go +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/service.go @@ -48,10 +48,11 @@ type chaosExperimentService struct { } // NewChaosExperimentService returns a new instance of the chaos workflow service -func NewChaosExperimentService(chaosWorkflowOperator *dbChaosExperiment.Operator, clusterOperator *dbChaosInfra.Operator) Service { +func NewChaosExperimentService(chaosWorkflowOperator *dbChaosExperiment.Operator, clusterOperator *dbChaosInfra.Operator, chaosExperimentRunOperator *dbChaosExperimentRun.Operator) Service { return &chaosExperimentService{ chaosExperimentOperator: chaosWorkflowOperator, chaosInfrastructureOperator: clusterOperator, + chaosExperimentRunOperator: chaosExperimentRunOperator, } } From 9b8e7c4f34ae0c18771f427cf53b5d73495496e4 Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Fri, 18 Aug 2023 18:34:49 +0530 Subject: [PATCH 09/18] feat: service tests Signed-off-by: SohamRatnaparkhi --- .../pkg/chaos_experiment/service_test.go | 497 ++++++++++++++++++ 1 file changed, 497 insertions(+) create mode 100644 chaoscenter/graphql/server/pkg/chaos_experiment/service_test.go diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/service_test.go b/chaoscenter/graphql/server/pkg/chaos_experiment/service_test.go new file mode 100644 index 00000000000..c3b4c941e6e --- /dev/null +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/service_test.go @@ -0,0 +1,497 @@ +package chaos_experiment + +import ( + "context" + "errors" + "io" + "log" + "math/rand" + "os" + "reflect" + "testing" + + "github.com/gin-gonic/gin" + "github.com/google/uuid" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/graph/model" + store "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/data-store" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb" + dbChaosExperiment "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment" + dbChaosExperimentRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment_run" + dbChaosInfra "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_infrastructure" + dbMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/mocks" + "github.com/stretchr/testify/mock" + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/mongo" + "sigs.k8s.io/yaml" +) + +var ( + mongodbMockOperator = new(dbMocks.MongoOperator) + infraOperator = dbChaosInfra.NewInfrastructureOperator(mongodbMockOperator) + chaosExperimentOperator = dbChaosExperiment.NewChaosExperimentOperator(mongodbMockOperator) + chaosExperimentRunOperator = dbChaosExperimentRun.NewChaosExperimentRunOperator(mongodbMockOperator) +) + +var chaosExperimentRunTestService = NewChaosExperimentService(chaosExperimentOperator, infraOperator, chaosExperimentRunOperator) + +func TestMain(m *testing.M) { + gin.SetMode(gin.TestMode) + log.SetOutput(io.Discard) + os.Exit(m.Run()) +} + +func loadYAMLData(path string) (string, error) { + YAMLData, err := os.ReadFile(path) + if err != nil { + return "", err + } + jsonData, err := yaml.YAMLToJSON(YAMLData) + if err != nil { + return "", err + } + return string(jsonData), nil +} + +func TestNewChaosExperimentService(t *testing.T) { + type args struct { + chaosWorkflowOperator *dbChaosExperiment.Operator + clusterOperator *dbChaosInfra.Operator + chaosExperimentRunOperator *dbChaosExperimentRun.Operator + } + tests := []struct { + name string + args args + want Service + }{ + { + name: "NewChaosExperimentService", + args: args{ + chaosWorkflowOperator: chaosExperimentOperator, + clusterOperator: infraOperator, + chaosExperimentRunOperator: chaosExperimentRunOperator, + }, + want: &chaosExperimentService{ + chaosExperimentOperator: chaosExperimentOperator, + chaosInfrastructureOperator: infraOperator, + chaosExperimentRunOperator: chaosExperimentRunOperator, + }, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + if got := NewChaosExperimentService(tc.args.chaosWorkflowOperator, tc.args.clusterOperator, tc.args.chaosExperimentRunOperator); !reflect.DeepEqual(got, tc.want) { + t.Errorf("NewChaosExperimentService() = %v, want %v", got, tc.want) + } + }) + } +} + +func Test_chaosExperimentService_ProcessExperiment(t *testing.T) { + projectID := uuid.NewString() + revID := uuid.NewString() + + commonPath := "./model/mocks/" + yamlTypeMap := map[string]string{ + "workflow": commonPath + "workflow.yaml", + "cron_workflow": commonPath + "cron_workflow.yaml", + "chaos_engine": commonPath + "chaos_engine.yaml", + "chaos_schedule": commonPath + "chaos_schedule.yaml", + "wrong_type": commonPath + "wrong_type.yaml", + } + experimentID := uuid.NewString() + infraID := uuid.NewString() + projectID = uuid.NewString() + + tests := []struct { + experiment *model.ChaosExperimentRequest + name string + given func(experiment *model.ChaosExperimentRequest) + wantErr bool + }{ + { + name: "success: Process Experiment (type-workflow)", + experiment: &model.ChaosExperimentRequest{ + ExperimentID: &experimentID, + InfraID: infraID, + ExperimentName: "test-podtato-head-1682669740", + }, + given: func(experiment *model.ChaosExperimentRequest) { + findResult := bson.D{ + {Key: "infra_id", Value: infraID}, + {Key: "project_id", Value: projectID}, + {Key: "is_active", Value: true}, + {Key: "is_registered", Value: true}, + } + singleResult := mongo.NewSingleResultFromDocument(findResult, nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosInfraCollection, mock.Anything).Return(singleResult, nil).Once() + + yaml, err := loadYAMLData(yamlTypeMap["workflow"]) + if (err != nil) != false { + t.Errorf("chaosExperimentService.ProcessExperiment() error = %v, wantErr %v", err, false) + return + } + experiment.ExperimentManifest = yaml + }, + }, + { + name: "success: Process Experiment (type-cron_workflow)", + experiment: &model.ChaosExperimentRequest{ + ExperimentID: &experimentID, + InfraID: infraID, + ExperimentName: "test-podtato-head-1682669740", + }, + given: func(experiment *model.ChaosExperimentRequest) { + findResult := bson.D{ + {Key: "infra_id", Value: infraID}, + {Key: "project_id", Value: projectID}, + {Key: "is_active", Value: true}, + {Key: "is_registered", Value: true}, + } + singleResult := mongo.NewSingleResultFromDocument(findResult, nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosInfraCollection, mock.Anything).Return(singleResult, nil).Once() + + yaml, err := loadYAMLData(yamlTypeMap["cron_workflow"]) + if (err != nil) != false { + t.Errorf("chaosExperimentService.ProcessExperiment() error = %v, wantErr %v", err, false) + return + } + experiment.ExperimentManifest = yaml + }, + }, + { + name: "success: Process Experiment (type-chaos_engine)", + experiment: &model.ChaosExperimentRequest{ + ExperimentID: &experimentID, + InfraID: infraID, + ExperimentName: "nginx-chaos", + }, + given: func(experiment *model.ChaosExperimentRequest) { + findResult := bson.D{ + {Key: "infra_id", Value: infraID}, + {Key: "project_id", Value: projectID}, + {Key: "is_active", Value: true}, + {Key: "is_registered", Value: true}, + } + singleResult := mongo.NewSingleResultFromDocument(findResult, nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosInfraCollection, mock.Anything).Return(singleResult, nil).Once() + + yaml, err := loadYAMLData(yamlTypeMap["chaos_engine"]) + if (err != nil) != false { + t.Errorf("chaosExperimentService.ProcessExperiment() error = %v, wantErr %v", err, false) + return + } + experiment.ExperimentManifest = yaml + }, + }, + { + name: "success: Process Experiment (type-chaos_schedule)", + experiment: &model.ChaosExperimentRequest{ + ExperimentID: &experimentID, + InfraID: infraID, + ExperimentName: "schedule-nginx", + }, + given: func(experiment *model.ChaosExperimentRequest) { + findResult := bson.D{ + {Key: "infra_id", Value: infraID}, + {Key: "project_id", Value: projectID}, + {Key: "is_active", Value: true}, + {Key: "is_registered", Value: true}, + } + singleResult := mongo.NewSingleResultFromDocument(findResult, nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosInfraCollection, mock.Anything).Return(singleResult, nil).Once() + + yaml, err := loadYAMLData(yamlTypeMap["chaos_schedule"]) + if (err != nil) != false { + t.Errorf("chaosExperimentService.ProcessExperiment() error = %v, wantErr %v", err, false) + return + } + experiment.ExperimentManifest = yaml + }, + }, + { + name: "failure: Process Experiment (type-random(incorrect))", + experiment: &model.ChaosExperimentRequest{ + ExperimentID: &experimentID, + InfraID: infraID, + ExperimentName: "schedule-nginx", + }, + given: func(experiment *model.ChaosExperimentRequest) { + findResult := bson.D{ + {Key: "infra_id", Value: infraID}, + {Key: "project_id", Value: projectID}, + {Key: "is_active", Value: true}, + {Key: "is_registered", Value: true}, + } + singleResult := mongo.NewSingleResultFromDocument(findResult, nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosInfraCollection, mock.Anything).Return(singleResult, nil).Once() + + yaml, err := loadYAMLData(yamlTypeMap["wrong_type"]) + if (err != nil) != false { + t.Errorf("chaosExperimentService.ProcessExperiment() error = %v, wantErr %v", err, false) + return + } + experiment.ExperimentManifest = yaml + }, + wantErr: true, + }, + { + name: "failure: incorrect experiment name", + experiment: &model.ChaosExperimentRequest{ + ExperimentID: &experimentID, + InfraID: infraID, + ExperimentName: "some_random_name", + }, + given: func(experiment *model.ChaosExperimentRequest) { + findResult := bson.D{ + {Key: "infra_id", Value: infraID}, + {Key: "project_id", Value: projectID}, + {Key: "is_active", Value: true}, + {Key: "is_registered", Value: true}, + } + singleResult := mongo.NewSingleResultFromDocument(findResult, nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosInfraCollection, mock.Anything).Return(singleResult, nil).Once() + + yaml, err := loadYAMLData(yamlTypeMap["workflow"]) + if (err != nil) != false { + t.Errorf("chaosExperimentService.ProcessExperiment() error = %v, wantErr %v", err, false) + return + } + experiment.ExperimentManifest = yaml + }, + wantErr: true, + }, + { + name: "failure: unable to unmarshal experiment manifest", + experiment: &model.ChaosExperimentRequest{ + ExperimentID: &experimentID, + InfraID: infraID, + ExperimentName: "some_name", + }, + given: func(experiment *model.ChaosExperimentRequest) { + findResult := bson.D{ + {Key: "infra_id", Value: infraID}, + {Key: "project_id", Value: projectID}, + {Key: "is_active", Value: true}, + {Key: "is_registered", Value: true}, + } + singleResult := mongo.NewSingleResultFromDocument(findResult, nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosInfraCollection, mock.Anything).Return(singleResult, nil).Once() + + yaml := "{\"kind\": \"SomeKubernetesKind\", \"apiVersion\": \"v1\", \"metadata\": {\"name\": \"some-name\"}" + experiment.ExperimentManifest = yaml + }, + wantErr: true, + }, + { + name: "failure: inactive infra", + experiment: &model.ChaosExperimentRequest{ + ExperimentID: &experimentID, + InfraID: infraID, + ExperimentName: "test-podtato-head-1682669740", + }, + given: func(_ *model.ChaosExperimentRequest) { + findResult := bson.D{ + {Key: "infra_id", Value: infraID}, + {Key: "project_id", Value: projectID}, + } + singleResult := mongo.NewSingleResultFromDocument(findResult, nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosInfraCollection, mock.Anything).Return(singleResult, nil).Once() + }, + wantErr: true, + }, + { + name: "failure: incorrect project ID", + experiment: &model.ChaosExperimentRequest{ + ExperimentID: &experimentID, + InfraID: infraID, + ExperimentName: "test-podtato-head-1682669740", + }, + given: func(_ *model.ChaosExperimentRequest) { + findResult := bson.D{ + {Key: "infra_id", Value: infraID}, + {Key: "project_id", Value: uuid.NewString()}, + {Key: "is_active", Value: true}, + } + singleResult := mongo.NewSingleResultFromDocument(findResult, nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosInfraCollection, mock.Anything).Return(singleResult, nil).Once() + }, + wantErr: true, + }, + { + name: "failure: mongo returns empty result", + experiment: &model.ChaosExperimentRequest{ + ExperimentID: &experimentID, + InfraID: infraID, + ExperimentName: "test-podtato-head-1682669740", + }, + given: func(_ *model.ChaosExperimentRequest) { + singleResult := mongo.NewSingleResultFromDocument(nil, nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosInfraCollection, mock.Anything).Return(singleResult, errors.New("nil single result returned")).Once() + }, + wantErr: true, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + tc.given(tc.experiment) + _, _, err := chaosExperimentRunTestService.ProcessExperiment(tc.experiment, projectID, revID) + if (err != nil) != tc.wantErr { + t.Errorf("chaosExperimentService.ProcessExperiment() error = %v, wantErr %v", err, tc.wantErr) + return + } + }) + } +} + +func Test_chaosExperimentService_ProcessExperimentCreation(t *testing.T) { + type args struct { + input *model.ChaosExperimentRequest + } + ctx := context.Background() + store := store.NewStore() + experimentID := uuid.NewString() + projectID := uuid.NewString() + revisionID := uuid.NewString() + infraID := uuid.NewString() + username := "test" + wfType := dbChaosExperiment.NonCronExperiment + + tests := []struct { + name string + args args + given func() + wantErr bool + }{ + { + name: "success: Process Experiment Creation", + args: args{ + input: &model.ChaosExperimentRequest{ + ExperimentID: &experimentID, + InfraID: infraID, + }, + }, + given: func() { + mongodbMockOperator.On("Create", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(nil) + }, + }, + { + name: "success: Process Experiment Creation with weights", + args: args{ + input: &model.ChaosExperimentRequest{ + ExperimentID: &experimentID, + InfraID: infraID, + Weightages: []*model.WeightagesInput{ + { + Weightage: rand.Int(), + }, + }, + }, + }, + given: func() { + mongodbMockOperator.On("Create", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(nil) + }, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + tc.given() + if err := chaosExperimentRunTestService.ProcessExperimentCreation(ctx, tc.args.input, username, projectID, &wfType, revisionID, store); (err != nil) != tc.wantErr { + t.Errorf("chaosExperimentService.ProcessExperimentCreation() error = %v, wantErr %v", err, tc.wantErr) + } + }) + } +} + +func Test_chaosExperimentService_ProcessExperimentUpdate(t *testing.T) { + type args struct { + workflow *model.ChaosExperimentRequest + updateRevision bool + } + username := "test" + wfType := dbChaosExperiment.NonCronExperiment + revisionID := uuid.NewString() + infraID := uuid.NewString() + projectID := uuid.NewString() + store := store.NewStore() + tests := []struct { + name string + args args + given func() + wantErr bool + }{ + { + name: "success: Process Experiment Update", + args: args{ + workflow: &model.ChaosExperimentRequest{ + Weightages: []*model.WeightagesInput{ + { + FaultName: "pod-delete", + }, + }, + InfraID: infraID, + ExperimentManifest: "{\"kind\": \"SomeKubernetesKind\", \"apiVersion\": \"v1\", \"metadata\": {\"name\": \"some-name\"}}", + }, + updateRevision: true, + }, + given: func() { + updateResult := &mongo.UpdateResult{ + MatchedCount: 1, + } + mongodbMockOperator.On("Update", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything, mock.Anything).Return(updateResult, nil).Once() + }, + wantErr: false, + }, + { + name: "failure: incorrect experiment manifest", + args: args{ + workflow: &model.ChaosExperimentRequest{ + Weightages: []*model.WeightagesInput{ + { + FaultName: "pod-delete", + }, + }, + InfraID: infraID, + ExperimentManifest: "{\"test\": \"name\"}", + }, + updateRevision: true, + }, + given: func() { + updateResult := &mongo.UpdateResult{ + MatchedCount: 1, + } + mongodbMockOperator.On("Update", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything, mock.Anything).Return(updateResult, nil).Once() + }, + wantErr: true, + }, + { + name: "failure: failed to update experiment", + args: args{ + workflow: &model.ChaosExperimentRequest{ + Weightages: []*model.WeightagesInput{ + { + FaultName: "pod-delete", + }, + }, + InfraID: infraID, + ExperimentManifest: "{\"kind\": \"SomeKubernetesKind\", \"apiVersion\": \"v1\", \"metadata\": {\"name\": \"some-name\"}}", + }, + updateRevision: true, + }, + given: func() { + updateResult := &mongo.UpdateResult{ + MatchedCount: 1, + } + mongodbMockOperator.On("Update", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything, mock.Anything).Return(updateResult, errors.New("error while updating")).Once() + }, + wantErr: true, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + tc.given() + if err := chaosExperimentRunTestService.ProcessExperimentUpdate(tc.args.workflow, username, &wfType, revisionID, tc.args.updateRevision, projectID, store); (err != nil) != tc.wantErr { + t.Errorf("chaosExperimentService.ProcessExperimentUpdate() error = %v, wantErr %v", err, tc.wantErr) + } + }) + } +} From 54afc14e2c8608b5198e5ef9856edea1f728a5f0 Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Fri, 18 Aug 2023 18:35:00 +0530 Subject: [PATCH 10/18] feat: handler tests Signed-off-by: SohamRatnaparkhi --- .../chaos_experiment/handler/handler_test.go | 767 ++++++++++++++++++ 1 file changed, 767 insertions(+) create mode 100644 chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go b/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go new file mode 100644 index 00000000000..54b24e42547 --- /dev/null +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go @@ -0,0 +1,767 @@ +package handler + +import ( + "context" + "errors" + "reflect" + "testing" + + "github.com/golang-jwt/jwt" + "github.com/google/uuid" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/graph/model" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/authorization" + types "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment" + choasExperimentMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_infrastructure" + chaosInfraMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_infrastructure/model/mocks" + chaosExperimentRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/choas_experiment_run" + choasExperimentRunMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/choas_experiment_run/model/mocks" + store "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/data-store" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb" + dbChoasInfra "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_infrastructure" + "github.com/stretchr/testify/mock" + + dbChaosExperiment "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment" + dbChaosExperimentRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment_run" + dbMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/mocks" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/gitops" + dbGitOpsMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/gitops/model/mocks" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/utils" + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/mongo" +) + +var ( + mongodbMockOperator = new(dbMocks.MongoOperator) + infrastructureService = new(chaosInfraMocks.InfraService) + chaosExperimentRunService = new(choasExperimentRunMocks.ChaosExperimentRunService) + gitOpsService = new(dbGitOpsMocks.GitOpsService) + chaosExperimentOperator = dbChaosExperiment.NewChaosExperimentOperator(mongodbMockOperator) + chaosExperimentRunOperator = dbChaosExperimentRun.NewChaosExperimentRunOperator(mongodbMockOperator) + chaosExperimentService = new(choasExperimentMocks.ChaosExperimentService) +) + +var chaosExperimentHandler = NewChaosExperimentHandler(chaosExperimentService, chaosExperimentRunService, infrastructureService, gitOpsService, chaosExperimentOperator, chaosExperimentRunOperator, mongodbMockOperator) + +func TestNewChaosExperimentHandler(t *testing.T) { + type args struct { + chaosExperimentService types.Service + chaosExperimentRunService chaosExperimentRun.Service + infrastructureService chaos_infrastructure.Service + gitOpsService gitops.Service + chaosExperimentOperator *dbChaosExperiment.Operator + chaosExperimentRunOperator *dbChaosExperimentRun.Operator + mongodbOperator mongodb.MongoOperator + } + tests := []struct { + name string + args args + want *ChaosExperimentHandler + }{ + { + name: "NewChaosExperimentHandler", + args: args{ + chaosExperimentService: chaosExperimentService, + chaosExperimentRunService: chaosExperimentRunService, + infrastructureService: infrastructureService, + gitOpsService: gitOpsService, + chaosExperimentOperator: chaosExperimentOperator, + chaosExperimentRunOperator: chaosExperimentRunOperator, + mongodbOperator: mongodbMockOperator, + }, + want: &ChaosExperimentHandler{ + chaosExperimentService: chaosExperimentService, + chaosExperimentRunService: chaosExperimentRunService, + infrastructureService: infrastructureService, + gitOpsService: gitOpsService, + chaosExperimentOperator: chaosExperimentOperator, + chaosExperimentRunOperator: chaosExperimentRunOperator, + mongodbOperator: mongodbMockOperator, + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + if got := NewChaosExperimentHandler(tt.args.chaosExperimentService, tt.args.chaosExperimentRunService, tt.args.infrastructureService, tt.args.gitOpsService, tt.args.chaosExperimentOperator, tt.args.chaosExperimentRunOperator, tt.args.mongodbOperator); !reflect.DeepEqual(got, tt.want) { + t.Errorf("NewChaosExperimentHandler() = %v, want %v", got, tt.want) + } + }) + } +} +func TestChaosExperimentHandler_SaveChaosExperiment(t *testing.T) { + type args struct { + request model.SaveChaosExperimentRequest + request2 *model.ChaosExperimentRequest + projectID string + } + + username, _ := jwt.NewWithClaims(jwt.SigningMethodHS512, jwt.MapClaims{"username": "test"}).SignedString([]byte(utils.Config.JwtSecret)) + ctx := context.Background() + projectId := uuid.New().String() + experimentId := uuid.New().String() + experimentType := dbChaosExperiment.NonCronExperiment + infraId := uuid.New().String() + + store := store.NewStore() + tests := []struct { + name string + args args + wantErr bool + given func(request *model.ChaosExperimentRequest) + }{ + { + name: "Save Chaos Experiment", + args: args{ + projectID: projectId, + request: model.SaveChaosExperimentRequest{ + ID: experimentId, + Type: &model.AllExperimentType[0], + InfraID: infraId, + }, + request2: &model.ChaosExperimentRequest{ + ExperimentID: &experimentId, + InfraID: infraId, + ExperimentType: &model.AllExperimentType[0], + }, + }, + given: func(request2 *model.ChaosExperimentRequest) { + ctx = context.WithValue(ctx, authorization.AuthKey, username) + findResult := []interface{}{bson.D{ + {Key: "experiment_id", Value: experimentId}, + }} + singleResult := mongo.NewSingleResultFromDocument(findResult[0], nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(singleResult, nil).Once() + + chaosExperimentService.On("ProcessExperiment", request2, mock.Anything, mock.Anything).Return(request2, &experimentType, nil).Once() + + chaosExperimentService.On("ProcessExperimentUpdate", request2, mock.Anything, mock.Anything, mock.Anything, false, mock.Anything, mock.Anything).Return(nil).Once() + + chaosExperimentService.On("ProcessExperimentCreation", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, nil).Return(nil).Once() + }, + wantErr: false, + }, + { + name: "Failure: mongo error", + args: args{ + projectID: projectId, + request: model.SaveChaosExperimentRequest{ + ID: experimentId, + Type: &model.AllExperimentType[0], + InfraID: infraId, + }, + request2: &model.ChaosExperimentRequest{ + ExperimentID: &experimentId, + InfraID: infraId, + ExperimentType: &model.AllExperimentType[0], + }, + }, + given: func(request2 *model.ChaosExperimentRequest) { + ctx = context.WithValue(ctx, authorization.AuthKey, username) + singleResult := mongo.NewSingleResultFromDocument(nil, nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(singleResult, errors.New("single result error")).Once() + }, + wantErr: true, + }, + { + name: "Failed to process experiment", + args: args{ + projectID: projectId, + request: model.SaveChaosExperimentRequest{ + ID: experimentId, + Type: &model.AllExperimentType[0], + InfraID: infraId, + }, + request2: &model.ChaosExperimentRequest{ + ExperimentID: &experimentId, + InfraID: infraId, + ExperimentType: &model.AllExperimentType[0], + }, + }, + given: func(request2 *model.ChaosExperimentRequest) { + ctx = context.WithValue(ctx, authorization.AuthKey, username) + findResult := []interface{}{bson.D{ + {Key: "experiment_id", Value: experimentId}, + }} + singleResult := mongo.NewSingleResultFromDocument(findResult[0], nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(singleResult, nil).Once() + + chaosExperimentService.On("ProcessExperiment", request2, mock.Anything, mock.Anything).Return(request2, &experimentType, errors.New("Incorrect request format")).Once() + }, + wantErr: true, + }, + { + name: "Failed to create experiment", + args: args{ + projectID: projectId, + request: model.SaveChaosExperimentRequest{ + ID: experimentId, + Type: &model.AllExperimentType[0], + InfraID: infraId, + }, + request2: &model.ChaosExperimentRequest{ + ExperimentID: &experimentId, + InfraID: infraId, + ExperimentType: &model.AllExperimentType[0], + }, + }, + given: func(request2 *model.ChaosExperimentRequest) { + ctx = context.WithValue(ctx, authorization.AuthKey, username) + findResult := []interface{}{bson.D{ + {Key: "experiment_id", Value: experimentId}, + }} + singleResult := mongo.NewSingleResultFromDocument(findResult[0], nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(singleResult, nil).Once() + + chaosExperimentService.On("ProcessExperiment", request2, mock.Anything, mock.Anything).Return(request2, &experimentType, nil).Once() + + chaosExperimentService.On("ProcessExperimentUpdate", request2, mock.Anything, mock.Anything, mock.Anything, false, mock.Anything, mock.Anything).Return(nil).Once() + + chaosExperimentService.On("ProcessExperimentCreation", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, nil).Return(errors.New("experiment creation failed")).Once() + }, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + tc.given(tc.args.request2) + _, err := chaosExperimentHandler.SaveChaosExperiment(ctx, tc.args.request, tc.args.projectID, store) + if (err != nil) != tc.wantErr { + t.Errorf("ChaosExperimentHandler.SaveChaosExperiment() error = %v, wantErr %v", err, tc.wantErr) + return + } + }) + } +} + +func TestChaosExperimentHandler_CreateChaosExperiment(t *testing.T) { + type fields struct { + chaosExperimentService types.Service + chaosExperimentRunService chaosExperimentRun.Service + infrastructureService chaos_infrastructure.Service + gitOpsService gitops.Service + chaosExperimentOperator *dbChaosExperiment.Operator + chaosExperimentRunOperator *dbChaosExperimentRun.Operator + mongodbOperator mongodb.MongoOperator + } + type args struct { + ctx context.Context + request *model.ChaosExperimentRequest + projectID string + r *store.StateData + } + tests := []struct { + name string + fields fields + args args + want *model.ChaosExperimentResponse + wantErr bool + }{ + // TODO: Add test cases. + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + c := &ChaosExperimentHandler{ + chaosExperimentService: tt.fields.chaosExperimentService, + chaosExperimentRunService: tt.fields.chaosExperimentRunService, + infrastructureService: tt.fields.infrastructureService, + gitOpsService: tt.fields.gitOpsService, + chaosExperimentOperator: tt.fields.chaosExperimentOperator, + chaosExperimentRunOperator: tt.fields.chaosExperimentRunOperator, + mongodbOperator: tt.fields.mongodbOperator, + } + got, err := c.CreateChaosExperiment(tt.args.ctx, tt.args.request, tt.args.projectID, tt.args.r) + if (err != nil) != tt.wantErr { + t.Errorf("ChaosExperimentHandler.CreateChaosExperiment() error = %v, wantErr %v", err, tt.wantErr) + return + } + if !reflect.DeepEqual(got, tt.want) { + t.Errorf("ChaosExperimentHandler.CreateChaosExperiment() = %v, want %v", got, tt.want) + } + }) + } +} + +func TestChaosExperimentHandler_DeleteChaosExperiment(t *testing.T) { + username, _ := jwt.NewWithClaims(jwt.SigningMethodHS512, jwt.MapClaims{"username": "test"}).SignedString([]byte(utils.Config.JwtSecret)) + ctx := context.TODO() + projectId := uuid.New().String() + experimentId := uuid.New().String() + experimentRunID := uuid.New().String() + store := store.NewStore() + + tests := []struct { + name string + given func() + wantErr bool + }{ + { + name: "success: Delete Chaos Experiment", + given: func() { + ctx = context.WithValue(ctx, authorization.AuthKey, username) + findResult := []interface{}{bson.D{ + {Key: "experiment_id", Value: experimentId}, + {Key: "experiment_runs", Value: []*dbChaosExperimentRun.ChaosExperimentRun{ + {ExperimentRunID: experimentRunID}, + }}, + }} + singleResult := mongo.NewSingleResultFromDocument(findResult[0], nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(singleResult, nil).Once() + + chaosExperimentService.On("ProcessExperimentUpdate", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once() + + chaosExperimentService.On("ProcessExperimentDelete", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once() + + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything).Return(singleResult, nil).Once() + + chaosExperimentRunService.On("ProcessExperimentRunDelete", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once() + }, + wantErr: false, + }, + { + name: "failure: mongo error while retrieving the experiment details", + given: func() { + ctx = context.WithValue(ctx, authorization.AuthKey, username) + findResult := []interface{}{bson.D{ + {Key: "experiment_id", Value: experimentId}, + {Key: "experiment_runs", Value: []*dbChaosExperimentRun.ChaosExperimentRun{ + {ExperimentRunID: experimentRunID}, + }}, + }} + singleResult := mongo.NewSingleResultFromDocument(findResult[0], nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(singleResult, errors.New("error retrieving the experiments")).Once() + }, + wantErr: true, + }, + { + name: "failure: mongo error while retrieving the experiment run details", + given: func() { + ctx = context.WithValue(ctx, authorization.AuthKey, username) + findResult := []interface{}{bson.D{ + {Key: "experiment_id", Value: experimentId}, + {Key: "experiment_runs", Value: []*dbChaosExperimentRun.ChaosExperimentRun{ + {ExperimentRunID: experimentRunID}, + }}, + }} + singleResult := mongo.NewSingleResultFromDocument(findResult[0], nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(singleResult, nil).Once() + + chaosExperimentService.On("ProcessExperimentUpdate", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once() + + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything).Return(singleResult, errors.New("error retrieving the experiment runs")).Once() + }, + wantErr: true, + }, + { + name: "failure: unable to delete experiment-runs", + given: func() { + ctx = context.WithValue(ctx, authorization.AuthKey, username) + findResult := []interface{}{bson.D{ + {Key: "experiment_id", Value: experimentId}, + {Key: "experiment_runs", Value: []*dbChaosExperimentRun.ChaosExperimentRun{ + {ExperimentRunID: experimentRunID}, + }}, + }} + singleResult := mongo.NewSingleResultFromDocument(findResult[0], nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(singleResult, nil).Once() + + chaosExperimentService.On("ProcessExperimentUpdate", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once() + + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything).Return(singleResult, nil).Once() + chaosExperimentService.On("ProcessExperimentDelete", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once() + + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything).Return(singleResult, nil).Once() + + chaosExperimentRunService.On("ProcessExperimentRunDelete", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New("")).Once() + }, + wantErr: true, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + tc.given() + _, err := chaosExperimentHandler.DeleteChaosExperiment(ctx, projectId, experimentId, &experimentRunID, store) + if (err != nil) != tc.wantErr { + t.Errorf("ChaosExperimentHandler.DeleteChaosExperiment() error = %v, wantErr %v", err, tc.wantErr) + return + } + }) + } +} + +func TestChaosExperimentHandler_UpdateChaosExperiment(t *testing.T) { + type args struct { + request *model.ChaosExperimentRequest + projectID string + } + username, _ := jwt.NewWithClaims(jwt.SigningMethodHS512, jwt.MapClaims{"username": "test"}).SignedString([]byte(utils.Config.JwtSecret)) + ctx := context.Background() + projectId := uuid.New().String() + infraId := uuid.New().String() + experimentId := uuid.New().String() + experimentType := dbChaosExperiment.NonCronExperiment + + store := store.NewStore() + tests := []struct { + name string + args args + given func(request *model.ChaosExperimentRequest) + wantErr bool + }{ + { + name: "Update Chaos Experiment", + + args: args{ + projectID: projectId, + request: &model.ChaosExperimentRequest{ + ExperimentID: &experimentId, + InfraID: infraId, + ExperimentType: &model.AllExperimentType[0], + }, + }, + given: func(request *model.ChaosExperimentRequest) { + ctx = context.WithValue(ctx, authorization.AuthKey, username) + + chaosExperimentService.On("ProcessExperiment", mock.Anything, mock.Anything, mock.Anything).Return(request, &experimentType, nil).Once() + + chaosExperimentService.On("ProcessExperimentUpdate", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once() + }, + wantErr: false, + }, + { + name: "Failed to process experiment", + args: args{ + projectID: projectId, + request: &model.ChaosExperimentRequest{ + ExperimentID: &experimentId, + InfraID: infraId, + ExperimentType: &model.AllExperimentType[0], + }, + }, + given: func(request *model.ChaosExperimentRequest) { + ctx = context.WithValue(ctx, authorization.AuthKey, username) + + chaosExperimentService.On("ProcessExperiment", mock.Anything, mock.Anything, mock.Anything).Return(request, &experimentType, errors.New("Incorrect request format")).Once() + }, + wantErr: true, + }, + { + name: "Update failed", + args: args{ + projectID: projectId, + request: &model.ChaosExperimentRequest{ + ExperimentID: &experimentId, + InfraID: infraId, + ExperimentType: &model.AllExperimentType[0], + }, + }, + given: func(request *model.ChaosExperimentRequest) { + ctx = context.WithValue(ctx, authorization.AuthKey, username) + + chaosExperimentService.On("ProcessExperiment", mock.Anything, mock.Anything, mock.Anything).Return(request, &experimentType, nil).Once() + + chaosExperimentService.On("ProcessExperimentUpdate", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New("experiment update failed")).Once() + }, + wantErr: true, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + tc.given(tc.args.request) + _, err := chaosExperimentHandler.UpdateChaosExperiment(ctx, tc.args.request, tc.args.projectID, store) + if (err != nil) != tc.wantErr { + t.Errorf("ChaosExperimentHandler.UpdateChaosExperiment() error = %v, wantErr %v", err, tc.wantErr) + return + } + }) + } +} + +func TestChaosExperimentHandler_GetExperiment(t *testing.T) { + projectId := uuid.New().String() + experimentId := uuid.New().String() + infraId := uuid.New().String() + ctx := context.Background() + tests := []struct { + name string + given func() + wantErr bool + }{ + { + name: "success: Get Experiment", + given: func() { + findResult := []interface{}{bson.D{ + {Key: "project_id", Value: projectId}, + {Key: "infra_id", Value: infraId}, + {Key: "kubernetesInfraDetails", Value: []dbChoasInfra.ChaosInfra{ + { + ProjectID: projectId, + InfraID: infraId, + }, + }}, + { + Key: "revision", Value: []dbChaosExperiment.ExperimentRevision{ + { + RevisionID: uuid.NewString(), + }, + }, + }, + }} + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() + }, + wantErr: false, + }, + { + name: "failure: Kubernetes infra details absent", + given: func() { + findResult := []interface{}{bson.D{ + {Key: "project_id", Value: projectId}, + {Key: "infra_id", Value: infraId}, + }} + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything).Return(cursor, errors.New("kubernetes infra details absent")).Once() + }, + wantErr: true, + }, + { + name: "failure: Absent experiment run details", + given: func() { + findResult := []interface{}{bson.D{ + {Key: "project_id", Value: projectId}, + {Key: "infra_id", Value: infraId}, + {Key: "kubernetesInfraDetails", Value: []dbChoasInfra.ChaosInfra{ + { + ProjectID: projectId, + InfraID: infraId, + }, + }}, + }} + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything).Return(cursor, errors.New("experiment run details absent")).Once() + }, + wantErr: true, + }, + { + name: "failure: empty mongo cursor returned", + given: func() { + cursor, _ := mongo.NewCursorFromDocuments(nil, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything).Return(cursor, errors.New("experiment run details absent")).Once() + }, + wantErr: true, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + tc.given() + _, err := chaosExperimentHandler.GetExperiment(ctx, projectId, experimentId) + if (err != nil) != tc.wantErr { + t.Errorf("ChaosExperimentHandler.GetExperiment() error = %v, wantErr %v", err, tc.wantErr) + return + } + }) + } +} + +func TestChaosExperimentHandler_ListExperiment(t *testing.T) { + type args struct { + projectID string + request model.ListExperimentRequest + } + projectId := uuid.New().String() + infraId := uuid.New().String() + findResult := []interface{}{ + bson.D{ + {Key: "project_id", Value: projectId}, + {Key: "infra_id", Value: infraId}, + }, + } + tests := []struct { + name string + args args + given func() + wantErr bool + }{ + { + name: "List Experiment", + args: args{ + projectID: projectId, + request: model.ListExperimentRequest{ + ExperimentIDs: []*string{&infraId}, + Pagination: &model.Pagination{Page: 1}, + }, + }, + given: func() { + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() + }, + wantErr: false, + }, + { + name: "success: sorting in descending order of name", + args: args{ + projectID: projectId, + request: model.ListExperimentRequest{ + ExperimentIDs: []*string{&infraId}, + Pagination: &model.Pagination{Page: 1}, + Sort: &model.ExperimentSortInput{ + Field: model.ExperimentSortingFieldName, + }, + }, + }, + given: func() { + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() + }, + wantErr: false, + }, + { + name: "success: sorting in descending order of time", + args: args{ + projectID: projectId, + request: model.ListExperimentRequest{ + ExperimentIDs: []*string{&infraId}, + Pagination: &model.Pagination{Page: 1}, + Sort: &model.ExperimentSortInput{ + Field: model.ExperimentSortingFieldTime, + }, + }, + }, + given: func() { + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() + }, + wantErr: false, + }, + { + name: "failure: listing experiment", + args: args{ + projectID: projectId, + request: model.ListExperimentRequest{ + ExperimentIDs: []*string{&infraId}, + Pagination: &model.Pagination{Page: 1}, + }, + }, + given: func() { + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything).Return(cursor, errors.New("failed aggregating experiments")).Once() + }, + wantErr: true, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + tc.given() + _, err := chaosExperimentHandler.ListExperiment(tc.args.projectID, tc.args.request) + if (err != nil) != tc.wantErr { + t.Errorf("ChaosExperimentHandler.ListExperiment() error = %v, wantErr %v", err, tc.wantErr) + return + } + }) + } +} + +func TestChaosExperimentHandler_DisableCronExperiment(t *testing.T) { + username, _ := jwt.NewWithClaims(jwt.SigningMethodHS512, jwt.MapClaims{"username": "test"}).SignedString([]byte(utils.Config.JwtSecret)) + projectID := uuid.New().String() + experimentID := uuid.New().String() + infraID := uuid.New().String() + experimentRequest := dbChaosExperiment.ChaosExperimentRequest{ + ExperimentID: experimentID, + InfraID: infraID, + Revision: []dbChaosExperiment.ExperimentRevision{ + { + RevisionID: uuid.New().String(), + }, + }, + } + store := store.NewStore() + tests := []struct { + name string + given func() + wantErr bool + }{ + { + name: "Success: Disable Cron Experiment", + given: func() { + chaosExperimentService.On("ProcessExperimentUpdate", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once() + }, + wantErr: false, + }, + { + name: "Failure: mongo error while updating the experiment details", + given: func() { + chaosExperimentService.On("ProcessExperimentUpdate", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New("error while updating")).Once() + }, + wantErr: true, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + tc.given() + if err := chaosExperimentHandler.DisableCronExperiment(username, experimentRequest, projectID, store); (err != nil) != tc.wantErr { + t.Errorf("ChaosExperimentHandler.DisableCronExperiment() error = %v, wantErr %v", err, tc.wantErr) + } + }) + } +} + +func TestChaosExperimentHandler_GetExperimentStats(t *testing.T) { + ctx := context.Background() + projectID := uuid.New().String() + tests := []struct { + name string + wantErr bool + given func() + }{ + { + name: "success: get experiment stats", + given: func() { + username, _ := jwt.NewWithClaims(jwt.SigningMethodHS512, jwt.MapClaims{"username": "test"}).SignedString([]byte(utils.Config.JwtSecret)) + ctx = context.WithValue(ctx, authorization.AuthKey, username) + findResult := []interface{}{ + bson.D{ + {Key: "project_id", Value: projectID}, + }, + } + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() + }, + wantErr: false, + }, + { + name: "failure: empty cursor returned", + given: func() { + username, _ := jwt.NewWithClaims(jwt.SigningMethodHS512, jwt.MapClaims{"username": "test"}).SignedString([]byte(utils.Config.JwtSecret)) + ctx = context.WithValue(ctx, authorization.AuthKey, username) + cursor, _ := mongo.NewCursorFromDocuments(nil, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything).Return(cursor, errors.New("empty cursor returned")).Once() + }, + wantErr: true, + }, + { + name: "failure: getting experiment stats", + given: func() { + username, _ := jwt.NewWithClaims(jwt.SigningMethodHS512, jwt.MapClaims{"username": "test"}).SignedString([]byte(utils.Config.JwtSecret)) + ctx = context.WithValue(ctx, authorization.AuthKey, username) + findResult := []interface{}{ + bson.D{ + {Key: "project_id", Value: projectID}, + }, + } + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything).Return(cursor, errors.New("failed to get experiment stats")).Once() + }, + wantErr: true, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + tc.given() + _, err := chaosExperimentHandler.GetExperimentStats(ctx, projectID) + if (err != nil) != tc.wantErr { + t.Errorf("ChaosExperimentHandler.GetExperimentStats() error = %v, wantErr %v", err, tc.wantErr) + return + } + }) + } +} From 6f2a97e1ab31e2ba9c7c15a75dba24c9b4dc52cc Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Sun, 27 Aug 2023 18:36:30 +0530 Subject: [PATCH 11/18] fix: errors due to package restructure conflicts with upstream Signed-off-by: SohamRatnaparkhi --- .../pkg/chaos_experiment/handler/handler_test.go | 2 +- .../server/pkg/chaos_experiment/ops/service.go | 14 ++------------ .../pkg/chaos_experiment/{ => ops}/service_test.go | 4 ++-- 3 files changed, 5 insertions(+), 15 deletions(-) rename chaoscenter/graphql/server/pkg/chaos_experiment/{ => ops}/service_test.go (99%) diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go b/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go index 54b24e42547..ec87cc0d52a 100644 --- a/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go @@ -10,8 +10,8 @@ import ( "github.com/google/uuid" "github.com/litmuschaos/litmus/chaoscenter/graphql/server/graph/model" "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/authorization" - types "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment" choasExperimentMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks" + types "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment/ops" "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_infrastructure" chaosInfraMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_infrastructure/model/mocks" chaosExperimentRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/choas_experiment_run" diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/ops/service.go b/chaoscenter/graphql/server/pkg/chaos_experiment/ops/service.go index 23e993228b2..f539469f9de 100644 --- a/chaoscenter/graphql/server/pkg/chaos_experiment/ops/service.go +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/ops/service.go @@ -8,9 +8,6 @@ import ( "strings" "time" - chaosTypes "github.com/litmuschaos/chaos-operator/api/litmuschaos/v1alpha1" - "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/probe" - "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_infrastructure" "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb" @@ -29,7 +26,7 @@ import ( "github.com/argoproj/argo-workflows/v3/pkg/apis/workflow/v1alpha1" "github.com/ghodss/yaml" "github.com/google/uuid" - + chaosTypes "github.com/litmuschaos/chaos-operator/api/litmuschaos/v1alpha1" scheduleTypes "github.com/litmuschaos/chaos-scheduler/api/litmuschaos/v1alpha1" "go.mongodb.org/mongo-driver/bson" v1 "k8s.io/apimachinery/pkg/apis/meta/v1" @@ -150,12 +147,6 @@ func (c *chaosExperimentService) ProcessExperimentCreation(ctx context.Context, weightages []*dbChaosExperiment.WeightagesInput revision []dbChaosExperiment.ExperimentRevision ) - - probes, err := probe.ParseProbesFromManifest(wfType, input.ExperimentManifest) - if err != nil { - return err - } - if input.Weightages != nil { //TODO: Once we make the new chaos terminology change in APIs, then we can we the copier instead of for loop for _, v := range input.Weightages { @@ -173,7 +164,6 @@ func (c *chaosExperimentService) ProcessExperimentCreation(ctx context.Context, ExperimentManifest: input.ExperimentManifest, UpdatedAt: timeNow, Weightages: weightages, - Probes: probes, }) newChaosExperiment := dbChaosExperiment.ChaosExperimentRequest{ @@ -199,7 +189,7 @@ func (c *chaosExperimentService) ProcessExperimentCreation(ctx context.Context, RecentExperimentRunDetails: []dbChaosExperiment.ExperimentRunDetail{}, } - err = c.chaosExperimentOperator.InsertChaosExperiment(ctx, newChaosExperiment) + err := c.chaosExperimentOperator.InsertChaosExperiment(ctx, newChaosExperiment) if err != nil { return err } diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/service_test.go b/chaoscenter/graphql/server/pkg/chaos_experiment/ops/service_test.go similarity index 99% rename from chaoscenter/graphql/server/pkg/chaos_experiment/service_test.go rename to chaoscenter/graphql/server/pkg/chaos_experiment/ops/service_test.go index c3b4c941e6e..4e515011426 100644 --- a/chaoscenter/graphql/server/pkg/chaos_experiment/service_test.go +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/ops/service_test.go @@ -1,4 +1,4 @@ -package chaos_experiment +package ops import ( "context" @@ -90,7 +90,7 @@ func Test_chaosExperimentService_ProcessExperiment(t *testing.T) { projectID := uuid.NewString() revID := uuid.NewString() - commonPath := "./model/mocks/" + commonPath := "../model/mocks/" yamlTypeMap := map[string]string{ "workflow": commonPath + "workflow.yaml", "cron_workflow": commonPath + "cron_workflow.yaml", From d7e7421fa21d43359372c26e0887391379207499 Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Sun, 17 Sep 2023 13:16:44 +0530 Subject: [PATCH 12/18] fix: infra resolver bug Signed-off-by: SohamRatnaparkhi --- chaoscenter/graphql/server/graph/resolver.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/chaoscenter/graphql/server/graph/resolver.go b/chaoscenter/graphql/server/graph/resolver.go index c9891bb27df..4dcaaa98619 100644 --- a/chaoscenter/graphql/server/graph/resolver.go +++ b/chaoscenter/graphql/server/graph/resolver.go @@ -54,7 +54,7 @@ func NewConfig(mongodbOperator mongodb.MongoOperator) generated.Config { //service chaosHubService := chaoshub.NewService(chaosHubOperator) - chaosInfrastructureService := chaos_infrastructure.NewChaosInfrastructureService(chaosInfraOperator) + chaosInfrastructureService := chaos_infrastructure.NewChaosInfrastructureService(chaosInfraOperator, EnvironmentOperator) chaosExperimentService := chaos_experiment2.NewChaosExperimentService(chaosExperimentOperator, chaosInfraOperator, chaosExperimentRunOperator) chaosExperimentRunService := chaos_experiment_run2.NewChaosExperimentRunService(chaosExperimentOperator, chaosInfraOperator, chaosExperimentRunOperator) gitOpsService := gitops3.NewGitOpsService(gitopsOperator, chaosExperimentService, *chaosExperimentOperator) From b1ec89324f7e84914774195d822c1a8265ebfd91 Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Wed, 20 Sep 2023 17:41:48 +0530 Subject: [PATCH 13/18] feat: add exp_run mock service Signed-off-by: SohamRatnaparkhi --- .../chaos_experiment/handler/handler_test.go | 4 +-- .../model/mocks/service.go | 28 +++++++++++++++++++ 2 files changed, 30 insertions(+), 2 deletions(-) create mode 100644 chaoscenter/graphql/server/pkg/chaos_experiment_run/model/mocks/service.go diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go b/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go index ec87cc0d52a..64257fd02dc 100644 --- a/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go @@ -12,10 +12,10 @@ import ( "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/authorization" choasExperimentMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks" types "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment/ops" + chaosExperimentRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment_run" + choasExperimentRunMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment_run/model/mocks" "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_infrastructure" chaosInfraMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_infrastructure/model/mocks" - chaosExperimentRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/choas_experiment_run" - choasExperimentRunMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/choas_experiment_run/model/mocks" store "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/data-store" "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb" dbChoasInfra "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_infrastructure" diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment_run/model/mocks/service.go b/chaoscenter/graphql/server/pkg/chaos_experiment_run/model/mocks/service.go new file mode 100644 index 00000000000..f8e53ffd30b --- /dev/null +++ b/chaoscenter/graphql/server/pkg/chaos_experiment_run/model/mocks/service.go @@ -0,0 +1,28 @@ +package mocks + +import ( + "context" + + types "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment_run" + store "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/data-store" + dbChaosExperiment "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment" + dbChaosExperimentRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment_run" + "github.com/stretchr/testify/mock" + "go.mongodb.org/mongo-driver/bson" +) + +type ChaosExperimentRunService struct { + mock.Mock +} + +// ProcessExperimentRunDelete mocks the ProcessExperimentRunDelete of chaos-experiment-run service +func (c *ChaosExperimentRunService) ProcessExperimentRunDelete(ctx context.Context, query bson.D, workflowRunID *string, experimentRun dbChaosExperimentRun.ChaosExperimentRun, workflow dbChaosExperiment.ChaosExperimentRequest, username string, r *store.StateData) error { + args := c.Called(ctx, query, workflowRunID, experimentRun, workflow, username, r) + return args.Error(0) +} + +// ProcessCompletedExperimentRun mocks the ProcessCompletedExperimentRun of chaos-experiment-run service +func (c *ChaosExperimentRunService) ProcessCompletedExperimentRun(execData types.ExecutionData, wfID string, runID string) (types.ExperimentRunMetrics, error) { + args := c.Called(execData, wfID, runID) + return args.Get(0).(types.ExperimentRunMetrics), args.Error(1) +} From 7f083e6396ccdf6899e77d4273c0ac3077a04448 Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Wed, 20 Sep 2023 17:42:04 +0530 Subject: [PATCH 14/18] fix: gitops mocks Signed-off-by: SohamRatnaparkhi --- chaoscenter/graphql/server/pkg/gitops/model/mocks/service.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/chaoscenter/graphql/server/pkg/gitops/model/mocks/service.go b/chaoscenter/graphql/server/pkg/gitops/model/mocks/service.go index 9513acd533d..2a622bc038d 100644 --- a/chaoscenter/graphql/server/pkg/gitops/model/mocks/service.go +++ b/chaoscenter/graphql/server/pkg/gitops/model/mocks/service.go @@ -21,7 +21,7 @@ func (g *GitOpsService) GitOpsNotificationHandler(ctx context.Context, infra cha } // EnableGitOpsHandler provides a mock function with given fields: ctx, config -func (g *GitOpsService) EnableGitOpsHandler(ctx context.Context, config model.GitConfig) (bool, error) { +func (g *GitOpsService) EnableGitOpsHandler(ctx context.Context, project_id string, config model.GitConfig) (bool, error) { args := g.Called(ctx, config) return args.Bool(0), args.Error(1) } @@ -33,7 +33,7 @@ func (g *GitOpsService) DisableGitOpsHandler(ctx context.Context, projectID stri } // UpdateGitOpsDetailsHandler provides a mock function with given fields: ctx, config -func (g *GitOpsService) UpdateGitOpsDetailsHandler(ctx context.Context, config model.GitConfig) (bool, error) { +func (g *GitOpsService) UpdateGitOpsDetailsHandler(ctx context.Context, projectId string, config model.GitConfig) (bool, error) { args := g.Called(ctx, config) return args.Bool(0), args.Error(1) } From 7ce68a0eb91818e66a2c549b849b2882be979a5e Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Wed, 20 Sep 2023 17:50:20 +0530 Subject: [PATCH 15/18] fix: typos Signed-off-by: SohamRatnaparkhi --- .../server/pkg/chaos_experiment/handler/handler_test.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go b/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go index 64257fd02dc..83730af1938 100644 --- a/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go @@ -10,10 +10,10 @@ import ( "github.com/google/uuid" "github.com/litmuschaos/litmus/chaoscenter/graphql/server/graph/model" "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/authorization" - choasExperimentMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks" + chaosExperimentMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment/model/mocks" types "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment/ops" chaosExperimentRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment_run" - choasExperimentRunMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment_run/model/mocks" + chaosExperimentRunMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment_run/model/mocks" "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_infrastructure" chaosInfraMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_infrastructure/model/mocks" store "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/data-store" @@ -34,11 +34,11 @@ import ( var ( mongodbMockOperator = new(dbMocks.MongoOperator) infrastructureService = new(chaosInfraMocks.InfraService) - chaosExperimentRunService = new(choasExperimentRunMocks.ChaosExperimentRunService) + chaosExperimentRunService = new(chaosExperimentRunMocks.ChaosExperimentRunService) gitOpsService = new(dbGitOpsMocks.GitOpsService) chaosExperimentOperator = dbChaosExperiment.NewChaosExperimentOperator(mongodbMockOperator) chaosExperimentRunOperator = dbChaosExperimentRun.NewChaosExperimentRunOperator(mongodbMockOperator) - chaosExperimentService = new(choasExperimentMocks.ChaosExperimentService) + chaosExperimentService = new(chaosExperimentMocks.ChaosExperimentService) ) var chaosExperimentHandler = NewChaosExperimentHandler(chaosExperimentService, chaosExperimentRunService, infrastructureService, gitOpsService, chaosExperimentOperator, chaosExperimentRunOperator, mongodbMockOperator) From bbc318933901f04e15db3061ad65f30416aab1f3 Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Sat, 30 Sep 2023 23:18:21 +0530 Subject: [PATCH 16/18] feat: add exp run test files Signed-off-by: SohamRatnaparkhi --- .../handler/handler_test.go | 441 ++++++++++++++++++ .../pkg/chaos_experiment_run/service_test.go | 231 +++++++++ 2 files changed, 672 insertions(+) create mode 100644 chaoscenter/graphql/server/pkg/chaos_experiment_run/handler/handler_test.go create mode 100644 chaoscenter/graphql/server/pkg/chaos_experiment_run/service_test.go diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment_run/handler/handler_test.go b/chaoscenter/graphql/server/pkg/chaos_experiment_run/handler/handler_test.go new file mode 100644 index 00000000000..6f08fa1f6cf --- /dev/null +++ b/chaoscenter/graphql/server/pkg/chaos_experiment_run/handler/handler_test.go @@ -0,0 +1,441 @@ +package handler + +import ( + "context" + "errors" + "io" + "log" + "os" + "reflect" + "strconv" + "testing" + "time" + + "github.com/gin-gonic/gin" + "github.com/google/uuid" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/graph/model" + choas_experiment_run "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment_run" + choasExperimentRunMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_experiment_run/model/mocks" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_infrastructure" + chaosInfraMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_infrastructure/model/mocks" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb" + dbChaosExperiment "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment" + dbOperationsChaosExpRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment" + dbChaosExperimentRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment_run" + dbInfra "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_infrastructure" + dbMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/mocks" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/gitops" + dbGitOpsMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/gitops/model/mocks" + "github.com/stretchr/testify/mock" + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/mongo" +) + +var ( + mongodbMockOperator = new(dbMocks.MongoOperator) + infrastructureService = new(chaosInfraMocks.InfraService) + chaosExperimentRunService = new(choasExperimentRunMocks.ChaosExperimentRunService) + gitOpsService = new(dbGitOpsMocks.GitOpsService) + chaosExperimentOperator = dbChaosExperiment.NewChaosExperimentOperator(mongodbMockOperator) + chaosExperimentRunOperator = dbChaosExperimentRun.NewChaosExperimentRunOperator(mongodbMockOperator) +) + +var chaosExperimentRunHandler = NewChaosExperimentRunHandler(chaosExperimentRunService, infrastructureService, gitOpsService, chaosExperimentOperator, chaosExperimentRunOperator, mongodbMockOperator) + +// TestMain is the entry point for testing +func TestMain(m *testing.M) { + gin.SetMode(gin.TestMode) + log.SetOutput(io.Discard) + os.Exit(m.Run()) +} + +func TestNewChaosExperimentRunHandler(t *testing.T) { + type args struct { + chaosExperimentRunService choas_experiment_run.Service + infrastructureService chaos_infrastructure.Service + gitOpsService gitops.Service + chaosExperimentOperator *dbChaosExperiment.Operator + chaosExperimentRunOperator *dbChaosExperimentRun.Operator + mongodbOperator mongodb.MongoOperator + } + tests := []struct { + name string + args args + want *ChaosExperimentRunHandler + }{ + { + name: "success: NewChaosExperimentRunHandler", + args: args{ + chaosExperimentRunService: chaosExperimentRunService, + infrastructureService: infrastructureService, + gitOpsService: gitOpsService, + chaosExperimentOperator: chaosExperimentOperator, + chaosExperimentRunOperator: chaosExperimentRunOperator, + mongodbOperator: mongodbMockOperator, + }, + want: &ChaosExperimentRunHandler{ + chaosExperimentRunService: chaosExperimentRunService, + infrastructureService: infrastructureService, + gitOpsService: gitOpsService, + chaosExperimentOperator: chaosExperimentOperator, + chaosExperimentRunOperator: chaosExperimentRunOperator, + mongodbOperator: mongodbMockOperator, + }, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + if got := NewChaosExperimentRunHandler(tc.args.chaosExperimentRunService, tc.args.infrastructureService, tc.args.gitOpsService, tc.args.chaosExperimentOperator, tc.args.chaosExperimentRunOperator, tc.args.mongodbOperator); !reflect.DeepEqual(got, tc.want) { + t.Errorf("NewChaosExperimentRunHandler() = %v, want %v", got, tc.want) + } + }) + } +} + +func TestChaosExperimentRunHandler_GetExperimentRun(t *testing.T) { + type args struct { + ctx context.Context + projectID string + experimentRunID string + } + projectId := uuid.NewString() + experimentRunId := uuid.NewString() + infraId := uuid.NewString() + tests := []struct { + name string + args args + given func() + wantErr bool + }{ + { + name: "success: GetExperimentRun", + args: args{ + ctx: context.Background(), + projectID: projectId, + experimentRunID: experimentRunId, + }, + given: func() { + findResult := []interface{}{ + bson.D{ + {Key: "experiment_run_id", Value: experimentRunId}, + {Key: "project_id", Value: projectId}, + {Key: "infra_id", Value: infraId}, + {Key: "kubernetesInfraDetails", Value: []dbInfra.ChaosInfra{ + { + InfraID: infraId, + }, + }}, + {Key: "experiment", Value: []dbChaosExperiment.ExperimentDetails{ + { + Revision: []dbOperationsChaosExpRun.ExperimentRevision{ + { + RevisionID: uuid.NewString(), + }, + }, + }, + }}, + }, + } + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() + }, + wantErr: false, + }, + { + name: "failure: kubernetes infra details absent", + args: args{ + ctx: context.Background(), + projectID: projectId, + experimentRunID: experimentRunId, + }, + given: func() { + findResult := []interface{}{ + bson.D{ + {Key: "experiment_run_id", Value: experimentRunId}, + {Key: "project_id", Value: projectId}, + {Key: "infra_id", Value: infraId}, + {Key: "experiment", Value: []dbChaosExperiment.ExperimentDetails{ + { + Revision: []dbOperationsChaosExpRun.ExperimentRevision{ + { + RevisionID: uuid.NewString(), + }, + }, + }, + }}, + }, + } + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() + }, + wantErr: true, + }, + { + name: "failure: experiment details absent", + args: args{ + ctx: context.Background(), + projectID: projectId, + experimentRunID: experimentRunId, + }, + given: func() { + findResult := []interface{}{ + bson.D{ + {Key: "experiment_run_id", Value: experimentRunId}, + {Key: "project_id", Value: projectId}, + {Key: "infra_id", Value: infraId}, + }, + } + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() + }, + wantErr: true, + }, + { + name: "failure: nil mongo cursor returned", + args: args{ + ctx: context.Background(), + projectID: projectId, + experimentRunID: experimentRunId, + }, + given: func() { + cursor, _ := mongo.NewCursorFromDocuments(nil, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, errors.New("mongo returned nil cursor")).Once() + }, + wantErr: true, + }, + } + for _, tc := range tests { + tc.given() + t.Run(tc.name, func(t *testing.T) { + experimentRunID := tc.args.experimentRunID + experimentRunUUID := uuid.NewString() + _, err := chaosExperimentRunHandler.GetExperimentRun(tc.args.ctx, tc.args.projectID, &experimentRunID, &experimentRunUUID) + if (err != nil) != tc.wantErr { + t.Errorf("ChaosExperimentRunHandler.GetExperimentRun() error = %v, wantErr %v", err, tc.wantErr) + return + } + }) + } +} + +func TestChaosExperimentRunHandler_ListExperimentRun(t *testing.T) { + type args struct { + projectID string + request model.ListExperimentRunRequest + } + // given + projectId := uuid.NewString() + experimentID := uuid.NewString() + experimentRunID := uuid.NewString() + experimentName := uuid.NewString() + infraId := uuid.NewString() + experimentStatus := model.ExperimentRunStatusRunning + endDate := strconv.FormatInt(time.Now().Unix(), 10) + startDate := strconv.FormatInt(time.Now().Unix(), 10) + + tests := []struct { + name string + args args + wantErr bool + given func() + }{ + { + name: "success: ListExperimentRun", + args: args{ + projectID: projectId, + request: model.ListExperimentRunRequest{ + ExperimentRunIDs: []*string{&experimentRunID}, + ExperimentIDs: []*string{&experimentID}, + Pagination: &model.Pagination{ + Page: 1, + }, + Filter: &model.ExperimentRunFilterInput{ + ExperimentName: &experimentName, + InfraID: &infraId, + ExperimentStatus: &experimentStatus, + DateRange: &model.DateRange{ + StartDate: startDate, + EndDate: &endDate, + }, + }, + }, + }, + given: func() { + findResult := []interface{}{bson.D{ + {Key: "total_filtered_experiment_runs", Value: []dbOperationsChaosExpRun.TotalFilteredData{ + { + Count: 1, + }, + }}, + {Key: "flattened_experiment_runs", Value: []dbOperationsChaosExpRun.FlattenedExperimentRun{ + { + ExperimentDetails: []dbOperationsChaosExpRun.ExperimentDetails{ + { + ExperimentName: experimentName, + }, + }, + }, + }}}, + } + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() + }, + wantErr: false, + }, + { + name: "success: sort in descending order of time", + args: args{ + projectID: projectId, + request: model.ListExperimentRunRequest{ + ExperimentRunIDs: []*string{&experimentRunID}, + ExperimentIDs: []*string{&experimentID}, + Pagination: &model.Pagination{ + Page: 1, + }, + Sort: &model.ExperimentRunSortInput{ + Field: model.ExperimentSortingFieldTime, + }, + Filter: &model.ExperimentRunFilterInput{ + ExperimentName: &experimentName, + InfraID: &infraId, + ExperimentStatus: &experimentStatus, + DateRange: &model.DateRange{ + StartDate: startDate, + EndDate: &endDate, + }, + }, + }, + }, + given: func() { + findResult := []interface{}{bson.D{ + {Key: "total_filtered_experiment_runs", Value: []dbOperationsChaosExpRun.TotalFilteredData{ + { + Count: 1, + }, + }}, + {Key: "flattened_experiment_runs", Value: []dbOperationsChaosExpRun.FlattenedExperimentRun{ + { + ExperimentDetails: []dbOperationsChaosExpRun.ExperimentDetails{ + { + ExperimentName: experimentName, + }, + }, + }, + }}}, + } + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() + }, + wantErr: false, + }, + { + name: "success: sort in descending order of name", + args: args{ + projectID: projectId, + request: model.ListExperimentRunRequest{ + ExperimentRunIDs: []*string{&experimentRunID}, + ExperimentIDs: []*string{&experimentID}, + Pagination: &model.Pagination{ + Page: 1, + }, + Sort: &model.ExperimentRunSortInput{ + Field: model.ExperimentSortingFieldName, + }, + Filter: &model.ExperimentRunFilterInput{ + ExperimentName: &experimentName, + InfraID: &infraId, + ExperimentStatus: &experimentStatus, + DateRange: &model.DateRange{ + StartDate: startDate, + EndDate: &endDate, + }, + }, + }, + }, + given: func() { + findResult := []interface{}{bson.D{ + {Key: "total_filtered_experiment_runs", Value: []dbOperationsChaosExpRun.TotalFilteredData{ + { + Count: 1, + }, + }}, + {Key: "flattened_experiment_runs", Value: []dbOperationsChaosExpRun.FlattenedExperimentRun{ + { + ExperimentDetails: []dbOperationsChaosExpRun.ExperimentDetails{ + { + ExperimentName: experimentName, + }, + }, + }, + }}}, + } + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() + }, + wantErr: false, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + tc.given() + _, err := chaosExperimentRunHandler.ListExperimentRun(tc.args.projectID, tc.args.request) + if (err != nil) != tc.wantErr { + t.Errorf("ChaosExperimentRunHandler.ListExperimentRun() error = %v, wantErr %v", err, tc.wantErr) + return + } + }) + } +} + +func TestChaosExperimentRunHandler_GetExperimentRunStats(t *testing.T) { + ctx := context.Background() + projectId := uuid.NewString() + tests := []struct { + name string + given func() + wantErr bool + }{ + { + name: "success: GetExperimentRunStats", + given: func() { + findResult := []interface{}{ + bson.D{ + {Key: "total_filtered_experiment_runs", Value: []dbOperationsChaosExpRun.TotalFilteredData{ + { + Count: 1, + }, + }}, + {Key: "flattened_experiment_runs", Value: []dbOperationsChaosExpRun.FlattenedExperimentRun{ + { + ExperimentDetails: []dbOperationsChaosExpRun.ExperimentDetails{ + { + ExperimentName: uuid.NewString(), + }, + }, + }, + }}}, + } + cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() + }, + }, + { + name: "failure: GetExperimentRunStats", + given: func() { + cursor, _ := mongo.NewCursorFromDocuments(nil, nil, nil) + mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, errors.New("failed to aggregate experiment runs")).Once() + }, + wantErr: true, + }, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + tc.given() + _, err := chaosExperimentRunHandler.GetExperimentRunStats(ctx, projectId) + if (err != nil) != tc.wantErr { + t.Errorf("ChaosExperimentRunHandler.GetExperimentRunStats() error = %v, wantErr %v", err, tc.wantErr) + return + } + }) + } +} diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment_run/service_test.go b/chaoscenter/graphql/server/pkg/chaos_experiment_run/service_test.go new file mode 100644 index 00000000000..a722829dade --- /dev/null +++ b/chaoscenter/graphql/server/pkg/chaos_experiment_run/service_test.go @@ -0,0 +1,231 @@ +package chaos_experiment_run + +import ( + "context" + "errors" + "io" + "log" + "os" + "reflect" + "testing" + + "github.com/gin-gonic/gin" + "github.com/google/uuid" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/graph/model" + store "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/data-store" + "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb" + dbChaosExperiment "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment" + dbChaosExperimentRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment_run" + dbChaosInfra "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_infrastructure" + dbMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/mocks" + "github.com/stretchr/testify/mock" + "go.mongodb.org/mongo-driver/bson" + "go.mongodb.org/mongo-driver/mongo" +) + +var ( + mongodbMockOperator = new(dbMocks.MongoOperator) + infraOperator = dbChaosInfra.NewInfrastructureOperator(mongodbMockOperator) + chaosExperimentOperator = dbChaosExperiment.NewChaosExperimentOperator(mongodbMockOperator) + chaosExperimentRunOperator = dbChaosExperimentRun.NewChaosExperimentRunOperator(mongodbMockOperator) +) + +var chaosExperimentRunTestService = NewChaosExperimentRunService(chaosExperimentOperator, infraOperator, chaosExperimentRunOperator) + +// TestMain is the entry point for testing +func TestMain(m *testing.M) { + gin.SetMode(gin.TestMode) + log.SetOutput(io.Discard) + os.Exit(m.Run()) +} + +func TestNewChaosExperimentRunService(t *testing.T) { + type args struct { + chaosWorkflowOperator *dbChaosExperiment.Operator + clusterOperator *dbChaosInfra.Operator + chaosExperimentRunOperator *dbChaosExperimentRun.Operator + } + testcases := []struct { + name string + args args + want Service + }{ + { + name: "success: creating new chaos experiment run service", + args: args{ + chaosWorkflowOperator: chaosExperimentOperator, + clusterOperator: infraOperator, + chaosExperimentRunOperator: chaosExperimentRunOperator, + }, + want: &chaosExperimentRunService{ + chaosExperimentOperator: chaosExperimentOperator, + chaosInfrastructureOperator: infraOperator, + chaosExperimentRunOperator: chaosExperimentRunOperator, + }, + }, + } + for _, tc := range testcases { + t.Run(tc.name, func(t *testing.T) { + if got := NewChaosExperimentRunService(tc.args.chaosWorkflowOperator, tc.args.clusterOperator, tc.args.chaosExperimentRunOperator); !reflect.DeepEqual(got, tc.want) { + t.Errorf("NewChaosExperimentRunService() = %v, want %v", got, tc.want) + } + }) + } +} + +func Test_chaosExperimentRunService_ProcessExperimentRunDelete(t *testing.T) { + type args struct { + ctx context.Context + query bson.D + workflowRunID *string + experimentRun dbChaosExperimentRun.ChaosExperimentRun + workflow dbChaosExperiment.ChaosExperimentRequest + username string + r *store.StateData + } + experimentRunId := uuid.New().String() + projectID := uuid.New().String() + experimentID := uuid.New().String() + infraId := uuid.New().String() + + testcases := []struct { + name string + args args + given func() + wantErr bool + }{ + { + name: "success: deleting experiment run", + args: args{ + ctx: context.Background(), + query: bson.D{{Key: "experiment_run_id", Value: experimentRunId}}, + experimentRun: dbChaosExperimentRun.ChaosExperimentRun{ + ProjectID: projectID, + ExperimentID: experimentID, + InfraID: infraId, + }, + workflow: dbChaosExperiment.ChaosExperimentRequest{ + ProjectID: projectID, + InfraID: infraId, + ExperimentID: experimentID, + }, + workflowRunID: &experimentID, + username: "test", + r: store.NewStore(), + }, + given: func() { + // given + mongodbMockOperator.On("Update", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything, mock.Anything).Return(&mongo.UpdateResult{MatchedCount: 1}, nil).Once() + }, + wantErr: false, + }, + { + name: "failure: deleting experiment run", + args: args{ + ctx: context.Background(), + query: bson.D{{Key: "experiment_run_id", Value: experimentRunId}}, + experimentRun: dbChaosExperimentRun.ChaosExperimentRun{ + ProjectID: projectID, + ExperimentID: experimentID, + InfraID: infraId, + }, + workflow: dbChaosExperiment.ChaosExperimentRequest{ + ProjectID: projectID, + InfraID: infraId, + ExperimentID: experimentID, + }, + workflowRunID: &experimentID, + username: "test", + r: store.NewStore(), + }, + given: func() { + // given + mongodbMockOperator.On("Update", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything, mock.Anything).Return(&mongo.UpdateResult{MatchedCount: 0}, errors.New("")).Once() + }, + wantErr: true, + }, + } + for _, tc := range testcases { + tc.given() + t.Run(tc.name, func(t *testing.T) { + if err := chaosExperimentRunTestService.ProcessExperimentRunDelete(tc.args.ctx, tc.args.query, tc.args.workflowRunID, tc.args.experimentRun, tc.args.workflow, tc.args.username, tc.args.r); (err != nil) != tc.wantErr { + t.Errorf("chaosExperimentRunService.ProcessExperimentRunDelete() error = %v, wantErr %v", err, tc.wantErr) + } + }) + } +} + +func Test_chaosExperimentRunService_ProcessCompletedExperimentRun(t *testing.T) { + type args struct { + execData ExecutionData + wfID string + runID string + } + experimentRunId := uuid.New().String() + experimentID := uuid.New().String() + + testcases := []struct { + name string + args args + given func() + wantErr bool + }{ + { + name: "success: processing completed experiment run", + args: args{ + execData: ExecutionData{ + ExperimentID: experimentID, + }, + wfID: experimentID, + runID: experimentRunId, + }, + given: func() { + findResult := []interface{}{bson.D{{Key: "experiment_id", Value: experimentID}, {Key: "weightages", Value: []*model.WeightagesInput{{FaultName: uuid.NewString(), Weightage: 10}}}}} + singleResult := mongo.NewSingleResultFromDocument(findResult[0], nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(singleResult, nil).Once() + }, + wantErr: false, + }, + { + name: "failure: can't find unique experiment run", + args: args{ + execData: ExecutionData{ + ExperimentID: experimentID, + }, + wfID: experimentID, + runID: experimentRunId, + }, + given: func() { + findResult := []interface{}{bson.D{{Key: "experiment_id", Value: experimentID}}, bson.D{{Key: "experiment_id", Value: uuid.NewString()}}} + singleResult := mongo.NewSingleResultFromDocument(findResult, nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(singleResult, nil).Once() + }, + wantErr: true, + }, + { + name: "failure: nil mongo single result", + args: args{ + execData: ExecutionData{ + ExperimentID: experimentID, + }, + wfID: experimentID, + runID: experimentRunId, + }, + given: func() { + singleResult := mongo.NewSingleResultFromDocument(nil, nil, nil) + mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(singleResult, errors.New("")).Once() + }, + wantErr: true, + }, + } + for _, tc := range testcases { + t.Run(tc.name, func(t *testing.T) { + tc.given() + _, err := chaosExperimentRunTestService.ProcessCompletedExperimentRun(tc.args.execData, tc.args.wfID, tc.args.runID) + if (err != nil) != tc.wantErr { + t.Errorf("chaosExperimentRunService.ProcessCompletedExperimentRun() error = %v, wantErr %v", err, tc.wantErr) + return + } + }) + } +} From 9dd434c6cd309afe4029c12c8e0e7889a58940f6 Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Sat, 30 Sep 2023 23:19:05 +0530 Subject: [PATCH 17/18] chore: remove redundant package Signed-off-by: SohamRatnaparkhi --- .../handler/handler_test.go | 439 ------------------ .../model/mocks/service.go | 28 -- .../pkg/choas_experiment_run/service_test.go | 231 --------- 3 files changed, 698 deletions(-) delete mode 100644 chaoscenter/graphql/server/pkg/choas_experiment_run/handler/handler_test.go delete mode 100644 chaoscenter/graphql/server/pkg/choas_experiment_run/model/mocks/service.go delete mode 100644 chaoscenter/graphql/server/pkg/choas_experiment_run/service_test.go diff --git a/chaoscenter/graphql/server/pkg/choas_experiment_run/handler/handler_test.go b/chaoscenter/graphql/server/pkg/choas_experiment_run/handler/handler_test.go deleted file mode 100644 index 09c69e06a84..00000000000 --- a/chaoscenter/graphql/server/pkg/choas_experiment_run/handler/handler_test.go +++ /dev/null @@ -1,439 +0,0 @@ -package handler - -import ( - "context" - "errors" - "io" - "log" - "os" - "reflect" - "strconv" - "testing" - "time" - - "github.com/gin-gonic/gin" - "github.com/google/uuid" - "github.com/litmuschaos/litmus/chaoscenter/graphql/server/graph/model" - "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_infrastructure" - chaosInfraMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/chaos_infrastructure/model/mocks" - choas_experiment_run "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/choas_experiment_run" - choasExperimentRunMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/choas_experiment_run/model/mocks" - "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb" - dbChaosExperiment "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment" - dbOperationsChaosExpRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment" - dbChaosExperimentRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment_run" - dbInfra "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_infrastructure" - dbMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/mocks" - "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/gitops" - dbGitOpsMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/gitops/model/mocks" - "github.com/stretchr/testify/mock" - "go.mongodb.org/mongo-driver/bson" - "go.mongodb.org/mongo-driver/mongo" -) - -var ( - mongodbMockOperator = new(dbMocks.MongoOperator) - infrastructureService = new(chaosInfraMocks.InfraService) - chaosExperimentRunService = new(choasExperimentRunMocks.ChaosExperimentRunService) - gitOpsService = new(dbGitOpsMocks.GitOpsService) - chaosExperimentOperator = dbChaosExperiment.NewChaosExperimentOperator(mongodbMockOperator) - chaosExperimentRunOperator = dbChaosExperimentRun.NewChaosExperimentRunOperator(mongodbMockOperator) -) - -var chaosExperimentRunHandler = NewChaosExperimentRunHandler(chaosExperimentRunService, infrastructureService, gitOpsService, chaosExperimentOperator, chaosExperimentRunOperator, mongodbMockOperator) - -// TestMain is the entry point for testing -func TestMain(m *testing.M) { - gin.SetMode(gin.TestMode) - log.SetOutput(io.Discard) - os.Exit(m.Run()) -} - -func TestNewChaosExperimentRunHandler(t *testing.T) { - type args struct { - chaosExperimentRunService choas_experiment_run.Service - infrastructureService chaos_infrastructure.Service - gitOpsService gitops.Service - chaosExperimentOperator *dbChaosExperiment.Operator - chaosExperimentRunOperator *dbChaosExperimentRun.Operator - mongodbOperator mongodb.MongoOperator - } - tests := []struct { - name string - args args - want *ChaosExperimentRunHandler - }{ - { - name: "success: NewChaosExperimentRunHandler", - args: args{ - chaosExperimentRunService: chaosExperimentRunService, - infrastructureService: infrastructureService, - gitOpsService: gitOpsService, - chaosExperimentOperator: chaosExperimentOperator, - chaosExperimentRunOperator: chaosExperimentRunOperator, - mongodbOperator: mongodbMockOperator, - }, - want: &ChaosExperimentRunHandler{ - chaosExperimentRunService: chaosExperimentRunService, - infrastructureService: infrastructureService, - gitOpsService: gitOpsService, - chaosExperimentOperator: chaosExperimentOperator, - chaosExperimentRunOperator: chaosExperimentRunOperator, - mongodbOperator: mongodbMockOperator, - }, - }, - } - for _, tc := range tests { - t.Run(tc.name, func(t *testing.T) { - if got := NewChaosExperimentRunHandler(tc.args.chaosExperimentRunService, tc.args.infrastructureService, tc.args.gitOpsService, tc.args.chaosExperimentOperator, tc.args.chaosExperimentRunOperator, tc.args.mongodbOperator); !reflect.DeepEqual(got, tc.want) { - t.Errorf("NewChaosExperimentRunHandler() = %v, want %v", got, tc.want) - } - }) - } -} - -func TestChaosExperimentRunHandler_GetExperimentRun(t *testing.T) { - type args struct { - ctx context.Context - projectID string - experimentRunID string - } - projectId := uuid.NewString() - experimentRunId := uuid.NewString() - infraId := uuid.NewString() - tests := []struct { - name string - args args - given func() - wantErr bool - }{ - { - name: "success: GetExperimentRun", - args: args{ - ctx: context.Background(), - projectID: projectId, - experimentRunID: experimentRunId, - }, - given: func() { - findResult := []interface{}{ - bson.D{ - {Key: "experiment_run_id", Value: experimentRunId}, - {Key: "project_id", Value: projectId}, - {Key: "infra_id", Value: infraId}, - {Key: "kubernetesInfraDetails", Value: []dbInfra.ChaosInfra{ - { - InfraID: infraId, - }, - }}, - {Key: "experiment", Value: []dbChaosExperiment.ExperimentDetails{ - { - Revision: []dbOperationsChaosExpRun.ExperimentRevision{ - { - RevisionID: uuid.NewString(), - }, - }, - }, - }}, - }, - } - cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) - mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() - }, - wantErr: false, - }, - { - name: "failure: kubernetes infra details absent", - args: args{ - ctx: context.Background(), - projectID: projectId, - experimentRunID: experimentRunId, - }, - given: func() { - findResult := []interface{}{ - bson.D{ - {Key: "experiment_run_id", Value: experimentRunId}, - {Key: "project_id", Value: projectId}, - {Key: "infra_id", Value: infraId}, - {Key: "experiment", Value: []dbChaosExperiment.ExperimentDetails{ - { - Revision: []dbOperationsChaosExpRun.ExperimentRevision{ - { - RevisionID: uuid.NewString(), - }, - }, - }, - }}, - }, - } - cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) - mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() - }, - wantErr: true, - }, - { - name: "failure: experiment details absent", - args: args{ - ctx: context.Background(), - projectID: projectId, - experimentRunID: experimentRunId, - }, - given: func() { - findResult := []interface{}{ - bson.D{ - {Key: "experiment_run_id", Value: experimentRunId}, - {Key: "project_id", Value: projectId}, - {Key: "infra_id", Value: infraId}, - }, - } - cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) - mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() - }, - wantErr: true, - }, - { - name: "failure: nil mongo cursor returned", - args: args{ - ctx: context.Background(), - projectID: projectId, - experimentRunID: experimentRunId, - }, - given: func() { - cursor, _ := mongo.NewCursorFromDocuments(nil, nil, nil) - mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, errors.New("mongo returned nil cursor")).Once() - }, - wantErr: true, - }, - } - for _, tc := range tests { - tc.given() - t.Run(tc.name, func(t *testing.T) { - _, err := chaosExperimentRunHandler.GetExperimentRun(tc.args.ctx, tc.args.projectID, tc.args.experimentRunID) - if (err != nil) != tc.wantErr { - t.Errorf("ChaosExperimentRunHandler.GetExperimentRun() error = %v, wantErr %v", err, tc.wantErr) - return - } - }) - } -} - -func TestChaosExperimentRunHandler_ListExperimentRun(t *testing.T) { - type args struct { - projectID string - request model.ListExperimentRunRequest - } - // given - projectId := uuid.NewString() - experimentID := uuid.NewString() - experimentRunID := uuid.NewString() - experimentName := uuid.NewString() - infraId := uuid.NewString() - experimentStatus := model.ExperimentRunStatusRunning - endDate := strconv.FormatInt(time.Now().Unix(), 10) - startDate := strconv.FormatInt(time.Now().Unix(), 10) - - tests := []struct { - name string - args args - wantErr bool - given func() - }{ - { - name: "success: ListExperimentRun", - args: args{ - projectID: projectId, - request: model.ListExperimentRunRequest{ - ExperimentRunIDs: []*string{&experimentRunID}, - ExperimentIDs: []*string{&experimentID}, - Pagination: &model.Pagination{ - Page: 1, - }, - Filter: &model.ExperimentRunFilterInput{ - ExperimentName: &experimentName, - InfraID: &infraId, - ExperimentStatus: &experimentStatus, - DateRange: &model.DateRange{ - StartDate: startDate, - EndDate: &endDate, - }, - }, - }, - }, - given: func() { - findResult := []interface{}{bson.D{ - {Key: "total_filtered_experiment_runs", Value: []dbOperationsChaosExpRun.TotalFilteredData{ - { - Count: 1, - }, - }}, - {Key: "flattened_experiment_runs", Value: []dbOperationsChaosExpRun.FlattenedExperimentRun{ - { - ExperimentDetails: []dbOperationsChaosExpRun.ExperimentDetails{ - { - ExperimentName: experimentName, - }, - }, - }, - }}}, - } - cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) - mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() - }, - wantErr: false, - }, - { - name: "success: sort in descending order of time", - args: args{ - projectID: projectId, - request: model.ListExperimentRunRequest{ - ExperimentRunIDs: []*string{&experimentRunID}, - ExperimentIDs: []*string{&experimentID}, - Pagination: &model.Pagination{ - Page: 1, - }, - Sort: &model.ExperimentRunSortInput{ - Field: model.ExperimentSortingFieldTime, - }, - Filter: &model.ExperimentRunFilterInput{ - ExperimentName: &experimentName, - InfraID: &infraId, - ExperimentStatus: &experimentStatus, - DateRange: &model.DateRange{ - StartDate: startDate, - EndDate: &endDate, - }, - }, - }, - }, - given: func() { - findResult := []interface{}{bson.D{ - {Key: "total_filtered_experiment_runs", Value: []dbOperationsChaosExpRun.TotalFilteredData{ - { - Count: 1, - }, - }}, - {Key: "flattened_experiment_runs", Value: []dbOperationsChaosExpRun.FlattenedExperimentRun{ - { - ExperimentDetails: []dbOperationsChaosExpRun.ExperimentDetails{ - { - ExperimentName: experimentName, - }, - }, - }, - }}}, - } - cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) - mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() - }, - wantErr: false, - }, - { - name: "success: sort in descending order of name", - args: args{ - projectID: projectId, - request: model.ListExperimentRunRequest{ - ExperimentRunIDs: []*string{&experimentRunID}, - ExperimentIDs: []*string{&experimentID}, - Pagination: &model.Pagination{ - Page: 1, - }, - Sort: &model.ExperimentRunSortInput{ - Field: model.ExperimentSortingFieldName, - }, - Filter: &model.ExperimentRunFilterInput{ - ExperimentName: &experimentName, - InfraID: &infraId, - ExperimentStatus: &experimentStatus, - DateRange: &model.DateRange{ - StartDate: startDate, - EndDate: &endDate, - }, - }, - }, - }, - given: func() { - findResult := []interface{}{bson.D{ - {Key: "total_filtered_experiment_runs", Value: []dbOperationsChaosExpRun.TotalFilteredData{ - { - Count: 1, - }, - }}, - {Key: "flattened_experiment_runs", Value: []dbOperationsChaosExpRun.FlattenedExperimentRun{ - { - ExperimentDetails: []dbOperationsChaosExpRun.ExperimentDetails{ - { - ExperimentName: experimentName, - }, - }, - }, - }}}, - } - cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) - mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() - }, - wantErr: false, - }, - } - for _, tc := range tests { - t.Run(tc.name, func(t *testing.T) { - tc.given() - _, err := chaosExperimentRunHandler.ListExperimentRun(tc.args.projectID, tc.args.request) - if (err != nil) != tc.wantErr { - t.Errorf("ChaosExperimentRunHandler.ListExperimentRun() error = %v, wantErr %v", err, tc.wantErr) - return - } - }) - } -} - -func TestChaosExperimentRunHandler_GetExperimentRunStats(t *testing.T) { - ctx := context.Background() - projectId := uuid.NewString() - tests := []struct { - name string - given func() - wantErr bool - }{ - { - name: "success: GetExperimentRunStats", - given: func() { - findResult := []interface{}{ - bson.D{ - {Key: "total_filtered_experiment_runs", Value: []dbOperationsChaosExpRun.TotalFilteredData{ - { - Count: 1, - }, - }}, - {Key: "flattened_experiment_runs", Value: []dbOperationsChaosExpRun.FlattenedExperimentRun{ - { - ExperimentDetails: []dbOperationsChaosExpRun.ExperimentDetails{ - { - ExperimentName: uuid.NewString(), - }, - }, - }, - }}}, - } - cursor, _ := mongo.NewCursorFromDocuments(findResult, nil, nil) - mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, nil).Once() - }, - }, - { - name: "failure: GetExperimentRunStats", - given: func() { - cursor, _ := mongo.NewCursorFromDocuments(nil, nil, nil) - mongodbMockOperator.On("Aggregate", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything).Return(cursor, errors.New("failed to aggregate experiment runs")).Once() - }, - wantErr: true, - }, - } - for _, tc := range tests { - t.Run(tc.name, func(t *testing.T) { - tc.given() - _, err := chaosExperimentRunHandler.GetExperimentRunStats(ctx, projectId) - if (err != nil) != tc.wantErr { - t.Errorf("ChaosExperimentRunHandler.GetExperimentRunStats() error = %v, wantErr %v", err, tc.wantErr) - return - } - }) - } -} diff --git a/chaoscenter/graphql/server/pkg/choas_experiment_run/model/mocks/service.go b/chaoscenter/graphql/server/pkg/choas_experiment_run/model/mocks/service.go deleted file mode 100644 index 4bfe7d3c80c..00000000000 --- a/chaoscenter/graphql/server/pkg/choas_experiment_run/model/mocks/service.go +++ /dev/null @@ -1,28 +0,0 @@ -package mocks - -import ( - "context" - - types "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/choas_experiment_run" - store "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/data-store" - dbChaosExperiment "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment" - dbChaosExperimentRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment_run" - "github.com/stretchr/testify/mock" - "go.mongodb.org/mongo-driver/bson" -) - -type ChaosExperimentRunService struct { - mock.Mock -} - -// ProcessExperimentRunDelete mocks the ProcessExperimentRunDelete of chaos-experiment-run service -func (c *ChaosExperimentRunService) ProcessExperimentRunDelete(ctx context.Context, query bson.D, workflowRunID *string, experimentRun dbChaosExperimentRun.ChaosExperimentRun, workflow dbChaosExperiment.ChaosExperimentRequest, username string, r *store.StateData) error { - args := c.Called(ctx, query, workflowRunID, experimentRun, workflow, username, r) - return args.Error(0) -} - -// ProcessCompletedExperimentRun mocks the ProcessCompletedExperimentRun of chaos-experiment-run service -func (c *ChaosExperimentRunService) ProcessCompletedExperimentRun(execData types.ExecutionData, wfID string, runID string) (types.ExperimentRunMetrics, error) { - args := c.Called(execData, wfID, runID) - return args.Get(0).(types.ExperimentRunMetrics), args.Error(1) -} diff --git a/chaoscenter/graphql/server/pkg/choas_experiment_run/service_test.go b/chaoscenter/graphql/server/pkg/choas_experiment_run/service_test.go deleted file mode 100644 index a722829dade..00000000000 --- a/chaoscenter/graphql/server/pkg/choas_experiment_run/service_test.go +++ /dev/null @@ -1,231 +0,0 @@ -package chaos_experiment_run - -import ( - "context" - "errors" - "io" - "log" - "os" - "reflect" - "testing" - - "github.com/gin-gonic/gin" - "github.com/google/uuid" - "github.com/litmuschaos/litmus/chaoscenter/graphql/server/graph/model" - store "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/data-store" - "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb" - dbChaosExperiment "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment" - dbChaosExperimentRun "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment_run" - dbChaosInfra "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/chaos_infrastructure" - dbMocks "github.com/litmuschaos/litmus/chaoscenter/graphql/server/pkg/database/mongodb/mocks" - "github.com/stretchr/testify/mock" - "go.mongodb.org/mongo-driver/bson" - "go.mongodb.org/mongo-driver/mongo" -) - -var ( - mongodbMockOperator = new(dbMocks.MongoOperator) - infraOperator = dbChaosInfra.NewInfrastructureOperator(mongodbMockOperator) - chaosExperimentOperator = dbChaosExperiment.NewChaosExperimentOperator(mongodbMockOperator) - chaosExperimentRunOperator = dbChaosExperimentRun.NewChaosExperimentRunOperator(mongodbMockOperator) -) - -var chaosExperimentRunTestService = NewChaosExperimentRunService(chaosExperimentOperator, infraOperator, chaosExperimentRunOperator) - -// TestMain is the entry point for testing -func TestMain(m *testing.M) { - gin.SetMode(gin.TestMode) - log.SetOutput(io.Discard) - os.Exit(m.Run()) -} - -func TestNewChaosExperimentRunService(t *testing.T) { - type args struct { - chaosWorkflowOperator *dbChaosExperiment.Operator - clusterOperator *dbChaosInfra.Operator - chaosExperimentRunOperator *dbChaosExperimentRun.Operator - } - testcases := []struct { - name string - args args - want Service - }{ - { - name: "success: creating new chaos experiment run service", - args: args{ - chaosWorkflowOperator: chaosExperimentOperator, - clusterOperator: infraOperator, - chaosExperimentRunOperator: chaosExperimentRunOperator, - }, - want: &chaosExperimentRunService{ - chaosExperimentOperator: chaosExperimentOperator, - chaosInfrastructureOperator: infraOperator, - chaosExperimentRunOperator: chaosExperimentRunOperator, - }, - }, - } - for _, tc := range testcases { - t.Run(tc.name, func(t *testing.T) { - if got := NewChaosExperimentRunService(tc.args.chaosWorkflowOperator, tc.args.clusterOperator, tc.args.chaosExperimentRunOperator); !reflect.DeepEqual(got, tc.want) { - t.Errorf("NewChaosExperimentRunService() = %v, want %v", got, tc.want) - } - }) - } -} - -func Test_chaosExperimentRunService_ProcessExperimentRunDelete(t *testing.T) { - type args struct { - ctx context.Context - query bson.D - workflowRunID *string - experimentRun dbChaosExperimentRun.ChaosExperimentRun - workflow dbChaosExperiment.ChaosExperimentRequest - username string - r *store.StateData - } - experimentRunId := uuid.New().String() - projectID := uuid.New().String() - experimentID := uuid.New().String() - infraId := uuid.New().String() - - testcases := []struct { - name string - args args - given func() - wantErr bool - }{ - { - name: "success: deleting experiment run", - args: args{ - ctx: context.Background(), - query: bson.D{{Key: "experiment_run_id", Value: experimentRunId}}, - experimentRun: dbChaosExperimentRun.ChaosExperimentRun{ - ProjectID: projectID, - ExperimentID: experimentID, - InfraID: infraId, - }, - workflow: dbChaosExperiment.ChaosExperimentRequest{ - ProjectID: projectID, - InfraID: infraId, - ExperimentID: experimentID, - }, - workflowRunID: &experimentID, - username: "test", - r: store.NewStore(), - }, - given: func() { - // given - mongodbMockOperator.On("Update", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything, mock.Anything).Return(&mongo.UpdateResult{MatchedCount: 1}, nil).Once() - }, - wantErr: false, - }, - { - name: "failure: deleting experiment run", - args: args{ - ctx: context.Background(), - query: bson.D{{Key: "experiment_run_id", Value: experimentRunId}}, - experimentRun: dbChaosExperimentRun.ChaosExperimentRun{ - ProjectID: projectID, - ExperimentID: experimentID, - InfraID: infraId, - }, - workflow: dbChaosExperiment.ChaosExperimentRequest{ - ProjectID: projectID, - InfraID: infraId, - ExperimentID: experimentID, - }, - workflowRunID: &experimentID, - username: "test", - r: store.NewStore(), - }, - given: func() { - // given - mongodbMockOperator.On("Update", mock.Anything, mongodb.ChaosExperimentRunsCollection, mock.Anything, mock.Anything, mock.Anything).Return(&mongo.UpdateResult{MatchedCount: 0}, errors.New("")).Once() - }, - wantErr: true, - }, - } - for _, tc := range testcases { - tc.given() - t.Run(tc.name, func(t *testing.T) { - if err := chaosExperimentRunTestService.ProcessExperimentRunDelete(tc.args.ctx, tc.args.query, tc.args.workflowRunID, tc.args.experimentRun, tc.args.workflow, tc.args.username, tc.args.r); (err != nil) != tc.wantErr { - t.Errorf("chaosExperimentRunService.ProcessExperimentRunDelete() error = %v, wantErr %v", err, tc.wantErr) - } - }) - } -} - -func Test_chaosExperimentRunService_ProcessCompletedExperimentRun(t *testing.T) { - type args struct { - execData ExecutionData - wfID string - runID string - } - experimentRunId := uuid.New().String() - experimentID := uuid.New().String() - - testcases := []struct { - name string - args args - given func() - wantErr bool - }{ - { - name: "success: processing completed experiment run", - args: args{ - execData: ExecutionData{ - ExperimentID: experimentID, - }, - wfID: experimentID, - runID: experimentRunId, - }, - given: func() { - findResult := []interface{}{bson.D{{Key: "experiment_id", Value: experimentID}, {Key: "weightages", Value: []*model.WeightagesInput{{FaultName: uuid.NewString(), Weightage: 10}}}}} - singleResult := mongo.NewSingleResultFromDocument(findResult[0], nil, nil) - mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(singleResult, nil).Once() - }, - wantErr: false, - }, - { - name: "failure: can't find unique experiment run", - args: args{ - execData: ExecutionData{ - ExperimentID: experimentID, - }, - wfID: experimentID, - runID: experimentRunId, - }, - given: func() { - findResult := []interface{}{bson.D{{Key: "experiment_id", Value: experimentID}}, bson.D{{Key: "experiment_id", Value: uuid.NewString()}}} - singleResult := mongo.NewSingleResultFromDocument(findResult, nil, nil) - mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(singleResult, nil).Once() - }, - wantErr: true, - }, - { - name: "failure: nil mongo single result", - args: args{ - execData: ExecutionData{ - ExperimentID: experimentID, - }, - wfID: experimentID, - runID: experimentRunId, - }, - given: func() { - singleResult := mongo.NewSingleResultFromDocument(nil, nil, nil) - mongodbMockOperator.On("Get", mock.Anything, mongodb.ChaosExperimentCollection, mock.Anything).Return(singleResult, errors.New("")).Once() - }, - wantErr: true, - }, - } - for _, tc := range testcases { - t.Run(tc.name, func(t *testing.T) { - tc.given() - _, err := chaosExperimentRunTestService.ProcessCompletedExperimentRun(tc.args.execData, tc.args.wfID, tc.args.runID) - if (err != nil) != tc.wantErr { - t.Errorf("chaosExperimentRunService.ProcessCompletedExperimentRun() error = %v, wantErr %v", err, tc.wantErr) - return - } - }) - } -} From 25947c822eed934f0c85e5d18eb81d098bffce44 Mon Sep 17 00:00:00 2001 From: SohamRatnaparkhi Date: Wed, 4 Oct 2023 13:38:11 +0530 Subject: [PATCH 18/18] fix: update exp bugs Signed-off-by: SohamRatnaparkhi --- .../server/pkg/chaos_experiment/handler/handler_test.go | 6 ++++-- .../pkg/database/mongodb/chaos_experiment/operations.go | 2 +- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go b/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go index 83730af1938..d81e290ae6e 100644 --- a/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go +++ b/chaoscenter/graphql/server/pkg/chaos_experiment/handler/handler_test.go @@ -420,7 +420,7 @@ func TestChaosExperimentHandler_UpdateChaosExperiment(t *testing.T) { }, given: func(request *model.ChaosExperimentRequest) { ctx = context.WithValue(ctx, authorization.AuthKey, username) - + mongodbMockOperator.On("CountDocuments", ctx, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything).Return(int64(0), nil).Once() chaosExperimentService.On("ProcessExperiment", mock.Anything, mock.Anything, mock.Anything).Return(request, &experimentType, nil).Once() chaosExperimentService.On("ProcessExperimentUpdate", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil).Once() @@ -439,7 +439,7 @@ func TestChaosExperimentHandler_UpdateChaosExperiment(t *testing.T) { }, given: func(request *model.ChaosExperimentRequest) { ctx = context.WithValue(ctx, authorization.AuthKey, username) - + mongodbMockOperator.On("CountDocuments", ctx, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything).Return(int64(0), nil).Once() chaosExperimentService.On("ProcessExperiment", mock.Anything, mock.Anything, mock.Anything).Return(request, &experimentType, errors.New("Incorrect request format")).Once() }, wantErr: true, @@ -457,6 +457,8 @@ func TestChaosExperimentHandler_UpdateChaosExperiment(t *testing.T) { given: func(request *model.ChaosExperimentRequest) { ctx = context.WithValue(ctx, authorization.AuthKey, username) + mongodbMockOperator.On("CountDocuments", ctx, mongodb.ChaosExperimentCollection, mock.Anything, mock.Anything).Return(int64(0), nil).Once() + chaosExperimentService.On("ProcessExperiment", mock.Anything, mock.Anything, mock.Anything).Return(request, &experimentType, nil).Once() chaosExperimentService.On("ProcessExperimentUpdate", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errors.New("experiment update failed")).Once() diff --git a/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment/operations.go b/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment/operations.go index 65058673a9d..1dd59da01e4 100644 --- a/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment/operations.go +++ b/chaoscenter/graphql/server/pkg/database/mongodb/chaos_experiment/operations.go @@ -127,7 +127,7 @@ func (c *Operator) UpdateChaosExperiments(ctx context.Context, query bson.D, upd // CountChaosExperiments returns total number of matched documents func (c *Operator) CountChaosExperiments(ctx context.Context, query bson.D) (int64, error) { - res, err := mongodb.Operator.CountDocuments(ctx, mongodb.ChaosExperimentCollection, query) + res, err := c.operator.CountDocuments(ctx, mongodb.ChaosExperimentCollection, query) if err != nil { return 0, err }