kami
6316354518
The day total rolls over at midnight and the poller had nothing to write until the first spend of the new day, so at 09:00 the latest money_today fact was yesterday's spending and looked perfectly fresh. The value now carries the first instant of the window it covers, and a today question that the stored window does not cover is refused rather than answered with yesterday's number. Staleness was measured off the fact timestamp, which only moved when the figure moved, so a quiet month was reported as data from three days ago while being current. The value now carries when it was last read and the poller writes on every read. Amounts in an instrument the window diff never named were spoken with a numeric instrument id as the currency. Instruments are resolved from one cursor-zero diff, cached for the process, and an amount still unnamed is dropped from speech rather than recited wrongly. "сколько я потратил вчера" was answered with the month total, a real number to a different question, and is now refused by naming the two windows she keeps. Income questions led with the spending. Found in review of #62.
229 lines
8.4 KiB
Go
229 lines
8.4 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/kami/maven/internal/ipc"
|
|
"github.com/kami/maven/internal/router"
|
|
"github.com/kami/maven/internal/zenmoney"
|
|
)
|
|
|
|
// moneyAPI answers only LatestFactBySource; everything else is unimplemented,
|
|
// which is the assertion that answering a money question costs no model call
|
|
// and reaches no network.
|
|
type moneyAPI struct {
|
|
ipc.UnimplementedCoreAPI
|
|
|
|
fact ipc.Fact
|
|
err error
|
|
gotKey string
|
|
gotSrc string
|
|
callCnt int
|
|
}
|
|
|
|
func (a *moneyAPI) LatestFactBySource(_ context.Context, key, source string) (ipc.Fact, error) {
|
|
a.gotKey, a.gotSrc = key, source
|
|
a.callCnt++
|
|
return a.fact, a.err
|
|
}
|
|
|
|
func moneyNow() time.Time { return time.Date(2026, 8, 15, 20, 0, 0, 0, time.UTC) }
|
|
|
|
func moneyFact(ts time.Time, val string) ipc.Fact {
|
|
return ipc.Fact{Kind: "env", Key: zenmoney.KeySpentMonth, Value: val, Source: zenmoney.Source, Ts: ts}
|
|
}
|
|
|
|
func TestQueryMoneyAnswersFromTheFact(t *testing.T) {
|
|
api := &moneyAPI{fact: moneyFact(moneyNow(), `{"spent":[{"currency":"RUB","amount":1749.5}],"count":3}`)}
|
|
h := &reactiveHandler{api: api, now: moneyNow}
|
|
reply, ok := h.queryMoney(context.Background(), &queryTurn{
|
|
dec: router.Decision{Utterance: "сколько я потратил в этом месяце?"},
|
|
})
|
|
if !ok {
|
|
t.Fatal("the money source must claim a money question")
|
|
}
|
|
if api.gotKey != zenmoney.KeySpentMonth || api.gotSrc != zenmoney.Source {
|
|
t.Errorf("read %q/%q, want the month key from the poller's source", api.gotKey, api.gotSrc)
|
|
}
|
|
if !strings.Contains(reply, "1749.5") {
|
|
t.Errorf("reply = %q, want the exact figure", reply)
|
|
}
|
|
if !strings.Contains(reply, "в этом месяце") {
|
|
t.Errorf("reply = %q, want the window named", reply)
|
|
}
|
|
}
|
|
|
|
func TestQueryMoneyPicksTodaysKey(t *testing.T) {
|
|
api := &moneyAPI{fact: moneyFact(moneyNow(), `{"spent":[{"currency":"RUB","amount":250}],"count":1}`)}
|
|
h := &reactiveHandler{api: api, now: moneyNow}
|
|
if _, ok := h.queryMoney(context.Background(), &queryTurn{
|
|
dec: router.Decision{Utterance: "сколько я потратил сегодня?"},
|
|
}); !ok {
|
|
t.Fatal("expected the source to claim it")
|
|
}
|
|
if api.gotKey != zenmoney.KeySpentToday {
|
|
t.Errorf("key = %q, want today's", api.gotKey)
|
|
}
|
|
}
|
|
|
|
// The capability is off unless configured, and then there is no fact. She says
|
|
// so instead of letting the recall pass answer a money question from a note.
|
|
func TestQueryMoneySaysNotConnected(t *testing.T) {
|
|
h := &reactiveHandler{api: &moneyAPI{err: ipc.ErrNoFact}, now: moneyNow}
|
|
reply, ok := h.queryMoney(context.Background(), &queryTurn{
|
|
dec: router.Decision{Utterance: "сколько я потратил?"},
|
|
})
|
|
if !ok {
|
|
t.Fatal("expected the source to claim it")
|
|
}
|
|
if !strings.Contains(reply, "не подключено") {
|
|
t.Errorf("reply = %q, want an honest 'not connected'", reply)
|
|
}
|
|
// No number of any kind in that answer.
|
|
for _, d := range []string{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"} {
|
|
if strings.Contains(reply, d) {
|
|
t.Errorf("reply %q contains a digit — nothing was read, so there is no figure", reply)
|
|
}
|
|
}
|
|
}
|
|
|
|
// A fact older than the staleness bound is dated rather than spoken as if it
|
|
// were current: the poller can be down, and last week's total presented as
|
|
// today's is a lie by omission.
|
|
func TestQueryMoneyDatesAStaleFact(t *testing.T) {
|
|
old := moneyNow().Add(-72 * time.Hour)
|
|
api := &moneyAPI{fact: moneyFact(old, `{"spent":[{"currency":"RUB","amount":100}],"count":1}`)}
|
|
h := &reactiveHandler{api: api, now: moneyNow}
|
|
reply, _ := h.queryMoney(context.Background(), &queryTurn{
|
|
dec: router.Decision{Utterance: "сколько я потратил?"},
|
|
})
|
|
if !strings.Contains(reply, "данные от") {
|
|
t.Errorf("reply = %q, want the stale fact dated", reply)
|
|
}
|
|
}
|
|
|
|
func TestQueryMoneyPassesOtherQuestions(t *testing.T) {
|
|
api := &moneyAPI{}
|
|
h := &reactiveHandler{api: api, now: moneyNow}
|
|
for _, u := range []string{"какая погода?", "я потратил весь день на это", "какие у меня задачи?"} {
|
|
if _, ok := h.queryMoney(context.Background(), &queryTurn{dec: router.Decision{Utterance: u}}); ok {
|
|
t.Errorf("the money source claimed %q", u)
|
|
}
|
|
}
|
|
if api.callCnt != 0 {
|
|
t.Error("a non-money question must not read the money facts")
|
|
}
|
|
}
|
|
|
|
// Money must be answered before the recall sources, or a question about
|
|
// spending gets answered by the nearest note.
|
|
func TestQuerySourcesOrderMoneyBeforeRecall(t *testing.T) {
|
|
moneyAt, notesAt := -1, -1
|
|
for i, src := range querySources {
|
|
switch src.name {
|
|
case "money":
|
|
moneyAt = i
|
|
case "notes":
|
|
notesAt = i
|
|
}
|
|
}
|
|
if moneyAt < 0 || notesAt < 0 {
|
|
t.Fatalf("sources missing: money=%d notes=%d", moneyAt, notesAt)
|
|
}
|
|
if moneyAt > notesAt {
|
|
t.Errorf("money source at %d, after notes at %d", moneyAt, notesAt)
|
|
}
|
|
}
|
|
|
|
// The day window rolls over at midnight and the poller writes nothing until the
|
|
// first spend of the new day, so the last money_today fact is fresh by ts and
|
|
// covers yesterday. No staleness check can catch that.
|
|
func TestQueryMoneyRefusesYesterdaysDayTotal(t *testing.T) {
|
|
yesterday, _ := zenmoney.DayWindow(moneyNow().AddDate(0, 0, -1))
|
|
sum := zenmoney.Summary{From: yesterday, Spent: []zenmoney.Money{{Currency: "RUB", Amount: 1749.5}}, Count: 3}
|
|
val, ok := sum.Value(moneyNow().AddDate(0, 0, -1).Add(2 * time.Hour))
|
|
if !ok {
|
|
t.Fatal("want a fact value")
|
|
}
|
|
api := &moneyAPI{fact: ipc.Fact{
|
|
Kind: "env", Key: zenmoney.KeySpentToday, Value: val,
|
|
Source: zenmoney.Source, Ts: moneyNow().Add(-11 * time.Hour),
|
|
}}
|
|
h := &reactiveHandler{api: api, now: moneyNow}
|
|
reply, claimed := h.queryMoney(context.Background(), &queryTurn{
|
|
dec: router.Decision{Utterance: "сколько я потратил сегодня?"},
|
|
})
|
|
if !claimed {
|
|
t.Fatal("expected the source to claim it")
|
|
}
|
|
if strings.Contains(reply, "1749.5") {
|
|
t.Errorf("reply = %q — that is yesterday's spending spoken as today's", reply)
|
|
}
|
|
}
|
|
|
|
// Ts advances only when the number moves, so a quiet month used to be reported
|
|
// as stale while being current. The read stamp inside the value is what the
|
|
// staleness check means.
|
|
func TestQueryMoneyMeasuresStalenessFromTheRead(t *testing.T) {
|
|
from, _ := zenmoney.MonthWindow(moneyNow())
|
|
sum := zenmoney.Summary{From: from, Spent: []zenmoney.Money{{Currency: "RUB", Amount: 100}}, Count: 1}
|
|
val, _ := sum.Value(moneyNow().Add(-time.Hour))
|
|
// The fact itself last CHANGED three days ago: nothing was spent since.
|
|
api := &moneyAPI{fact: ipc.Fact{
|
|
Kind: "env", Key: zenmoney.KeySpentMonth, Value: val,
|
|
Source: zenmoney.Source, Ts: moneyNow().Add(-72 * time.Hour),
|
|
}}
|
|
h := &reactiveHandler{api: api, now: moneyNow}
|
|
reply, _ := h.queryMoney(context.Background(), &queryTurn{
|
|
dec: router.Decision{Utterance: "сколько я потратил в этом месяце?"},
|
|
})
|
|
if strings.Contains(reply, "данные от") {
|
|
t.Errorf("reply = %q — the figure was read an hour ago and is current", reply)
|
|
}
|
|
}
|
|
|
|
// Two windows are stored and no others. Answering "вчера" with the
|
|
// month-to-date total answers a different question with a real number.
|
|
func TestQueryMoneyRefusesWindowsItDoesNotKeep(t *testing.T) {
|
|
api := &moneyAPI{}
|
|
h := &reactiveHandler{api: api, now: moneyNow}
|
|
reply, ok := h.queryMoney(context.Background(), &queryTurn{
|
|
dec: router.Decision{Utterance: "сколько я потратил вчера?"},
|
|
})
|
|
if !ok {
|
|
t.Fatal("a money question must be claimed, not passed to recall")
|
|
}
|
|
if !strings.Contains(reply, "только") {
|
|
t.Errorf("reply = %q, want her to say which windows she keeps", reply)
|
|
}
|
|
if api.callCnt != 0 {
|
|
t.Error("a window she does not keep must not read a fact")
|
|
}
|
|
}
|
|
|
|
// "сколько я заработал" reads the same fact and must lead with the income.
|
|
func TestQueryMoneyLeadsWithIncomeWhenAsked(t *testing.T) {
|
|
from, _ := zenmoney.MonthWindow(moneyNow())
|
|
sum := zenmoney.Summary{
|
|
From: from,
|
|
Spent: []zenmoney.Money{{Currency: "RUB", Amount: 100}},
|
|
Earned: []zenmoney.Money{{Currency: "RUB", Amount: 3000}},
|
|
Count: 2,
|
|
}
|
|
val, _ := sum.Value(moneyNow())
|
|
api := &moneyAPI{fact: ipc.Fact{
|
|
Kind: "env", Key: zenmoney.KeySpentMonth, Value: val,
|
|
Source: zenmoney.Source, Ts: moneyNow(),
|
|
}}
|
|
h := &reactiveHandler{api: api, now: moneyNow}
|
|
reply, _ := h.queryMoney(context.Background(), &queryTurn{
|
|
dec: router.Decision{Utterance: "сколько я заработал в этом месяце?"},
|
|
})
|
|
if strings.Index(reply, "3000") > strings.Index(reply, "100") {
|
|
t.Errorf("reply = %q, want the income he asked about first", reply)
|
|
}
|
|
}
|