Testing

package domain

import "testing"

func TestProrateBySqft_RoundsHalfAwayFromZero(t *testing.T) {
	tests := []struct {
		name     string
		rate     Paise
		areaSqft float64
		want     Paise
	}{
		{"exact multiple", 100, 10, 1000},
		{"rounds up at .5", 100, 10.005, 1001},
		{"rounds down below .5", 100, 10.004, 1000},
		{"zero area", 250, 0, 0},
		{"fractional rate times fractional area", 33, 12.5, 413},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			got := ProrateBySqft(tt.rate, tt.areaSqft)
			if got != tt.want {
				t.Errorf("ProrateBySqft(%d, %v) = %d, want %d", tt.rate, tt.areaSqft, got, tt.want)
			}
		})
	}
}

// TestPaise_NoDriftOverManyAdditions guards against the accumulation bug
// that float64 money would have: adding the same small amount ten
// thousand times must equal that amount multiplied by ten thousand,
// exactly, every time.
func TestPaise_NoDriftOverManyAdditions(t *testing.T) {
	var total Paise
	const iterations = 10000
	const perOp Paise = 7

	for i := 0; i < iterations; i++ {
		total = total.Add(perOp)
	}

	want := Paise(iterations * int64(perOp))
	if total != want {
		t.Fatalf("after %d additions: got %d, want %d (drift of %d)", iterations, total, want, total-want)
	}
}

package service

import (
	"testing"
	"time"

	"github.com/google/uuid"

	"github.com/hoa-platform/backend/services/maintenance-service/internal/domain"
)

func TestGenerateMonthlyInvoice_Deterministic(t *testing.T) {
	tenantID, flatID, residentID := uuid.New(), uuid.New(), uuid.New()
	billingPeriod := time.Date(2024, 6, 1, 0, 0, 0, 0, time.UTC)
	charges := []domain.ActiveCharge{
		{ChargeTypeID: uuid.New(), ChargeName: "General Maintenance", RateBasis: domain.RateBasisPerSqft, RatePaise: 250},
		{ChargeTypeID: uuid.New(), ChargeName: "Sinking Fund", RateBasis: domain.RateBasisFlat, RatePaise: 50000},
	}

	inv1, items1 := GenerateMonthlyInvoice(tenantID, flatID, residentID, billingPeriod, 950.5, charges)
	inv2, items2 := GenerateMonthlyInvoice(tenantID, flatID, residentID, billingPeriod, 950.5, charges)

	if inv1.TotalPaise != inv2.TotalPaise {
		t.Fatalf("total mismatch across identical calls: %d vs %d", inv1.TotalPaise, inv2.TotalPaise)
	}
	if len(items1) != len(items2) {
		t.Fatalf("line item count mismatch: %d vs %d", len(items1), len(items2))
	}
	for i := range items1 {
		if items1[i].AmountPaise != items2[i].AmountPaise || items1[i].Description != items2[i].Description {
			t.Fatalf("line item %d differs across identical calls: %+v vs %+v", i, items1[i], items2[i])
		}
	}

	const wantPerSqft = domain.Paise(237625) // ProrateBySqft(250, 950.5) = 250 * 950.5, no rounding needed
	const wantTotal = wantPerSqft + 50000
	if inv1.TotalPaise != wantTotal {
		t.Errorf("total = %d, want %d", inv1.TotalPaise, wantTotal)
	}
}

func TestGenerateMonthlyInvoice_NoChargesProducesZeroTotalInvoice(t *testing.T) {
	inv, items := GenerateMonthlyInvoice(uuid.New(), uuid.New(), uuid.New(), time.Now(), 500, nil)
	if inv.TotalPaise != 0 {
		t.Errorf("total = %d, want 0", inv.TotalPaise)
	}
	if len(items) != 0 {
		t.Errorf("line items = %d, want 0", len(items))
	}
	if inv.Status != domain.InvoiceStatusIssued {
		t.Errorf("status = %s, want issued", inv.Status)
	}
}

//go:build integration

package postgres

import (
	"context"
	"testing"
	"time"

	"github.com/google/uuid"

	"github.com/hoa-platform/backend/pkg/tenantctx"
	"github.com/hoa-platform/backend/services/maintenance-service/internal/domain"
	"github.com/hoa-platform/backend/services/maintenance-service/internal/service"
)

// fakeFlatLister and fakeOwnerResolver stand in for the HTTP clients —
// this test's job is to prove the database layer's idempotency guarantee,
// not to re-test HTTP behavior already covered elsewhere.
type fakeFlatLister struct{ flats []domain.FlatSummary }

func (f fakeFlatLister) ListActive(ctx context.Context) ([]domain.FlatSummary, error) {
	return f.flats, nil
}

type fakeOwnerResolver struct{ residentID uuid.UUID }

func (f fakeOwnerResolver) CurrentOwner(ctx context.Context, flatID uuid.UUID) (uuid.UUID, error) {
	return f.residentID, nil
}

func TestBillingRunner_RerunIsIdempotent(t *testing.T) {
	pool := newTestPool(t)
	tenantID := uuid.New()
	flatID := uuid.New()
	ctx := tenantctx.WithTenantID(context.Background(), tenantID)
	billingPeriod := time.Date(2024, 6, 1, 0, 0, 0, 0, time.UTC)

	chargeTypeRepo := NewChargeTypeRepository(pool)
	chargeVersionRepo := NewChargeVersionRepository(pool)
	ct, err := chargeTypeRepo.Create(ctx, domain.ChargeType{TenantID: tenantID, Code: "GEN", Name: "General", RateBasis: domain.RateBasisFlat})
	if err != nil {
		t.Fatalf("seeding charge type: %v", err)
	}
	if _, err := chargeVersionRepo.ReviseRate(ctx, tenantID, ct.ID, 50000, billingPeriod); err != nil {
		t.Fatalf("seeding charge version: %v", err)
	}

	runner := service.NewBillingRunner(
		fakeFlatLister{flats: []domain.FlatSummary{{ID: flatID, AreaSqft: 800}}},
		fakeOwnerResolver{residentID: uuid.New()},
		chargeVersionRepo,
		NewBillingRunRepository(pool),
		NewInvoiceRepository(pool),
	)

	if _, err := runner.GenerateForPeriod(ctx, billingPeriod); err != nil {
		t.Fatalf("first run: %v", err)
	}
	if _, err := runner.GenerateForPeriod(ctx, billingPeriod); err != nil {
		t.Fatalf("second run: %v", err)
	}

	var count int
	if err := pool.QueryRow(ctx, `SELECT count(*) FROM invoices WHERE tenant_id = $1 AND flat_id = $2 AND billing_period = $3`,
		tenantID, flatID, billingPeriod).Scan(&count); err != nil {
		t.Fatalf("counting invoices: %v", err)
	}
	if count != 1 {
		t.Fatalf("expected exactly 1 invoice after two runs, got %d", count)
	}

	var flatsTotal int
	if err := pool.QueryRow(ctx, `SELECT flats_total FROM billing_runs WHERE tenant_id = $1 AND billing_period = $2`,
		tenantID, billingPeriod).Scan(&flatsTotal); err != nil {
		t.Fatalf("reading billing run: %v", err)
	}
	if flatsTotal != 1 {
		t.Fatalf("expected flats_total 1 after rerun (StartRun resets counters), got %d", flatsTotal)
	}
}

//go:build integration

package postgres

import (
	"context"
	"fmt"
	"sync"
	"testing"

	"github.com/google/uuid"

	"github.com/hoa-platform/backend/services/maintenance-service/internal/domain"
)

// TestPaymentRepository_ConcurrentPayments_NeverExceedsBalance fires 20
// goroutines, each attempting to pay Rs.100 (10000 paise) against a
// Rs.1000 (100000 paise) invoice — only 10 of them should succeed in
// applying their payment; the rest must observe ErrPaymentExceedsInvoiceBalance
// once the balance is exhausted, and none may observe an invoice that
// briefly appears to exceed its total.
func TestPaymentRepository_ConcurrentPayments_NeverExceedsBalance(t *testing.T) {
	pool := newTestPool(t)
	tenantID, flatID, residentID := uuid.New(), uuid.New(), uuid.New()

	var invoiceID uuid.UUID
	err := pool.QueryRow(context.Background(), `
		INSERT INTO invoices (tenant_id, flat_id, resident_id, billing_period, status, total_paise)
		VALUES ($1, $2, $3, '2024-06-01', 'issued', 100000)
		RETURNING id`,
		tenantID, flatID, residentID,
	).Scan(&invoiceID)
	if err != nil {
		t.Fatalf("seeding invoice: %v", err)
	}

	repo := NewPaymentRepository(pool)
	const attempts = 20
	const perPayment = domain.Paise(10000)

	var wg sync.WaitGroup
	successes := make([]bool, attempts)
	for i := 0; i < attempts; i++ {
		wg.Add(1)
		go func(i int) {
			defer wg.Done()
			_, _, err := repo.RecordPayment(context.Background(), tenantID, invoiceID, perPayment, domain.PaymentMethodUPI, fmt.Sprintf("concurrent-%d", i))
			successes[i] = err == nil
		}(i)
	}
	wg.Wait()

	successCount := 0
	for _, ok := range successes {
		if ok {
			successCount++
		}
	}
	if successCount != 10 {
		t.Fatalf("expected exactly 10 successful payments (100000 / 10000), got %d", successCount)
	}

	var paidPaise int64
	if err := pool.QueryRow(context.Background(), `SELECT paid_paise FROM invoices WHERE id = $1`, invoiceID).Scan(&paidPaise); err != nil {
		t.Fatalf("reading final invoice: %v", err)
	}
	if paidPaise != 100000 {
		t.Fatalf("paid_paise = %d, want exactly 100000 (never more, never less)", paidPaise)
	}
}