refactor: extract shared test context helpers and per-service test helpers (#1791)

* refactor: extract shared test context helpers and per-service test helpers

Task 22: Add testdb.ContextWithTenant and testdb.ContextWithDefaultTenant
helpers to shared/platform/testdb/context.go, reducing repetitive
tenant.WithTenant(context.Background(), ...) boilerplate across 382+
test occurrences. Migrate 8 high-traffic test files to use the new helpers.

Task 23: Create testhelpers/ packages for 5 services (current-account,
internal-account, position-keeping, reconciliation, reference-data) with
entity factory functions that consolidate duplicated test setup patterns.
Migrate reconciliation service tests to use the shared factories.

* fix: correct gofmt formatting in migrated test files

* fix: add missing newline at end of audit_tables.go

---------

Co-authored-by: Ben Coombs <bjcoombs@users.noreply.github.com>

Author: bjcoombs

services/current-account/service/fungibility_validator_test.go

@@ -11,7 +11,7 @@ import (
 
 	"github.com/meridianhub/meridian/services/reference-data/cache"
 	"github.com/meridianhub/meridian/services/reference-data/registry"
-	"github.com/meridianhub/meridian/shared/platform/tenant"
+	"github.com/meridianhub/meridian/shared/platform/testdb"
 )
 
 // Test sentinel errors for wrapping.
@@ -61,7 +61,7 @@ func (m *mockFungibilityKeyProgram) Eval(activation interface{}) (interface{}, e
 
 func TestFungibilityValidator_ValidateDoubleEntry_FullyFungible(t *testing.T) {
 	// Instrument with empty fungibility_key_expression is fully fungible
-	ctx := tenant.WithTenant(context.Background(), "test-tenant")
+	ctx := testdb.ContextWithTenant(t, "test-tenant")
 
 	mock := &mockInstrumentGetter{
 		instruments: map[string]*cache.CachedInstrument{
@@ -84,7 +84,7 @@ func TestFungibilityValidator_ValidateDoubleEntry_FullyFungible(t *testing.T) {
 
 func TestFungibilityValidator_ValidateDoubleEntry_MatchingKeys(t *testing.T) {
 	// Instrument with fungibility_key_expression where attributes produce matching keys
-	ctx := tenant.WithTenant(context.Background(), "test-tenant")
+	ctx := testdb.ContextWithTenant(t, "test-tenant")
 
 	mock := &mockInstrumentGetter{
 		instruments: map[string]*cache.CachedInstrument{
@@ -118,7 +118,7 @@ func TestFungibilityValidator_ValidateDoubleEntry_MatchingKeys(t *testing.T) {
 
 func TestFungibilityValidator_ValidateDoubleEntry_MismatchedKeys(t *testing.T) {
 	// Instrument with fungibility_key_expression where attributes produce different keys
-	ctx := tenant.WithTenant(context.Background(), "test-tenant")
+	ctx := testdb.ContextWithTenant(t, "test-tenant")
 
 	mock := &mockInstrumentGetter{
 		instruments: map[string]*cache.CachedInstrument{
@@ -150,7 +150,7 @@ func TestFungibilityValidator_ValidateDoubleEntry_MismatchedKeys(t *testing.T) {
 }
 
 func TestFungibilityValidator_ValidateDoubleEntry_InstrumentNotFound(t *testing.T) {
-	ctx := tenant.WithTenant(context.Background(), "test-tenant")
+	ctx := testdb.ContextWithTenant(t, "test-tenant")
 
 	mock := &mockInstrumentGetter{
 		instruments: map[string]*cache.CachedInstrument{}, // Empty - no instruments
@@ -164,7 +164,7 @@ func TestFungibilityValidator_ValidateDoubleEntry_InstrumentNotFound(t *testing.
 }
 
 func TestFungibilityValidator_ValidateDoubleEntry_InstrumentLookupError(t *testing.T) {
-	ctx := tenant.WithTenant(context.Background(), "test-tenant")
+	ctx := testdb.ContextWithTenant(t, "test-tenant")
 
 	mock := &mockInstrumentGetter{
 		err: fmt.Errorf("lookup failed: %w", errFungibilityTestConnRefused),
@@ -179,7 +179,7 @@ func TestFungibilityValidator_ValidateDoubleEntry_InstrumentLookupError(t *testi
 
 func TestFungibilityValidator_ValidateDoubleEntry_NilAttributes(t *testing.T) {
 	// Test that nil attributes are handled gracefully
-	ctx := tenant.WithTenant(context.Background(), "test-tenant")
+	ctx := testdb.ContextWithTenant(t, "test-tenant")
 
 	mock := &mockInstrumentGetter{
 		instruments: map[string]*cache.CachedInstrument{
@@ -208,7 +208,7 @@ func TestFungibilityValidator_ValidateDoubleEntry_NilAttributes(t *testing.T) {
 }
 
 func TestFungibilityValidator_ValidateDoubleEntry_CELEvaluationError(t *testing.T) {
-	ctx := tenant.WithTenant(context.Background(), "test-tenant")
+	ctx := testdb.ContextWithTenant(t, "test-tenant")
 
 	mock := &mockInstrumentGetter{
 		instruments: map[string]*cache.CachedInstrument{
@@ -247,7 +247,7 @@ func TestNewFungibilityValidator(t *testing.T) {
 
 func TestFungibilityValidator_UseCELProgramFromInstrument(t *testing.T) {
 	// Test that when no custom evaluator is set, the validator uses the instrument's BucketKeyProgram
-	ctx := tenant.WithTenant(context.Background(), "test-tenant")
+	ctx := testdb.ContextWithTenant(t, "test-tenant")
 
 	// This test verifies the production path works when BucketKeyProgram is nil (fully fungible)
 	mock := &mockInstrumentGetter{

services/current-account/testhelpers/factories.go

@@ -0,0 +1,57 @@
+// Package testhelpers provides shared test factories and utilities for current-account tests.
+package testhelpers
+
+import (
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/meridianhub/meridian/services/current-account/domain"
+	"github.com/stretchr/testify/require"
+)
+
+// NewCurrentAccount creates a test current account with sensible defaults.
+// The account is created with GBP currency and "CURRENCY" dimension.
+func NewCurrentAccount(t *testing.T, accountID string) domain.CurrentAccount {
+	t.Helper()
+	account, err := domain.NewCurrentAccount(
+		accountID,
+		"GB"+accountID, // external identifier
+		uuid.New().String(),
+		"GBP",
+	)
+	require.NoError(t, err)
+	return account
+}
+
+// NewCurrentAccountWithInstrument creates a test current account with a specific instrument code.
+func NewCurrentAccountWithInstrument(t *testing.T, accountID, instrumentCode string) domain.CurrentAccount {
+	t.Helper()
+	account, err := domain.NewCurrentAccount(
+		accountID,
+		"GB"+accountID,
+		uuid.New().String(),
+		instrumentCode,
+	)
+	require.NoError(t, err)
+	return account
+}
+
+// NewLien creates a test lien with the given status.
+func NewLien(t *testing.T, status domain.LienStatus) *domain.Lien {
+	t.Helper()
+	amount, err := domain.NewMoney("GBP", 10000)
+	require.NoError(t, err)
+
+	now := time.Now()
+	return &domain.Lien{
+		ID:                    uuid.New(),
+		AccountID:             uuid.New(),
+		Amount:                amount,
+		Status:                status,
+		PaymentOrderReference: "PO-TEST-001",
+		Version:               1,
+		CreatedAt:             now,
+		UpdatedAt:             now,
+	}
+}

services/internal-account/adapters/persistence/repository_integration_test.go

@@ -21,6 +21,7 @@ import (
 	"github.com/meridianhub/meridian/shared/platform/auth"
 	"github.com/meridianhub/meridian/shared/platform/await"
 	"github.com/meridianhub/meridian/shared/platform/tenant"
+	"github.com/meridianhub/meridian/shared/platform/testdb"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/testcontainers/testcontainers-go"
@@ -1671,8 +1672,7 @@ func TestIntegration_LoadTest_ConcurrentCreation(t *testing.T) {
 	tc := setupIntegrationTestContainer(t)
 	defer tc.cleanup(t)
 
-	tid := defaultTestTenantID
-	ctx := tenant.WithTenant(context.Background(), tid)
+	ctx := testdb.ContextWithTenant(t, string(defaultTestTenantID))
 	ctx = context.WithValue(ctx, auth.UserIDContextKey, "load-test-user")
 
 	const numAccounts = 1000

services/internal-account/testhelpers/factories.go

@@ -0,0 +1,70 @@
+// Package testhelpers provides shared test factories and utilities for internal-account tests.
+package testhelpers
+
+import (
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/meridianhub/meridian/services/internal-account/domain"
+	"github.com/stretchr/testify/require"
+)
+
+// NewInternalAccount creates a test internal account of the given type.
+// CLEARING accounts are automatically given ClearingPurposeGeneral.
+func NewInternalAccount(t *testing.T, accountType domain.AccountType) domain.InternalAccount {
+	t.Helper()
+
+	accountID := "IBA-TEST"
+	accountCode := "TEST_" + string(accountType)
+	name := "Test " + string(accountType) + " Account"
+
+	clearingPurpose := domain.ClearingPurposeUnspecified
+	if accountType == domain.AccountTypeClearing {
+		clearingPurpose = domain.ClearingPurposeGeneral
+	}
+
+	account, err := domain.NewInternalAccount(
+		accountID, accountCode, name,
+		accountType, clearingPurpose,
+		"GBP", "CURRENCY",
+	)
+	require.NoError(t, err)
+	return account
+}
+
+// NewInternalAccountWithID creates a test internal account with a specific ID and code.
+func NewInternalAccountWithID(t *testing.T, accountID, accountCode, name string, accountType domain.AccountType) domain.InternalAccount {
+	t.Helper()
+
+	clearingPurpose := domain.ClearingPurposeUnspecified
+	if accountType == domain.AccountTypeClearing {
+		clearingPurpose = domain.ClearingPurposeGeneral
+	}
+
+	account, err := domain.NewInternalAccount(
+		accountID, accountCode, name,
+		accountType, clearingPurpose,
+		"GBP", "CURRENCY",
+	)
+	require.NoError(t, err)
+	return account
+}
+
+// NewLien creates a test lien with the given status. All fields are exported
+// on the Lien struct so this can be used from any package.
+func NewLien(t *testing.T, status domain.LienStatus) *domain.Lien {
+	t.Helper()
+	now := time.Now()
+	return &domain.Lien{
+		ID:                    uuid.New(),
+		AccountID:             uuid.New(),
+		AmountCents:           10000,
+		InstrumentCode:        "GBP",
+		Status:                status,
+		PaymentOrderReference: "PO-TEST-001",
+		Version:               1,
+		CreatedAt:             now,
+		UpdatedAt:             now,
+	}
+}

services/position-keeping/testhelpers/factories.go

@@ -0,0 +1,24 @@
+// Package testhelpers provides shared test utilities for position-keeping tests.
+//
+// For domain entity factories (FinancialPositionLog, Money, TransactionCapturedEvent),
+// use the domain/testfixtures package which provides a comprehensive builder-pattern API.
+//
+// This package provides service-level test utilities that complement the domain fixtures.
+package testhelpers
+
+import (
+	"context"
+	"testing"
+
+	"github.com/meridianhub/meridian/shared/platform/testdb"
+)
+
+// ContextWithTenant returns a context with the given tenant ID for position-keeping tests.
+// This is a convenience wrapper around testdb.ContextWithTenant.
+func ContextWithTenant(t *testing.T, tenantID string) context.Context {
+	t.Helper()
+	return testdb.ContextWithTenant(t, tenantID)
+}
+
+// DefaultTestTenantID is the standard tenant ID used in position-keeping tests.
+const DefaultTestTenantID = "test_pk_tenant"

services/reconciliation/service/snapshot_capturer_test.go

@@ -5,10 +5,10 @@ import (
 	"errors"
 	"sync"
 	"testing"
-	"time"
 
 	"github.com/google/uuid"
 	"github.com/meridianhub/meridian/services/reconciliation/domain"
+	"github.com/meridianhub/meridian/services/reconciliation/testhelpers"
 	"github.com/shopspring/decimal"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -168,16 +168,7 @@ func (m *mockSnapshotRepo) snapshotCount() int {
 
 func newTestRun(t *testing.T) *domain.SettlementRun {
 	t.Helper()
-	run, err := domain.NewSettlementRun(
-		"ACC-001",
-		domain.ReconciliationScopeAccount,
-		domain.SettlementTypeDaily,
-		time.Now().Add(-24*time.Hour),
-		time.Now(),
-		"test-user",
-	)
-	require.NoError(t, err)
-	return run
+	return testhelpers.NewSettlementRun(t)
 }
 
 // --- Tests ---

services/reconciliation/service/variance_detector_test.go

@@ -9,6 +9,7 @@ import (
 
 	"github.com/google/uuid"
 	"github.com/meridianhub/meridian/services/reconciliation/domain"
+	"github.com/meridianhub/meridian/services/reconciliation/testhelpers"
 	"github.com/shopspring/decimal"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -110,17 +111,7 @@ func (m *mockVarianceRepoFull) varianceCount() int {
 
 func newRunningTestRun(t *testing.T) *domain.SettlementRun {
 	t.Helper()
-	run, err := domain.NewSettlementRun(
-		"ACC-001",
-		domain.ReconciliationScopeAccount,
-		domain.SettlementTypeDaily,
-		time.Now().Add(-24*time.Hour),
-		time.Now(),
-		"test-user",
-	)
-	require.NoError(t, err)
-	require.NoError(t, run.Start())
-	return run
+	return testhelpers.NewRunningSettlementRun(t)
 }
 
 // --- Tests ---

services/reconciliation/testhelpers/factories.go

@@ -0,0 +1,81 @@
+// Package testhelpers provides shared test factories and utilities for reconciliation tests.
+package testhelpers
+
+import (
+	"testing"
+	"time"
+
+	"github.com/google/uuid"
+	"github.com/meridianhub/meridian/services/reconciliation/domain"
+	"github.com/shopspring/decimal"
+	"github.com/stretchr/testify/require"
+)
+
+// NewSettlementRun creates a standard settlement run for testing.
+// The run is in PENDING status with daily scope for account ACC-001.
+func NewSettlementRun(t *testing.T) *domain.SettlementRun {
+	t.Helper()
+	now := time.Now().UTC()
+	run, err := domain.NewSettlementRun(
+		"ACC-001",
+		domain.ReconciliationScopeAccount,
+		domain.SettlementTypeDaily,
+		now.Add(-24*time.Hour),
+		now,
+		"test-user",
+	)
+	require.NoError(t, err)
+	return run
+}
+
+// NewRunningSettlementRun creates a settlement run that has been started.
+func NewRunningSettlementRun(t *testing.T) *domain.SettlementRun {
+	t.Helper()
+	run := NewSettlementRun(t)
+	err := run.Start()
+	require.NoError(t, err)
+	return run
+}
+
+// NewBalanceAssertion creates a standard balance assertion for testing.
+func NewBalanceAssertion(t *testing.T) *domain.BalanceAssertion {
+	t.Helper()
+	runID := uuid.New()
+	a, err := domain.NewBalanceAssertion(
+		&runID, "ACC-001", "GBP",
+		"balance == 10000", decimal.NewFromFloat(10000.00),
+	)
+	require.NoError(t, err)
+	return a
+}
+
+// NewDispute creates a standard dispute for testing.
+func NewDispute(t *testing.T) *domain.Dispute {
+	t.Helper()
+	d, err := domain.NewDispute(
+		uuid.New(), uuid.New(), "ACC-001",
+		"Amount discrepancy noted", "user-1",
+	)
+	require.NoError(t, err)
+	return d
+}
+
+// NewVariance creates a standard variance for testing with the given run and snapshot IDs.
+func NewVariance(t *testing.T, runSurrogateID, snapshotSurrogateID uuid.UUID) *domain.Variance {
+	t.Helper()
+	v, err := domain.NewVariance(
+		runSurrogateID,
+		snapshotSurrogateID,
+		"ACC-001", "GBP",
+		decimal.NewFromFloat(1000.00), decimal.NewFromFloat(995.50),
+		domain.VarianceReasonAmountMismatch,
+	)
+	require.NoError(t, err)
+	return v
+}
+
+// NewDefaultVariance creates a variance with generated IDs for simple test cases.
+func NewDefaultVariance(t *testing.T) *domain.Variance {
+	t.Helper()
+	return NewVariance(t, uuid.New(), uuid.New())
+}