296 lines
9.4 KiB
Go
296 lines
9.4 KiB
Go
package cache
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"pulsecast/api/internal/model"
|
|
)
|
|
|
|
type stubFetcher struct {
|
|
mu sync.Mutex
|
|
calls int
|
|
payload model.Bootstrap
|
|
err error
|
|
fn func(int) (model.Bootstrap, error)
|
|
}
|
|
|
|
func (s *stubFetcher) Bootstrap(context.Context) (model.Bootstrap, error) {
|
|
s.mu.Lock()
|
|
s.calls++
|
|
call := s.calls
|
|
payload, err, fn := s.payload, s.err, s.fn
|
|
s.mu.Unlock()
|
|
if fn != nil {
|
|
return fn(call)
|
|
}
|
|
return payload, err
|
|
}
|
|
|
|
func (s *stubFetcher) set(payload model.Bootstrap, err error) {
|
|
s.mu.Lock()
|
|
s.payload, s.err = payload, err
|
|
s.mu.Unlock()
|
|
}
|
|
|
|
func (s *stubFetcher) callCount() int {
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
return s.calls
|
|
}
|
|
|
|
func fixturePayload() model.Bootstrap {
|
|
t0 := time.Date(2026, 11, 14, 3, 0, 0, 0, time.UTC)
|
|
return model.Bootstrap{
|
|
DataVersion: "2026-11-07T23:51:00Z",
|
|
ModelVersion: "histgb-2026-11-14",
|
|
ContextVersion: "2026-11-14T03:00:00Z",
|
|
Sensors: []model.Sensor{
|
|
{ID: "hn-zebra-01", Name: "Zebra", Lat: 49.1, Lon: 9.2, Mean: 1, P95: 2},
|
|
{ID: "hn-alpha-01", Name: "Alpha", Lat: 49.1, Lon: 9.2, Mean: 3, P95: 4},
|
|
},
|
|
Series: map[string][]model.Point{
|
|
"hn-alpha-01": {
|
|
{T: t0.Add(2 * time.Hour), V: 3},
|
|
{T: t0, V: 1},
|
|
{T: t0.Add(time.Hour), V: 2},
|
|
},
|
|
},
|
|
Context: model.ContextData{
|
|
Weather: model.Weather{
|
|
Now: model.WeatherNow{T: t0, TempC: 8.9, HumidityPct: 79},
|
|
Forecast: []model.WeatherPoint{{T: t0.Add(time.Hour), TempC: 8.4}},
|
|
},
|
|
Holidays: []model.Holiday{{Date: "2026-11-01", Name: "Allerheiligen"}},
|
|
UpdatedAt: t0,
|
|
},
|
|
Meta: model.BootstrapMeta{
|
|
Coverage: model.Coverage{Sensors: 8, From: "2026-06-12T00:00:00Z", To: "2026-11-07T23:51:00Z", CadenceMin: 15},
|
|
Metrics: model.Metrics{Model: "weather", MAE: 3.36, WAPE: 27.8, R2: 0.779},
|
|
Limits: []string{"estimated devices, not people"},
|
|
},
|
|
}
|
|
}
|
|
|
|
func TestRetryDelaySchedule(t *testing.T) {
|
|
c := New(&stubFetcher{}, Options{})
|
|
want := []time.Duration{1 * time.Second, 2 * time.Second, 4 * time.Second, 8 * time.Second, 16 * time.Second, 30 * time.Second, 30 * time.Second}
|
|
for i, expected := range want {
|
|
if got := c.retryDelay(i + 1); got != expected {
|
|
t.Errorf("retryDelay(%d)=%s, want %s", i+1, got, expected)
|
|
}
|
|
}
|
|
for _, failures := range []int{0, -1} {
|
|
if got := c.retryDelay(failures); got != time.Second {
|
|
t.Errorf("retryDelay(%d)=%s, want 1s", failures, got)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestRefreshLoadsSnapshotAndStatus(t *testing.T) {
|
|
fetcher := &stubFetcher{payload: fixturePayload()}
|
|
c := New(fetcher, Options{RefreshInterval: time.Minute, Timeout: time.Second})
|
|
fixed := time.Date(2026, 11, 14, 4, 0, 0, 0, time.UTC)
|
|
c.now = func() time.Time { return fixed }
|
|
|
|
if err := c.Refresh(context.Background()); err != nil {
|
|
t.Fatalf("Refresh: %v", err)
|
|
}
|
|
if !c.Loaded() || !c.Ready() || !c.Fresh() {
|
|
t.Fatalf("loaded=%v ready=%v fresh=%v", c.Loaded(), c.Ready(), c.Fresh())
|
|
}
|
|
data, modelOK := c.Readiness()
|
|
if !data || !modelOK {
|
|
t.Fatalf("readiness data=%v model=%v", data, modelOK)
|
|
}
|
|
if c.Len() != 2 {
|
|
t.Fatalf("Len=%d, want 2", c.Len())
|
|
}
|
|
|
|
sensors := c.Sensors()
|
|
if len(sensors) != 2 || sensors[0].ID != "hn-alpha-01" || sensors[1].ID != "hn-zebra-01" {
|
|
t.Fatalf("sensors not sorted: %+v", sensors)
|
|
}
|
|
if sensor, ok := c.Sensor("hn-zebra-01"); !ok || sensor.Name != "Zebra" {
|
|
t.Fatalf("Sensor: ok=%v sensor=%+v", ok, sensor)
|
|
}
|
|
if _, ok := c.Sensor("nope"); ok {
|
|
t.Fatal("unexpected sensor nope")
|
|
}
|
|
series, ok := c.Series("hn-alpha-01")
|
|
if !ok || len(series) != 3 || !series[0].T.Before(series[1].T) || !series[1].T.Before(series[2].T) {
|
|
t.Fatalf("series not sorted: ok=%v points=%+v", ok, series)
|
|
}
|
|
if ctx := c.Context(); ctx.UpdatedAt.IsZero() || len(ctx.Holidays) != 1 || len(ctx.Weather.Forecast) != 1 {
|
|
t.Fatalf("context=%+v", ctx)
|
|
}
|
|
dataVersion, modelVersion, contextVersion := c.Versions()
|
|
if dataVersion != "2026-11-07T23:51:00Z" || modelVersion != "histgb-2026-11-14" || contextVersion != "2026-11-14T03:00:00Z" {
|
|
t.Fatalf("versions=%q %q %q", dataVersion, modelVersion, contextVersion)
|
|
}
|
|
|
|
meta := c.Meta()
|
|
if meta.Coverage.Sensors != 8 || meta.Metrics.MAE != 3.36 || len(meta.Limits) != 1 {
|
|
t.Fatalf("meta=%+v", meta)
|
|
}
|
|
if meta.Cache.Source != Source || meta.Cache.LastSuccessAt == nil ||
|
|
!meta.Cache.LastSuccessAt.Equal(fixed) || meta.Cache.LastError != nil ||
|
|
meta.Cache.NextRetryAt != nil || meta.Cache.Failures != 0 {
|
|
t.Fatalf("cache status=%+v", meta.Cache)
|
|
}
|
|
}
|
|
|
|
func TestRefreshFailureKeepsLastGoodAndCountsBackoff(t *testing.T) {
|
|
fetcher := &stubFetcher{payload: fixturePayload()}
|
|
c := New(fetcher, Options{RefreshInterval: time.Minute, Timeout: time.Second})
|
|
fixed := time.Date(2026, 11, 14, 4, 0, 0, 0, time.UTC)
|
|
c.now = func() time.Time { return fixed }
|
|
|
|
if err := c.Refresh(context.Background()); err != nil {
|
|
t.Fatalf("prime: %v", err)
|
|
}
|
|
primed := c.Sensors()
|
|
|
|
fetcher.set(model.Bootstrap{}, errors.New("connection refused"))
|
|
if err := c.Refresh(context.Background()); err == nil {
|
|
t.Fatal("expected refresh failure")
|
|
}
|
|
if !c.Ready() || c.Fresh() {
|
|
t.Fatalf("ready=%v fresh=%v, want ready and not fresh", c.Ready(), c.Fresh())
|
|
}
|
|
if got := c.Sensors(); len(got) != len(primed) || got[0].ID != primed[0].ID {
|
|
t.Fatalf("last good snapshot lost: %+v", got)
|
|
}
|
|
status := c.Status()
|
|
if status.Failures != 1 || status.LastError == nil || *status.LastError != "connection refused" {
|
|
t.Fatalf("status=%+v", status)
|
|
}
|
|
if status.LastSuccessAt == nil || !status.LastSuccessAt.Equal(fixed) {
|
|
t.Fatalf("last success=%v", status.LastSuccessAt)
|
|
}
|
|
if status.NextRetryAt == nil || !status.NextRetryAt.Equal(fixed.Add(time.Second)) {
|
|
t.Fatalf("next retry=%v, want %s", status.NextRetryAt, fixed.Add(time.Second))
|
|
}
|
|
|
|
if err := c.Refresh(context.Background()); err == nil {
|
|
t.Fatal("expected second refresh failure")
|
|
}
|
|
status = c.Status()
|
|
if status.Failures != 2 || status.NextRetryAt == nil || !status.NextRetryAt.Equal(fixed.Add(2*time.Second)) {
|
|
t.Fatalf("second failure status=%+v", status)
|
|
}
|
|
|
|
fetcher.set(fixturePayload(), nil)
|
|
if err := c.Refresh(context.Background()); err != nil {
|
|
t.Fatalf("recovery: %v", err)
|
|
}
|
|
status = c.Status()
|
|
if status.Failures != 0 || status.LastError != nil || status.NextRetryAt != nil || !c.Fresh() {
|
|
t.Fatalf("recovered status=%+v fresh=%v", status, c.Fresh())
|
|
}
|
|
if status.LastSuccessAt == nil || !status.LastSuccessAt.Equal(fixed) {
|
|
t.Fatalf("last success after recovery=%v", status.LastSuccessAt)
|
|
}
|
|
}
|
|
|
|
func TestRefreshRejectsIncompleteSnapshot(t *testing.T) {
|
|
for name, mutate := range map[string]func(*model.Bootstrap){
|
|
"no sensors": func(b *model.Bootstrap) { b.Sensors = nil },
|
|
"no data version": func(b *model.Bootstrap) { b.DataVersion = "" },
|
|
"no model version": func(b *model.Bootstrap) { b.ModelVersion = "" },
|
|
"no context version": func(b *model.Bootstrap) { b.ContextVersion = "" },
|
|
"no context time": func(b *model.Bootstrap) { b.Context.UpdatedAt = time.Time{} },
|
|
} {
|
|
t.Run(name, func(t *testing.T) {
|
|
payload := fixturePayload()
|
|
mutate(&payload)
|
|
c := New(&stubFetcher{payload: payload}, Options{Timeout: time.Second})
|
|
fixed := time.Date(2026, 11, 14, 4, 0, 0, 0, time.UTC)
|
|
c.now = func() time.Time { return fixed }
|
|
if err := c.Refresh(context.Background()); err == nil {
|
|
t.Fatal("expected validation error")
|
|
}
|
|
if c.Loaded() || c.Ready() {
|
|
t.Fatalf("loaded=%v ready=%v after invalid snapshot", c.Loaded(), c.Ready())
|
|
}
|
|
if status := c.Status(); status.Failures != 1 || status.LastError == nil ||
|
|
status.NextRetryAt == nil || !status.NextRetryAt.Equal(fixed.Add(time.Second)) {
|
|
t.Fatalf("status=%+v", status)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestRunRetriesWithBackoffThenLoads(t *testing.T) {
|
|
fetcher := &stubFetcher{fn: func(call int) (model.Bootstrap, error) {
|
|
if call <= 2 {
|
|
return model.Bootstrap{}, errors.New("not ready")
|
|
}
|
|
return fixturePayload(), nil
|
|
}}
|
|
c := New(fetcher, Options{RefreshInterval: 10 * time.Millisecond, Timeout: time.Second})
|
|
c.retry = []time.Duration{5 * time.Millisecond, 10 * time.Millisecond, 20 * time.Millisecond}
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
defer cancel()
|
|
done := make(chan struct{})
|
|
go func() {
|
|
c.Run(ctx)
|
|
close(done)
|
|
}()
|
|
|
|
deadline := time.Now().Add(2 * time.Second)
|
|
for !c.Loaded() {
|
|
if time.Now().After(deadline) {
|
|
t.Fatalf("cache did not load after retries; calls=%d status=%+v", fetcher.callCount(), c.Status())
|
|
}
|
|
time.Sleep(5 * time.Millisecond)
|
|
}
|
|
if got := fetcher.callCount(); got < 3 {
|
|
t.Fatalf("calls=%d, want at least 3", got)
|
|
}
|
|
if status := c.Status(); status.Failures != 0 || status.LastError != nil {
|
|
t.Fatalf("status after recovery=%+v", status)
|
|
}
|
|
|
|
cancel()
|
|
select {
|
|
case <-done:
|
|
case <-time.After(time.Second):
|
|
t.Fatal("Run did not stop after context cancellation")
|
|
}
|
|
}
|
|
|
|
func TestRunStopsWhenContextCancelled(t *testing.T) {
|
|
fetcher := &stubFetcher{err: errors.New("down")}
|
|
c := New(fetcher, Options{RefreshInterval: time.Hour, Timeout: time.Second})
|
|
c.retry = []time.Duration{time.Hour}
|
|
|
|
ctx, cancel := context.WithCancel(context.Background())
|
|
done := make(chan struct{})
|
|
go func() {
|
|
c.Run(ctx)
|
|
close(done)
|
|
}()
|
|
|
|
deadline := time.Now().Add(time.Second)
|
|
for fetcher.callCount() == 0 {
|
|
if time.Now().After(deadline) {
|
|
t.Fatal("Run never attempted the first fetch")
|
|
}
|
|
time.Sleep(time.Millisecond)
|
|
}
|
|
cancel()
|
|
select {
|
|
case <-done:
|
|
case <-time.After(time.Second):
|
|
t.Fatal("Run did not stop after context cancellation")
|
|
}
|
|
if status := c.Status(); status.Failures != 1 || status.NextRetryAt == nil {
|
|
t.Fatalf("status=%+v", status)
|
|
}
|
|
}
|