query-orchestration/internal/client/update/update_test.go

// Package clientupdate tests for client update functionality.
// Note: Mock-based tests have been removed. See remove_texttract_and_mocks_plan.md.
package clientupdate

import (
	"testing"

	"queryorchestration/internal/client"
	"queryorchestration/internal/database/repository"
	"queryorchestration/internal/serviceconfig"
	"queryorchestration/internal/serviceconfig/queue/clientsync"

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

type Config struct {
	serviceconfig.BaseConfig
	clientsync.ClientSyncConfig
}

func TestUpdate(t *testing.T) {
	ctx := t.Context()

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

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

	c := client.Client{
		ID:      "huhu",
		Name:    "example_name",
		CanSync: false,
	}
	update := Update{}

	pool.ExpectQuery("name: GetClient :one").WithArgs(c.ID).
		WillReturnRows(
			pgxmock.NewRows([]string{"id", "name", "canSync"}).
				AddRow(c.ID, c.Name, c.CanSync),
		)

	err = svc.Update(ctx, c.ID, &update)
	assert.Error(t, err)

	c.CanSync = false
	update.CanSync = &c.CanSync

	pool.ExpectQuery("name: GetClient :one").WithArgs(c.ID).
		WillReturnRows(
			pgxmock.NewRows([]string{"id", "name", "canSync"}).
				AddRow(c.ID, c.Name, c.CanSync),
		)

	err = svc.Update(ctx, c.ID, &update)
	assert.Error(t, err)

	c.Name = "updated_name"
	update.Name = &c.Name

	pool.ExpectQuery("name: GetClient :one").WithArgs(c.ID).
		WillReturnRows(
			pgxmock.NewRows([]string{"id", "name", "canSync"}).
				AddRow(c.ID, c.Name, c.CanSync),
		)
	pool.ExpectExec("name: UpdateClient :exec").WithArgs(*update.Name, c.ID).
		WillReturnResult(pgxmock.NewResult("", 1))

	err = svc.Update(ctx, c.ID, &update)
	assert.Error(t, err)
}

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

	err := svc.normalizeUpdateParams("huhu", nil, nil)
	assert.Error(t, err)

	current := &client.Client{
		ID:   "hi",
		Name: "client",
	}
	update := &Update{}

	err = svc.normalizeUpdateParams(current.ID, current, update)
	assert.Error(t, err)

	n := "updated_client"
	cs := true
	update = &Update{
		Name:    &n,
		CanSync: &cs,
	}
	err = svc.normalizeUpdateParams(current.ID, current, update)
	require.NoError(t, err)
	n = "updated_client"
	cs = true
	assert.EqualExportedValues(t, Update{
		Name:    &n,
		CanSync: &cs,
	}, *update)

	update = &Update{
		Name:    &current.Name,
		CanSync: &current.CanSync,
	}
	err = svc.normalizeUpdateParams(current.ID, current, update)
	assert.Error(t, err)
}

func TestSubmitUpdate(t *testing.T) {
	ctx := t.Context()

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

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

	c := client.Client{
		ID:      "hello",
		Name:    "example_name",
		CanSync: false,
	}
	update := Update{}

	pool.ExpectBegin()
	pool.ExpectCommit()

	err = svc.submitUpdate(ctx, c.ID, &update)
	require.NoError(t, err)

	c.CanSync = true
	update.CanSync = &c.CanSync

	pool.ExpectBegin()
	pool.ExpectExec("name: AddClientCanSync :exec").WithArgs(*update.CanSync, c.ID).
		WillReturnResult(pgxmock.NewResult("", 1))
	pool.ExpectCommit()

	err = svc.submitUpdate(ctx, c.ID, &update)
	require.NoError(t, err)

	c.Name = "updated_name"
	update.Name = &c.Name
	update.CanSync = nil

	pool.ExpectBegin()
	pool.ExpectExec("name: UpdateClient :exec").WithArgs(*update.Name, c.ID).
		WillReturnResult(pgxmock.NewResult("", 1))
	pool.ExpectCommit()

	err = svc.submitUpdate(ctx, c.ID, &update)
	require.NoError(t, err)
}

// Note: TestInformUpdate was removed as it used SQS mocks.
// Real SQS tests should be added using LocalStack via testcontainers.