Skip to content

armgit / lyftr

Public Imported from GitHub
0

Self-hosted fitness tracker. Log workouts, track nutrition, and monitor progress. Docker deployment, mobile-friendly.

15.8 KB
Raw Blame
package stores

import (
	"context"
	"database/sql"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/http/httptest"
	"slices"
	"strings"
	"sync/atomic"
	"testing"

	"github.com/Cawlumm/lyftr-backend/oedb"
)

func markRemoved(t *testing.T, conn *sql.DB, oedbIDs ...string) {
	t.Helper()
	for _, id := range oedbIDs {
		if _, err := conn.Exec(`UPDATE exercises SET upstream_missing_at = CURRENT_TIMESTAMP WHERE oedb_id = ?`, id); err != nil {
			t.Fatal(err)
		}
	}
}

func marked(t *testing.T, conn *sql.DB) int {
	t.Helper()
	return countRows(t, conn, `SELECT COUNT(*) FROM exercises WHERE upstream_missing_at IS NOT NULL`)
}

func isMarked(t *testing.T, conn *sql.DB, oedbID string) bool {
	t.Helper()
	return countRows(t, conn, `SELECT COUNT(*) FROM exercises WHERE oedb_id = ? AND upstream_missing_at IS NOT NULL`, oedbID) == 1
}

func (c *localeCatalog) setUpstream(n int) {
	c.mu.Lock()
	defer c.mu.Unlock()
	c.upstream = n
}

func listedNames(t *testing.T, s *ExerciseStore, f ExerciseFilter) []string {
	t.Helper()
	got, err := s.List(f)
	if err != nil {
		t.Fatal(err)
	}
	var names []string
	for _, e := range got {
		names = append(names, e.Name)
	}
	return names
}

func TestList_HidesRowsRemovedUpstream(t *testing.T) {
	conn := testDB(t)
	s := NewExerciseStore(conn)
	materialize(t, s, "en", catalogExercise("uuid-a", "Alpha Press"), catalogExercise("uuid-b", "Bravo Press"), catalogExercise("uuid-c", "Charlie Press"))
	if _, err := conn.Exec(`INSERT INTO exercises (name, muscle_group) VALUES ('Legacy Press', 'chest')`); err != nil {
		t.Fatal(err)
	}
	materialize(t, s, "es", served("uuid-b", "Prensa Bravo", "es", []string{"Uno."}, "es"))
	markRemoved(t, conn, "uuid-b")
	id := localID(t, s, "uuid-b")

	names := listedNames(t, s, ExerciseFilter{Limit: 100})
	if len(names) != 3 {
		t.Errorf("List = %v, want the three that remain", names)
	}
	for _, n := range names {
		if n == "Bravo Press" {
			t.Errorf("List returned the removed exercise: %v", names)
		}
	}
	if got := listedNames(t, s, ExerciseFilter{Limit: 100, Query: "Bravo"}); len(got) != 0 {
		t.Errorf("List(q=Bravo) = %v, want none", got)
	}
	if got := listedNames(t, s, ExerciseFilter{Limit: 100, Query: "Prensa", Locale: "es"}); len(got) != 0 {
		t.Errorf("List(q=Prensa, es) matched through the translation: %v", got)
	}
	if got := mustGet(t, s, id, "en").Name; got != "Bravo Press" {
		t.Errorf("Get = %q, want the removed exercise still resolvable by id", got)
	}

	got, err := s.Search(context.Background(), ExerciseFilter{Limit: 100})
	if err != nil || len(got) != 3 {
		t.Errorf("Search without a catalog = %d rows, %v, want 3", len(got), err)
	}

	cat := newLocaleCatalog(t, 3, "en")
	cat.setFail("/api/v1/exercises", "")
	cat.setFail("/api/v1/exercises/export", "")
	s.UseCatalog(oedb.New(cat.srv.URL, "test"))
	got, err = s.Search(context.Background(), ExerciseFilter{Limit: 100})
	if err != nil || len(got) != 3 {
		t.Errorf("Search on the offline fallback = %d rows, %v, want 3", len(got), err)
	}
	for _, e := range got {
		if e.Name == "Bravo Press" {
			t.Error("the offline fallback returned the removed exercise")
		}
	}
}

func TestMaterialize_RecordingARemovedExerciseUnhidesIt(t *testing.T) {
	s := NewExerciseStore(testDB(t))
	materialize(t, s, "en", catalogExercise("uuid-001", "Row"))
	markRemoved(t, s.db, "uuid-001")
	materialize(t, s, "en", catalogExercise("uuid-001", "Row"))
	if isMarked(t, s.db, "uuid-001") {
		t.Error("an English re-record must clear the mark")
	}
	markRemoved(t, s.db, "uuid-001")
	materialize(t, s, "es", served("uuid-001", "Remo", "es", []string{"Uno."}, "es"))
	if isMarked(t, s.db, "uuid-001") {
		t.Error("a Spanish re-record must clear the mark")
	}
}

func TestMaterialize_NewUpstreamIDAdoptsARemovedRowOfTheSameName(t *testing.T) {
	s := NewExerciseStore(testDB(t))
	materialize(t, s, "en", catalogExercise("uuid-a", "Bench Press"))
	id := localID(t, s, "uuid-a")

	materialize(t, s, "en", catalogExercise("uuid-b", "Bench Press"))
	if got := countRows(t, s.db, `SELECT COUNT(*) FROM exercises WHERE oedb_id = 'uuid-b'`); got != 0 {
		t.Fatalf("a live row must not be taken over, uuid-b rows = %d", got)
	}

	markRemoved(t, s.db, "uuid-a")
	materialize(t, s, "en", catalogExercise("uuid-b", "Bench Press"))
	if got := localID(t, s, "uuid-b"); got != id {
		t.Errorf("uuid-b local id = %d, want the removed row %d", got, id)
	}
	if marked(t, s.db) != 0 || countRows(t, s.db, `SELECT COUNT(*) FROM exercises`) != 1 {
		t.Error("want one visible row")
	}
}

func TestSyncCatalog_HidesExercisesRemovedUpstream(t *testing.T) {
	s, cat := syncStore(t, 10, "en")
	if _, err := s.db.Exec(`INSERT INTO exercises (name) VALUES ('Legacy Row')`); err != nil {
		t.Fatal(err)
	}
	uid := seedUser(t, s.db)
	res, err := s.db.Exec(`INSERT INTO workouts (user_id, name) VALUES (?, 'W')`, uid)
	if err != nil {
		t.Fatal(err)
	}
	wid, _ := res.LastInsertId()
	gone := localID(t, s, "uuid-009")
	if _, err := s.db.Exec(`INSERT INTO workout_exercises (workout_id, exercise_id, order_index) VALUES (?, ?, 0)`, wid, gone); err != nil {
		t.Fatal(err)
	}
	total := countRows(t, s.db, `SELECT COUNT(*) FROM exercises`)

	cat.setUpstream(8)
	if _, err := s.syncCatalog(t.Context()); err != nil {
		t.Fatal(err)
	}

	if !isMarked(t, s.db, "uuid-008") || !isMarked(t, s.db, "uuid-009") || marked(t, s.db) != 2 {
		t.Errorf("marked = %d, want exactly uuid-008 and uuid-009 (legacy and present rows untouched)", marked(t, s.db))
	}
	if got := countRows(t, s.db, `SELECT COUNT(*) FROM exercises`); got != total {
		t.Errorf("exercise rows = %d, want %d: nothing is ever deleted", got, total)
	}
	names := listedNames(t, s, ExerciseFilter{Limit: 100})
	if len(names) != 9 {
		t.Errorf("List = %d rows, want 9 (8 present + legacy)", len(names))
	}
	if got := mustGet(t, s, gone, "en").Name; got != "Exercise 009" {
		t.Errorf("Get = %q", got)
	}
	w, err := NewWorkoutStore(s.db).Get(uid, wid, "en")
	if err != nil {
		t.Fatal(err)
	}
	if len(w.Exercises) != 1 || w.Exercises[0].Exercise.Name != "Exercise 009" {
		t.Errorf("workout exercises = %+v, want the removed exercise still joined by name", w.Exercises)
	}

	cat.setUpstream(10)
	cat.setRev(1)
	if _, err := s.syncCatalog(t.Context()); err != nil {
		t.Fatal(err)
	}
	if marked(t, s.db) != 0 {
		t.Errorf("marked = %d after the exercises reappeared, want 0", marked(t, s.db))
	}
	if got := listedNames(t, s, ExerciseFilter{Limit: 100}); len(got) != 11 {
		t.Errorf("List = %d rows, want 11", len(got))
	}
}

func TestSyncCatalog_TruncatedExportMarksNothing(t *testing.T) {
	s, cat := syncStore(t, 10, "en")
	cat.setUpstream(4)
	_, err := s.syncCatalog(t.Context())
	if !errors.Is(err, ErrCatalogShrank) || errors.Is(err, ErrCatalogUnreachable) {
		t.Fatalf("err = %v, want ErrCatalogShrank (retried, but not an outage)", err)
	}
	if marked(t, s.db) != 0 {
		t.Errorf("marked = %d, want 0", marked(t, s.db))
	}

	s2, cat2 := syncStore(t, 10, "en")
	cat2.setUpstream(5)
	if _, err := s2.syncCatalog(t.Context()); err != nil {
		t.Fatalf("exactly half is allowed: %v", err)
	}
	if marked(t, s2.db) != 5 {
		t.Errorf("marked = %d, want 5", marked(t, s2.db))
	}
}

func TestRefreshCachedConfirmed_AcceptsAShrunkenExport(t *testing.T) {
	s, cat := syncStore(t, 10, "en")
	cat.setUpstream(4)
	if _, err := s.RefreshCached(t.Context()); !errors.Is(err, ErrCatalogShrank) {
		t.Fatalf("unconfirmed err = %v, want ErrCatalogShrank", err)
	}
	if _, err := s.RefreshCachedConfirmed(t.Context()); err != nil {
		t.Fatalf("confirmed pass: %v", err)
	}
	if marked(t, s.db) != 6 {
		t.Errorf("marked = %d, want 6", marked(t, s.db))
	}
	if _, err := s.syncCatalog(t.Context()); err != nil {
		t.Errorf("the next scheduled pass must see 4 against 4 visible: %v", err)
	}
}

func TestRefreshCachedConfirmed_StillRefusesAnEmptyExport(t *testing.T) {
	s, cat := syncStore(t, 10, "en")
	cat.setUpstream(0)
	if _, err := s.RefreshCachedConfirmed(t.Context()); !errors.Is(err, ErrCatalogUnreachable) {
		t.Fatalf("err = %v, want ErrCatalogUnreachable", err)
	}
	if marked(t, s.db) != 0 {
		t.Errorf("marked = %d, want 0", marked(t, s.db))
	}
}

func TestSyncCatalog_EmptyExportWithHeldRowsMarksNothing(t *testing.T) {
	s, cat := syncStore(t, 10, "en")
	cat.setUpstream(0)
	_, err := s.syncCatalog(t.Context())
	if !errors.Is(err, ErrCatalogUnreachable) {
		t.Fatalf("err = %v, want ErrCatalogUnreachable", err)
	}
	if marked(t, s.db) != 0 {
		t.Errorf("marked = %d, want 0", marked(t, s.db))
	}
}

func TestSyncCatalog_FailedEnglishImportMarksNothing(t *testing.T) {
	s, cat := syncStore(t, 10, "en")
	if _, err := s.db.Exec(`CREATE TRIGGER fail_import BEFORE UPDATE ON exercises WHEN NEW.oedb_id = 'uuid-003' BEGIN SELECT RAISE(ABORT, 'boom'); END`); err != nil {
		t.Fatal(err)
	}
	cat.setUpstream(8)
	if _, err := s.syncCatalog(t.Context()); err == nil {
		t.Fatal("want the failed import reported")
	}
	if marked(t, s.db) != 0 {
		t.Errorf("marked = %d, want 0: no mark unless the whole export imported", marked(t, s.db))
	}
}

func TestSyncCatalog_RemovalMarkIsIdempotent(t *testing.T) {
	s, cat := syncStore(t, 10, "en")
	cat.setUpstream(8)
	if _, err := s.syncCatalog(t.Context()); err != nil {
		t.Fatal(err)
	}
	if _, err := s.db.Exec(`UPDATE exercises SET upstream_missing_at = '2000-01-01 00:00:00' WHERE oedb_id = 'uuid-009'`); err != nil {
		t.Fatal(err)
	}
	if _, err := s.syncCatalog(t.Context()); err != nil {
		t.Fatal(err)
	}
	if got := countRows(t, s.db, `SELECT COUNT(*) FROM exercises WHERE oedb_id = 'uuid-009' AND upstream_missing_at = '2000-01-01 00:00:00'`); got != 1 {
		t.Error("a second pass must keep the first timestamp")
	}
	if marked(t, s.db) != 2 {
		t.Errorf("marked = %d, want 2", marked(t, s.db))
	}
}

func TestSyncCatalog_SkipsTranslationReadsForRemovedExercises(t *testing.T) {
	s, cat := syncStore(t, 10, "en", "es")
	cat.setUpstream(8)
	if _, err := s.syncCatalog(t.Context()); err != nil {
		t.Fatal(err)
	}
	for _, c := range cat.snapshot() {
		if c.path == "/api/v1/exercises" && (strings.Contains(c.ids, "uuid-008") || strings.Contains(c.ids, "uuid-009")) {
			t.Errorf("re-read %q for a removed exercise", c.ids)
		}
	}
	if !isMarked(t, s.db, "uuid-008") || !isMarked(t, s.db, "uuid-009") {
		t.Error("the translation pass must not un-hide a removed exercise")
	}
}

func TestSyncCatalog_PurgesTranslationsOfDroppedLanguages(t *testing.T) {
	s, cat := syncStore(t, 10, "en", "es", "fr")
	if _, err := s.syncCatalog(t.Context()); err != nil {
		t.Fatal(err)
	}
	if countRows(t, s.db, `SELECT COUNT(*) FROM exercise_translations WHERE locale = 'fr'`) != 10 {
		t.Fatal("fr should be held before the language is dropped")
	}
	base := countRows(t, s.db, `SELECT COUNT(*) FROM exercises WHERE name LIKE 'Exercise %' AND description <> ''`)

	cat.setLocales("en", "es-MX")
	cat.setRev(1)
	if _, err := s.syncCatalog(t.Context()); err != nil {
		t.Fatal(err)
	}
	if got := countRows(t, s.db, `SELECT COUNT(*) FROM exercise_translations WHERE locale = 'fr'`); got != 0 {
		t.Errorf("fr translations = %d, want 0", got)
	}
	if got := countRows(t, s.db, `SELECT COUNT(*) FROM exercise_translations WHERE locale = 'es-MX'`); got != 10 {
		t.Errorf("es-MX translations = %d, want 10", got)
	}
	if got := countRows(t, s.db, `SELECT COUNT(*) FROM exercises WHERE name LIKE 'Exercise %' AND description <> ''`); got != base {
		t.Errorf("English rows = %d, want %d untouched", got, base)
	}
}

func TestPurgeDroppedLocales_KeepsTheBaseOfAnOfferedRegion(t *testing.T) {
	s := NewExerciseStore(testDB(t))
	materialize(t, s, "en", catalogExercise("uuid-1", "One"))
	id := localID(t, s, "uuid-1")
	for _, l := range []string{"es", "es-MX", "pt-BR", "fr"} {
		if _, err := s.db.Exec(`INSERT INTO exercise_translations (exercise_id, locale, name) VALUES (?, ?, ?)`, id, l, l); err != nil {
			t.Fatal(err)
		}
	}
	if err := s.purgeDroppedLocales([]string{"es-MX", "pt"}); err != nil {
		t.Fatal(err)
	}
	var got []string
	rows, _ := s.db.Query(`SELECT locale FROM exercise_translations ORDER BY locale`)
	for rows.Next() {
		var l string
		rows.Scan(&l)
		got = append(got, l)
	}
	rows.Close()
	if fmt.Sprint(got) != "[es es-MX]" {
		t.Errorf("locales left = %v, want [es es-MX]", got)
	}
}

func TestSyncCatalog_KeepsTranslationsWhenDiscoveryFailsOrIsEmpty(t *testing.T) {
	s, cat := syncStore(t, 5, "en", "es", "fr")
	if _, err := s.syncCatalog(t.Context()); err != nil {
		t.Fatal(err)
	}
	before := countRows(t, s.db, `SELECT COUNT(*) FROM exercise_translations`)
	if before != 10 {
		t.Fatalf("translations = %d, want 10", before)
	}

	cat.setFail("/api/v1/meta/locales", "")
	if _, err := s.syncCatalog(t.Context()); err == nil {
		t.Fatal("want the discovery failure reported")
	}
	if got := countRows(t, s.db, `SELECT COUNT(*) FROM exercise_translations`); got != before {
		t.Errorf("translations = %d after a failed discovery, want %d", got, before)
	}

	cat.mu.Lock()
	delete(cat.failPath, "/api/v1/meta/locales")
	cat.mu.Unlock()
	cat.setLocales()
	if _, err := s.syncCatalog(t.Context()); err != nil {
		t.Fatal(err)
	}
	if got := countRows(t, s.db, `SELECT COUNT(*) FROM exercise_translations`); got != before {
		t.Errorf("translations = %d after an empty discovery, want %d", got, before)
	}
}

// One discovery answer must not be able to wipe the translations: dropping most of the
// held languages at once is far more likely a bad answer than a catalog that shrank.
func TestPurgeDroppedLocales_RefusesToDropMostLanguagesAtOnce(t *testing.T) {
	s := NewExerciseStore(testDB(t))
	materialize(t, s, "en", catalogExercise("uuid-1", "One"))
	id := localID(t, s, "uuid-1")
	for _, l := range []string{"es", "fr", "de"} {
		if _, err := s.db.Exec(`INSERT INTO exercise_translations (exercise_id, locale, name) VALUES (?, ?, ?)`, id, l, l); err != nil {
			t.Fatal(err)
		}
	}
	if err := s.purgeDroppedLocales([]string{"es"}); err != nil {
		t.Fatal(err)
	}
	if n := countRows(t, s.db, `SELECT COUNT(*) FROM exercise_translations`); n != 3 {
		t.Errorf("translations = %d, want all 3 kept when 2 of 3 languages would go", n)
	}
	if err := s.purgeDroppedLocales([]string{"es", "fr"}); err != nil {
		t.Fatal(err)
	}
	if n := countRows(t, s.db, `SELECT COUNT(*) FROM exercise_translations`); n != 2 {
		t.Errorf("translations = %d, want 2 after dropping 1 of 3", n)
	}
}

// A search answered from the response cache can still list an exercise the daily pass
// has just found removed. Recording that answer must not bring the exercise back.
func TestSyncCatalog_RemovalIsNotUndoneByACachedSearch(t *testing.T) {
	var removed atomic.Bool
	both := []oedb.Exercise{catalogExercise("uuid-x", "Squat X"), catalogExercise("uuid-y", "Squat Y")}
	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Cache-Control", "max-age=300")
		items := both
		if removed.Load() {
			items = both[1:]
		}
		switch r.URL.Path {
		case "/api/v1/meta/locales":
			fmt.Fprint(w, `{"locales":[{"code":"en"}],"total":1}`)
		case "/api/v1/exercises/export":
			json.NewEncoder(w).Encode(map[string]any{"exercises": items})
		default:
			if removed.Load() && r.URL.Query().Get("q") != "" {
				items = both[1:]
			} else if !removed.Load() {
				items = both
			}
			json.NewEncoder(w).Encode(map[string]any{"exercises": items, "total": len(items)})
		}
	}))
	defer srv.Close()

	s := NewExerciseStore(testDB(t))
	s.UseCatalog(oedb.New(srv.URL, "test"))
	names := func() []string {
		out, err := s.Search(context.Background(), ExerciseFilter{Query: "squat", Limit: 50})
		if err != nil {
			t.Fatal(err)
		}
		var n []string
		for _, e := range out {
			n = append(n, e.Name)
		}
		return n
	}

	if got := names(); len(got) != 2 {
		t.Fatalf("before the removal, search = %v, want both", got)
	}
	removed.Store(true)
	if _, err := s.syncCatalog(context.Background()); err != nil {
		t.Fatalf("sync: %v", err)
	}
	if got := names(); slices.Contains(got, "Squat X") {
		t.Errorf("search after the removal = %v, want Squat X to stay hidden", got)
	}
	list, err := s.List(ExerciseFilter{Query: "squat", Limit: 50})
	if err != nil {
		t.Fatal(err)
	}
	for _, e := range list {
		if e.Name == "Squat X" {
			t.Error("the removed exercise was un-hidden by a search")
		}
	}
}