From 7001ca854cd74ef9ae4d87c6543074047c4ec104 Mon Sep 17 00:00:00 2001 From: Michael McGuinness Date: Mon, 3 Feb 2025 17:30:50 +0000 Subject: [PATCH] Merged in feature/docinitialisation (pull request #41) Queuing Changes and Cfg Testing * staarting * staarting * startedpush * note * save * mocking * removederrs * fixtests * cleanuperrs * newenvsetup * preppingtests * queue * mmovetocfgpassunittests * sortoutconfig * passinginteg * deps * fixtests --- .bitbucket/CODEOWNERS | 2 +- .mockery.yml | 13 +- api/docInitRunner/runner.go | 49 + api/docInitRunner/runner_test.go | 82 + api/queryRunner/{queryrunner.go => runner.go} | 17 +- .../{queryrunner_test.go => runner_test.go} | 8 +- api/queryService/client_test.go | 12 +- api/queryService/controllers.go | 2 + api/queryService/export_test.go | 4 +- api/queryService/job_test.go | 12 +- api/queryService/jobcollector_test.go | 8 +- api/queryService/parse_test.go | 22 +- api/queryService/query_test.go | 22 +- cmd/docInitRunner/main.go | 64 + cmd/queryRunner/main.go | 2 +- devbox.json | 20 +- devbox.lock | 48 + internal/client/create_test.go | 2 +- internal/client/get_test.go | 2 +- internal/client/serviceprivate_test.go | 22 +- internal/client/update_test.go | 8 +- internal/database/migrations/migrations.go | 5 +- .../database/migrations/migrations_test.go | 31 +- .../migrations/migrationsprivate_test.go | 11 +- internal/database/parseuuid_test.go | 12 +- internal/database/repository/client_test.go | 20 +- .../database/repository/collector_test.go | 40 +- internal/database/repository/db_test.go | 2 +- internal/database/repository/document_test.go | 16 +- internal/database/repository/job_test.go | 17 +- internal/database/repository/query_test.go | 85 +- .../database/repository/querytype_test.go | 8 +- internal/database/repository/result_test.go | 104 +- internal/document/clean/service.go | 10 +- internal/document/create.go | 41 - internal/document/create_test.go | 47 - internal/document/get_test.go | 2 +- internal/document/init/create.go | 93 ++ internal/document/init/create_test.go | 106 ++ internal/document/init/service.go | 28 + internal/document/init/service_test.go | 13 + internal/document/service.go | 2 + internal/job/collector/create_test.go | 2 +- internal/job/collector/createprivate_test.go | 4 +- internal/job/collector/get_test.go | 4 +- internal/job/collector/parse_test.go | 6 +- internal/job/collector/update_test.go | 2 +- internal/job/collector/updateprivate_test.go | 34 +- internal/job/create_test.go | 2 +- internal/job/get_test.go | 4 +- internal/job/update_test.go | 2 +- internal/job/updateprivate_test.go | 16 +- internal/query/create_test.go | 10 +- internal/query/createprivate_test.go | 18 +- internal/query/get_test.go | 4 +- internal/query/list_test.go | 4 +- internal/query/normalize_test.go | 32 +- internal/query/parse_test.go | 8 +- internal/query/result/get_test.go | 6 +- internal/query/result/list_test.go | 4 +- internal/query/result/process_test.go | 16 +- internal/query/result/processor/parse_test.go | 30 +- internal/query/result/set_test.go | 2 +- internal/query/result/sync_test.go | 2 +- internal/query/test_test.go | 2 +- .../query/types/contextFull/creator_test.go | 2 +- .../query/types/contextFull/process_test.go | 2 +- .../query/types/contextFull/updator_test.go | 2 +- .../query/types/jsonExtractor/creator_test.go | 2 +- .../query/types/jsonExtractor/process_test.go | 6 +- .../query/types/jsonExtractor/updator_test.go | 2 +- internal/query/updateprivate_test.go | 14 +- internal/server/otel/service.go | 4 +- internal/server/otel/service_test.go | 4 +- internal/server/queue/client.go | 40 + internal/server/queue/config.go | 6 +- internal/server/queue/delete_test.go | 39 +- internal/server/queue/receive_test.go | 37 +- internal/server/queue/send_test.go | 31 +- internal/server/runner/listener.go | 49 +- internal/server/runner/listener_test.go | 102 +- internal/server/runner/poll.go | 8 +- internal/server/runner/poll_test.go | 74 +- internal/server/server.go | 4 +- internal/server/server_test.go | 7 +- internal/server/service/listener.go | 6 + internal/server/service/listener_test.go | 49 +- internal/server/validation/validation_test.go | 8 +- internal/serviceconfig/aws/config.go | 6 +- internal/serviceconfig/common.go | 112 +- internal/serviceconfig/common_test.go | 81 +- internal/serviceconfig/database/config.go | 14 +- .../serviceconfig/database/config_test.go | 12 +- internal/serviceconfig/database/pool.go | 8 +- internal/serviceconfig/database/pool_test.go | 11 +- .../serviceconfig/database/transaction.go | 2 +- .../database/transaction_test.go | 4 +- internal/serviceconfig/logger/config.go | 82 + internal/serviceconfig/logger/config_test.go | 36 + .../serviceconfig/{ => logger}/testlogger.go | 12 +- .../{ => logger}/testlogger_test.go | 4 +- .../serviceconfig/observability/config.go | 13 + .../observability/config_test.go | 15 + internal/serviceconfig/queue/config.go | 52 + internal/serviceconfig/queue/config_test.go | 51 + .../queue/documentclean/config.go | 13 + internal/test/api.go | 62 - internal/test/api_test.go | 56 - internal/test/container.go | 49 +- internal/test/container_test.go | 20 +- internal/test/database.go | 76 +- internal/test/database_test.go | 10 +- internal/test/ecosystem.go | 195 +++ internal/test/ecosystem_test.go | 79 + internal/test/queue.go | 94 +- internal/test/queue_test.go | 110 +- internal/test/queuecontainer.go | 81 - internal/test/queuecontainer_test.go | 67 - internal/test/runner.go | 47 + internal/test/runner_test.go | 46 + internal/test/service.go | 57 + internal/test/service_test.go | 41 + mocks/queue/mock_SQSClient.go | 1444 +++++++++++++++++ mocks/repository/mock_DBTX.go | 237 --- mocks/runner/mock_Controller.go | 85 + scripts/tests.yml | 1 + test/docInitRunner/docinitrunner_test.go | 91 ++ test/queryRunner/queryrunner_test.go | 23 +- test/queryService/client_test.go | 16 +- test/queryService/exportservice_test.go | 10 +- test/queryService/job_test.go | 18 +- test/queryService/jobcollectorservice_test.go | 22 +- test/queryService/openapi_test.go | 16 +- test/queryService/queryservice_test.go | 20 +- test/queryService/testquery_test.go | 12 +- 135 files changed, 3916 insertions(+), 1523 deletions(-) create mode 100644 api/docInitRunner/runner.go create mode 100644 api/docInitRunner/runner_test.go rename api/queryRunner/{queryrunner.go => runner.go} (65%) rename api/queryRunner/{queryrunner_test.go => runner_test.go} (91%) create mode 100644 cmd/docInitRunner/main.go delete mode 100644 internal/document/create.go delete mode 100644 internal/document/create_test.go create mode 100644 internal/document/init/create.go create mode 100644 internal/document/init/create_test.go create mode 100644 internal/document/init/service.go create mode 100644 internal/document/init/service_test.go create mode 100644 internal/server/queue/client.go create mode 100644 internal/serviceconfig/logger/config.go create mode 100644 internal/serviceconfig/logger/config_test.go rename internal/serviceconfig/{ => logger}/testlogger.go (52%) rename internal/serviceconfig/{ => logger}/testlogger_test.go (92%) create mode 100644 internal/serviceconfig/observability/config.go create mode 100644 internal/serviceconfig/observability/config_test.go create mode 100644 internal/serviceconfig/queue/config.go create mode 100644 internal/serviceconfig/queue/config_test.go create mode 100644 internal/serviceconfig/queue/documentclean/config.go delete mode 100644 internal/test/api.go delete mode 100644 internal/test/api_test.go create mode 100644 internal/test/ecosystem.go create mode 100644 internal/test/ecosystem_test.go delete mode 100644 internal/test/queuecontainer.go delete mode 100644 internal/test/queuecontainer_test.go create mode 100644 internal/test/runner.go create mode 100644 internal/test/runner_test.go create mode 100644 internal/test/service.go create mode 100644 internal/test/service_test.go create mode 100644 mocks/queue/mock_SQSClient.go delete mode 100644 mocks/repository/mock_DBTX.go create mode 100644 mocks/runner/mock_Controller.go create mode 100644 test/docInitRunner/docinitrunner_test.go diff --git a/.bitbucket/CODEOWNERS b/.bitbucket/CODEOWNERS index ff43a2ea..ff13605e 100644 --- a/.bitbucket/CODEOWNERS +++ b/.bitbucket/CODEOWNERS @@ -1,6 +1,6 @@ @@@Owners @"Michael McGuinness" -@@@Backend @@Owners +@@@Backend @@Owners @"Jay Brown" @@@Infrastructure @@Owners **/*.go @@Backend \ No newline at end of file diff --git a/.mockery.yml b/.mockery.yml index 8a8732c2..eca44192 100644 --- a/.mockery.yml +++ b/.mockery.yml @@ -1,8 +1,11 @@ --- with-expecter: true +outpkg: "{{.PackageName}}mock" +dir: "mocks/{{.PackageName}}" packages: - queryorchestration/internal/database/repository: - config: - recursive: true - all: true - dir: "mocks/{{.PackageName}}" + queryorchestration/internal/server/queue: + interfaces: + SQSClient: + queryorchestration/internal/server/runner: + interfaces: + Controller: diff --git a/api/docInitRunner/runner.go b/api/docInitRunner/runner.go new file mode 100644 index 00000000..12715e5e --- /dev/null +++ b/api/docInitRunner/runner.go @@ -0,0 +1,49 @@ +package docinitrunner + +import ( + "context" + "encoding/json" + documentinit "queryorchestration/internal/document/init" + + "github.com/go-playground/validator/v10" + + "github.com/aws/aws-sdk-go-v2/service/sqs/types" +) + +const Name = "docInitRunner" + +type Services struct { + Document *documentinit.Service +} + +type Runner struct { + validator *validator.Validate + svc *Services +} + +func New(validator *validator.Validate, svc *Services) Runner { + return Runner{ + validator: validator, + svc: svc, + } +} + +func (s Runner) Process(ctx context.Context, req *types.Message) error { + var body documentinit.Create + err := json.Unmarshal([]byte(*req.Body), &body) + if err != nil { + return err + } + + err = s.validator.Struct(body) + if err != nil { + return err + } + + _, err = s.svc.Document.Create(ctx, &body) + if err != nil { + return err + } + + return nil +} diff --git a/api/docInitRunner/runner_test.go b/api/docInitRunner/runner_test.go new file mode 100644 index 00000000..eaa7b4eb --- /dev/null +++ b/api/docInitRunner/runner_test.go @@ -0,0 +1,82 @@ +package docinitrunner_test + +import ( + "context" + "encoding/json" + docinitrunner "queryorchestration/api/docInitRunner" + "queryorchestration/internal/client" + "queryorchestration/internal/database" + "queryorchestration/internal/database/repository" + documentinit "queryorchestration/internal/document/init" + "queryorchestration/internal/job" + "queryorchestration/internal/job/collector" + "queryorchestration/internal/serviceconfig" + "queryorchestration/internal/serviceconfig/queue/documentclean" + "testing" + + "github.com/aws/aws-sdk-go-v2/service/sqs/types" + "github.com/go-playground/validator/v10" + "github.com/google/uuid" + "github.com/pashagolub/pgxmock/v3" + "github.com/stretchr/testify/assert" +) + +type DocInitConfig struct { + serviceconfig.BaseConfig + documentclean.DocCleanConfig +} + +func TestDocInitRunner(t *testing.T) { + ctx := context.Background() + + pool, err := pgxmock.NewPool() + if err != nil { + t.Fatalf("failed to open pgxmock database: %v", err) + } + + cfg := &DocInitConfig{} + cfg.DBPool = pool + cfg.DBQueries = repository.New(pool) + + runner := docinitrunner.New(validator.New(), &docinitrunner.Services{ + Document: documentinit.New(cfg, &documentinit.Services{ + Job: job.New(cfg, &job.Services{ + Collector: collector.New(cfg, &collector.Services{}), + Client: client.New(cfg), + }), + }), + }) + assert.NotNil(t, runner) + + j := job.Job{ + ID: uuid.New(), + ClientID: uuid.New(), + } + doc := documentinit.Create{ + JobID: j.ID, + Location: "/I/am/here", + } + bodyBytes, err := json.Marshal(doc) + assert.NoError(t, err) + body := string(bodyBytes) + msg := &types.Message{ + Body: &body, + } + + pool.ExpectQuery("name: GetJob :one").WithArgs(database.MustToDBUUID(j.ID)).WillReturnRows( + pgxmock.NewRows([]string{"id", "clientId", "canSync"}). + AddRow(database.MustToDBUUID(j.ID), database.MustToDBUUID(j.ClientID), j.CanSync), + ) + pool.ExpectQuery("-- name: GetClient :one").WithArgs(database.MustToDBUUID(j.ClientID)).WillReturnRows( + pgxmock.NewRows([]string{"id", "name", "canSync"}). + AddRow(database.MustToDBUUID(j.ClientID), "client_name", true), + ) + pool.ExpectQuery("name: CreateDocument :one").WithArgs(database.MustToDBUUID(doc.JobID), pgxmock.AnyArg(), doc.Location). + WillReturnRows( + pgxmock.NewRows([]string{"id"}). + AddRow(database.MustToDBUUID(uuid.New())), + ) + + err = runner.Process(ctx, msg) + assert.NoError(t, err) +} diff --git a/api/queryRunner/queryrunner.go b/api/queryRunner/runner.go similarity index 65% rename from api/queryRunner/queryrunner.go rename to api/queryRunner/runner.go index af78c9c4..772357b8 100644 --- a/api/queryRunner/queryrunner.go +++ b/api/queryRunner/runner.go @@ -1,4 +1,4 @@ -package controllers +package queryrunner import ( "context" @@ -8,30 +8,27 @@ import ( "github.com/go-playground/validator/v10" "github.com/aws/aws-sdk-go-v2/service/sqs/types" - "github.com/google/uuid" ) +const Name = "queryRunner" + type Services struct { Query *query.Service } -type QueryRunner struct { +type Runner struct { validator *validator.Validate svc *Services } -func NewQueryRunner(validator *validator.Validate, svc *Services) QueryRunner { - return QueryRunner{ +func New(validator *validator.Validate, svc *Services) Runner { + return Runner{ validator: validator, svc: svc, } } -type DocumentQueryEvent struct { - ID uuid.UUID `json:"id"` -} - -func (s *QueryRunner) Process(ctx context.Context, req *types.Message) error { +func (s *Runner) Process(ctx context.Context, req *types.Message) error { var body query.Document err := json.Unmarshal([]byte(*req.Body), &body) if err != nil { diff --git a/api/queryRunner/queryrunner_test.go b/api/queryRunner/runner_test.go similarity index 91% rename from api/queryRunner/queryrunner_test.go rename to api/queryRunner/runner_test.go index 3f38da28..39667377 100644 --- a/api/queryRunner/queryrunner_test.go +++ b/api/queryRunner/runner_test.go @@ -1,4 +1,4 @@ -package controllers_test +package queryrunner_test import ( "context" @@ -38,7 +38,7 @@ func TestQueryRunner(t *testing.T) { Collector: collector.New(cfg, &collector.Services{}), }) - runner := controllers.NewQueryRunner(validator.New(), &controllers.Services{ + runner := controllers.New(validator.New(), &controllers.Services{ Query: svc, }) assert.NotNil(t, runner) @@ -50,7 +50,7 @@ func TestQueryRunner(t *testing.T) { TextVersion: 1, } bodyBytes, err := json.Marshal(doc) - assert.Nil(t, err) + assert.NoError(t, err) body := string(bodyBytes) msg := &types.Message{ Body: &body, @@ -62,5 +62,5 @@ func TestQueryRunner(t *testing.T) { ) err = runner.Process(ctx, msg) - assert.Nil(t, err) + assert.NoError(t, err) } diff --git a/api/queryService/client_test.go b/api/queryService/client_test.go index 0014d370..1edc933b 100644 --- a/api/queryService/client_test.go +++ b/api/queryService/client_test.go @@ -38,7 +38,7 @@ func TestCreateClient(t *testing.T) { Name: "example_name", } bodyBytes, err := json.Marshal(body) - assert.Nil(t, err) + assert.NoError(t, err) e := echo.New() req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes))) @@ -54,7 +54,7 @@ func TestCreateClient(t *testing.T) { ) err = cons.CreateClient(ctx) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusCreated, rec.Code) assert.Equal(t, fmt.Sprintf("{\"id\":\"%s\"}\n", id), rec.Body.String()) } @@ -88,12 +88,12 @@ func TestGetClient(t *testing.T) { ) err = cons.GetClient(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) var res queryservice.JobClient err = json.Unmarshal(rec.Body.Bytes(), &res) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, queryservice.JobClient{ Id: id, Name: "client_name", @@ -120,7 +120,7 @@ func TestUpdateClient(t *testing.T) { CanSync: &cs, } bodyBytes, err := json.Marshal(body) - assert.Nil(t, err) + assert.NoError(t, err) e := echo.New() req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes))) @@ -142,7 +142,7 @@ func TestUpdateClient(t *testing.T) { pool.ExpectCommit() err = cons.UpdateClient(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) assert.Empty(t, rec.Body.String()) } diff --git a/api/queryService/controllers.go b/api/queryService/controllers.go index 36a89759..38077a8c 100644 --- a/api/queryService/controllers.go +++ b/api/queryService/controllers.go @@ -10,6 +10,8 @@ import ( "github.com/go-playground/validator/v10" ) +const Name = "queryService" + type Services struct { Export *export.Service Collector *collector.Service diff --git a/api/queryService/export_test.go b/api/queryService/export_test.go index ebb42a12..2f1d983d 100644 --- a/api/queryService/export_test.go +++ b/api/queryService/export_test.go @@ -22,7 +22,7 @@ func TestTriggerExport(t *testing.T) { cons := queryservice.NewControllers(validator.New(), &queryservice.Services{}) err := cons.TriggerExport(ctx) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) assert.NotEmpty(t, rec.Body.String()) } @@ -38,7 +38,7 @@ func TestExportState(t *testing.T) { id := uuid.New() err := cons.ExportState(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) assert.NotEmpty(t, rec.Body.String()) } diff --git a/api/queryService/job_test.go b/api/queryService/job_test.go index 808a8dba..5dffb944 100644 --- a/api/queryService/job_test.go +++ b/api/queryService/job_test.go @@ -49,7 +49,7 @@ func TestCreateJob(t *testing.T) { ClientId: uuid.New(), } bodyBytes, err := json.Marshal(body) - assert.Nil(t, err) + assert.NoError(t, err) e := echo.New() req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes))) @@ -71,7 +71,7 @@ func TestCreateJob(t *testing.T) { pool.ExpectCommit() err = cons.CreateJob(ctx) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusCreated, rec.Code) assert.Equal(t, fmt.Sprintf("{\"id\":\"%s\"}\n", id), rec.Body.String()) } @@ -113,12 +113,12 @@ func TestGetJob(t *testing.T) { ) err = cons.GetJob(ctx, j.ID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) var res queryservice.Job err = json.Unmarshal(rec.Body.Bytes(), &res) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, queryservice.Job{ Id: j.ID, ClientId: j.ClientID, @@ -152,7 +152,7 @@ func TestUpdateJob(t *testing.T) { CanSync: &ucs, } bodyBytes, err := json.Marshal(body) - assert.Nil(t, err) + assert.NoError(t, err) e := echo.New() req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes))) @@ -180,7 +180,7 @@ func TestUpdateJob(t *testing.T) { pool.ExpectCommit() err = cons.UpdateJob(ctx, j.ID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) assert.Empty(t, rec.Body.String()) } diff --git a/api/queryService/jobcollector_test.go b/api/queryService/jobcollector_test.go index 670967c2..d99c0dc0 100644 --- a/api/queryService/jobcollector_test.go +++ b/api/queryService/jobcollector_test.go @@ -36,7 +36,7 @@ func TestUpdateJobCollector(t *testing.T) { ActiveVersion: &av, } bodyBytes, err := json.Marshal(body) - assert.Nil(t, err) + assert.NoError(t, err) e := echo.New() req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes))) @@ -72,7 +72,7 @@ func TestUpdateJobCollector(t *testing.T) { pool.ExpectCommit() err = cons.UpdateJobCollectorByJobId(ctx, current.JobID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) assert.Empty(t, rec.Body.String()) } @@ -114,12 +114,12 @@ func TestGetJobCollectorByJobId(t *testing.T) { ) err = cons.GetJobCollectorByJobId(ctx, coll.JobID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) var res queryservice.JobCollector err = json.Unmarshal(rec.Body.Bytes(), &res) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, queryservice.JobCollector{ JobId: coll.JobID, MinimumCleanerVersion: coll.MinCleanVersion, diff --git a/api/queryService/parse_test.go b/api/queryService/parse_test.go index b2d7428a..562e066e 100644 --- a/api/queryService/parse_test.go +++ b/api/queryService/parse_test.go @@ -25,7 +25,7 @@ func TestParseQueries(t *testing.T) { }, } out, err := parseQueries(in) - assert.Nil(t, err) + assert.NoError(t, err) assert.Len(t, out, len(in)) assert.ElementsMatch(t, []Query{ { @@ -54,7 +54,7 @@ func TestParseQuery(t *testing.T) { Config: &cfg, } out, err := parseQuery(in) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, Query{ Id: in.ID, Type: CONTEXTFULL, @@ -76,7 +76,7 @@ func TestParseQueryMinimal(t *testing.T) { LatestVersion: 2, } out, err := parseQuery(in) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, Query{ Id: in.ID, Type: CONTEXTFULL, @@ -88,39 +88,39 @@ func TestParseQueryMinimal(t *testing.T) { func TestParseQueryType(t *testing.T) { qt, err := parseQueryType(resultprocessor.TypeContextFull) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, CONTEXTFULL, qt) qt, err = parseQueryType(resultprocessor.TypeJsonExtractor) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, JSONEXTRACTOR, qt) _, err = parseQueryType(resultprocessor.Type(-1)) - assert.NotNil(t, err) + assert.Error(t, err) } func TestParseSpecQueryType(t *testing.T) { qt, err := parseSpecQueryType(CONTEXTFULL) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, resultprocessor.Type(resultprocessor.TypeContextFull), qt) qt, err = parseSpecQueryType(JSONEXTRACTOR) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, resultprocessor.Type(resultprocessor.TypeJsonExtractor), qt) _, err = parseSpecQueryType("invalid") - assert.NotNil(t, err) + assert.Error(t, err) } func TestParseStringToUUIDArray(t *testing.T) { ids := []uuid.UUID{uuid.New()} out, err := parseStringToUUIDArray(&[]string{ids[0].String()}) - assert.Nil(t, err) + assert.NoError(t, err) assert.ElementsMatch(t, ids, *out) _, err = parseStringToUUIDArray(&[]string{"invalid_uuid"}) assert.Error(t, err) out, err = parseStringToUUIDArray(nil) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, out) } diff --git a/api/queryService/query_test.go b/api/queryService/query_test.go index fe71df3d..e403c117 100644 --- a/api/queryService/query_test.go +++ b/api/queryService/query_test.go @@ -44,7 +44,7 @@ func TestCreateQuery(t *testing.T) { Type: queryservice.CONTEXTFULL, } bodyBytes, err := json.Marshal(body) - assert.Nil(t, err) + assert.NoError(t, err) e := echo.New() req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes))) @@ -62,7 +62,7 @@ func TestCreateQuery(t *testing.T) { pool.ExpectCommit() err = cons.CreateQuery(ctx) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusCreated, rec.Code) assert.Equal(t, fmt.Sprintf("{\"id\":\"%s\"}\n", id), rec.Body.String()) } @@ -93,12 +93,12 @@ func TestListQueries(t *testing.T) { ) err = cons.ListQueries(ctx) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) var res queryservice.ListQueries err = json.Unmarshal(rec.Body.Bytes(), &res) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, res.Queries) assert.ElementsMatch(t, res.Queries, []queryservice.Query{ { @@ -138,12 +138,12 @@ func TestGetQuery(t *testing.T) { ) err = cons.GetQuery(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) var res queryservice.Query err = json.Unmarshal(rec.Body.Bytes(), &res) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, queryservice.Query{ Id: id, Type: queryservice.CONTEXTFULL, @@ -170,7 +170,7 @@ func TestUpdateQuery(t *testing.T) { ActiveVersion: &av, } bodyBytes, err := json.Marshal(body) - assert.Nil(t, err) + assert.NoError(t, err) e := echo.New() req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes))) @@ -193,7 +193,7 @@ func TestUpdateQuery(t *testing.T) { pool.ExpectCommit() err = cons.UpdateQuery(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) assert.Empty(t, rec.Body.String()) } @@ -241,7 +241,7 @@ func TestTestQuery(t *testing.T) { QueryVersion: params.QueryVersion, } bodyBytes, err := json.Marshal(body) - assert.Nil(t, err) + assert.NoError(t, err) e := echo.New() req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes))) @@ -275,12 +275,12 @@ func TestTestQuery(t *testing.T) { ) err = cons.TestQuery(ctx, params.QueryID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, http.StatusOK, rec.Code) var res queryservice.QueryTestResponse err = json.Unmarshal(rec.Body.Bytes(), &res) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, queryservice.QueryTestResponse{ Value: "old_value", }, res) diff --git a/cmd/docInitRunner/main.go b/cmd/docInitRunner/main.go new file mode 100644 index 00000000..9d5d7480 --- /dev/null +++ b/cmd/docInitRunner/main.go @@ -0,0 +1,64 @@ +package main + +import ( + "context" + "log/slog" + "os" + docinitrunner "queryorchestration/api/docInitRunner" + "queryorchestration/internal/client" + documentclean "queryorchestration/internal/document/clean" + documentinit "queryorchestration/internal/document/init" + documenttext "queryorchestration/internal/document/text" + "queryorchestration/internal/job" + "queryorchestration/internal/job/collector" + "queryorchestration/internal/server/runner" + "queryorchestration/internal/serviceconfig" + documentcleanc "queryorchestration/internal/serviceconfig/queue/documentclean" + + _ "github.com/lib/pq" +) + +type DocInitConfig struct { + runner.BaseConfig + documentcleanc.DocCleanConfig +} + +func main() { + ctx := context.Background() + + cfg := &DocInitConfig{} + + if err := serviceconfig.InitializeConfig(cfg); err != nil { + slog.Error("Error initializing config", "err", err) + os.Exit(1) + } + + cfg.ControllerFunc = func() runner.Controller { + text := documenttext.New() + clean := documentclean.New() + cli := client.New(cfg) + col := collector.New(cfg, &collector.Services{ + Clean: clean, + Text: text, + }) + j := job.New(cfg, &job.Services{ + Collector: col, + Client: cli, + }) + doc := documentinit.New(cfg, &documentinit.Services{ + Job: j, + }) + + return docinitrunner.New(cfg.GetValidator(), &docinitrunner.Services{ + Document: doc, + }) + } + + server, err := runner.New(ctx, cfg) + if err != nil { + slog.Error(err.Error()) + os.Exit(1) + } + + server.Listen(ctx) +} diff --git a/cmd/queryRunner/main.go b/cmd/queryRunner/main.go index 69501234..4ed57fca 100644 --- a/cmd/queryRunner/main.go +++ b/cmd/queryRunner/main.go @@ -43,7 +43,7 @@ func main() { Document: doc, }) - c := controllers.NewQueryRunner(cfg.GetValidator(), &controllers.Services{ + c := controllers.New(cfg.GetValidator(), &controllers.Services{ Query: svc, }) diff --git a/devbox.json b/devbox.json index c2da67df..722094b6 100644 --- a/devbox.json +++ b/devbox.json @@ -15,7 +15,8 @@ "hadolint@2.12.0", "gotools@0.25.0", "nodePackages.jsonlint@1.6.3", - "oapi-codegen@2.4.1" + "oapi-codegen@2.4.1", + "vacuum-go@0.14.1" ], "shell": { "init_hook": [ @@ -24,13 +25,16 @@ ] }, "env": { - "APP_ENV": "development", - "DB_USER": "postgres", - "DB_PASS": "pass", - "DB_HOST": "localhost", - "DB_PORT": "5432", - "DB_NAME": "query_orchestration", - "DB_NOSSL": "true" + "APP_ENV": "development", + "DB_USER": "postgres", + "DB_PASS": "pass", + "DB_HOST": "localhost", + "DB_PORT": "5432", + "DB_NAME": "query_orchestration", + "DB_NOSSL": "true", + "AWS_ACCESS_KEY_ID": "test", + "AWS_SECRET_ACCESS_KEY": "test", + "AWS_REGION": "us-east-1" }, "env_from": ".env" } diff --git a/devbox.lock b/devbox.lock index cf4fcdd1..9ab80907 100644 --- a/devbox.lock +++ b/devbox.lock @@ -677,6 +677,54 @@ } } }, + "vacuum-go@0.14.1": { + "last_modified": "2024-11-28T07:51:56Z", + "resolved": "github:NixOS/nixpkgs/226216574ada4c3ecefcbbec41f39ce4655f78ef#vacuum-go", + "source": "devbox-search", + "version": "0.14.1", + "systems": { + "aarch64-darwin": { + "outputs": [ + { + "name": "out", + "path": "/nix/store/b5jalz7pq12gxj0a1sq5dfbns9gx0ygf-vacuum-go-0.14.1", + "default": true + } + ], + "store_path": "/nix/store/b5jalz7pq12gxj0a1sq5dfbns9gx0ygf-vacuum-go-0.14.1" + }, + "aarch64-linux": { + "outputs": [ + { + "name": "out", + "path": "/nix/store/0agzrxdxifby6hm5cj5803lxja3vzk3i-vacuum-go-0.14.1", + "default": true + } + ], + "store_path": "/nix/store/0agzrxdxifby6hm5cj5803lxja3vzk3i-vacuum-go-0.14.1" + }, + "x86_64-darwin": { + "outputs": [ + { + "name": "out", + "path": "/nix/store/l3ywqp4gh6bhz0wqh0cjgvhn6a1kpzwx-vacuum-go-0.14.1", + "default": true + } + ], + "store_path": "/nix/store/l3ywqp4gh6bhz0wqh0cjgvhn6a1kpzwx-vacuum-go-0.14.1" + }, + "x86_64-linux": { + "outputs": [ + { + "name": "out", + "path": "/nix/store/flyd4lkak9ynkx5qbica64z5gq9bx021-vacuum-go-0.14.1", + "default": true + } + ], + "store_path": "/nix/store/flyd4lkak9ynkx5qbica64z5gq9bx021-vacuum-go-0.14.1" + } + } + }, "yamllint@1.35.1": { "last_modified": "2024-12-23T21:10:33Z", "resolved": "github:NixOS/nixpkgs/de1864217bfa9b5845f465e771e0ecb48b30e02d#yamllint", diff --git a/internal/client/create_test.go b/internal/client/create_test.go index cb7154f5..efc7cdde 100644 --- a/internal/client/create_test.go +++ b/internal/client/create_test.go @@ -36,6 +36,6 @@ func TestCreate(t *testing.T) { ) id, err := svc.Create(ctx, name) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, aid, id) } diff --git a/internal/client/get_test.go b/internal/client/get_test.go index cf2a208f..639c31d1 100644 --- a/internal/client/get_test.go +++ b/internal/client/get_test.go @@ -36,7 +36,7 @@ func TestGet(t *testing.T) { ) cli, err := svc.Get(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &client.Client{ ID: id, Name: "client_name", diff --git a/internal/client/serviceprivate_test.go b/internal/client/serviceprivate_test.go index f1d119f7..3ce9f00e 100644 --- a/internal/client/serviceprivate_test.go +++ b/internal/client/serviceprivate_test.go @@ -10,41 +10,41 @@ import ( func TestNormalizeName(t *testing.T) { name := "name" err := normalizeName(&name) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, "name", name) name = "" err = normalizeName(&name) - assert.NotNil(t, err) + assert.Error(t, err) name = " name\t" err = normalizeName(&name) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, "name", name) name = "name second" err = normalizeName(&name) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, "name second", name) name = "name\t second" err = normalizeName(&name) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, "name second", name) name = "name_second" err = normalizeName(&name) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, "name_second", name) name = "name-second" err = normalizeName(&name) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, "name-second", name) name = "name123" err = normalizeName(&name) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, "name123", name) } @@ -77,19 +77,19 @@ func TestNormalizeNameUpdate(t *testing.T) { } err := c.normalizeNameUpdate(nil) - assert.Nil(t, err) + assert.NoError(t, err) v := "update_name" val := &v err = c.normalizeNameUpdate(&val) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, val) assert.Equal(t, "update_name", *val) v = c.Name val = &v err = c.normalizeNameUpdate(&val) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, val) v = "###" diff --git a/internal/client/update_test.go b/internal/client/update_test.go index cd7f3fe4..090340bc 100644 --- a/internal/client/update_test.go +++ b/internal/client/update_test.go @@ -93,7 +93,7 @@ func TestNormalizeUpdateParams(t *testing.T) { CanSync: &cs, } err = svc.normalizeUpdateParams(current, update) - assert.Nil(t, err) + assert.NoError(t, err) n = "updated_client" cs = true assert.EqualExportedValues(t, Update{ @@ -137,7 +137,7 @@ func TestSubmitUpdate(t *testing.T) { pool.ExpectCommit() err = svc.submitUpdate(ctx, &update) - assert.Nil(t, err) + assert.NoError(t, err) c.CanSync = true update.CanSync = &c.CanSync @@ -148,7 +148,7 @@ func TestSubmitUpdate(t *testing.T) { pool.ExpectCommit() err = svc.submitUpdate(ctx, &update) - assert.Nil(t, err) + assert.NoError(t, err) c.Name = "updated_name" update.Name = &c.Name @@ -160,5 +160,5 @@ func TestSubmitUpdate(t *testing.T) { pool.ExpectCommit() err = svc.submitUpdate(ctx, &update) - assert.Nil(t, err) + assert.NoError(t, err) } diff --git a/internal/database/migrations/migrations.go b/internal/database/migrations/migrations.go index 9ac8f886..bbdf170f 100644 --- a/internal/database/migrations/migrations.go +++ b/internal/database/migrations/migrations.go @@ -7,6 +7,7 @@ import ( "log/slog" "path" "queryorchestration/internal/serviceconfig" + "queryorchestration/internal/serviceconfig/database" "github.com/golang-migrate/migrate/v4" _ "github.com/golang-migrate/migrate/v4/database/postgres" @@ -14,7 +15,7 @@ import ( _ "github.com/lib/pq" ) -func createDB(cfg serviceconfig.ConfigProvider) error { +func createDB(cfg database.ConfigProvider) error { connStr := fmt.Sprintf("%s?%s", cfg.GetDBBaseURI(), cfg.GetDBOptsString()) db, err := sql.Open(cfg.GetDBDriver(), connStr) @@ -32,7 +33,7 @@ func createDB(cfg serviceconfig.ConfigProvider) error { return fmt.Errorf("error creating database: %v", err) } - if !rs.Next() { + if rs.Next() { slog.Info("database created", "name", cfg.GetDBName()) } else { slog.Info("database already exists", "name", cfg.GetDBName()) diff --git a/internal/database/migrations/migrations_test.go b/internal/database/migrations/migrations_test.go index db78e195..8b17eb9b 100644 --- a/internal/database/migrations/migrations_test.go +++ b/internal/database/migrations/migrations_test.go @@ -5,7 +5,6 @@ import ( "os" "path" "queryorchestration/internal/database/migrations" - "queryorchestration/internal/serviceconfig" "queryorchestration/internal/test" "testing" @@ -18,34 +17,30 @@ func TestRunMigrations(t *testing.T) { } ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &serviceconfig.BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ Cfg: cfg, }) defer cleanup() - err = migrations.Run(ctx, cfg) - assert.Nil(t, err) + err := migrations.Run(ctx, cfg) + assert.NoError(t, err) } func TestRunMigrationsNoDB(t *testing.T) { ctx := context.Background() - t.Setenv("DB_USER", "invalid_user") - t.Setenv("DB_PASS", "invalid_pass") - t.Setenv("DB_HOST", "invalid_host") - t.Setenv("DB_PORT", "5432") - t.Setenv("DB_NAME", "invalid_name") - t.Setenv("DB_NOSSL", "true") - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &serviceconfig.BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") + cfg.DBUser = "invalid_user" + cfg.DBSecret = "invalid_pass" + cfg.DBHost = "invalid_host" + cfg.DBPort = 5432 + cfg.DBName = "invalid_name" + cfg.DBNoSSL = true - err = migrations.Run(ctx, cfg) + err := migrations.Run(ctx, cfg) assert.Error(t, err) } diff --git a/internal/database/migrations/migrationsprivate_test.go b/internal/database/migrations/migrationsprivate_test.go index b12ec90f..6a77d14c 100644 --- a/internal/database/migrations/migrationsprivate_test.go +++ b/internal/database/migrations/migrationsprivate_test.go @@ -1,18 +1,17 @@ package migrations import ( - "queryorchestration/internal/serviceconfig" + "queryorchestration/internal/serviceconfig/database" "testing" "github.com/stretchr/testify/assert" ) func TestCreateDB(t *testing.T) { - t.Setenv("DB_HOST", "invalid_value") - cfg := &serviceconfig.BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) + cfg := &database.DBConfig{ + DBHost: "invalid_value", + } - err = createDB(cfg) + err := createDB(cfg) assert.Error(t, err) } diff --git a/internal/database/parseuuid_test.go b/internal/database/parseuuid_test.go index 4ad97176..e4092ede 100644 --- a/internal/database/parseuuid_test.go +++ b/internal/database/parseuuid_test.go @@ -13,7 +13,7 @@ func TestToDBUUID(t *testing.T) { id := uuid.New() dbID, err := database.ToDBUUID(id) - assert.Nil(t, err) + assert.NoError(t, err) assert.True(t, dbID.Valid) assert.Equal(t, id.String(), uuid.UUID(dbID.Bytes).String()) @@ -23,7 +23,7 @@ func TestToDBUUIDNil(t *testing.T) { id := uuid.Nil dbID, err := database.ToDBUUID(id) - assert.Nil(t, err) + assert.NoError(t, err) assert.False(t, dbID.Valid) assert.Equal(t, id.String(), uuid.UUID(dbID.Bytes).String()) @@ -33,7 +33,7 @@ func TestToDBUUIDArray(t *testing.T) { ids := []uuid.UUID{uuid.Nil, uuid.New()} dbIDs, err := database.ToDBUUIDArray(ids) - assert.Nil(t, err) + assert.NoError(t, err) assert.Len(t, dbIDs, 1) assert.ElementsMatch(t, []pgtype.UUID{database.MustToDBUUID(ids[1])}, dbIDs) @@ -41,10 +41,10 @@ func TestToDBUUIDArray(t *testing.T) { func TestToUUID(t *testing.T) { dbID, err := database.ToDBUUID(uuid.New()) - assert.Nil(t, err) + assert.NoError(t, err) id, err := database.ToUUID(dbID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, id.String(), uuid.UUID(dbID.Bytes).String()) } @@ -54,7 +54,7 @@ func TestToUUIDArray(t *testing.T) { dbIDs := database.MustToDBUUIDArray(ogIDs) ids, err := database.ToUUIDArray(dbIDs) - assert.Nil(t, err) + assert.NoError(t, err) assert.Len(t, ids, 1) assert.ElementsMatch(t, []uuid.UUID{ogIDs[1]}, ids) diff --git a/internal/database/repository/client_test.go b/internal/database/repository/client_test.go index 40dee16b..33d62a0d 100644 --- a/internal/database/repository/client_test.go +++ b/internal/database/repository/client_test.go @@ -5,7 +5,6 @@ import ( "os" "path" "queryorchestration/internal/database/repository" - "queryorchestration/internal/serviceconfig" "queryorchestration/internal/test" "testing" @@ -15,11 +14,8 @@ import ( func TestClient(t *testing.T) { ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &serviceconfig.BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) - + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ Cfg: cfg, RunMigrations: true, @@ -29,11 +25,11 @@ func TestClient(t *testing.T) { queries := cfg.DBQueries id, err := queries.CreateClient(ctx, "example_client") - assert.Nil(t, err) + assert.NoError(t, err) assert.NotEmpty(t, id) client, err := queries.GetClient(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.GetClientRow{ ID: id, Name: "example_client", @@ -44,10 +40,10 @@ func TestClient(t *testing.T) { ID: id, Name: "updated_client", }) - assert.Nil(t, err) + assert.NoError(t, err) client, err = queries.GetClient(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.GetClientRow{ ID: id, Name: "updated_client", @@ -58,10 +54,10 @@ func TestClient(t *testing.T) { Clientid: id, Cansync: true, }) - assert.Nil(t, err) + assert.NoError(t, err) client, err = queries.GetClient(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.GetClientRow{ ID: id, Name: "updated_client", diff --git a/internal/database/repository/collector_test.go b/internal/database/repository/collector_test.go index c0f4d8bc..9818957b 100644 --- a/internal/database/repository/collector_test.go +++ b/internal/database/repository/collector_test.go @@ -7,7 +7,6 @@ import ( "path" "queryorchestration/internal/database" "queryorchestration/internal/database/repository" - "queryorchestration/internal/serviceconfig" "queryorchestration/internal/test" "testing" @@ -18,11 +17,8 @@ import ( func TestCollector(t *testing.T) { ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &serviceconfig.BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) - + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ Cfg: cfg, RunMigrations: true, @@ -32,28 +28,28 @@ func TestCollector(t *testing.T) { queries := cfg.DBQueries contextId, err := queries.CreateQuery(ctx, repository.QuerytypeContextFull) - assert.Nil(t, err) + assert.NoError(t, err) jsonId, err := queries.CreateQuery(ctx, repository.QuerytypeJsonExtractor) - assert.Nil(t, err) + assert.NoError(t, err) err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{ Queryid: jsonId, Requiredqueryid: contextId, Addedversion: 1, }) - assert.Nil(t, err) + assert.NoError(t, err) clientId, err := queries.CreateClient(ctx, "example_client") - assert.Nil(t, err) + assert.NoError(t, err) jobId, err := queries.CreateJob(ctx, clientId) - assert.Nil(t, err) + assert.NoError(t, err) minCleanVersion := int32(2) minTextVersion := int32(4) collId, err := queries.CreateCollector(ctx, jobId) - assert.Nil(t, err) + assert.NoError(t, err) coll, err := queries.GetCollector(ctx, collId) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.Fullactivecollector{ ID: collId, Jobid: jobId, @@ -64,7 +60,7 @@ func TestCollector(t *testing.T) { }, coll) coll, err = queries.GetCollectorByJobID(ctx, jobId) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.Fullactivecollector{ ID: collId, Jobid: jobId, @@ -80,7 +76,7 @@ func TestCollector(t *testing.T) { Addedversion: 1, Name: "example_key", }) - assert.Nil(t, err) + assert.NoError(t, err) err = queries.AddCollectorCodeVersion(ctx, &repository.AddCollectorCodeVersionParams{ Collectorid: collId, @@ -88,10 +84,10 @@ func TestCollector(t *testing.T) { Mincleanversion: minCleanVersion, Mintextversion: minTextVersion, }) - assert.Nil(t, err) + assert.NoError(t, err) coll, err = queries.GetCollector(ctx, collId) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.Fullactivecollector{ ID: collId, Jobid: jobId, @@ -103,7 +99,7 @@ func TestCollector(t *testing.T) { }, coll) qs, err := queries.ListCollectorQueries(ctx, collId) - assert.Nil(t, err) + assert.NoError(t, err) assert.Len(t, qs, 2) assert.ElementsMatch(t, []*repository.Collectorquerydependencytree{ { @@ -128,23 +124,23 @@ func TestCollector(t *testing.T) { Queryid: jsonId, Removedversion: &removeV, }) - assert.Nil(t, err) + assert.NoError(t, err) err = queries.RemoveCollectorCodeVersion(ctx, &repository.RemoveCollectorCodeVersionParams{ Collectorid: collId, Removedversion: &removeV, }) - assert.Nil(t, err) + assert.NoError(t, err) err = queries.UpdateCollector(ctx, &repository.UpdateCollectorParams{ ID: collId, Latestversion: 2, Activeversion: 2, }) - assert.Nil(t, err) + assert.NoError(t, err) coll, err = queries.GetCollector(ctx, collId) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.Fullactivecollector{ ID: collId, Jobid: jobId, diff --git a/internal/database/repository/db_test.go b/internal/database/repository/db_test.go index 21e8e834..b51babe3 100644 --- a/internal/database/repository/db_test.go +++ b/internal/database/repository/db_test.go @@ -34,7 +34,7 @@ func TestQueriesWithTx(t *testing.T) { pool.ExpectBeginTx(pgx.TxOptions{}) tx, err := pool.Begin(ctx) - assert.Nil(t, err) + assert.NoError(t, err) txQueries := queries.WithTx(tx) assert.NotNil(t, txQueries) diff --git a/internal/database/repository/document_test.go b/internal/database/repository/document_test.go index 169e4b35..92363a87 100644 --- a/internal/database/repository/document_test.go +++ b/internal/database/repository/document_test.go @@ -5,7 +5,6 @@ import ( "os" "path" "queryorchestration/internal/database/repository" - "queryorchestration/internal/serviceconfig" "queryorchestration/internal/test" "testing" @@ -15,11 +14,8 @@ import ( func TestDocument(t *testing.T) { ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &serviceconfig.BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) - + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ Cfg: cfg, RunMigrations: true, @@ -29,20 +25,20 @@ func TestDocument(t *testing.T) { queries := cfg.DBQueries clientId, err := queries.CreateClient(ctx, "example_client") - assert.Nil(t, err) + assert.NoError(t, err) jobId, err := queries.CreateJob(ctx, clientId) - assert.Nil(t, err) + assert.NoError(t, err) hash := "example_hash" id, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{ Jobid: jobId, Hash: hash, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotEmpty(t, id) doc, err := queries.GetDocument(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.Document{ ID: id, Jobid: jobId, diff --git a/internal/database/repository/job_test.go b/internal/database/repository/job_test.go index 919611a2..7436dcb8 100644 --- a/internal/database/repository/job_test.go +++ b/internal/database/repository/job_test.go @@ -5,7 +5,6 @@ import ( "os" "path" "queryorchestration/internal/database/repository" - "queryorchestration/internal/serviceconfig" "queryorchestration/internal/test" "testing" @@ -14,11 +13,9 @@ import ( func TestJob(t *testing.T) { ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &serviceconfig.BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ Cfg: cfg, RunMigrations: true, @@ -28,14 +25,14 @@ func TestJob(t *testing.T) { queries := cfg.DBQueries clientId, err := queries.CreateClient(ctx, "example_client") - assert.Nil(t, err) + assert.NoError(t, err) id, err := queries.CreateJob(ctx, clientId) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotEmpty(t, id) job, err := queries.GetJob(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.GetJobRow{ ID: id, Clientid: clientId, @@ -46,10 +43,10 @@ func TestJob(t *testing.T) { Cansync: true, Jobid: id, }) - assert.Nil(t, err) + assert.NoError(t, err) job, err = queries.GetJob(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.GetJobRow{ ID: id, Clientid: clientId, diff --git a/internal/database/repository/query_test.go b/internal/database/repository/query_test.go index 106cbd89..47a26814 100644 --- a/internal/database/repository/query_test.go +++ b/internal/database/repository/query_test.go @@ -6,7 +6,6 @@ import ( "path" "queryorchestration/internal/database" "queryorchestration/internal/database/repository" - "queryorchestration/internal/serviceconfig" "queryorchestration/internal/test" "testing" @@ -17,11 +16,9 @@ import ( func TestQueries(t *testing.T) { ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &serviceconfig.BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ Cfg: cfg, RunMigrations: true, @@ -31,15 +28,15 @@ func TestQueries(t *testing.T) { queries := cfg.DBQueries contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull)) - assert.Nil(t, err) + assert.NoError(t, err) assert.True(t, contextQueryID.Valid) jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor)) - assert.Nil(t, err) + assert.NoError(t, err) assert.True(t, jsonQueryID.Valid) jsonQuery, err := queries.GetQuery(ctx, jsonQueryID) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.Fullactivequery{ ID: jsonQueryID, Type: repository.QuerytypeJsonExtractor, @@ -54,7 +51,7 @@ func TestQueries(t *testing.T) { Activeversion: 1, ID: jsonQueryID, }) - assert.Nil(t, err) + assert.NoError(t, err) jsonConfig := []byte("{\"path\": \"example_path\"}") @@ -63,7 +60,7 @@ func TestQueries(t *testing.T) { Requiredqueryid: contextQueryID, Addedversion: 1, }) - assert.Nil(t, err) + assert.NoError(t, err) removeV := int32(2) err = queries.RemoveRequiredQuery(ctx, &repository.RemoveRequiredQueryParams{ @@ -71,20 +68,20 @@ func TestQueries(t *testing.T) { Requiredqueryid: contextQueryID, Removedversion: &removeV, }) - assert.Nil(t, err) + assert.NoError(t, err) err = queries.AddQueryConfig(ctx, &repository.AddQueryConfigParams{ Queryid: jsonQueryID, Config: jsonConfig, Addedversion: 1, }) - assert.Nil(t, err) + assert.NoError(t, err) jsonQueryConfig, err := queries.GetQueryConfig(ctx, &repository.GetQueryConfigParams{ Queryid: jsonQueryID, Addedversion: jsonQuery.Activeversion, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, jsonConfig, jsonQueryConfig.Config) removeV = 2 @@ -92,7 +89,7 @@ func TestQueries(t *testing.T) { Queryid: jsonQueryID, Removedversion: &removeV, }) - assert.Nil(t, err) + assert.NoError(t, err) _, err = queries.GetQueryConfig(ctx, &repository.GetQueryConfigParams{ Queryid: jsonQueryID, @@ -101,7 +98,7 @@ func TestQueries(t *testing.T) { assert.EqualError(t, err, "no rows in result set") jsonQuery, err = queries.GetQuery(ctx, jsonQueryID) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.Fullactivequery{ ID: jsonQueryID, Type: repository.QuerytypeJsonExtractor, @@ -116,10 +113,10 @@ func TestQueries(t *testing.T) { Latestversion: 2, ID: jsonQueryID, }) - assert.Nil(t, err) + assert.NoError(t, err) jsonQuery, err = queries.GetQuery(ctx, jsonQueryID) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.Fullactivequery{ ID: jsonQueryID, Type: repository.QuerytypeJsonExtractor, @@ -133,7 +130,7 @@ func TestQueries(t *testing.T) { ID: jsonQueryID, Addedversion: 1, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.GetQueryWithVersionRow{ ID: jsonQueryID, Type: repository.QuerytypeJsonExtractor, @@ -144,34 +141,31 @@ func TestQueries(t *testing.T) { }, versionedQuery) all_exist, err := queries.AllQueriesExist(ctx, []pgtype.UUID{}) - assert.Nil(t, err) + assert.NoError(t, err) assert.True(t, all_exist) all_exist, err = queries.AllQueriesExist(ctx, []pgtype.UUID{database.MustToDBUUID(uuid.New())}) - assert.Nil(t, err) + assert.NoError(t, err) assert.False(t, all_exist) all_exist, err = queries.AllQueriesExist(ctx, []pgtype.UUID{jsonQueryID}) - assert.Nil(t, err) + assert.NoError(t, err) assert.True(t, all_exist) all_exist, err = queries.AllQueriesExist(ctx, []pgtype.UUID{jsonQueryID, contextQueryID}) - assert.Nil(t, err) + assert.NoError(t, err) assert.True(t, all_exist) all_exist, err = queries.AllQueriesExist(ctx, []pgtype.UUID{jsonQueryID, database.MustToDBUUID(uuid.New())}) - assert.Nil(t, err) + assert.NoError(t, err) assert.False(t, all_exist) } func TestQueryDependencyTree(t *testing.T) { ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &serviceconfig.BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) - + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ Cfg: cfg, RunMigrations: true, @@ -181,70 +175,67 @@ func TestQueryDependencyTree(t *testing.T) { queries := cfg.DBQueries contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull)) - assert.Nil(t, err) + assert.NoError(t, err) jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor)) - assert.Nil(t, err) + assert.NoError(t, err) err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{ Queryid: jsonQueryID, Requiredqueryid: contextQueryID, Addedversion: 1, }) - assert.Nil(t, err) + assert.NoError(t, err) secondJsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor)) - assert.Nil(t, err) + assert.NoError(t, err) err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{ Queryid: secondJsonQueryID, Requiredqueryid: jsonQueryID, Addedversion: 1, }) - assert.Nil(t, err) + assert.NoError(t, err) isdependent, err := queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{ Requiredqueryid: jsonQueryID, ID: []pgtype.UUID{contextQueryID}, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.False(t, isdependent) isdependent, err = queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{ Requiredqueryid: jsonQueryID, ID: []pgtype.UUID{secondJsonQueryID}, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.True(t, isdependent) isdependent, err = queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{ Requiredqueryid: jsonQueryID, ID: []pgtype.UUID{jsonQueryID}, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.True(t, isdependent) isdependent, err = queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{ Requiredqueryid: secondJsonQueryID, ID: []pgtype.UUID{jsonQueryID, contextQueryID}, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.False(t, isdependent) isdependent, err = queries.IsQueryInDependencyTree(ctx, &repository.IsQueryInDependencyTreeParams{ Requiredqueryid: contextQueryID, ID: []pgtype.UUID{jsonQueryID, secondJsonQueryID}, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.True(t, isdependent) } func TestQueriesList(t *testing.T) { ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &serviceconfig.BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) - + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ Cfg: cfg, RunMigrations: true, @@ -254,13 +245,13 @@ func TestQueriesList(t *testing.T) { queries := cfg.DBQueries contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull)) - assert.Nil(t, err) + assert.NoError(t, err) jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor)) - assert.Nil(t, err) + assert.NoError(t, err) qs, err := queries.ListQueries(ctx) - assert.Nil(t, err) + assert.NoError(t, err) assert.Len(t, qs, 2) assert.ElementsMatch(t, []*repository.Fullactivequery{ { @@ -282,7 +273,7 @@ func TestQueriesList(t *testing.T) { }, qs) qs, err = queries.ListQueriesById(ctx, []pgtype.UUID{jsonQueryID}) - assert.Nil(t, err) + assert.NoError(t, err) assert.Len(t, qs, 1) assert.ElementsMatch(t, []*repository.Fullactivequery{ { diff --git a/internal/database/repository/querytype_test.go b/internal/database/repository/querytype_test.go index 1a8359f0..2cd29c3d 100644 --- a/internal/database/repository/querytype_test.go +++ b/internal/database/repository/querytype_test.go @@ -13,7 +13,7 @@ func TestQueryTypeScan(t *testing.T) { stringType := "context_full" err := qType.Scan(stringType) - assert.Nil(t, err) + assert.NoError(t, err) } func TestNullQueryTypeScan(t *testing.T) { @@ -21,7 +21,7 @@ func TestNullQueryTypeScan(t *testing.T) { stringType := "context_full" err := qType.Scan(stringType) - assert.Nil(t, err) + assert.NoError(t, err) } func TestNullQueryTypeValue(t *testing.T) { @@ -29,10 +29,10 @@ func TestNullQueryTypeValue(t *testing.T) { stringType := "context_full" err := qType.Scan(stringType) - assert.Nil(t, err) + assert.NoError(t, err) val, err := qType.Value() - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, stringType, val) } diff --git a/internal/database/repository/result_test.go b/internal/database/repository/result_test.go index 919b2de2..b05114a3 100644 --- a/internal/database/repository/result_test.go +++ b/internal/database/repository/result_test.go @@ -5,7 +5,6 @@ import ( "os" "path" "queryorchestration/internal/database/repository" - "queryorchestration/internal/serviceconfig" "queryorchestration/internal/test" "testing" @@ -16,11 +15,8 @@ import ( func TestResults(t *testing.T) { ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &serviceconfig.BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) - + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ Cfg: cfg, RunMigrations: true, @@ -30,20 +26,20 @@ func TestResults(t *testing.T) { queries := cfg.DBQueries jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor)) - assert.Nil(t, err) + assert.NoError(t, err) clientId, err := queries.CreateClient(ctx, "example_client") - assert.Nil(t, err) + assert.NoError(t, err) jobId, err := queries.CreateJob(ctx, clientId) - assert.Nil(t, err) + assert.NoError(t, err) documentID, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{ Jobid: jobId, Hash: "example_hash", }) - assert.Nil(t, err) + assert.NoError(t, err) jsonQuery, err := queries.GetQuery(ctx, jsonQueryID) - assert.Nil(t, err) + assert.NoError(t, err) cleanVersion := int32(1) textVersion := int32(1) @@ -57,7 +53,7 @@ func TestResults(t *testing.T) { Textversion: textVersion, Queryversion: jsonQuery.Activeversion, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.True(t, jsonResultID.Valid) res, err := queries.GetResultValueWithVersion(ctx, &repository.GetResultValueWithVersionParams{ @@ -67,7 +63,7 @@ func TestResults(t *testing.T) { Cleanversion: cleanVersion, Textversion: textVersion, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &repository.GetResultValueWithVersionRow{ ID: jsonResultID, Value: jsonResultValue, @@ -77,11 +73,8 @@ func TestResults(t *testing.T) { func TestResultValues(t *testing.T) { ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &serviceconfig.BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) - + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ Cfg: cfg, RunMigrations: true, @@ -91,29 +84,29 @@ func TestResultValues(t *testing.T) { queries := cfg.DBQueries jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor)) - assert.Nil(t, err) + assert.NoError(t, err) clientId, err := queries.CreateClient(ctx, "example_client") - assert.Nil(t, err) + assert.NoError(t, err) jobId, err := queries.CreateJob(ctx, clientId) - assert.Nil(t, err) + assert.NoError(t, err) documentID, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{ Jobid: jobId, Hash: "example_hash", }) - assert.Nil(t, err) + assert.NoError(t, err) contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull)) - assert.Nil(t, err) + assert.NoError(t, err) err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{ Queryid: jsonQueryID, Requiredqueryid: contextQueryID, Addedversion: 1, }) - assert.Nil(t, err) + assert.NoError(t, err) contextQuery, err := queries.GetQuery(ctx, contextQueryID) - assert.Nil(t, err) + assert.NoError(t, err) result := repository.SetResultParams{ Queryid: contextQueryID, @@ -125,7 +118,7 @@ func TestResultValues(t *testing.T) { } _, err = queries.SetResult(ctx, &result) - assert.Nil(t, err) + assert.NoError(t, err) _, err = queries.SetResult(ctx, &repository.SetResultParams{ Queryid: contextQueryID, @@ -135,7 +128,7 @@ func TestResultValues(t *testing.T) { Textversion: 2, Queryversion: contextQuery.Activeversion - 1, }) - assert.Nil(t, err) + assert.NoError(t, err) _, err = queries.SetResult(ctx, &repository.SetResultParams{ Queryid: contextQueryID, @@ -145,7 +138,7 @@ func TestResultValues(t *testing.T) { Textversion: 2, Queryversion: contextQuery.Activeversion, }) - assert.Nil(t, err) + assert.NoError(t, err) _, err = queries.SetResult(ctx, &repository.SetResultParams{ Queryid: jsonQueryID, @@ -155,7 +148,7 @@ func TestResultValues(t *testing.T) { Textversion: 2, Queryversion: contextQuery.Activeversion, }) - assert.Nil(t, err) + assert.NoError(t, err) qResults, err := queries.ListQueryRequirementValues(ctx, &repository.ListQueryRequirementValuesParams{ Queryid: jsonQueryID, @@ -164,7 +157,7 @@ func TestResultValues(t *testing.T) { Cleanversion: result.Cleanversion, Textversion: result.Textversion, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, []*repository.ListQueryRequirementValuesRow{ { Queryid: contextQueryID, @@ -177,11 +170,8 @@ func TestResultValues(t *testing.T) { func TestUnsyncedQueries(t *testing.T) { ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &serviceconfig.BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) - + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ Cfg: cfg, RunMigrations: true, @@ -191,27 +181,27 @@ func TestUnsyncedQueries(t *testing.T) { queries := cfg.DBQueries clientId, err := queries.CreateClient(ctx, "example_client") - assert.Nil(t, err) + assert.NoError(t, err) jobId, err := queries.CreateJob(ctx, clientId) - assert.Nil(t, err) + assert.NoError(t, err) collectorId, err := queries.CreateCollector(ctx, jobId) - assert.Nil(t, err) + assert.NoError(t, err) documentID, err := queries.CreateDocument(ctx, &repository.CreateDocumentParams{ Jobid: jobId, Hash: "example_hash", }) - assert.Nil(t, err) + assert.NoError(t, err) contextQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeContextFull)) - assert.Nil(t, err) + assert.NoError(t, err) jsonQueryID, err := queries.CreateQuery(ctx, repository.Querytype(repository.QuerytypeJsonExtractor)) - assert.Nil(t, err) + assert.NoError(t, err) err = queries.AddRequiredQuery(ctx, &repository.AddRequiredQueryParams{ Queryid: jsonQueryID, Requiredqueryid: contextQueryID, Addedversion: 1, }) - assert.Nil(t, err) + assert.NoError(t, err) err = queries.AddCollectorQuery(ctx, &repository.AddCollectorQueryParams{ Collectorid: collectorId, @@ -219,10 +209,10 @@ func TestUnsyncedQueries(t *testing.T) { Queryid: jsonQueryID, Addedversion: 1, }) - assert.Nil(t, err) + assert.NoError(t, err) qs, err := queries.ListUnsyncedQueriesByDocId(ctx, documentID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Len(t, qs, 2) assert.ElementsMatch(t, []*repository.Fullactivequery{ { @@ -251,10 +241,10 @@ func TestUnsyncedQueries(t *testing.T) { Textversion: 2, Queryversion: 1, }) - assert.Nil(t, err) + assert.NoError(t, err) qs, err = queries.ListUnsyncedQueriesByDocId(ctx, documentID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Len(t, qs, 1) assert.ElementsMatch(t, []*repository.Fullactivequery{ { @@ -272,10 +262,10 @@ func TestUnsyncedQueries(t *testing.T) { Activeversion: 2, ID: contextQueryID, }) - assert.Nil(t, err) + assert.NoError(t, err) qs, err = queries.ListUnsyncedQueriesByDocId(ctx, documentID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Len(t, qs, 2) assert.ElementsMatch(t, []*repository.Fullactivequery{ { @@ -304,7 +294,7 @@ func TestUnsyncedQueries(t *testing.T) { Textversion: 2, Queryversion: 2, }) - assert.Nil(t, err) + assert.NoError(t, err) _, err = queries.SetResult(ctx, &repository.SetResultParams{ Queryid: jsonQueryID, Documentid: documentID, @@ -313,10 +303,10 @@ func TestUnsyncedQueries(t *testing.T) { Textversion: 2, Queryversion: 1, }) - assert.Nil(t, err) + assert.NoError(t, err) qs, err = queries.ListUnsyncedQueriesByDocId(ctx, documentID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Len(t, qs, 0) err = queries.UpdateQuery(ctx, &repository.UpdateQueryParams{ @@ -324,10 +314,10 @@ func TestUnsyncedQueries(t *testing.T) { Activeversion: 2, ID: jsonQueryID, }) - assert.Nil(t, err) + assert.NoError(t, err) qs, err = queries.ListUnsyncedQueriesByDocId(ctx, documentID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Len(t, qs, 1) assert.ElementsMatch(t, []*repository.Fullactivequery{ { @@ -348,10 +338,10 @@ func TestUnsyncedQueries(t *testing.T) { Textversion: 2, Queryversion: 2, }) - assert.Nil(t, err) + assert.NoError(t, err) qs, err = queries.ListUnsyncedQueriesByDocId(ctx, documentID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Len(t, qs, 0) err = queries.UpdateQuery(ctx, &repository.UpdateQueryParams{ @@ -359,10 +349,10 @@ func TestUnsyncedQueries(t *testing.T) { Activeversion: 3, ID: contextQueryID, }) - assert.Nil(t, err) + assert.NoError(t, err) qs, err = queries.ListUnsyncedQueriesByDocId(ctx, documentID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Len(t, qs, 2) assert.ElementsMatch(t, []*repository.Fullactivequery{ { diff --git a/internal/document/clean/service.go b/internal/document/clean/service.go index 3de769fd..aa5cd110 100644 --- a/internal/document/clean/service.go +++ b/internal/document/clean/service.go @@ -1,6 +1,14 @@ package documentclean -import "errors" +import ( + "errors" + + "github.com/google/uuid" +) + +type Create struct { + ID uuid.UUID `json:"id" validate:"required,uuid"` +} type Service struct { } diff --git a/internal/document/create.go b/internal/document/create.go deleted file mode 100644 index 3da75fdc..00000000 --- a/internal/document/create.go +++ /dev/null @@ -1,41 +0,0 @@ -package document - -import ( - "context" - "queryorchestration/internal/database" - "queryorchestration/internal/database/repository" - - "github.com/google/uuid" -) - -type Location = string - -type Create struct { - JobID uuid.UUID - Location Location -} - -func (s *Service) Create(ctx context.Context, doc *Create) (uuid.UUID, error) { - hash, err := s.getHash() - if err != nil { - return uuid.Nil, err - } - - dbid, err := s.cfg.GetDBQueries().CreateDocument(ctx, &repository.CreateDocumentParams{ - Jobid: database.MustToDBUUID(doc.JobID), - Hash: hash, - Location: doc.Location, - }) - if err != nil { - return uuid.Nil, err - } - - id := database.MustToUUID(dbid) - - return id, nil -} - -func (s *Service) getHash() (string, error) { - // TODO - return "example_hash", nil -} diff --git a/internal/document/create_test.go b/internal/document/create_test.go deleted file mode 100644 index dc968643..00000000 --- a/internal/document/create_test.go +++ /dev/null @@ -1,47 +0,0 @@ -package document_test - -import ( - "context" - "queryorchestration/internal/database" - "queryorchestration/internal/database/repository" - "queryorchestration/internal/document" - "queryorchestration/internal/serviceconfig" - "testing" - - "github.com/google/uuid" - "github.com/pashagolub/pgxmock/v3" - "github.com/stretchr/testify/assert" -) - -func TestCreate(t *testing.T) { - ctx := context.Background() - - pool, err := pgxmock.NewPool() - if err != nil { - t.Fatalf("failed to open pgxmock database: %v", err) - } - cfg := &serviceconfig.BaseConfig{} - cfg.DBPool = pool - cfg.DBQueries = repository.New(pool) - - svc := document.New(cfg) - - doc := document.Document{ - ID: uuid.New(), - JobID: uuid.New(), - Location: "example_location", - } - - pool.ExpectQuery("name: CreateDocument :one").WithArgs(database.MustToDBUUID(doc.JobID), pgxmock.AnyArg(), doc.Location). - WillReturnRows( - pgxmock.NewRows([]string{"id"}). - AddRow(database.MustToDBUUID(doc.ID)), - ) - - id, err := svc.Create(ctx, &document.Create{ - JobID: doc.JobID, - Location: doc.Location, - }) - assert.Nil(t, err) - assert.Equal(t, doc.ID, id) -} diff --git a/internal/document/get_test.go b/internal/document/get_test.go index 3998b42a..6b6cf0b2 100644 --- a/internal/document/get_test.go +++ b/internal/document/get_test.go @@ -40,6 +40,6 @@ func TestGet(t *testing.T) { ) adoc, err := svc.Get(ctx, doc.ID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, &doc, adoc) } diff --git a/internal/document/init/create.go b/internal/document/init/create.go new file mode 100644 index 00000000..88c44d97 --- /dev/null +++ b/internal/document/init/create.go @@ -0,0 +1,93 @@ +package documentinit + +import ( + "context" + "queryorchestration/internal/database" + "queryorchestration/internal/database/repository" + "queryorchestration/internal/document" + documentclean "queryorchestration/internal/document/clean" + "queryorchestration/internal/job" + "queryorchestration/internal/server/queue" + + "github.com/aws/aws-sdk-go-v2/service/sqs/types" + "github.com/google/uuid" +) + +type Create struct { + JobID uuid.UUID `json:"jobId" validate:"required,uuid"` + Location document.Location `json:"location" validate:"required"` +} + +func (s *Service) Create(ctx context.Context, doc *Create) (uuid.UUID, error) { + j, err := s.svc.Job.Get(ctx, doc.JobID) + if err != nil { + return uuid.Nil, err + } + + params, err := s.getCreateParams(ctx, doc) + if err != nil { + return uuid.Nil, err + } + + id, err := s.submitCreate(ctx, params) + if err != nil { + return uuid.Nil, err + } + + err = s.informCreate(ctx, id, j) + if err != nil { + return uuid.Nil, err + } + + return id, nil +} + +func (s *Service) getCreateParams(ctx context.Context, doc *Create) (*repository.CreateDocumentParams, error) { + // TODO - get document + + hash, err := s.getHash() + if err != nil { + return nil, err + } + + return &repository.CreateDocumentParams{ + Jobid: database.MustToDBUUID(doc.JobID), + Hash: hash, + Location: doc.Location, + }, nil +} + +func (s *Service) submitCreate(ctx context.Context, params *repository.CreateDocumentParams) (uuid.UUID, error) { + // TODO create - or if hash exists log attempt + dbid, err := s.cfg.GetDBQueries().CreateDocument(ctx, params) + if err != nil { + return uuid.Nil, err + } + + id := database.MustToUUID(dbid) + + return id, nil +} + +func (s *Service) getHash() (string, error) { + // TODO + return "example_hash", nil +} + +func (s *Service) informCreate(ctx context.Context, id uuid.UUID, j *job.Job) error { + if !j.CanSync { + return nil + } + + err := queue.Send(ctx, &queue.Config{ + Client: s.cfg.GetQueueClient(), + URL: s.cfg.GetDocumentCleanURL(), + }, documentclean.Create{ + ID: id, + }, map[string]types.MessageAttributeValue{}) + if err != nil { + return err + } + + return nil +} diff --git a/internal/document/init/create_test.go b/internal/document/init/create_test.go new file mode 100644 index 00000000..3ccda88d --- /dev/null +++ b/internal/document/init/create_test.go @@ -0,0 +1,106 @@ +package documentinit + +import ( + "context" + "fmt" + "queryorchestration/internal/client" + "queryorchestration/internal/database" + "queryorchestration/internal/database/repository" + "queryorchestration/internal/document" + "queryorchestration/internal/job" + "queryorchestration/internal/serviceconfig" + "queryorchestration/internal/serviceconfig/queue/documentclean" + queuemock "queryorchestration/mocks/queue" + "testing" + + "github.com/aws/aws-sdk-go-v2/service/sqs" + "github.com/google/uuid" + "github.com/pashagolub/pgxmock/v3" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" +) + +type DocInitConfig struct { + serviceconfig.BaseConfig + documentclean.DocCleanConfig +} + +func TestCreate(t *testing.T) { + ctx := context.Background() + + pool, err := pgxmock.NewPool() + if err != nil { + t.Fatalf("failed to open pgxmock database: %v", err) + } + cfg := &DocInitConfig{} + cfg.DBPool = pool + cfg.DBQueries = repository.New(pool) + + svc := New(cfg, &Services{ + Job: job.New(cfg, &job.Services{ + Client: client.New(cfg), + }), + }) + + j := job.Job{ + ID: uuid.New(), + ClientID: uuid.New(), + } + doc := document.Document{ + ID: uuid.New(), + JobID: j.ID, + Location: "example_location", + } + + pool.ExpectQuery("name: GetJob :one").WithArgs(database.MustToDBUUID(j.ID)).WillReturnRows( + pgxmock.NewRows([]string{"id", "clientId", "canSync"}). + AddRow(database.MustToDBUUID(j.ID), database.MustToDBUUID(j.ClientID), j.CanSync), + ) + pool.ExpectQuery("-- name: GetClient :one").WithArgs(database.MustToDBUUID(j.ClientID)).WillReturnRows( + pgxmock.NewRows([]string{"id", "name", "canSync"}). + AddRow(database.MustToDBUUID(j.ClientID), "client_name", true), + ) + pool.ExpectQuery("name: CreateDocument :one").WithArgs(database.MustToDBUUID(doc.JobID), pgxmock.AnyArg(), doc.Location). + WillReturnRows( + pgxmock.NewRows([]string{"id"}). + AddRow(database.MustToDBUUID(doc.ID)), + ) + + id, err := svc.Create(ctx, &Create{ + JobID: doc.JobID, + Location: doc.Location, + }) + assert.NoError(t, err) + assert.Equal(t, doc.ID, id) +} + +func TestInformCreate(t *testing.T) { + ctx := context.Background() + mockSQS := queuemock.NewMockSQSClient(t) + + cfg := &DocInitConfig{} + cfg.QueueClient = mockSQS + cfg.DocumentCleanURL = "/i/am/here" + svc := Service{ + cfg: cfg, + } + id := uuid.New() + j := &job.Job{} + + err := svc.informCreate(ctx, id, j) + assert.NoError(t, err) + + mockSQS.EXPECT(). + SendMessage( + mock.Anything, + mock.MatchedBy(func(in *sqs.SendMessageInput) bool { + return *in.QueueUrl == cfg.DocumentCleanURL && *in.MessageBody == fmt.Sprintf("{\"id\":\"%s\"}", id) + }), + mock.Anything, + ). + Return(&sqs.SendMessageOutput{}, nil) + + j.CanSync = true + err = svc.informCreate(ctx, id, j) + assert.NoError(t, err) +} diff --git a/internal/document/init/service.go b/internal/document/init/service.go new file mode 100644 index 00000000..cb62ad90 --- /dev/null +++ b/internal/document/init/service.go @@ -0,0 +1,28 @@ +package documentinit + +import ( + "queryorchestration/internal/job" + "queryorchestration/internal/serviceconfig" + "queryorchestration/internal/serviceconfig/queue/documentclean" +) + +type Services struct { + Job *job.Service +} + +type ConfigProvider interface { + serviceconfig.ConfigProvider + documentclean.ConfigProvider +} + +type Service struct { + cfg ConfigProvider + svc *Services +} + +func New(cfg ConfigProvider, svc *Services) *Service { + return &Service{ + cfg, + svc, + } +} diff --git a/internal/document/init/service_test.go b/internal/document/init/service_test.go new file mode 100644 index 00000000..1cb80b7f --- /dev/null +++ b/internal/document/init/service_test.go @@ -0,0 +1,13 @@ +package documentinit_test + +import ( + "queryorchestration/internal/document" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestNew(t *testing.T) { + svc := document.New(nil) + assert.NotNil(t, svc) +} diff --git a/internal/document/service.go b/internal/document/service.go index b65870f7..19d1b07e 100644 --- a/internal/document/service.go +++ b/internal/document/service.go @@ -6,6 +6,8 @@ import ( "github.com/google/uuid" ) +type Location = string + type Document struct { ID uuid.UUID JobID uuid.UUID diff --git a/internal/job/collector/create_test.go b/internal/job/collector/create_test.go index 29026402..c20cd63f 100644 --- a/internal/job/collector/create_test.go +++ b/internal/job/collector/create_test.go @@ -55,6 +55,6 @@ func TestCreate(t *testing.T) { pool.ExpectCommit() aid, err := svc.Create(ctx, &create) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, id, aid) } diff --git a/internal/job/collector/createprivate_test.go b/internal/job/collector/createprivate_test.go index e16ac8be..09994cf6 100644 --- a/internal/job/collector/createprivate_test.go +++ b/internal/job/collector/createprivate_test.go @@ -47,7 +47,7 @@ func TestGetCreateParams(t *testing.T) { ) dbparams, err := svc.getCreateParams(ctx, ¶ms) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &dbCreateParams{ JobID: database.MustToDBUUID(params.JobID), MinCleanVersion: &minCleanV, @@ -103,6 +103,6 @@ func TestSubmitCreate(t *testing.T) { pool.ExpectCommit() aid, err := svc.submitCreate(ctx, ¶ms) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, id, aid) } diff --git a/internal/job/collector/get_test.go b/internal/job/collector/get_test.go index 2434ae47..36152163 100644 --- a/internal/job/collector/get_test.go +++ b/internal/job/collector/get_test.go @@ -46,7 +46,7 @@ func TestGet(t *testing.T) { ) coll, err := svc.Get(ctx, ogc.ID) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, ogc, *coll) } @@ -82,6 +82,6 @@ func TestGetByJobID(t *testing.T) { ) coll, err := svc.GetByJobID(ctx, ogc.JobID) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, ogc, *coll) } diff --git a/internal/job/collector/parse_test.go b/internal/job/collector/parse_test.go index 0fbd18e3..bb8632c8 100644 --- a/internal/job/collector/parse_test.go +++ b/internal/job/collector/parse_test.go @@ -12,7 +12,7 @@ import ( func TestParseDBCollector(t *testing.T) { c, err := parseDBCollector(nil) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, c) minCleanV := int32(1) @@ -33,7 +33,7 @@ func TestParseDBCollector(t *testing.T) { Mintextversion: ogc.MinTextVersion, Fields: []byte(fmt.Sprintf("{\"example_key\":\"%s\"}", ogc.Fields["example_key"])), }) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, ogc, *c) ogc.MinCleanVersion = 0 @@ -43,6 +43,6 @@ func TestParseDBCollector(t *testing.T) { Jobid: database.MustToDBUUID(ogc.JobID), Fields: []byte(fmt.Sprintf("{\"example_key\":\"%s\"}", ogc.Fields["example_key"])), }) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, ogc, *c) } diff --git a/internal/job/collector/update_test.go b/internal/job/collector/update_test.go index b010f204..b4ef5b13 100644 --- a/internal/job/collector/update_test.go +++ b/internal/job/collector/update_test.go @@ -55,5 +55,5 @@ func TestUpdate(t *testing.T) { pool.ExpectCommit() err = svc.UpdateByJobId(ctx, &update) - assert.Nil(t, err) + assert.NoError(t, err) } diff --git a/internal/job/collector/updateprivate_test.go b/internal/job/collector/updateprivate_test.go index c9717ee1..5b799455 100644 --- a/internal/job/collector/updateprivate_test.go +++ b/internal/job/collector/updateprivate_test.go @@ -55,7 +55,7 @@ func TestGetUpdateParams(t *testing.T) { ) dbparams, err := svc.getUpdateParams(ctx, ¤t, ¶ms) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &dbUpdateParams{ JobID: database.MustToDBUUID(params.JobID), ActiveVersion: &aV, @@ -142,7 +142,7 @@ func TestSubmitUpdate(t *testing.T) { pool.ExpectCommit() err = svc.submitUpdate(ctx, ¤t, ¶ms) - assert.Nil(t, err) + assert.NoError(t, err) } func TestNormalizeFieldsToDB(t *testing.T) { @@ -171,7 +171,7 @@ func TestNormalizeFieldsToDB(t *testing.T) { ) dbparams, err := svc.normalizeFieldsToDB(ctx, &fields) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &map[string]pgtype.UUID{ "example_key": database.MustToDBUUID(fields["example_key"]), }, dbparams) @@ -199,17 +199,17 @@ func TestNormalizeActiveVersion(t *testing.T) { } err = svc.normalizeActiveVersion(¤t, nil) - assert.Nil(t, err) + assert.NoError(t, err) update := UpdateParams{} err = svc.normalizeActiveVersion(¤t, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, update.ActiveVersion) update.ActiveVersion = ¤t.ActiveVersion err = svc.normalizeActiveVersion(¤t, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, update.ActiveVersion) av := current.LatestVersion + 2 @@ -220,7 +220,7 @@ func TestNormalizeActiveVersion(t *testing.T) { av = current.ActiveVersion + 1 update.ActiveVersion = &av err = svc.normalizeActiveVersion(¤t, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, av, *update.ActiveVersion) } @@ -238,12 +238,12 @@ func TestNormalizeCodeVersions(t *testing.T) { current := Collector{} err = svc.normalizeCodeVersions(¤t, nil) - assert.Nil(t, err) + assert.NoError(t, err) update := UpdateParams{} err = svc.normalizeCodeVersions(¤t, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, update.MinCleanVersion) assert.Nil(t, update.MinTextVersion) @@ -251,7 +251,7 @@ func TestNormalizeCodeVersions(t *testing.T) { update.MinCleanVersion = &cv update.MinTextVersion = nil err = svc.normalizeCodeVersions(¤t, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, cv, *update.MinCleanVersion) assert.Equal(t, int32(0), *update.MinTextVersion) @@ -259,35 +259,35 @@ func TestNormalizeCodeVersions(t *testing.T) { tv := int32(2) update.MinTextVersion = &tv err = svc.normalizeCodeVersions(¤t, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, int32(0), *update.MinCleanVersion) assert.Equal(t, tv, *update.MinTextVersion) current.MinCleanVersion = 2 current.MinTextVersion = 2 err = svc.normalizeCodeVersions(¤t, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, update.MinCleanVersion) assert.Nil(t, update.MinTextVersion) update.MinCleanVersion = ¤t.MinCleanVersion update.MinTextVersion = nil err = svc.normalizeCodeVersions(¤t, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, update.MinCleanVersion) assert.Nil(t, update.MinTextVersion) update.MinCleanVersion = nil update.MinTextVersion = ¤t.MinTextVersion err = svc.normalizeCodeVersions(¤t, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, update.MinCleanVersion) assert.Nil(t, update.MinTextVersion) update.MinCleanVersion = ¤t.MinCleanVersion update.MinTextVersion = ¤t.MinTextVersion err = svc.normalizeCodeVersions(¤t, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, update.MinCleanVersion) assert.Nil(t, update.MinTextVersion) @@ -295,7 +295,7 @@ func TestNormalizeCodeVersions(t *testing.T) { update.MinCleanVersion = &cv update.MinTextVersion = ¤t.MinTextVersion err = svc.normalizeCodeVersions(¤t, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, cv, *update.MinCleanVersion) assert.Equal(t, current.MinTextVersion, *update.MinTextVersion) @@ -304,7 +304,7 @@ func TestNormalizeCodeVersions(t *testing.T) { tv = current.MinTextVersion + 1 update.MinTextVersion = &tv err = svc.normalizeCodeVersions(¤t, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, cv, *update.MinCleanVersion) assert.Equal(t, tv, *update.MinTextVersion) } diff --git a/internal/job/create_test.go b/internal/job/create_test.go index 0ee05bc0..a18ee0cc 100644 --- a/internal/job/create_test.go +++ b/internal/job/create_test.go @@ -47,6 +47,6 @@ func TestCreate(t *testing.T) { pool.ExpectCommit() aid, err := svc.Create(ctx, job.ClientID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, job.ID, aid) } diff --git a/internal/job/get_test.go b/internal/job/get_test.go index 57d8f849..f7327922 100644 --- a/internal/job/get_test.go +++ b/internal/job/get_test.go @@ -48,7 +48,7 @@ func TestGet(t *testing.T) { ) ajob, err := svc.Get(ctx, j.ID) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &job.Job{ ID: j.ID, ClientID: j.ClientID, @@ -66,7 +66,7 @@ func TestGet(t *testing.T) { ) ajob, err = svc.Get(ctx, j.ID) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &job.Job{ ID: j.ID, ClientID: j.ClientID, diff --git a/internal/job/update_test.go b/internal/job/update_test.go index bd909780..6e54200b 100644 --- a/internal/job/update_test.go +++ b/internal/job/update_test.go @@ -55,5 +55,5 @@ func TestUpdate(t *testing.T) { pool.ExpectCommit() err = svc.Update(ctx, u) - assert.Nil(t, err) + assert.NoError(t, err) } diff --git a/internal/job/updateprivate_test.go b/internal/job/updateprivate_test.go index 16ebe93c..aa37a86e 100644 --- a/internal/job/updateprivate_test.go +++ b/internal/job/updateprivate_test.go @@ -39,13 +39,13 @@ func TestNormalizeCanSync(t *testing.T) { } err = svc.normalizeCanSync(ctx, &j, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, update.CanSync) cs := false update.CanSync = &cs err = svc.normalizeCanSync(ctx, &j, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, update.CanSync) pool.ExpectQuery("name: GetClient :one").WithArgs(database.MustToDBUUID(j.ClientID)). @@ -68,7 +68,7 @@ func TestNormalizeCanSync(t *testing.T) { cs = false update.CanSync = &cs err = svc.normalizeCanSync(ctx, &j, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, update.CanSync) pool.ExpectQuery("name: GetClient :one").WithArgs(database.MustToDBUUID(j.ClientID)). @@ -80,14 +80,14 @@ func TestNormalizeCanSync(t *testing.T) { cs = true update.CanSync = &cs err = svc.normalizeCanSync(ctx, &j, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.True(t, *update.CanSync) j.CanSync = true cs = true update.CanSync = &cs err = svc.normalizeCanSync(ctx, &j, &update) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, update.CanSync) } @@ -119,7 +119,7 @@ func TestNormalizeUpdate(t *testing.T) { } err = svc.normalizeUpdate(ctx, &j, &update) - assert.Nil(t, err) + assert.NoError(t, err) ucs = !ucs assert.EqualExportedValues(t, Update{ID: update.ID, CanSync: &ucs}, update) } @@ -150,7 +150,7 @@ func TestSubmitUpdate(t *testing.T) { pool.ExpectCommit() err = svc.submitUpdate(ctx, u) - assert.Nil(t, err) + assert.NoError(t, err) ucs := true u = &Update{ @@ -164,5 +164,5 @@ func TestSubmitUpdate(t *testing.T) { pool.ExpectCommit() err = svc.submitUpdate(ctx, u) - assert.Nil(t, err) + assert.NoError(t, err) } diff --git a/internal/query/create_test.go b/internal/query/create_test.go index 58c8ade3..a4c1e2d8 100644 --- a/internal/query/create_test.go +++ b/internal/query/create_test.go @@ -44,7 +44,7 @@ func TestCreate(t *testing.T) { } dbType, err := resultprocessor.ToDBQueryType(create.Type) - assert.Nil(t, err) + assert.NoError(t, err) pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(database.MustToDBUUIDArray(*create.RequiredQueryIDs)).WillReturnRows( pgxmock.NewRows([]string{"all_exist"}).AddRow(true), @@ -64,7 +64,7 @@ func TestCreate(t *testing.T) { pool.ExpectCommit() id, err := svc.Create(ctx, create) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, q.ID, id) } @@ -89,7 +89,7 @@ func TestCreateMinimal(t *testing.T) { } dbType, err := resultprocessor.ToDBQueryType(create.Type) - assert.Nil(t, err) + assert.NoError(t, err) pool.ExpectBeginTx(pgx.TxOptions{}) pool.ExpectQuery("name: CreateQuery :one").WithArgs(dbType).WillReturnRows( @@ -99,7 +99,7 @@ func TestCreateMinimal(t *testing.T) { pool.ExpectCommit() id, err := svc.Create(ctx, create) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, q.ID, id) } @@ -120,7 +120,7 @@ func TestCreateRollback(t *testing.T) { } dbType, err := resultprocessor.ToDBQueryType(create.Type) - assert.Nil(t, err) + assert.NoError(t, err) pool.ExpectBeginTx(pgx.TxOptions{}) msg := "database failure" diff --git a/internal/query/createprivate_test.go b/internal/query/createprivate_test.go index 7e6f216b..488ae522 100644 --- a/internal/query/createprivate_test.go +++ b/internal/query/createprivate_test.go @@ -26,17 +26,17 @@ func TestGetCreator(t *testing.T) { queryType := resultprocessor.Type(resultprocessor.TypeContextFull) creator, err := svc.getCreator(queryType) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, creator) queryType = resultprocessor.Type(resultprocessor.TypeJsonExtractor) creator, err = svc.getCreator(queryType) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, creator) queryType = resultprocessor.Type(-1) _, err = svc.getCreator(queryType) - assert.NotNil(t, err) + assert.Error(t, err) } func TestParseCreateQuery(t *testing.T) { @@ -50,7 +50,7 @@ func TestParseCreateQuery(t *testing.T) { } resultQuery, err := parseCreateQuery(cQuery) - assert.Nil(t, err) + assert.NoError(t, err) rQIDs := database.MustToDBUUIDArray(*cQuery.RequiredQueryIDs) qcfg := []byte(*cQuery.Config) assert.EqualExportedValues(t, createQuery{ @@ -102,7 +102,7 @@ func TestSubmitCreate(t *testing.T) { } dbType, err := resultprocessor.ToDBQueryType(create.Type) - assert.Nil(t, err) + assert.NoError(t, err) pool.ExpectBeginTx(pgx.TxOptions{}) pool.ExpectQuery("name: CreateQuery :one").WithArgs(dbType).WillReturnRows( @@ -118,7 +118,7 @@ func TestSubmitCreate(t *testing.T) { pool.ExpectCommit() id, err := svc.submitCreate(ctx, create) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, q.ID, id) } @@ -143,7 +143,7 @@ func TestSubmitCreateNoReqsOrConfig(t *testing.T) { } dbType, err := resultprocessor.ToDBQueryType(create.Type) - assert.Nil(t, err) + assert.NoError(t, err) pool.ExpectBeginTx(pgx.TxOptions{}) pool.ExpectQuery("name: CreateQuery :one").WithArgs(dbType).WillReturnRows( @@ -153,7 +153,7 @@ func TestSubmitCreateNoReqsOrConfig(t *testing.T) { pool.ExpectCommit() id, err := svc.submitCreate(ctx, create) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, q.ID, id) } @@ -182,7 +182,7 @@ func TestNormalizeCreate(t *testing.T) { ) err = svc.normalizeCreate(ctx, create) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, resultprocessor.Create{ Type: resultprocessor.TypeJsonExtractor, Config: nil, diff --git a/internal/query/get_test.go b/internal/query/get_test.go index 36980b02..49e3e53d 100644 --- a/internal/query/get_test.go +++ b/internal/query/get_test.go @@ -46,7 +46,7 @@ func TestGet(t *testing.T) { ) returnQuery, err := svc.Get(ctx, query.ID) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, query, *returnQuery) } @@ -85,7 +85,7 @@ func TestGetWithVersion(t *testing.T) { ) returnQuery, err := svc.GetWithVersion(ctx, query.ID, version) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, query, *returnQuery) } diff --git a/internal/query/list_test.go b/internal/query/list_test.go index 21fa9f05..b2cb434e 100644 --- a/internal/query/list_test.go +++ b/internal/query/list_test.go @@ -47,7 +47,7 @@ func TestList(t *testing.T) { ) resList, err := svc.List(ctx) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, []*query.Query{q}, resList) } @@ -84,7 +84,7 @@ func TestListById(t *testing.T) { ) resList, err := svc.ListById(ctx, []uuid.UUID{q.ID}) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, []*query.Query{q}, resList) } diff --git a/internal/query/normalize_test.go b/internal/query/normalize_test.go index 002d0a73..2a6f7081 100644 --- a/internal/query/normalize_test.go +++ b/internal/query/normalize_test.go @@ -18,43 +18,43 @@ func TestNormalizeConfig(t *testing.T) { s := Service{} err := s.normalizeConfig(nil) - assert.Nil(t, err) + assert.NoError(t, err) entity := resultprocessor.Create{} entity.Config = nil err = s.normalizeConfig(&entity) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, entity.Config) cfg := "" entity.Config = &cfg err = s.normalizeConfig(&entity) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, entity.Config) cfg = " " entity.Config = &cfg err = s.normalizeConfig(&entity) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, entity.Config) cfg = "{}" entity.Config = &cfg err = s.normalizeConfig(&entity) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, "{}", *(entity.Config)) cfg = "{\"hello\":\"bye\"}" entity.Config = &cfg err = s.normalizeConfig(&entity) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, "{\"hello\":\"bye\"}", *(entity.Config)) cfg = " { \"hello\" : \"bye\" } " entity.Config = &cfg err = s.normalizeConfig(&entity) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, "{\"hello\":\"bye\"}", *(entity.Config)) cfg = "{'hello':'bye'}" @@ -81,18 +81,18 @@ func TestNormalizeQueryIDs(t *testing.T) { s := Service{cfg: cfg} err = s.NormalizeQueryIDs(ctx, nil) - assert.Nil(t, err) + assert.NoError(t, err) entity := resultprocessor.Create{} entity.RequiredQueryIDs = nil err = s.NormalizeQueryIDs(ctx, &entity) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, entity.RequiredQueryIDs) entity.RequiredQueryIDs = &[]uuid.UUID{} err = s.NormalizeQueryIDs(ctx, &entity) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, entity.RequiredQueryIDs) ids := []uuid.UUID{uuid.New()} @@ -105,7 +105,7 @@ func TestNormalizeQueryIDs(t *testing.T) { ) err = s.NormalizeQueryIDs(ctx, &entity) - assert.Nil(t, err) + assert.NoError(t, err) assert.ElementsMatch(t, ids, *entity.RequiredQueryIDs) pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).WillReturnRows( @@ -135,7 +135,7 @@ func TestNormalizeQueryIDs(t *testing.T) { ) err = s.NormalizeQueryIDs(ctx, &entity) - assert.Nil(t, err) + assert.NoError(t, err) assert.ElementsMatch(t, outids, *entity.RequiredQueryIDs) } @@ -155,20 +155,20 @@ func TestNormalizeActiveVersion(t *testing.T) { assert.Error(t, err) err = s.normalizeActiveVersion(¤t, nil) - assert.Nil(t, err) + assert.NoError(t, err) err = s.normalizeActiveVersion(¤t, &entity) - assert.Nil(t, err) + assert.NoError(t, err) entity.ActiveVersion = ¤t.ActiveVersion err = s.normalizeActiveVersion(¤t, &entity) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, entity.ActiveVersion) aV := current.ActiveVersion + 1 entity.ActiveVersion = &aV err = s.normalizeActiveVersion(¤t, &entity) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, aV, *entity.ActiveVersion) aV = current.LatestVersion + 2 diff --git a/internal/query/parse_test.go b/internal/query/parse_test.go index b8afcf46..72518fea 100644 --- a/internal/query/parse_test.go +++ b/internal/query/parse_test.go @@ -48,7 +48,7 @@ func TestParseFullActiveQuery(t *testing.T) { } out, err := query.ParseFullActiveQuery(q) - assert.Nil(t, err) + assert.NoError(t, err) bcfg := string(q.Config) assert.EqualExportedValues(t, query.Query{ ID: database.MustToUUID(q.ID), @@ -71,7 +71,7 @@ func TestFullActiveQueryEmpty(t *testing.T) { } out, err := query.ParseFullActiveQuery(dbQuery) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, query.Query{ ID: database.MustToUUID(dbQuery.ID), Type: resultprocessor.TypeContextFull, @@ -89,7 +89,7 @@ func TestFullActiveQueryWithNullUUID(t *testing.T) { } out, err := query.ParseFullActiveQuery(dbQuery) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, query.Query{ ID: database.MustToUUID(dbQuery.ID), Type: resultprocessor.TypeContextFull, @@ -109,7 +109,7 @@ func TestFullActiveQueryArray(t *testing.T) { } out, err := query.ParseFullActiveQueryArray(dbQueries) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, []*query.Query{ { ID: database.MustToUUID(dbQueries[0].ID), diff --git a/internal/query/result/get_test.go b/internal/query/result/get_test.go index 980528dc..a32b34f7 100644 --- a/internal/query/result/get_test.go +++ b/internal/query/result/get_test.go @@ -19,11 +19,11 @@ func TestGetValueByType(t *testing.T) { _, err := getValueByType(resultprocessor.Type(-1), "example_val") assert.Error(t, err) pro, err := getValueByType(resultprocessor.TypeContextFull, "example_context") - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, pro) assert.Equal(t, "example_context", pro.GetStoreValue()) pro, err = getValueByType(resultprocessor.TypeJsonExtractor, "example_json") - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, pro) assert.Equal(t, "example_json", pro.GetStoreValue()) } @@ -57,7 +57,7 @@ func TestGetValueWithVersion(t *testing.T) { ) val, err := svc.GetValueWithVersion(ctx, params) - assert.Nil(t, err) + assert.NoError(t, err) v := jsonextractor.NewResult("example_value") assert.Equal(t, v, val) assert.Equal(t, "example_value", v.GetStoreValue()) diff --git a/internal/query/result/list_test.go b/internal/query/result/list_test.go index 964efe51..10408b72 100644 --- a/internal/query/result/list_test.go +++ b/internal/query/result/list_test.go @@ -44,7 +44,7 @@ func TestListQueryRequirementValues(t *testing.T) { ) val, err := svc.ListQueryRequirementValues(ctx, params) - assert.Nil(t, err) + assert.NoError(t, err) assert.ElementsMatch(t, []resultprocessor.Value{ jsonextractor.NewResult("example_value"), }, *val) @@ -60,7 +60,7 @@ func TestParseQueryRequirementValueArray(t *testing.T) { } out, err := parseQueryRequirementValueArray(in) - assert.Nil(t, err) + assert.NoError(t, err) assert.ElementsMatch(t, []resultprocessor.Value{ jsonextractor.NewResult("example_value"), }, *out) diff --git a/internal/query/result/process_test.go b/internal/query/result/process_test.go index ad9fb5ae..ae78a676 100644 --- a/internal/query/result/process_test.go +++ b/internal/query/result/process_test.go @@ -56,7 +56,7 @@ func TestProcess(t *testing.T) { ) val, err := svc.Process(ctx, ¶ms) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, val) assert.Equal(t, "example_value", val.GetStoreValue()) } @@ -77,17 +77,17 @@ func TestListRequiredValue(t *testing.T) { } pr, err := svc.listRequiredValues(ctx, nil) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, pr) pr, err = svc.listRequiredValues(ctx, &Process{}) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, pr) pr, err = svc.listRequiredValues(ctx, &Process{ Query: &resultprocessor.Query{}, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, pr) pr, err = svc.listRequiredValues(ctx, &Process{ @@ -95,7 +95,7 @@ func TestListRequiredValue(t *testing.T) { RequiredQueryIDs: &[]uuid.UUID{}, }, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, pr) params := Process{ @@ -118,7 +118,7 @@ func TestListRequiredValue(t *testing.T) { ) pr, err = svc.listRequiredValues(ctx, ¶ms) - assert.Nil(t, err) + assert.NoError(t, err) assert.ElementsMatch(t, []resultprocessor.Value{ jsonextractor.NewResult("example_value"), }, *pr) @@ -128,11 +128,11 @@ func TestGetProcessor(t *testing.T) { svc := Service{} pr, err := svc.getProcessor(resultprocessor.TypeJsonExtractor) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, pr) pr, err = svc.getProcessor(resultprocessor.TypeContextFull) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, pr) _, err = svc.getProcessor(resultprocessor.Type(-1)) diff --git a/internal/query/result/processor/parse_test.go b/internal/query/result/processor/parse_test.go index 0e9495aa..250ab49b 100644 --- a/internal/query/result/processor/parse_test.go +++ b/internal/query/result/processor/parse_test.go @@ -20,7 +20,7 @@ func TestParseDBCollectorQuery(t *testing.T) { Queryversion: 1, } value, err := resultprocessor.ParseDBCollectorQuery(&dbResult) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, uuid.Nil, value.ID) assert.Nil(t, value.RequiredQueryIDs) assert.Equal(t, int32(1), value.Version) @@ -34,7 +34,7 @@ func TestParseDBCollectorQuery(t *testing.T) { func TestParseDBNullType(t *testing.T) { qType := repository.NullQuerytype{Valid: true, Querytype: repository.QuerytypeJsonExtractor} value, err := resultprocessor.ParseDBNullType(qType) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, resultprocessor.Type(resultprocessor.TypeJsonExtractor), value) qType = repository.NullQuerytype{} @@ -49,19 +49,19 @@ func TestParseDBNullType(t *testing.T) { func TestParseDBType(t *testing.T) { qType := repository.QuerytypeJsonExtractor value, err := resultprocessor.ParseDBType(qType) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, resultprocessor.Type(resultprocessor.TypeJsonExtractor), value) qType = repository.QuerytypeContextFull value, err = resultprocessor.ParseDBType(qType) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, resultprocessor.Type(resultprocessor.TypeContextFull), value) } func TestToDBQueryType(t *testing.T) { dbQueryType := resultprocessor.Type(resultprocessor.TypeJsonExtractor) value, err := resultprocessor.ToDBQueryType(dbQueryType) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, repository.Querytype(repository.QuerytypeJsonExtractor), value) dbQueryType = resultprocessor.Type(-1) @@ -70,7 +70,7 @@ func TestToDBQueryType(t *testing.T) { dbQueryType = resultprocessor.Type(resultprocessor.TypeContextFull) value, err = resultprocessor.ToDBQueryType(dbQueryType) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, repository.Querytype(repository.QuerytypeContextFull), value) } @@ -80,7 +80,7 @@ func TestToDBQueryTypeArray(t *testing.T) { resultprocessor.TypeContextFull, } value, err := resultprocessor.ToDBQueryTypeArray(inArr) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, []repository.Querytype{ repository.QuerytypeJsonExtractor, repository.QuerytypeContextFull, @@ -96,7 +96,7 @@ func TestToDBQueryTypeArray(t *testing.T) { func TestToDBNullQueryType(t *testing.T) { dbQueryType := resultprocessor.Type(resultprocessor.TypeJsonExtractor) value, err := resultprocessor.ToDBNullQueryType(dbQueryType) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, repository.NullQuerytype{Valid: true, Querytype: repository.QuerytypeJsonExtractor}, value) dbQueryType = resultprocessor.Type(-1) @@ -105,14 +105,14 @@ func TestToDBNullQueryType(t *testing.T) { dbQueryType = resultprocessor.Type(resultprocessor.TypeContextFull) value, err = resultprocessor.ToDBNullQueryType(dbQueryType) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, repository.NullQuerytype{Valid: true, Querytype: repository.QuerytypeContextFull}, value) } func TestParseFullQuery(t *testing.T) { var q *repository.Fullactivequery out, err := resultprocessor.ParseFullQuery(q) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, out) q = &repository.Fullactivequery{ @@ -123,7 +123,7 @@ func TestParseFullQuery(t *testing.T) { } out, err = resultprocessor.ParseFullQuery(q) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &resultprocessor.Query{ ID: database.MustToUUID(q.ID), Type: resultprocessor.TypeContextFull, @@ -139,7 +139,7 @@ func TestParseFullQuery(t *testing.T) { } out, err = resultprocessor.ParseFullQuery(q) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, &resultprocessor.Query{ ID: database.MustToUUID(q.ID), Type: resultprocessor.TypeContextFull, @@ -158,7 +158,7 @@ func TestParseFullQuery(t *testing.T) { } out, err = resultprocessor.ParseFullQuery(q) - assert.Nil(t, err) + assert.NoError(t, err) cfg := "hello" assert.EqualExportedValues(t, &resultprocessor.Query{ ID: database.MustToUUID(q.ID), @@ -172,7 +172,7 @@ func TestParseFullQuery(t *testing.T) { func TestParseFullQueryArray(t *testing.T) { var q []*repository.Fullactivequery out, err := resultprocessor.ParseFullQueryArray(q) - assert.Nil(t, err) + assert.NoError(t, err) assert.ElementsMatch(t, []*resultprocessor.Query{}, out) q = []*repository.Fullactivequery{ @@ -185,7 +185,7 @@ func TestParseFullQueryArray(t *testing.T) { } out, err = resultprocessor.ParseFullQueryArray(q) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, []*resultprocessor.Query{ { ID: database.MustToUUID(q[0].ID), diff --git a/internal/query/result/set_test.go b/internal/query/result/set_test.go index e278af50..9f8ce5ba 100644 --- a/internal/query/result/set_test.go +++ b/internal/query/result/set_test.go @@ -61,6 +61,6 @@ func TestSet(t *testing.T) { ) id, err := svc.Set(ctx, ¶ms) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, rid, id) } diff --git a/internal/query/result/sync_test.go b/internal/query/result/sync_test.go index 204c29f8..f668ae0d 100644 --- a/internal/query/result/sync_test.go +++ b/internal/query/result/sync_test.go @@ -43,6 +43,6 @@ func TestListUnsyncedQueriesByDocId(t *testing.T) { ) val, err := svc.ListUnsyncedQueriesByDocId(ctx, documentId) - assert.Nil(t, err) + assert.NoError(t, err) assert.ElementsMatch(t, actualQs, val) } diff --git a/internal/query/test_test.go b/internal/query/test_test.go index 8748b3e8..a55b63f4 100644 --- a/internal/query/test_test.go +++ b/internal/query/test_test.go @@ -85,6 +85,6 @@ func TestTest(t *testing.T) { ) result, err := svc.Test(ctx, *params) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, "old_value", result) } diff --git a/internal/query/types/contextFull/creator_test.go b/internal/query/types/contextFull/creator_test.go index da4fbeb6..35b0adcf 100644 --- a/internal/query/types/contextFull/creator_test.go +++ b/internal/query/types/contextFull/creator_test.go @@ -31,5 +31,5 @@ func TestCreatorValidate(t *testing.T) { } err = svc.Validate(ctx, entity) - assert.Nil(t, err) + assert.NoError(t, err) } diff --git a/internal/query/types/contextFull/process_test.go b/internal/query/types/contextFull/process_test.go index fb0583f1..6873b322 100644 --- a/internal/query/types/contextFull/process_test.go +++ b/internal/query/types/contextFull/process_test.go @@ -24,7 +24,7 @@ func TestContextFull(t *testing.T) { values := []resultprocessor.Value{} value, err := extractor.Process(ctx, query, &values) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, "", value) values = []resultprocessor.Value{ diff --git a/internal/query/types/contextFull/updator_test.go b/internal/query/types/contextFull/updator_test.go index bd5f09a4..6d59a6c1 100644 --- a/internal/query/types/contextFull/updator_test.go +++ b/internal/query/types/contextFull/updator_test.go @@ -38,5 +38,5 @@ func TestUpdatorValidate(t *testing.T) { } err = svc.Validate(ctx, current, entity) - assert.Nil(t, err) + assert.NoError(t, err) } diff --git a/internal/query/types/jsonExtractor/creator_test.go b/internal/query/types/jsonExtractor/creator_test.go index 5bc55f0a..140bb0d0 100644 --- a/internal/query/types/jsonExtractor/creator_test.go +++ b/internal/query/types/jsonExtractor/creator_test.go @@ -31,5 +31,5 @@ func TestCreatorValidate(t *testing.T) { } err = svc.Validate(ctx, entity) - assert.Nil(t, err) + assert.NoError(t, err) } diff --git a/internal/query/types/jsonExtractor/process_test.go b/internal/query/types/jsonExtractor/process_test.go index 7dbb0ebd..cd971904 100644 --- a/internal/query/types/jsonExtractor/process_test.go +++ b/internal/query/types/jsonExtractor/process_test.go @@ -51,7 +51,7 @@ func TestJSONProcess(t *testing.T) { ) value, err := extractor.Process(ctx, query, &values) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, entryValue, value) entryValue = "" @@ -66,7 +66,7 @@ func TestJSONProcess(t *testing.T) { ) value, err = extractor.Process(ctx, query, &values) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, entryValue, value) entryValue = "1" @@ -81,7 +81,7 @@ func TestJSONProcess(t *testing.T) { ) value, err = extractor.Process(ctx, query, &values) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, entryValue, value) } diff --git a/internal/query/types/jsonExtractor/updator_test.go b/internal/query/types/jsonExtractor/updator_test.go index f61d99b1..e3154b44 100644 --- a/internal/query/types/jsonExtractor/updator_test.go +++ b/internal/query/types/jsonExtractor/updator_test.go @@ -38,5 +38,5 @@ func TestUpdatorValidate(t *testing.T) { } err = svc.Validate(ctx, current, entity) - assert.Nil(t, err) + assert.NoError(t, err) } diff --git a/internal/query/updateprivate_test.go b/internal/query/updateprivate_test.go index 1f40e589..a0e9fd61 100644 --- a/internal/query/updateprivate_test.go +++ b/internal/query/updateprivate_test.go @@ -27,17 +27,17 @@ func TestGetUpdator(t *testing.T) { queryType := resultprocessor.Type(resultprocessor.TypeContextFull) updator, err := svc.getUpdator(queryType) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, updator) queryType = resultprocessor.Type(resultprocessor.TypeJsonExtractor) updator, err = svc.getUpdator(queryType) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, updator) queryType = resultprocessor.Type(-1) _, err = svc.getUpdator(queryType) - assert.NotNil(t, err) + assert.Error(t, err) } func TestSubmitUpdate(t *testing.T) { @@ -86,7 +86,7 @@ func TestSubmitUpdate(t *testing.T) { pool.ExpectCommit() err = svc.submitUpdate(ctx, &q, update) - assert.Nil(t, err) + assert.NoError(t, err) } func TestSubmitUpdateRollback(t *testing.T) { @@ -169,7 +169,7 @@ func TestSubmitUpdateRequiredQueries(t *testing.T) { pool.ExpectCommit() err = svc.submitUpdate(ctx, &q, update) - assert.Nil(t, err) + assert.NoError(t, err) } func TestSubmitUpdateActiveVersion(t *testing.T) { @@ -201,7 +201,7 @@ func TestSubmitUpdateActiveVersion(t *testing.T) { pool.ExpectCommit() err = svc.submitUpdate(ctx, &q, update) - assert.Nil(t, err) + assert.NoError(t, err) } func TestGetSetDifference(t *testing.T) { @@ -252,7 +252,7 @@ func TestNormalizeUpdate(t *testing.T) { ) err = svc.normalizeUpdate(ctx, current, update) - assert.Nil(t, err) + assert.NoError(t, err) assert.EqualExportedValues(t, resultprocessor.Update{ ID: current.ID, ActiveVersion: &aV, diff --git a/internal/server/otel/service.go b/internal/server/otel/service.go index ddb562d6..0a284787 100644 --- a/internal/server/otel/service.go +++ b/internal/server/otel/service.go @@ -3,14 +3,14 @@ package otel import ( "context" "log/slog" - "queryorchestration/internal/serviceconfig" + "queryorchestration/internal/serviceconfig/observability" "go.opentelemetry.io/otel" "go.opentelemetry.io/otel/exporters/otlp/otlptrace/otlptracegrpc" sdktrace "go.opentelemetry.io/otel/sdk/trace" ) -func New(ctx context.Context, cfg serviceconfig.ObservabilityConfigProvider) func() error { +func New(ctx context.Context, cfg observability.ConfigProvider) func() error { if !cfg.IsOtelEnabled() { slog.Warn("OpenTelemetry is disabled. Set ENABLE_OTEL to true to enable.") return func() error { return nil } diff --git a/internal/server/otel/service_test.go b/internal/server/otel/service_test.go index 26d8266b..aa904512 100644 --- a/internal/server/otel/service_test.go +++ b/internal/server/otel/service_test.go @@ -4,7 +4,7 @@ import ( "context" "fmt" "queryorchestration/internal/server/otel" - "queryorchestration/internal/serviceconfig" + "queryorchestration/internal/serviceconfig/observability" "testing" "github.com/stretchr/testify/assert" @@ -13,7 +13,7 @@ import ( func TestNew(t *testing.T) { ctx := context.Background() - cfg := &serviceconfig.ObservabilityConfig{ + cfg := &observability.ObsConfig{ EnableOtel: true, } clean := otel.New(ctx, cfg) diff --git a/internal/server/queue/client.go b/internal/server/queue/client.go new file mode 100644 index 00000000..0f5b8023 --- /dev/null +++ b/internal/server/queue/client.go @@ -0,0 +1,40 @@ +package queue + +import ( + "context" + + "github.com/aws/aws-sdk-go-v2/service/sqs" +) + +type SQSClient interface { + // Message Operations + SendMessage(ctx context.Context, params *sqs.SendMessageInput, optFns ...func(*sqs.Options)) (*sqs.SendMessageOutput, error) + SendMessageBatch(ctx context.Context, params *sqs.SendMessageBatchInput, optFns ...func(*sqs.Options)) (*sqs.SendMessageBatchOutput, error) + ReceiveMessage(ctx context.Context, params *sqs.ReceiveMessageInput, optFns ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error) + DeleteMessage(ctx context.Context, params *sqs.DeleteMessageInput, optFns ...func(*sqs.Options)) (*sqs.DeleteMessageOutput, error) + DeleteMessageBatch(ctx context.Context, params *sqs.DeleteMessageBatchInput, optFns ...func(*sqs.Options)) (*sqs.DeleteMessageBatchOutput, error) + ChangeMessageVisibility(ctx context.Context, params *sqs.ChangeMessageVisibilityInput, optFns ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityOutput, error) + ChangeMessageVisibilityBatch(ctx context.Context, params *sqs.ChangeMessageVisibilityBatchInput, optFns ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityBatchOutput, error) + + // Queue Operations + CreateQueue(ctx context.Context, params *sqs.CreateQueueInput, optFns ...func(*sqs.Options)) (*sqs.CreateQueueOutput, error) + DeleteQueue(ctx context.Context, params *sqs.DeleteQueueInput, optFns ...func(*sqs.Options)) (*sqs.DeleteQueueOutput, error) + GetQueueUrl(ctx context.Context, params *sqs.GetQueueUrlInput, optFns ...func(*sqs.Options)) (*sqs.GetQueueUrlOutput, error) + ListQueues(ctx context.Context, params *sqs.ListQueuesInput, optFns ...func(*sqs.Options)) (*sqs.ListQueuesOutput, error) + + // Queue Attributes + GetQueueAttributes(ctx context.Context, params *sqs.GetQueueAttributesInput, optFns ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error) + SetQueueAttributes(ctx context.Context, params *sqs.SetQueueAttributesInput, optFns ...func(*sqs.Options)) (*sqs.SetQueueAttributesOutput, error) + + // Tags + ListQueueTags(ctx context.Context, params *sqs.ListQueueTagsInput, optFns ...func(*sqs.Options)) (*sqs.ListQueueTagsOutput, error) + TagQueue(ctx context.Context, params *sqs.TagQueueInput, optFns ...func(*sqs.Options)) (*sqs.TagQueueOutput, error) + UntagQueue(ctx context.Context, params *sqs.UntagQueueInput, optFns ...func(*sqs.Options)) (*sqs.UntagQueueOutput, error) + + // Dead Letter Queue + AddPermission(ctx context.Context, params *sqs.AddPermissionInput, optFns ...func(*sqs.Options)) (*sqs.AddPermissionOutput, error) + RemovePermission(ctx context.Context, params *sqs.RemovePermissionInput, optFns ...func(*sqs.Options)) (*sqs.RemovePermissionOutput, error) + + // FIFO Queue + PurgeQueue(ctx context.Context, params *sqs.PurgeQueueInput, optFns ...func(*sqs.Options)) (*sqs.PurgeQueueOutput, error) +} diff --git a/internal/server/queue/config.go b/internal/server/queue/config.go index fb1aa7e5..e629cfb6 100644 --- a/internal/server/queue/config.go +++ b/internal/server/queue/config.go @@ -1,10 +1,6 @@ package queue -import ( - "github.com/aws/aws-sdk-go-v2/service/sqs" -) - type Config struct { URL string - Client *sqs.Client + Client SQSClient } diff --git a/internal/server/queue/delete_test.go b/internal/server/queue/delete_test.go index 0fa7b365..38215d94 100644 --- a/internal/server/queue/delete_test.go +++ b/internal/server/queue/delete_test.go @@ -3,31 +3,38 @@ package queue_test import ( "context" "queryorchestration/internal/server/queue" - "queryorchestration/internal/test" + queuemock "queryorchestration/mocks/queue" "testing" + "github.com/aws/aws-sdk-go-v2/service/sqs" "github.com/aws/aws-sdk-go-v2/service/sqs/types" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" ) func TestDelete(t *testing.T) { - if testing.Short() { - t.Skip("Skipping long test in short mode") - } ctx := context.Background() - queueConfig, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{}) - defer cleanup() - + mockSQS := queuemock.NewMockSQSClient(t) cfg := &queue.Config{ - URL: queueConfig.URL, - Client: queueConfig.Client, + URL: "/i/am/here", + Client: mockSQS, + } + handle := "iamahandler" + + mockSQS.EXPECT(). + DeleteMessage( + mock.Anything, + mock.MatchedBy(func(in *sqs.DeleteMessageInput) bool { + return *in.QueueUrl == cfg.URL && *in.ReceiptHandle == handle + }), + mock.Anything, + ). + Return(&sqs.DeleteMessageOutput{}, nil) + + message := &types.Message{ + ReceiptHandle: &handle, } - err := queue.Send(ctx, cfg, "{}", map[string]types.MessageAttributeValue{}) - assert.Nil(t, err) - - message := test.AssertMessageWait(t, ctx, cfg, []string{}) - - err = queue.Delete(ctx, cfg, &message) - assert.Nil(t, err) + err := queue.Delete(ctx, cfg, message) + assert.NoError(t, err) } diff --git a/internal/server/queue/receive_test.go b/internal/server/queue/receive_test.go index d0450645..452ba2f3 100644 --- a/internal/server/queue/receive_test.go +++ b/internal/server/queue/receive_test.go @@ -3,35 +3,36 @@ package queue_test import ( "context" "queryorchestration/internal/server/queue" - "queryorchestration/internal/test" + queuemock "queryorchestration/mocks/queue" "testing" + "github.com/aws/aws-sdk-go-v2/service/sqs" "github.com/aws/aws-sdk-go-v2/service/sqs/types" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" ) func TestReceive(t *testing.T) { - if testing.Short() { - t.Skip("Skipping long test in short mode") - } ctx := context.Background() - queueConfig, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{}) - defer cleanup() + mockSQS := queuemock.NewMockSQSClient(t) cfg := &queue.Config{ - URL: queueConfig.URL, - Client: queueConfig.Client, + URL: "/i/am/here", + Client: mockSQS, } - attributes := map[string]types.MessageAttributeValue{} + res := sqs.ReceiveMessageOutput{Messages: []types.Message{}} - err := queue.Send(ctx, cfg, "example_body", attributes) - assert.Nil(t, err) + mockSQS.EXPECT(). + ReceiveMessage( + mock.Anything, + mock.MatchedBy(func(in *sqs.ReceiveMessageInput) bool { + return *in.QueueUrl == cfg.URL + }), + mock.Anything, + ). + Return(&res, nil) - result, err := queue.Receive(ctx, cfg, []string{}) - assert.Nil(t, err) - - assert.Len(t, result.Messages, 1) - message := result.Messages[0] - - assert.Equal(t, "\"example_body\"", *message.Body) + ares, err := queue.Receive(ctx, cfg, []string{}) + assert.NoError(t, err) + assert.EqualExportedValues(t, res, *ares) } diff --git a/internal/server/queue/send_test.go b/internal/server/queue/send_test.go index e4ff3666..20c6661d 100644 --- a/internal/server/queue/send_test.go +++ b/internal/server/queue/send_test.go @@ -3,25 +3,36 @@ package queue_test import ( "context" "queryorchestration/internal/server/queue" - "queryorchestration/internal/test" + queuemock "queryorchestration/mocks/queue" "testing" + "github.com/aws/aws-sdk-go-v2/service/sqs" "github.com/aws/aws-sdk-go-v2/service/sqs/types" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" ) func TestSend(t *testing.T) { - if testing.Short() { - t.Skip("Skipping long test in short mode") - } ctx := context.Background() - queueConfig, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{}) - defer cleanup() + mockSQS := queuemock.NewMockSQSClient(t) cfg := &queue.Config{ - URL: queueConfig.URL, - Client: queueConfig.Client, + URL: "/i/am/here", + Client: mockSQS, } - err := queue.Send(ctx, cfg, "{}", map[string]types.MessageAttributeValue{}) - assert.Nil(t, err) + mockSQS.EXPECT(). + SendMessage( + mock.Anything, + mock.MatchedBy(func(in *sqs.SendMessageInput) bool { + return *in.QueueUrl == cfg.URL && *in.MessageBody == "{}" + }), + mock.Anything, + ). + Return(&sqs.SendMessageOutput{}, nil) + + body := struct{}{} + attrs := map[string]types.MessageAttributeValue{} + + err := queue.Send(ctx, cfg, body, attrs) + assert.NoError(t, err) } diff --git a/internal/server/runner/listener.go b/internal/server/runner/listener.go index 84f5f96c..e7d9d939 100644 --- a/internal/server/runner/listener.go +++ b/internal/server/runner/listener.go @@ -2,12 +2,10 @@ package runner import ( "context" - "fmt" + "errors" "queryorchestration/internal/server" "queryorchestration/internal/serviceconfig/aws" - "github.com/aws/aws-sdk-go-v2/config" - "github.com/aws/aws-sdk-go-v2/service/sqs" "github.com/aws/aws-sdk-go-v2/service/sqs/types" ) @@ -18,43 +16,66 @@ type Controller interface { type ListenerConfig interface { server.Config aws.ConfigProvider - RegisterController() Controller + RegisterController() error + GetController() Controller GetQueueURL() string + PingQueue(context.Context) error } type BaseConfig struct { server.BaseConfig - aws.AWSConfig ControllerFunc func() Controller + Controller Controller QueueURL string `env:"QUEUE_URL,required,notEmpty"` } -func (c *BaseConfig) RegisterController() Controller { - return c.ControllerFunc() +func (c *BaseConfig) RegisterController() error { + if c.ControllerFunc == nil { + return errors.New("controllerFunc required") + } + + c.Controller = c.ControllerFunc() + + return nil } + func (c *BaseConfig) GetQueueURL() string { return c.QueueURL } +func (c *BaseConfig) GetController() Controller { + return c.Controller +} + +func (c *BaseConfig) PingQueue(ctx context.Context) error { + return c.PingQueueByURL(ctx, c.QueueURL) +} + func New(ctx context.Context, cfg ListenerConfig) (*Server, error) { cleanup, err := server.New(ctx, cfg) if err != nil { - return nil, fmt.Errorf("unable run server.New: %v", err) + return nil, err } - qcfg, err := config.LoadDefaultConfig(ctx) + err = cfg.SetQueueClient(ctx) if err != nil { - return nil, fmt.Errorf("unable to load SDK config: %v", err) + return nil, err } - sqsClient := sqs.NewFromConfig(qcfg) + err = cfg.PingQueue(ctx) + if err != nil { + return nil, err + } - controller := cfg.RegisterController() + err = cfg.RegisterController() + if err != nil { + return nil, err + } return &Server{ - controller: controller, + controller: cfg.GetController(), queueURL: cfg.GetQueueURL(), - client: sqsClient, + client: cfg.GetQueueClient(), cleanup: cleanup, }, nil } diff --git a/internal/server/runner/listener_test.go b/internal/server/runner/listener_test.go index ea0c21cc..c57afaa6 100644 --- a/internal/server/runner/listener_test.go +++ b/internal/server/runner/listener_test.go @@ -1,52 +1,51 @@ -package runner_test +package runner import ( "context" "os" "path" - "queryorchestration/internal/server/runner" - "queryorchestration/internal/serviceconfig" + "queryorchestration/internal/server" "queryorchestration/internal/test" + queuemock "queryorchestration/mocks/queue" + runnermock "queryorchestration/mocks/runner" "testing" "time" - "github.com/aws/aws-sdk-go-v2/service/sqs/types" + "github.com/aws/aws-sdk-go-v2/service/sqs" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" ) -type MockController struct{} - -func (s *MockController) Process(ctx context.Context, req *types.Message) error { - return nil -} - func TestNew(t *testing.T) { if testing.Short() { t.Skip("Skipping long test in short mode") } ctx := context.Background() - t.Setenv("QUEUE_URL", "example_url") - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &runner.BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) - - _, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{}) - defer cleanup() - _, cleanup = test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ - Cfg: cfg, - RunMigrations: true, + sccfg := test.CreateBaseConfig() + sccfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") + cfg := &BaseConfig{ + BaseConfig: server.BaseConfig{ + BaseConfig: *sccfg, + }, + } + qcleanup := test.CreateQueueClient(t, ctx, &test.CreateQueueConfig{ + Cfg: &cfg.BaseConfig.BaseConfig, + }) + defer qcleanup() + _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ + Cfg: cfg, }) defer cleanup() - ctx, cancel := context.WithTimeout(ctx, time.Second) + ctx, cancel := context.WithTimeout(ctx, 10*time.Second) defer cancel() - cfg.ControllerFunc = func() runner.Controller { - return &MockController{} + cfg.ControllerFunc = func() Controller { + return runnermock.NewMockController(t) } + cfg.QueueURL = test.CreateQueue(t, ctx, &cfg.BaseConfig.BaseConfig, "queueName") - srvPtr, err := runner.New(ctx, cfg) + srvPtr, err := New(ctx, cfg) assert.NotNil(t, srvPtr) assert.NoError(t, err) } @@ -54,7 +53,58 @@ func TestNew(t *testing.T) { func TestListen(t *testing.T) { ctx := context.Background() - queue := runner.Server{} + queue := Server{} assert.Panics(t, func() { queue.Listen(ctx) }) } + +func TestRegisterController(t *testing.T) { + c := BaseConfig{} + err := c.RegisterController() + assert.Error(t, err) + assert.Nil(t, c.Controller) + + c.ControllerFunc = func() Controller { + return runnermock.NewMockController(t) + } + err = c.RegisterController() + assert.NoError(t, err) + assert.Equal(t, runnermock.NewMockController(t), c.Controller) +} + +func TestPingQueue(t *testing.T) { + ctx := context.Background() + c := BaseConfig{} + c.QueueURL = "i/am/here" + mockSQS := queuemock.NewMockSQSClient(t) + c.QueueClient = mockSQS + + mockSQS.EXPECT(). + GetQueueAttributes( + mock.Anything, + mock.MatchedBy(func(in *sqs.GetQueueAttributesInput) bool { + return *in.QueueUrl == c.QueueURL + }), + mock.Anything, + ). + Return(&sqs.GetQueueAttributesOutput{}, nil) + + err := c.PingQueue(ctx) + assert.NoError(t, err) +} + +func TestGetQueueURL(t *testing.T) { + c := BaseConfig{} + assert.Empty(t, c.GetQueueURL()) + + c.QueueURL = "exampleurl" + assert.Equal(t, "exampleurl", c.GetQueueURL()) +} + +func TestGetController(t *testing.T) { + c := BaseConfig{} + assert.Empty(t, c.GetController()) + + c.Controller = runnermock.NewMockController(t) + assert.Equal(t, runnermock.NewMockController(t), c.GetController()) +} diff --git a/internal/server/runner/poll.go b/internal/server/runner/poll.go index fe6fa187..2046d0ec 100644 --- a/internal/server/runner/poll.go +++ b/internal/server/runner/poll.go @@ -5,14 +5,12 @@ import ( "fmt" "log/slog" "queryorchestration/internal/server/queue" - - "github.com/aws/aws-sdk-go-v2/service/sqs" ) type Server struct { controller Controller queueURL string - client *sqs.Client + client queue.SQSClient cleanup func() error } @@ -69,9 +67,7 @@ func (c *Server) pollMessage(ctx context.Context) error { URL: c.queueURL, Client: c.client, } - result, err := queue.Receive(ctx, cfg, []string{ - "type", - }) + result, err := queue.Receive(ctx, cfg, []string{}) if err != nil { return fmt.Errorf("message fetch fail: %v", err) } diff --git a/internal/server/runner/poll_test.go b/internal/server/runner/poll_test.go index 8b3dbd5f..89c1e610 100644 --- a/internal/server/runner/poll_test.go +++ b/internal/server/runner/poll_test.go @@ -2,57 +2,75 @@ package runner import ( "context" - "queryorchestration/internal/test" + "queryorchestration/internal/server/queue" + queuemock "queryorchestration/mocks/queue" + runnermock "queryorchestration/mocks/runner" "testing" "time" + "github.com/aws/aws-sdk-go-v2/service/sqs" "github.com/aws/aws-sdk-go-v2/service/sqs/types" "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" ) -type MockController struct{} - -func (s *MockController) Process(ctx context.Context, req *types.Message) error { - return nil -} - func TestPollMessages(t *testing.T) { - if testing.Short() { - t.Skip("Skipping long test in short mode") - } ctx := context.Background() - queueConfig, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{}) - defer cleanup() - controller := MockController{} + controller := runnermock.NewMockController(t) + mockSQS := queuemock.NewMockSQSClient(t) + cfg := &queue.Config{ + URL: "/i/am/here", + Client: mockSQS, + } + + res := sqs.ReceiveMessageOutput{Messages: []types.Message{}} + + mockSQS.EXPECT(). + ReceiveMessage( + mock.Anything, + mock.MatchedBy(func(in *sqs.ReceiveMessageInput) bool { + return *in.QueueUrl == cfg.URL + }), + mock.Anything, + ). + Return(&res, nil) ctx, cancel := context.WithTimeout(ctx, time.Second) defer cancel() - cfg := &Server{ - controller: &controller, - queueURL: queueConfig.URL, - client: queueConfig.Client, + scfg := &Server{ + controller: controller, + queueURL: cfg.URL, + client: cfg.Client, cleanup: func() error { return nil }, } - cfg.Listen(ctx) + scfg.Listen(ctx) } func TestPollMessage(t *testing.T) { - if testing.Short() { - t.Skip("Skipping long test in short mode") - } ctx := context.Background() - queueConfig, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{}) - defer cleanup() - controller := MockController{} + controller := runnermock.NewMockController(t) + mockSQS := queuemock.NewMockSQSClient(t) cfg := &Server{ - controller: &controller, - queueURL: queueConfig.URL, - client: queueConfig.Client, + controller: controller, + queueURL: "/i/am/here", + client: mockSQS, + cleanup: func() error { return nil }, } + + mockSQS.EXPECT(). + ReceiveMessage( + mock.Anything, + mock.MatchedBy(func(in *sqs.ReceiveMessageInput) bool { + return *in.QueueUrl == cfg.queueURL + }), + mock.Anything, + ). + Return(&sqs.ReceiveMessageOutput{}, nil) + err := cfg.pollMessage(ctx) - assert.Nil(t, err) + assert.NoError(t, err) } diff --git a/internal/server/server.go b/internal/server/server.go index 26486476..8a35b12d 100644 --- a/internal/server/server.go +++ b/internal/server/server.go @@ -34,14 +34,14 @@ func New(ctx context.Context, cfg Config) (func() error, error) { err := migrations.Run(ctx, cfg) if err != nil { - return nil, err + return func() error { return nil }, err } cfg.SetValidator() err = cfg.SetDBPool(ctx) if err != nil { - return nil, err + return func() error { return nil }, err } return closeTracer, nil diff --git a/internal/server/server_test.go b/internal/server/server_test.go index b9415116..31a08625 100644 --- a/internal/server/server_test.go +++ b/internal/server/server_test.go @@ -18,8 +18,11 @@ func TestNew(t *testing.T) { } ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../..")) - cfg := &server.BaseConfig{} + sccfg := test.CreateBaseConfig() + sccfg.BasePath = path.Join(os.Getenv("PWD"), "../..") + cfg := &server.BaseConfig{ + BaseConfig: *sccfg, + } _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ Cfg: cfg, diff --git a/internal/server/service/listener.go b/internal/server/service/listener.go index 84a999fd..3f931acb 100644 --- a/internal/server/service/listener.go +++ b/internal/server/service/listener.go @@ -2,6 +2,7 @@ package service import ( "context" + "errors" "log/slog" "net" "net/http" @@ -37,10 +38,15 @@ func (c *BaseConfig) GetRouter() *echo.Echo { return c.Router } func (c *BaseConfig) RegisterHandlers() (*openapi3.T, error) { + if c.RegisterHandlersFunc == nil { + return nil, errors.New("registerHandlersFunc required") + } + o, err := c.RegisterHandlersFunc() if err != nil { return nil, err } + c.OpenAPI = o return c.OpenAPI, nil } diff --git a/internal/server/service/listener_test.go b/internal/server/service/listener_test.go index f4d1623e..24f83c40 100644 --- a/internal/server/service/listener_test.go +++ b/internal/server/service/listener_test.go @@ -4,12 +4,14 @@ import ( "context" "os" "path" + "queryorchestration/internal/server" "queryorchestration/internal/serviceconfig" "queryorchestration/internal/test" "testing" "github.com/getkin/kin-openapi/openapi3" + "github.com/labstack/echo/v4" "github.com/stretchr/testify/assert" ) @@ -19,13 +21,15 @@ func TestNew(t *testing.T) { } ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &BaseConfig{} - err := serviceconfig.InitializeConfig(cfg) - assert.Nil(t, err) + sccfg := test.CreateBaseConfig() + sccfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") + cfg := &BaseConfig{ + BaseConfig: server.BaseConfig{ + BaseConfig: *sccfg, + }, + } _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ - Cfg: cfg, - RunMigrations: true, + Cfg: cfg, }) defer cleanup() @@ -48,3 +52,36 @@ func TestListen(t *testing.T) { assert.Panics(t, func() { server.Listen() }) } + +func TestRegisterHandlers(t *testing.T) { + c := BaseConfig{} + _, err := c.RegisterHandlers() + assert.Error(t, err) + + c.RegisterHandlersFunc = func() (*openapi3.T, error) { + return &openapi3.T{}, nil + } + op, err := c.RegisterHandlers() + assert.NoError(t, err) + assert.Equal(t, &openapi3.T{}, op) + assert.Equal(t, op, c.OpenAPI) +} + +func TestSetRouter(t *testing.T) { + c := BaseConfig{} + assert.Nil(t, c.Router) + c.SetRouter(&echo.Echo{}) + assert.Equal(t, &echo.Echo{}, c.Router) +} + +func TestGetRouter(t *testing.T) { + c := BaseConfig{} + r := c.GetRouter() + assert.Nil(t, r) + assert.Equal(t, r, c.Router) + + c.Router = &echo.Echo{} + r = c.GetRouter() + assert.Equal(t, &echo.Echo{}, r) + assert.Equal(t, r, c.Router) +} diff --git a/internal/server/validation/validation_test.go b/internal/server/validation/validation_test.go index f36799a7..a3302232 100644 --- a/internal/server/validation/validation_test.go +++ b/internal/server/validation/validation_test.go @@ -29,17 +29,17 @@ func TestDeduplicateArray(t *testing.T) { func TestNormalizeInClosedInterval(t *testing.T) { err := validation.NormalizeInClosedInterval(nil, 1, 1, 1) - assert.Nil(t, err) + assert.NoError(t, err) var param *int32 err = validation.NormalizeInClosedInterval(¶m, 1, 1, 1) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, param) updated := int32(1) param = &updated err = validation.NormalizeInClosedInterval(¶m, 1, 1, 1) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, int32(1), updated) updated = -1 @@ -55,6 +55,6 @@ func TestNormalizeInClosedInterval(t *testing.T) { updated = 2 param = &updated err = validation.NormalizeInClosedInterval(¶m, 1, 1, 3) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, int32(2), updated) } diff --git a/internal/serviceconfig/aws/config.go b/internal/serviceconfig/aws/config.go index d3d9d3a0..a8ff91d0 100644 --- a/internal/serviceconfig/aws/config.go +++ b/internal/serviceconfig/aws/config.go @@ -1,8 +1,10 @@ package aws type AWSConfig struct { - AWSClientID string `env:"AWS_CLIENT_ID"` // AWS client identifier - AWSSecretKey string `env:"AWS_SECRET_KEY"` // AWS secret access key + AWSKeyID string `env:"AWS_ACCESS_KEY_ID,required,notEmpty"` + AWSSecretKey string `env:"AWS_SECRET_ACCESS_KEY,required,notEmpty"` + AWSRegion string `env:"AWS_REGION,required,notEmpty"` + AWSSessionToken string `env:"AWS_SESSION_TOKEN"` } type ConfigProvider interface{} diff --git a/internal/serviceconfig/common.go b/internal/serviceconfig/common.go index db5adf10..9ae995c0 100644 --- a/internal/serviceconfig/common.go +++ b/internal/serviceconfig/common.go @@ -2,12 +2,14 @@ package serviceconfig import ( "errors" - "fmt" "log/slog" "os" + "queryorchestration/internal/serviceconfig/aws" "queryorchestration/internal/serviceconfig/database" + "queryorchestration/internal/serviceconfig/logger" + "queryorchestration/internal/serviceconfig/observability" + "queryorchestration/internal/serviceconfig/queue" "reflect" - "strings" "github.com/caarlos0/env/v11" "github.com/joho/godotenv" @@ -17,29 +19,15 @@ import ( // ------------ // Logging -type LoggerConfig struct { - Logger *slog.Logger -} - -// Observability -type ObservabilityConfig struct { - EnableOtel bool `env:"ENABLE_OTEL" envDefault:"false"` -} - -type ObservabilityConfigProvider interface { - IsOtelEnabled() bool -} - -func (o *ObservabilityConfig) IsOtelEnabled() bool { - return o.EnableOtel -} // BaseConfig provides common configuration fields and functionality // that can be embedded in service-specific configs. type BaseConfig struct { - LoggerConfig - ObservabilityConfig - database.BaseConfig + logger.LogConfig + observability.ObsConfig + database.DBConfig + aws.AWSConfig + queue.QueueConfig // miscellaneous fields uncategorized // PWD will replace the BASE_PATH env var @@ -55,10 +43,12 @@ type BaseConfig struct { // Implementations must provide logging capabilities and configuration display. type ConfigProvider interface { database.ConfigProvider - ObservabilityConfigProvider + observability.ConfigProvider + logger.ConfigProvider + aws.ConfigProvider + queue.ConfigProvider GetBasePath() string - GetLogger() *slog.Logger - LogConfig(prefixSecret string) + SetDBConfig(*database.DBConfig) } // Configuration Methods @@ -133,76 +123,6 @@ func (b *BaseConfig) GetBasePath() string { return b.Pwd } -func (b *BaseConfig) GetLogger() *slog.Logger { - return b.Logger -} - -// Logging Methods -// -------------- - -// LogConfig displays the current configuration values, masking sensitive -// information based on the provided prefixSecret. It implements the -// ConfigProvider interface. -func (b *BaseConfig) LogConfig(prefixSecret string) { - b.logConfigRecursive(reflect.ValueOf(b), "", prefixSecret, make(map[reflect.Value]bool)) -} - -// logConfigRecursive is a helper method that recursively traverses the configuration -// structure and logs each field's value. It handles nested structs, pointers, -// and masks sensitive values containing the specified prefixSecret in their names. -func (b *BaseConfig) logConfigRecursive(val reflect.Value, prefix string, prefixSecret string, visited map[reflect.Value]bool) { - // Handle pointer dereference - if val.Kind() == reflect.Ptr { - val = val.Elem() - } - - // Prevent infinite recursion - if visited[val] { - return - } - visited[val] = true - - typ := val.Type() - - for i := 0; i < val.NumField(); i++ { - field := val.Field(i) - fieldType := typ.Field(i) - - // Skip unexported fields - if !fieldType.IsExported() { - continue - } - - fieldName := fieldType.Name - fullPath := prefix + fieldName - - // Handle embedded fields - if fieldType.Anonymous { - b.logConfigRecursive(field, prefix, prefixSecret, visited) - continue - } - - switch field.Kind() { - case reflect.Struct: - b.logConfigRecursive(field, fullPath+".", prefixSecret, visited) - default: - var valueStr string - if field.Kind() == reflect.String { - valueStr = field.String() - } else { - valueStr = fmt.Sprintf("%v", field.Interface()) - } - - // Mask sensitive values - if strings.Contains(strings.ToLower(fieldName), strings.ToLower(prefixSecret)) { - if len(valueStr) > 5 { - valueStr = valueStr[:5] + "..." - } - } - - b.Logger.Info("Config value", - "key", fullPath, - "value", valueStr) - } - } +func (b *BaseConfig) SetDBConfig(cfg *database.DBConfig) { + b.DBConfig = *cfg } diff --git a/internal/serviceconfig/common_test.go b/internal/serviceconfig/common_test.go index ec927404..6acd40b7 100644 --- a/internal/serviceconfig/common_test.go +++ b/internal/serviceconfig/common_test.go @@ -1,9 +1,8 @@ package serviceconfig import ( - "log/slog" "os" - "reflect" + "queryorchestration/internal/serviceconfig/database" "strings" "testing" @@ -27,33 +26,39 @@ func TestInitializeConfig(t *testing.T) { { name: "valid configuration", envVars: map[string]string{ - "APP_ENV": "testing", - "BOOL_TEST": "true", - "INT_TEST": "42", - "DB_USER": "postgres", - "DB_PASS": "pass", - "DB_HOST": "localhost", - "DB_PORT": "5432", - "DB_NAME": "query_orchestration", - "DB_NOSSL": "true", - "SUB_FIELD1:": "value1", - "SUB_FIELD2": "42", - "PWD": "/foo", + "APP_ENV": "testing", + "BOOL_TEST": "true", + "INT_TEST": "42", + "DB_USER": "postgres", + "DB_PASS": "pass", + "DB_HOST": "localhost", + "DB_PORT": "5432", + "DB_NAME": "query_orchestration", + "DB_NOSSL": "true", + "AWS_ACCESS_KEY_ID": "key", + "AWS_SECRET_ACCESS_KEY": "secret", + "AWS_REGION": "region", + "SUB_FIELD1:": "value1", + "SUB_FIELD2": "42", + "PWD": "/foo", }, wantErr: false, }, { name: "missing required env var", envVars: map[string]string{ - "APP_ENV": "testing", - "BOOL_TEST": "true", - "DB_USER": "postgres", - "DB_PASS": "pass", - "DB_HOST": "localhost", - "DB_PORT": "5432", - "DB_NAME": "query_orchestration", - "DB_NOSSL": "true", - "PWD": "/foo", + "APP_ENV": "testing", + "BOOL_TEST": "true", + "DB_USER": "postgres", + "DB_PASS": "pass", + "DB_HOST": "localhost", + "DB_PORT": "5432", + "DB_NAME": "query_orchestration", + "DB_NOSSL": "true", + "AWS_ACCESS_KEY_ID": "key", + "AWS_SECRET_ACCESS_KEY": "secret", + "AWS_REGION": "region", + "PWD": "/foo", // INT_TEST intentionally omitted }, wantErr: true, @@ -145,29 +150,11 @@ func TestGetBasePath(t *testing.T) { assert.Equal(t, "base_path", cfg.GetBasePath()) } -func TestGetLogger(t *testing.T) { +func TestSetDBConfig(t *testing.T) { cfg := &BaseConfig{} - assert.Nil(t, cfg.GetLogger()) - cfg.Logger = slog.Default() - assert.NotNil(t, cfg.GetLogger()) -} - -func TestLogConfig(t *testing.T) { - cfg := &BaseConfig{} - tl := &testLogger{T: t} - cfg.Logger = slog.New(tl) - cfg.LogConfig("") - assert.Len(t, tl.Logs, 14) - assert.Equal(t, "Logger", tl.Logs[0]["key"]) -} - -func TestLogConfigRecursive(t *testing.T) { - cfg := &BaseConfig{} - tl := &testLogger{T: t} - cfg.Logger = slog.New(tl) - v := struct{ Example string }{Example: "examplestring"} - cfg.logConfigRecursive(reflect.ValueOf(v), "", "", make(map[reflect.Value]bool)) - assert.Len(t, tl.Logs, 1) - assert.Equal(t, "Example", tl.Logs[0]["key"]) - assert.Equal(t, "examp...", tl.Logs[0]["value"]) + dbcfg := database.DBConfig{ + DBUser: "user", + } + cfg.SetDBConfig(&dbcfg) + assert.Equal(t, dbcfg, cfg.DBConfig) } diff --git a/internal/serviceconfig/database/config.go b/internal/serviceconfig/database/config.go index 4033a9c9..7db55c32 100644 --- a/internal/serviceconfig/database/config.go +++ b/internal/serviceconfig/database/config.go @@ -8,7 +8,7 @@ import ( "github.com/jackc/pgx/v5/pgxpool" ) -type BaseConfig struct { +type DBConfig struct { DBUser string `env:"DB_USER,required,notEmpty"` DBSecret string `env:"DB_PASS,required,notEmpty"` DBHost string `env:"DB_HOST,required,notEmpty"` @@ -35,7 +35,7 @@ type ConfigProvider interface { ExecuteDBTransaction(context.Context, func(context.Context, *repository.Queries) error) error } -func (b *BaseConfig) GetDBOpts() map[string]string { +func (b *DBConfig) GetDBOpts() map[string]string { opts := make(map[string]string) if b.DBNoSSL { @@ -45,7 +45,7 @@ func (b *BaseConfig) GetDBOpts() map[string]string { return opts } -func (b *BaseConfig) GetDBOptsString() string { +func (b *DBConfig) GetDBOptsString() string { str := "" opts := b.GetDBOpts() isFirst := true @@ -61,18 +61,18 @@ func (b *BaseConfig) GetDBOptsString() string { return str } -func (b *BaseConfig) GetDBDriver() string { +func (b *DBConfig) GetDBDriver() string { return "postgres" } -func (b *BaseConfig) GetDBBaseURI() string { +func (b *DBConfig) GetDBBaseURI() string { return fmt.Sprintf("%s://%s:%s@%s:%d/", b.GetDBDriver(), b.DBUser, b.DBSecret, b.DBHost, b.DBPort) } -func (b *BaseConfig) GetDBName() string { +func (b *DBConfig) GetDBName() string { return b.DBName } -func (b *BaseConfig) GetDBURI() string { +func (b *DBConfig) GetDBURI() string { return fmt.Sprintf("%s%s?%s", b.GetDBBaseURI(), b.DBName, b.GetDBOptsString()) } diff --git a/internal/serviceconfig/database/config_test.go b/internal/serviceconfig/database/config_test.go index ec41dca2..0a69f496 100644 --- a/internal/serviceconfig/database/config_test.go +++ b/internal/serviceconfig/database/config_test.go @@ -8,7 +8,7 @@ import ( ) func TestGetDBOpts(t *testing.T) { - cfg := database.BaseConfig{} + cfg := database.DBConfig{} opts := cfg.GetDBOpts() assert.Equal(t, map[string]string{}, opts) @@ -19,7 +19,7 @@ func TestGetDBOpts(t *testing.T) { } func TestGetDBOptsString(t *testing.T) { - cfg := database.BaseConfig{} + cfg := database.DBConfig{} opts := cfg.GetDBOptsString() assert.Equal(t, "", opts) @@ -30,14 +30,14 @@ func TestGetDBOptsString(t *testing.T) { } func TestGetDBDriver(t *testing.T) { - cfg := database.BaseConfig{} + cfg := database.DBConfig{} driver := cfg.GetDBDriver() assert.Equal(t, "postgres", driver) } func TestGetDBBaseURI(t *testing.T) { - cfg := database.BaseConfig{} + cfg := database.DBConfig{} uri := cfg.GetDBBaseURI() assert.Equal(t, "postgres://:@:0/", uri) @@ -51,7 +51,7 @@ func TestGetDBBaseURI(t *testing.T) { } func TestGetDBURI(t *testing.T) { - cfg := database.BaseConfig{} + cfg := database.DBConfig{} uri := cfg.GetDBURI() assert.Equal(t, "postgres://:@:0/?", uri) @@ -67,7 +67,7 @@ func TestGetDBURI(t *testing.T) { } func TestGetDBName(t *testing.T) { - cfg := database.BaseConfig{} + cfg := database.DBConfig{} name := cfg.GetDBName() assert.Equal(t, "", name) diff --git a/internal/serviceconfig/database/pool.go b/internal/serviceconfig/database/pool.go index 9a0367a1..e7eacae9 100644 --- a/internal/serviceconfig/database/pool.go +++ b/internal/serviceconfig/database/pool.go @@ -16,15 +16,15 @@ type Pool interface { Ping(ctx context.Context) error } -func (b *BaseConfig) GetDBPool() Pool { +func (b *DBConfig) GetDBPool() Pool { return b.DBPool } -func (b *BaseConfig) GetDBQueries() *repository.Queries { +func (b *DBConfig) GetDBQueries() *repository.Queries { return b.DBQueries } -func (b *BaseConfig) SetDBPoolConfig() error { +func (b *DBConfig) SetDBPoolConfig() error { config, err := pgxpool.ParseConfig(b.GetDBURI()) if err != nil { return err @@ -50,7 +50,7 @@ func (b *BaseConfig) SetDBPoolConfig() error { return nil } -func (b *BaseConfig) SetDBPool(ctx context.Context) error { +func (b *DBConfig) SetDBPool(ctx context.Context) error { err := b.SetDBPoolConfig() if err != nil { return err diff --git a/internal/serviceconfig/database/pool_test.go b/internal/serviceconfig/database/pool_test.go index 5afee0ff..2c328acb 100644 --- a/internal/serviceconfig/database/pool_test.go +++ b/internal/serviceconfig/database/pool_test.go @@ -5,7 +5,6 @@ import ( "os" "path" "queryorchestration/internal/database/repository" - "queryorchestration/internal/serviceconfig" "queryorchestration/internal/serviceconfig/database" "queryorchestration/internal/test" "testing" @@ -20,8 +19,8 @@ func TestSetDBPool(t *testing.T) { } ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../../..")) - cfg := &serviceconfig.BaseConfig{} + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../../..") _, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ Cfg: cfg, RunMigrations: true, @@ -34,7 +33,7 @@ func TestSetDBPool(t *testing.T) { } func TestGetDBPoolConfig(t *testing.T) { - cfg := database.BaseConfig{} + cfg := database.DBConfig{} err := cfg.SetDBPoolConfig() assert.Error(t, err) @@ -51,7 +50,7 @@ func TestGetDBPoolConfig(t *testing.T) { } func TestGetDBPool(t *testing.T) { - cfg := database.BaseConfig{} + cfg := database.DBConfig{} pool := cfg.GetDBPool() assert.Nil(t, pool) @@ -63,7 +62,7 @@ func TestGetDBPool(t *testing.T) { } func TestGetDBQueries(t *testing.T) { - cfg := database.BaseConfig{} + cfg := database.DBConfig{} queries := cfg.GetDBQueries() assert.Nil(t, queries) diff --git a/internal/serviceconfig/database/transaction.go b/internal/serviceconfig/database/transaction.go index 9b76b17a..bb75ebd4 100644 --- a/internal/serviceconfig/database/transaction.go +++ b/internal/serviceconfig/database/transaction.go @@ -5,7 +5,7 @@ import ( "queryorchestration/internal/database/repository" ) -func (b *BaseConfig) ExecuteDBTransaction(ctx context.Context, executeQueries func(context.Context, *repository.Queries) error) error { +func (b *DBConfig) ExecuteDBTransaction(ctx context.Context, executeQueries func(context.Context, *repository.Queries) error) error { tx, err := b.DBPool.Begin(ctx) if err != nil { return err diff --git a/internal/serviceconfig/database/transaction_test.go b/internal/serviceconfig/database/transaction_test.go index d0139ea8..90d5ce57 100644 --- a/internal/serviceconfig/database/transaction_test.go +++ b/internal/serviceconfig/database/transaction_test.go @@ -36,10 +36,10 @@ func TestExecuteTransaction(t *testing.T) { err = cfg.ExecuteDBTransaction(ctx, func(ctx context.Context, q *repository.Queries) error { id, err := q.CreateClient(ctx, "example_client") - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, clientID, id) return nil }) - assert.Nil(t, err) + assert.NoError(t, err) } diff --git a/internal/serviceconfig/logger/config.go b/internal/serviceconfig/logger/config.go new file mode 100644 index 00000000..35d78f4f --- /dev/null +++ b/internal/serviceconfig/logger/config.go @@ -0,0 +1,82 @@ +package logger + +import ( + "fmt" + "log/slog" + "reflect" + "strings" +) + +type LogConfig struct { + Logger *slog.Logger +} + +type ConfigProvider interface { + GetLogger() *slog.Logger + PrintConfig(prefixSecret string) +} + +func (b *LogConfig) GetLogger() *slog.Logger { + return b.Logger +} + +func (b *LogConfig) PrintConfig(prefixSecret string) { + b.printConfigRecursive(reflect.ValueOf(b), "", prefixSecret, make(map[reflect.Value]bool)) +} + +func (b *LogConfig) printConfigRecursive(val reflect.Value, prefix string, prefixSecret string, visited map[reflect.Value]bool) { + // Handle pointer dereference + if val.Kind() == reflect.Ptr { + val = val.Elem() + } + + // Prevent infinite recursion + if visited[val] { + return + } + visited[val] = true + + typ := val.Type() + + for i := 0; i < val.NumField(); i++ { + field := val.Field(i) + fieldType := typ.Field(i) + + // Skip unexported fields + if !fieldType.IsExported() { + continue + } + + fieldName := fieldType.Name + fullPath := prefix + fieldName + + // Handle embedded fields + if fieldType.Anonymous { + b.printConfigRecursive(field, prefix, prefixSecret, visited) + continue + } + + switch field.Kind() { + case reflect.Struct: + b.printConfigRecursive(field, fullPath+".", prefixSecret, visited) + default: + var valueStr string + if field.Kind() == reflect.String { + valueStr = field.String() + } else { + valueStr = fmt.Sprintf("%v", field.Interface()) + } + + // Mask sensitive values + if strings.Contains(strings.ToLower(fieldName), strings.ToLower(prefixSecret)) { + if len(valueStr) > 5 { + valueStr = valueStr[:5] + "..." + } + } + + b.Logger.Info("Config value", + "key", fullPath, + "value", valueStr) + } + } +} diff --git a/internal/serviceconfig/logger/config_test.go b/internal/serviceconfig/logger/config_test.go new file mode 100644 index 00000000..6d623b2a --- /dev/null +++ b/internal/serviceconfig/logger/config_test.go @@ -0,0 +1,36 @@ +package logger + +import ( + "log/slog" + "reflect" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestGetLogger(t *testing.T) { + cfg := &LogConfig{} + assert.Nil(t, cfg.GetLogger()) + cfg.Logger = slog.Default() + assert.NotNil(t, cfg.GetLogger()) +} + +func TestPrintConfig(t *testing.T) { + cfg := &LogConfig{} + tl := &TestLogger{T: t} + cfg.Logger = slog.New(tl) + cfg.PrintConfig("") + assert.Len(t, tl.Logs, 1) + assert.Equal(t, "Logger", tl.Logs[0]["key"]) +} + +func TestPrintConfigRecursive(t *testing.T) { + cfg := &LogConfig{} + tl := &TestLogger{T: t} + cfg.Logger = slog.New(tl) + v := struct{ Example string }{Example: "examplestring"} + cfg.printConfigRecursive(reflect.ValueOf(v), "", "", make(map[reflect.Value]bool)) + assert.Len(t, tl.Logs, 1) + assert.Equal(t, "Example", tl.Logs[0]["key"]) + assert.Equal(t, "examp...", tl.Logs[0]["value"]) +} diff --git a/internal/serviceconfig/testlogger.go b/internal/serviceconfig/logger/testlogger.go similarity index 52% rename from internal/serviceconfig/testlogger.go rename to internal/serviceconfig/logger/testlogger.go index 2bbfef85..10d4c5ba 100644 --- a/internal/serviceconfig/testlogger.go +++ b/internal/serviceconfig/logger/testlogger.go @@ -1,4 +1,4 @@ -package serviceconfig +package logger import ( "context" @@ -6,12 +6,12 @@ import ( "testing" ) -type testLogger struct { +type TestLogger struct { T *testing.T Logs []map[string]interface{} } -func (l *testLogger) Handle(ctx context.Context, r slog.Record) error { +func (l *TestLogger) Handle(ctx context.Context, r slog.Record) error { attrs := make(map[string]interface{}) r.Attrs(func(a slog.Attr) bool { attrs[a.Key] = a.Value.Any() @@ -21,14 +21,14 @@ func (l *testLogger) Handle(ctx context.Context, r slog.Record) error { return nil } -func (l *testLogger) Enabled(ctx context.Context, level slog.Level) bool { +func (l *TestLogger) Enabled(ctx context.Context, level slog.Level) bool { return true } -func (l *testLogger) WithAttrs(attrs []slog.Attr) slog.Handler { +func (l *TestLogger) WithAttrs(attrs []slog.Attr) slog.Handler { return l } -func (l *testLogger) WithGroup(name string) slog.Handler { +func (l *TestLogger) WithGroup(name string) slog.Handler { return l } diff --git a/internal/serviceconfig/testlogger_test.go b/internal/serviceconfig/logger/testlogger_test.go similarity index 92% rename from internal/serviceconfig/testlogger_test.go rename to internal/serviceconfig/logger/testlogger_test.go index e3569378..e7819580 100644 --- a/internal/serviceconfig/testlogger_test.go +++ b/internal/serviceconfig/logger/testlogger_test.go @@ -1,4 +1,4 @@ -package serviceconfig +package logger import ( "log/slog" @@ -8,7 +8,7 @@ import ( ) func TestTestLogger(t *testing.T) { - tl := &testLogger{T: t} + tl := &TestLogger{T: t} logger := slog.New(tl) slog.SetDefault(logger) diff --git a/internal/serviceconfig/observability/config.go b/internal/serviceconfig/observability/config.go new file mode 100644 index 00000000..30940d36 --- /dev/null +++ b/internal/serviceconfig/observability/config.go @@ -0,0 +1,13 @@ +package observability + +type ConfigProvider interface { + IsOtelEnabled() bool +} + +type ObsConfig struct { + EnableOtel bool `env:"ENABLE_OTEL" envDefault:"false"` +} + +func (o *ObsConfig) IsOtelEnabled() bool { + return o.EnableOtel +} diff --git a/internal/serviceconfig/observability/config_test.go b/internal/serviceconfig/observability/config_test.go new file mode 100644 index 00000000..a732ff2d --- /dev/null +++ b/internal/serviceconfig/observability/config_test.go @@ -0,0 +1,15 @@ +package observability_test + +import ( + "queryorchestration/internal/serviceconfig/observability" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestIsOtelEnabled(t *testing.T) { + c := observability.ObsConfig{} + assert.False(t, c.IsOtelEnabled()) + c.EnableOtel = true + assert.True(t, c.IsOtelEnabled()) +} diff --git a/internal/serviceconfig/queue/config.go b/internal/serviceconfig/queue/config.go new file mode 100644 index 00000000..4cdd6560 --- /dev/null +++ b/internal/serviceconfig/queue/config.go @@ -0,0 +1,52 @@ +package queue + +import ( + "context" + "fmt" + "queryorchestration/internal/server/queue" + "queryorchestration/internal/serviceconfig/aws" + + "github.com/aws/aws-sdk-go-v2/config" + "github.com/aws/aws-sdk-go-v2/service/sqs" + "github.com/aws/aws-sdk-go-v2/service/sqs/types" +) + +type QueueConfig struct { + aws.AWSConfig + EnableOtel bool `env:"ENABLE_OTEL" envDefault:"false"` + AWSEndpointUrlSQS string `env:"AWS_ENDPOINT_URL_SQS"` + QueueClient queue.SQSClient +} + +type ConfigProvider interface { + aws.ConfigProvider + SetQueueClient(context.Context) error + GetQueueClient() queue.SQSClient + PingQueueByURL(context.Context, string) error +} + +func (c *QueueConfig) GetQueueClient() queue.SQSClient { + return c.QueueClient +} + +func (c *QueueConfig) PingQueueByURL(ctx context.Context, url string) error { + _, err := c.QueueClient.GetQueueAttributes(ctx, &sqs.GetQueueAttributesInput{ + QueueUrl: &url, + AttributeNames: []types.QueueAttributeName{types.QueueAttributeNameApproximateNumberOfMessages}, + }) + if err != nil { + return fmt.Errorf("unable to load ping queue by url (%s): %v", url, err) + } + return err +} + +func (c *QueueConfig) SetQueueClient(ctx context.Context) error { + qcfg, err := config.LoadDefaultConfig(ctx) + if err != nil { + return fmt.Errorf("unable to load SDK config: %v", err) + } + + c.QueueClient = sqs.NewFromConfig(qcfg) + + return nil +} diff --git a/internal/serviceconfig/queue/config_test.go b/internal/serviceconfig/queue/config_test.go new file mode 100644 index 00000000..826acd08 --- /dev/null +++ b/internal/serviceconfig/queue/config_test.go @@ -0,0 +1,51 @@ +package queue_test + +import ( + "context" + "os" + "queryorchestration/internal/serviceconfig/queue" + queuemock "queryorchestration/mocks/queue" + "testing" + + "github.com/aws/aws-sdk-go-v2/service/sqs" + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" +) + +func TestGetQueueClient(t *testing.T) { + c := queue.QueueConfig{} + assert.Nil(t, c.GetQueueClient()) + c.QueueClient = &sqs.Client{} + assert.Equal(t, &sqs.Client{}, c.GetQueueClient()) +} + +func TestSetQueueClient(t *testing.T) { + os.Clearenv() + ctx := context.Background() + c := queue.QueueConfig{} + err := c.SetQueueClient(ctx) + assert.NoError(t, err) + assert.NotNil(t, c.QueueClient) +} + +func TestPingQueueByURL(t *testing.T) { + ctx := context.Background() + mockSQS := queuemock.NewMockSQSClient(t) + c := queue.QueueConfig{ + QueueClient: mockSQS, + } + url := "i/am/here" + + mockSQS.EXPECT(). + GetQueueAttributes( + mock.Anything, + mock.MatchedBy(func(in *sqs.GetQueueAttributesInput) bool { + return *in.QueueUrl == url + }), + mock.Anything, + ). + Return(&sqs.GetQueueAttributesOutput{}, nil) + + err := c.PingQueueByURL(ctx, url) + assert.NoError(t, err) +} diff --git a/internal/serviceconfig/queue/documentclean/config.go b/internal/serviceconfig/queue/documentclean/config.go new file mode 100644 index 00000000..895668ba --- /dev/null +++ b/internal/serviceconfig/queue/documentclean/config.go @@ -0,0 +1,13 @@ +package documentclean + +type DocCleanConfig struct { + DocumentCleanURL string `env:"DOCUMENT_CLEAN_URL,required,notEmpty"` +} + +func (c *DocCleanConfig) GetDocumentCleanURL() string { + return c.DocumentCleanURL +} + +type ConfigProvider interface { + GetDocumentCleanURL() string +} diff --git a/internal/test/api.go b/internal/test/api.go deleted file mode 100644 index 616ea036..00000000 --- a/internal/test/api.go +++ /dev/null @@ -1,62 +0,0 @@ -package test - -import ( - "context" - "fmt" - "testing" - - "github.com/docker/go-connections/nat" - "github.com/testcontainers/testcontainers-go" -) - -type APIContainerConfig struct { - ServiceName string - DB *ExternalDatabase - Network *testcontainers.DockerNetwork -} - -func CreateAPIContainer(t *testing.T, ctx context.Context, config *APIContainerConfig) (string, func()) { - port, err := nat.NewPort("tcp", "8080") - if err != nil { - t.Fatalf("Failed to create port: %v", err) - } - - container, cleanup := createContainer(t, ctx, &containerConfig{ - DB: config.DB, - ServiceName: config.ServiceName, - Network: config.Network, - ExposedPorts: []nat.Port{port}, - WaitForMsg: "Listening for requests", - }) - - host, err := container.Host(ctx) - if err != nil { - t.Fatalf("Failed to extract host: %v", err) - } - mappedPort, err := container.MappedPort(ctx, port) - if err != nil { - t.Fatalf("Failed to extract port: %v", err) - } - - return fmt.Sprintf("http://%s:%s", host, mappedPort.Port()), cleanup -} - -func CreateAPIWithDependencies(t *testing.T, ctx context.Context, serviceName string) (string, func()) { - network, ncleanup := CreateNetwork(t, ctx) - - dbconfig, dbcleanup := CreateDB(t, ctx, &CreateDatabaseConfig{ - Network: network, - }) - - address, ccleanup := CreateAPIContainer(t, ctx, &APIContainerConfig{ - ServiceName: serviceName, - DB: dbconfig.External, - Network: network, - }) - - return address, func() { - ncleanup() - dbcleanup() - ccleanup() - } -} diff --git a/internal/test/api_test.go b/internal/test/api_test.go deleted file mode 100644 index a408ebd8..00000000 --- a/internal/test/api_test.go +++ /dev/null @@ -1,56 +0,0 @@ -package test_test - -import ( - "context" - "os" - "path" - "queryorchestration/internal/serviceconfig" - "queryorchestration/internal/test" - "testing" - - "github.com/stretchr/testify/assert" -) - -func TestCreateAPIContainer(t *testing.T) { - if testing.Short() { - t.Skip("Skipping long test in short mode") - } - ctx := context.Background() - - ncfg, ncleanup := test.CreateNetwork(t, ctx) - defer ncleanup() - - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../..")) - cfg := &serviceconfig.BaseConfig{} - dbcfg, dbcleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ - Network: ncfg, - Cfg: cfg, - RunMigrations: true, - }) - defer dbcleanup() - - acfg := &test.APIContainerConfig{ - ServiceName: "queryService", - DB: dbcfg.External, - Network: ncfg, - } - - conn, cleanup := test.CreateAPIContainer(t, ctx, acfg) - assert.NotNil(t, conn) - assert.NotNil(t, cleanup) - - cleanup() -} -func TestCreateAPIWithDependencies(t *testing.T) { - if testing.Short() { - t.Skip("Skipping long test in short mode") - } - ctx := context.Background() - - conn, cleanup := test.CreateAPIWithDependencies(t, ctx, "queryService") - - assert.NotNil(t, conn) - assert.NotNil(t, cleanup) - - cleanup() -} diff --git a/internal/test/container.go b/internal/test/container.go index 405d65ee..129f74f7 100644 --- a/internal/test/container.go +++ b/internal/test/container.go @@ -1,8 +1,11 @@ package test import ( + "bufio" "context" "fmt" + "log/slog" + "queryorchestration/internal/serviceconfig" "strconv" "testing" @@ -11,9 +14,14 @@ import ( "github.com/testcontainers/testcontainers-go/wait" ) +type Container struct { + Container testcontainers.Container + URI string +} + type containerConfig struct { - ServiceName string - DB *ExternalDatabase + Name string + Cfg *serviceconfig.BaseConfig Network *testcontainers.DockerNetwork Env map[string]string WaitForMsg string @@ -22,12 +30,16 @@ type containerConfig struct { func createContainer(t *testing.T, ctx context.Context, cfg *containerConfig) (testcontainers.Container, func()) { env := map[string]string{ - "DB_USER": cfg.DB.User, - "DB_PASS": cfg.DB.Password, - "DB_HOST": cfg.DB.Host, - "DB_NAME": cfg.DB.Name, - "DB_PORT": strconv.Itoa(cfg.DB.Port), - "DB_NOSSL": "true", + "DB_USER": cfg.Cfg.DBUser, + "DB_PASS": cfg.Cfg.DBSecret, + "DB_HOST": cfg.Cfg.DBHost, + "DB_NAME": cfg.Cfg.DBName, + "DB_PORT": strconv.Itoa(cfg.Cfg.DBPort), + "DB_NOSSL": "true", + "AWS_ACCESS_KEY_ID": cfg.Cfg.AWSKeyID, + "AWS_SECRET_ACCESS_KEY": cfg.Cfg.AWSRegion, + "AWS_REGION": cfg.Cfg.AWSSecretKey, + "AWS_ENDPOINT_URL_SQS": cfg.Cfg.AWSEndpointUrlSQS, } if cfg.Env != nil { for k, v := range cfg.Env { @@ -40,7 +52,7 @@ func createContainer(t *testing.T, ctx context.Context, cfg *containerConfig) (t Env: env, Networks: []string{cfg.Network.Name}, WaitingFor: wait.ForLog(cfg.WaitForMsg), - Entrypoint: []string{fmt.Sprintf("./%s", cfg.ServiceName)}, + Entrypoint: []string{fmt.Sprintf("./%s", cfg.Name)}, } if len(cfg.ExposedPorts) > 0 { @@ -49,11 +61,11 @@ func createContainer(t *testing.T, ctx context.Context, cfg *containerConfig) (t ports[index] = port.Port() } req.ExposedPorts = ports - req.WaitingFor = wait.ForAll( - // wait.ForExposedPort(), - // wait.ForListeningPort(cfg.ExposedPorts[0]), - wait.ForLog(cfg.WaitForMsg), - ) + // req.WaitingFor = wait.ForAll( + // // wait.ForExposedPort(), + // // wait.ForListeningPort(cfg.ExposedPorts[0]), + // wait.ForLog(cfg.WaitForMsg), + // ) } container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{ @@ -61,6 +73,15 @@ func createContainer(t *testing.T, ctx context.Context, cfg *containerConfig) (t Started: true, }) if err != nil { + logs, _ := container.Logs(ctx) + defer logs.Close() + + scanner := bufio.NewScanner(logs) + for scanner.Scan() { + line := scanner.Text() + slog.Error(line) + } + t.Fatalf("Failed to start container: %v", err) } diff --git a/internal/test/container_test.go b/internal/test/container_test.go index 3446de8e..5f2a9447 100644 --- a/internal/test/container_test.go +++ b/internal/test/container_test.go @@ -2,9 +2,6 @@ package test import ( "context" - "os" - "path" - "queryorchestration/internal/serviceconfig" "testing" "github.com/stretchr/testify/assert" @@ -19,19 +16,18 @@ func TestCreateContainer(t *testing.T) { ncfg, ncleanup := CreateNetwork(t, ctx) defer ncleanup() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../..")) - cfg := &serviceconfig.BaseConfig{} - dbcfg, dbcleanup := CreateDB(t, ctx, &CreateDatabaseConfig{ - Network: ncfg, - Cfg: cfg, - RunMigrations: true, + cfg := CreateBaseConfig() + + _, dbcleanup := CreateDB(t, ctx, &CreateDatabaseConfig{ + Network: ncfg, + Cfg: cfg, }) defer dbcleanup() ccfg := &containerConfig{ - ServiceName: "queryService", - DB: dbcfg.External, - Network: ncfg, + Name: QueryService, + Cfg: cfg, + Network: ncfg, } container, cleanup := createContainer(t, ctx, ccfg) diff --git a/internal/test/database.go b/internal/test/database.go index 9025f677..e72ca839 100644 --- a/internal/test/database.go +++ b/internal/test/database.go @@ -5,6 +5,7 @@ import ( "fmt" "queryorchestration/internal/database/migrations" "queryorchestration/internal/serviceconfig" + "queryorchestration/internal/serviceconfig/database" "testing" "github.com/docker/go-connections/nat" @@ -12,26 +13,13 @@ import ( "github.com/testcontainers/testcontainers-go/wait" ) -type ExternalDatabase struct { - Name string - Host string - Port int - User string - Password string -} - -type Database struct { - Container testcontainers.Container - External *ExternalDatabase -} - type CreateDatabaseConfig struct { Network *testcontainers.DockerNetwork Cfg serviceconfig.ConfigProvider RunMigrations bool } -func CreateDB(t *testing.T, ctx context.Context, cfg *CreateDatabaseConfig) (*Database, func()) { +func CreateDB(t *testing.T, ctx context.Context, cfg *CreateDatabaseConfig) (testcontainers.Container, func()) { alias := "postgres" port, err := nat.NewPort("tcp", "5432") @@ -82,47 +70,49 @@ func CreateDB(t *testing.T, ctx context.Context, cfg *CreateDatabaseConfig) (*Da t.Fatalf("Failed to extract port: %v", err) } - t.Setenv("DB_USER", user) - t.Setenv("DB_PASS", pass) - t.Setenv("DB_HOST", host) - t.Setenv("DB_PORT", fmt.Sprint(mappedPort.Int())) - t.Setenv("DB_NAME", name) - t.Setenv("DB_NOSSL", "true") + dbcfg := &database.DBConfig{ + DBName: name, + DBSecret: pass, + DBUser: user, + DBPort: mappedPort.Int(), + DBHost: host, + DBNoSSL: true, + } + + t.Setenv("DB_USER", dbcfg.DBUser) + t.Setenv("DB_PASS", dbcfg.DBSecret) + t.Setenv("DB_NAME", dbcfg.DBName) + t.Setenv("DB_NOSSL", fmt.Sprintf("%v", dbcfg.DBNoSSL)) + t.Setenv("DB_HOST", dbcfg.DBHost) + t.Setenv("DB_PORT", fmt.Sprint(dbcfg.DBPort)) if cfg.Cfg != nil { - err = serviceconfig.InitializeConfig(cfg.Cfg) - if err != nil { - t.Fatal(err) - } - if cfg.RunMigrations { + cfg.Cfg.SetDBConfig(dbcfg) + err := migrations.Run(ctx, cfg.Cfg) if err != nil { t.Fatal(err) } - err = cfg.Cfg.SetDBPool(ctx) + err = dbcfg.SetDBPool(ctx) if err != nil { t.Fatal(err) } } - } - external := &ExternalDatabase{ - Name: name, - Password: pass, - User: user, - Port: port.Int(), - Host: alias, - } - - return &Database{ - Container: container, - External: external, - }, func() { - err := container.Terminate(ctx) - if err != nil { - t.Error(err) - } + if cfg.Network != nil { + dbcfg.DBHost = alias + dbcfg.DBPort = port.Int() } + + cfg.Cfg.SetDBConfig(dbcfg) + } + + return container, func() { + err := container.Terminate(ctx) + if err != nil { + t.Error(err) + } + } } diff --git a/internal/test/database_test.go b/internal/test/database_test.go index 0b4e7907..3a40e921 100644 --- a/internal/test/database_test.go +++ b/internal/test/database_test.go @@ -4,7 +4,6 @@ import ( "context" "os" "path" - "queryorchestration/internal/serviceconfig" "queryorchestration/internal/test" "testing" @@ -17,7 +16,9 @@ func TestCreateDB(t *testing.T) { } ctx := context.Background() - cfg := &serviceconfig.BaseConfig{} + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../..") + dbcfg, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{Cfg: cfg}) assert.NotNil(t, dbcfg) assert.Nil(t, cfg.DBPool) @@ -32,8 +33,9 @@ func TestCreateDBWithMigrations(t *testing.T) { } ctx := context.Background() - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../..")) - cfg := &serviceconfig.BaseConfig{} + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../..") + dbcfg, cleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ Cfg: cfg, RunMigrations: true, diff --git a/internal/test/ecosystem.go b/internal/test/ecosystem.go new file mode 100644 index 00000000..24c0c2d0 --- /dev/null +++ b/internal/test/ecosystem.go @@ -0,0 +1,195 @@ +package test + +import ( + "context" + "queryorchestration/internal/serviceconfig" + "testing" + + "github.com/testcontainers/testcontainers-go" +) + +type EcosystemConfig struct { + Services map[Service]*Container + Runners map[Runner]*Container + Cfg *serviceconfig.BaseConfig +} + +type EcosystemNetworkConfig struct { + Runners []*RunnerNetworkConfig + Services []*ServiceNetworkConfig + Cfg *serviceconfig.BaseConfig + Network *testcontainers.DockerNetwork +} + +func CreateRunnersAndServicesNetwork(t *testing.T, ctx context.Context, ncfg *EcosystemNetworkConfig) (*EcosystemConfig, func()) { + if ncfg.Cfg == nil { + ncfg.Cfg = CreateBaseConfig() + } + + network := ncfg.Network + var ncleanup func() + if network == nil { + network, ncleanup = CreateNetwork(t, ctx) + } + + _, dbcleanup := CreateDB(t, ctx, &CreateDatabaseConfig{ + Network: network, + Cfg: ncfg.Cfg, + RunMigrations: true, + }) + + ss := make(map[string]*Container, len(ncfg.Services)) + sclean := make([]func(), len(ncfg.Services)) + for i, s := range ncfg.Services { + c, ccleanup := CreateService(t, ctx, &ServiceConfig{ + Name: s.Name, + Env: s.Env, + Cfg: ncfg.Cfg, + Network: network, + }) + ss[s.Name] = c + sclean[i] = ccleanup + } + + var qcleanup func() + if ncfg.Cfg.QueueClient == nil { + qcleanup = CreateQueueClient(t, ctx, &CreateQueueConfig{ + Network: network, + Cfg: ncfg.Cfg, + }) + } + + qs := make(map[string]*Container, len(ncfg.Runners)) + qclean := make([]func(), len(ncfg.Runners)) + for i, r := range ncfg.Runners { + url := CreateQueue(t, ctx, ncfg.Cfg, r.Name) + + c, ccleanup := CreateRunner(t, ctx, &RunnerConfig{ + Name: r.Name, + Env: r.Env, + QueueURL: url, + Cfg: ncfg.Cfg, + Network: network, + }) + + qs[r.Name] = c + qclean[i] = ccleanup + } + + return &EcosystemConfig{ + Services: ss, + Runners: qs, + }, func() { + for _, c := range sclean { + c() + } + for _, c := range qclean { + c() + } + dbcleanup() + if qcleanup != nil { + qcleanup() + } + if ncleanup != nil { + ncleanup() + } + } +} + +func CreateBaseConfig() *serviceconfig.BaseConfig { + cfg := &serviceconfig.BaseConfig{} + + cfg.AWSKeyID = "test" + cfg.AWSSecretKey = "test" + cfg.AWSRegion = "us-east-1" + cfg.DBUser = "invalid_user" + cfg.DBSecret = "invalid_pass" + cfg.DBHost = "invalid_host" + cfg.DBPort = 5432 + cfg.DBName = "invalid_name" + cfg.DBNoSSL = true + + return cfg +} + +type ServiceNetworkConfig struct { + Name Runner + Env map[string]string +} + +func CreateServiceNetwork(t *testing.T, ctx context.Context, scfg *ServiceNetworkConfig) (*Container, func()) { + cfg := CreateBaseConfig() + + network, ncleanup := CreateNetwork(t, ctx) + + _, dbcleanup := CreateDB(t, ctx, &CreateDatabaseConfig{ + Network: network, + Cfg: cfg, + }) + + c, ccleanup := CreateService(t, ctx, &ServiceConfig{ + Name: scfg.Name, + Env: scfg.Env, + Cfg: cfg, + Network: network, + }) + + return c, func() { + dbcleanup() + ccleanup() + ncleanup() + } +} + +type RunnerNetworkConfig struct { + Network *testcontainers.DockerNetwork + Cfg *serviceconfig.BaseConfig + Name Runner + Env map[string]string +} + +func CreateRunnerNetwork(t *testing.T, ctx context.Context, rcfg *RunnerNetworkConfig) (*Container, func()) { + if rcfg.Cfg == nil { + rcfg.Cfg = CreateBaseConfig() + } + + network := rcfg.Network + var ncleanup func() + if network == nil { + network, ncleanup = CreateNetwork(t, ctx) + } + + var qcleanup func() + if rcfg.Cfg.QueueClient == nil { + qcleanup = CreateQueueClient(t, ctx, &CreateQueueConfig{ + Network: network, + Cfg: rcfg.Cfg, + }) + } + + url := CreateQueue(t, ctx, rcfg.Cfg, rcfg.Name) + + _, dbcleanup := CreateDB(t, ctx, &CreateDatabaseConfig{ + Network: network, + Cfg: rcfg.Cfg, + }) + + c, ccleanup := CreateRunner(t, ctx, &RunnerConfig{ + Name: rcfg.Name, + Env: rcfg.Env, + QueueURL: url, + Cfg: rcfg.Cfg, + Network: network, + }) + + return c, func() { + ccleanup() + dbcleanup() + if qcleanup != nil { + qcleanup() + } + if ncleanup != nil { + ncleanup() + } + } +} diff --git a/internal/test/ecosystem_test.go b/internal/test/ecosystem_test.go new file mode 100644 index 00000000..ebc2e74e --- /dev/null +++ b/internal/test/ecosystem_test.go @@ -0,0 +1,79 @@ +package test + +import ( + "context" + "os" + "path" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestCreateRunnerNetwork(t *testing.T) { + if testing.Short() { + t.Skip("Skipping long test in short mode") + } + ctx := context.Background() + + conn, cleanup := CreateRunnerNetwork(t, ctx, &RunnerNetworkConfig{ + Name: QueryRunner, + }) + + assert.NotNil(t, conn) + assert.NotNil(t, cleanup) + + cleanup() +} + +func TestCreateServiceNetwork(t *testing.T) { + if testing.Short() { + t.Skip("Skipping long test in short mode") + } + ctx := context.Background() + + conn, cleanup := CreateServiceNetwork(t, ctx, &ServiceNetworkConfig{ + Name: QueryService, + }) + + assert.NotNil(t, conn) + assert.NotNil(t, cleanup) + + cleanup() +} + +func TestCreateRunnersAndServicesNetwork(t *testing.T) { + if testing.Short() { + t.Skip("Skipping long test in short mode") + } + ctx := context.Background() + cfg := CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../..") + + conn, cleanup := CreateRunnersAndServicesNetwork(t, ctx, &EcosystemNetworkConfig{ + Cfg: cfg, + Runners: []*RunnerNetworkConfig{ + {Name: QueryRunner}, + }, + Services: []*ServiceNetworkConfig{ + {Name: QueryService}, + }, + }) + + assert.NotNil(t, conn) + assert.NotNil(t, cleanup) + + cleanup() +} + +func TestCreateBaseConfig(t *testing.T) { + cfg := CreateBaseConfig() + assert.Equal(t, "test", cfg.AWSKeyID) + assert.Equal(t, "test", cfg.AWSSecretKey) + assert.Equal(t, "us-east-1", cfg.AWSRegion) + assert.Equal(t, "invalid_user", cfg.DBUser) + assert.Equal(t, "invalid_pass", cfg.DBSecret) + assert.Equal(t, "invalid_host", cfg.DBHost) + assert.Equal(t, 5432, cfg.DBPort) + assert.Equal(t, "invalid_name", cfg.DBName) + assert.True(t, cfg.DBNoSSL) +} diff --git a/internal/test/queue.go b/internal/test/queue.go index 5d58a1d6..5abc877b 100644 --- a/internal/test/queue.go +++ b/internal/test/queue.go @@ -4,6 +4,7 @@ import ( "context" "fmt" "queryorchestration/internal/server/queue" + "queryorchestration/internal/serviceconfig" "testing" "time" @@ -18,29 +19,20 @@ import ( "github.com/testcontainers/testcontainers-go/wait" ) -type QueueConfig struct { - Container testcontainers.Container - Client *sqs.Client - URL string - External *ExternalQueue -} - -type ExternalQueue struct { - Endpoint string - Credentials aws.CredentialsProvider - Region string - URL string +type queueContainerConfig struct { + Container testcontainers.Container + ExternalEndpoint string + NetworkEndpoint string } type CreateQueueConfig struct { Network *testcontainers.DockerNetwork + Cfg *serviceconfig.BaseConfig } -func CreateQueue(t *testing.T, ctx context.Context, cfg *CreateQueueConfig) (*QueueConfig, func()) { - queueName := "test-queue" - region := "us-east-1" +func createQueueContainer(t *testing.T, ctx context.Context, cfg *CreateQueueConfig) (*queueContainerConfig, func()) { alias := "localstack" - provider := credentials.NewStaticCredentialsProvider("test", "test", "") + provider := credentials.NewStaticCredentialsProvider(cfg.Cfg.AWSKeyID, cfg.Cfg.AWSSecretKey, cfg.Cfg.AWSSessionToken) port, err := nat.NewPort("tcp", "4566") if err != nil { @@ -53,8 +45,7 @@ func CreateQueue(t *testing.T, ctx context.Context, cfg *CreateQueueConfig) (*Qu "AWS_ACCESS_KEY_ID": provider.Value.AccessKeyID, "AWS_SECRET_ACCESS_KEY": provider.Value.SecretAccessKey, "AWS_SESSION_TOKEN": provider.Value.SessionToken, - "AWS_DEFAULT_REGION": region, - "AWS_REGION": region, + "AWS_REGION": cfg.Cfg.AWSRegion, "SERVICES": "sqs", "SKIP_SSL_CERT_DOWNLOAD": "1", "LOCALSTACK_HOST": alias, @@ -92,32 +83,20 @@ func CreateQueue(t *testing.T, ctx context.Context, cfg *CreateQueueConfig) (*Qu t.Fatalf("Failed to extract port: %v", err) } - endpoint := fmt.Sprintf("http://%s:%s", host, mappedPort.Port()) - sqsCfg, err := config.LoadDefaultConfig(ctx, config.WithRegion(region), config.WithCredentialsProvider(provider), config.WithBaseEndpoint(endpoint)) - if err != nil { - t.Fatal(err) + extEndpoint := fmt.Sprintf("http://%s:%s", host, mappedPort.Port()) + t.Setenv("AWS_ENDPOINT_URL_SQS", extEndpoint) + cfg.Cfg.AWSEndpointUrlSQS = extEndpoint + + var endpoint string + if cfg.Network != nil { + endpoint = fmt.Sprintf("http://%s:%s", alias, port.Port()) + cfg.Cfg.AWSEndpointUrlSQS = endpoint } - client := sqs.NewFromConfig(sqsCfg) - - queueM, err := client.CreateQueue(ctx, &sqs.CreateQueueInput{ - QueueName: aws.String(queueName), - }) - if err != nil { - t.Fatal(err) - } - - endpoint = fmt.Sprintf("http://%s:%s", alias, port.Port()) - - return &QueueConfig{ - Container: container, - Client: client, - URL: *queueM.QueueUrl, - External: &ExternalQueue{ - Region: region, - Credentials: provider, - Endpoint: endpoint, - }, + return &queueContainerConfig{ + Container: container, + ExternalEndpoint: extEndpoint, + NetworkEndpoint: endpoint, }, func() { err := container.Terminate(ctx) if err != nil { @@ -126,11 +105,38 @@ func CreateQueue(t *testing.T, ctx context.Context, cfg *CreateQueueConfig) (*Qu } } +func CreateQueueClient(t *testing.T, ctx context.Context, cfg *CreateQueueConfig) func() { + qcfg, clean := createQueueContainer(t, ctx, cfg) + + provider := credentials.NewStaticCredentialsProvider(cfg.Cfg.AWSKeyID, cfg.Cfg.AWSSecretKey, cfg.Cfg.AWSSessionToken) + + sqsCfg, err := config.LoadDefaultConfig(ctx, config.WithRegion(cfg.Cfg.AWSRegion), config.WithCredentialsProvider(provider), config.WithBaseEndpoint(qcfg.ExternalEndpoint)) + if err != nil { + t.Fatal(err) + } + + cfg.Cfg.QueueClient = sqs.NewFromConfig(sqsCfg) + + return clean +} + +func CreateQueue(t *testing.T, ctx context.Context, cfg *serviceconfig.BaseConfig, name string) string { + queueM, err := cfg.QueueClient.CreateQueue(ctx, &sqs.CreateQueueInput{ + QueueName: aws.String(name), + }) + if err != nil { + t.Fatal(err) + } + + return *queueM.QueueUrl +} + func AssertMessageWait(t *testing.T, ctx context.Context, cfg *queue.Config, attrs []string) types.Message { - time.Sleep(time.Second) + time.Sleep(1 * time.Second) result, err := queue.Receive(ctx, cfg, attrs) - assert.Nil(t, err) + assert.NoError(t, err) + assert.NotNil(t, result.Messages) assert.Len(t, result.Messages, 1) assert.NotNil(t, result.Messages[0]) diff --git a/internal/test/queue_test.go b/internal/test/queue_test.go index c00b5a10..32d1de27 100644 --- a/internal/test/queue_test.go +++ b/internal/test/queue_test.go @@ -1,9 +1,8 @@ -package test_test +package test import ( "context" "queryorchestration/internal/server/queue" - "queryorchestration/internal/test" "testing" "github.com/aws/aws-sdk-go-v2/aws" @@ -11,17 +10,53 @@ import ( "github.com/stretchr/testify/assert" ) +func TestCreateQueueContainer(t *testing.T) { + if testing.Short() { + t.Skip("Skipping long test in short mode") + } + ctx := context.Background() + cfg := CreateBaseConfig() + + qcfg, cleanup := createQueueContainer(t, ctx, &CreateQueueConfig{ + Cfg: cfg, + }) + assert.NotNil(t, qcfg) + assert.NotNil(t, cleanup) + + cleanup() +} + +func TestCreateQueueClient(t *testing.T) { + if testing.Short() { + t.Skip("Skipping long test in short mode") + } + ctx := context.Background() + cfg := CreateBaseConfig() + + cleanup := CreateQueueClient(t, ctx, &CreateQueueConfig{ + Cfg: cfg, + }) + assert.NotNil(t, cfg.QueueClient) + assert.NotNil(t, cleanup) + + cleanup() +} + func TestCreateQueue(t *testing.T) { if testing.Short() { t.Skip("Skipping long test in short mode") } ctx := context.Background() - qcfg, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{}) - assert.NotNil(t, qcfg) - assert.NotNil(t, cleanup) + cfg := CreateBaseConfig() - cleanup() + cleanup := CreateQueueClient(t, ctx, &CreateQueueConfig{ + Cfg: cfg, + }) + defer cleanup() + + url := CreateQueue(t, ctx, cfg, "myname") + assert.Equal(t, "http://localstack:4566/queue/us-east-1/000000000000/myname", url) } func TestAssertMessageWait(t *testing.T) { @@ -30,18 +65,23 @@ func TestAssertMessageWait(t *testing.T) { } ctx := context.Background() - qcfg, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{}) - defer cleanup() + cfg := CreateBaseConfig() - cfg := &queue.Config{ - URL: qcfg.URL, - Client: qcfg.Client, + cleanup := CreateQueueClient(t, ctx, &CreateQueueConfig{ + Cfg: cfg, + }) + defer cleanup() + url := CreateQueue(t, ctx, cfg, "myname") + + qucfg := &queue.Config{ + URL: url, + Client: cfg.QueueClient, } - err := queue.Send(ctx, cfg, "body", map[string]types.MessageAttributeValue{}) - assert.Nil(t, err) + err := queue.Send(ctx, qucfg, "body", map[string]types.MessageAttributeValue{}) + assert.NoError(t, err) - msg := test.AssertMessageWait(t, ctx, cfg, []string{}) + msg := AssertMessageWait(t, ctx, qucfg, []string{}) assert.NotNil(t, msg) } @@ -51,18 +91,23 @@ func TestAssertMessageBodyWait(t *testing.T) { } ctx := context.Background() - qcfg, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{}) - defer cleanup() + cfg := CreateBaseConfig() - cfg := &queue.Config{ - URL: qcfg.URL, - Client: qcfg.Client, + cleanup := CreateQueueClient(t, ctx, &CreateQueueConfig{ + Cfg: cfg, + }) + defer cleanup() + url := CreateQueue(t, ctx, cfg, "myname") + + qucfg := &queue.Config{ + URL: url, + Client: cfg.QueueClient, } - err := queue.Send(ctx, cfg, "body", map[string]types.MessageAttributeValue{}) - assert.Nil(t, err) + err := queue.Send(ctx, qucfg, "body", map[string]types.MessageAttributeValue{}) + assert.NoError(t, err) - test.AssertMessageBodyWait(t, ctx, cfg, "\"body\"") + AssertMessageBodyWait(t, ctx, qucfg, "\"body\"") } func TestAssertMessageAttrWait(t *testing.T) { @@ -71,24 +116,29 @@ func TestAssertMessageAttrWait(t *testing.T) { } ctx := context.Background() - qcfg, cleanup := test.CreateQueue(t, ctx, &test.CreateQueueConfig{}) - defer cleanup() + cfg := CreateBaseConfig() - cfg := &queue.Config{ - URL: qcfg.URL, - Client: qcfg.Client, + cleanup := CreateQueueClient(t, ctx, &CreateQueueConfig{ + Cfg: cfg, + }) + defer cleanup() + url := CreateQueue(t, ctx, cfg, "myname") + + qucfg := &queue.Config{ + URL: url, + Client: cfg.QueueClient, } name := "name" value := "value" - err := queue.Send(ctx, cfg, "body", map[string]types.MessageAttributeValue{ + err := queue.Send(ctx, qucfg, "body", map[string]types.MessageAttributeValue{ name: { DataType: aws.String("String"), StringValue: aws.String(value), }, }) - assert.Nil(t, err) + assert.NoError(t, err) - test.AssertMessageAttrWait(t, ctx, cfg, name, value) + AssertMessageAttrWait(t, ctx, qucfg, name, value) } diff --git a/internal/test/queuecontainer.go b/internal/test/queuecontainer.go deleted file mode 100644 index acb6b2bc..00000000 --- a/internal/test/queuecontainer.go +++ /dev/null @@ -1,81 +0,0 @@ -package test - -import ( - "context" - "testing" - - "github.com/aws/aws-sdk-go-v2/aws" - "github.com/testcontainers/testcontainers-go" -) - -type QueueContainerConfig struct { - ServiceName string - Queue *queueConfig - DB *ExternalDatabase - Network *testcontainers.DockerNetwork -} - -func CreateQueueContainer(t *testing.T, ctx context.Context, config *QueueContainerConfig) func() { - queueCredentials, err := config.Queue.Credentials.Retrieve(ctx) - if err != nil { - t.Fatal(err) - } - - _, cleanup := createContainer(t, ctx, &containerConfig{ - Network: config.Network, - ServiceName: config.ServiceName, - DB: config.DB, - WaitForMsg: "Listening to queue", - Env: map[string]string{ - "QUEUE_URL": config.Queue.URL, - "AWS_DEFAULT_REGION": config.Queue.Region, - "AWS_REGION": config.Queue.Region, - "AWS_ACCESS_KEY_ID": queueCredentials.AccessKeyID, - "AWS_SECRET_ACCESS_KEY": queueCredentials.SecretAccessKey, - "AWS_SESSION_TOKEN": queueCredentials.SessionToken, - "AWS_ENDPOINT_URL_SQS": config.Queue.Endpoint, - }, - }) - - return cleanup -} - -type queueConfig struct { - URL string - Region string - Endpoint string - Credentials aws.CredentialsProvider -} - -func CreateQueueWithDependencies(t *testing.T, ctx context.Context, serviceName string) (*QueueConfig, func()) { - network, ncleanup := CreateNetwork(t, ctx) - - dbconfig, dbcleanup := CreateDB(t, ctx, &CreateDatabaseConfig{ - Network: network, - }) - - qCfg, qcleanup := CreateQueue(t, ctx, &CreateQueueConfig{ - Network: network, - }) - - cfg := &queueConfig{ - URL: qCfg.URL, - Region: qCfg.External.Region, - Endpoint: qCfg.External.Endpoint, - Credentials: qCfg.External.Credentials, - } - - ccleanup := CreateQueueContainer(t, ctx, &QueueContainerConfig{ - ServiceName: serviceName, - Queue: cfg, - DB: dbconfig.External, - Network: network, - }) - - return qCfg, func() { - ncleanup() - dbcleanup() - qcleanup() - ccleanup() - } -} diff --git a/internal/test/queuecontainer_test.go b/internal/test/queuecontainer_test.go deleted file mode 100644 index a5a43306..00000000 --- a/internal/test/queuecontainer_test.go +++ /dev/null @@ -1,67 +0,0 @@ -package test - -import ( - "context" - "os" - "path" - "queryorchestration/internal/serviceconfig" - "testing" - - "github.com/stretchr/testify/assert" -) - -func TestCreateQueueContainer(t *testing.T) { - if testing.Short() { - t.Skip("Skipping long test in short mode") - } - ctx := context.Background() - - ncfg, ncleanup := CreateNetwork(t, ctx) - defer ncleanup() - - t.Setenv("BASE_PATH", path.Join(os.Getenv("PWD"), "../..")) - cfg := &serviceconfig.BaseConfig{} - dbcfg, dbcleanup := CreateDB(t, ctx, &CreateDatabaseConfig{ - Network: ncfg, - Cfg: cfg, - RunMigrations: true, - }) - defer dbcleanup() - - qcfg, qcleanup := CreateQueue(t, ctx, &CreateQueueConfig{ - Network: ncfg, - }) - defer qcleanup() - - extcfg := &queueConfig{ - URL: qcfg.URL, - Region: qcfg.External.Region, - Endpoint: qcfg.External.Endpoint, - Credentials: qcfg.External.Credentials, - } - qccfg := &QueueContainerConfig{ - ServiceName: "queryRunner", - DB: dbcfg.External, - Network: ncfg, - Queue: extcfg, - } - - cleanup := CreateQueueContainer(t, ctx, qccfg) - assert.NotNil(t, cleanup) - - cleanup() -} - -func TestCreateQueueWithDependencies(t *testing.T) { - if testing.Short() { - t.Skip("Skipping long test in short mode") - } - ctx := context.Background() - - conn, cleanup := CreateQueueWithDependencies(t, ctx, "queryRunner") - - assert.NotNil(t, conn) - assert.NotNil(t, cleanup) - - cleanup() -} diff --git a/internal/test/runner.go b/internal/test/runner.go new file mode 100644 index 00000000..bd7a55e3 --- /dev/null +++ b/internal/test/runner.go @@ -0,0 +1,47 @@ +package test + +import ( + "context" + docinitrunner "queryorchestration/api/docInitRunner" + queryrunner "queryorchestration/api/queryRunner" + "testing" + + "queryorchestration/internal/serviceconfig" + + "github.com/testcontainers/testcontainers-go" +) + +type Runner = string + +const ( + QueryRunner = queryrunner.Name + DocInitRunner = docinitrunner.Name +) + +type RunnerConfig struct { + Name Runner + QueueURL string + Cfg *serviceconfig.BaseConfig + Network *testcontainers.DockerNetwork + Env map[string]string +} + +func CreateRunner(t *testing.T, ctx context.Context, config *RunnerConfig) (*Container, func()) { + if config.Env == nil { + config.Env = map[string]string{} + } + config.Env["QUEUE_URL"] = config.QueueURL + + c, cleanup := createContainer(t, ctx, &containerConfig{ + Network: config.Network, + Name: config.Name, + Cfg: config.Cfg, + Env: config.Env, + WaitForMsg: "Listening to queue", + }) + + return &Container{ + Container: c, + URI: config.QueueURL, + }, cleanup +} diff --git a/internal/test/runner_test.go b/internal/test/runner_test.go new file mode 100644 index 00000000..1e4c888e --- /dev/null +++ b/internal/test/runner_test.go @@ -0,0 +1,46 @@ +package test + +import ( + "context" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestCreateRunner(t *testing.T) { + if testing.Short() { + t.Skip("Skipping long test in short mode") + } + ctx := context.Background() + + ncfg, ncleanup := CreateNetwork(t, ctx) + defer ncleanup() + + cfg := CreateBaseConfig() + + qcleanup := CreateQueueClient(t, ctx, &CreateQueueConfig{ + Network: ncfg, + Cfg: cfg, + }) + defer qcleanup() + url := CreateQueue(t, ctx, cfg, "myname") + + _, dbcleanup := CreateDB(t, ctx, &CreateDatabaseConfig{ + Network: ncfg, + Cfg: cfg, + }) + defer dbcleanup() + + qccfg := &RunnerConfig{ + Name: QueryRunner, + Cfg: cfg, + Network: ncfg, + QueueURL: url, + } + + c, cleanup := CreateRunner(t, ctx, qccfg) + assert.NotNil(t, cleanup) + assert.NotNil(t, c) + + cleanup() +} diff --git a/internal/test/service.go b/internal/test/service.go new file mode 100644 index 00000000..c09e30bb --- /dev/null +++ b/internal/test/service.go @@ -0,0 +1,57 @@ +package test + +import ( + "context" + "fmt" + queryservice "queryorchestration/api/queryService" + "queryorchestration/internal/serviceconfig" + "testing" + + "github.com/docker/go-connections/nat" + "github.com/testcontainers/testcontainers-go" +) + +type Service = string + +const ( + QueryService = queryservice.Name +) + +type ServiceConfig struct { + Name Service + Cfg *serviceconfig.BaseConfig + Network *testcontainers.DockerNetwork + Env map[string]string +} + +func CreateService(t *testing.T, ctx context.Context, config *ServiceConfig) (*Container, func()) { + port, err := nat.NewPort("tcp", "8080") + if err != nil { + t.Fatalf("Failed to create port: %v", err) + } + + container, cleanup := createContainer(t, ctx, &containerConfig{ + Cfg: config.Cfg, + Name: config.Name, + Network: config.Network, + Env: config.Env, + ExposedPorts: []nat.Port{port}, + WaitForMsg: "⇨ http server started on [::]:8080", + }) + + host, err := container.Host(ctx) + if err != nil { + t.Fatalf("Failed to extract host: %v", err) + } + mappedPort, err := container.MappedPort(ctx, port) + if err != nil { + t.Fatalf("Failed to extract port: %v", err) + } + + address := fmt.Sprintf("http://%s:%s", host, mappedPort.Port()) + + return &Container{ + URI: address, + Container: container, + }, cleanup +} diff --git a/internal/test/service_test.go b/internal/test/service_test.go new file mode 100644 index 00000000..0b4feac5 --- /dev/null +++ b/internal/test/service_test.go @@ -0,0 +1,41 @@ +package test_test + +import ( + "context" + "os" + "path" + "queryorchestration/internal/test" + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestCreateService(t *testing.T) { + if testing.Short() { + t.Skip("Skipping long test in short mode") + } + ctx := context.Background() + + ncfg, ncleanup := test.CreateNetwork(t, ctx) + defer ncleanup() + + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../..") + _, dbcleanup := test.CreateDB(t, ctx, &test.CreateDatabaseConfig{ + Network: ncfg, + Cfg: cfg, + }) + defer dbcleanup() + + acfg := &test.ServiceConfig{ + Name: test.QueryService, + Cfg: cfg, + Network: ncfg, + } + + conn, cleanup := test.CreateService(t, ctx, acfg) + assert.NotNil(t, conn) + assert.NotNil(t, cleanup) + + cleanup() +} diff --git a/mocks/queue/mock_SQSClient.go b/mocks/queue/mock_SQSClient.go new file mode 100644 index 00000000..f2e8e3f9 --- /dev/null +++ b/mocks/queue/mock_SQSClient.go @@ -0,0 +1,1444 @@ +// Code generated by mockery v2.46.3. DO NOT EDIT. + +package queuemock + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + sqs "github.com/aws/aws-sdk-go-v2/service/sqs" +) + +// MockSQSClient is an autogenerated mock type for the SQSClient type +type MockSQSClient struct { + mock.Mock +} + +type MockSQSClient_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSQSClient) EXPECT() *MockSQSClient_Expecter { + return &MockSQSClient_Expecter{mock: &_m.Mock} +} + +// AddPermission provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) AddPermission(ctx context.Context, params *sqs.AddPermissionInput, optFns ...func(*sqs.Options)) (*sqs.AddPermissionOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for AddPermission") + } + + var r0 *sqs.AddPermissionOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.AddPermissionInput, ...func(*sqs.Options)) (*sqs.AddPermissionOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.AddPermissionInput, ...func(*sqs.Options)) *sqs.AddPermissionOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.AddPermissionOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.AddPermissionInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_AddPermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddPermission' +type MockSQSClient_AddPermission_Call struct { + *mock.Call +} + +// AddPermission is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.AddPermissionInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) AddPermission(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_AddPermission_Call { + return &MockSQSClient_AddPermission_Call{Call: _e.mock.On("AddPermission", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_AddPermission_Call) Run(run func(ctx context.Context, params *sqs.AddPermissionInput, optFns ...func(*sqs.Options))) *MockSQSClient_AddPermission_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.AddPermissionInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_AddPermission_Call) Return(_a0 *sqs.AddPermissionOutput, _a1 error) *MockSQSClient_AddPermission_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_AddPermission_Call) RunAndReturn(run func(context.Context, *sqs.AddPermissionInput, ...func(*sqs.Options)) (*sqs.AddPermissionOutput, error)) *MockSQSClient_AddPermission_Call { + _c.Call.Return(run) + return _c +} + +// ChangeMessageVisibility provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) ChangeMessageVisibility(ctx context.Context, params *sqs.ChangeMessageVisibilityInput, optFns ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ChangeMessageVisibility") + } + + var r0 *sqs.ChangeMessageVisibilityOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.ChangeMessageVisibilityInput, ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.ChangeMessageVisibilityInput, ...func(*sqs.Options)) *sqs.ChangeMessageVisibilityOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.ChangeMessageVisibilityOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.ChangeMessageVisibilityInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_ChangeMessageVisibility_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChangeMessageVisibility' +type MockSQSClient_ChangeMessageVisibility_Call struct { + *mock.Call +} + +// ChangeMessageVisibility is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.ChangeMessageVisibilityInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) ChangeMessageVisibility(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ChangeMessageVisibility_Call { + return &MockSQSClient_ChangeMessageVisibility_Call{Call: _e.mock.On("ChangeMessageVisibility", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_ChangeMessageVisibility_Call) Run(run func(ctx context.Context, params *sqs.ChangeMessageVisibilityInput, optFns ...func(*sqs.Options))) *MockSQSClient_ChangeMessageVisibility_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.ChangeMessageVisibilityInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_ChangeMessageVisibility_Call) Return(_a0 *sqs.ChangeMessageVisibilityOutput, _a1 error) *MockSQSClient_ChangeMessageVisibility_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_ChangeMessageVisibility_Call) RunAndReturn(run func(context.Context, *sqs.ChangeMessageVisibilityInput, ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityOutput, error)) *MockSQSClient_ChangeMessageVisibility_Call { + _c.Call.Return(run) + return _c +} + +// ChangeMessageVisibilityBatch provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) ChangeMessageVisibilityBatch(ctx context.Context, params *sqs.ChangeMessageVisibilityBatchInput, optFns ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityBatchOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ChangeMessageVisibilityBatch") + } + + var r0 *sqs.ChangeMessageVisibilityBatchOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.ChangeMessageVisibilityBatchInput, ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityBatchOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.ChangeMessageVisibilityBatchInput, ...func(*sqs.Options)) *sqs.ChangeMessageVisibilityBatchOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.ChangeMessageVisibilityBatchOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.ChangeMessageVisibilityBatchInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_ChangeMessageVisibilityBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChangeMessageVisibilityBatch' +type MockSQSClient_ChangeMessageVisibilityBatch_Call struct { + *mock.Call +} + +// ChangeMessageVisibilityBatch is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.ChangeMessageVisibilityBatchInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) ChangeMessageVisibilityBatch(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ChangeMessageVisibilityBatch_Call { + return &MockSQSClient_ChangeMessageVisibilityBatch_Call{Call: _e.mock.On("ChangeMessageVisibilityBatch", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_ChangeMessageVisibilityBatch_Call) Run(run func(ctx context.Context, params *sqs.ChangeMessageVisibilityBatchInput, optFns ...func(*sqs.Options))) *MockSQSClient_ChangeMessageVisibilityBatch_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.ChangeMessageVisibilityBatchInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_ChangeMessageVisibilityBatch_Call) Return(_a0 *sqs.ChangeMessageVisibilityBatchOutput, _a1 error) *MockSQSClient_ChangeMessageVisibilityBatch_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_ChangeMessageVisibilityBatch_Call) RunAndReturn(run func(context.Context, *sqs.ChangeMessageVisibilityBatchInput, ...func(*sqs.Options)) (*sqs.ChangeMessageVisibilityBatchOutput, error)) *MockSQSClient_ChangeMessageVisibilityBatch_Call { + _c.Call.Return(run) + return _c +} + +// CreateQueue provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) CreateQueue(ctx context.Context, params *sqs.CreateQueueInput, optFns ...func(*sqs.Options)) (*sqs.CreateQueueOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for CreateQueue") + } + + var r0 *sqs.CreateQueueOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.CreateQueueInput, ...func(*sqs.Options)) (*sqs.CreateQueueOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.CreateQueueInput, ...func(*sqs.Options)) *sqs.CreateQueueOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.CreateQueueOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.CreateQueueInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_CreateQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateQueue' +type MockSQSClient_CreateQueue_Call struct { + *mock.Call +} + +// CreateQueue is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.CreateQueueInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) CreateQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_CreateQueue_Call { + return &MockSQSClient_CreateQueue_Call{Call: _e.mock.On("CreateQueue", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_CreateQueue_Call) Run(run func(ctx context.Context, params *sqs.CreateQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_CreateQueue_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.CreateQueueInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_CreateQueue_Call) Return(_a0 *sqs.CreateQueueOutput, _a1 error) *MockSQSClient_CreateQueue_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_CreateQueue_Call) RunAndReturn(run func(context.Context, *sqs.CreateQueueInput, ...func(*sqs.Options)) (*sqs.CreateQueueOutput, error)) *MockSQSClient_CreateQueue_Call { + _c.Call.Return(run) + return _c +} + +// DeleteMessage provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) DeleteMessage(ctx context.Context, params *sqs.DeleteMessageInput, optFns ...func(*sqs.Options)) (*sqs.DeleteMessageOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteMessage") + } + + var r0 *sqs.DeleteMessageOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteMessageInput, ...func(*sqs.Options)) (*sqs.DeleteMessageOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteMessageInput, ...func(*sqs.Options)) *sqs.DeleteMessageOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.DeleteMessageOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.DeleteMessageInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_DeleteMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessage' +type MockSQSClient_DeleteMessage_Call struct { + *mock.Call +} + +// DeleteMessage is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.DeleteMessageInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) DeleteMessage(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_DeleteMessage_Call { + return &MockSQSClient_DeleteMessage_Call{Call: _e.mock.On("DeleteMessage", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_DeleteMessage_Call) Run(run func(ctx context.Context, params *sqs.DeleteMessageInput, optFns ...func(*sqs.Options))) *MockSQSClient_DeleteMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.DeleteMessageInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_DeleteMessage_Call) Return(_a0 *sqs.DeleteMessageOutput, _a1 error) *MockSQSClient_DeleteMessage_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_DeleteMessage_Call) RunAndReturn(run func(context.Context, *sqs.DeleteMessageInput, ...func(*sqs.Options)) (*sqs.DeleteMessageOutput, error)) *MockSQSClient_DeleteMessage_Call { + _c.Call.Return(run) + return _c +} + +// DeleteMessageBatch provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) DeleteMessageBatch(ctx context.Context, params *sqs.DeleteMessageBatchInput, optFns ...func(*sqs.Options)) (*sqs.DeleteMessageBatchOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteMessageBatch") + } + + var r0 *sqs.DeleteMessageBatchOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteMessageBatchInput, ...func(*sqs.Options)) (*sqs.DeleteMessageBatchOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteMessageBatchInput, ...func(*sqs.Options)) *sqs.DeleteMessageBatchOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.DeleteMessageBatchOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.DeleteMessageBatchInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_DeleteMessageBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteMessageBatch' +type MockSQSClient_DeleteMessageBatch_Call struct { + *mock.Call +} + +// DeleteMessageBatch is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.DeleteMessageBatchInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) DeleteMessageBatch(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_DeleteMessageBatch_Call { + return &MockSQSClient_DeleteMessageBatch_Call{Call: _e.mock.On("DeleteMessageBatch", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_DeleteMessageBatch_Call) Run(run func(ctx context.Context, params *sqs.DeleteMessageBatchInput, optFns ...func(*sqs.Options))) *MockSQSClient_DeleteMessageBatch_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.DeleteMessageBatchInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_DeleteMessageBatch_Call) Return(_a0 *sqs.DeleteMessageBatchOutput, _a1 error) *MockSQSClient_DeleteMessageBatch_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_DeleteMessageBatch_Call) RunAndReturn(run func(context.Context, *sqs.DeleteMessageBatchInput, ...func(*sqs.Options)) (*sqs.DeleteMessageBatchOutput, error)) *MockSQSClient_DeleteMessageBatch_Call { + _c.Call.Return(run) + return _c +} + +// DeleteQueue provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) DeleteQueue(ctx context.Context, params *sqs.DeleteQueueInput, optFns ...func(*sqs.Options)) (*sqs.DeleteQueueOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for DeleteQueue") + } + + var r0 *sqs.DeleteQueueOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteQueueInput, ...func(*sqs.Options)) (*sqs.DeleteQueueOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.DeleteQueueInput, ...func(*sqs.Options)) *sqs.DeleteQueueOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.DeleteQueueOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.DeleteQueueInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_DeleteQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteQueue' +type MockSQSClient_DeleteQueue_Call struct { + *mock.Call +} + +// DeleteQueue is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.DeleteQueueInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) DeleteQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_DeleteQueue_Call { + return &MockSQSClient_DeleteQueue_Call{Call: _e.mock.On("DeleteQueue", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_DeleteQueue_Call) Run(run func(ctx context.Context, params *sqs.DeleteQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_DeleteQueue_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.DeleteQueueInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_DeleteQueue_Call) Return(_a0 *sqs.DeleteQueueOutput, _a1 error) *MockSQSClient_DeleteQueue_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_DeleteQueue_Call) RunAndReturn(run func(context.Context, *sqs.DeleteQueueInput, ...func(*sqs.Options)) (*sqs.DeleteQueueOutput, error)) *MockSQSClient_DeleteQueue_Call { + _c.Call.Return(run) + return _c +} + +// GetQueueAttributes provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) GetQueueAttributes(ctx context.Context, params *sqs.GetQueueAttributesInput, optFns ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetQueueAttributes") + } + + var r0 *sqs.GetQueueAttributesOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.GetQueueAttributesInput, ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.GetQueueAttributesInput, ...func(*sqs.Options)) *sqs.GetQueueAttributesOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.GetQueueAttributesOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.GetQueueAttributesInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_GetQueueAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetQueueAttributes' +type MockSQSClient_GetQueueAttributes_Call struct { + *mock.Call +} + +// GetQueueAttributes is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.GetQueueAttributesInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) GetQueueAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_GetQueueAttributes_Call { + return &MockSQSClient_GetQueueAttributes_Call{Call: _e.mock.On("GetQueueAttributes", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_GetQueueAttributes_Call) Run(run func(ctx context.Context, params *sqs.GetQueueAttributesInput, optFns ...func(*sqs.Options))) *MockSQSClient_GetQueueAttributes_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.GetQueueAttributesInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_GetQueueAttributes_Call) Return(_a0 *sqs.GetQueueAttributesOutput, _a1 error) *MockSQSClient_GetQueueAttributes_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_GetQueueAttributes_Call) RunAndReturn(run func(context.Context, *sqs.GetQueueAttributesInput, ...func(*sqs.Options)) (*sqs.GetQueueAttributesOutput, error)) *MockSQSClient_GetQueueAttributes_Call { + _c.Call.Return(run) + return _c +} + +// GetQueueUrl provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) GetQueueUrl(ctx context.Context, params *sqs.GetQueueUrlInput, optFns ...func(*sqs.Options)) (*sqs.GetQueueUrlOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for GetQueueUrl") + } + + var r0 *sqs.GetQueueUrlOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.GetQueueUrlInput, ...func(*sqs.Options)) (*sqs.GetQueueUrlOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.GetQueueUrlInput, ...func(*sqs.Options)) *sqs.GetQueueUrlOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.GetQueueUrlOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.GetQueueUrlInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_GetQueueUrl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetQueueUrl' +type MockSQSClient_GetQueueUrl_Call struct { + *mock.Call +} + +// GetQueueUrl is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.GetQueueUrlInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) GetQueueUrl(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_GetQueueUrl_Call { + return &MockSQSClient_GetQueueUrl_Call{Call: _e.mock.On("GetQueueUrl", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_GetQueueUrl_Call) Run(run func(ctx context.Context, params *sqs.GetQueueUrlInput, optFns ...func(*sqs.Options))) *MockSQSClient_GetQueueUrl_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.GetQueueUrlInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_GetQueueUrl_Call) Return(_a0 *sqs.GetQueueUrlOutput, _a1 error) *MockSQSClient_GetQueueUrl_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_GetQueueUrl_Call) RunAndReturn(run func(context.Context, *sqs.GetQueueUrlInput, ...func(*sqs.Options)) (*sqs.GetQueueUrlOutput, error)) *MockSQSClient_GetQueueUrl_Call { + _c.Call.Return(run) + return _c +} + +// ListQueueTags provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) ListQueueTags(ctx context.Context, params *sqs.ListQueueTagsInput, optFns ...func(*sqs.Options)) (*sqs.ListQueueTagsOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListQueueTags") + } + + var r0 *sqs.ListQueueTagsOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.ListQueueTagsInput, ...func(*sqs.Options)) (*sqs.ListQueueTagsOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.ListQueueTagsInput, ...func(*sqs.Options)) *sqs.ListQueueTagsOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.ListQueueTagsOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.ListQueueTagsInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_ListQueueTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListQueueTags' +type MockSQSClient_ListQueueTags_Call struct { + *mock.Call +} + +// ListQueueTags is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.ListQueueTagsInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) ListQueueTags(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ListQueueTags_Call { + return &MockSQSClient_ListQueueTags_Call{Call: _e.mock.On("ListQueueTags", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_ListQueueTags_Call) Run(run func(ctx context.Context, params *sqs.ListQueueTagsInput, optFns ...func(*sqs.Options))) *MockSQSClient_ListQueueTags_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.ListQueueTagsInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_ListQueueTags_Call) Return(_a0 *sqs.ListQueueTagsOutput, _a1 error) *MockSQSClient_ListQueueTags_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_ListQueueTags_Call) RunAndReturn(run func(context.Context, *sqs.ListQueueTagsInput, ...func(*sqs.Options)) (*sqs.ListQueueTagsOutput, error)) *MockSQSClient_ListQueueTags_Call { + _c.Call.Return(run) + return _c +} + +// ListQueues provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) ListQueues(ctx context.Context, params *sqs.ListQueuesInput, optFns ...func(*sqs.Options)) (*sqs.ListQueuesOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ListQueues") + } + + var r0 *sqs.ListQueuesOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.ListQueuesInput, ...func(*sqs.Options)) (*sqs.ListQueuesOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.ListQueuesInput, ...func(*sqs.Options)) *sqs.ListQueuesOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.ListQueuesOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.ListQueuesInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_ListQueues_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListQueues' +type MockSQSClient_ListQueues_Call struct { + *mock.Call +} + +// ListQueues is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.ListQueuesInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) ListQueues(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ListQueues_Call { + return &MockSQSClient_ListQueues_Call{Call: _e.mock.On("ListQueues", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_ListQueues_Call) Run(run func(ctx context.Context, params *sqs.ListQueuesInput, optFns ...func(*sqs.Options))) *MockSQSClient_ListQueues_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.ListQueuesInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_ListQueues_Call) Return(_a0 *sqs.ListQueuesOutput, _a1 error) *MockSQSClient_ListQueues_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_ListQueues_Call) RunAndReturn(run func(context.Context, *sqs.ListQueuesInput, ...func(*sqs.Options)) (*sqs.ListQueuesOutput, error)) *MockSQSClient_ListQueues_Call { + _c.Call.Return(run) + return _c +} + +// PurgeQueue provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) PurgeQueue(ctx context.Context, params *sqs.PurgeQueueInput, optFns ...func(*sqs.Options)) (*sqs.PurgeQueueOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for PurgeQueue") + } + + var r0 *sqs.PurgeQueueOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.PurgeQueueInput, ...func(*sqs.Options)) (*sqs.PurgeQueueOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.PurgeQueueInput, ...func(*sqs.Options)) *sqs.PurgeQueueOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.PurgeQueueOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.PurgeQueueInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_PurgeQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PurgeQueue' +type MockSQSClient_PurgeQueue_Call struct { + *mock.Call +} + +// PurgeQueue is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.PurgeQueueInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) PurgeQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_PurgeQueue_Call { + return &MockSQSClient_PurgeQueue_Call{Call: _e.mock.On("PurgeQueue", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_PurgeQueue_Call) Run(run func(ctx context.Context, params *sqs.PurgeQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_PurgeQueue_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.PurgeQueueInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_PurgeQueue_Call) Return(_a0 *sqs.PurgeQueueOutput, _a1 error) *MockSQSClient_PurgeQueue_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_PurgeQueue_Call) RunAndReturn(run func(context.Context, *sqs.PurgeQueueInput, ...func(*sqs.Options)) (*sqs.PurgeQueueOutput, error)) *MockSQSClient_PurgeQueue_Call { + _c.Call.Return(run) + return _c +} + +// ReceiveMessage provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) ReceiveMessage(ctx context.Context, params *sqs.ReceiveMessageInput, optFns ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for ReceiveMessage") + } + + var r0 *sqs.ReceiveMessageOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.ReceiveMessageInput, ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.ReceiveMessageInput, ...func(*sqs.Options)) *sqs.ReceiveMessageOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.ReceiveMessageOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.ReceiveMessageInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_ReceiveMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReceiveMessage' +type MockSQSClient_ReceiveMessage_Call struct { + *mock.Call +} + +// ReceiveMessage is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.ReceiveMessageInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) ReceiveMessage(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_ReceiveMessage_Call { + return &MockSQSClient_ReceiveMessage_Call{Call: _e.mock.On("ReceiveMessage", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_ReceiveMessage_Call) Run(run func(ctx context.Context, params *sqs.ReceiveMessageInput, optFns ...func(*sqs.Options))) *MockSQSClient_ReceiveMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.ReceiveMessageInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_ReceiveMessage_Call) Return(_a0 *sqs.ReceiveMessageOutput, _a1 error) *MockSQSClient_ReceiveMessage_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_ReceiveMessage_Call) RunAndReturn(run func(context.Context, *sqs.ReceiveMessageInput, ...func(*sqs.Options)) (*sqs.ReceiveMessageOutput, error)) *MockSQSClient_ReceiveMessage_Call { + _c.Call.Return(run) + return _c +} + +// RemovePermission provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) RemovePermission(ctx context.Context, params *sqs.RemovePermissionInput, optFns ...func(*sqs.Options)) (*sqs.RemovePermissionOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for RemovePermission") + } + + var r0 *sqs.RemovePermissionOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.RemovePermissionInput, ...func(*sqs.Options)) (*sqs.RemovePermissionOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.RemovePermissionInput, ...func(*sqs.Options)) *sqs.RemovePermissionOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.RemovePermissionOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.RemovePermissionInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_RemovePermission_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemovePermission' +type MockSQSClient_RemovePermission_Call struct { + *mock.Call +} + +// RemovePermission is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.RemovePermissionInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) RemovePermission(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_RemovePermission_Call { + return &MockSQSClient_RemovePermission_Call{Call: _e.mock.On("RemovePermission", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_RemovePermission_Call) Run(run func(ctx context.Context, params *sqs.RemovePermissionInput, optFns ...func(*sqs.Options))) *MockSQSClient_RemovePermission_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.RemovePermissionInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_RemovePermission_Call) Return(_a0 *sqs.RemovePermissionOutput, _a1 error) *MockSQSClient_RemovePermission_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_RemovePermission_Call) RunAndReturn(run func(context.Context, *sqs.RemovePermissionInput, ...func(*sqs.Options)) (*sqs.RemovePermissionOutput, error)) *MockSQSClient_RemovePermission_Call { + _c.Call.Return(run) + return _c +} + +// SendMessage provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) SendMessage(ctx context.Context, params *sqs.SendMessageInput, optFns ...func(*sqs.Options)) (*sqs.SendMessageOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SendMessage") + } + + var r0 *sqs.SendMessageOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.SendMessageInput, ...func(*sqs.Options)) (*sqs.SendMessageOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.SendMessageInput, ...func(*sqs.Options)) *sqs.SendMessageOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.SendMessageOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.SendMessageInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_SendMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMessage' +type MockSQSClient_SendMessage_Call struct { + *mock.Call +} + +// SendMessage is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.SendMessageInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) SendMessage(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_SendMessage_Call { + return &MockSQSClient_SendMessage_Call{Call: _e.mock.On("SendMessage", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_SendMessage_Call) Run(run func(ctx context.Context, params *sqs.SendMessageInput, optFns ...func(*sqs.Options))) *MockSQSClient_SendMessage_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.SendMessageInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_SendMessage_Call) Return(_a0 *sqs.SendMessageOutput, _a1 error) *MockSQSClient_SendMessage_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_SendMessage_Call) RunAndReturn(run func(context.Context, *sqs.SendMessageInput, ...func(*sqs.Options)) (*sqs.SendMessageOutput, error)) *MockSQSClient_SendMessage_Call { + _c.Call.Return(run) + return _c +} + +// SendMessageBatch provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) SendMessageBatch(ctx context.Context, params *sqs.SendMessageBatchInput, optFns ...func(*sqs.Options)) (*sqs.SendMessageBatchOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SendMessageBatch") + } + + var r0 *sqs.SendMessageBatchOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.SendMessageBatchInput, ...func(*sqs.Options)) (*sqs.SendMessageBatchOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.SendMessageBatchInput, ...func(*sqs.Options)) *sqs.SendMessageBatchOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.SendMessageBatchOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.SendMessageBatchInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_SendMessageBatch_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendMessageBatch' +type MockSQSClient_SendMessageBatch_Call struct { + *mock.Call +} + +// SendMessageBatch is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.SendMessageBatchInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) SendMessageBatch(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_SendMessageBatch_Call { + return &MockSQSClient_SendMessageBatch_Call{Call: _e.mock.On("SendMessageBatch", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_SendMessageBatch_Call) Run(run func(ctx context.Context, params *sqs.SendMessageBatchInput, optFns ...func(*sqs.Options))) *MockSQSClient_SendMessageBatch_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.SendMessageBatchInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_SendMessageBatch_Call) Return(_a0 *sqs.SendMessageBatchOutput, _a1 error) *MockSQSClient_SendMessageBatch_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_SendMessageBatch_Call) RunAndReturn(run func(context.Context, *sqs.SendMessageBatchInput, ...func(*sqs.Options)) (*sqs.SendMessageBatchOutput, error)) *MockSQSClient_SendMessageBatch_Call { + _c.Call.Return(run) + return _c +} + +// SetQueueAttributes provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) SetQueueAttributes(ctx context.Context, params *sqs.SetQueueAttributesInput, optFns ...func(*sqs.Options)) (*sqs.SetQueueAttributesOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for SetQueueAttributes") + } + + var r0 *sqs.SetQueueAttributesOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.SetQueueAttributesInput, ...func(*sqs.Options)) (*sqs.SetQueueAttributesOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.SetQueueAttributesInput, ...func(*sqs.Options)) *sqs.SetQueueAttributesOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.SetQueueAttributesOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.SetQueueAttributesInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_SetQueueAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetQueueAttributes' +type MockSQSClient_SetQueueAttributes_Call struct { + *mock.Call +} + +// SetQueueAttributes is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.SetQueueAttributesInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) SetQueueAttributes(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_SetQueueAttributes_Call { + return &MockSQSClient_SetQueueAttributes_Call{Call: _e.mock.On("SetQueueAttributes", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_SetQueueAttributes_Call) Run(run func(ctx context.Context, params *sqs.SetQueueAttributesInput, optFns ...func(*sqs.Options))) *MockSQSClient_SetQueueAttributes_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.SetQueueAttributesInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_SetQueueAttributes_Call) Return(_a0 *sqs.SetQueueAttributesOutput, _a1 error) *MockSQSClient_SetQueueAttributes_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_SetQueueAttributes_Call) RunAndReturn(run func(context.Context, *sqs.SetQueueAttributesInput, ...func(*sqs.Options)) (*sqs.SetQueueAttributesOutput, error)) *MockSQSClient_SetQueueAttributes_Call { + _c.Call.Return(run) + return _c +} + +// TagQueue provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) TagQueue(ctx context.Context, params *sqs.TagQueueInput, optFns ...func(*sqs.Options)) (*sqs.TagQueueOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for TagQueue") + } + + var r0 *sqs.TagQueueOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.TagQueueInput, ...func(*sqs.Options)) (*sqs.TagQueueOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.TagQueueInput, ...func(*sqs.Options)) *sqs.TagQueueOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.TagQueueOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.TagQueueInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_TagQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TagQueue' +type MockSQSClient_TagQueue_Call struct { + *mock.Call +} + +// TagQueue is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.TagQueueInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) TagQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_TagQueue_Call { + return &MockSQSClient_TagQueue_Call{Call: _e.mock.On("TagQueue", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_TagQueue_Call) Run(run func(ctx context.Context, params *sqs.TagQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_TagQueue_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.TagQueueInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_TagQueue_Call) Return(_a0 *sqs.TagQueueOutput, _a1 error) *MockSQSClient_TagQueue_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_TagQueue_Call) RunAndReturn(run func(context.Context, *sqs.TagQueueInput, ...func(*sqs.Options)) (*sqs.TagQueueOutput, error)) *MockSQSClient_TagQueue_Call { + _c.Call.Return(run) + return _c +} + +// UntagQueue provides a mock function with given fields: ctx, params, optFns +func (_m *MockSQSClient) UntagQueue(ctx context.Context, params *sqs.UntagQueueInput, optFns ...func(*sqs.Options)) (*sqs.UntagQueueOutput, error) { + _va := make([]interface{}, len(optFns)) + for _i := range optFns { + _va[_i] = optFns[_i] + } + var _ca []interface{} + _ca = append(_ca, ctx, params) + _ca = append(_ca, _va...) + ret := _m.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for UntagQueue") + } + + var r0 *sqs.UntagQueueOutput + var r1 error + if rf, ok := ret.Get(0).(func(context.Context, *sqs.UntagQueueInput, ...func(*sqs.Options)) (*sqs.UntagQueueOutput, error)); ok { + return rf(ctx, params, optFns...) + } + if rf, ok := ret.Get(0).(func(context.Context, *sqs.UntagQueueInput, ...func(*sqs.Options)) *sqs.UntagQueueOutput); ok { + r0 = rf(ctx, params, optFns...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*sqs.UntagQueueOutput) + } + } + + if rf, ok := ret.Get(1).(func(context.Context, *sqs.UntagQueueInput, ...func(*sqs.Options)) error); ok { + r1 = rf(ctx, params, optFns...) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockSQSClient_UntagQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UntagQueue' +type MockSQSClient_UntagQueue_Call struct { + *mock.Call +} + +// UntagQueue is a helper method to define mock.On call +// - ctx context.Context +// - params *sqs.UntagQueueInput +// - optFns ...func(*sqs.Options) +func (_e *MockSQSClient_Expecter) UntagQueue(ctx interface{}, params interface{}, optFns ...interface{}) *MockSQSClient_UntagQueue_Call { + return &MockSQSClient_UntagQueue_Call{Call: _e.mock.On("UntagQueue", + append([]interface{}{ctx, params}, optFns...)...)} +} + +func (_c *MockSQSClient_UntagQueue_Call) Run(run func(ctx context.Context, params *sqs.UntagQueueInput, optFns ...func(*sqs.Options))) *MockSQSClient_UntagQueue_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]func(*sqs.Options), len(args)-2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(func(*sqs.Options)) + } + } + run(args[0].(context.Context), args[1].(*sqs.UntagQueueInput), variadicArgs...) + }) + return _c +} + +func (_c *MockSQSClient_UntagQueue_Call) Return(_a0 *sqs.UntagQueueOutput, _a1 error) *MockSQSClient_UntagQueue_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockSQSClient_UntagQueue_Call) RunAndReturn(run func(context.Context, *sqs.UntagQueueInput, ...func(*sqs.Options)) (*sqs.UntagQueueOutput, error)) *MockSQSClient_UntagQueue_Call { + _c.Call.Return(run) + return _c +} + +// NewMockSQSClient creates a new instance of MockSQSClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockSQSClient(t interface { + mock.TestingT + Cleanup(func()) +}) *MockSQSClient { + mock := &MockSQSClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/mocks/repository/mock_DBTX.go b/mocks/repository/mock_DBTX.go deleted file mode 100644 index 10dceec2..00000000 --- a/mocks/repository/mock_DBTX.go +++ /dev/null @@ -1,237 +0,0 @@ -// Code generated by mockery v2.46.3. DO NOT EDIT. - -package repository - -import ( - context "context" - - pgconn "github.com/jackc/pgx/v5/pgconn" - mock "github.com/stretchr/testify/mock" - - pgx "github.com/jackc/pgx/v5" -) - -// MockDBTX is an autogenerated mock type for the DBTX type -type MockDBTX struct { - mock.Mock -} - -type MockDBTX_Expecter struct { - mock *mock.Mock -} - -func (_m *MockDBTX) EXPECT() *MockDBTX_Expecter { - return &MockDBTX_Expecter{mock: &_m.Mock} -} - -// Exec provides a mock function with given fields: _a0, _a1, _a2 -func (_m *MockDBTX) Exec(_a0 context.Context, _a1 string, _a2 ...interface{}) (pgconn.CommandTag, error) { - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _a2...) - ret := _m.Called(_ca...) - - if len(ret) == 0 { - panic("no return value specified for Exec") - } - - var r0 pgconn.CommandTag - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) (pgconn.CommandTag, error)); ok { - return rf(_a0, _a1, _a2...) - } - if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) pgconn.CommandTag); ok { - r0 = rf(_a0, _a1, _a2...) - } else { - r0 = ret.Get(0).(pgconn.CommandTag) - } - - if rf, ok := ret.Get(1).(func(context.Context, string, ...interface{}) error); ok { - r1 = rf(_a0, _a1, _a2...) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// MockDBTX_Exec_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exec' -type MockDBTX_Exec_Call struct { - *mock.Call -} - -// Exec is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 string -// - _a2 ...interface{} -func (_e *MockDBTX_Expecter) Exec(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockDBTX_Exec_Call { - return &MockDBTX_Exec_Call{Call: _e.mock.On("Exec", - append([]interface{}{_a0, _a1}, _a2...)...)} -} - -func (_c *MockDBTX_Exec_Call) Run(run func(_a0 context.Context, _a1 string, _a2 ...interface{})) *MockDBTX_Exec_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]interface{}, len(args)-2) - for i, a := range args[2:] { - if a != nil { - variadicArgs[i] = a.(interface{}) - } - } - run(args[0].(context.Context), args[1].(string), variadicArgs...) - }) - return _c -} - -func (_c *MockDBTX_Exec_Call) Return(_a0 pgconn.CommandTag, _a1 error) *MockDBTX_Exec_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *MockDBTX_Exec_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (pgconn.CommandTag, error)) *MockDBTX_Exec_Call { - _c.Call.Return(run) - return _c -} - -// Query provides a mock function with given fields: _a0, _a1, _a2 -func (_m *MockDBTX) Query(_a0 context.Context, _a1 string, _a2 ...interface{}) (pgx.Rows, error) { - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _a2...) - ret := _m.Called(_ca...) - - if len(ret) == 0 { - panic("no return value specified for Query") - } - - var r0 pgx.Rows - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) (pgx.Rows, error)); ok { - return rf(_a0, _a1, _a2...) - } - if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) pgx.Rows); ok { - r0 = rf(_a0, _a1, _a2...) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(pgx.Rows) - } - } - - if rf, ok := ret.Get(1).(func(context.Context, string, ...interface{}) error); ok { - r1 = rf(_a0, _a1, _a2...) - } else { - r1 = ret.Error(1) - } - - return r0, r1 -} - -// MockDBTX_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query' -type MockDBTX_Query_Call struct { - *mock.Call -} - -// Query is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 string -// - _a2 ...interface{} -func (_e *MockDBTX_Expecter) Query(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockDBTX_Query_Call { - return &MockDBTX_Query_Call{Call: _e.mock.On("Query", - append([]interface{}{_a0, _a1}, _a2...)...)} -} - -func (_c *MockDBTX_Query_Call) Run(run func(_a0 context.Context, _a1 string, _a2 ...interface{})) *MockDBTX_Query_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]interface{}, len(args)-2) - for i, a := range args[2:] { - if a != nil { - variadicArgs[i] = a.(interface{}) - } - } - run(args[0].(context.Context), args[1].(string), variadicArgs...) - }) - return _c -} - -func (_c *MockDBTX_Query_Call) Return(_a0 pgx.Rows, _a1 error) *MockDBTX_Query_Call { - _c.Call.Return(_a0, _a1) - return _c -} - -func (_c *MockDBTX_Query_Call) RunAndReturn(run func(context.Context, string, ...interface{}) (pgx.Rows, error)) *MockDBTX_Query_Call { - _c.Call.Return(run) - return _c -} - -// QueryRow provides a mock function with given fields: _a0, _a1, _a2 -func (_m *MockDBTX) QueryRow(_a0 context.Context, _a1 string, _a2 ...interface{}) pgx.Row { - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _a2...) - ret := _m.Called(_ca...) - - if len(ret) == 0 { - panic("no return value specified for QueryRow") - } - - var r0 pgx.Row - if rf, ok := ret.Get(0).(func(context.Context, string, ...interface{}) pgx.Row); ok { - r0 = rf(_a0, _a1, _a2...) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(pgx.Row) - } - } - - return r0 -} - -// MockDBTX_QueryRow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryRow' -type MockDBTX_QueryRow_Call struct { - *mock.Call -} - -// QueryRow is a helper method to define mock.On call -// - _a0 context.Context -// - _a1 string -// - _a2 ...interface{} -func (_e *MockDBTX_Expecter) QueryRow(_a0 interface{}, _a1 interface{}, _a2 ...interface{}) *MockDBTX_QueryRow_Call { - return &MockDBTX_QueryRow_Call{Call: _e.mock.On("QueryRow", - append([]interface{}{_a0, _a1}, _a2...)...)} -} - -func (_c *MockDBTX_QueryRow_Call) Run(run func(_a0 context.Context, _a1 string, _a2 ...interface{})) *MockDBTX_QueryRow_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]interface{}, len(args)-2) - for i, a := range args[2:] { - if a != nil { - variadicArgs[i] = a.(interface{}) - } - } - run(args[0].(context.Context), args[1].(string), variadicArgs...) - }) - return _c -} - -func (_c *MockDBTX_QueryRow_Call) Return(_a0 pgx.Row) *MockDBTX_QueryRow_Call { - _c.Call.Return(_a0) - return _c -} - -func (_c *MockDBTX_QueryRow_Call) RunAndReturn(run func(context.Context, string, ...interface{}) pgx.Row) *MockDBTX_QueryRow_Call { - _c.Call.Return(run) - return _c -} - -// NewMockDBTX creates a new instance of MockDBTX. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewMockDBTX(t interface { - mock.TestingT - Cleanup(func()) -}) *MockDBTX { - mock := &MockDBTX{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} diff --git a/mocks/runner/mock_Controller.go b/mocks/runner/mock_Controller.go new file mode 100644 index 00000000..5659ce81 --- /dev/null +++ b/mocks/runner/mock_Controller.go @@ -0,0 +1,85 @@ +// Code generated by mockery v2.46.3. DO NOT EDIT. + +package runnermock + +import ( + context "context" + + mock "github.com/stretchr/testify/mock" + + types "github.com/aws/aws-sdk-go-v2/service/sqs/types" +) + +// MockController is an autogenerated mock type for the Controller type +type MockController struct { + mock.Mock +} + +type MockController_Expecter struct { + mock *mock.Mock +} + +func (_m *MockController) EXPECT() *MockController_Expecter { + return &MockController_Expecter{mock: &_m.Mock} +} + +// Process provides a mock function with given fields: ctx, message +func (_m *MockController) Process(ctx context.Context, message *types.Message) error { + ret := _m.Called(ctx, message) + + if len(ret) == 0 { + panic("no return value specified for Process") + } + + var r0 error + if rf, ok := ret.Get(0).(func(context.Context, *types.Message) error); ok { + r0 = rf(ctx, message) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// MockController_Process_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Process' +type MockController_Process_Call struct { + *mock.Call +} + +// Process is a helper method to define mock.On call +// - ctx context.Context +// - message *types.Message +func (_e *MockController_Expecter) Process(ctx interface{}, message interface{}) *MockController_Process_Call { + return &MockController_Process_Call{Call: _e.mock.On("Process", ctx, message)} +} + +func (_c *MockController_Process_Call) Run(run func(ctx context.Context, message *types.Message)) *MockController_Process_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(context.Context), args[1].(*types.Message)) + }) + return _c +} + +func (_c *MockController_Process_Call) Return(_a0 error) *MockController_Process_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockController_Process_Call) RunAndReturn(run func(context.Context, *types.Message) error) *MockController_Process_Call { + _c.Call.Return(run) + return _c +} + +// NewMockController creates a new instance of MockController. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockController(t interface { + mock.TestingT + Cleanup(func()) +}) *MockController { + mock := &MockController{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/scripts/tests.yml b/scripts/tests.yml index 8c1b21ac..d7375eeb 100644 --- a/scripts/tests.yml +++ b/scripts/tests.yml @@ -12,6 +12,7 @@ vars: tasks: mocks:generate: cmds: + - rm -rf mocks/* - mockery unit:short: deps: diff --git a/test/docInitRunner/docinitrunner_test.go b/test/docInitRunner/docinitrunner_test.go new file mode 100644 index 00000000..f56d6088 --- /dev/null +++ b/test/docInitRunner/docinitrunner_test.go @@ -0,0 +1,91 @@ +package integration_test + +import ( + "context" + "os" + "path" + documentinit "queryorchestration/internal/document/init" + "queryorchestration/internal/server/queue" + "queryorchestration/internal/test" + queryservice "queryorchestration/pkg/queryService" + "testing" + + "github.com/aws/aws-sdk-go-v2/service/sqs/types" + "github.com/stretchr/testify/assert" +) + +func TestDocInitRunner(t *testing.T) { + ctx := context.Background() + + cfg := test.CreateBaseConfig() + cfg.BasePath = path.Join(os.Getenv("PWD"), "../..") + + network, ncleanup := test.CreateNetwork(t, ctx) + defer ncleanup() + + qcleanup := test.CreateQueueClient(t, ctx, &test.CreateQueueConfig{ + Cfg: cfg, + Network: network, + }) + defer qcleanup() + doccleanurl := test.CreateQueue(t, ctx, cfg, "docclean") + + net, cleanup := test.CreateRunnersAndServicesNetwork(t, ctx, &test.EcosystemNetworkConfig{ + Cfg: cfg, + Network: network, + Runners: []*test.RunnerNetworkConfig{ + { + Name: test.DocInitRunner, + Env: map[string]string{ + "DOCUMENT_CLEAN_URL": doccleanurl, + }, + }, + }, + Services: []*test.ServiceNetworkConfig{ + { + Name: test.QueryService, + }, + }, + }) + defer cleanup() + + qService, err := queryservice.NewClientWithResponses(net.Services[test.QueryService].URI) + assert.NoError(t, err) + + clientRes, err := qService.CreateClientWithResponse(ctx, queryservice.ClientCreate{ + Name: "example_name", + }) + assert.NoError(t, err) + jobRes, err := qService.CreateJobWithResponse(ctx, queryservice.JobCreate{ + ClientId: clientRes.JSON201.Id, + }) + assert.NoError(t, err) + + canSync := true + _, err = qService.UpdateClientWithResponse(ctx, clientRes.JSON201.Id, queryservice.ClientUpdate{ + CanSync: &canSync, + }) + assert.NoError(t, err) + _, err = qService.UpdateJobWithResponse(ctx, jobRes.JSON201.Id, queryservice.JobUpdate{ + CanSync: &canSync, + }) + assert.NoError(t, err) + + document := documentinit.Create{ + JobID: jobRes.JSON201.Id, + Location: "/I/am/here", // TODO + } + + qcfg := &queue.Config{ + URL: net.Runners[test.DocInitRunner].URI, + Client: cfg.QueueClient, + } + + err = queue.Send(ctx, qcfg, document, map[string]types.MessageAttributeValue{}) + assert.NoError(t, err) + + _ = test.AssertMessageWait(t, ctx, &queue.Config{ + URL: doccleanurl, + Client: cfg.GetQueueClient(), + }, []string{}) +} diff --git a/test/queryRunner/queryrunner_test.go b/test/queryRunner/queryrunner_test.go index ec8d8228..f9debf47 100644 --- a/test/queryRunner/queryrunner_test.go +++ b/test/queryRunner/queryrunner_test.go @@ -2,7 +2,6 @@ package integration_test import ( "context" - "encoding/json" "queryorchestration/internal/query" "queryorchestration/internal/server/queue" "queryorchestration/internal/test" @@ -16,7 +15,12 @@ import ( func TestQueryRunner(t *testing.T) { ctx := context.Background() - qCfg, cleanup := test.CreateQueueWithDependencies(t, ctx, "queryRunner") + cfg := test.CreateBaseConfig() + + c, cleanup := test.CreateRunnerNetwork(t, ctx, &test.RunnerNetworkConfig{ + Cfg: cfg, + Name: test.QueryRunner, + }) defer cleanup() document := query.Document{ @@ -25,14 +29,13 @@ func TestQueryRunner(t *testing.T) { CleanVersion: int32(1), TextVersion: int32(1), } - docJson, err := json.Marshal(document) - assert.Nil(t, err) - - cfg := &queue.Config{ - URL: qCfg.URL, - Client: qCfg.Client, + qcfg := &queue.Config{ + URL: c.URI, + Client: cfg.QueueClient, } - err = queue.Send(ctx, cfg, string(docJson), map[string]types.MessageAttributeValue{}) - assert.Nil(t, err) + err := queue.Send(ctx, qcfg, document, map[string]types.MessageAttributeValue{}) + assert.NoError(t, err) + + // TODO - check document output } diff --git a/test/queryService/client_test.go b/test/queryService/client_test.go index d4577b01..447705bf 100644 --- a/test/queryService/client_test.go +++ b/test/queryService/client_test.go @@ -12,23 +12,25 @@ import ( func TestClient(t *testing.T) { ctx := context.Background() - address, cleanup := test.CreateAPIWithDependencies(t, ctx, "queryService") + c, cleanup := test.CreateServiceNetwork(t, ctx, &test.ServiceNetworkConfig{ + Name: test.QueryService, + }) defer cleanup() - client, err := queryservice.NewClientWithResponses(address) - assert.Nil(t, err) + client, err := queryservice.NewClientWithResponses(c.URI) + assert.NoError(t, err) idRes, err := client.CreateClientWithResponse(ctx, queryservice.ClientCreate{ Name: "example_name", }) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, idRes) assert.NotNil(t, idRes.JSON201) assert.NotNil(t, idRes.JSON201.Id) id := idRes.JSON201.Id clientRes, err := client.GetClientWithResponse(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, id, clientRes.JSON200.Id) assert.Equal(t, "example_name", clientRes.JSON200.Name) assert.False(t, clientRes.JSON200.CanSync) @@ -39,11 +41,11 @@ func TestClient(t *testing.T) { Name: &updateName, CanSync: &updateCanSync, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, updateRes) clientRes, err = client.GetClientWithResponse(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, id, clientRes.JSON200.Id) assert.Equal(t, updateName, clientRes.JSON200.Name) assert.True(t, clientRes.JSON200.CanSync) diff --git a/test/queryService/exportservice_test.go b/test/queryService/exportservice_test.go index 22bb4df3..8948de4a 100644 --- a/test/queryService/exportservice_test.go +++ b/test/queryService/exportservice_test.go @@ -12,13 +12,15 @@ import ( func TestExportService(t *testing.T) { ctx := context.Background() - address, cleanup := test.CreateAPIWithDependencies(t, ctx, "queryService") + c, cleanup := test.CreateServiceNetwork(t, ctx, &test.ServiceNetworkConfig{ + Name: test.QueryService, + }) defer cleanup() - client, err := queryservice.NewClientWithResponses(address) - assert.Nil(t, err) + client, err := queryservice.NewClientWithResponses(c.URI) + assert.NoError(t, err) idRes, err := client.TriggerExportWithResponse(ctx, queryservice.ExportTrigger{}) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, idRes) } diff --git a/test/queryService/job_test.go b/test/queryService/job_test.go index 80557dc6..79bdf692 100644 --- a/test/queryService/job_test.go +++ b/test/queryService/job_test.go @@ -12,27 +12,29 @@ import ( func TestJob(t *testing.T) { ctx := context.Background() - address, cleanup := test.CreateAPIWithDependencies(t, ctx, "queryService") + c, cleanup := test.CreateServiceNetwork(t, ctx, &test.ServiceNetworkConfig{ + Name: test.QueryService, + }) defer cleanup() - client, err := queryservice.NewClientWithResponses(address) - assert.Nil(t, err) + client, err := queryservice.NewClientWithResponses(c.URI) + assert.NoError(t, err) clientRes, err := client.CreateClientWithResponse(ctx, queryservice.ClientCreate{ Name: "example_name", }) - assert.Nil(t, err) + assert.NoError(t, err) idRes, err := client.CreateJobWithResponse(ctx, queryservice.JobCreate{ ClientId: clientRes.JSON201.Id, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, idRes) assert.NotNil(t, idRes.JSON201) assert.NotNil(t, idRes.JSON201.Id) id := idRes.JSON201.Id jobRes, err := client.GetJobWithResponse(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, id, jobRes.JSON200.Id) assert.Equal(t, clientRes.JSON201.Id, jobRes.JSON200.ClientId) assert.False(t, jobRes.JSON200.CanSync) @@ -41,11 +43,11 @@ func TestJob(t *testing.T) { updateRes, err := client.UpdateJobWithResponse(ctx, id, queryservice.JobUpdate{ CanSync: &updateCanSync, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, updateRes) jobRes, err = client.GetJobWithResponse(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, id, jobRes.JSON200.Id) assert.Equal(t, clientRes.JSON201.Id, jobRes.JSON200.ClientId) assert.False(t, jobRes.JSON200.CanSync) diff --git a/test/queryService/jobcollectorservice_test.go b/test/queryService/jobcollectorservice_test.go index 1ab12f60..604154e7 100644 --- a/test/queryService/jobcollectorservice_test.go +++ b/test/queryService/jobcollectorservice_test.go @@ -14,16 +14,18 @@ func TestJobCollectorService(t *testing.T) { t.SkipNow() ctx := context.Background() - address, cleanup := test.CreateAPIWithDependencies(t, ctx, "queryService") + c, cleanup := test.CreateServiceNetwork(t, ctx, &test.ServiceNetworkConfig{ + Name: test.QueryService, + }) defer cleanup() - client, err := queryservice.NewClientWithResponses(address) - assert.Nil(t, err) + client, err := queryservice.NewClientWithResponses(c.URI) + assert.NoError(t, err) contextRes, err := client.CreateQueryWithResponse(ctx, queryservice.QueryCreate{ Type: queryservice.CONTEXTFULL, }) - assert.Nil(t, err) + assert.NoError(t, err) jsoncfg := "{\"path\":\"key\"}" jsonRes, err := client.CreateQueryWithResponse(ctx, queryservice.QueryCreate{ @@ -33,16 +35,16 @@ func TestJobCollectorService(t *testing.T) { contextRes.JSON201.Id, }, }) - assert.Nil(t, err) + assert.NoError(t, err) clientRes, err := client.CreateClientWithResponse(ctx, queryservice.ClientCreate{ Name: "example_name", }) - assert.Nil(t, err) + assert.NoError(t, err) jobRes, err := client.CreateJobWithResponse(ctx, queryservice.JobCreate{ ClientId: clientRes.JSON201.Id, }) - assert.Nil(t, err) + assert.NoError(t, err) id := jobRes.JSON201.Id fields := []queryservice.JobCollectorField{ @@ -53,7 +55,7 @@ func TestJobCollectorService(t *testing.T) { } collRes, err := client.GetJobCollectorByJobIdWithResponse(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, id, collRes.JSON200.JobId) assert.Equal(t, 1, collRes.JSON200.ActiveVersion) assert.Equal(t, 1, collRes.JSON200.LatestVersion) @@ -70,11 +72,11 @@ func TestJobCollectorService(t *testing.T) { MinimumTextVersion: &minText, Fields: &fields, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.Nil(t, uRes) collRes, err = client.GetJobCollectorByJobIdWithResponse(ctx, id) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, id, collRes.JSON200.JobId) assert.Equal(t, 2, collRes.JSON200.ActiveVersion) assert.Equal(t, 2, collRes.JSON200.LatestVersion) diff --git a/test/queryService/openapi_test.go b/test/queryService/openapi_test.go index 88c8f49e..ae86dc79 100644 --- a/test/queryService/openapi_test.go +++ b/test/queryService/openapi_test.go @@ -13,21 +13,23 @@ import ( func TestQueryServiceOpenAPI(t *testing.T) { ctx := context.Background() - address, cleanup := test.CreateAPIWithDependencies(t, ctx, "queryService") + c, cleanup := test.CreateServiceNetwork(t, ctx, &test.ServiceNetworkConfig{ + Name: test.QueryService, + }) defer cleanup() - resp, err := http.Get(fmt.Sprintf("%s/swagger/doc.json", address)) - assert.Nil(t, err) + resp, err := http.Get(fmt.Sprintf("%s/swagger/doc.json", c.URI)) + assert.NoError(t, err) assert.NotNil(t, resp) assert.Equal(t, http.StatusOK, resp.StatusCode) - resp, err = http.Get(fmt.Sprintf("%s/swagger/doc.yaml", address)) - assert.Nil(t, err) + resp, err = http.Get(fmt.Sprintf("%s/swagger/doc.yaml", c.URI)) + assert.NoError(t, err) assert.NotNil(t, resp) assert.Equal(t, http.StatusOK, resp.StatusCode) - resp, err = http.Get(fmt.Sprintf("%s/swagger/index.html", address)) - assert.Nil(t, err) + resp, err = http.Get(fmt.Sprintf("%s/swagger/index.html", c.URI)) + assert.NoError(t, err) assert.NotNil(t, resp) assert.Equal(t, http.StatusOK, resp.StatusCode) } diff --git a/test/queryService/queryservice_test.go b/test/queryService/queryservice_test.go index a17dbcad..90f2bab8 100644 --- a/test/queryService/queryservice_test.go +++ b/test/queryService/queryservice_test.go @@ -13,16 +13,18 @@ import ( func TestQueryService(t *testing.T) { ctx := context.Background() - address, cleanup := test.CreateAPIWithDependencies(t, ctx, "queryService") + c, cleanup := test.CreateServiceNetwork(t, ctx, &test.ServiceNetworkConfig{ + Name: test.QueryService, + }) defer cleanup() - client, err := queryservice.NewClientWithResponses(address) - assert.Nil(t, err) + client, err := queryservice.NewClientWithResponses(c.URI) + assert.NoError(t, err) idRes, err := client.CreateQueryWithResponse(ctx, queryservice.QueryCreate{ Type: queryservice.CONTEXTFULL, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, idRes) assert.NotNil(t, idRes.JSON201) contextID := idRes.JSON201.Id @@ -31,11 +33,11 @@ func TestQueryService(t *testing.T) { idRes, err = client.CreateQueryWithResponse(ctx, queryservice.QueryCreate{ Type: queryservice.JSONEXTRACTOR, }) - assert.Nil(t, err) + assert.NoError(t, err) jsonID := idRes.JSON201.Id queryRes, err := client.GetQueryWithResponse(ctx, jsonID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, jsonID, queryRes.JSON200.Id) assert.Equal(t, queryservice.JSONEXTRACTOR, queryRes.JSON200.Type) assert.Equal(t, int32(1), queryRes.JSON200.ActiveVersion) @@ -44,7 +46,7 @@ func TestQueryService(t *testing.T) { assert.Nil(t, queryRes.JSON200.RequiredQueries) queriesRes, err := client.ListQueriesWithResponse(ctx) - assert.Nil(t, err) + assert.NoError(t, err) assert.Len(t, queriesRes.JSON200.Queries, 2) aV := int32(2) @@ -54,11 +56,11 @@ func TestQueryService(t *testing.T) { contextID, }, }) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, res) queryRes, err = client.GetQueryWithResponse(ctx, jsonID) - assert.Nil(t, err) + assert.NoError(t, err) assert.Equal(t, jsonID, queryRes.JSON200.Id) assert.Equal(t, queryservice.JSONEXTRACTOR, queryRes.JSON200.Type) assert.Equal(t, int32(2), queryRes.JSON200.ActiveVersion) diff --git a/test/queryService/testquery_test.go b/test/queryService/testquery_test.go index 2d5b2c41..4641d7fa 100644 --- a/test/queryService/testquery_test.go +++ b/test/queryService/testquery_test.go @@ -13,16 +13,18 @@ import ( func TestQueryServiceTest(t *testing.T) { ctx := context.Background() - address, cleanup := test.CreateAPIWithDependencies(t, ctx, "queryService") + c, cleanup := test.CreateServiceNetwork(t, ctx, &test.ServiceNetworkConfig{ + Name: test.QueryService, + }) defer cleanup() - client, err := queryservice.NewClientWithResponses(address) - assert.Nil(t, err) + client, err := queryservice.NewClientWithResponses(c.URI) + assert.NoError(t, err) idRes, err := client.CreateQueryWithResponse(ctx, queryservice.QueryCreate{ Type: queryservice.CONTEXTFULL, }) - assert.Nil(t, err) + assert.NoError(t, err) id := idRes.JSON201.Id assert.NotEmpty(t, id) @@ -32,7 +34,7 @@ func TestQueryServiceTest(t *testing.T) { DocumentId: docId, QueryVersion: int32(1), }) - assert.Nil(t, err) + assert.NoError(t, err) assert.NotNil(t, testRes) // TODO // assert.NotNil(t, testRes.JSON200)