From f230465523a56ce240758e3bf3f615592f211688 Mon Sep 17 00:00:00 2001 From: Michael McGuinness Date: Mon, 6 Jan 2025 13:30:20 +0000 Subject: [PATCH] fixexistingtests --- internal/database/pool.go | 9 +- internal/query/update.go | 5 +- test/integration/queryrunner_test.go | 2 +- test/unit/internal/collector/service_test.go | 31 +++---- test/unit/internal/document/sync_test.go | 76 +++++++++-------- .../internal/jsonextractor/process_test.go | 52 +++++++----- test/unit/internal/query/get_test.go | 25 +++--- test/unit/internal/query/parse_test.go | 10 +-- test/unit/internal/query/service_test.go | 16 ++-- test/unit/internal/queryQueue/queue_test.go | 83 +++++++++---------- test/unit/internal/result/store_test.go | 13 ++- 11 files changed, 172 insertions(+), 150 deletions(-) diff --git a/internal/database/pool.go b/internal/database/pool.go index 576d6d75..5324c664 100644 --- a/internal/database/pool.go +++ b/internal/database/pool.go @@ -1,12 +1,17 @@ package database import ( + "context" "queryorchestration/internal/database/repository" - "github.com/jackc/pgx/v5/pgxpool" + "github.com/jackc/pgx/v5" ) +type Pool interface { + Begin(ctx context.Context) (pgx.Tx, error) +} + type Connection struct { - Pool *pgxpool.Pool + Pool Pool Queries *repository.Queries } diff --git a/internal/query/update.go b/internal/query/update.go index 4c646f25..516150c9 100644 --- a/internal/query/update.go +++ b/internal/query/update.go @@ -24,9 +24,12 @@ func (s *Service) Update(ctx context.Context, entity *queryprocessor.Update) err return err } + return nil +} + +func (s *Service) submitUpdate(ctx *context.Context, entity *queryprocessor.Update) error { // TODO - generate new entity // TODO - submit update - id, type, activeversion, requiredQueryId, Config - return nil } diff --git a/test/integration/queryrunner_test.go b/test/integration/queryrunner_test.go index d01e511e..078911d7 100644 --- a/test/integration/queryrunner_test.go +++ b/test/integration/queryrunner_test.go @@ -19,7 +19,7 @@ func TestName(t *testing.T) { document := document.Document{ ID: uuid.New(), JobID: uuid.New(), - Name: "document_name", + Name: "documentname", CleanVersion: int32(1), TextVersion: int32(1), } diff --git a/test/unit/internal/collector/service_test.go b/test/unit/internal/collector/service_test.go index e0789dfe..8d307cda 100644 --- a/test/unit/internal/collector/service_test.go +++ b/test/unit/internal/collector/service_test.go @@ -13,29 +13,32 @@ import ( ) func TestService(t *testing.T) { - ctx := context.Background() - - db, err := pgxmock.NewConn() + pool, err := pgxmock.NewPool() if err != nil { t.Fatalf("failed to open pgxmock database: %v", err) } - defer db.Close(ctx) + queries := repository.New(pool) + db := &database.Connection{ + Queries: queries, + Pool: pool, + } - queries := repository.New(db) - svc := collector.New(queries) + svc := collector.New(db) assert.NotNil(t, svc) } func TestByJobId(t *testing.T) { ctx := context.Background() - db, err := pgxmock.NewConn() + pool, err := pgxmock.NewPool() if err != nil { t.Fatalf("failed to open pgxmock database: %v", err) } - defer db.Close(ctx) - - queries := repository.New(db) + queries := repository.New(pool) + db := &database.Connection{ + Queries: queries, + Pool: pool, + } jobID := uuid.New() fullCollector := collector.Collector{ @@ -44,21 +47,21 @@ func TestByJobId(t *testing.T) { MinTextVersion: int32(1), } - db.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(database.MustToDBUUID(jobID)). + pool.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(database.MustToDBUUID(jobID)). WillReturnRows( pgxmock.NewRows([]string{"id", "jobId", "minCleanVersion", "minTextVersion"}). AddRow(database.MustToDBUUID(fullCollector.ID), database.MustToDBUUID(jobID), fullCollector.MinCleanVersion, fullCollector.MinTextVersion), ) - coll, err := collector.NewByJobId(ctx, queries, jobID) + coll, err := collector.NewByJobId(ctx, db, jobID) assert.Nil(t, err) assert.EqualExportedValues(t, fullCollector, *coll) - db.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(database.MustToDBUUID(jobID)). + pool.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(database.MustToDBUUID(jobID)). WillReturnRows( pgxmock.NewRows([]string{"id", "jobId", "minCleanVersion", "minTextVersion"}), ) - _, err = collector.NewByJobId(ctx, queries, jobID) + _, err = collector.NewByJobId(ctx, db, jobID) assert.EqualError(t, err, "no rows in result set") } diff --git a/test/unit/internal/document/sync_test.go b/test/unit/internal/document/sync_test.go index dafb210d..298f5ea2 100644 --- a/test/unit/internal/document/sync_test.go +++ b/test/unit/internal/document/sync_test.go @@ -17,13 +17,15 @@ import ( func TestSyncIsSynced(t *testing.T) { ctx := context.Background() - db, err := pgxmock.NewConn() + pool, err := pgxmock.NewPool() if err != nil { t.Fatalf("failed to open pgxmock database: %v", err) } - defer db.Close(ctx) - - queries := repository.New(db) + queries := repository.New(pool) + db := &database.Connection{ + Queries: queries, + Pool: pool, + } doc := document.Document{ ID: uuid.New(), @@ -36,23 +38,23 @@ func TestSyncIsSynced(t *testing.T) { minCleanVersion := int32(1) minTextVersion := int32(1) - db.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). + pool.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). WillReturnRows( pgxmock.NewRows([]string{"id", "jobId", "minCleanVersion", "minTextVersion"}). AddRow(dbCollectorId, dbJobID, minCleanVersion, minTextVersion), ) - db.ExpectQuery("name: ListResultsByDocumentID :many").WithArgs(database.MustToDBUUID(doc.ID), minCleanVersion, minTextVersion). + pool.ExpectQuery("name: ListResultsByDocumentID :many").WithArgs(database.MustToDBUUID(doc.ID), minCleanVersion, minTextVersion). WillReturnRows( pgxmock.NewRows([]string{"id", "queryId", "queryVersion"}). AddRow(pgtype.UUID{}, pgtype.UUID{}, int32(1)), ) - db.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorId). + pool.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorId). WillReturnRows( pgxmock.NewRows([]string{"collectorId", "queryId", "type", "queryVersion", "requiredIds"}). AddRow(dbCollectorId, pgtype.UUID{}, repository.NullQuerytype{Querytype: repository.QuerytypeJsonExtractor, Valid: true}, pgtype.Int4{Int32: int32(1), Valid: true}, []pgtype.UUID{}), ) - docSvc := document.New(queries) + docSvc := document.New(db) err = docSvc.Sync(ctx, &doc) assert.Nil(t, err) } @@ -60,13 +62,15 @@ func TestSyncIsSynced(t *testing.T) { func TestSyncDBFail(t *testing.T) { ctx := context.Background() - db, err := pgxmock.NewConn() + pool, err := pgxmock.NewPool() if err != nil { t.Fatalf("failed to open pgxmock database: %v", err) } - defer db.Close(ctx) - - queries := repository.New(db) + queries := repository.New(pool) + db := &database.Connection{ + Queries: queries, + Pool: pool, + } doc := document.Document{ ID: uuid.New(), @@ -80,64 +84,64 @@ func TestSyncDBFail(t *testing.T) { minCleanVersion := int32(1) minTextVersion := int32(1) - db.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). + pool.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). WillReturnRows( pgxmock.NewRows([]string{"id", "jobId", "minCleanVersion", "minTextVersion"}), ) - docSvc := document.New(queries) + docSvc := document.New(db) err = docSvc.Sync(ctx, &doc) assert.EqualError(t, err, "no rows in result set") - db.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). + pool.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). WillReturnRows( pgxmock.NewRows([]string{"id", "jobId", "minCleanVersion", "minTextVersion"}). AddRow(dbCollectorId, dbJobID, minCleanVersion, minTextVersion), ) errr := "database failure" - db.ExpectQuery("name: ListResultsByDocumentID :many").WithArgs(database.MustToDBUUID(doc.ID), minCleanVersion, minTextVersion). + pool.ExpectQuery("name: ListResultsByDocumentID :many").WithArgs(database.MustToDBUUID(doc.ID), minCleanVersion, minTextVersion). WillReturnError(errors.New(errr)) - docSvc = document.New(queries) + docSvc = document.New(db) err = docSvc.Sync(ctx, &doc) assert.EqualError(t, err, errr) - db.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). + pool.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). WillReturnRows( pgxmock.NewRows([]string{"id", "jobId", "minCleanVersion", "minTextVersion"}). AddRow(dbCollectorId, dbJobID, minCleanVersion, minTextVersion), ) - db.ExpectQuery("name: ListResultsByDocumentID :many").WithArgs(database.MustToDBUUID(doc.ID), minCleanVersion, minTextVersion). + pool.ExpectQuery("name: ListResultsByDocumentID :many").WithArgs(database.MustToDBUUID(doc.ID), minCleanVersion, minTextVersion). WillReturnRows( pgxmock.NewRows([]string{"id", "queryId", "queryVersion"}), ) errr = "database failure" - db.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorId). + pool.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorId). WillReturnError(errors.New(errr)) - docSvc = document.New(queries) + docSvc = document.New(db) err = docSvc.Sync(ctx, &doc) assert.EqualError(t, err, errr) - db.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). + pool.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). WillReturnRows( pgxmock.NewRows([]string{"id", "jobId", "minCleanVersion", "minTextVersion"}). AddRow(dbCollectorId, dbJobID, minCleanVersion, minTextVersion), ) - db.ExpectQuery("name: ListResultsByDocumentID :many").WithArgs(database.MustToDBUUID(doc.ID), minCleanVersion, minTextVersion). + pool.ExpectQuery("name: ListResultsByDocumentID :many").WithArgs(database.MustToDBUUID(doc.ID), minCleanVersion, minTextVersion). WillReturnRows( pgxmock.NewRows([]string{"id", "queryId", "queryVersion"}), ) errr = "database failure" - db.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorId). + pool.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorId). WillReturnRows( pgxmock.NewRows([]string{"collectorId", "queryId", "type", "queryVersion", "requiredIds"}). AddRow(dbCollectorId, dbQueryID, repository.NullQuerytype{Querytype: repository.QuerytypeJsonExtractor, Valid: true}, pgtype.Int4{Int32: int32(1), Valid: true}, []pgtype.UUID{}), ) - db.ExpectQuery("name: ListResultValuesByID :many").WithArgs([]pgtype.UUID{}). + pool.ExpectQuery("name: ListResultValuesByID :many").WithArgs([]pgtype.UUID{}). WillReturnError(errors.New(errr)) - docSvc = document.New(queries) + docSvc = document.New(db) err = docSvc.Sync(ctx, &doc) assert.EqualError(t, err, errr) } @@ -145,13 +149,15 @@ func TestSyncDBFail(t *testing.T) { func TestSync(t *testing.T) { ctx := context.Background() - db, err := pgxmock.NewConn() + pool, err := pgxmock.NewPool() if err != nil { t.Fatalf("failed to open pgxmock database: %v", err) } - defer db.Close(ctx) - - queries := repository.New(db) + queries := repository.New(pool) + db := &database.Connection{ + Queries: queries, + Pool: pool, + } doc := document.Document{ ID: uuid.New(), @@ -165,26 +171,26 @@ func TestSync(t *testing.T) { minCleanVersion := int32(1) minTextVersion := int32(1) - db.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). + pool.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). WillReturnRows( pgxmock.NewRows([]string{"id", "jobId", "minCleanVersion", "minTextVersion"}). AddRow(dbCollectorId, dbJobID, minCleanVersion, minTextVersion), ) - db.ExpectQuery("name: ListResultsByDocumentID :many").WithArgs(database.MustToDBUUID(doc.ID), minCleanVersion, minTextVersion). + pool.ExpectQuery("name: ListResultsByDocumentID :many").WithArgs(database.MustToDBUUID(doc.ID), minCleanVersion, minTextVersion). WillReturnRows( pgxmock.NewRows([]string{"id", "queryId", "queryVersion"}), ) - db.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorId). + pool.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorId). WillReturnRows( pgxmock.NewRows([]string{"collectorId", "queryId", "type", "queryVersion", "requiredIds"}). AddRow(dbCollectorId, dbQueryID, repository.NullQuerytype{Querytype: repository.QuerytypeJsonExtractor, Valid: true}, pgtype.Int4{Int32: int32(1), Valid: true}, []pgtype.UUID{}), ) - db.ExpectQuery("name: ListResultValuesByID :many").WithArgs([]pgtype.UUID{}). + pool.ExpectQuery("name: ListResultValuesByID :many").WithArgs([]pgtype.UUID{}). WillReturnRows( pgxmock.NewRows([]string{"id", "queryId", "value"}), ) - docSvc := document.New(queries) + docSvc := document.New(db) err = docSvc.Sync(ctx, &doc) assert.EqualError(t, err, "JSON Extraction requires 1 result") } diff --git a/test/unit/internal/jsonextractor/process_test.go b/test/unit/internal/jsonextractor/process_test.go index 0cfe4221..a99a84a1 100644 --- a/test/unit/internal/jsonextractor/process_test.go +++ b/test/unit/internal/jsonextractor/process_test.go @@ -20,15 +20,17 @@ import ( func TestJSONProcess(t *testing.T) { ctx := context.Background() - db, err := pgxmock.NewConn() + pool, err := pgxmock.NewPool() if err != nil { t.Fatalf("failed to open pgxmock database: %v", err) } - defer db.Close(ctx) + queries := repository.New(pool) + db := &database.Connection{ + Queries: queries, + Pool: pool, + } - queries := repository.New(db) - - extractor := jsonextractor.NewExtractor(queries) + extractor := jsonextractor.NewExtractor(db) query := queryprocessor.Query{ ID: uuid.New(), @@ -45,7 +47,7 @@ func TestJSONProcess(t *testing.T) { config := "{\"path\":\"key\"}" - db.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). + pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). WillReturnRows( pgxmock.NewRows([]string{"id", "config"}). AddRow(pgtype.UUID{}, []byte(config)), @@ -60,7 +62,7 @@ func TestJSONProcess(t *testing.T) { values = &[]result.Value{ contextfull.NewResult(jsonString), } - db.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). + pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). WillReturnRows( pgxmock.NewRows([]string{"id", "config"}). AddRow(pgtype.UUID{}, []byte(config)), @@ -75,7 +77,7 @@ func TestJSONProcess(t *testing.T) { values = &[]result.Value{ contextfull.NewResult(jsonString), } - db.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). + pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). WillReturnRows( pgxmock.NewRows([]string{"id", "config"}). AddRow(pgtype.UUID{}, []byte(config)), @@ -89,15 +91,17 @@ func TestJSONProcess(t *testing.T) { func TestJSONProcessJSON(t *testing.T) { ctx := context.Background() - db, err := pgxmock.NewConn() + pool, err := pgxmock.NewPool() if err != nil { t.Fatalf("failed to open pgxmock database: %v", err) } - defer db.Close(ctx) + queries := repository.New(pool) + db := &database.Connection{ + Queries: queries, + Pool: pool, + } - queries := repository.New(db) - - extractor := jsonextractor.NewExtractor(queries) + extractor := jsonextractor.NewExtractor(db) query := queryprocessor.Query{ ID: uuid.New(), @@ -114,7 +118,7 @@ func TestJSONProcessJSON(t *testing.T) { config := "{\"path\":\"invalid_key\"}" - db.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). + pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). WillReturnRows( pgxmock.NewRows([]string{"id", "config"}). AddRow(pgtype.UUID{}, []byte(config)), @@ -126,7 +130,7 @@ func TestJSONProcessJSON(t *testing.T) { config = "" - db.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). + pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). WillReturnRows( pgxmock.NewRows([]string{"id", "config"}). AddRow(pgtype.UUID{}, []byte(config)), @@ -138,7 +142,7 @@ func TestJSONProcessJSON(t *testing.T) { config = "{\"path\":\"\"}" - db.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). + pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). WillReturnRows( pgxmock.NewRows([]string{"id", "config"}). AddRow(pgtype.UUID{}, []byte(config)), @@ -150,7 +154,7 @@ func TestJSONProcessJSON(t *testing.T) { config = "{\"path\":}" - db.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). + pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). WillReturnRows( pgxmock.NewRows([]string{"id", "config"}). AddRow(pgtype.UUID{}, []byte(config)), @@ -162,7 +166,7 @@ func TestJSONProcessJSON(t *testing.T) { config = "{\"path\":\"key\"}" - db.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). + pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(query.ID), query.Version). WillReturnRows( pgxmock.NewRows([]string{"id", "config"}), ) @@ -175,15 +179,17 @@ func TestJSONProcessJSON(t *testing.T) { func TestJSONProcessResults(t *testing.T) { ctx := context.Background() - db, err := pgxmock.NewConn() + pool, err := pgxmock.NewPool() if err != nil { t.Fatalf("failed to open pgxmock database: %v", err) } - defer db.Close(ctx) + queries := repository.New(pool) + db := &database.Connection{ + Queries: queries, + Pool: pool, + } - queries := repository.New(db) - - extractor := jsonextractor.NewExtractor(queries) + extractor := jsonextractor.NewExtractor(db) query := queryprocessor.Query{ ID: uuid.New(), diff --git a/test/unit/internal/query/get_test.go b/test/unit/internal/query/get_test.go index 9d47d08c..1f038670 100644 --- a/test/unit/internal/query/get_test.go +++ b/test/unit/internal/query/get_test.go @@ -17,20 +17,23 @@ import ( func TestGet(t *testing.T) { ctx := context.Background() - db, err := pgxmock.NewConn() + pool, err := pgxmock.NewPool() if err != nil { t.Fatalf("failed to open pgxmock database: %v", err) } - defer db.Close(ctx) - - queries := repository.New(db) - svc := query.New(queries) + queries := repository.New(pool) + db := &database.Connection{ + Queries: queries, + Pool: pool, + } + svc := query.New(db) config := "{\"path\":\"example_path\"}" query := query.Query{ - ID: uuid.New(), - Type: queryprocessor.TypeJsonExtractor, - Version: int32(1), + ID: uuid.New(), + Type: queryprocessor.TypeJsonExtractor, + ActiveVersion: int32(1), + LatestVersion: int32(1), RequiredQueryIDs: []uuid.UUID{ uuid.New(), }, @@ -42,9 +45,9 @@ func TestGet(t *testing.T) { dbReqIDs[index] = database.MustToDBUUID(id) } - db.ExpectQuery("name: GetQuery :one").WithArgs(database.MustToDBUUID(query.ID)).WillReturnRows( - pgxmock.NewRows([]string{"id", "type", "activeVersion", "config", "requiredIds"}). - AddRow(database.MustToDBUUID(query.ID), repository.QuerytypeJsonExtractor, int32(1), []byte(config), dbReqIDs), + pool.ExpectQuery("name: GetQuery :one").WithArgs(database.MustToDBUUID(query.ID)).WillReturnRows( + pgxmock.NewRows([]string{"id", "type", "activeVersion", "latestVersion", "config", "requiredIds"}). + AddRow(database.MustToDBUUID(query.ID), repository.QuerytypeJsonExtractor, query.ActiveVersion, query.LatestVersion, []byte(config), dbReqIDs), ) returnQuery, err := svc.Get(ctx, query.ID) diff --git a/test/unit/internal/query/parse_test.go b/test/unit/internal/query/parse_test.go index 5c423173..67869f91 100644 --- a/test/unit/internal/query/parse_test.go +++ b/test/unit/internal/query/parse_test.go @@ -10,7 +10,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestParseDBQueryRow(t *testing.T) { +func TestParseDBCollectorQuery(t *testing.T) { dbResult := repository.GetCollectorQueriesRow{ Collectorid: pgtype.UUID{}, Queryid: pgtype.UUID{}, @@ -18,7 +18,7 @@ func TestParseDBQueryRow(t *testing.T) { Type: repository.NullQuerytype{Valid: true, Querytype: repository.QuerytypeJsonExtractor}, Queryversion: pgtype.Int4{}, } - value, err := queryprocessor.ParseDBQuery(&dbResult) + value, err := queryprocessor.ParseDBCollectorQuery(&dbResult) assert.Nil(t, err) assert.Equal(t, uuid.Nil, value.ID) assert.Equal(t, []uuid.UUID{}, value.RequiredQueryIDs) @@ -26,7 +26,7 @@ func TestParseDBQueryRow(t *testing.T) { assert.Equal(t, queryprocessor.Type(queryprocessor.TypeJsonExtractor), value.Type) dbResult.Type = repository.NullQuerytype{} - _, err = queryprocessor.ParseDBQuery(&dbResult) + _, err = queryprocessor.ParseDBCollectorQuery(&dbResult) assert.EqualError(t, err, "invalid database query type") } @@ -61,7 +61,7 @@ func TestToDBQueryType(t *testing.T) { dbQueryType := queryprocessor.Type(queryprocessor.TypeJsonExtractor) value, err := queryprocessor.ToDBQueryType(dbQueryType) assert.Nil(t, err) - assert.Equal(t, repository.NullQuerytype{Querytype: repository.QuerytypeJsonExtractor, Valid: true}, value) + assert.Equal(t, repository.Querytype(repository.QuerytypeJsonExtractor), value) dbQueryType = queryprocessor.Type(-1) _, err = queryprocessor.ToDBQueryType(dbQueryType) @@ -70,5 +70,5 @@ func TestToDBQueryType(t *testing.T) { dbQueryType = queryprocessor.Type(queryprocessor.TypeContextFull) value, err = queryprocessor.ToDBQueryType(dbQueryType) assert.Nil(t, err) - assert.Equal(t, repository.NullQuerytype{Querytype: repository.QuerytypeContextFull, Valid: true}, value) + assert.Equal(t, repository.Querytype(repository.QuerytypeContextFull), value) } diff --git a/test/unit/internal/query/service_test.go b/test/unit/internal/query/service_test.go index 23111b58..cd5f43ca 100644 --- a/test/unit/internal/query/service_test.go +++ b/test/unit/internal/query/service_test.go @@ -1,7 +1,7 @@ package document_test import ( - "context" + "queryorchestration/internal/database" "queryorchestration/internal/database/repository" "queryorchestration/internal/query" "testing" @@ -11,15 +11,15 @@ import ( ) func TestService(t *testing.T) { - ctx := context.Background() - - db, err := pgxmock.NewConn() + pool, err := pgxmock.NewPool() if err != nil { t.Fatalf("failed to open pgxmock database: %v", err) } - defer db.Close(ctx) - - queries := repository.New(db) - svc := query.New(queries) + queries := repository.New(pool) + db := &database.Connection{ + Queries: queries, + Pool: pool, + } + svc := query.New(db) assert.NotNil(t, svc) } diff --git a/test/unit/internal/queryQueue/queue_test.go b/test/unit/internal/queryQueue/queue_test.go index e2284933..4e6683a8 100644 --- a/test/unit/internal/queryQueue/queue_test.go +++ b/test/unit/internal/queryQueue/queue_test.go @@ -21,25 +21,27 @@ import ( func TestQueue(t *testing.T) { ctx := context.Background() - db, err := pgxmock.NewConn() + pool, err := pgxmock.NewPool() if err != nil { t.Fatalf("failed to open pgxmock database: %v", err) } - defer db.Close(ctx) - - queries := repository.New(db) + queries := repository.New(pool) + db := &database.Connection{ + Queries: queries, + Pool: pool, + } jobID := uuid.New() dbJobID := database.MustToDBUUID(jobID) collectorID := uuid.New() dbCollectorID := database.MustToDBUUID(collectorID) - db.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). + pool.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). WillReturnRows( pgxmock.NewRows([]string{"id", "jobId", "minCleanVersion", "minTextVersion"}). AddRow(dbCollectorID, dbJobID, int32(1), int32(1)), ) - coll, err := collector.NewByJobId(ctx, queries, jobID) + coll, err := collector.NewByJobId(ctx, db, jobID) assert.Nil(t, err) queryOneID := uuid.New() @@ -73,13 +75,13 @@ func TestQueue(t *testing.T) { for index, id := range q.RequiredQueryIDs { dbReqIDs[index] = database.MustToDBUUID(id) } - ty, err := queryprocessor.ToDBQueryType(q.Type) + ty, err := queryprocessor.ToDBNullQueryType(q.Type) assert.Nil(t, err) rows = rows. AddRow(dbCollectorID, dbID, ty, pgtype.Int4{Int32: int32(q.Version), Valid: true}, dbReqIDs) } - db.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorID).WillReturnRows(rows) + pool.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorID).WillReturnRows(rows) contextResultID := uuid.New() results := []result.Result{ @@ -101,7 +103,7 @@ func TestQueue(t *testing.T) { cleanVersion := int32(1) textVersion := int32(1) - q, err := queryQueue.New(ctx, queries, coll, &results, docID, cleanVersion, textVersion) + q, err := queryQueue.New(ctx, db, coll, &results, docID, cleanVersion, textVersion) assert.Nil(t, err) assert.Equal(t, expectedQueries, q.GetQueue()) @@ -111,74 +113,69 @@ func TestQueue(t *testing.T) { valueLayerOne := fmt.Sprintf("{\"%s\":\"%s\"}", keyLayerTwo, valueLayerTwo) valueContext := fmt.Sprintf("{\"%s\":%s}", keyLayerOne, valueLayerOne) - db.ExpectQuery("name: ListResultValuesByID :many").WithArgs([]pgtype.UUID{database.MustToDBUUID(contextResultID)}).WillReturnRows( + pool.ExpectQuery("name: ListResultValuesByID :many").WithArgs([]pgtype.UUID{database.MustToDBUUID(contextResultID)}).WillReturnRows( pgxmock.NewRows([]string{"id", "queryId", "value"}). AddRow(database.MustToDBUUID(contextResultID), database.MustToDBUUID(contextID), valueContext), ) - db.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(querySixID), querySixVersion).WillReturnRows( + pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(querySixID), querySixVersion).WillReturnRows( pgxmock.NewRows([]string{"id", "config"}). AddRow(pgtype.UUID{}, []byte(fmt.Sprintf("{\"path\":\"%s\"}", keyLayerOne))), ) - db.ExpectQuery("name: SetResult :one").WithArgs(database.MustToDBUUID(querySixID), database.MustToDBUUID(docID), valueLayerOne, cleanVersion, textVersion, querySixVersion). + pool.ExpectQuery("name: SetResult :one").WithArgs(database.MustToDBUUID(querySixID), database.MustToDBUUID(docID), valueLayerOne, cleanVersion, textVersion, querySixVersion). WillReturnRows( - pgxmock.NewRows([]string{"id"}). - AddRow(pgtype.UUID{}), + pgxmock.NewRows([]string{"id"}).AddRow(pgtype.UUID{}), ) - db.ExpectQuery("name: ListResultValuesByID :many").WithArgs(pgxmock.AnyArg()).WillReturnRows( + pool.ExpectQuery("name: ListResultValuesByID :many").WithArgs(pgxmock.AnyArg()).WillReturnRows( pgxmock.NewRows([]string{"id", "queryId", "value"}). AddRow(pgtype.UUID{}, database.MustToDBUUID(querySixID), valueLayerOne), ) - db.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(queryFiveID), queryFiveVersion).WillReturnRows( + pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(queryFiveID), queryFiveVersion).WillReturnRows( pgxmock.NewRows([]string{"id", "config"}). AddRow(pgtype.UUID{}, []byte(fmt.Sprintf("{\"path\":\"%s\"}", keyLayerTwo))), ) - db.ExpectQuery("name: SetResult :one").WithArgs(database.MustToDBUUID(queryFiveID), database.MustToDBUUID(docID), valueLayerTwo, cleanVersion, textVersion, queryFiveVersion). + pool.ExpectQuery("name: SetResult :one").WithArgs(database.MustToDBUUID(queryFiveID), database.MustToDBUUID(docID), valueLayerTwo, cleanVersion, textVersion, queryFiveVersion). WillReturnRows( - pgxmock.NewRows([]string{"id"}). - AddRow(pgtype.UUID{}), + pgxmock.NewRows([]string{"id"}).AddRow(pgtype.UUID{}), ) - db.ExpectQuery("name: ListResultValuesByID :many").WithArgs(pgxmock.AnyArg()).WillReturnRows( + pool.ExpectQuery("name: ListResultValuesByID :many").WithArgs(pgxmock.AnyArg()).WillReturnRows( pgxmock.NewRows([]string{"id", "queryId", "value"}). AddRow(database.MustToDBUUID(contextResultID), database.MustToDBUUID(contextID), valueContext), ) - db.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(queryOneID), queryOneVersion).WillReturnRows( + pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(queryOneID), queryOneVersion).WillReturnRows( pgxmock.NewRows([]string{"id", "config"}). AddRow(pgtype.UUID{}, []byte(fmt.Sprintf("{\"path\":\"%s\"}", keyLayerOne))), ) - db.ExpectQuery("name: SetResult :one").WithArgs(database.MustToDBUUID(queryOneID), database.MustToDBUUID(docID), valueLayerOne, cleanVersion, textVersion, queryOneVersion). + pool.ExpectQuery("name: SetResult :one").WithArgs(database.MustToDBUUID(queryOneID), database.MustToDBUUID(docID), valueLayerOne, cleanVersion, textVersion, queryOneVersion). WillReturnRows( - pgxmock.NewRows([]string{"id"}). - AddRow(pgtype.UUID{}), + pgxmock.NewRows([]string{"id"}).AddRow(pgtype.UUID{}), ) - db.ExpectQuery("name: ListResultValuesByID :many").WithArgs(pgxmock.AnyArg()).WillReturnRows( + pool.ExpectQuery("name: ListResultValuesByID :many").WithArgs(pgxmock.AnyArg()).WillReturnRows( pgxmock.NewRows([]string{"id", "queryId", "value"}). AddRow(pgtype.UUID{}, database.MustToDBUUID(queryOneID), valueLayerOne), ) - db.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(queryThreeID), queryThreeVersion).WillReturnRows( + pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(queryThreeID), queryThreeVersion).WillReturnRows( pgxmock.NewRows([]string{"id", "config"}). AddRow(pgtype.UUID{}, []byte(fmt.Sprintf("{\"path\":\"%s\"}", keyLayerTwo))), ) - db.ExpectQuery("name: SetResult :one").WithArgs(database.MustToDBUUID(queryThreeID), database.MustToDBUUID(docID), valueLayerTwo, cleanVersion, textVersion, queryThreeVersion). + pool.ExpectQuery("name: SetResult :one").WithArgs(database.MustToDBUUID(queryThreeID), database.MustToDBUUID(docID), valueLayerTwo, cleanVersion, textVersion, queryThreeVersion). WillReturnRows( - pgxmock.NewRows([]string{"id"}). - AddRow(pgtype.UUID{}), + pgxmock.NewRows([]string{"id"}).AddRow(pgtype.UUID{}), ) - db.ExpectQuery("name: ListResultValuesByID :many").WithArgs(pgxmock.AnyArg()).WillReturnRows( + pool.ExpectQuery("name: ListResultValuesByID :many").WithArgs(pgxmock.AnyArg()).WillReturnRows( pgxmock.NewRows([]string{"id", "queryId", "value"}). AddRow(pgtype.UUID{}, database.MustToDBUUID(queryOneID), valueLayerOne), ) - db.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(queryTwoID), queryTwoVersion).WillReturnRows( + pool.ExpectQuery("name: GetQueryConfig :one").WithArgs(database.MustToDBUUID(queryTwoID), queryTwoVersion).WillReturnRows( pgxmock.NewRows([]string{"id", "config"}). AddRow(pgtype.UUID{}, []byte(fmt.Sprintf("{\"path\":\"%s\"}", keyLayerTwo))), ) - db.ExpectQuery("name: SetResult :one").WithArgs(database.MustToDBUUID(queryTwoID), database.MustToDBUUID(docID), valueLayerTwo, cleanVersion, textVersion, queryTwoVersion). + pool.ExpectQuery("name: SetResult :one").WithArgs(database.MustToDBUUID(queryTwoID), database.MustToDBUUID(docID), valueLayerTwo, cleanVersion, textVersion, queryTwoVersion). WillReturnRows( - pgxmock.NewRows([]string{"id"}). - AddRow(pgtype.UUID{}), + pgxmock.NewRows([]string{"id"}).AddRow(pgtype.UUID{}), ) err = q.Execute(ctx) @@ -188,29 +185,31 @@ func TestQueue(t *testing.T) { func TestQueueFail(t *testing.T) { ctx := context.Background() - db, err := pgxmock.NewConn() + pool, err := pgxmock.NewPool() if err != nil { t.Fatalf("failed to open pgxmock database: %v", err) } - defer db.Close(ctx) - - queries := repository.New(db) + queries := repository.New(pool) + db := &database.Connection{ + Queries: queries, + Pool: pool, + } jobID := uuid.New() dbJobID := database.MustToDBUUID(jobID) collectorID := uuid.New() dbCollectorID := database.MustToDBUUID(collectorID) - db.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). + pool.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). WillReturnRows( pgxmock.NewRows([]string{"id", "jobId", "minCleanVersion", "minTextVersion"}). AddRow(dbCollectorID, dbJobID, int32(1), int32(1)), ) - coll, err := collector.NewByJobId(ctx, queries, jobID) + coll, err := collector.NewByJobId(ctx, db, jobID) assert.Nil(t, err) errr := "database failure" - db.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorID). + pool.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorID). WillReturnError(errors.New(errr)) results := []result.Result{} @@ -219,6 +218,6 @@ func TestQueueFail(t *testing.T) { cleanVersion := int32(1) textVersion := int32(1) - _, err = queryQueue.New(ctx, queries, coll, &results, docID, cleanVersion, textVersion) + _, err = queryQueue.New(ctx, db, coll, &results, docID, cleanVersion, textVersion) assert.EqualError(t, err, errr) } diff --git a/test/unit/internal/result/store_test.go b/test/unit/internal/result/store_test.go index 1084fb23..8fc59313 100644 --- a/test/unit/internal/result/store_test.go +++ b/test/unit/internal/result/store_test.go @@ -16,13 +16,11 @@ import ( func TestStore(t *testing.T) { ctx := context.Background() - db, err := pgxmock.NewConn() + pool, err := pgxmock.NewPool() if err != nil { t.Fatalf("failed to open pgxmock database: %v", err) } - defer db.Close(ctx) - - queries := repository.New(db) + queries := repository.New(pool) resultStore := result.ResultStore{ QueryID: uuid.New(), @@ -33,10 +31,9 @@ func TestStore(t *testing.T) { QueryVersion: int32(1), } - db.ExpectQuery("name: SetResult :one").WithArgs(database.MustToDBUUID(resultStore.QueryID), database.MustToDBUUID(resultStore.DocumentID), resultStore.Value, resultStore.CleanVersion, resultStore.TextVersion, resultStore.QueryVersion). + pool.ExpectQuery("name: SetResult :one").WithArgs(database.MustToDBUUID(resultStore.QueryID), database.MustToDBUUID(resultStore.DocumentID), resultStore.Value, resultStore.CleanVersion, resultStore.TextVersion, resultStore.QueryVersion). WillReturnRows( - pgxmock.NewRows([]string{"id"}). - AddRow(pgtype.UUID{}), + pgxmock.NewRows([]string{"id"}).AddRow(pgtype.UUID{}), ) id, err := result.Store(ctx, queries, &resultStore) @@ -44,7 +41,7 @@ func TestStore(t *testing.T) { assert.NotNil(t, id) errr := "database failing" - db.ExpectQuery("name: SetResult :one").WithArgs(database.MustToDBUUID(resultStore.QueryID), database.MustToDBUUID(resultStore.DocumentID), resultStore.Value, resultStore.CleanVersion, resultStore.TextVersion, resultStore.QueryVersion). + pool.ExpectQuery("name: SetResult :one").WithArgs(database.MustToDBUUID(resultStore.QueryID), database.MustToDBUUID(resultStore.DocumentID), resultStore.Value, resultStore.CleanVersion, resultStore.TextVersion, resultStore.QueryVersion). WillReturnError(fmt.Errorf(errr)) id, err = result.Store(ctx, queries, &resultStore)