query-orchestration/internal/query/result/process_test.go

package result

import (
	"context"
	"testing"
	"time"

	"queryorchestration/internal/database/repository"
	"queryorchestration/internal/query"
	resultprocessor "queryorchestration/internal/query/result/processor"
	jsonextractor "queryorchestration/internal/query/types/jsonExtractor"
	"queryorchestration/internal/serviceconfig"
	"queryorchestration/internal/test"

	"github.com/google/uuid"
	"github.com/jackc/pgx/v5/pgtype"
	"github.com/pashagolub/pgxmock/v3"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

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

	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)
	contextQueryId, err := cfg.GetDBQueries().CreateQuery(t.Context(), repository.QuerytypeContextFull)
	require.NoError(t, err)
	contextVersion, err := cfg.GetDBQueries().AddLatestQueryVersion(t.Context(), contextQueryId)
	require.NoError(t, err)
	err = cfg.GetDBQueries().AddActiveQueryVersion(t.Context(), &repository.AddActiveQueryVersionParams{
		Queryid:   contextQueryId,
		Versionid: contextVersion,
	})
	require.NoError(t, err)
	queryId, err := cfg.GetDBQueries().CreateQuery(t.Context(), repository.QuerytypeJsonExtractor)
	require.NoError(t, err)
	latestVersion, err := cfg.GetDBQueries().AddLatestQueryVersion(t.Context(), queryId)
	require.NoError(t, err)
	err = cfg.GetDBQueries().AddActiveQueryVersion(t.Context(), &repository.AddActiveQueryVersionParams{
		Queryid:   queryId,
		Versionid: latestVersion,
	})
	require.NoError(t, err)
	err = cfg.GetDBQueries().AddRequiredQuery(t.Context(), &repository.AddRequiredQueryParams{
		Queryid:         queryId,
		Requiredqueryid: contextQueryId,
		Addedversion:    latestVersion,
	})
	require.NoError(t, err)
	c := `{"path":"oldkey"}`
	err = cfg.GetDBQueries().SetQueryConfig(t.Context(), &repository.SetQueryConfigParams{
		Queryid:      queryId,
		Config:       []byte(c),
		Addedversion: latestVersion,
	})
	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: contextVersion,
	})
	require.NoError(t, err)
	latestVersion, err = cfg.GetDBQueries().AddLatestQueryVersion(t.Context(), queryId)
	require.NoError(t, err)
	c = `{"path": "mykey"}`
	err = cfg.GetDBQueries().SetQueryConfig(t.Context(), &repository.SetQueryConfigParams{
		Queryid:      queryId,
		Config:       []byte(c),
		Addedversion: latestVersion,
	})
	require.NoError(t, err)

	svc := New(cfg, &Services{
		Query: query.New(cfg),
	})

	val, err := svc.Process(t.Context(), &Process{
		DocumentID:   docId,
		QueryID:      queryId,
		QueryVersion: 1,
	})
	require.NoError(t, err)
	assert.NotNil(t, val)
	assert.Equal(t, "old_value", val.GetStoreValue())

	val, err = svc.Process(t.Context(), &Process{
		DocumentID:   docId,
		QueryID:      queryId,
		QueryVersion: 2,
	})
	require.NoError(t, err)
	assert.NotNil(t, val)
	assert.Equal(t, "example_value", val.GetStoreValue())
}

func TestListRequiredValue(t *testing.T) {
	ctx := context.Background()

	pool, err := pgxmock.NewPool()
	require.NoError(t, err)
	cfg := &serviceconfig.BaseConfig{}
	cfg.DBPool = pool
	cfg.DBQueries = repository.New(pool)

	svc := Service{
		cfg: cfg,
	}

	pr, err := svc.listRequiredValues(ctx, nil, nil)
	require.NoError(t, err)
	assert.Nil(t, pr)

	pr, err = svc.listRequiredValues(ctx, &Process{}, &resultprocessor.Query{})
	require.NoError(t, err)
	assert.Nil(t, pr)

	pr, err = svc.listRequiredValues(ctx, &Process{},
		&resultprocessor.Query{
			RequiredQueryIDs: &[]uuid.UUID{},
		},
	)
	require.NoError(t, err)
	assert.Nil(t, pr)

	query := &resultprocessor.Query{
		ID:               uuid.New(),
		Version:          2,
		RequiredQueryIDs: &[]uuid.UUID{uuid.New()},
	}
	params := Process{
		DocumentID:   uuid.New(),
		QueryID:      query.ID,
		QueryVersion: query.Version,
	}

	strVal := "axe_value"

	pool.ExpectQuery("name: ListQueryRequirementValues :many").WithArgs(&query.ID, &query.Version, &params.DocumentID).
		WillReturnRows(
			pgxmock.NewRows([]string{"id", "queryId", "type", "value"}).
				AddRow(&uuid.UUID{}, (*query.RequiredQueryIDs)[0], repository.QuerytypeJsonExtractor, &strVal),
		)

	pr, err = svc.listRequiredValues(ctx, &params, query)
	require.NoError(t, err)
	assert.ElementsMatch(t, []resultprocessor.Value{
		jsonextractor.NewResult(strVal),
	}, pr)
}

func TestGetProcessor(t *testing.T) {
	svc := Service{}

	pr, err := svc.getProcessor(resultprocessor.TypeJsonExtractor)
	require.NoError(t, err)
	assert.NotNil(t, pr)

	pr, err = svc.getProcessor(resultprocessor.TypeContextFull)
	require.NoError(t, err)
	assert.NotNil(t, pr)

	_, err = svc.getProcessor(resultprocessor.Type(-1))
	assert.Error(t, err)
}

func TestParseQueryRequirementValueArray(t *testing.T) {
	exval := "exampleval"
	in := []*repository.ListQueryRequirementValuesRow{
		{
			Queryid:   uuid.New(),
			Value:     &exval,
			Querytype: repository.QuerytypeJsonExtractor,
		},
	}

	out, err := parseQueryRequirementValueArray(in)
	require.NoError(t, err)
	assert.ElementsMatch(t, []resultprocessor.Value{
		jsonextractor.NewResult(exval),
	}, out)
}