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

package result

import (
	"testing"
	"time"

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

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

func TestGetValueByType(t *testing.T) {
	_, err := getValueByType(resultprocessor.Type(-1), "example_val")
	assert.Error(t, err)
	pro, err := getValueByType(resultprocessor.TypeContextFull, "example_context")
	require.NoError(t, err)
	assert.NotNil(t, pro)
	assert.Equal(t, "example_context", pro.GetStoreValue())
	pro, err = getValueByType(resultprocessor.TypeJsonExtractor, "example_json")
	require.NoError(t, err)
	assert.NotNil(t, pro)
	assert.Equal(t, "example_json", pro.GetStoreValue())
}

func TestGetValueWithVersion(t *testing.T) {
	t.Run("no entry", func(t *testing.T) {
		t.Parallel()
		cfg := &serviceconfig.BaseConfig{}
		net := test.GetNetwork(t)
		test.CreateDB(t, cfg, net, &test.CreateDatabaseConfig{})

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

		params := &GetValueWithVersionParams{
			Type:         resultprocessor.TypeJsonExtractor,
			QueryID:      uuid.New(),
			DocumentID:   uuid.New(),
			QueryVersion: 1,
		}

		_, err := svc.GetValueWithVersion(t.Context(), params)
		require.EqualError(t, err, "no rows in result set")
	})
	t.Run("existing entry", func(t *testing.T) {
		t.Parallel()
		cfg := &serviceconfig.BaseConfig{}
		net := test.GetNetwork(t)
		test.CreateDB(t, cfg, net, &test.CreateDatabaseConfig{})

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

		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)
		filetype := "pdf"
		part := uint16(1)
		key := objectstore.BucketKey{
			CreatedAt: time.Now().UTC(),
			ClientID:  "clientid",
			EntityID:  uuid.New(),
			Location:  objectstore.Import,
			Part:      &part,
			FileType:  &filetype,
		}
		err = cfg.GetDBQueries().AddDocumentEntry(t.Context(), &repository.AddDocumentEntryParams{
			Documentid: docId,
			Bucket:     "bucket",
			Key:        key.String(),
		})
		require.NoError(t, err)
		bucket := "bucket"
		hash := "hash"
		keyStr := key.String()
		cleanId, err := cfg.GetDBQueries().AddDocumentClean(t.Context(), &repository.AddDocumentCleanParams{
			Documentid: docId,
			Bucket:     &bucket,
			Hash:       &hash,
			Key:        &keyStr,
			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:  bucket,
			Hash:    hash,
			Key:     keyStr,
			Part:    part,
			Createdat: pgtype.Timestamp{
				Valid: true,
				Time:  time.Now(),
			},
		})
		require.NoError(t, err)
		err = cfg.GetDBQueries().AddDocumentTextEntry(t.Context(), &repository.AddDocumentTextEntryParams{
			Textid:  textId,
			Version: 1,
		})
		require.NoError(t, err)
		queryId, err := cfg.GetDBQueries().CreateQuery(t.Context(), repository.QuerytypeJsonExtractor)
		require.NoError(t, err)
		queryVersion, err := cfg.GetDBQueries().AddLatestQueryVersion(t.Context(), queryId)
		require.NoError(t, err)
		value := "exaple_value"
		_, err = cfg.GetDBQueries().AddResult(t.Context(), &repository.AddResultParams{
			Queryid:      queryId,
			Value:        value,
			Textentryid:  textId,
			Queryversion: queryVersion,
		})
		require.NoError(t, err)

		params := &GetValueWithVersionParams{
			Type:         resultprocessor.TypeJsonExtractor,
			QueryID:      queryId,
			DocumentID:   docId,
			QueryVersion: 1,
		}

		val, err := svc.GetValueWithVersion(t.Context(), params)
		require.NoError(t, err)
		v := jsonextractor.NewResult(value)
		assert.Equal(t, v, val)
		assert.Equal(t, value, v.GetStoreValue())
	})
	t.Run("not existing version", func(t *testing.T) {
		t.Parallel()
		cfg := &serviceconfig.BaseConfig{}
		net := test.GetNetwork(t)
		test.CreateDB(t, cfg, net, &test.CreateDatabaseConfig{})

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

		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)
		filetype := "pdf"
		part := uint16(1)
		key := objectstore.BucketKey{
			CreatedAt: time.Now().UTC(),
			ClientID:  "clientid",
			EntityID:  uuid.New(),
			Location:  objectstore.Import,
			Part:      &part,
			FileType:  &filetype,
		}
		err = cfg.GetDBQueries().AddDocumentEntry(t.Context(), &repository.AddDocumentEntryParams{
			Documentid: docId,
			Bucket:     "bucket",
			Key:        key.String(),
		})
		require.NoError(t, err)
		bucket := "bucket"
		hash := "hash"
		keyStr := key.String()
		cleanId, err := cfg.GetDBQueries().AddDocumentClean(t.Context(), &repository.AddDocumentCleanParams{
			Documentid: docId,
			Bucket:     &bucket,
			Hash:       &hash,
			Key:        &keyStr,
			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:  bucket,
			Hash:    hash,
			Key:     keyStr,
			Part:    part,
			Createdat: pgtype.Timestamp{
				Valid: true,
				Time:  time.Now(),
			},
		})
		require.NoError(t, err)
		err = cfg.GetDBQueries().AddDocumentTextEntry(t.Context(), &repository.AddDocumentTextEntryParams{
			Textid:  textId,
			Version: 1,
		})
		require.NoError(t, err)
		queryId, err := cfg.GetDBQueries().CreateQuery(t.Context(), repository.QuerytypeJsonExtractor)
		require.NoError(t, err)
		queryVersion, err := cfg.GetDBQueries().AddLatestQueryVersion(t.Context(), queryId)
		require.NoError(t, err)
		value := "exaple_value"
		_, err = cfg.GetDBQueries().AddResult(t.Context(), &repository.AddResultParams{
			Queryid:      queryId,
			Value:        value,
			Textentryid:  textId,
			Queryversion: queryVersion,
		})
		require.NoError(t, err)

		params := &GetValueWithVersionParams{
			Type:         resultprocessor.TypeJsonExtractor,
			QueryID:      queryId,
			DocumentID:   docId,
			QueryVersion: 2,
		}

		_, err = svc.GetValueWithVersion(t.Context(), params)
		require.EqualError(t, err, "no value found")
	})
}