dev_agentandClaude Opus 5.5
45c4f8a803
Connect the features to the notification outbox so real events notify,
each stored by the new notify.EmitTx in the transaction of the change it
is about (Wake after commit):
- plan_ready:{weekStart} (/plan) when a draft job stores the AI's draft;
a redraft shares the key and a manual swap never emits. The title reads
"Next week's plan is ready" for the coming week.
- list_ready:{weekStart} (/plan/shopping) when a week's Supply run is
first created, by generate or after Push to Calendar.
- new_suggestions:{batchId} (/discover) when a scheduled or manual batch
ends done with cards; replenish batches never notify.
- plan.Service.EmitDayOfReminder(date) emits day_of_reminder:{date} for
the Feature 20 scheduler.
Add POST /api/v1/shopping/{weekStart}/send-chat: shopping.SendToChat posts
the dinners with needed items and a link through chat.PostSupplyRun,
records sent_to_chat_at, and is idempotent per week unless
{"resend": true}. The Supply run's Send to Google Chat button calls it
("Send again" once sent) and shows failures in an ErrorBanner; the unused
Unavailable placeholder is removed.
Task: f0cd9d50-9c11-41be-a945-7bae9f5f28a4
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
98 lines
2.5 KiB
Go
98 lines
2.5 KiB
Go
// Package chattest provides a fake Google Chat incoming webhook for tests
|
|
// of the features that post to Google Chat: an httptest server that
|
|
// records each post and answers a status the test sets, reached through a
|
|
// transport that sends chat.googleapis.com requests to it.
|
|
package chattest
|
|
|
|
import (
|
|
"encoding/json"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"net/url"
|
|
"sync"
|
|
"testing"
|
|
)
|
|
|
|
// Webhook is a valid Google Chat incoming webhook URL to store.
|
|
const Webhook = "https://chat.googleapis.com/v1/spaces/AAQA1b2C3d4/messages?key=AIzaSyDdI0hCZtE6vySjMm-WEfRq3CPzqKqqsHI&token=q0Lz3kV9Yw8pXcRtN2bHsJdFgA7uEmKiOlP1nZxQ%3D"
|
|
|
|
// Post is one message the fake received.
|
|
type Post struct {
|
|
// Query is the request's query: key, token and any threading.
|
|
Query url.Values
|
|
// Body is the decoded JSON message.
|
|
Body map[string]any
|
|
}
|
|
|
|
// Text is the post's text.
|
|
func (p Post) Text() string {
|
|
s, _ := p.Body["text"].(string)
|
|
return s
|
|
}
|
|
|
|
// Chat is a fake Google Chat endpoint. It answers 200 until SetStatus.
|
|
type Chat struct {
|
|
srv *httptest.Server
|
|
mu sync.Mutex
|
|
status int
|
|
posts []Post
|
|
}
|
|
|
|
// New starts a fake Google Chat endpoint, closed when the test ends.
|
|
func New(t *testing.T) *Chat {
|
|
t.Helper()
|
|
c := &Chat{status: http.StatusOK}
|
|
c.srv = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
data, _ := io.ReadAll(r.Body)
|
|
var body map[string]any
|
|
if err := json.Unmarshal(data, &body); err != nil {
|
|
t.Errorf("Google Chat post body %q: %v", data, err)
|
|
}
|
|
c.mu.Lock()
|
|
c.posts = append(c.posts, Post{Query: r.URL.Query(), Body: body})
|
|
status := c.status
|
|
c.mu.Unlock()
|
|
w.WriteHeader(status)
|
|
}))
|
|
t.Cleanup(c.srv.Close)
|
|
return c
|
|
}
|
|
|
|
// Transport sends every request to the fake, as if it were
|
|
// chat.googleapis.com.
|
|
func (c *Chat) Transport() http.RoundTripper {
|
|
return transport{c}
|
|
}
|
|
|
|
type transport struct{ c *Chat }
|
|
|
|
func (tr transport) RoundTrip(req *http.Request) (*http.Response, error) {
|
|
target, err := url.Parse(tr.c.srv.URL)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
out := req.Clone(req.Context())
|
|
out.URL.Scheme, out.URL.Host = target.Scheme, target.Host
|
|
return http.DefaultTransport.RoundTrip(out)
|
|
}
|
|
|
|
// SetStatus makes the fake answer status from now on.
|
|
func (c *Chat) SetStatus(status int) {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
c.status = status
|
|
}
|
|
|
|
// Close stops the fake, so posts get no answer.
|
|
func (c *Chat) Close() {
|
|
c.srv.Close()
|
|
}
|
|
|
|
// Posts returns the messages received so far, in order.
|
|
func (c *Chat) Posts() []Post {
|
|
c.mu.Lock()
|
|
defer c.mu.Unlock()
|
|
return append([]Post(nil), c.posts...)
|
|
}
|