query-orchestration/internal/query/normalize_test.go

package query

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

	"github.com/google/uuid"
	"github.com/pashagolub/pgxmock/v3"
	"github.com/stretchr/testify/assert"
)

func TestNormalizeConfig(t *testing.T) {
	s := Service{}

	err := s.normalizeConfig(nil)
	assert.Nil(t, err)

	entity := resultprocessor.Create{}

	entity.Config = nil
	err = s.normalizeConfig(&entity)
	assert.Nil(t, err)
	assert.Nil(t, entity.Config)

	cfg := ""
	entity.Config = &cfg
	err = s.normalizeConfig(&entity)
	assert.Nil(t, err)
	assert.Nil(t, entity.Config)

	cfg = "   	"
	entity.Config = &cfg
	err = s.normalizeConfig(&entity)
	assert.Nil(t, err)
	assert.Nil(t, entity.Config)

	cfg = "{}"
	entity.Config = &cfg
	err = s.normalizeConfig(&entity)
	assert.Nil(t, err)
	assert.Equal(t, "{}", *(entity.Config))

	cfg = "{\"hello\":\"bye\"}"
	entity.Config = &cfg
	err = s.normalizeConfig(&entity)
	assert.Nil(t, err)
	assert.Equal(t, "{\"hello\":\"bye\"}", *(entity.Config))

	cfg = "		   {  \"hello\"  :  	\"bye\"   }     "
	entity.Config = &cfg
	err = s.normalizeConfig(&entity)
	assert.Nil(t, err)
	assert.Equal(t, "{\"hello\":\"bye\"}", *(entity.Config))

	cfg = "{'hello':'bye'}"
	entity.Config = &cfg
	err = s.normalizeConfig(&entity)
	assert.Error(t, err)

	cfg = "{\"hello\":\"}"
	entity.Config = &cfg
	err = s.normalizeConfig(&entity)
	assert.Error(t, err)
}

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

	pool, err := pgxmock.NewPool()
	if err != nil {
		t.Fatalf("failed to open pgxmock database: %v", err)
	}
	queries := repository.New(pool)
	db := &database.Connection{
		Queries: queries,
		Pool:    pool,
	}
	s := Service{db: db}

	err = s.NormalizeQueryIDs(ctx, nil)
	assert.Nil(t, err)

	entity := resultprocessor.Create{}

	entity.RequiredQueryIDs = nil
	err = s.NormalizeQueryIDs(ctx, &entity)
	assert.Nil(t, err)
	assert.Nil(t, entity.RequiredQueryIDs)

	entity.RequiredQueryIDs = &[]uuid.UUID{}
	err = s.NormalizeQueryIDs(ctx, &entity)
	assert.Nil(t, err)
	assert.Nil(t, entity.RequiredQueryIDs)

	ids := []uuid.UUID{uuid.New()}
	entity.RequiredQueryIDs = &ids
	dbids := database.MustToDBUUIDArray(*entity.RequiredQueryIDs)

	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).WillReturnRows(
		pgxmock.NewRows([]string{"all_exist"}).
			AddRow(true),
	)

	err = s.NormalizeQueryIDs(ctx, &entity)
	assert.Nil(t, err)
	assert.ElementsMatch(t, ids, *entity.RequiredQueryIDs)

	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).WillReturnRows(
		pgxmock.NewRows([]string{"all_exist"}).
			AddRow(false),
	)

	err = s.NormalizeQueryIDs(ctx, &entity)
	assert.Error(t, err)
	assert.ElementsMatch(t, ids, *entity.RequiredQueryIDs)

	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).
		WillReturnError(errors.New("database failure"))

	err = s.NormalizeQueryIDs(ctx, &entity)
	assert.Error(t, err)
	assert.ElementsMatch(t, ids, *entity.RequiredQueryIDs)

	singleid := uuid.New()
	entity.RequiredQueryIDs = &[]uuid.UUID{singleid, singleid}
	outids := []uuid.UUID{singleid}
	dbids = database.MustToDBUUIDArray(outids)

	pool.ExpectQuery("name: AllQueriesExist :one").WithArgs(dbids).WillReturnRows(
		pgxmock.NewRows([]string{"all_exist"}).
			AddRow(true),
	)

	err = s.NormalizeQueryIDs(ctx, &entity)
	assert.Nil(t, err)
	assert.ElementsMatch(t, outids, *entity.RequiredQueryIDs)
}

func TestNormalizeActiveVersion(t *testing.T) {
	s := Service{}

	err := s.normalizeActiveVersion(nil, nil)
	assert.Error(t, err)

	current := Query{
		ActiveVersion: 2,
		LatestVersion: 4,
	}
	entity := resultprocessor.Update{}

	err = s.normalizeActiveVersion(nil, &entity)
	assert.Error(t, err)

	err = s.normalizeActiveVersion(&current, nil)
	assert.Nil(t, err)

	err = s.normalizeActiveVersion(&current, &entity)
	assert.Nil(t, err)

	entity.ActiveVersion = &current.ActiveVersion
	err = s.normalizeActiveVersion(&current, &entity)
	assert.Nil(t, err)
	assert.Nil(t, entity.ActiveVersion)

	aV := current.ActiveVersion + 1
	entity.ActiveVersion = &aV
	err = s.normalizeActiveVersion(&current, &entity)
	assert.Nil(t, err)
	assert.Equal(t, aV, *entity.ActiveVersion)

	aV = current.LatestVersion + 2
	entity.ActiveVersion = &aV
	err = s.normalizeActiveVersion(&current, &entity)
	assert.Error(t, err)

	aV = 0
	entity.ActiveVersion = &aV
	err = s.normalizeActiveVersion(&current, &entity)
	assert.Error(t, err)
}