Testing

package complaint

import (
	"errors"
	"slices"
	"sort"
	"testing"

	"github.com/google/uuid"
)

func TestCanTransitionMatrix(t *testing.T) {
	statuses := []Status{
		StatusOpen,
		StatusAcknowledged,
		StatusInProgress,
		StatusResolved,
		StatusClosed,
		StatusReopened,
	}

	// The adjacency table in state.go is the single source of truth; copying it
	// into the test would only prove the copy matches itself. Instead assert
	// that CanTransition never disagrees with the table it reads from...
	for _, from := range statuses {
		for _, to := range statuses {
			_, want := allowedTransitions[from][to]
			if got := CanTransition(from, to); got != want {
				t.Fatalf("CanTransition(%s, %s) = %t, want %t", from, to, got, want)
			}
		}
	}

	// ...and pin the exact edge set, so adding or deleting an edge is a
	// deliberate act that fails this test until someone updates the list.
	var edges []string
	for from, targets := range allowedTransitions {
		for to := range targets {
			edges = append(edges, string(from)+"->"+string(to))
		}
	}
	sort.Strings(edges)

	want := []string{
		"acknowledged->in_progress",
		"acknowledged->resolved",
		"closed->reopened",
		"in_progress->resolved",
		"open->acknowledged",
		"reopened->acknowledged",
		"resolved->closed",
		"resolved->reopened",
	}
	if !slices.Equal(edges, want) {
		t.Fatalf("transition edges changed:\ngot  %v\nwant %v", edges, want)
	}
}

func TestAuthorizeTransitionByRole(t *testing.T) {
	raiser := uuid.MustParse("11111111-1111-1111-1111-111111111111")
	staff := uuid.MustParse("22222222-2222-2222-2222-222222222222")
	admin := uuid.MustParse("33333333-3333-3333-3333-333333333333")
	resident := uuid.MustParse("44444444-4444-4444-4444-444444444444")

	base := Complaint{
		RaisedBy: raiser,
		Category: CategoryPlumbing,
		Severity: SeverityHigh,
	}

	cases := []struct {
		name    string
		from    Status
		to      Status
		actor   Actor
		wantErr error
	}{
		{
			name:  "staff can acknowledge",
			from:  StatusOpen,
			to:    StatusAcknowledged,
			actor: Actor{UserID: staff, Role: RoleStaff},
		},
		{
			name:    "resident cannot resolve",
			from:    StatusInProgress,
			to:      StatusResolved,
			actor:   Actor{UserID: resident, Role: RoleResident},
			wantErr: ErrTransitionForbidden,
		},
		{
			name:  "raising resident can close",
			from:  StatusResolved,
			to:    StatusClosed,
			actor: Actor{UserID: raiser, Role: RoleResident},
		},
		{
			name:  "org admin can close",
			from:  StatusResolved,
			to:    StatusClosed,
			actor: Actor{UserID: admin, Role: RoleOrgAdmin},
		},
		{
			name:    "non-raiser resident cannot close",
			from:    StatusResolved,
			to:      StatusClosed,
			actor:   Actor{UserID: resident, Role: RoleResident},
			wantErr: ErrTransitionForbidden,
		},
	}

	for _, tc := range cases {
		t.Run(tc.name, func(t *testing.T) {
			complaint := base
			complaint.Status = tc.from

			err := authorizeTransition(complaint, tc.to, tc.actor)
			if !errors.Is(err, tc.wantErr) {
				t.Fatalf("authorizeTransition() error = %v, want %v", err, tc.wantErr)
			}
		})
	}
}

package complaint

import (
	"context"
	"testing"
	"time"

	"github.com/google/uuid"
)

type fakeClock struct {
	current time.Time
}

func (c *fakeClock) Now() time.Time {
	return c.current
}

func (c *fakeClock) Advance(d time.Duration) {
	c.current = c.current.Add(d)
}

type fakeSweepRepo struct {
	complaints []Complaint
	marked     []uuid.UUID
}

func (r *fakeSweepRepo) FindBreachedComplaints(_ context.Context, now time.Time, limit int) ([]Complaint, error) {
	out := make([]Complaint, 0, len(r.complaints))
	for _, complaint := range r.complaints {
		if complaint.DueAt == nil {
			continue
		}
		if complaint.DueAt.After(now) {
			continue
		}
		if complaint.SLABreached || IsTerminal(complaint.Status) {
			continue
		}
		out = append(out, complaint)
	}
	if len(out) > limit {
		out = out[:limit]
	}
	return out, nil
}

func (r *fakeSweepRepo) MarkSLABreached(_ context.Context, _ uuid.UUID, complaintID uuid.UUID) error {
	r.marked = append(r.marked, complaintID)
	for i := range r.complaints {
		if r.complaints[i].ID == complaintID {
			r.complaints[i].SLABreached = true
		}
	}
	return nil
}

type fakePublisher struct {
	published []uuid.UUID
}

func (p *fakePublisher) PublishSLABreached(_ context.Context, complaint Complaint) error {
	p.published = append(p.published, complaint.ID)
	return nil
}

func TestWatcherSweepMarksBreachAfterDueAt(t *testing.T) {
	clock := &fakeClock{current: time.Date(2026, time.January, 12, 9, 0, 0, 0, time.UTC)}
	orgID := uuid.MustParse("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
	complaintID := uuid.MustParse("bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb")
	due := clock.Now().Add(30 * time.Minute)

	repo := &fakeSweepRepo{
		complaints: []Complaint{
			{
				ID:       complaintID,
				OrgID:    orgID,
				Category: CategorySecurity,
				Severity: SeverityCritical,
				Status:   StatusInProgress,
				DueAt:    &due,
			},
		},
	}
	publisher := &fakePublisher{}
	watcher := NewWatcher(repo, publisher, time.Minute, 100, clock.Now)

	if err := watcher.Sweep(context.Background()); err != nil {
		t.Fatalf("first Sweep() error = %v", err)
	}
	if len(repo.marked) != 0 {
		t.Fatalf("expected no breach before due_at, got %d", len(repo.marked))
	}

	clock.Advance(31 * time.Minute)
	if err := watcher.Sweep(context.Background()); err != nil {
		t.Fatalf("second Sweep() error = %v", err)
	}
	if len(repo.marked) != 1 {
		t.Fatalf("expected one breach after due_at, got %d", len(repo.marked))
	}
	if len(publisher.published) != 1 || publisher.published[0] != complaintID {
		t.Fatalf("expected publisher to emit complaint %s, got %#v", complaintID, publisher.published)
	}
}