Merged in feature/checkbox (pull request #145)

Checkbox Primary Edge Cases

* hascheckboxlogic

* gen

* preppinggen

* exploringcheckbox

* removeunselected

* tests

* failingtest

* failintests

* nomockqueryapi

* db

* name

* nocontainer

* deleterow

* cnc

* extradocsandupdatetextracts

* moretables

* appndedtables

* baseversion

api/queryAPI/collector_test.go

@@ -1,11 +1,8 @@
 package queryapi_test
 
 import (
-	"encoding/json"
 	"fmt"
 	"net/http"
-	"net/http/httptest"
-	"strings"
 	"testing"
 
 	queryapi "queryorchestration/api/queryAPI"
@@ -13,39 +10,36 @@ import (
 	collectorset "queryorchestration/internal/collector/set"
 	"queryorchestration/internal/database/repository"
 	"queryorchestration/internal/serviceconfig"
-	"queryorchestration/internal/serviceconfig/queue/clientsync"
+	"queryorchestration/internal/test"
 	queuemock "queryorchestration/mocks/queue"
 
 	"github.com/aws/aws-sdk-go-v2/service/sqs"
-	"github.com/google/uuid"
-	"github.com/jackc/pgx/v5"
-	"github.com/labstack/echo/v4"
-	"github.com/pashagolub/pgxmock/v3"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
 )
 
 func TestSetCollector(t *testing.T) {
-	pool, err := pgxmock.NewPool()
-	require.NoError(t, err)
-	cfg := &struct {
-		serviceconfig.BaseConfig
-		clientsync.ClientSyncConfig
-	}{}
-	cfg.DBPool = pool
-	cfg.DBQueries = repository.New(pool)
+	t.Parallel()
+	cfg := &ClientConfig{}
+	cfg.ClientSyncURL = "example"
+	net := test.GetNetwork(t)
+	test.CreateDB(t, cfg, net, &test.CreateDatabaseConfig{})
+
 	mockSQS := queuemock.NewMockSQSClient(t)
 	cfg.QueueClient = mockSQS
 
 	id := "clientid"
-	current := collector.Collector{
-		ClientID:      id,
-		ActiveVersion: 1,
-		LatestVersion: 4,
-	}
 
-	av := int32(2)
+	err := cfg.GetDBQueries().CreateClient(t.Context(), &repository.CreateClientParams{
+		Clientid: id,
+		Name:     "client_name",
+	})
+	require.NoError(t, err)
+	queryId, err := cfg.GetDBQueries().CreateQuery(t.Context(), repository.QuerytypeContextFull)
+	require.NoError(t, err)
+
+	av := int32(1)
 	cv := int64(1)
 	body := queryapi.CollectorSet{
 		ActiveVersion:         &av,
@@ -53,18 +47,11 @@ func TestSetCollector(t *testing.T) {
 		Fields: &[]queryapi.CollectorField{
 			{
 				Name:    "a",
-				QueryId: uuid.New(),
+				QueryId: queryId,
 			},
 		},
 	}
-	bodyBytes, err := json.Marshal(body)
-	require.NoError(t, err)
-
-	e := echo.New()
-	req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(string(bodyBytes)))
-	req.Header.Set(echo.HeaderContentType, echo.MIMEApplicationJSON)
-	rec := httptest.NewRecorder()
-	ctx := e.NewContext(req, rec)
+	ctx, rec := createContextWithBody(t, body)
 
 	cons := queryapi.NewControllers(&queryapi.Services{
 		CollectorSet: collectorset.New(cfg, &collectorset.Services{
@@ -72,36 +59,11 @@ func TestSetCollector(t *testing.T) {
 		}),
 	})
 
-	ctx.Set("id", id)
-
-	pool.ExpectQuery("name: GetCollectorByClientID :one").WithArgs(current.ClientID).
-		WillReturnRows(
-			pgxmock.NewRows([]string{"clientId", "minCleanVersion", "minTextVersion", "activeVersion", "latestVersion", "fields"}).
-				AddRow(current.ClientID, current.MinCleanVersion, current.MinTextVersion, current.ActiveVersion, current.LatestVersion, []byte("")),
-		)
-	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs([]uuid.UUID{(*body.Fields)[0].QueryId}).
-		WillReturnRows(
-			pgxmock.NewRows([]string{"exist"}).
-				AddRow(true),
-		)
-	pool.ExpectBeginTx(pgx.TxOptions{})
-	pool.ExpectQuery("name: AddLatestCollectorVersion :one").WithArgs(current.ClientID).WillReturnRows(
-		pgxmock.NewRows([]string{"version"}).
-			AddRow(int32(5)),
-	)
-	pool.ExpectExec("name: SetActiveCollectorVersion :exec").WithArgs(current.ClientID, int32(2)).
-		WillReturnResult(pgxmock.NewResult("", 1))
-	pool.ExpectExec("name: SetCollectorCleanVersion :exec").WithArgs(current.ClientID, int32(5), *body.MinimumCleanerVersion).
-		WillReturnResult(pgxmock.NewResult("", 1))
-	pool.ExpectExec("name: AddCollectorQuery :exec").WithArgs(current.ClientID, "a", (*body.Fields)[0].QueryId, int32(5)).
-		WillReturnResult(pgxmock.NewResult("", 1))
-	pool.ExpectCommit()
-
 	mockSQS.EXPECT().
 		SendMessage(
 			mock.Anything,
 			mock.MatchedBy(func(in *sqs.SendMessageInput) bool {
-				return *in.QueueUrl == cfg.ClientSyncURL && *in.MessageBody == fmt.Sprintf("{\"id\":\"%s\"}", current.ClientID)
+				return *in.QueueUrl == cfg.GetClientSyncURL() && *in.MessageBody == fmt.Sprintf("{\"id\":\"%s\"}", id)
 			}),
 			mock.Anything,
 		).
@@ -113,50 +75,35 @@ func TestSetCollector(t *testing.T) {
 	assert.Empty(t, rec.Body.String())
 }
 
-func TestGetCollectorByclientId(t *testing.T) {
-	pool, err := pgxmock.NewPool()
-	require.NoError(t, err)
+func TestGetCollectorByClientId(t *testing.T) {
+	t.Parallel()
 	cfg := &serviceconfig.BaseConfig{}
-	cfg.DBPool = pool
-	cfg.DBQueries = repository.New(pool)
+	net := test.GetNetwork(t)
+	test.CreateDB(t, cfg, net, &test.CreateDatabaseConfig{})
 
-	e := echo.New()
-	req := httptest.NewRequest(http.MethodPost, "/", strings.NewReader(""))
-	rec := httptest.NewRecorder()
-	ctx := e.NewContext(req, rec)
-
-	svc := collector.New(cfg)
 	cons := queryapi.NewControllers(&queryapi.Services{
-		Collector: svc,
+		Collector: collector.New(cfg),
 	})
 
-	coll := collector.Collector{
-		ClientID:        "hello",
-		MinCleanVersion: 1,
-		MinTextVersion:  2,
-	}
-
 	id := "clientid"
 
-	pool.ExpectQuery("name: GetCollectorByClientID :one").WithArgs(id).
-		WillReturnRows(
-			pgxmock.NewRows([]string{"clientId", "minCleanVersion", "minTextVersion", "activeVersion", "latestVersion", "fields"}).
-				AddRow(coll.ClientID, coll.MinCleanVersion, coll.MinTextVersion, int32(1), int32(2), []byte("")),
-		)
+	err := cfg.GetDBQueries().CreateClient(t.Context(), &repository.CreateClientParams{
+		Clientid: id,
+		Name:     "client_name",
+	})
+	require.NoError(t, err)
+
+	ctx, rec := createContext(t)
 
 	err = cons.GetCollectorByClientId(ctx, id)
 	require.NoError(t, err)
 	assert.Equal(t, http.StatusOK, rec.Code)
-
-	var res queryapi.Collector
-	err = json.Unmarshal(rec.Body.Bytes(), &res)
-	require.NoError(t, err)
-	assert.EqualExportedValues(t, queryapi.Collector{
+	assertBody(t, rec, queryapi.Collector{
 		ClientId:              id,
-		MinimumCleanerVersion: coll.MinCleanVersion,
-		MinimumTextVersion:    coll.MinTextVersion,
-		ActiveVersion:         int32(1),
-		LatestVersion:         int32(2),
+		MinimumCleanerVersion: 0,
+		MinimumTextVersion:    0,
+		ActiveVersion:         0,
+		LatestVersion:         0,
 		Fields:                []queryapi.CollectorField{},
-	}, res)
+	})
 }