query-orchestration/api/queryAPI/query_test.go

package queryapi_test

import (
	"fmt"
	"net/http"
	"testing"
	"time"

	queryapi "queryorchestration/api/queryAPI"
	"queryorchestration/internal/collector"
	"queryorchestration/internal/database/repository"
	"queryorchestration/internal/document"
	"queryorchestration/internal/query"
	"queryorchestration/internal/query/result"
	resultprocessor "queryorchestration/internal/query/result/processor"
	querytest "queryorchestration/internal/query/test"
	queryupdate "queryorchestration/internal/query/update"
	"queryorchestration/internal/serviceconfig"
	"queryorchestration/internal/serviceconfig/queue/queryversionsync"
	"queryorchestration/internal/test"
	queuemock "queryorchestration/mocks/queue"

	"github.com/jackc/pgx/v5/pgtype"
	"github.com/stretchr/testify/require"

	"github.com/aws/aws-sdk-go-v2/service/sqs"
	"github.com/google/uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/mock"
)

func TestCreateQuery(t *testing.T) {
	t.Parallel()
	cfg := &serviceconfig.BaseConfig{}
	net := test.GetNetwork(t)
	test.CreateDB(t, cfg, net, &test.CreateDatabaseConfig{})

	cons := queryapi.NewControllers(&queryapi.Services{
		Query: query.New(cfg),
	})

	body := queryapi.QueryCreate{
		Type: queryapi.CONTEXTFULL,
	}
	ctx, rec := createContextWithBody(t, body)

	err := cons.CreateQuery(ctx)
	require.NoError(t, err)
	assert.Equal(t, http.StatusCreated, rec.Code)
	res := getBody[queryapi.IdMessage](t, rec)
	assert.NotEqual(t, uuid.Nil, res.Id)
}

func TestListQueries(t *testing.T) {
	t.Parallel()
	cfg := &serviceconfig.BaseConfig{}
	net := test.GetNetwork(t)
	test.CreateDB(t, cfg, net, &test.CreateDatabaseConfig{})

	cons := queryapi.NewControllers(&queryapi.Services{
		Query: query.New(cfg),
	})

	ctx, rec := createContext(t)

	id, err := cfg.GetDBQueries().CreateQuery(t.Context(), repository.QuerytypeContextFull)
	require.NoError(t, err)

	err = cons.ListQueries(ctx)
	require.NoError(t, err)
	assert.Equal(t, http.StatusOK, rec.Code)
	assertBody(t, rec, queryapi.ListQueries{
		Queries: []queryapi.Query{
			{
				Id:            id,
				Type:          queryapi.CONTEXTFULL,
				ActiveVersion: 0,
				LatestVersion: 0,
			},
		},
	})
}

func TestGetQuery(t *testing.T) {
	t.Parallel()
	cfg := &serviceconfig.BaseConfig{}
	net := test.GetNetwork(t)
	test.CreateDB(t, cfg, net, &test.CreateDatabaseConfig{})

	cons := queryapi.NewControllers(&queryapi.Services{
		Query: query.New(cfg),
	})

	ctx, rec := createContext(t)

	id, err := cfg.GetDBQueries().CreateQuery(t.Context(), repository.QuerytypeContextFull)
	require.NoError(t, err)

	err = cons.GetQuery(ctx, id)
	require.NoError(t, err)
	assert.Equal(t, http.StatusOK, rec.Code)
	assertBody(t, rec, queryapi.Query{
		Id:            id,
		Type:          queryapi.CONTEXTFULL,
		ActiveVersion: 0,
		LatestVersion: 0,
	})
}

func TestUpdateQuery(t *testing.T) {
	t.Parallel()
	cfg := &struct {
		serviceconfig.BaseConfig
		queryversionsync.QueryVersionSyncConfig
	}{}
	net := test.GetNetwork(t)
	test.CreateDB(t, cfg, net, &test.CreateDatabaseConfig{})
	mockSQS := queuemock.NewMockSQSClient(t)
	cfg.QueueClient = mockSQS
	cfg.QueryVersionSyncURL = "here"

	cons := queryapi.NewControllers(&queryapi.Services{
		QueryUpdate: queryupdate.New(cfg, &queryupdate.Services{
			Query: query.New(cfg),
		}),
	})

	id, err := cfg.GetDBQueries().CreateQuery(t.Context(), repository.QuerytypeJsonExtractor)
	require.NoError(t, err)

	av := int32(1)
	c := `{"path": "val"}`
	body := queryapi.QueryUpdate{
		ActiveVersion: &av,
		Config:        &c,
	}
	ctx, rec := createContextWithBody(t, body)

	mockSQS.EXPECT().
		SendMessage(
			mock.Anything,
			mock.MatchedBy(func(in *sqs.SendMessageInput) bool {
				return *in.QueueUrl == cfg.QueryVersionSyncURL && *in.MessageBody == fmt.Sprintf("{\"id\":\"%s\"}", id.String())
			}),
			mock.Anything,
		).
		Return(&sqs.SendMessageOutput{}, nil)

	err = cons.UpdateQuery(ctx, id)
	require.NoError(t, err)
	assert.Equal(t, http.StatusOK, rec.Code)
	assert.Empty(t, rec.Body.String())
}

type QueryUpdateConfig struct {
	serviceconfig.BaseConfig
	queryversionsync.QueryVersionSyncConfig
}

func TestTestQuery(t *testing.T) {
	t.Parallel()
	cfg := &QueryUpdateConfig{}
	net := test.GetNetwork(t)
	test.CreateDB(t, cfg, net, &test.CreateDatabaseConfig{})

	docsvc := document.New(cfg)
	col := collector.New(cfg)
	que := query.New(cfg)
	queup := queryupdate.New(cfg, &queryupdate.Services{
		Query: que,
	})
	cons := queryapi.NewControllers(&queryapi.Services{
		Collector:   col,
		Query:       que,
		QueryUpdate: queup,
		QueryTest: querytest.New(cfg, &querytest.Services{
			Document:  docsvc,
			Collector: col,
			Result: result.New(cfg, &result.Services{
				Query: que,
			}),
		}),
	})

	contextQueryId, err := que.Create(t.Context(), &resultprocessor.Create{
		Type: resultprocessor.TypeContextFull,
	})
	require.NoError(t, err)

	err = cfg.GetDBQueries().CreateClient(t.Context(), &repository.CreateClientParams{
		Clientid: "client_id",
		Name:     "client_name",
	})
	require.NoError(t, err)
	docId, err := cfg.GetDBQueries().CreateDocument(t.Context(), &repository.CreateDocumentParams{
		Clientid: "client_id",
		Hash:     "hash",
	})
	require.NoError(t, err)
	fill := "fill"
	cleanId, err := cfg.GetDBQueries().AddDocumentClean(t.Context(), &repository.AddDocumentCleanParams{
		Documentid: docId,
		Bucket:     &fill,
		Key:        &fill,
		Hash:       &fill,
		Mimetype: repository.NullCleanmimetype{
			Valid:         true,
			Cleanmimetype: repository.CleanmimetypeApplicationPdf,
		},
	})
	require.NoError(t, err)
	err = cfg.GetDBQueries().AddDocumentCleanEntry(t.Context(), &repository.AddDocumentCleanEntryParams{
		Cleanid: cleanId,
		Version: 1,
	})
	require.NoError(t, err)
	textId, err := cfg.GetDBQueries().AddDocumentText(t.Context(), &repository.AddDocumentTextParams{
		Cleanid: cleanId,
		Bucket:  fill,
		Key:     fill,
		Hash:    fill,
		Createdat: pgtype.Timestamp{
			Time:  time.Now(),
			Valid: true,
		},
	})
	require.NoError(t, err)
	err = cfg.GetDBQueries().AddDocumentTextEntry(t.Context(), &repository.AddDocumentTextEntryParams{
		Textid:  textId,
		Version: 1,
	})
	require.NoError(t, err)
	strVal := `{"mykey": "example_value", "oldkey": "old_value"}`
	_, err = cfg.GetDBQueries().AddResult(t.Context(), &repository.AddResultParams{
		Queryid:      contextQueryId,
		Value:        strVal,
		Textentryid:  textId,
		Queryversion: 1,
	})
	require.NoError(t, err)

	c := `{"path": "oldkey"}`
	queryId, err := que.Create(t.Context(), &resultprocessor.Create{
		Type:   resultprocessor.TypeJsonExtractor,
		Config: &c,
		RequiredQueryIDs: &[]uuid.UUID{
			contextQueryId,
		},
	})
	require.NoError(t, err)
	c = `{"path": "mykey"}`
	err = queup.Update(t.Context(), &resultprocessor.Update{
		ID:     queryId,
		Config: &c,
	})
	require.NoError(t, err)

	body := queryapi.QueryTestRequest{
		DocumentId:   docId,
		QueryVersion: 1,
	}
	ctx, rec := createContextWithBody(t, body)

	err = cons.TestQuery(ctx, queryId)
	require.NoError(t, err)
	assert.Equal(t, http.StatusOK, rec.Code)
	assertBody(t, rec, queryapi.QueryTestResponse{
		Value: "old_value",
	})

	body = queryapi.QueryTestRequest{
		DocumentId:   docId,
		QueryVersion: 2,
	}
	ctx, rec = createContextWithBody(t, body)

	err = cons.TestQuery(ctx, queryId)
	require.NoError(t, err)
	assert.Equal(t, http.StatusOK, rec.Code)
	assertBody(t, rec, queryapi.QueryTestResponse{
		Value: "example_value",
	})
}