feat: refactor source breakdown logic for case-insensitive matching and add corresponding tests

Author: alvarorichard

internal/api/enhanced.go

@@ -146,30 +146,16 @@ func SearchAnimeEnhanced(name string, source string) (*models.Anime, error) {
 
 	util.Debug("Search results summary", "total", len(animes))
 
-	// Show sources breakdown in debug only
-	animefireCount := 0
-	allanimeCount := 0
-	animedriveCount := 0
-	flixhqCount := 0
-	nineAnimeCount := 0
-	superflixCount := 0
-	for _, anime := range animes {
-		if strings.Contains(anime.Source, "AnimeFire") {
-			animefireCount++
-		} else if anime.Source == "AllAnime" {
-			allanimeCount++
-		} else if anime.Source == "AnimeDrive" {
-			animedriveCount++
-		} else if anime.Source == "FlixHQ" {
-			flixhqCount++
-		} else if anime.Source == "9Anime" {
-			nineAnimeCount++
-		} else if anime.Source == "SuperFlix" {
-			superflixCount++
-		}
-	}
-
-	util.Debug("Source breakdown", "AnimeFire", animefireCount, "AllAnime", allanimeCount, "AnimeDrive", animedriveCount, "FlixHQ", flixhqCount, "9Anime", nineAnimeCount, "SuperFlix", superflixCount)
+	breakdown := countSourceBreakdown(animes)
+	util.Debug("Source breakdown",
+		"AnimeFire", breakdown.AnimeFire,
+		"AllAnime", breakdown.AllAnime,
+		"AnimeDrive", breakdown.AnimeDrive,
+		"FlixHQ", breakdown.FlixHQ,
+		"9Anime", breakdown.NineAnime,
+		"SuperFlix", breakdown.SuperFlix,
+		"Goyabu", breakdown.Goyabu,
+	)
 
 	// Sort results by language priority: Portuguese first, then Multilanguage, Movies/TV, English, others
 	sort.SliceStable(animes, func(i, j int) bool {
@@ -279,10 +265,12 @@ func GetAnimeEpisodesEnhanced(anime *models.Anime) ([]models.Episode, error) {
 	// Determine source type from multiple indicators with enhanced logic
 	var sourceName string
 
-	// Priority 1: Check the Source field (most reliable)
+	// Priority 1: Check the Source field (most reliable). Use a case-insensitive
+	// match for AnimeFire because the scraper emits "Animefire.io" (lowercase 'f')
+	// while older code paths/tests sometimes use the camelcase spelling "AnimeFire".
 	if anime.Source == "AllAnime" {
 		sourceName = "AllAnime"
-	} else if strings.Contains(anime.Source, "AnimeFire") {
+	} else if strings.Contains(strings.ToLower(anime.Source), "animefire") {
 		sourceName = "Animefire.io"
 	} else if anime.Source == "AnimeDrive" {
 		sourceName = "AnimeDrive"
@@ -1151,6 +1139,49 @@ func GetSuperFlixStreamURL(media *models.Anime, episode *models.Episode, quality
 	return result.StreamURL, nil
 }
 
+// sourceBreakdown holds per-source result counts for the debug "Source breakdown"
+// diagnostic line. Counted via countSourceBreakdown so the predicate stays
+// testable in isolation.
+type sourceBreakdown struct {
+	AnimeFire  int
+	AllAnime   int
+	AnimeDrive int
+	FlixHQ     int
+	NineAnime  int
+	SuperFlix  int
+	Goyabu     int
+}
+
+// countSourceBreakdown tallies anime results by Source field using
+// case-insensitive matching for AnimeFire. The scraper canonical Source is
+// "Animefire.io" (lowercase 'f'), but older callers and tests sometimes emit
+// "AnimeFire"; both must be counted so the diagnostic line never lies.
+func countSourceBreakdown(animes []*models.Anime) sourceBreakdown {
+	var b sourceBreakdown
+	for _, anime := range animes {
+		if anime == nil {
+			continue
+		}
+		switch {
+		case strings.Contains(strings.ToLower(anime.Source), "animefire"):
+			b.AnimeFire++
+		case anime.Source == "AllAnime":
+			b.AllAnime++
+		case anime.Source == "AnimeDrive":
+			b.AnimeDrive++
+		case anime.Source == "FlixHQ":
+			b.FlixHQ++
+		case anime.Source == "9Anime":
+			b.NineAnime++
+		case anime.Source == "SuperFlix":
+			b.SuperFlix++
+		case anime.Source == "Goyabu":
+			b.Goyabu++
+		}
+	}
+	return b
+}
+
 // languagePriority returns a sort key for language-based ordering.
 // Lower values sort first: Portuguese → Multilanguage → English → Movies/TV → Unknown.
 func languagePriority(name string) int {

internal/api/source_breakdown_test.go

@@ -0,0 +1,87 @@
+package api
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/alvarorichard/Goanime/internal/models"
+	"github.com/stretchr/testify/assert"
+)
+
+// TestSourceBreakdown_LegacyCaseSensitiveBug documents the original case-sensitive
+// regression: scrapers emit anime.Source = "Animefire.io" (lowercase 'f'), but the
+// debug breakdown searched for the substring "AnimeFire" (capital 'F'). Because
+// strings.Contains is byte-exact in Go, the AnimeFire counter was always zero
+// even when the search returned dozens of AnimeFire results — making the
+// "Source breakdown" diagnostic line lie to operators.
+//
+// This test reproduces the buggy comparison in isolation. The expectation
+// matches the broken behaviour so that if anyone ever "fixes" the bug by
+// hand without updating both the production code AND this regression test,
+// the failure makes the intent obvious.
+func TestSourceBreakdown_LegacyCaseSensitiveBug(t *testing.T) {
+	source := "Animefire.io"
+
+	// The exact pre-fix predicate from internal/api/enhanced.go.
+	matchesLegacyPredicate := strings.Contains(source, "AnimeFire")
+
+	assert.False(t, matchesLegacyPredicate,
+		"sanity check: 'Animefire.io' must NOT match 'AnimeFire' under case-sensitive Contains — "+
+			"if this assertion changes, Go's strings package semantics changed and the rest of the suite needs review")
+}
+
+// TestCountSourceBreakdown_AnimeFireCaseInsensitive is the positive regression
+// test for the fix: the breakdown helper must count "Animefire.io" results
+// regardless of capitalisation. Future scrapers (or upstream renames) that
+// emit "AnimeFire", "ANIMEFIRE", or "animefire" must all be counted.
+func TestCountSourceBreakdown_AnimeFireCaseInsensitive(t *testing.T) {
+	animes := []*models.Anime{
+		{Source: "Animefire.io"},
+		{Source: "Animefire.io"},
+		{Source: "AnimeFire"},
+		{Source: "ANIMEFIRE"},
+		{Source: "animefire"},
+		{Source: "AllAnime"},
+		{Source: "Goyabu"},
+		{Source: "FlixHQ"},
+		{Source: "9Anime"},
+		{Source: "SuperFlix"},
+		{Source: "AnimeDrive"},
+	}
+
+	got := countSourceBreakdown(animes)
+
+	assert.Equal(t, 5, got.AnimeFire, "all AnimeFire spellings must be counted")
+	assert.Equal(t, 1, got.AllAnime)
+	assert.Equal(t, 1, got.Goyabu)
+	assert.Equal(t, 1, got.FlixHQ)
+	assert.Equal(t, 1, got.NineAnime)
+	assert.Equal(t, 1, got.SuperFlix)
+	assert.Equal(t, 1, got.AnimeDrive)
+}
+
+// TestCountSourceBreakdown_RealisticPayload mirrors the user-reported log:
+// 10 AnimeFire results, 5 AllAnime, 8 Goyabu — and asserts that Goyabu is
+// reported (the original breakdown silently dropped it).
+func TestCountSourceBreakdown_RealisticPayload(t *testing.T) {
+	var animes []*models.Anime
+	for i := 0; i < 10; i++ {
+		animes = append(animes, &models.Anime{Source: "Animefire.io"})
+	}
+	for i := 0; i < 5; i++ {
+		animes = append(animes, &models.Anime{Source: "AllAnime"})
+	}
+	for i := 0; i < 8; i++ {
+		animes = append(animes, &models.Anime{Source: "Goyabu"})
+	}
+
+	got := countSourceBreakdown(animes)
+
+	assert.Equal(t, 10, got.AnimeFire, "AnimeFire breakdown must equal what the scraper returned")
+	assert.Equal(t, 5, got.AllAnime)
+	assert.Equal(t, 8, got.Goyabu, "Goyabu must appear in the breakdown")
+	assert.Equal(t, 0, got.AnimeDrive)
+	assert.Equal(t, 0, got.FlixHQ)
+	assert.Equal(t, 0, got.NineAnime)
+	assert.Equal(t, 0, got.SuperFlix)
+}

internal/playback/handle_download_and_play_call_site_test.go

@@ -21,8 +21,8 @@ import (
 // downstream, and would silently restore the original failure mode.
 //
 // This test parses the two call sites in the playback package and asserts:
-//   1. positional index 5 (the 6th argument) reads field MalID, and
-//   2. positional index 6 (the 7th argument) reads field AnilistID.
+//  1. positional index 5 (the 6th argument) reads field MalID, and
+//  2. positional index 6 (the 7th argument) reads field AnilistID.
 //
 // If either invariant breaks, the test fails with a precise message.
 func TestHandleDownloadAndPlay_CallSites_PassDistinctIDFields(t *testing.T) {

internal/player/animefire_referer_test.go

@@ -422,4 +422,3 @@ func TestApplyDownloadAuthHeaders_NilRequestIsNoop(t *testing.T) {
 		applyDownloadAuthHeaders(nil, "https://lightspeedst.net/x")
 	})
 }
-