steveandClaude Opus 4.8
f4c5db587f
"Change the garlic bed to cucumbers this year" has a year in it, and pansy had no notion of one — the editor showed whatever is currently planted, full stop. The data has always supported seasons: plantings carry planted_at and removed_at, and "clear bed" soft-removes rather than deleting. A season is a date range over data that already exists. No schema change, and specifically no seasons table — it would duplicate what the dates already say and create a second source of truth about when something was in the ground. ?year=YYYY on /full returns every plop whose [planted_at, removed_at] interval overlapped that calendar year, so garlic planted in October and pulled the following July appears in BOTH years, which is what actually happened. Undated plantings appear in every year: everything that predates this feature has a null planted_at, and a rule that excluded them would empty every existing garden the moment a year was selected. Without the param /full behaves exactly as before — the existing tests pass unchanged, which was the point of doing it this way. Widening to past plops means widening the referenced-plant lookup with it. A plant pulled last July isn't active, but its plops still have to render with the right icon and colour, so ListReferencedPlants takes an includeRemoved flag that tracks the same switch. A past season is READ-ONLY, gated at the single canEdit the palette, inspector, nudging, placement and drag handles all key off. Editing the past by accident is the failure mode this feature introduces, so the state is stated in a banner rather than implied by a dropdown you set a while ago, with the way back to the live garden next to it. The season is a separate query under its own key. The optimistic mutations all patch gardenFullKey(gardenId); folding a year into that key would let them write into whichever season happened to be on screen. Read-only views never need that machinery, and keeping them out of it means they can't accidentally join it. The year selector offers only years the garden holds data for, plus the current one. A free numeric field invites a typo, and a typo'd year produces a confidently empty garden that reads as data loss rather than a mistake — the server bounds the year for the same reason. Closes #54 Co-Authored-By: Claude Opus 4.8 (1M context) <[email protected]> Claude-Session: https://claude.ai/code/session_01H3zbym8Doka2d7D48maSgZ
379 lines
14 KiB
Go
379 lines
14 KiB
Go
package service
|
||
|
||
import (
|
||
"context"
|
||
"errors"
|
||
"testing"
|
||
|
||
"gitea.stevedudenhoeffer.com/steve/pansy/internal/domain"
|
||
)
|
||
|
||
// seedBed creates a plantable 200×200 bed centered in a 1000×1000 garden.
|
||
func seedBed(t *testing.T, s *Service, owner, gardenID int64) *domain.GardenObject {
|
||
t.Helper()
|
||
o, err := s.CreateObject(context.Background(), owner, gardenID, ObjectInput{
|
||
Kind: domain.KindBed, XCM: 500, YCM: 500, WidthCM: 200, HeightCM: 200,
|
||
})
|
||
if err != nil {
|
||
t.Fatalf("seed bed: %v", err)
|
||
}
|
||
return o
|
||
}
|
||
|
||
// seedOwnPlant creates a custom plant owned by owner with the given spacing.
|
||
func seedOwnPlant(t *testing.T, s *Service, owner int64, spacingCM float64) *domain.Plant {
|
||
t.Helper()
|
||
p, err := s.CreatePlant(context.Background(), owner, PlantInput{
|
||
Name: "Testroot", Category: domain.CategoryHerb, SpacingCM: spacingCM, Color: "#4a7c3f", Icon: "🌿",
|
||
})
|
||
if err != nil {
|
||
t.Fatalf("seed plant: %v", err)
|
||
}
|
||
return p
|
||
}
|
||
|
||
func TestDerivedCountFormula(t *testing.T) {
|
||
cases := []struct {
|
||
r, sp float64
|
||
want int
|
||
}{
|
||
{0.1, 10, 1}, // tiny radius floors to 1
|
||
{0, 10, 1}, // zero radius → 1
|
||
{10, 0, 1}, // zero spacing → 1
|
||
{10, 10, 3}, // π·100/100 = 3.14 → 3
|
||
{50, 10, 79}, // π·2500/100 = 78.5 → 79
|
||
{30, 15, 13}, // π·900/225 = 12.57 → 13
|
||
}
|
||
for i, c := range cases {
|
||
if got := derivedCount(c.r, c.sp); got != c.want {
|
||
t.Errorf("case %d: derivedCount(%v, %v) = %d, want %d", i, c.r, c.sp, got, c.want)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestDerivedCountCapped(t *testing.T) {
|
||
// A huge radius with a tiny spacing would produce an absurd (32-bit
|
||
// overflowing) count; it's capped at the same ceiling as a manual override.
|
||
if got := derivedCount(10_000, 0.1); got != maxExplicitCount {
|
||
t.Errorf("derivedCount(10000, 0.1) = %d, want cap %d", got, maxExplicitCount)
|
||
}
|
||
}
|
||
|
||
func TestCreatePlantingDefaultsAndDerivedCount(t *testing.T) {
|
||
s := newTestService(t, openConfig())
|
||
owner := seedUser(t, s, "[email protected]")
|
||
g := seedGarden(t, s, owner)
|
||
bed := seedBed(t, s, owner, g.ID)
|
||
plant := seedOwnPlant(t, s, owner, 10)
|
||
|
||
pl, err := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: plant.ID, XCM: 10, YCM: -20, RadiusCM: 10,
|
||
})
|
||
if err != nil {
|
||
t.Fatalf("CreatePlanting: %v", err)
|
||
}
|
||
if pl.Count != nil {
|
||
t.Errorf("count = %v, want nil (derived)", *pl.Count)
|
||
}
|
||
if pl.DerivedCount != 3 {
|
||
t.Errorf("derivedCount = %d, want 3", pl.DerivedCount)
|
||
}
|
||
if pl.PlantedAt == nil {
|
||
t.Error("plantedAt should default to today, got nil")
|
||
}
|
||
if pl.Version != 1 || pl.ObjectID != bed.ID {
|
||
t.Errorf("unexpected planting: %+v", pl)
|
||
}
|
||
}
|
||
|
||
func TestPlantingCountOverrideWins(t *testing.T) {
|
||
s := newTestService(t, openConfig())
|
||
owner := seedUser(t, s, "[email protected]")
|
||
g := seedGarden(t, s, owner)
|
||
bed := seedBed(t, s, owner, g.ID)
|
||
plant := seedOwnPlant(t, s, owner, 10)
|
||
|
||
cnt := 12
|
||
pl, err := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: plant.ID, XCM: 0, YCM: 0, RadiusCM: 50, Count: &cnt,
|
||
})
|
||
if err != nil {
|
||
t.Fatalf("CreatePlanting: %v", err)
|
||
}
|
||
if pl.Count == nil || *pl.Count != 12 {
|
||
t.Errorf("count override = %v, want 12", pl.Count)
|
||
}
|
||
// derivedCount is still computed alongside the override (79 for r=50, sp=10).
|
||
if pl.DerivedCount != 79 {
|
||
t.Errorf("derivedCount = %d, want 79", pl.DerivedCount)
|
||
}
|
||
}
|
||
|
||
func TestUpdatePlantingMoveResizeAndClearCount(t *testing.T) {
|
||
s := newTestService(t, openConfig())
|
||
owner := seedUser(t, s, "[email protected]")
|
||
g := seedGarden(t, s, owner)
|
||
bed := seedBed(t, s, owner, g.ID)
|
||
plant := seedOwnPlant(t, s, owner, 10)
|
||
|
||
cnt := 5
|
||
pl, _ := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: plant.ID, XCM: 0, YCM: 0, RadiusCM: 10, Count: &cnt,
|
||
})
|
||
|
||
// Move + grow radius, and clear the count override back to derived.
|
||
nx, ny, nr := 30.0, -40.0, 50.0
|
||
updated, err := s.UpdatePlanting(context.Background(), owner, pl.ID,
|
||
PlantingPatch{XCM: &nx, YCM: &ny, RadiusCM: &nr, SetCount: true, Count: nil}, pl.Version)
|
||
if err != nil {
|
||
t.Fatalf("UpdatePlanting: %v", err)
|
||
}
|
||
if updated.XCM != 30 || updated.YCM != -40 || updated.RadiusCM != 50 {
|
||
t.Errorf("move/resize didn't apply: %+v", updated)
|
||
}
|
||
if updated.Count != nil {
|
||
t.Errorf("count should be cleared, got %v", *updated.Count)
|
||
}
|
||
if updated.DerivedCount != 79 { // r=50, sp=10
|
||
t.Errorf("derivedCount after grow = %d, want 79", updated.DerivedCount)
|
||
}
|
||
if updated.Version != pl.Version+1 {
|
||
t.Errorf("version = %d, want %d", updated.Version, pl.Version+1)
|
||
}
|
||
}
|
||
|
||
func TestPlantingNonPlantableObjectRejected(t *testing.T) {
|
||
s := newTestService(t, openConfig())
|
||
owner := seedUser(t, s, "[email protected]")
|
||
g := seedGarden(t, s, owner)
|
||
plant := seedOwnPlant(t, s, owner, 10)
|
||
|
||
tree, _ := s.CreateObject(context.Background(), owner, g.ID, ObjectInput{
|
||
Kind: domain.KindTree, XCM: 500, YCM: 500, WidthCM: 100, HeightCM: 100,
|
||
})
|
||
if _, err := s.CreatePlanting(context.Background(), owner, tree.ID, PlantingInput{
|
||
PlantID: plant.ID, XCM: 0, YCM: 0, RadiusCM: 10,
|
||
}); !errors.Is(err, domain.ErrInvalidInput) {
|
||
t.Errorf("planting into a tree err = %v, want ErrInvalidInput", err)
|
||
}
|
||
}
|
||
|
||
func TestPlantingForeignPlantRejectedBuiltinAllowed(t *testing.T) {
|
||
s := newTestService(t, openConfig())
|
||
owner := seedUser(t, s, "[email protected]")
|
||
bob := seedUser(t, s, "[email protected]")
|
||
g := seedGarden(t, s, owner)
|
||
bed := seedBed(t, s, owner, g.ID)
|
||
|
||
// Bob's custom plant is invisible to owner → invalid reference.
|
||
bobPlant := seedOwnPlant(t, s, bob, 10)
|
||
if _, err := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: bobPlant.ID, XCM: 0, YCM: 0, RadiusCM: 10,
|
||
}); !errors.Is(err, domain.ErrInvalidInput) {
|
||
t.Errorf("foreign plant err = %v, want ErrInvalidInput", err)
|
||
}
|
||
// An unknown plant id is likewise invalid.
|
||
if _, err := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: 999999, XCM: 0, YCM: 0, RadiusCM: 10,
|
||
}); !errors.Is(err, domain.ErrInvalidInput) {
|
||
t.Errorf("unknown plant err = %v, want ErrInvalidInput", err)
|
||
}
|
||
// A built-in plant is plantable by anyone.
|
||
builtins, _ := s.ListPlants(context.Background(), owner)
|
||
if _, err := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: builtins[0].ID, XCM: 0, YCM: 0, RadiusCM: 10,
|
||
}); err != nil {
|
||
t.Errorf("planting a built-in should work: %v", err)
|
||
}
|
||
}
|
||
|
||
func TestPlantingBoundsCheck(t *testing.T) {
|
||
s := newTestService(t, openConfig())
|
||
owner := seedUser(t, s, "[email protected]")
|
||
g := seedGarden(t, s, owner)
|
||
bed := seedBed(t, s, owner, g.ID) // 200×200 → local bounds ±100
|
||
plant := seedOwnPlant(t, s, owner, 10)
|
||
|
||
// Center outside the object's local bounds → rejected (radius may overhang,
|
||
// but the center may not).
|
||
if _, err := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: plant.ID, XCM: 150, YCM: 0, RadiusCM: 10,
|
||
}); !errors.Is(err, domain.ErrInvalidInput) {
|
||
t.Errorf("out-of-bounds center err = %v, want ErrInvalidInput", err)
|
||
}
|
||
// On the edge is allowed.
|
||
if _, err := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: plant.ID, XCM: 100, YCM: -100, RadiusCM: 30,
|
||
}); err != nil {
|
||
t.Errorf("edge-of-bounds center should be allowed: %v", err)
|
||
}
|
||
// Non-positive radius rejected.
|
||
if _, err := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: plant.ID, XCM: 0, YCM: 0, RadiusCM: 0,
|
||
}); !errors.Is(err, domain.ErrInvalidInput) {
|
||
t.Errorf("zero radius err = %v, want ErrInvalidInput", err)
|
||
}
|
||
}
|
||
|
||
func TestPlantingSoftRemoveLeavesFull(t *testing.T) {
|
||
s := newTestService(t, openConfig())
|
||
owner := seedUser(t, s, "[email protected]")
|
||
g := seedGarden(t, s, owner)
|
||
bed := seedBed(t, s, owner, g.ID)
|
||
plant := seedOwnPlant(t, s, owner, 10)
|
||
|
||
pl, _ := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: plant.ID, XCM: 0, YCM: 0, RadiusCM: 10,
|
||
})
|
||
|
||
// It shows in /full, with a derived count.
|
||
full, _ := s.GardenFull(context.Background(), owner, g.ID, nil)
|
||
if len(full.Plantings) != 1 {
|
||
t.Fatalf("full.Plantings = %d, want 1", len(full.Plantings))
|
||
}
|
||
if full.Plantings[0].DerivedCount != 3 {
|
||
t.Errorf("full derivedCount = %d, want 3", full.Plantings[0].DerivedCount)
|
||
}
|
||
if len(full.Plants) != 1 {
|
||
t.Errorf("full.Plants = %d, want 1 referenced plant", len(full.Plants))
|
||
}
|
||
|
||
// Soft-remove → it leaves /full. (On/after today's default planted_at.)
|
||
rm := "2030-06-01"
|
||
if _, err := s.UpdatePlanting(context.Background(), owner, pl.ID,
|
||
PlantingPatch{SetRemovedAt: true, RemovedAt: &rm}, pl.Version); err != nil {
|
||
t.Fatalf("soft-remove: %v", err)
|
||
}
|
||
full, _ = s.GardenFull(context.Background(), owner, g.ID, nil)
|
||
if len(full.Plantings) != 0 {
|
||
t.Errorf("removed plop still in /full: %d", len(full.Plantings))
|
||
}
|
||
}
|
||
|
||
func TestPlantingRemovedBeforePlantedRejected(t *testing.T) {
|
||
s := newTestService(t, openConfig())
|
||
owner := seedUser(t, s, "[email protected]")
|
||
g := seedGarden(t, s, owner)
|
||
bed := seedBed(t, s, owner, g.ID)
|
||
plant := seedOwnPlant(t, s, owner, 10)
|
||
|
||
// planted_at defaults to today; a removed_at in the distant past is invalid.
|
||
pl, _ := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: plant.ID, XCM: 0, YCM: 0, RadiusCM: 10,
|
||
})
|
||
past := "2000-01-01"
|
||
if _, err := s.UpdatePlanting(context.Background(), owner, pl.ID,
|
||
PlantingPatch{SetRemovedAt: true, RemovedAt: &past}, pl.Version); !errors.Is(err, domain.ErrInvalidInput) {
|
||
t.Errorf("removed-before-planted err = %v, want ErrInvalidInput", err)
|
||
}
|
||
}
|
||
|
||
func TestUpdatePlantingEditableAfterObjectShrinks(t *testing.T) {
|
||
s := newTestService(t, openConfig())
|
||
owner := seedUser(t, s, "[email protected]")
|
||
g := seedGarden(t, s, owner)
|
||
bed := seedBed(t, s, owner, g.ID) // 200×200 → local bounds ±100
|
||
plant := seedOwnPlant(t, s, owner, 10)
|
||
|
||
// A plop near the bed's edge.
|
||
pl, _ := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: plant.ID, XCM: 90, YCM: 0, RadiusCM: 10,
|
||
})
|
||
|
||
// Shrink the bed to 100×100 (local bounds ±50): the plop's center (90) is now
|
||
// outside the object.
|
||
w, h := 100.0, 100.0
|
||
if _, err := s.UpdateObject(context.Background(), owner, bed.ID, ObjectPatch{WidthCM: &w, HeightCM: &h}, bed.Version); err != nil {
|
||
t.Fatalf("shrink bed: %v", err)
|
||
}
|
||
|
||
// Editing the out-of-bounds plop without moving it (radius here) must still
|
||
// work — otherwise it'd be un-removable.
|
||
nr := 15.0
|
||
updated, err := s.UpdatePlanting(context.Background(), owner, pl.ID, PlantingPatch{RadiusCM: &nr}, pl.Version)
|
||
if err != nil {
|
||
t.Fatalf("radius edit on orphaned plop should work: %v", err)
|
||
}
|
||
// But actually moving it still enforces the new bounds.
|
||
outside := 90.0
|
||
if _, err := s.UpdatePlanting(context.Background(), owner, pl.ID, PlantingPatch{XCM: &outside}, updated.Version); !errors.Is(err, domain.ErrInvalidInput) {
|
||
t.Errorf("moving to out-of-bounds should be rejected: %v", err)
|
||
}
|
||
// Moving it back inside works.
|
||
inside := 10.0
|
||
if _, err := s.UpdatePlanting(context.Background(), owner, pl.ID, PlantingPatch{XCM: &inside}, updated.Version); err != nil {
|
||
t.Errorf("moving in-bounds should work: %v", err)
|
||
}
|
||
}
|
||
|
||
func TestPlantingVersionConflict(t *testing.T) {
|
||
s := newTestService(t, openConfig())
|
||
owner := seedUser(t, s, "[email protected]")
|
||
g := seedGarden(t, s, owner)
|
||
bed := seedBed(t, s, owner, g.ID)
|
||
plant := seedOwnPlant(t, s, owner, 10)
|
||
pl, _ := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: plant.ID, XCM: 0, YCM: 0, RadiusCM: 10,
|
||
})
|
||
|
||
nr := 20.0
|
||
if _, err := s.UpdatePlanting(context.Background(), owner, pl.ID, PlantingPatch{RadiusCM: &nr}, pl.Version); err != nil {
|
||
t.Fatalf("first update: %v", err)
|
||
}
|
||
current, err := s.UpdatePlanting(context.Background(), owner, pl.ID, PlantingPatch{RadiusCM: &nr}, pl.Version)
|
||
if !errors.Is(err, domain.ErrVersionConflict) {
|
||
t.Fatalf("stale update err = %v, want ErrVersionConflict", err)
|
||
}
|
||
if current == nil || current.Version != 2 {
|
||
t.Fatalf("conflict didn't return current row: %+v", current)
|
||
}
|
||
if current.DerivedCount < 1 {
|
||
t.Errorf("conflict current row should carry a derived count, got %d", current.DerivedCount)
|
||
}
|
||
}
|
||
|
||
func TestPlantingCrossUserIsNotFound(t *testing.T) {
|
||
s := newTestService(t, openConfig())
|
||
owner := seedUser(t, s, "[email protected]")
|
||
bob := seedUser(t, s, "[email protected]")
|
||
g := seedGarden(t, s, owner)
|
||
bed := seedBed(t, s, owner, g.ID)
|
||
plant := seedOwnPlant(t, s, owner, 10)
|
||
pl, _ := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: plant.ID, XCM: 0, YCM: 0, RadiusCM: 10,
|
||
})
|
||
|
||
nr := 5.0
|
||
if _, err := s.UpdatePlanting(context.Background(), bob, pl.ID, PlantingPatch{RadiusCM: &nr}, pl.Version); !errors.Is(err, domain.ErrNotFound) {
|
||
t.Errorf("bob update err = %v, want ErrNotFound", err)
|
||
}
|
||
if err := s.DeletePlanting(context.Background(), bob, pl.ID); !errors.Is(err, domain.ErrNotFound) {
|
||
t.Errorf("bob delete err = %v, want ErrNotFound", err)
|
||
}
|
||
// Bob can't place into owner's bed either.
|
||
if _, err := s.CreatePlanting(context.Background(), bob, bed.ID, PlantingInput{
|
||
PlantID: plant.ID, XCM: 0, YCM: 0, RadiusCM: 10,
|
||
}); !errors.Is(err, domain.ErrNotFound) {
|
||
t.Errorf("bob create err = %v, want ErrNotFound", err)
|
||
}
|
||
}
|
||
|
||
func TestDeletePlanting(t *testing.T) {
|
||
s := newTestService(t, openConfig())
|
||
owner := seedUser(t, s, "[email protected]")
|
||
g := seedGarden(t, s, owner)
|
||
bed := seedBed(t, s, owner, g.ID)
|
||
plant := seedOwnPlant(t, s, owner, 10)
|
||
pl, _ := s.CreatePlanting(context.Background(), owner, bed.ID, PlantingInput{
|
||
PlantID: plant.ID, XCM: 0, YCM: 0, RadiusCM: 10,
|
||
})
|
||
|
||
if err := s.DeletePlanting(context.Background(), owner, pl.ID); err != nil {
|
||
t.Fatalf("DeletePlanting: %v", err)
|
||
}
|
||
full, _ := s.GardenFull(context.Background(), owner, g.ID, nil)
|
||
if len(full.Plantings) != 0 {
|
||
t.Errorf("planting still present after delete: %d", len(full.Plantings))
|
||
}
|
||
}
|