diff --git a/internal/agent/tools.go b/internal/agent/tools.go index e3ad479..5bc0718 100644 --- a/internal/agent/tools.go +++ b/internal/agent/tools.go @@ -36,11 +36,36 @@ func NewToolbox(svc *service.Service, actorID int64) *llm.Toolbox { "Place one plop of a plant inside a plantable object, positioned in the object's LOCAL frame (0,0 = object center, -y = north).", a.placePlanting), llm.DefineTool("fill_region", - "Fill a named region of a plantable object with a plant, hex-packed. Region is one of nw/ne/sw/se (corners), north/south/east/west or top/bottom/left/right (halves), or all.", + "Fill part of a plantable object with one plant, hex-packed at the plant's spacing. "+ + "region is a compass name, not coordinates: nw|ne|sw|se for the quarter corners, "+ + "north|south|east|west (or top|bottom|left|right) for halves, or all for the whole thing. "+ + "North is the top of the garden. Example: to replant a whole bed, clear_object then "+ + "fill_region with region=all. Filling skips spots already covered by an existing plant, "+ + "so it is safe to run twice.", a.fillRegion), llm.DefineTool("clear_object", - "Remove all plants from an object (soft-remove; history is kept).", + "Remove all plants from an object. They are soft-removed, so the planting history for past "+ + "seasons is kept and the change can be undone. Use this before replanting a bed with "+ + "something else.", a.clearObject), + llm.DefineTool("find_plant", + "Look up plants in the user's catalog by name or category, to get the plantId that "+ + "place_planting and fill_region need. Returns SEVERAL candidates when the query is "+ + "ambiguous — \"garlic\" may match both the built-in \"Garlic\" and a custom \"German Red "+ + "Garlic\" — so pick the one that fits what the user asked for, or ask them which. Each "+ + "result also reports how much seed the user has left of it, when they have recorded any.", + a.findPlant), + llm.DefineTool("create_plant", + "Add a new plant to the user's own catalog, for when they name a variety that isn't in it "+ + "yet. Check find_plant first — creating a duplicate of something that already exists is "+ + "worse than reusing it. The plant belongs to the user, not to any garden.", + a.createPlant), + llm.DefineTool("add_journal_entry", + "Write a dated observation into the garden's grow journal — what happened, and when. "+ + "Attach it to one bed with objectId when it is about that bed. This is for events "+ + "(\"powdery mildew on the west bed\", \"first frost\"), not for descriptions of what a "+ + "thing is. observedAt defaults to today; set it to backdate.", + a.addJournalEntry), ) } @@ -108,6 +133,42 @@ func (a *adapter) fillRegion(ctx context.Context, args struct { return a.svc.FillNamedRegion(ctx, a.actor, args.ObjectID, args.Region, args.PlantID, args.SpacingOverride) } +func (a *adapter) findPlant(ctx context.Context, args struct { + Query string `json:"query" description:"plant name or category to search for, e.g. \"cucumber\" or \"herb\"; empty lists the catalog"` +}) (any, error) { + return a.svc.FindPlants(ctx, a.actor, args.Query) +} + +func (a *adapter) createPlant(ctx context.Context, args struct { + Name string `json:"name" description:"the variety's name, e.g. \"German Red Garlic\""` + Category string `json:"category" description:"vegetable | herb | flower | fruit | tree_shrub | cover"` + SpacingCM float64 `json:"spacingCm" description:"mature in-row spacing in cm; this is what fill_region packs to"` + Color string `json:"color" description:"hex color for the plant on the canvas, e.g. #8a5a8a"` + Icon string `json:"icon" description:"a single emoji to draw it with, e.g. 🧄"` + DaysToMaturity *int `json:"daysToMaturity" description:"optional days from planting to harvest"` + SourceURL string `json:"sourceUrl" description:"optional http(s) link to where the seed came from"` + Vendor string `json:"vendor" description:"optional vendor name, e.g. \"Johnny\u0027s Selected Seeds\""` +}) (any, error) { + return a.svc.CreatePlant(ctx, a.actor, service.PlantInput{ + Name: args.Name, Category: args.Category, SpacingCM: args.SpacingCM, + Color: args.Color, Icon: args.Icon, DaysToMaturity: args.DaysToMaturity, + SourceURL: args.SourceURL, Vendor: args.Vendor, + }) +} + +func (a *adapter) addJournalEntry(ctx context.Context, args struct { + GardenID int64 `json:"gardenId" description:"garden the observation is about"` + ObjectID *int64 `json:"objectId" description:"optional bed the observation is about; omit for a garden-level note"` + Body string `json:"body" description:"what happened, in plain words"` + ObservedAt string `json:"observedAt" description:"optional date it happened, YYYY-MM-DD; defaults to today"` +}) (any, error) { + in := service.JournalInput{ObjectID: args.ObjectID, Body: args.Body} + if args.ObservedAt != "" { + in.ObservedAt = &args.ObservedAt + } + return a.svc.CreateJournalEntry(ctx, a.actor, args.GardenID, in) +} + func (a *adapter) clearObject(ctx context.Context, args struct { ObjectID int64 `json:"objectId" description:"object to remove all plants from"` }) (any, error) { diff --git a/internal/agent/tools_test.go b/internal/agent/tools_test.go index a1d33c8..f116377 100644 --- a/internal/agent/tools_test.go +++ b/internal/agent/tools_test.go @@ -5,6 +5,7 @@ package agent import ( "context" "encoding/json" + "strings" "testing" "gitea.stevedudenhoeffer.com/steve/majordomo/llm" @@ -24,21 +25,8 @@ import ( // Build/run with: go test -tags majordomo ./internal/agent/ func TestToolboxScenario(t *testing.T) { ctx := context.Background() - db, err := store.Open(":memory:") - if err != nil { - t.Fatalf("open: %v", err) - } - t.Cleanup(func() { db.Close() }) - if err := db.Migrate(ctx); err != nil { - t.Fatalf("migrate: %v", err) - } - svc := service.New(db, &config.Config{Registration: config.RegistrationOpen, LocalAuth: true}) - - owner, err := svc.Register(ctx, service.RegisterInput{Email: "a@example.com", DisplayName: "A", Password: "password123"}) - if err != nil { - t.Fatalf("register: %v", err) - } - box := NewToolbox(svc, owner.ID) + svc, ownerID := newAgentTestService(t) + box := NewToolbox(svc, ownerID) call := func(name string, args any) llm.ToolResult { t.Helper() @@ -48,13 +36,13 @@ func TestToolboxScenario(t *testing.T) { // Garden + plants are set up directly (there are no create_garden/plant tools); // the agent-facing bits — object + fills + describe — go through the toolbox. - g, err := svc.CreateGarden(ctx, owner.ID, service.GardenInput{Name: "Plot", WidthCM: 2000, HeightCM: 2000}) + g, err := svc.CreateGarden(ctx, ownerID, service.GardenInput{Name: "Plot", WidthCM: 2000, HeightCM: 2000}) if err != nil { t.Fatalf("garden: %v", err) } - garlic := mustPlant(t, svc, owner.ID, "Garlic", 15, "🧄") - basil := mustPlant(t, svc, owner.ID, "Basil", 25, "🌿") - beans := mustPlant(t, svc, owner.ID, "Beans", 10, "🫘") + garlic := mustPlant(t, svc, ownerID, "Garlic", 15, "🧄") + basil := mustPlant(t, svc, ownerID, "Basil", 25, "🌿") + beans := mustPlant(t, svc, ownerID, "Beans", 10, "🫘") // create_object → a 400×400 bed. res := call("create_object", map[string]any{ @@ -119,7 +107,7 @@ func TestToolboxScenario(t *testing.T) { if err != nil { t.Fatalf("register viewer: %v", err) } - if _, err := svc.AddShare(ctx, owner.ID, g.ID, "v@example.com", domain.RoleViewer); err != nil { + if _, err := svc.AddShare(ctx, ownerID, g.ID, "v@example.com", domain.RoleViewer); err != nil { t.Fatalf("share: %v", err) } viewerBox := NewToolbox(svc, viewerUser.ID) @@ -150,3 +138,233 @@ func mustPlant(t *testing.T, svc *service.Service, owner int64, name string, spa } return p } + +// TestGarlicBedToCucumbers is the flagship interaction from #58, driven end to +// end through the tool layer: "change the garlic garden bed to instead be +// cucumbers this year". +// +// The sequence is the one a model would actually run — describe to find the bed, +// find_plant to turn the word "cucumber" into an id, clear, refill — and until +// find_plant existed step three had no way to get its plantId, which blocked the +// whole thing on one missing tool. +func TestGarlicBedToCucumbers(t *testing.T) { + ctx := context.Background() + svc, owner := newAgentTestService(t) + box := NewToolbox(svc, owner) + + call := func(name string, args any) llm.ToolResult { + t.Helper() + raw, _ := json.Marshal(args) + return box.Execute(ctx, llm.ToolCall{ID: "1", Name: name, Arguments: raw}) + } + + g, err := svc.CreateGarden(ctx, owner, service.GardenInput{Name: "Plot", WidthCM: 2000, HeightCM: 2000}) + if err != nil { + t.Fatalf("garden: %v", err) + } + garlic := mustPlant(t, svc, owner, "Garlic", 15, "🧄") + mustPlant(t, svc, owner, "Cucumber", 45, "🥒") + + bed, err := svc.CreateObject(ctx, owner, g.ID, service.ObjectInput{ + Kind: domain.KindBed, Name: "Garlic bed", XCM: 1000, YCM: 1000, WidthCM: 400, HeightCM: 400, + }) + if err != nil { + t.Fatalf("bed: %v", err) + } + if _, err := svc.FillNamedRegion(ctx, owner, bed.ID, "all", garlic.ID, nil); err != nil { + t.Fatalf("seed the garlic: %v", err) + } + + // 1. describe_garden — "the garlic bed" resolves to an object id, because the + // description carries the NAMES of what's planted in each object. + res := call("describe_garden", map[string]any{"gardenId": g.ID}) + if res.IsError { + t.Fatalf("describe_garden: %s", res.Content) + } + if !strings.Contains(res.Content, "Garlic") { + t.Fatalf("describe_garden didn't name what's planted: %s", res.Content) + } + + // 2. find_plant — the step that used to be impossible. + res = call("find_plant", map[string]any{"query": "cucumber"}) + if res.IsError { + t.Fatalf("find_plant: %s", res.Content) + } + var matches []struct { + ID int64 `json:"id"` + Name string `json:"name"` + } + if err := json.Unmarshal([]byte(res.Content), &matches); err != nil { + t.Fatalf("decode find_plant: %v (%s)", err, res.Content) + } + if len(matches) == 0 || matches[0].Name != "Cucumber" { + t.Fatalf("find_plant(cucumber) = %+v", matches) + } + + // 3. clear_object, 4. fill_region. + if r := call("clear_object", map[string]any{"objectId": bed.ID}); r.IsError { + t.Fatalf("clear_object: %s", r.Content) + } + if r := call("fill_region", map[string]any{ + "objectId": bed.ID, "region": "all", "plantId": matches[0].ID, + }); r.IsError { + t.Fatalf("fill_region: %s", r.Content) + } + + // The bed is cucumbers, and no garlic is still growing in it. + full, err := svc.GardenFull(ctx, owner, g.ID, nil) + if err != nil { + t.Fatalf("GardenFull: %v", err) + } + if len(full.Plantings) == 0 { + t.Fatal("the bed ended up empty") + } + for _, p := range full.Plantings { + if p.PlantID == garlic.ID { + t.Errorf("garlic is still active in the bed") + } + if p.PlantID != matches[0].ID { + t.Errorf("unexpected plant %d in the bed", p.PlantID) + } + } +} + +// TestFindPlantReturnsCandidatesNotAGuess — "garlic" against a catalog holding +// both "Garlic" and "German Red Garlic" is genuinely ambiguous, and silently +// picking one is how the agent plants the wrong thing. +func TestFindPlantReturnsCandidatesNotAGuess(t *testing.T) { + ctx := context.Background() + svc, owner := newAgentTestService(t) + box := NewToolbox(svc, owner) + + mustPlant(t, svc, owner, "German Red Garlic", 15, "🧄") + + raw, _ := json.Marshal(map[string]any{"query": "garlic"}) + res := box.Execute(ctx, llm.ToolCall{ID: "1", Name: "find_plant", Arguments: raw}) + if res.IsError { + t.Fatalf("find_plant: %s", res.Content) + } + var matches []struct { + Name string `json:"name"` + } + if err := json.Unmarshal([]byte(res.Content), &matches); err != nil { + t.Fatalf("decode: %v", err) + } + names := map[string]bool{} + for _, m := range matches { + names[m.Name] = true + } + // The built-in catalog seeds a plain "Garlic"; the custom one is ours. + if !names["Garlic"] || !names["German Red Garlic"] { + t.Errorf("find_plant(garlic) = %+v, want both the built-in and the custom variety", matches) + } + // Exact match ranks first, so a caller taking [0] gets the least surprising one. + if len(matches) > 0 && matches[0].Name != "Garlic" { + t.Errorf("first match = %q, want the exact name", matches[0].Name) + } +} + +// TestCreatePlantIsUserScoped — the catalog belongs to the user, not to any +// garden, so someone with no editable garden can still name a new variety. The +// issue asks for this to be asserted rather than assumed. +func TestCreatePlantIsUserScoped(t *testing.T) { + ctx := context.Background() + svc, owner := newAgentTestService(t) + other, err := svc.Register(ctx, service.RegisterInput{Email: "b@example.com", DisplayName: "B", Password: "password123"}) + if err != nil { + t.Fatalf("register: %v", err) + } + box := NewToolbox(svc, other.ID) + + raw, _ := json.Marshal(map[string]any{ + "name": "Painted Mountain Corn", "category": "vegetable", + "spacingCm": 30.0, "color": "#c08a3f", "icon": "🌽", + }) + res := box.Execute(ctx, llm.ToolCall{ID: "1", Name: "create_plant", Arguments: raw}) + if res.IsError { + t.Fatalf("create_plant: %s", res.Content) + } + var created struct { + ID int64 `json:"id"` + OwnerID *int64 `json:"ownerId"` + Name string `json:"name"` + } + if err := json.Unmarshal([]byte(res.Content), &created); err != nil { + t.Fatalf("decode: %v", err) + } + if created.OwnerID == nil || *created.OwnerID != other.ID { + t.Errorf("ownerId = %v, want the acting user %d", created.OwnerID, other.ID) + } + // And it stays theirs: the other user's catalog doesn't gain it. + ownerPlants, err := svc.ListPlants(ctx, owner) + if err != nil { + t.Fatalf("ListPlants: %v", err) + } + for _, p := range ownerPlants { + if p.Name == "Painted Mountain Corn" { + t.Error("a plant created by one user showed up in another's catalog") + } + } +} + +// TestJournalToolWritesADatedObservation — "note that the west bed has mildew" +// is squarely the kind of thing you say out loud while walking around. +func TestJournalToolWritesADatedObservation(t *testing.T) { + ctx := context.Background() + svc, owner := newAgentTestService(t) + box := NewToolbox(svc, owner) + + g, err := svc.CreateGarden(ctx, owner, service.GardenInput{Name: "Plot", WidthCM: 2000, HeightCM: 2000}) + if err != nil { + t.Fatalf("garden: %v", err) + } + bed, err := svc.CreateObject(ctx, owner, g.ID, service.ObjectInput{ + Kind: domain.KindBed, Name: "West bed", XCM: 500, YCM: 500, WidthCM: 200, HeightCM: 200, + }) + if err != nil { + t.Fatalf("bed: %v", err) + } + + raw, _ := json.Marshal(map[string]any{ + "gardenId": g.ID, "objectId": bed.ID, + "body": "Powdery mildew on the west bed", "observedAt": "2026-08-14", + }) + res := box.Execute(ctx, llm.ToolCall{ID: "1", Name: "add_journal_entry", Arguments: raw}) + if res.IsError { + t.Fatalf("add_journal_entry: %s", res.Content) + } + + entries, _, err := svc.ListJournal(ctx, owner, g.ID, service.JournalQuery{ObjectID: &bed.ID}) + if err != nil { + t.Fatalf("ListJournal: %v", err) + } + if len(entries) != 1 { + t.Fatalf("got %d entries, want 1", len(entries)) + } + if entries[0].Body != "Powdery mildew on the west bed" || entries[0].ObservedAt != "2026-08-14" { + t.Errorf("unexpected entry: %+v", entries[0]) + } + if entries[0].AuthorID != owner { + t.Errorf("author = %d, want the acting user %d", entries[0].AuthorID, owner) + } +} + +// newAgentTestService spins up an in-memory pansy with one registered user. +func newAgentTestService(t *testing.T) (*service.Service, int64) { + t.Helper() + ctx := context.Background() + db, err := store.Open(":memory:") + if err != nil { + t.Fatalf("open: %v", err) + } + t.Cleanup(func() { db.Close() }) + if err := db.Migrate(ctx); err != nil { + t.Fatalf("migrate: %v", err) + } + svc := service.New(db, &config.Config{Registration: config.RegistrationOpen, LocalAuth: true}) + owner, err := svc.Register(ctx, service.RegisterInput{Email: "a@example.com", DisplayName: "A", Password: "password123"}) + if err != nil { + t.Fatalf("register: %v", err) + } + return svc, owner.ID +} diff --git a/internal/service/plants.go b/internal/service/plants.go index c664b7d..2f2214d 100644 --- a/internal/service/plants.go +++ b/internal/service/plants.go @@ -2,6 +2,7 @@ package service import ( "context" + "sort" "strings" "gitea.stevedudenhoeffer.com/steve/pansy/internal/domain" @@ -69,6 +70,124 @@ func (s *Service) ListPlants(ctx context.Context, actorID int64) ([]domain.Plant return s.store.ListPlantsForActor(ctx, actorID) } +// PlantMatch is a candidate from FindPlants: the plant, plus what seed the actor +// has left of it, so an agent can say "you only have enough for half that bed" +// instead of confidently planting seed that doesn't exist. +type PlantMatch struct { + domain.Plant + // SeedRemaining is the total left across the actor's lots of this plant, and + // SeedUnit the unit they're counted in. Both are omitted when there are no + // lots — and also when the lots disagree about the unit, because adding + // grams to packets produces a number that means nothing. SeedLots still + // reports how many there are, so "several lots, no single total" is + // distinguishable from "no seed at all". + SeedRemaining *float64 `json:"seedRemaining,omitempty"` + SeedUnit string `json:"seedUnit,omitempty"` + SeedLots int `json:"seedLots,omitempty"` +} + +// maxPlantMatches caps FindPlants. A model given fifty candidates is not being +// helped; if the query is that broad the answer is to ask a better one. +const maxPlantMatches = 10 + +// FindPlants returns the plants in the actor's visible catalog (built-ins plus +// their own) whose name or category matches the query, best match first. +// +// It deliberately returns SEVERAL candidates rather than one guess. "garlic" +// against a catalog holding both "Garlic" and "German Red Garlic" is genuinely +// ambiguous, and a caller with the surrounding conversation is far better placed +// to disambiguate than a fuzzy-match heuristic here. An empty query returns the +// catalog head rather than nothing, so a caller can browse. +func (s *Service) FindPlants(ctx context.Context, actorID int64, query string) ([]PlantMatch, error) { + plants, err := s.store.ListPlantsForActor(ctx, actorID) + if err != nil { + return nil, err + } + q := strings.ToLower(strings.TrimSpace(query)) + + type scored struct { + plant domain.Plant + rank int + } + ranked := make([]scored, 0, len(plants)) + for _, p := range plants { + name := strings.ToLower(p.Name) + switch { + case q == "": + ranked = append(ranked, scored{p, 3}) + case name == q: + ranked = append(ranked, scored{p, 0}) + case strings.HasPrefix(name, q): + ranked = append(ranked, scored{p, 1}) + case strings.Contains(name, q): + ranked = append(ranked, scored{p, 2}) + case strings.Contains(strings.ToLower(p.Category), q): + ranked = append(ranked, scored{p, 3}) + } + } + // Stable by rank then name, so the same query always answers the same way — + // a tool whose results reshuffle between calls is one a model can't reason + // about across turns. + sort.SliceStable(ranked, func(i, j int) bool { + if ranked[i].rank != ranked[j].rank { + return ranked[i].rank < ranked[j].rank + } + return ranked[i].plant.Name < ranked[j].plant.Name + }) + if len(ranked) > maxPlantMatches { + ranked = ranked[:maxPlantMatches] + } + + matches := make([]PlantMatch, 0, len(ranked)) + for _, r := range ranked { + matches = append(matches, PlantMatch{Plant: r.plant}) + } + if err := s.attachSeedRemaining(ctx, actorID, matches); err != nil { + return nil, err + } + return matches, nil +} + +// attachSeedRemaining fills SeedRemaining/SeedUnit from the actor's lots. +func (s *Service) attachSeedRemaining(ctx context.Context, actorID int64, matches []PlantMatch) error { + if len(matches) == 0 { + return nil + } + lots, err := s.ListSeedLots(ctx, actorID, nil) + if err != nil { + return err + } + byPlant := map[int64][]domain.SeedLot{} + for _, l := range lots { + byPlant[l.PlantID] = append(byPlant[l.PlantID], l) + } + for i := range matches { + ls := byPlant[matches[i].ID] + if len(ls) == 0 { + continue + } + matches[i].SeedLots = len(ls) + unit := ls[0].Unit + mixed := false + total := 0.0 + for _, l := range ls { + total += l.Remaining + if l.Unit != unit { + mixed = true + } + } + if mixed { + // Dropping only the LABEL would leave a number that reads as a + // quantity and isn't one. Drop the total with it; SeedLots still says + // there is seed here, just not one figure for it. + continue + } + matches[i].SeedRemaining = &total + matches[i].SeedUnit = unit + } + return nil +} + // CreatePlant adds a plant owned by the actor. To "clone" a built-in the client // simply POSTs a copy — there is no dedicated endpoint, and the copy is owned by // (and editable by) the actor. diff --git a/internal/service/plants_test.go b/internal/service/plants_test.go index 6b20854..9394691 100644 --- a/internal/service/plants_test.go +++ b/internal/service/plants_test.go @@ -237,3 +237,138 @@ func TestDeletePlantInUseIsBlocked(t *testing.T) { t.Errorf("delete freed plant: %v", err) } } + +// TestFindPlantsRanksAndDisambiguates — FindPlants deliberately returns several +// candidates rather than one guess, because "garlic" against a catalog holding +// both "Garlic" and "German Red Garlic" is genuinely ambiguous and a caller with +// the surrounding context is better placed to choose than a heuristic here. +func TestFindPlantsRanksAndDisambiguates(t *testing.T) { + s := newTestService(t, openConfig()) + owner := seedUser(t, s, "a@example.com") + ctx := context.Background() + + custom, err := s.CreatePlant(ctx, owner, PlantInput{ + Name: "German Red Garlic", Category: domain.CategoryVegetable, SpacingCM: 15, + Color: "#8a5a8a", Icon: "🧄", + }) + if err != nil { + t.Fatalf("CreatePlant: %v", err) + } + + got, err := s.FindPlants(ctx, owner, "garlic") + if err != nil { + t.Fatalf("FindPlants: %v", err) + } + names := map[string]bool{} + for _, m := range got { + names[m.Name] = true + } + if !names["Garlic"] || !names[custom.Name] { + t.Errorf("got %v, want both the built-in and the custom variety", names) + } + // Exact match first, so a caller taking [0] gets the least surprising one. + if got[0].Name != "Garlic" { + t.Errorf("first match = %q, want the exact name", got[0].Name) + } + + // Prefix beats substring: "german" should surface the custom one first. + pre, err := s.FindPlants(ctx, owner, "german") + if err != nil { + t.Fatalf("FindPlants: %v", err) + } + if len(pre) == 0 || pre[0].Name != custom.Name { + t.Errorf("FindPlants(german) = %+v, want the custom variety first", pre) + } + + // Category search works, and a query matching nothing says so plainly. + if herbs, _ := s.FindPlants(ctx, owner, "herb"); len(herbs) == 0 { + t.Error("category search found nothing") + } + if none, _ := s.FindPlants(ctx, owner, "zzzzz"); len(none) != 0 { + t.Errorf("FindPlants(zzzzz) = %+v, want nothing", none) + } +} + +// TestFindPlantsReportsSeedRemaining — so a caller can say "you only have enough +// for half that bed" instead of confidently planting seed that doesn't exist. +func TestFindPlantsReportsSeedRemaining(t *testing.T) { + s := newTestService(t, openConfig()) + owner := seedUser(t, s, "a@example.com") + other := seedUser(t, s, "b@example.com") + ctx := context.Background() + + plant := seedOwnPlant(t, s, owner, 15) + if _, err := s.CreateSeedLot(ctx, owner, SeedLotInput{ + PlantID: plant.ID, Quantity: 100, Unit: domain.UnitSeeds, + }); err != nil { + t.Fatalf("CreateSeedLot: %v", err) + } + + got, err := s.FindPlants(ctx, owner, plant.Name) + if err != nil { + t.Fatalf("FindPlants: %v", err) + } + if len(got) == 0 || got[0].SeedRemaining == nil || *got[0].SeedRemaining != 100 { + t.Fatalf("seedRemaining = %+v, want 100", got[0].SeedRemaining) + } + if got[0].SeedUnit != domain.UnitSeeds { + t.Errorf("seedUnit = %q", got[0].SeedUnit) + } + + // A plant with no lots reports nothing rather than a misleading zero. + builtin, err := s.FindPlants(ctx, owner, "Garlic") + if err != nil { + t.Fatalf("FindPlants: %v", err) + } + if len(builtin) > 0 && builtin[0].SeedRemaining != nil { + t.Errorf("a plant with no lots reported %v remaining", *builtin[0].SeedRemaining) + } + + // And lots are private: another user searching the same plant sees no seed. + // (They can't see the custom plant at all, so search a built-in instead.) + if _, err := s.CreateSeedLot(ctx, other, SeedLotInput{ + PlantID: builtinPlantID(t, s, other), Quantity: 50, Unit: domain.UnitSeeds, + }); err != nil { + t.Fatalf("CreateSeedLot(other): %v", err) + } + mine, _ := s.FindPlants(ctx, owner, "Garlic") + for _, m := range mine { + if m.SeedRemaining != nil { + t.Errorf("saw another user's seed count on %q", m.Name) + } + } +} + +// TestFindPlantsOmitsATotalItCannotHonestlyGive — lots in different units can't +// be summed. Dropping only the unit LABEL would leave a number that reads as a +// quantity and isn't one; the count of lots still says there is seed here. +func TestFindPlantsOmitsATotalItCannotHonestlyGive(t *testing.T) { + s := newTestService(t, openConfig()) + owner := seedUser(t, s, "a@example.com") + plant := seedOwnPlant(t, s, owner, 15) + ctx := context.Background() + + for _, u := range []string{domain.UnitSeeds, domain.UnitGrams} { + if _, err := s.CreateSeedLot(ctx, owner, SeedLotInput{PlantID: plant.ID, Quantity: 50, Unit: u}); err != nil { + t.Fatalf("CreateSeedLot(%s): %v", u, err) + } + } + + got, err := s.FindPlants(ctx, owner, plant.Name) + if err != nil { + t.Fatalf("FindPlants: %v", err) + } + if len(got) == 0 { + t.Fatal("plant not found") + } + if got[0].SeedRemaining != nil { + t.Errorf("reported %v across mismatched units; that number means nothing", *got[0].SeedRemaining) + } + if got[0].SeedUnit != "" { + t.Errorf("seedUnit = %q, want empty", got[0].SeedUnit) + } + // But "several lots, no single total" must stay distinguishable from "none". + if got[0].SeedLots != 2 { + t.Errorf("seedLots = %d, want 2", got[0].SeedLots) + } +}