Merged in feature/listtypes (pull request #23)

Feature/listtypes

* started

* cleanuplist

* someunittestfixes

* removemostflakiness

internal/query/create.go

@@ -54,7 +54,7 @@ func (s *Service) submitCreate(ctx context.Context, entity *queryprocessor.Creat
 	}
 
 	for _, reqQuery := range query.RequiredQueryIDs {
-		err = qtx.CreateRequiredQuery(ctx, repository.CreateRequiredQueryParams{
+		err = qtx.CreateRequiredQuery(ctx, &repository.CreateRequiredQueryParams{
 			Queryid:         dbID,
 			Requiredqueryid: reqQuery,
 			Addedversion:    1,
@@ -65,7 +65,7 @@ func (s *Service) submitCreate(ctx context.Context, entity *queryprocessor.Creat
 	}
 
 	if query.Config != nil && string(query.Config) != "" {
-		err = qtx.CreateQueryConfig(ctx, repository.CreateQueryConfigParams{
+		err = qtx.CreateQueryConfig(ctx, &repository.CreateQueryConfigParams{
 			Queryid:      dbID,
 			Config:       query.Config,
 			Addedversion: 1,

internal/query/get.go

@@ -24,7 +24,7 @@ func (s *Service) Get(ctx context.Context, id uuid.UUID) (*Query, error) {
 		return nil, err
 	}
 
-	return ParseFullActiveQuery(&query)
+	return ParseFullActiveQuery(query)
 }
 
 func ParseFullActiveQuery(q *repository.Fullactivequery) (*Query, error) {
@@ -47,3 +47,17 @@ func ParseFullActiveQuery(q *repository.Fullactivequery) (*Query, error) {
 		Config:           string(q.Config),
 	}, nil
 }
+
+func ParseFullActiveQueryArray(q []*repository.Fullactivequery) ([]*Query, error) {
+	queries := make([]*Query, len(q))
+	for index, query := range q {
+		q, err := ParseFullActiveQuery(query)
+		if err != nil {
+			return nil, err
+		}
+
+		queries[index] = q
+	}
+
+	return queries, nil
+}

internal/query/get_test.go

@@ -96,3 +96,29 @@ func TestFullActiveQueryWithNullUUID(t *testing.T) {
 		RequiredQueryIDs: []uuid.UUID{},
 	}, *out)
 }
+
+func TestFullActiveQueryArray(t *testing.T) {
+	dbQueries := []*repository.Fullactivequery{
+		{
+			ID:            database.MustToDBUUID(uuid.New()),
+			Type:          repository.QuerytypeContextFull,
+			Activeversion: int32(1),
+			Latestversion: int32(2),
+			Config:        []byte(""),
+			Requiredids:   []pgtype.UUID{},
+		},
+	}
+
+	out, err := query.ParseFullActiveQueryArray(dbQueries)
+	assert.Nil(t, err)
+	assert.EqualExportedValues(t, []*query.Query{
+		{
+			ID:               database.MustToUUID(dbQueries[0].ID),
+			Type:             queryprocessor.TypeContextFull,
+			ActiveVersion:    int32(1),
+			LatestVersion:    int32(2),
+			Config:           "",
+			RequiredQueryIDs: []uuid.UUID{},
+		},
+	}, out)
+}

internal/query/list.go

@@ -2,29 +2,20 @@ package query
 
 import (
 	"context"
-	queryprocessor "queryorchestration/internal/queryProcessor"
 )
 
 type ListFilters struct {
-	Types []queryprocessor.Type
 }
 
 func (s *Service) List(ctx context.Context, filters ListFilters) ([]*Query, error) {
-	// TODO - use filters
-
 	dbQueries, err := s.db.Queries.ListQueries(ctx)
 	if err != nil {
 		return nil, err
 	}
 
-	queries := make([]*Query, len(dbQueries))
-	for index, query := range dbQueries {
-		q, err := ParseFullActiveQuery(&query)
-		if err != nil {
-			return nil, err
-		}
-
-		queries[index] = q
+	queries, err := ParseFullActiveQueryArray(dbQueries)
+	if err != nil {
+		return nil, err
 	}
 
 	return queries, nil

internal/query/list_test.go

@@ -53,3 +53,44 @@ func TestList(t *testing.T) {
 
 	assert.EqualExportedValues(t, []*query.Query{q}, resList)
 }
+
+func TestListFilterType(t *testing.T) {
+	ctx := context.Background()
+
+	pool, err := pgxmock.NewPool()
+	if err != nil {
+		t.Fatalf("failed to open pgxmock database: %v", err)
+	}
+	queries := repository.New(pool)
+	db := &database.Connection{
+		Queries: queries,
+		Pool:    pool,
+	}
+	svc := query.New(db)
+
+	config := "{\"path\":\"example_path\"}"
+	q := &query.Query{
+		ID:            uuid.New(),
+		Type:          queryprocessor.TypeJsonExtractor,
+		ActiveVersion: int32(1),
+		LatestVersion: int32(1),
+		RequiredQueryIDs: []uuid.UUID{
+			uuid.New(),
+		},
+		Config: config,
+	}
+
+	dbReqIDs := database.MustToDBUUIDArray(q.RequiredQueryIDs)
+
+	filters := query.ListFilters{}
+
+	pool.ExpectQuery("name: ListQueries :many").WithArgs().WillReturnRows(
+		pgxmock.NewRows([]string{"id", "type", "activeVersion", "latestVersion", "config", "requiredIds"}).
+			AddRow(database.MustToDBUUID(q.ID), repository.QuerytypeJsonExtractor, q.ActiveVersion, q.LatestVersion, []byte(config), dbReqIDs),
+	)
+
+	resList, err := svc.List(ctx, filters)
+	assert.Nil(t, err)
+
+	assert.EqualExportedValues(t, []*query.Query{q}, resList)
+}