paliad/internal/services/scenario_builder_service_test.go

package services

import (
	"context"
	"encoding/json"
	"errors"
	"os"
	"testing"

	"github.com/google/uuid"
	"github.com/jmoiron/sqlx"
	_ "github.com/lib/pq"

	"mgit.msbls.de/m/paliad/internal/db"
)

// TestScenarioBuilderService exercises the t-paliad-340 / m/paliad#153 B0
// surface end-to-end against a live DB: create + list + deep-get + patch
// + add-proceeding + add-event + add/delete-share, plus the visibility
// negative case (a non-owner can't see the scenario unless shared).
//
// Skipped without TEST_DATABASE_URL — matches the pattern in
// project_service_test.go / event_choice_service_test.go.
func TestScenarioBuilderService(t *testing.T) {
	url := os.Getenv("TEST_DATABASE_URL")
	if url == "" {
		t.Skip("TEST_DATABASE_URL not set — skipping live DB test")
	}
	if err := db.ApplyMigrations(url); err != nil {
		t.Fatalf("apply migrations: %v", err)
	}
	pool, err := sqlx.Connect("postgres", url)
	if err != nil {
		t.Fatalf("connect: %v", err)
	}
	defer pool.Close()

	ctx := context.Background()

	owner := uuid.New()
	other := uuid.New()
	cleanup := func() {
		// Cascade order: delete from scenarios → CASCADE clears
		// proceedings, events, shares. Then the two users.
		pool.ExecContext(ctx,
			`DELETE FROM paliad.scenarios WHERE owner_id IN ($1, $2)`, owner, other)
		pool.ExecContext(ctx,
			`DELETE FROM paliad.users WHERE id IN ($1, $2)`, owner, other)
		pool.ExecContext(ctx,
			`DELETE FROM auth.users WHERE id IN ($1, $2)`, owner, other)
	}
	cleanup()
	defer cleanup()

	for _, seed := range []struct {
		id    uuid.UUID
		email string
		name  string
	}{
		{owner, "builder-owner-test@hlc.com", "Builder Owner"},
		{other, "builder-other-test@hlc.com", "Builder Other"},
	} {
		if _, err := pool.ExecContext(ctx,
			`INSERT INTO auth.users (id, email) VALUES ($1, $2)`,
			seed.id, seed.email); err != nil {
			t.Fatalf("seed auth.users %s: %v", seed.email, err)
		}
		if _, err := pool.ExecContext(ctx,
			`INSERT INTO paliad.users (id, email, display_name, office, lang)
			 VALUES ($1, $2, $3, 'munich', 'de')`,
			seed.id, seed.email, seed.name); err != nil {
			t.Fatalf("seed paliad.users %s: %v", seed.email, err)
		}
	}

	// Pick a real proceeding_type_id so the FK insert succeeds.
	var ptID int
	if err := pool.GetContext(ctx, &ptID,
		`SELECT id FROM paliad.proceeding_types
		  WHERE code = $1 AND is_active = true
		  LIMIT 1`, CodeUPCInfringement); err != nil {
		t.Fatalf("look up upc.inf id: %v", err)
	}

	svc := NewScenarioBuilderService(pool)

	// 1. Create a scenario for the owner. Empty name should default.
	sc, err := svc.CreateScenario(ctx, owner, CreateBuilderScenarioInput{})
	if err != nil {
		t.Fatalf("CreateScenario: %v", err)
	}
	if sc.Name != "Unbenanntes Szenario" {
		t.Errorf("default name = %q, want %q", sc.Name, "Unbenanntes Szenario")
	}
	if sc.Status != "active" {
		t.Errorf("default status = %q, want active", sc.Status)
	}
	if sc.OwnerID == nil || *sc.OwnerID != owner {
		t.Errorf("owner_id = %v, want %v", sc.OwnerID, owner)
	}

	// 2. List — should return the one row.
	list, err := svc.ListMyScenarios(ctx, owner, "active")
	if err != nil {
		t.Fatalf("ListMyScenarios: %v", err)
	}
	if len(list) != 1 || list[0].ID != sc.ID {
		t.Errorf("ListMyScenarios returned %d rows; want 1 with id %s", len(list), sc.ID)
	}

	// 3. Other user can NOT see the scenario.
	if _, err := svc.GetScenarioDeep(ctx, other, sc.ID); !errors.Is(err, ErrScenarioBuilderNotVisible) {
		t.Errorf("GetScenarioDeep by non-owner = %v, want ErrScenarioBuilderNotVisible", err)
	}

	// 4. Add a proceeding.
	pr, err := svc.AddProceeding(ctx, owner, sc.ID, AddProceedingInput{
		ProceedingTypeID: ptID,
		PrimaryParty:     ptrString("defendant"),
		ScenarioFlags:    json.RawMessage(`{"with_ccr": true}`),
	})
	if err != nil {
		t.Fatalf("AddProceeding: %v", err)
	}
	if pr.ProceedingTypeID != ptID {
		t.Errorf("ProceedingTypeID = %d, want %d", pr.ProceedingTypeID, ptID)
	}
	if pr.PrimaryParty == nil || *pr.PrimaryParty != "defendant" {
		t.Errorf("PrimaryParty = %v, want defendant", pr.PrimaryParty)
	}

	// 5. Add a custom-label event card.
	ev, err := svc.AddEvent(ctx, owner, sc.ID, pr.ID, AddEventInput{
		CustomLabel: ptrString("Klageerwiderung"),
		State:       ptrString("planned"),
	})
	if err != nil {
		t.Fatalf("AddEvent: %v", err)
	}
	if ev.State != "planned" {
		t.Errorf("event state = %q, want planned", ev.State)
	}

	// 5b. Add-event with NO anchor fields fails.
	if _, err := svc.AddEvent(ctx, owner, sc.ID, pr.ID, AddEventInput{}); !errors.Is(err, ErrInvalidInput) {
		t.Errorf("AddEvent without anchor = %v, want ErrInvalidInput", err)
	}

	// 6. Deep get — should bundle the scenario + 1 proceeding + 1 event + 0 shares.
	deep, err := svc.GetScenarioDeep(ctx, owner, sc.ID)
	if err != nil {
		t.Fatalf("GetScenarioDeep: %v", err)
	}
	if len(deep.Proceedings) != 1 || deep.Proceedings[0].ID != pr.ID {
		t.Errorf("deep proceedings count=%d want 1; ids: %+v", len(deep.Proceedings), deep.Proceedings)
	}
	if len(deep.Events) != 1 || deep.Events[0].ID != ev.ID {
		t.Errorf("deep events count=%d want 1; ids: %+v", len(deep.Events), deep.Events)
	}
	if len(deep.Shares) != 0 {
		t.Errorf("deep shares count=%d want 0", len(deep.Shares))
	}

	// 7. Share with `other`. Recipient should now see the scenario.
	sh, err := svc.AddShare(ctx, owner, sc.ID, other)
	if err != nil {
		t.Fatalf("AddShare: %v", err)
	}
	if _, err := svc.GetScenarioDeep(ctx, other, sc.ID); err != nil {
		t.Errorf("GetScenarioDeep by share recipient: %v", err)
	}
	// But the recipient can NOT add proceedings.
	if _, err := svc.AddProceeding(ctx, other, sc.ID, AddProceedingInput{
		ProceedingTypeID: ptID,
	}); !errors.Is(err, ErrScenarioBuilderNotVisible) {
		t.Errorf("AddProceeding by share recipient = %v, want ErrScenarioBuilderNotVisible", err)
	}

	// 7b. Self-share should be rejected.
	if _, err := svc.AddShare(ctx, owner, sc.ID, owner); !errors.Is(err, ErrInvalidInput) {
		t.Errorf("self-share = %v, want ErrInvalidInput", err)
	}

	// 8. Patch — archive then re-activate.
	patched, err := svc.PatchScenario(ctx, owner, sc.ID, PatchBuilderScenarioInput{
		Status: ptrString("archived"),
	})
	if err != nil {
		t.Fatalf("PatchScenario archive: %v", err)
	}
	if patched.Status != "archived" {
		t.Errorf("after archive, status = %q, want archived", patched.Status)
	}
	// PATCH to 'promoted' is rejected — that's the wizard's job.
	if _, err := svc.PatchScenario(ctx, owner, sc.ID, PatchBuilderScenarioInput{
		Status: ptrString("promoted"),
	}); !errors.Is(err, ErrInvalidInput) {
		t.Errorf("PATCH status=promoted = %v, want ErrInvalidInput", err)
	}
	patched, err = svc.PatchScenario(ctx, owner, sc.ID, PatchBuilderScenarioInput{
		Status: ptrString("active"),
	})
	if err != nil {
		t.Fatalf("PatchScenario re-activate: %v", err)
	}
	if patched.Status != "active" {
		t.Errorf("after re-activate, status = %q, want active", patched.Status)
	}

	// 9. Revoke the share. Recipient loses visibility.
	if err := svc.DeleteShare(ctx, owner, sc.ID, sh.ID); err != nil {
		t.Fatalf("DeleteShare: %v", err)
	}
	if _, err := svc.GetScenarioDeep(ctx, other, sc.ID); !errors.Is(err, ErrScenarioBuilderNotVisible) {
		t.Errorf("after revoke, recipient GetScenarioDeep = %v, want ErrScenarioBuilderNotVisible", err)
	}
}

// (Note: ptrString lives in rule_editor_service_test.go in this package
// and is reused here. No second declaration needed.)