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

@@ -1,6 +1,6 @@
 @@@Owners @"Michael McGuinness"
 
-@@@Backend @@Owners
+@@@Backend @@Owners @"Jay Brown"
 @@@Infrastructure @@Owners
 
 **/*.go @@Backend

.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:

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

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

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 {

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

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

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

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

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

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,

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

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)

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

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

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

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",

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

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",

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 = "###"

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

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

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

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

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)

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",

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,

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)

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,

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,

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{
 		{

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

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{
 		{

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

internal/document/create.go

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

internal/document/create_test.go

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

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

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

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

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,
+	}
+}

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

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

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

internal/job/collector/createprivate_test.go

@@ -47,7 +47,7 @@ func TestGetCreateParams(t *testing.T) {
 	)
 
 	dbparams, err := svc.getCreateParams(ctx, &params)
-	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, &params)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, id, aid)
 }

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

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

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

internal/job/collector/updateprivate_test.go

@@ -55,7 +55,7 @@ func TestGetUpdateParams(t *testing.T) {
 	)
 
 	dbparams, err := svc.getUpdateParams(ctx, &current, &params)
-	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, &current, &params)
-	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(&current, nil)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	update := UpdateParams{}
 
 	err = svc.normalizeActiveVersion(&current, &update)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Nil(t, update.ActiveVersion)
 
 	update.ActiveVersion = &current.ActiveVersion
 	err = svc.normalizeActiveVersion(&current, &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(&current, &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(&current, nil)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	update := UpdateParams{}
 
 	err = svc.normalizeCodeVersions(&current, &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(&current, &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(&current, &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(&current, &update)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Nil(t, update.MinCleanVersion)
 	assert.Nil(t, update.MinTextVersion)
 
 	update.MinCleanVersion = &current.MinCleanVersion
 	update.MinTextVersion = nil
 	err = svc.normalizeCodeVersions(&current, &update)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Nil(t, update.MinCleanVersion)
 	assert.Nil(t, update.MinTextVersion)
 
 	update.MinCleanVersion = nil
 	update.MinTextVersion = &current.MinTextVersion
 	err = svc.normalizeCodeVersions(&current, &update)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Nil(t, update.MinCleanVersion)
 	assert.Nil(t, update.MinTextVersion)
 
 	update.MinCleanVersion = &current.MinCleanVersion
 	update.MinTextVersion = &current.MinTextVersion
 	err = svc.normalizeCodeVersions(&current, &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 = &current.MinTextVersion
 	err = svc.normalizeCodeVersions(&current, &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(&current, &update)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, cv, *update.MinCleanVersion)
 	assert.Equal(t, tv, *update.MinTextVersion)
 }

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

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,

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

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

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"

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,

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

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

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(&current, nil)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	err = s.normalizeActiveVersion(&current, &entity)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 
 	entity.ActiveVersion = &current.ActiveVersion
 	err = s.normalizeActiveVersion(&current, &entity)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Nil(t, entity.ActiveVersion)
 
 	aV := current.ActiveVersion + 1
 	entity.ActiveVersion = &aV
 	err = s.normalizeActiveVersion(&current, &entity)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, aV, *entity.ActiveVersion)
 
 	aV = current.LatestVersion + 2

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

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

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)

internal/query/result/process_test.go

@@ -56,7 +56,7 @@ func TestProcess(t *testing.T) {
 	)
 
 	val, err := svc.Process(ctx, &params)
-	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, &params)
-	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))

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

internal/query/result/set_test.go

@@ -61,6 +61,6 @@ func TestSet(t *testing.T) {
 		)
 
 	id, err := svc.Set(ctx, &params)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, rid, id)
 }

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

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

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

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{

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

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

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

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

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,

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 }

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)

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

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
 }

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

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

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

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
 }

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

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

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

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

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,

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
 }

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

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(&param, 1, 1, 1)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Nil(t, param)
 
 	updated := int32(1)
 	param = &updated
 	err = validation.NormalizeInClosedInterval(&param, 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(&param, 1, 1, 3)
-	assert.Nil(t, err)
+	assert.NoError(t, err)
 	assert.Equal(t, int32(2), updated)
 }

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

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
 }

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

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

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)

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

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)

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

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

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

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"])
+}

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
 }