pansy/internal/service/plants_test.go

package service

import (
	"context"
	"errors"
	"strings"
	"testing"

	"gitea.stevedudenhoeffer.com/steve/pansy/internal/domain"
)

func ptrInt(n int) *int { return &n }

// validPlant is a well-formed PlantInput for tests to tweak.
func validPlant(name string) PlantInput {
	return PlantInput{Name: name, Category: domain.CategoryHerb, SpacingCM: 25, Color: "#4a7c3f", Icon: "🌿"}
}

func TestListPlantsIncludesSeededBuiltins(t *testing.T) {
	s := newTestService(t, openConfig())
	owner := seedUser(t, s, "[email protected]")

	plants, err := s.ListPlants(context.Background(), owner)
	if err != nil {
		t.Fatalf("ListPlants: %v", err)
	}
	// The 0003 seed ships a catalog; assert it's there and all built-ins.
	if len(plants) < 30 {
		t.Fatalf("seeded catalog = %d plants, want >= 30", len(plants))
	}
	for _, p := range plants {
		if p.OwnerID != nil {
			t.Fatalf("unexpected non-builtin in a fresh catalog: %+v", p)
		}
	}
	// Find a known one.
	var found bool
	for _, p := range plants {
		if p.Name == "Garlic" {
			found = true
			if p.SpacingCM != 15 || p.Icon != "🧄" {
				t.Errorf("Garlic seeded wrong: %+v", p)
			}
		}
	}
	if !found {
		t.Error("expected seeded Garlic in the catalog")
	}
}

func TestCreatePlantIsOwnedAndTrimmed(t *testing.T) {
	s := newTestService(t, openConfig())
	owner := seedUser(t, s, "[email protected]")

	in := validPlant("  Purple basil  ")
	in.DaysToMaturity = ptrInt(60)
	p, err := s.CreatePlant(context.Background(), owner, in)
	if err != nil {
		t.Fatalf("CreatePlant: %v", err)
	}
	if p.OwnerID == nil || *p.OwnerID != owner {
		t.Errorf("owner = %v, want %d", p.OwnerID, owner)
	}
	if p.Name != "Purple basil" {
		t.Errorf("name = %q, want trimmed", p.Name)
	}
	if p.Version != 1 || p.DaysToMaturity == nil || *p.DaysToMaturity != 60 {
		t.Errorf("unexpected plant: %+v", p)
	}
}

func TestPlantVisibilityAcrossUsers(t *testing.T) {
	s := newTestService(t, openConfig())
	alice := seedUser(t, s, "[email protected]")
	bob := seedUser(t, s, "[email protected]")

	p, err := s.CreatePlant(context.Background(), alice, validPlant("Alice's mint"))
	if err != nil {
		t.Fatalf("CreatePlant: %v", err)
	}

	// Bob's catalog: built-ins only, none of Alice's.
	bobList, err := s.ListPlants(context.Background(), bob)
	if err != nil {
		t.Fatalf("ListPlants(bob): %v", err)
	}
	for _, bp := range bobList {
		if bp.ID == p.ID {
			t.Fatal("bob can see alice's custom plant")
		}
	}

	// Bob can neither edit nor delete it — invisibility masks it as ErrNotFound.
	nm := "hijack"
	if _, err := s.UpdatePlant(context.Background(), bob, p.ID, PlantPatch{Name: &nm}, p.Version); !errors.Is(err, domain.ErrNotFound) {
		t.Errorf("bob update err = %v, want ErrNotFound", err)
	}
	if err := s.DeletePlant(context.Background(), bob, p.ID); !errors.Is(err, domain.ErrNotFound) {
		t.Errorf("bob delete err = %v, want ErrNotFound", err)
	}
}

func TestBuiltinPlantsAreReadOnly(t *testing.T) {
	s := newTestService(t, openConfig())
	owner := seedUser(t, s, "[email protected]")

	plants, _ := s.ListPlants(context.Background(), owner)
	builtin := plants[0] // seeded, owner_id nil
	if builtin.OwnerID != nil {
		t.Fatalf("expected a built-in, got %+v", builtin)
	}

	nm := "tweaked"
	if _, err := s.UpdatePlant(context.Background(), owner, builtin.ID, PlantPatch{Name: &nm}, builtin.Version); !errors.Is(err, domain.ErrForbidden) {
		t.Errorf("edit built-in err = %v, want ErrForbidden", err)
	}
	if err := s.DeletePlant(context.Background(), owner, builtin.ID); !errors.Is(err, domain.ErrForbidden) {
		t.Errorf("delete built-in err = %v, want ErrForbidden", err)
	}
}

func TestCloneBuiltinThenEdit(t *testing.T) {
	s := newTestService(t, openConfig())
	owner := seedUser(t, s, "[email protected]")

	plants, _ := s.ListPlants(context.Background(), owner)
	src := plants[0]

	// "Clone" = POST a copy; it's now owned and editable.
	clone, err := s.CreatePlant(context.Background(), owner, PlantInput{
		Name: src.Name + " (mine)", Category: src.Category, SpacingCM: src.SpacingCM, Color: src.Color, Icon: src.Icon,
	})
	if err != nil {
		t.Fatalf("clone: %v", err)
	}
	sp := 12.0
	updated, err := s.UpdatePlant(context.Background(), owner, clone.ID, PlantPatch{SpacingCM: &sp}, clone.Version)
	if err != nil {
		t.Fatalf("edit clone: %v", err)
	}
	if updated.SpacingCM != 12 || updated.Version != clone.Version+1 {
		t.Errorf("clone edit didn't apply: %+v", updated)
	}
}

func TestUpdatePlantClearsDays(t *testing.T) {
	s := newTestService(t, openConfig())
	owner := seedUser(t, s, "[email protected]")
	in := validPlant("Dill")
	in.DaysToMaturity = ptrInt(50)
	p, _ := s.CreatePlant(context.Background(), owner, in)

	// SetDays with nil clears; absent (SetDays=false) would leave it.
	cleared, err := s.UpdatePlant(context.Background(), owner, p.ID, PlantPatch{SetDays: true, DaysToMaturity: nil}, p.Version)
	if err != nil {
		t.Fatalf("clear days: %v", err)
	}
	if cleared.DaysToMaturity != nil {
		t.Errorf("daysToMaturity = %v, want nil", *cleared.DaysToMaturity)
	}
}

func TestPlantVersionConflict(t *testing.T) {
	s := newTestService(t, openConfig())
	owner := seedUser(t, s, "[email protected]")
	p, _ := s.CreatePlant(context.Background(), owner, validPlant("Sage"))

	sp := 30.0
	if _, err := s.UpdatePlant(context.Background(), owner, p.ID, PlantPatch{SpacingCM: &sp}, p.Version); err != nil {
		t.Fatalf("first update: %v", err)
	}
	// Stale version → conflict + current row.
	current, err := s.UpdatePlant(context.Background(), owner, p.ID, PlantPatch{SpacingCM: &sp}, p.Version)
	if !errors.Is(err, domain.ErrVersionConflict) {
		t.Fatalf("stale update err = %v, want ErrVersionConflict", err)
	}
	if current == nil || current.Version != 2 {
		t.Errorf("conflict didn't return current row: %+v", current)
	}
}

func TestCreatePlantValidation(t *testing.T) {
	s := newTestService(t, openConfig())
	owner := seedUser(t, s, "[email protected]")

	bad := []PlantInput{
		{Name: "", Category: domain.CategoryHerb, SpacingCM: 10, Color: "#4a7c3f", Icon: "🌿"},                                     // empty name
		{Name: "x", Category: "spaceship", SpacingCM: 10, Color: "#4a7c3f", Icon: "🌿"},                                            // bad category
		{Name: "x", Category: domain.CategoryHerb, SpacingCM: 0, Color: "#4a7c3f", Icon: "🌿"},                                     // zero spacing
		{Name: "x", Category: domain.CategoryHerb, SpacingCM: -5, Color: "#4a7c3f", Icon: "🌿"},                                    // negative spacing
		{Name: "x", Category: domain.CategoryHerb, SpacingCM: 10, Color: "nope", Icon: "🌿"},                                       // bad color
		{Name: "x", Category: domain.CategoryHerb, SpacingCM: 10, Color: "#4a7c3f", Icon: ""},                                     // empty icon
		{Name: strings.Repeat("x", maxPlantNameLen+1), Category: domain.CategoryHerb, SpacingCM: 10, Color: "#4a7c3f", Icon: "🌿"}, // name too long
		{Name: "x", Category: domain.CategoryHerb, SpacingCM: 10, Color: "#4a7c3f", Icon: "🌿", DaysToMaturity: ptrInt(0)},         // days must be >= 1
	}
	for i, in := range bad {
		if _, err := s.CreatePlant(context.Background(), owner, in); !errors.Is(err, domain.ErrInvalidInput) {
			t.Errorf("case %d: err = %v, want ErrInvalidInput", i, err)
		}
	}

	// A shorthand hex (#rgb) and a set days value pass.
	ok := validPlant("Thyme")
	ok.Color = "#0a0"
	ok.DaysToMaturity = ptrInt(90)
	if _, err := s.CreatePlant(context.Background(), owner, ok); err != nil {
		t.Errorf("valid plant rejected: %v", err)
	}
}

func TestDeletePlantInUseIsBlocked(t *testing.T) {
	s := newTestService(t, openConfig())
	owner := seedUser(t, s, "[email protected]")
	g := seedGarden(t, s, owner)
	bed, _ := s.CreateObject(context.Background(), owner, g.ID, ObjectInput{
		Kind: domain.KindBed, XCM: 500, YCM: 500, WidthCM: 200, HeightCM: 200,
	})
	plant, _ := s.CreatePlant(context.Background(), owner, validPlant("Basil"))

	// Plantings CRUD is #14; insert a plop directly so the plant is referenced.
	if _, err := s.store.SQL().ExecContext(context.Background(),
		`INSERT INTO plantings (object_id, plant_id, x_cm, y_cm, radius_cm) VALUES (?, ?, 0, 0, 10)`,
		bed.ID, plant.ID,
	); err != nil {
		t.Fatalf("seed planting: %v", err)
	}

	if err := s.DeletePlant(context.Background(), owner, plant.ID); !errors.Is(err, domain.ErrPlantInUse) {
		t.Fatalf("delete in-use plant err = %v, want ErrPlantInUse", err)
	}

	// Clearing the reference frees the delete.
	if _, err := s.store.SQL().ExecContext(context.Background(), `DELETE FROM plantings WHERE plant_id = ?`, plant.ID); err != nil {
		t.Fatalf("clear planting: %v", err)
	}
	if err := s.DeletePlant(context.Background(), owner, plant.ID); err != nil {
		t.Errorf("delete freed plant: %v", err)
	}
}