@stackonward/cli 0.0.1 → 1.0.1

package/dist/resources/templates/go-backend/internal/core/commandreplay/service_persistence_test.go

@@ -0,0 +1,432 @@
+package commandreplay_test
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"os"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/jackc/pgx/v5"
+	"github.com/jackc/pgx/v5/stdlib"
+	"gorm.io/driver/postgres"
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+
+	commandreplay "{{module}}/internal/core/commandreplay"
+	"{{module}}/internal/core/database"
+	"{{module}}/pkg/apierror"
+)
+
+func TestCommandReplayExecuteStandaloneCommitsBusinessFailure(t *testing.T) {
+	service, repo := newPersistentCommandReplayService(t)
+	businessErr := apierror.Conflict("payment_declined", "Payment was declined")
+	ctx := context.Background()
+
+	result, err := service.Execute(ctx, persistentCommandReplayRequest(json.RawMessage(`{"amount":100}`)), func(ctx context.Context, record *commandreplay.CommandReplayRecord) (*commandreplay.CommandReplayCommandResult, error) {
+		if record.ID == 0 {
+			t.Fatalf("record.ID = 0, want persisted id")
+		}
+		return &commandreplay.CommandReplayCommandResult{
+			Status:      commandreplay.CommandReplayStatusFailed,
+			ErrorCode:   "payment_declined",
+			ReturnError: businessErr,
+		}, nil
+	})
+	if !errors.Is(err, businessErr) {
+		t.Fatalf("Execute() error = %v, want businessErr", err)
+	}
+	if result == nil || result.Status != commandreplay.CommandReplayStatusFailed {
+		t.Fatalf("Execute() result = %#v, want failed result", result)
+	}
+
+	stored, err := repo.FindByScope(ctx, "test.command.replay", "quote:123", "key-123")
+	if err != nil {
+		t.Fatalf("FindByScope() error = %v", err)
+	}
+	if stored == nil {
+		t.Fatalf("stored record = nil, want committed failed record")
+	}
+	if stored.Status != commandreplay.CommandReplayStatusFailed {
+		t.Fatalf("stored Status = %q, want failed", stored.Status)
+	}
+	if stored.ErrorCode == nil || *stored.ErrorCode != "payment_declined" {
+		t.Fatalf("stored ErrorCode = %v, want payment_declined", stored.ErrorCode)
+	}
+	if stored.ErrorStatus == nil || *stored.ErrorStatus != http.StatusConflict {
+		t.Fatalf("stored ErrorStatus = %v, want 409", stored.ErrorStatus)
+	}
+	if string(stored.ResponsePayload) != `{"error":{"code":"payment_declined","message":"Payment was declined","type":"invalid_request_error"}}` {
+		t.Fatalf("stored ResponsePayload = %s, want canonical object", stored.ResponsePayload)
+	}
+	if stored.CompletedAt == nil {
+		t.Fatalf("stored CompletedAt = nil, want committed completion time")
+	}
+
+	replayed, err := service.Execute(ctx, persistentCommandReplayRequest(json.RawMessage(`{"amount":100}`)), func(ctx context.Context, record *commandreplay.CommandReplayRecord) (*commandreplay.CommandReplayCommandResult, error) {
+		t.Fatalf("fn should not be invoked for persisted terminal replay")
+		return nil, nil
+	})
+	assertPersistentAPIError(t, err, http.StatusConflict, "payment_declined")
+	if replayed == nil || !replayed.Replayed || replayed.Status != commandreplay.CommandReplayStatusFailed {
+		t.Fatalf("Execute() replay result = %#v, want replayed failed result", replayed)
+	}
+}
+
+func TestCommandReplayExecuteStandaloneRollsBackInfrastructureError(t *testing.T) {
+	service, repo, db, _ := newPersistentCommandReplayFixture(t)
+	infraErr := errors.New("database unavailable")
+	ctx := context.Background()
+	createPersistentCommandReplaySideEffectSchema(t, db)
+
+	_, err := service.Execute(ctx, persistentCommandReplayRequest(json.RawMessage(`{"amount":100}`)), func(ctx context.Context, record *commandreplay.CommandReplayRecord) (*commandreplay.CommandReplayCommandResult, error) {
+		if record.ID == 0 {
+			t.Fatalf("record.ID = 0, want persisted id before rollback")
+		}
+		if err := database.GetDB(ctx, db).Exec(`INSERT INTO command_replay_test_state (id, value) VALUES (1, 'settled')`).Error; err != nil {
+			return nil, fmt.Errorf("insert command state: %w", err)
+		}
+		if err := database.GetDB(ctx, db).Exec(`INSERT INTO command_replay_test_outbox (id, payload) VALUES (1, '{"event":"settled"}')`).Error; err != nil {
+			return nil, fmt.Errorf("insert command outbox: %w", err)
+		}
+		return nil, infraErr
+	})
+	if !errors.Is(err, infraErr) {
+		t.Fatalf("Execute() error = %v, want infraErr", err)
+	}
+
+	stored, err := repo.FindByScope(ctx, "test.command.replay", "quote:123", "key-123")
+	if err != nil {
+		t.Fatalf("FindByScope() error = %v", err)
+	}
+	if stored != nil {
+		t.Fatalf("stored record = %#v, want rollback to remove started record", stored)
+	}
+	assertPersistentCommandReplayCount(t, db, "command_replay_test_state", 0)
+	assertPersistentCommandReplayCount(t, db, "command_replay_test_outbox", 0)
+}
+
+func TestCommandReplayExecuteJoinsOuterTransactionRollback(t *testing.T) {
+	service, repo, db, manager := newPersistentCommandReplayFixture(t)
+	ctx := context.Background()
+	rollbackErr := errors.New("rollback authoritative command")
+	createPersistentCommandReplaySideEffectSchema(t, db)
+
+	err := manager.WithTransaction(ctx, func(txCtx context.Context) error {
+		outerDB := database.GetDB(txCtx, db)
+		result, executeErr := service.Execute(txCtx, persistentCommandReplayRequest(json.RawMessage(`{"amount":100}`)), func(commandCtx context.Context, record *commandreplay.CommandReplayRecord) (*commandreplay.CommandReplayCommandResult, error) {
+			if database.GetDB(commandCtx, db) != outerDB {
+				return nil, errors.New("command replay did not join the outer transaction")
+			}
+			if err := database.GetDB(commandCtx, db).Exec(`INSERT INTO command_replay_test_state (id, value) VALUES (1, 'settled')`).Error; err != nil {
+				return nil, fmt.Errorf("insert command state: %w", err)
+			}
+			if err := database.GetDB(commandCtx, db).Exec(`INSERT INTO command_replay_test_outbox (id, payload) VALUES (1, '{"event":"settled"}')`).Error; err != nil {
+				return nil, fmt.Errorf("insert command outbox: %w", err)
+			}
+			return &commandreplay.CommandReplayCommandResult{
+				Status:          commandreplay.CommandReplayStatusSucceeded,
+				ResponsePayload: json.RawMessage(`{"status":"settled"}`),
+			}, nil
+		})
+		if executeErr != nil {
+			return executeErr
+		}
+		if result == nil || result.Status != commandreplay.CommandReplayStatusSucceeded {
+			return fmt.Errorf("unexpected command replay result: %#v", result)
+		}
+		return rollbackErr
+	})
+	if !errors.Is(err, rollbackErr) {
+		t.Fatalf("WithTransaction() error = %v, want rollbackErr", err)
+	}
+
+	stored, err := repo.FindByScope(ctx, "test.command.replay", "quote:123", "key-123")
+	if err != nil {
+		t.Fatalf("FindByScope() error = %v", err)
+	}
+	if stored != nil {
+		t.Fatalf("stored record = %#v, want outer rollback to remove replay record", stored)
+	}
+	assertPersistentCommandReplayCount(t, db, "command_replay_test_state", 0)
+	assertPersistentCommandReplayCount(t, db, "command_replay_test_outbox", 0)
+}
+
+func TestCommandReplayExecuteRejectsConcurrentDuplicateOnPostgres(t *testing.T) {
+	db := openPersistentCommandReplayPostgres(t)
+	repo := commandreplay.NewCommandReplayRepository(db)
+	service := commandreplay.NewCommandReplayService(repo, database.NewTransactionManager(db))
+	ctx := context.Background()
+	firstStarted := make(chan struct{})
+	releaseFirst := make(chan struct{})
+	firstDone := make(chan error, 1)
+	releasedFirst := false
+	defer func() {
+		if !releasedFirst {
+			close(releaseFirst)
+		}
+	}()
+	var executions atomic.Int32
+
+	go func() {
+		_, err := service.Execute(ctx, persistentCommandReplayRequest(json.RawMessage(`{"amount":100}`)), func(ctx context.Context, record *commandreplay.CommandReplayRecord) (*commandreplay.CommandReplayCommandResult, error) {
+			executions.Add(1)
+			close(firstStarted)
+			<-releaseFirst
+			return &commandreplay.CommandReplayCommandResult{
+				Status:          commandreplay.CommandReplayStatusSucceeded,
+				ResponsePayload: json.RawMessage(`{"status":"created"}`),
+			}, nil
+		})
+		firstDone <- err
+	}()
+
+	select {
+	case <-firstStarted:
+	case <-time.After(5 * time.Second):
+		close(releaseFirst)
+		t.Fatal("first command did not enter its transaction")
+	}
+
+	_, duplicateErr := service.Execute(ctx, persistentCommandReplayRequest(json.RawMessage(`{"amount":100}`)), func(ctx context.Context, record *commandreplay.CommandReplayRecord) (*commandreplay.CommandReplayCommandResult, error) {
+		executions.Add(1)
+		return nil, errors.New("concurrent duplicate executed business logic")
+	})
+	assertPersistentAPIError(t, duplicateErr, http.StatusConflict, "command_replay_in_progress")
+	close(releaseFirst)
+	releasedFirst = true
+
+	select {
+	case err := <-firstDone:
+		if err != nil {
+			t.Fatalf("first Execute() error = %v", err)
+		}
+	case <-time.After(5 * time.Second):
+		t.Fatal("first command did not complete")
+	}
+	if executions.Load() != 1 {
+		t.Fatalf("business executions = %d, want 1", executions.Load())
+	}
+
+	stored, err := repo.FindByScope(ctx, "test.command.replay", "quote:123", "key-123")
+	if err != nil {
+		t.Fatalf("FindByScope() error = %v", err)
+	}
+	if stored == nil || stored.Status != commandreplay.CommandReplayStatusSucceeded {
+		t.Fatalf("stored record = %#v, want one succeeded record", stored)
+	}
+}
+
+func newPersistentCommandReplayService(t *testing.T) (*commandreplay.CommandReplayService, commandreplay.CommandReplayRepository) {
+	t.Helper()
+	service, repo, _, _ := newPersistentCommandReplayFixture(t)
+	return service, repo
+}
+
+func newPersistentCommandReplayFixture(t *testing.T) (*commandreplay.CommandReplayService, commandreplay.CommandReplayRepository, *gorm.DB, *database.TransactionManager) {
+	t.Helper()
+
+	name := strings.NewReplacer("/", "_", " ", "_").Replace(t.Name())
+	db, err := gorm.Open(sqlite.Open(fmt.Sprintf("file:%s?mode=memory&cache=shared&_loc=auto", name)), &gorm.Config{})
+	if err != nil {
+		t.Fatalf("open sqlite: %v", err)
+	}
+	createPersistentCommandReplayRecordSchema(t, db)
+
+	repo := sqliteCommandReplayRepository{CommandReplayRepository: commandreplay.NewCommandReplayRepository(db)}
+	manager := database.NewTransactionManager(db)
+	return commandreplay.NewCommandReplayService(repo, manager), repo, db, manager
+}
+
+type sqliteCommandReplayRepository struct {
+	commandreplay.CommandReplayRepository
+}
+
+func (r sqliteCommandReplayRepository) TryAcquireScopeLock(ctx context.Context, namespace, commandScope, idempotencyKey string) (bool, error) {
+	return true, nil
+}
+
+func persistentCommandReplayRequest(payload json.RawMessage) commandreplay.CommandReplayBeginRequest {
+	return commandreplay.CommandReplayBeginRequest{
+		Namespace:      "test.command.replay",
+		CommandScope:   "quote:123",
+		IdempotencyKey: "key-123",
+		RequestPayload: payload,
+		Metadata:       json.RawMessage(`{"source":"test"}`),
+		TTL:            time.Hour,
+	}
+}
+
+func createPersistentCommandReplayRecordSchema(t *testing.T, db *gorm.DB) {
+	t.Helper()
+
+	if err := db.Exec(`
+		CREATE TABLE sys_command_replay_records (
+			id INTEGER PRIMARY KEY AUTOINCREMENT,
+			created_at DATETIME NOT NULL,
+			updated_at DATETIME NOT NULL,
+			namespace TEXT NOT NULL,
+			command_scope TEXT NOT NULL,
+			idempotency_key TEXT NOT NULL,
+			request_hash TEXT NOT NULL,
+			principal_type TEXT,
+			principal_ref TEXT,
+			status TEXT NOT NULL DEFAULT 'started',
+			response_payload TEXT NOT NULL DEFAULT '{}',
+			error_code TEXT,
+			error_status INTEGER,
+			expires_at DATETIME NOT NULL,
+			completed_at DATETIME,
+			external_reference_type TEXT,
+			external_reference_no TEXT,
+			execution_token_hash TEXT,
+			lease_expires_at DATETIME,
+			external_next_recovery_at DATETIME,
+			external_attempt_count INTEGER NOT NULL DEFAULT 0,
+			external_last_error_code TEXT,
+			metadata TEXT NOT NULL DEFAULT '{}'
+		)
+	`).Error; err != nil {
+		t.Fatalf("create command replay schema: %v", err)
+	}
+	if err := db.Exec(`
+		CREATE UNIQUE INDEX uk_sys_command_replay_records_namespace_scope_key
+		ON sys_command_replay_records (namespace, command_scope, idempotency_key)
+	`).Error; err != nil {
+		t.Fatalf("create command replay unique index: %v", err)
+	}
+}
+
+func createPersistentCommandReplaySideEffectSchema(t *testing.T, db *gorm.DB) {
+	t.Helper()
+	if err := db.Exec(`CREATE TABLE command_replay_test_state (id INTEGER PRIMARY KEY, value TEXT NOT NULL)`).Error; err != nil {
+		t.Fatalf("create command state table: %v", err)
+	}
+	if err := db.Exec(`CREATE TABLE command_replay_test_outbox (id INTEGER PRIMARY KEY, payload TEXT NOT NULL)`).Error; err != nil {
+		t.Fatalf("create command outbox table: %v", err)
+	}
+}
+
+func openPersistentCommandReplayPostgres(t *testing.T) *gorm.DB {
+	t.Helper()
+	baseDSN := strings.TrimSpace(os.Getenv("ONEX_TEST_POSTGRES_DSN"))
+	if baseDSN == "" {
+		t.Skip("ONEX_TEST_POSTGRES_DSN is not set")
+	}
+	adminConfig, err := pgx.ParseConfig(baseDSN)
+	if err != nil {
+		t.Fatalf("parse PostgreSQL test DSN: %v", err)
+	}
+	adminSQLDB := stdlib.OpenDB(*adminConfig)
+	if err := adminSQLDB.PingContext(context.Background()); err != nil {
+		_ = adminSQLDB.Close()
+		t.Fatalf("ping PostgreSQL admin database: %v", err)
+	}
+	databaseName := fmt.Sprintf("command_replay_%d", time.Now().UnixNano())
+	if _, err := adminSQLDB.ExecContext(context.Background(), `CREATE DATABASE "`+databaseName+`"`); err != nil {
+		_ = adminSQLDB.Close()
+		t.Fatalf("create PostgreSQL test database: %v", err)
+	}
+
+	testConfig := adminConfig.Copy()
+	testConfig.Database = databaseName
+	testSQLDB := stdlib.OpenDB(*testConfig)
+	if err := testSQLDB.PingContext(context.Background()); err != nil {
+		_ = testSQLDB.Close()
+		_ = adminSQLDB.Close()
+		t.Fatalf("ping PostgreSQL test database: %v", err)
+	}
+	db, err := gorm.Open(postgres.New(postgres.Config{Conn: testSQLDB}), &gorm.Config{Logger: logger.Default.LogMode(logger.Silent)})
+	if err != nil {
+		_ = testSQLDB.Close()
+		_ = adminSQLDB.Close()
+		t.Fatalf("open PostgreSQL test database: %v", err)
+	}
+	t.Cleanup(func() {
+		if err := testSQLDB.Close(); err != nil {
+			t.Errorf("close PostgreSQL test database: %v", err)
+		}
+		if _, err := adminSQLDB.ExecContext(
+			context.Background(),
+			"SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = $1 AND pid <> pg_backend_pid()",
+			databaseName,
+		); err != nil {
+			t.Errorf("terminate PostgreSQL test sessions: %v", err)
+		}
+		if _, err := adminSQLDB.ExecContext(context.Background(), `DROP DATABASE IF EXISTS "`+databaseName+`"`); err != nil {
+			t.Errorf("drop PostgreSQL test database: %v", err)
+		}
+		if err := adminSQLDB.Close(); err != nil {
+			t.Errorf("close PostgreSQL admin database: %v", err)
+		}
+	})
+	createPersistentCommandReplayPostgresSchema(t, db)
+	return db
+}
+
+func createPersistentCommandReplayPostgresSchema(t *testing.T, db *gorm.DB) {
+	t.Helper()
+	if err := db.Exec(`
+		CREATE TABLE sys_command_replay_records (
+			id BIGSERIAL PRIMARY KEY,
+			created_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+			updated_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP,
+			namespace VARCHAR(200) NOT NULL,
+			command_scope VARCHAR(128) NOT NULL,
+			idempotency_key VARCHAR(191) NOT NULL,
+			request_hash CHAR(64) NOT NULL,
+			principal_type VARCHAR(32),
+			principal_ref VARCHAR(64),
+			status VARCHAR(20) NOT NULL DEFAULT 'started',
+			response_payload JSONB NOT NULL DEFAULT '{}'::jsonb,
+			error_code VARCHAR(120),
+			error_status INTEGER,
+			expires_at TIMESTAMPTZ NOT NULL,
+			completed_at TIMESTAMPTZ,
+			external_reference_type VARCHAR(64),
+			external_reference_no VARCHAR(191),
+			execution_token_hash CHAR(64),
+			lease_expires_at TIMESTAMPTZ,
+			external_next_recovery_at TIMESTAMPTZ,
+			external_attempt_count INTEGER NOT NULL DEFAULT 0,
+			external_last_error_code VARCHAR(120),
+			metadata JSONB NOT NULL DEFAULT '{}'::jsonb,
+			CONSTRAINT uk_sys_command_replay_records_namespace_scope_key
+				UNIQUE (namespace, command_scope, idempotency_key)
+		)
+	`).Error; err != nil {
+		t.Fatalf("create PostgreSQL command replay schema: %v", err)
+	}
+}
+
+func assertPersistentCommandReplayCount(t *testing.T, db *gorm.DB, table string, want int64) {
+	t.Helper()
+	var count int64
+	if err := db.Table(table).Count(&count).Error; err != nil {
+		t.Fatalf("count %s: %v", table, err)
+	}
+	if count != want {
+		t.Fatalf("%s count = %d, want %d", table, count, want)
+	}
+}
+
+func assertPersistentAPIError(t *testing.T, err error, status int, code string) {
+	t.Helper()
+
+	var apiErr *apierror.APIError
+	if !errors.As(err, &apiErr) {
+		t.Fatalf("error = %v, want APIError", err)
+	}
+	if apiErr.Status != status {
+		t.Fatalf("APIError.Status = %d, want %d", apiErr.Status, status)
+	}
+	if apiErr.Detail.Code != code {
+		t.Fatalf("APIError.Code = %q, want %q", apiErr.Detail.Code, code)
+	}
+}