From eb917fb25ea18bbe19650d0502d752b7c5c720c0 Mon Sep 17 00:00:00 2001 From: Michael McGuinness Date: Mon, 23 Dec 2024 18:13:57 +0000 Subject: [PATCH] moretesting --- internal/collector/collector.go | 5 +- internal/database/connection.go | 3 +- internal/database/uuid.go | 19 +-- internal/document/service.go | 9 +- internal/query/create.go | 5 +- test/unit/internal/collector/service_test.go | 64 ++++++++++ test/unit/internal/database/uuid_test.go | 6 +- test/unit/internal/document/sync_test.go | 125 ++++++++++++++++++- test/unit/internal/query/service_test.go | 25 ++++ test/unit/internal/result/parse_test.go | 24 ++++ 10 files changed, 245 insertions(+), 40 deletions(-) create mode 100644 test/unit/internal/collector/service_test.go create mode 100644 test/unit/internal/query/service_test.go create mode 100644 test/unit/internal/result/parse_test.go diff --git a/internal/collector/collector.go b/internal/collector/collector.go index 36469d6e..98b5848f 100644 --- a/internal/collector/collector.go +++ b/internal/collector/collector.go @@ -29,10 +29,7 @@ func NewByJobId(ctx context.Context, db *repository.Queries, jobID uuid.UUID) (* } func (c *Collector) getByJobID(ctx context.Context, jobID uuid.UUID) error { - dbJobID, err := database.ToDBUUID(jobID) - if err != nil { - return err - } + dbJobID := database.MustToDBUUID(jobID) dbCollector, err := c.db.GetCollectorFromJobID(ctx, dbJobID) if err != nil { diff --git a/internal/database/connection.go b/internal/database/connection.go index 2e998675..3e72d306 100644 --- a/internal/database/connection.go +++ b/internal/database/connection.go @@ -17,7 +17,8 @@ func createConnectionString() string { dbHost := env.GetFatal("DB_HOST") dbPort := env.GetFatal("DB_PORT") dbName := env.GetFatal("DB_NAME") - connStr := fmt.Sprintf("%s://%s:%s@%s:%s/%s?sslmode=disable", driver, dbUser, dbPass, dbHost, dbPort, dbName) + opts := "sslmode=disable" + connStr := fmt.Sprintf("%s://%s:%s@%s:%s/%s?%s", driver, dbUser, dbPass, dbHost, dbPort, dbName, opts) return connStr } diff --git a/internal/database/uuid.go b/internal/database/uuid.go index 6af0aaa8..66966fc0 100644 --- a/internal/database/uuid.go +++ b/internal/database/uuid.go @@ -1,28 +1,13 @@ package database import ( - "fmt" - "github.com/google/uuid" "github.com/jackc/pgx/v5/pgtype" ) -func ToDBUUID(id uuid.UUID) (pgtype.UUID, error) { - var dbID pgtype.UUID - err := dbID.Scan(id.String()) - if err != nil { - return pgtype.UUID{}, err - } - - return dbID, nil -} - func MustToDBUUID(id uuid.UUID) pgtype.UUID { - dbID, err := ToDBUUID(id) - if err != nil { - panic(fmt.Sprint("id is not valid: ", id)) - } - + var dbID pgtype.UUID + dbID.Scan(id.String()) return dbID } diff --git a/internal/document/service.go b/internal/document/service.go index a30e6188..b1103d3f 100644 --- a/internal/document/service.go +++ b/internal/document/service.go @@ -34,7 +34,7 @@ func (s *Service) Sync(ctx context.Context, doc *Document) error { return err } - results, err := s.GetResults(ctx, doc.ID, collector) + results, err := s.getResults(ctx, doc.ID, collector) if err != nil { return err } @@ -52,11 +52,8 @@ func (s *Service) Sync(ctx context.Context, doc *Document) error { return nil } -func (s *Service) GetResults(ctx context.Context, id uuid.UUID, coll *collector.Collector) (*[]query.Result, error) { - docID, err := database.ToDBUUID(id) - if err != nil { - return nil, err - } +func (s *Service) getResults(ctx context.Context, id uuid.UUID, coll *collector.Collector) (*[]query.Result, error) { + docID := database.MustToDBUUID(id) results, err := s.db.ListResultsByDocumentID(ctx, repository.ListResultsByDocumentIDParams{ Documentid: docID, diff --git a/internal/query/create.go b/internal/query/create.go index 9fe49136..d31eacee 100644 --- a/internal/query/create.go +++ b/internal/query/create.go @@ -28,10 +28,7 @@ func (c *Queue) getCollectorQueries(ctx context.Context) error { return nil } - id, err := database.ToDBUUID(c.collector.ID) - if err != nil { - return err - } + id := database.MustToDBUUID(c.collector.ID) queries, err := c.db.GetCollectorQueries(ctx, id) if err != nil { diff --git a/test/unit/internal/collector/service_test.go b/test/unit/internal/collector/service_test.go new file mode 100644 index 00000000..069bb419 --- /dev/null +++ b/test/unit/internal/collector/service_test.go @@ -0,0 +1,64 @@ +package document_test + +import ( + "context" + "gotemplate/internal/collector" + "gotemplate/internal/database" + "gotemplate/internal/database/repository" + "testing" + + "github.com/google/uuid" + "github.com/pashagolub/pgxmock/v3" + "github.com/stretchr/testify/assert" +) + +func TestService(t *testing.T) { + ctx := context.Background() + + db, err := pgxmock.NewConn() + if err != nil { + t.Fatalf("failed to open pgxmock database: %v", err) + } + defer db.Close(ctx) + + queries := repository.New(db) + svc := collector.New(queries) + assert.NotNil(t, svc) +} + +func TestByJobId(t *testing.T) { + ctx := context.Background() + + db, err := pgxmock.NewConn() + if err != nil { + t.Fatalf("failed to open pgxmock database: %v", err) + } + defer db.Close(ctx) + + queries := repository.New(db) + + jobID := uuid.New() + fullCollector := collector.Collector{ + ID: uuid.New(), + MinCleanVersion: int32(1), + MinTextVersion: int32(1), + } + + db.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) + assert.Nil(t, err) + assert.EqualExportedValues(t, fullCollector, *coll) + + db.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(database.MustToDBUUID(jobID)). + WillReturnRows( + pgxmock.NewRows([]string{"id", "jobId", "minCleanVersion", "minTextVersion"}), + ) + + _, err = collector.NewByJobId(ctx, queries, jobID) + assert.EqualError(t, err, "no rows in result set") +} diff --git a/test/unit/internal/database/uuid_test.go b/test/unit/internal/database/uuid_test.go index 5fee1f3d..fa61b4c4 100644 --- a/test/unit/internal/database/uuid_test.go +++ b/test/unit/internal/database/uuid_test.go @@ -8,11 +8,11 @@ import ( "github.com/stretchr/testify/assert" ) -func TestToDBUUID(t *testing.T) { +func TestMustToDBUUID(t *testing.T) { id := uuid.New() - dbID, err := database.ToDBUUID(id) + dbID := database.MustToDBUUID(id) - assert.Nil(t, err) assert.Equal(t, true, dbID.Valid) + assert.Equal(t, id.String(), uuid.UUID(dbID.Bytes).String()) } diff --git a/test/unit/internal/document/sync_test.go b/test/unit/internal/document/sync_test.go index c503c493..f85d8a67 100644 --- a/test/unit/internal/document/sync_test.go +++ b/test/unit/internal/document/sync_test.go @@ -13,7 +13,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestSync(t *testing.T) { +func TestSyncIsSynced(t *testing.T) { ctx := context.Background() db, err := pgxmock.NewConn() @@ -23,7 +23,6 @@ func TestSync(t *testing.T) { defer db.Close(ctx) queries := repository.New(db) - docSvc := document.New(queries) doc := document.Document{ ID: uuid.New(), @@ -35,14 +34,13 @@ func TestSync(t *testing.T) { dbJobID := database.MustToDBUUID(doc.JobID) minCleanVersion := int32(1) minTextVersion := int32(1) + db.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). WillReturnRows( pgxmock.NewRows([]string{"id", "jobId", "minCleanVersion", "minTextVersion"}). AddRow(dbCollectorId, dbJobID, minCleanVersion, minTextVersion), ) - - dbDocID := database.MustToDBUUID(doc.ID) - db.ExpectQuery("name: ListResultsByDocumentID :many").WithArgs(dbDocID, minCleanVersion, minTextVersion). + db.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)), @@ -53,6 +51,123 @@ func TestSync(t *testing.T) { AddRow(dbCollectorId, pgtype.UUID{}, repository.NullQuerytype{Querytype: repository.QuerytypeJsonExtractor, Valid: true}, pgtype.UUID{}, pgtype.Int4{Int32: int32(1), Valid: true}), ) + docSvc := document.New(queries) err = docSvc.Sync(ctx, &doc) assert.Nil(t, err) } + +func TestSyncNoJob(t *testing.T) { + ctx := context.Background() + + db, err := pgxmock.NewConn() + if err != nil { + t.Fatalf("failed to open pgxmock database: %v", err) + } + defer db.Close(ctx) + + queries := repository.New(db) + + doc := document.Document{ + ID: uuid.New(), + JobID: uuid.New(), + Name: "document_name", + } + + dbJobID := database.MustToDBUUID(doc.JobID) + db.ExpectQuery("name: GetCollectorFromJobID :one").WithArgs(dbJobID). + WillReturnRows( + pgxmock.NewRows([]string{"id", "jobId", "minCleanVersion", "minTextVersion"}), + ) + + docSvc := document.New(queries) + err = docSvc.Sync(ctx, &doc) + assert.EqualError(t, err, "no rows in result set") +} + +func TestSyncNoResultsNoCollector(t *testing.T) { + ctx := context.Background() + + db, err := pgxmock.NewConn() + if err != nil { + t.Fatalf("failed to open pgxmock database: %v", err) + } + defer db.Close(ctx) + + queries := repository.New(db) + + doc := document.Document{ + ID: uuid.New(), + JobID: uuid.New(), + Name: "document_name", + } + + dbCollectorId := database.MustToDBUUID(uuid.New()) + dbJobID := database.MustToDBUUID(doc.JobID) + minCleanVersion := int32(1) + minTextVersion := int32(1) + + db.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). + WillReturnRows( + pgxmock.NewRows([]string{"id", "queryId", "queryVersion"}), + ) + db.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorId). + WillReturnRows( + pgxmock.NewRows([]string{"collectorId", "queryId", "type", "requiredQueryId", "queryVersion"}), + ) + + docSvc := document.New(queries) + err = docSvc.Sync(ctx, &doc) + assert.Nil(t, err) +} + +func TestSync(t *testing.T) { + ctx := context.Background() + + db, err := pgxmock.NewConn() + if err != nil { + t.Fatalf("failed to open pgxmock database: %v", err) + } + defer db.Close(ctx) + + queries := repository.New(db) + + doc := document.Document{ + ID: uuid.New(), + JobID: uuid.New(), + Name: "document_name", + } + + dbCollectorId := database.MustToDBUUID(uuid.New()) + dbJobID := database.MustToDBUUID(doc.JobID) + dbQueryID := database.MustToDBUUID(uuid.New()) + minCleanVersion := int32(1) + minTextVersion := int32(1) + + db.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). + WillReturnRows( + pgxmock.NewRows([]string{"id", "queryId", "queryVersion"}), + ) + db.ExpectQuery("name: GetCollectorQueries :many").WithArgs(dbCollectorId). + WillReturnRows( + pgxmock.NewRows([]string{"collectorId", "queryId", "type", "requiredQueryId", "queryVersion"}). + AddRow(dbCollectorId, dbQueryID, repository.NullQuerytype{Querytype: repository.QuerytypeJsonExtractor, Valid: true}, pgtype.UUID{}, pgtype.Int4{Int32: int32(1), Valid: true}), + ) + db.ExpectQuery("name: ListResultValuesByID :many").WithArgs([]pgtype.UUID{}). + WillReturnRows( + pgxmock.NewRows([]string{"id", "queryId", "value"}), + ) + + docSvc := document.New(queries) + err = docSvc.Sync(ctx, &doc) + assert.EqualError(t, err, "JSON Extraction requires 1 result") +} diff --git a/test/unit/internal/query/service_test.go b/test/unit/internal/query/service_test.go new file mode 100644 index 00000000..70e34f76 --- /dev/null +++ b/test/unit/internal/query/service_test.go @@ -0,0 +1,25 @@ +package document_test + +import ( + "context" + "gotemplate/internal/database/repository" + "gotemplate/internal/query" + "testing" + + "github.com/pashagolub/pgxmock/v3" + "github.com/stretchr/testify/assert" +) + +func TestService(t *testing.T) { + ctx := context.Background() + + db, err := pgxmock.NewConn() + if err != nil { + t.Fatalf("failed to open pgxmock database: %v", err) + } + defer db.Close(ctx) + + queries := repository.New(db) + svc := query.New(queries) + assert.NotNil(t, svc) +} diff --git a/test/unit/internal/result/parse_test.go b/test/unit/internal/result/parse_test.go new file mode 100644 index 00000000..5d75e65e --- /dev/null +++ b/test/unit/internal/result/parse_test.go @@ -0,0 +1,24 @@ +package document_test + +import ( + "gotemplate/internal/database/repository" + "gotemplate/internal/result" + "testing" + + "github.com/google/uuid" + "github.com/jackc/pgx/v5/pgtype" + "github.com/stretchr/testify/assert" +) + +func TestParseResultValue(t *testing.T) { + dbResult := repository.ListResultValuesByIDRow{ + ID: pgtype.UUID{}, + Queryid: pgtype.UUID{}, + Value: "", + } + + value := result.ParseResultValue(dbResult) + assert.Equal(t, dbResult.Value, value.Value) + assert.Equal(t, uuid.Nil, value.ID) + assert.Equal(t, uuid.Nil, value.QueryID) +}