query-orchestration/internal/query/result/processor/parse_test.go

package resultprocessor_test

import (
	"queryorchestration/internal/database"
	"queryorchestration/internal/database/repository"
	resultprocessor "queryorchestration/internal/query/result/processor"
	"testing"

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

func TestParseDBCollectorQuery(t *testing.T) {
	dbResult := repository.Collectorquerydependencytree{
		Jobid:        pgtype.UUID{},
		Queryid:      pgtype.UUID{},
		Requiredids:  []pgtype.UUID{},
		Type:         repository.QuerytypeJsonExtractor,
		Queryversion: 1,
	}
	value, err := resultprocessor.ParseDBCollectorQuery(&dbResult)
	assert.NoError(t, err)
	assert.Equal(t, uuid.Nil, value.ID)
	assert.Nil(t, value.RequiredQueryIDs)
	assert.Equal(t, int32(1), value.Version)
	assert.Equal(t, resultprocessor.Type(resultprocessor.TypeJsonExtractor), value.Type)

	dbResult.Type = repository.Querytype("")
	_, err = resultprocessor.ParseDBCollectorQuery(&dbResult)
	assert.EqualError(t, err, "invalid database query type")
}

func TestParseDBNullType(t *testing.T) {
	qType := repository.NullQuerytype{Valid: true, Querytype: repository.QuerytypeJsonExtractor}
	value, err := resultprocessor.ParseDBNullType(qType)
	assert.NoError(t, err)
	assert.Equal(t, resultprocessor.Type(resultprocessor.TypeJsonExtractor), value)

	qType = repository.NullQuerytype{}
	_, err = resultprocessor.ParseDBNullType(qType)
	assert.EqualError(t, err, "invalid database query type")

	qType = repository.NullQuerytype{Valid: true}
	_, err = resultprocessor.ParseDBNullType(qType)
	assert.EqualError(t, err, "invalid database query type")
}

func TestParseDBType(t *testing.T) {
	qType := repository.QuerytypeJsonExtractor
	value, err := resultprocessor.ParseDBType(qType)
	assert.NoError(t, err)
	assert.Equal(t, resultprocessor.Type(resultprocessor.TypeJsonExtractor), value)

	qType = repository.QuerytypeContextFull
	value, err = resultprocessor.ParseDBType(qType)
	assert.NoError(t, err)
	assert.Equal(t, resultprocessor.Type(resultprocessor.TypeContextFull), value)
}

func TestToDBQueryType(t *testing.T) {
	dbQueryType := resultprocessor.Type(resultprocessor.TypeJsonExtractor)
	value, err := resultprocessor.ToDBQueryType(dbQueryType)
	assert.NoError(t, err)
	assert.Equal(t, repository.Querytype(repository.QuerytypeJsonExtractor), value)

	dbQueryType = resultprocessor.Type(-1)
	_, err = resultprocessor.ToDBQueryType(dbQueryType)
	assert.EqualError(t, err, "invalid database query type")

	dbQueryType = resultprocessor.Type(resultprocessor.TypeContextFull)
	value, err = resultprocessor.ToDBQueryType(dbQueryType)
	assert.NoError(t, err)
	assert.Equal(t, repository.Querytype(repository.QuerytypeContextFull), value)
}

func TestToDBQueryTypeArray(t *testing.T) {
	inArr := []resultprocessor.Type{
		resultprocessor.TypeJsonExtractor,
		resultprocessor.TypeContextFull,
	}
	value, err := resultprocessor.ToDBQueryTypeArray(inArr)
	assert.NoError(t, err)
	assert.Equal(t, []repository.Querytype{
		repository.QuerytypeJsonExtractor,
		repository.QuerytypeContextFull,
	}, value)

	inArr = []resultprocessor.Type{
		resultprocessor.Type(-1),
	}
	_, err = resultprocessor.ToDBQueryTypeArray(inArr)
	assert.EqualError(t, err, "invalid database query type")
}

func TestToDBNullQueryType(t *testing.T) {
	dbQueryType := resultprocessor.Type(resultprocessor.TypeJsonExtractor)
	value, err := resultprocessor.ToDBNullQueryType(dbQueryType)
	assert.NoError(t, err)
	assert.Equal(t, repository.NullQuerytype{Valid: true, Querytype: repository.QuerytypeJsonExtractor}, value)

	dbQueryType = resultprocessor.Type(-1)
	_, err = resultprocessor.ToDBNullQueryType(dbQueryType)
	assert.EqualError(t, err, "invalid database query type")

	dbQueryType = resultprocessor.Type(resultprocessor.TypeContextFull)
	value, err = resultprocessor.ToDBNullQueryType(dbQueryType)
	assert.NoError(t, err)
	assert.Equal(t, repository.NullQuerytype{Valid: true, Querytype: repository.QuerytypeContextFull}, value)
}

func TestParseFullQuery(t *testing.T) {
	var q *repository.Fullactivequery
	out, err := resultprocessor.ParseFullQuery(q)
	assert.NoError(t, err)
	assert.Nil(t, out)

	q = &repository.Fullactivequery{
		ID:            database.MustToDBUUID(uuid.New()),
		Type:          repository.QuerytypeContextFull,
		Activeversion: 1,
		Latestversion: 2,
	}

	out, err = resultprocessor.ParseFullQuery(q)
	assert.NoError(t, err)
	assert.EqualExportedValues(t, &resultprocessor.Query{
		ID:      database.MustToUUID(q.ID),
		Type:    resultprocessor.TypeContextFull,
		Version: 1,
	}, out)

	q = &repository.Fullactivequery{
		ID:            database.MustToDBUUID(uuid.New()),
		Type:          repository.QuerytypeContextFull,
		Activeversion: 1,
		Latestversion: 2,
		Requiredids:   []pgtype.UUID{},
	}

	out, err = resultprocessor.ParseFullQuery(q)
	assert.NoError(t, err)
	assert.EqualExportedValues(t, &resultprocessor.Query{
		ID:      database.MustToUUID(q.ID),
		Type:    resultprocessor.TypeContextFull,
		Version: 1,
	}, out)

	q = &repository.Fullactivequery{
		ID:            database.MustToDBUUID(uuid.New()),
		Type:          repository.QuerytypeContextFull,
		Activeversion: 1,
		Latestversion: 2,
		Config:        []byte("hello"),
		Requiredids: []pgtype.UUID{
			database.MustToDBUUID(uuid.New()),
		},
	}

	out, err = resultprocessor.ParseFullQuery(q)
	assert.NoError(t, err)
	cfg := "hello"
	assert.EqualExportedValues(t, &resultprocessor.Query{
		ID:               database.MustToUUID(q.ID),
		Type:             resultprocessor.TypeContextFull,
		Version:          1,
		Config:           &cfg,
		RequiredQueryIDs: &[]uuid.UUID{database.MustToUUID(q.Requiredids[0])},
	}, out)
}

func TestParseFullQueryArray(t *testing.T) {
	var q []*repository.Fullactivequery
	out, err := resultprocessor.ParseFullQueryArray(q)
	assert.NoError(t, err)
	assert.ElementsMatch(t, []*resultprocessor.Query{}, out)

	q = []*repository.Fullactivequery{
		{
			ID:            database.MustToDBUUID(uuid.New()),
			Type:          repository.QuerytypeContextFull,
			Activeversion: 1,
			Latestversion: 2,
		},
	}

	out, err = resultprocessor.ParseFullQueryArray(q)
	assert.NoError(t, err)
	assert.EqualExportedValues(t, []*resultprocessor.Query{
		{
			ID:      database.MustToUUID(q[0].ID),
			Type:    resultprocessor.TypeContextFull,
			Version: 1,
		},
	}, out)

}