116 lines
3.6 KiB
Go
116 lines
3.6 KiB
Go
package memory
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
"time"
|
|
|
|
"keel/internal/aw"
|
|
)
|
|
|
|
func TestFakeRecordThenRecentNewestFirstByKind(t *testing.T) {
|
|
f := NewFake()
|
|
ctx := context.Background()
|
|
_ = f.Record(ctx, Event{Kind: "proposal_made", At: time.Unix(1, 0), Data: map[string]any{"n": "a"}})
|
|
_ = f.Record(ctx, Event{Kind: "action_taken", At: time.Unix(2, 0)})
|
|
_ = f.Record(ctx, Event{Kind: "proposal_made", At: time.Unix(3, 0), Data: map[string]any{"n": "b"}})
|
|
|
|
got, err := f.Recent(ctx, "proposal_made", 5)
|
|
if err != nil {
|
|
t.Fatalf("Recent: %v", err)
|
|
}
|
|
if len(got) != 2 || got[0].Data["n"] != "b" {
|
|
t.Fatalf("want newest-first [b,a], got %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestFakeRecentRespectsLimit(t *testing.T) {
|
|
f := NewFake()
|
|
ctx := context.Background()
|
|
for i := 0; i < 4; i++ {
|
|
_ = f.Record(ctx, Event{Kind: "proposal_made", At: time.Unix(int64(i), 0)})
|
|
}
|
|
got, _ := f.Recent(ctx, "proposal_made", 2)
|
|
if len(got) != 2 {
|
|
t.Fatalf("limit not honored: %d", len(got))
|
|
}
|
|
}
|
|
|
|
func TestNopStoreIsInert(t *testing.T) {
|
|
s := NewNop()
|
|
if err := s.Record(context.Background(), Event{Kind: "x"}); err != nil {
|
|
t.Fatalf("nop Record: %v", err)
|
|
}
|
|
got, err := s.Recent(context.Background(), "x", 5)
|
|
if err != nil || len(got) != 0 {
|
|
t.Fatalf("nop Recent = %+v, %v", got, err)
|
|
}
|
|
}
|
|
|
|
// fakeAWClient is the AWClient subset, recording inserts and replaying a fixed
|
|
// recent list so we can test mapping and over-fetch filtering without HTTP.
|
|
type fakeAWClient struct {
|
|
inserted []aw.Event
|
|
recent []aw.Event // newest-first, mixed kinds
|
|
lastLimit int
|
|
}
|
|
|
|
func (f *fakeAWClient) Insert(_ context.Context, _ string, e aw.Event) error {
|
|
f.inserted = append(f.inserted, e)
|
|
return nil
|
|
}
|
|
func (f *fakeAWClient) Recent(_ context.Context, _ string, limit int) ([]aw.Event, error) {
|
|
f.lastLimit = limit
|
|
return f.recent, nil
|
|
}
|
|
|
|
func TestAWStoreRecordMapsKindIntoData(t *testing.T) {
|
|
fc := &fakeAWClient{}
|
|
s := NewAWStore(fc, "keel.events")
|
|
at := time.Unix(1000, 0).UTC()
|
|
if err := s.Record(context.Background(), Event{Kind: "proposal_made", At: at, Data: map[string]any{"proposal_id": "x"}}); err != nil {
|
|
t.Fatalf("Record: %v", err)
|
|
}
|
|
if len(fc.inserted) != 1 {
|
|
t.Fatalf("inserted %d", len(fc.inserted))
|
|
}
|
|
got := fc.inserted[0]
|
|
if !got.Timestamp.Equal(at) || got.Data["_kind"] != "proposal_made" || got.Data["proposal_id"] != "x" {
|
|
t.Fatalf("mapped event = %+v", got)
|
|
}
|
|
}
|
|
|
|
func TestAWStoreRecentOverfetchesAndFiltersByKind(t *testing.T) {
|
|
fc := &fakeAWClient{recent: []aw.Event{
|
|
{Timestamp: time.Unix(3, 0), Data: map[string]any{"_kind": "proposal_made", "n": "b"}},
|
|
{Timestamp: time.Unix(2, 0), Data: map[string]any{"_kind": "action_taken"}},
|
|
{Timestamp: time.Unix(1, 0), Data: map[string]any{"_kind": "proposal_made", "n": "a"}},
|
|
}}
|
|
s := NewAWStore(fc, "keel.events")
|
|
got, err := s.Recent(context.Background(), "proposal_made", 5)
|
|
if err != nil {
|
|
t.Fatalf("Recent: %v", err)
|
|
}
|
|
if fc.lastLimit != overfetch {
|
|
t.Fatalf("over-fetch limit = %d, want %d", fc.lastLimit, overfetch)
|
|
}
|
|
if len(got) != 2 || got[0].Kind != "proposal_made" || got[0].Data["n"] != "b" {
|
|
t.Fatalf("filtered = %+v", got)
|
|
}
|
|
if _, leaked := got[0].Data["_kind"]; leaked {
|
|
t.Fatalf("_kind leaked into returned Data: %+v", got[0].Data)
|
|
}
|
|
}
|
|
|
|
func TestAWStoreRecentCapsAtN(t *testing.T) {
|
|
var recent []aw.Event
|
|
for i := 0; i < 5; i++ {
|
|
recent = append(recent, aw.Event{Timestamp: time.Unix(int64(i), 0), Data: map[string]any{"_kind": "proposal_made"}})
|
|
}
|
|
s := NewAWStore(&fakeAWClient{recent: recent}, "keel.events")
|
|
got, _ := s.Recent(context.Background(), "proposal_made", 2)
|
|
if len(got) != 2 {
|
|
t.Fatalf("cap not applied: %d", len(got))
|
|
}
|
|
}
|