Artifact [3b1310cafb]

Artifact 3b1310cafb4387ed642658aeb8579b54d31c9a04121c6ba24ae7bd4b95767ecd:

• File internal/events/log_test.go — part of check-in [a5c5fe771e] at 2026-08-24 21:20:37 on branch praise-ui — Event log: proof the hooks fired

  Read straight off the vocabulary stream — no table, no fold, nothing to keep in sync, so it cannot disagree with what the forge published.

  The window is the stream's window, 24 hours, and the page says so: a log that let a reader assume history would be lying about a live tail.

  Asks the consumer how much is pending before fetching. Without that a quiet repository waits out the fetch timeout, which would make 'nothing has happened yet' the slowest page on the site — 2s became 9ms.

  Linked from the webhooks settings, not given a tab: that is where the question gets asked. (user: dmestas, size: 2050) [annotate] [blame] [check-ins using] [more...]

package events

import (
	"testing"

	"craftdesign.group/quarry/internal/evt"
)

func TestRecentIsNewestFirstAndPerRepo(t *testing.T) {
	s := testServer(t)
	for _, k := range []evt.Kind{evt.TicketOpened, evt.WikiEdited, evt.LandingOpened} {
		if err := s.Raise(k, "alpha", map[string]any{"actor": "dan", "summary": string(k)}); err != nil {
			t.Fatal(err)
		}
	}
	if err := s.Raise(evt.TicketClosed, "beta", map[string]any{"actor": "eve"}); err != nil {
		t.Fatal(err)
	}
	got, err := s.Recent("alpha", 10)
	if err != nil {
		t.Fatal(err)
	}
	if len(got) != 3 {
		t.Fatalf("got %d events for alpha, want 3 (%v)", len(got), got)
	}
	// Newest first.
	want := []evt.Kind{evt.LandingOpened, evt.WikiEdited, evt.TicketOpened}
	for i := range want {
		if got[i].Kind != want[i] {
			t.Fatalf("order = %v, want newest first %v", kindsOf(got), want)
		}
	}
	if got[0].Actor != "dan" || got[0].Repo != "alpha" {
		t.Errorf("actor/repo = %q/%q", got[0].Actor, got[0].Repo)
	}
	if got[0].At.IsZero() {
		t.Error("no timestamp; the log's whole job is when")
	}
	// Another repository's events must not appear in this one's log.
	for _, e := range got {
		if e.Repo != "alpha" {
			t.Errorf("beta's event leaked into alpha's log: %+v", e)
		}
	}
}

func TestRecentHonoursItsLimit(t *testing.T) {
	s := testServer(t)
	for i := 0; i < 8; i++ {
		if err := s.Raise(evt.CheckinCreated, "alpha", map[string]any{"summary": "c"}); err != nil {
			t.Fatal(err)
		}
	}
	got, err := s.Recent("alpha", 3)
	if err != nil {
		t.Fatal(err)
	}
	if len(got) != 3 {
		t.Fatalf("limit 3 returned %d", len(got))
	}
}

// A repository nothing has happened to has an empty log, not an error:
// "nothing yet" is an answer.
func TestRecentOnAQuietRepo(t *testing.T) {
	s := testServer(t)
	got, err := s.Recent("silent", 10)
	if err != nil {
		t.Fatalf("quiet repo errored: %v", err)
	}
	if len(got) != 0 {
		t.Errorf("got %v", got)
	}
}

func kindsOf(es []Logged) []evt.Kind {
	out := make([]evt.Kind, 0, len(es))
	for _, e := range es {
		out = append(out, e.Kind)
	}
	return out
}