query-orchestration/internal/job/updateprivate_test.go

package job

import (
	"context"
	"queryorchestration/internal/client"
	"queryorchestration/internal/database"
	"queryorchestration/internal/database/repository"
	"queryorchestration/internal/serviceconfig"
	"testing"

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

func TestNormalizeCanSync(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 := New(cfg, &Services{
		Client: client.New(cfg),
	})

	j := Job{
		ID:       uuid.New(),
		ClientID: uuid.New(),
		CanSync:  false,
	}

	update := Update{
		ID: j.ID,
	}

	err = svc.normalizeCanSync(ctx, &j, &update)
	assert.NoError(t, err)
	assert.Nil(t, update.CanSync)

	cs := false
	update.CanSync = &cs
	err = svc.normalizeCanSync(ctx, &j, &update)
	assert.NoError(t, err)
	assert.Nil(t, update.CanSync)

	pool.ExpectQuery("name: GetClient :one").WithArgs(database.MustToDBUUID(j.ClientID)).
		WillReturnRows(
			pgxmock.NewRows([]string{"id", "name", "canSync"}).
				AddRow(database.MustToDBUUID(j.ClientID), "client_name", false),
		)

	cs = true
	update.CanSync = &cs
	err = svc.normalizeCanSync(ctx, &j, &update)
	assert.Error(t, err)

	pool.ExpectQuery("name: GetClient :one").WithArgs(database.MustToDBUUID(j.ClientID)).
		WillReturnRows(
			pgxmock.NewRows([]string{"id", "name", "canSync"}).
				AddRow(database.MustToDBUUID(j.ClientID), "client_name", true),
		)

	cs = false
	update.CanSync = &cs
	err = svc.normalizeCanSync(ctx, &j, &update)
	assert.NoError(t, err)
	assert.Nil(t, update.CanSync)

	pool.ExpectQuery("name: GetClient :one").WithArgs(database.MustToDBUUID(j.ClientID)).
		WillReturnRows(
			pgxmock.NewRows([]string{"id", "name", "canSync"}).
				AddRow(database.MustToDBUUID(j.ClientID), "client_name", true),
		)

	cs = true
	update.CanSync = &cs
	err = svc.normalizeCanSync(ctx, &j, &update)
	assert.NoError(t, err)
	assert.True(t, *update.CanSync)

	j.CanSync = true
	cs = true
	update.CanSync = &cs
	err = svc.normalizeCanSync(ctx, &j, &update)
	assert.NoError(t, err)
	assert.Nil(t, update.CanSync)
}

func TestNormalizeUpdate(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 := New(cfg, &Services{
		Client: client.New(cfg),
	})

	j := Job{
		ID:       uuid.New(),
		ClientID: uuid.New(),
		CanSync:  true,
	}

	ucs := false
	update := Update{
		ID:      j.ID,
		CanSync: &ucs,
	}

	err = svc.normalizeUpdate(ctx, &j, &update)
	assert.NoError(t, err)
	ucs = !ucs
	assert.EqualExportedValues(t, Update{ID: update.ID, CanSync: &ucs}, update)
}

func TestSubmitUpdate(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,
	}

	j := Job{
		ID: uuid.New(),
	}
	u := &Update{
		ID: j.ID,
	}

	pool.ExpectBegin()
	pool.ExpectCommit()

	err = svc.submitUpdate(ctx, u)
	assert.NoError(t, err)

	ucs := true
	u = &Update{
		ID:      j.ID,
		CanSync: &ucs,
	}

	pool.ExpectBegin()
	pool.ExpectExec("name: AddJobCanSync :exec").WithArgs(*u.CanSync, database.MustToDBUUID(j.ID)).
		WillReturnResult(pgxmock.NewResult("", 1))
	pool.ExpectCommit()

	err = svc.submitUpdate(ctx, u)
	assert.NoError(t, err)
}