Add gated cover byte fetcher

backend/internal/latest/poller_test.go

@@ -128,6 +128,30 @@ func (f *fakeCoverFetcher) callCount() int {
 	return len(f.calls)
 }
 
+type fakeBytesCoverFetcher struct {
+	mu          sync.Mutex
+	calls       []string
+	body        []byte
+	contentType string
+	err         error
+}
+
+func (f *fakeBytesCoverFetcher) Fetch(_ context.Context, sourceURL string) ([]byte, string, error) {
+	f.mu.Lock()
+	f.calls = append(f.calls, sourceURL)
+	f.mu.Unlock()
+	if f.err != nil {
+		return nil, "", f.err
+	}
+	return f.body, f.contentType, nil
+}
+
+func (f *fakeBytesCoverFetcher) callCount() int {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return len(f.calls)
+}
+
 // newTestPoller wires a poller with a frozen clock and no stagger, so tests run
 // instantly and deterministically.
 func newTestPoller(t *testing.T, s *store.Store, f Fetcher, at time.Time) *Poller {
@@ -144,6 +168,63 @@ func newTestPoller(t *testing.T, s *store.Store, f Fetcher, at time.Time) *Polle
 	}
 }
 
+func TestRunOncePrefetchesPublicCover(t *testing.T) {
+	s, _ := newTestStore(t)
+	const (
+		key       = "asura:chronicles-of-the-demon-faction-f886a8af"
+		seriesURL = "https://asurascans.com/comics/chronicles-of-the-demon-faction-f886a8af"
+		coverURL  = "https://cdn.example/covers/chronicles.jpg"
+	)
+	if _, err := s.Upsert(s.OwnerID(), store.Bookmark{
+		Key: key, Site: "asura", SeriesID: "chronicles-of-the-demon-faction-f886a8af",
+		SeriesURL: seriesURL, Cover: coverURL, UpdatedAt: 1000,
+	}); err != nil {
+		t.Fatalf("seed: %v", err)
+	}
+	covers := &fakeBytesCoverFetcher{body: []byte("cover-bytes"), contentType: "image/jpeg"}
+	p := &Poller{
+		Store: s, Fetch: &fakeFetcher{body: asuraSeriesFixture, status: 200}, CoverBytesFetch: covers,
+		Now: func() time.Time { return time.UnixMilli(5_000_000) }, Cooldown: time.Hour, Batch: 10,
+	}
+	p.runOnce(context.Background())
+
+	if got := covers.callCount(); got != 1 {
+		t.Fatalf("cover fetch calls = %d, want 1", got)
+	}
+	body, contentType, found, err := s.GetCover(coverURL)
+	if err != nil || !found {
+		t.Fatalf("GetCover: %v found=%v", err, found)
+	}
+	if string(body) != "cover-bytes" || contentType != "image/jpeg" {
+		t.Fatalf("stored cover = (%q, %q), want (cover-bytes, image/jpeg)", body, contentType)
+	}
+}
+
+func TestRunOnceDoesNotStoreNonImagePublicCover(t *testing.T) {
+	s, _ := newTestStore(t)
+	const (
+		key       = "asura:non-image-cover"
+		seriesURL = "https://asurascans.com/comics/non-image-cover"
+		coverURL  = "https://cdn.example/covers/challenge"
+	)
+	if _, err := s.Upsert(s.OwnerID(), store.Bookmark{
+		Key: key, Site: "asura", SeriesID: "non-image-cover", SeriesURL: seriesURL, Cover: coverURL,
+		UpdatedAt: 1000,
+	}); err != nil {
+		t.Fatalf("seed: %v", err)
+	}
+	p := &Poller{
+		Store: s, Fetch: &fakeFetcher{body: asuraSeriesFixture, status: 200},
+		CoverBytesFetch: &fakeBytesCoverFetcher{body: []byte("challenge"), contentType: "text/html"},
+		Now:             func() time.Time { return time.UnixMilli(5_000_000) }, Cooldown: time.Hour, Batch: 10,
+	}
+	p.runOnce(context.Background())
+
+	if _, _, found, err := s.GetCover(coverURL); err != nil || found {
+		t.Fatalf("non-image cover = found %v, err %v; want missing", found, err)
+	}
+}
+
 func TestRunOnceRecordsLatestChapter(t *testing.T) {
 	s, _ := newTestStore(t)
 	const url = "https://asurascans.com/comics/chronicles-of-the-demon-faction-f886a8af"
@@ -748,24 +829,30 @@ func TestRunOnceWithoutCoverFetcherStillPollsKagane(t *testing.T) {
 	}
 }
 
-func TestRunOnceDoesNotPrefetchNonKaganeCover(t *testing.T) {
+func TestRunOnceRoutesNonKaganeCoverToPublicFetcher(t *testing.T) {
 	s, _ := newTestStore(t)
 	const key = "asura:solo"
+	const coverURL = "https://asurascans.com/covers/solo.jpg"
 	if _, err := s.Upsert(s.OwnerID(), store.Bookmark{
 		Key: key, Site: "asura", SeriesID: "solo", SeriesURL: "https://asurascans.com/comics/solo",
-		Cover: "https://asurascans.com/covers/solo.jpg", UpdatedAt: 1000,
+		Cover: coverURL, UpdatedAt: 1000,
 	}); err != nil {
 		t.Fatalf("seed: %v", err)
 	}
-	covers := &fakeCoverFetcher{body: []byte("must not be fetched"), contentType: "image/webp"}
+	browserCovers := &fakeCoverFetcher{body: []byte("must not be fetched"), contentType: "image/webp"}
+	publicCovers := &fakeBytesCoverFetcher{body: []byte("public cover"), contentType: "image/webp"}
 	p := &Poller{
-		Store: s, Fetch: &fakeFetcher{body: asuraSeriesFixture, status: 200}, CoverFetch: covers,
-		Now: func() time.Time { return time.UnixMilli(5_000_000) }, Cooldown: time.Hour, BrowserCooldown: time.Hour, Batch: 10,
+		Store: s, Fetch: &fakeFetcher{body: asuraSeriesFixture, status: 200}, CoverFetch: browserCovers,
+		CoverBytesFetch: publicCovers,
+		Now:             func() time.Time { return time.UnixMilli(5_000_000) }, Cooldown: time.Hour, BrowserCooldown: time.Hour, Batch: 10,
 	}
 	p.runOnce(context.Background())
 
-	if got := covers.callCount(); got != 0 {
-		t.Fatalf("cover fetch calls for asura = %d, want 0", got)
+	if got := publicCovers.callCount(); got != 1 {
+		t.Fatalf("public cover fetch calls = %d, want 1", got)
+	}
+	if got := browserCovers.callCount(); got != 0 {
+		t.Fatalf("browser cover fetch calls for asura = %d, want 0", got)
 	}
 }