Add local-first refactor foundation

2026-08-07 19:56:18 -04:00 · 2026-05-25 00:45:46 -04:00
parent 161e871c53
commit 517c6b987b
45 changed files with 11545 additions and 697 deletions
--- a/internal/ingest/ingest_test.go
+++ b/internal/ingest/ingest_test.go
@@ -0,0 +1,381 @@
+package ingest
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"path/filepath"
+	"testing"
+	"time"
+
+	"github.com/AmanTahiliani/box-box/internal/api"
+	"github.com/AmanTahiliani/box-box/internal/models"
+	"github.com/AmanTahiliani/box-box/internal/store"
+)
+
+type fakeSource struct {
+	meetingsByYear    map[int][]models.Meeting
+	meetingsByKey     map[int][]models.Meeting
+	sessionsByMeeting map[int][]models.Session
+	sessionsByKey     map[int][]models.Session
+	drivers           map[int][]models.Driver
+	results           map[int][]models.SessionResult
+	grid              map[int][]models.StartingGrid
+	failOn            string
+	liveLockout       bool
+}
+
+func newFakeSource() *fakeSource {
+	return &fakeSource{
+		meetingsByYear:    make(map[int][]models.Meeting),
+		meetingsByKey:     make(map[int][]models.Meeting),
+		sessionsByMeeting: make(map[int][]models.Session),
+		sessionsByKey:     make(map[int][]models.Session),
+		drivers:           make(map[int][]models.Driver),
+		results:           make(map[int][]models.SessionResult),
+		grid:              make(map[int][]models.StartingGrid),
+	}
+}
+
+func (f *fakeSource) maybeFail(endpoint string) error {
+	if f.liveLockout {
+		return fmt.Errorf("%w", api.ErrLiveSessionLocked)
+	}
+	if f.failOn == endpoint {
+		return errors.New("simulated fetch failure")
+	}
+	return nil
+}
+
+func (f *fakeSource) wrap(endpoint, requestKey string, payload any) FetchResult {
+	body, _ := json.Marshal(payload)
+	return FetchResult{
+		Endpoint:   endpoint,
+		RequestKey: requestKey,
+		URL:        "fake://" + endpoint + "?" + requestKey,
+		Body:       body,
+		FetchedAt:  time.Now(),
+	}
+}
+
+func (f *fakeSource) FetchMeetingsForYear(year int) (FetchResult, []models.Meeting, error) {
+	if err := f.maybeFail("meetings"); err != nil {
+		return FetchResult{}, nil, err
+	}
+	data := f.meetingsByYear[year]
+	return f.wrap("meetings", fmt.Sprintf("year=%d", year), data), data, nil
+}
+
+func (f *fakeSource) FetchMeetingsForMeetingKey(meetingKey int) (FetchResult, []models.Meeting, error) {
+	if err := f.maybeFail("meetings"); err != nil {
+		return FetchResult{}, nil, err
+	}
+	data := f.meetingsByKey[meetingKey]
+	return f.wrap("meetings", fmt.Sprintf("meeting_key=%d", meetingKey), data), data, nil
+}
+
+func (f *fakeSource) FetchSessionsForMeeting(meetingKey int) (FetchResult, []models.Session, error) {
+	if err := f.maybeFail("sessions"); err != nil {
+		return FetchResult{}, nil, err
+	}
+	data := f.sessionsByMeeting[meetingKey]
+	return f.wrap("sessions", fmt.Sprintf("meeting_key=%d", meetingKey), data), data, nil
+}
+
+func (f *fakeSource) FetchSessionsForSessionKey(sessionKey int) (FetchResult, []models.Session, error) {
+	if err := f.maybeFail("sessions"); err != nil {
+		return FetchResult{}, nil, err
+	}
+	data := f.sessionsByKey[sessionKey]
+	return f.wrap("sessions", fmt.Sprintf("session_key=%d", sessionKey), data), data, nil
+}
+
+func (f *fakeSource) FetchDriversForSession(sessionKey int) (FetchResult, []models.Driver, error) {
+	if err := f.maybeFail("drivers"); err != nil {
+		return FetchResult{}, nil, err
+	}
+	data := f.drivers[sessionKey]
+	return f.wrap("drivers", fmt.Sprintf("session_key=%d", sessionKey), data), data, nil
+}
+
+func (f *fakeSource) FetchSessionResult(sessionKey int) (FetchResult, []models.SessionResult, error) {
+	if err := f.maybeFail("session_result"); err != nil {
+		return FetchResult{}, nil, err
+	}
+	data := f.results[sessionKey]
+	return f.wrap("session_result", fmt.Sprintf("session_key=%d", sessionKey), data), data, nil
+}
+
+func (f *fakeSource) FetchStartingGrid(sessionKey int) (FetchResult, []models.StartingGrid, error) {
+	if err := f.maybeFail("starting_grid"); err != nil {
+		return FetchResult{}, nil, err
+	}
+	data := f.grid[sessionKey]
+	return f.wrap("starting_grid", fmt.Sprintf("session_key=%d", sessionKey), data), data, nil
+}
+
+func openTestStore(t *testing.T) *store.Store {
+	t.Helper()
+	path := filepath.Join(t.TempDir(), "ingest.db")
+	s, err := store.Open(path)
+	if err != nil {
+		t.Fatalf("store.Open() error = %v", err)
+	}
+	t.Cleanup(func() { _ = s.Close() })
+	return s
+}
+
+func testSessionFixtures() (int, int, *fakeSource) {
+	const meetingKey = 1229
+	const sessionKey = 9472
+
+	src := newFakeSource()
+	src.meetingsByKey[meetingKey] = []models.Meeting{{
+		MeetingKey:          meetingKey,
+		MeetingName:         "Monaco",
+		MeetingOfficialName: "FORMULA 1 GRAND PRIX DE MONACO 2025",
+		Location:            "Monaco",
+		CountryCode:         "MON",
+		CountryName:         "Monaco",
+		Circuit: models.Circuit{
+			CircuitKey:       10,
+			CircuitShortName: "Monte Carlo",
+		},
+		Year: 2025,
+	}}
+	src.sessionsByKey[sessionKey] = []models.Session{{
+		SessionKey:  sessionKey,
+		MeetingKey:  meetingKey,
+		SessionName: "Race",
+		SessionType: "Race",
+		CircuitKey:  10,
+	}}
+	src.drivers[sessionKey] = []models.Driver{
+		{
+			DriverNumber: 1,
+			FullName:     "Max Verstappen",
+			SessionKey:   sessionKey,
+			MeetingKey:   meetingKey,
+			TeamName:     "Red Bull Racing",
+			TeamColour:   "3671C6",
+		},
+		{
+			DriverNumber: 44,
+			FullName:     "Lewis Hamilton",
+			SessionKey:   sessionKey,
+			MeetingKey:   meetingKey,
+			TeamName:     "Ferrari",
+			TeamColour:   "E8002D",
+		},
+	}
+	src.results[sessionKey] = []models.SessionResult{
+		{SessionKey: sessionKey, MeetingKey: meetingKey, DriverNumber: 1, Position: 1, Points: 25, NumberOfLaps: 78},
+		{SessionKey: sessionKey, MeetingKey: meetingKey, DriverNumber: 44, Position: 2, Points: 18, NumberOfLaps: 78, GapToLeader: 1.5},
+	}
+	src.grid[sessionKey] = []models.StartingGrid{
+		{SessionKey: sessionKey, MeetingKey: meetingKey, DriverNumber: 1, Position: 1, LapDuration: 71.234},
+		{SessionKey: sessionKey, MeetingKey: meetingKey, DriverNumber: 44, Position: 2, LapDuration: 71.456},
+	}
+
+	return meetingKey, sessionKey, src
+}
+
+func TestIngestSessionWritesDomainAndRawRows(t *testing.T) {
+	_, sessionKey, src := testSessionFixtures()
+	st := openTestStore(t)
+
+	opts := DefaultOptions()
+	opts.RequestDelay = 0
+	svc := NewService(st, src, opts)
+
+	summary, err := svc.IngestSession(sessionKey)
+	if err != nil {
+		t.Fatalf("IngestSession() error = %v", err)
+	}
+	if summary.Status != "completed" {
+		t.Fatalf("summary.Status = %q, want completed", summary.Status)
+	}
+	if summary.Drivers != 2 || summary.SessionResults != 2 || summary.StartingGrid != 2 {
+		t.Fatalf("summary counts = %+v, want 2 drivers/results/grid", summary)
+	}
+	if summary.RawPayloads != 5 {
+		t.Fatalf("summary.RawPayloads = %d, want 5", summary.RawPayloads)
+	}
+
+	drivers, err := st.ListSessionDrivers(sessionKey)
+	if err != nil {
+		t.Fatalf("ListSessionDrivers() error = %v", err)
+	}
+	if len(drivers) != 2 {
+		t.Fatalf("session drivers = %d, want 2", len(drivers))
+	}
+
+	results, err := st.ListSessionResults(sessionKey)
+	if err != nil {
+		t.Fatalf("ListSessionResults() error = %v", err)
+	}
+	if len(results) != 2 {
+		t.Fatalf("session results = %d, want 2", len(results))
+	}
+
+	grid, err := st.ListStartingGrid(sessionKey)
+	if err != nil {
+		t.Fatalf("ListStartingGrid() error = %v", err)
+	}
+	if len(grid) != 2 {
+		t.Fatalf("starting grid = %d, want 2", len(grid))
+	}
+
+	raw, err := st.ListRawPayloadsBySession(sessionKey)
+	if err != nil {
+		t.Fatalf("ListRawPayloadsBySession() error = %v", err)
+	}
+	if len(raw) != 5 {
+		t.Fatalf("raw payloads = %d, want 5", len(raw))
+	}
+}
+
+func TestIngestSessionIsIdempotent(t *testing.T) {
+	_, sessionKey, src := testSessionFixtures()
+	st := openTestStore(t)
+
+	opts := DefaultOptions()
+	opts.RequestDelay = 0
+	svc := NewService(st, src, opts)
+
+	if _, err := svc.IngestSession(sessionKey); err != nil {
+		t.Fatalf("first IngestSession() error = %v", err)
+	}
+	if _, err := svc.IngestSession(sessionKey); err != nil {
+		t.Fatalf("second IngestSession() error = %v", err)
+	}
+
+	count := func(query string) int {
+		var n int
+		if err := st.DB().QueryRow(query, sessionKey).Scan(&n); err != nil {
+			t.Fatalf("count query failed: %v", err)
+		}
+		return n
+	}
+
+	if got := count(`SELECT COUNT(*) FROM session_drivers WHERE session_key = ?`); got != 2 {
+		t.Fatalf("session_drivers count = %d, want 2", got)
+	}
+	if got := count(`SELECT COUNT(*) FROM session_results WHERE session_key = ?`); got != 2 {
+		t.Fatalf("session_results count = %d, want 2", got)
+	}
+	if got := count(`SELECT COUNT(*) FROM starting_grid WHERE session_key = ?`); got != 2 {
+		t.Fatalf("starting_grid count = %d, want 2", got)
+	}
+}
+
+func TestDryRunDoesNotWriteDomainRows(t *testing.T) {
+	_, sessionKey, src := testSessionFixtures()
+	st := openTestStore(t)
+
+	opts := DefaultOptions()
+	opts.DryRun = true
+	opts.RequestDelay = 0
+	svc := NewService(st, src, opts)
+
+	summary, err := svc.IngestSession(sessionKey)
+	if err != nil {
+		t.Fatalf("IngestSession() error = %v", err)
+	}
+	if summary.Status != "dry_run" {
+		t.Fatalf("summary.Status = %q, want dry_run", summary.Status)
+	}
+
+	var driverCount int
+	if err := st.DB().QueryRow(`SELECT COUNT(*) FROM drivers`).Scan(&driverCount); err != nil {
+		t.Fatalf("count drivers: %v", err)
+	}
+	if driverCount != 0 {
+		t.Fatalf("drivers written during dry-run = %d, want 0", driverCount)
+	}
+
+	var rawCount int
+	if err := st.DB().QueryRow(`SELECT COUNT(*) FROM raw_payloads`).Scan(&rawCount); err != nil {
+		t.Fatalf("count raw payloads: %v", err)
+	}
+	if rawCount != 0 {
+		t.Fatalf("raw payloads written during dry-run = %d, want 0", rawCount)
+	}
+}
+
+func TestSourceErrorStopsRun(t *testing.T) {
+	_, sessionKey, src := testSessionFixtures()
+	src.failOn = "session_result"
+	st := openTestStore(t)
+
+	opts := DefaultOptions()
+	opts.RequestDelay = 0
+	svc := NewService(st, src, opts)
+
+	summary, err := svc.IngestSession(sessionKey)
+	if err == nil {
+		t.Fatal("IngestSession() expected error, got nil")
+	}
+	if summary.Status != "failed" {
+		t.Fatalf("summary.Status = %q, want failed", summary.Status)
+	}
+
+	var resultCount int
+	if err := st.DB().QueryRow(`SELECT COUNT(*) FROM session_results WHERE session_key = ?`, sessionKey).Scan(&resultCount); err != nil {
+		t.Fatalf("count session_results: %v", err)
+	}
+	if resultCount != 0 {
+		t.Fatalf("session_results after failure = %d, want 0", resultCount)
+	}
+}
+
+func TestLiveSessionLockoutSurfacesControlledFailure(t *testing.T) {
+	_, sessionKey, src := testSessionFixtures()
+	src.liveLockout = true
+	st := openTestStore(t)
+
+	opts := DefaultOptions()
+	opts.RequestDelay = 0
+	svc := NewService(st, src, opts)
+
+	_, err := svc.IngestSession(sessionKey)
+	if err == nil {
+		t.Fatal("IngestSession() expected live lockout error, got nil")
+	}
+	if !api.IsLiveSessionError(err) {
+		t.Fatalf("error = %v, want live session lockout", err)
+	}
+}
+
+func TestIngestYearAndMeeting(t *testing.T) {
+	src := newFakeSource()
+	src.meetingsByYear[2025] = []models.Meeting{
+		{MeetingKey: 100, MeetingName: "Bahrain", Year: 2025},
+		{MeetingKey: 101, MeetingName: "Saudi Arabia", Year: 2025},
+	}
+	src.meetingsByKey[100] = src.meetingsByYear[2025][:1]
+	src.sessionsByMeeting[100] = []models.Session{
+		{SessionKey: 9001, MeetingKey: 100, SessionName: "Race", SessionType: "Race"},
+	}
+
+	st := openTestStore(t)
+	opts := DefaultOptions()
+	opts.RequestDelay = 0
+	svc := NewService(st, src, opts)
+
+	yearSummary, err := svc.IngestYear(2025)
+	if err != nil {
+		t.Fatalf("IngestYear() error = %v", err)
+	}
+	if yearSummary.Meetings != 2 {
+		t.Fatalf("year meetings = %d, want 2", yearSummary.Meetings)
+	}
+
+	meetingSummary, err := svc.IngestMeeting(100)
+	if err != nil {
+		t.Fatalf("IngestMeeting() error = %v", err)
+	}
+	if meetingSummary.Sessions != 1 {
+		t.Fatalf("meeting sessions = %d, want 1", meetingSummary.Sessions)
+	}
+}