cricinfo-cli-go 0.1.0

package/internal/cricinfo/live_matches_test.go

@@ -0,0 +1,203 @@
+package cricinfo
+
+import (
+	"context"
+	"encoding/json"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestLiveMatchesTraversalFromEvents(t *testing.T) {
+	t.Parallel()
+	requireLiveMatrix(t)
+
+	service, err := NewMatchService(MatchServiceConfig{})
+	if err != nil {
+		t.Fatalf("NewMatchService error: %v", err)
+	}
+	defer func() {
+		_ = service.Close()
+	}()
+
+	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
+	defer cancel()
+
+	result, err := service.List(ctx, MatchListOptions{Limit: 5})
+	if err != nil {
+		t.Fatalf("MatchService.List error: %v", err)
+	}
+
+	if result.Status == ResultStatusError {
+		if result.Error != nil && result.Error.StatusCode == 503 {
+			t.Skipf("skipping live traversal after persistent 503: %s", result.Message)
+		}
+		t.Fatalf("unexpected error result: %+v", result)
+	}
+	if !strings.Contains(result.RequestedRef, "/events") {
+		t.Fatalf("expected list traversal to begin from /events, requestedRef=%q", result.RequestedRef)
+	}
+
+	if len(result.Items) == 0 {
+		if hasLive503Warning(result.Warnings) {
+			t.Skipf("skipping after transient 503 warnings: %v", result.Warnings)
+		}
+		t.Fatalf("expected at least one match from /events traversal")
+	}
+
+	first, ok := result.Items[0].(Match)
+	if !ok {
+		t.Fatalf("expected first result item to be Match, got %T", result.Items[0])
+	}
+	if first.LeagueID == "" || first.EventID == "" || first.CompetitionID == "" {
+		t.Fatalf("expected match IDs for drill-down use, got %+v", first)
+	}
+	if len(first.Teams) == 0 {
+		t.Fatalf("expected match teams in live traversal output")
+	}
+	if strings.TrimSpace(first.Date) == "" {
+		t.Fatalf("expected match date in live traversal output")
+	}
+}
+
+func TestLiveMatchDrillDownRoutes(t *testing.T) {
+	t.Parallel()
+	requireLiveMatrix(t)
+
+	client, err := NewClient(Config{
+		Timeout:    12 * time.Second,
+		MaxRetries: 3,
+	})
+	if err != nil {
+		t.Fatalf("NewClient error: %v", err)
+	}
+
+	routes := []struct {
+		name string
+		ref  string
+	}{
+		{name: "details", ref: "/leagues/19138/events/1529474/competitions/1529474/details"},
+		{name: "plays", ref: "/leagues/19138/events/1529474/competitions/1529474/plays"},
+		{name: "matchcards", ref: "/leagues/11132/events/1527966/competitions/1527966/matchcards"},
+		{name: "situation", ref: "/leagues/19138/events/1529474/competitions/1529474/situation"},
+	}
+
+	for _, tc := range routes {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+			defer cancel()
+
+			resolved, err := client.ResolveRefChain(ctx, tc.ref)
+			if err != nil {
+				if isLive503(err) {
+					t.Skipf("skipping %s after transient 503: %v", tc.name, err)
+				}
+				t.Fatalf("ResolveRefChain(%q) error: %v", tc.ref, err)
+			}
+
+			switch tc.name {
+			case "details", "plays":
+				page, err := DecodePage[Ref](resolved.Body)
+				if err != nil {
+					t.Fatalf("DecodePage %s error: %v", tc.name, err)
+				}
+				if len(page.Items) == 0 {
+					t.Fatalf("expected at least one %s item ref", tc.name)
+				}
+			case "matchcards":
+				var payload map[string]any
+				if err := json.Unmarshal(resolved.Body, &payload); err != nil {
+					t.Fatalf("unmarshal matchcards payload: %v", err)
+				}
+				items := mapSliceField(payload, "items")
+				if len(items) == 0 {
+					t.Fatalf("expected matchcards items")
+				}
+				headlines := map[string]bool{}
+				for _, item := range items {
+					headline := strings.ToLower(strings.TrimSpace(stringField(item, "headline")))
+					if headline != "" {
+						headlines[headline] = true
+					}
+				}
+				if !headlines["batting"] || !headlines["bowling"] {
+					t.Fatalf("expected matchcards to include batting and bowling sections, got %v", headlines)
+				}
+			case "situation":
+				var payload map[string]any
+				if err := json.Unmarshal(resolved.Body, &payload); err != nil {
+					t.Fatalf("unmarshal situation payload: %v", err)
+				}
+				if len(payload) == 0 {
+					t.Fatalf("expected non-empty situation payload")
+				}
+				if _, ok := payload["$ref"]; !ok {
+					t.Fatalf("expected situation payload to include $ref")
+				}
+			}
+		})
+	}
+}
+
+func TestLiveMatchInningsDepthRoutes(t *testing.T) {
+	t.Parallel()
+	requireLiveMatrix(t)
+
+	client, err := NewClient(Config{
+		Timeout:    12 * time.Second,
+		MaxRetries: 3,
+	})
+	if err != nil {
+		t.Fatalf("NewClient error: %v", err)
+	}
+
+	routes := []struct {
+		name string
+		ref  string
+		keys []string
+	}{
+		{
+			name: "linescores",
+			ref:  "/leagues/19138/events/1529474/competitions/1529474/competitors/789643/linescores",
+			keys: []string{"items", "count"},
+		},
+		{
+			name: "period-statistics",
+			ref:  "/leagues/19138/events/1529474/competitions/1529474/competitors/789643/linescores/1/1/statistics/0",
+			keys: []string{"splits", "team"},
+		},
+		{
+			name: "partnerships",
+			ref:  "/leagues/19138/events/1529474/competitions/1529474/competitors/789643/linescores/1/1/partnerships",
+			keys: []string{"items", "count"},
+		},
+		{
+			name: "fow",
+			ref:  "/leagues/19138/events/1529474/competitions/1529474/competitors/789643/linescores/1/1/fow",
+			keys: []string{"items", "count"},
+		},
+	}
+
+	for _, tc := range routes {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+			defer cancel()
+
+			resolved, err := client.ResolveRefChain(ctx, tc.ref)
+			if err != nil {
+				if isLive503(err) {
+					t.Skipf("skipping %s after transient 503: %v", tc.name, err)
+				}
+				t.Fatalf("ResolveRefChain(%q) error: %v", tc.ref, err)
+			}
+
+			var payload map[string]any
+			if err := json.Unmarshal(resolved.Body, &payload); err != nil {
+				t.Fatalf("unmarshal %s payload: %v", tc.name, err)
+			}
+			requireAnyKey(t, payload, tc.keys...)
+		})
+	}
+}

package/internal/cricinfo/live_matrix_test.go

@@ -0,0 +1,118 @@
+package cricinfo
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"os"
+	"testing"
+	"time"
+)
+
+const (
+	liveMatrixEnv         = "CRICINFO_LIVE_MATRIX"
+	liveMatrixFamiliesEnv = "CRICINFO_LIVE_FAMILIES"
+)
+
+func TestLiveFixtureMatrixByFamily(t *testing.T) {
+	t.Parallel()
+	requireLiveMatrix(t)
+
+	selected, err := ParseFixtureFamilies(os.Getenv(liveMatrixFamiliesEnv))
+	if err != nil {
+		t.Fatalf("ParseFixtureFamilies error: %v", err)
+	}
+
+	matrix := FixtureMatrix()
+	matrix = FilterFixtureMatrixByFamily(matrix, selected)
+	matrix = LiveProbeMatrix(matrix)
+
+	if len(matrix) == 0 {
+		t.Fatalf("no live probes selected from fixture matrix")
+	}
+
+	requiredFamilies := map[FixtureFamily]struct{}{}
+	for _, spec := range matrix {
+		requiredFamilies[spec.Family] = struct{}{}
+	}
+	for family := range selected {
+		if _, ok := requiredFamilies[family]; !ok {
+			t.Fatalf("selected family %q has no live probe in matrix", family)
+		}
+	}
+
+	client, err := NewClient(Config{
+		Timeout:    12 * time.Second,
+		MaxRetries: 3,
+	})
+	if err != nil {
+		t.Fatalf("NewClient error: %v", err)
+	}
+
+	for _, spec := range matrix {
+		spec := spec
+		t.Run(fmt.Sprintf("%s/%s", spec.Family, spec.Name), func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+			defer cancel()
+
+			resolved, err := client.ResolveRefChain(ctx, spec.Ref)
+			if err != nil {
+				if isLive503(err) {
+					t.Skipf("skipping after persistent 503 for %s: %v", spec.Ref, err)
+				}
+				t.Fatalf("ResolveRefChain(%q) error: %v", spec.Ref, err)
+			}
+
+			var payload map[string]any
+			if err := json.Unmarshal(resolved.Body, &payload); err != nil {
+				t.Fatalf("unmarshal %q: %v", spec.Ref, err)
+			}
+			if len(payload) == 0 {
+				t.Fatalf("empty payload from %q", spec.Ref)
+			}
+
+			validateLiveFamilyPayload(t, spec.Family, payload)
+		})
+	}
+}
+
+func requireLiveMatrix(t *testing.T) {
+	t.Helper()
+	if os.Getenv(liveMatrixEnv) != "1" {
+		t.Skip("set CRICINFO_LIVE_MATRIX=1 to run live fixture matrix tests")
+	}
+}
+
+func isLive503(err error) bool {
+	var statusErr *HTTPStatusError
+	if errors.As(err, &statusErr) {
+		return statusErr.StatusCode == 503
+	}
+	return false
+}
+
+func validateLiveFamilyPayload(t *testing.T, family FixtureFamily, payload map[string]any) {
+	t.Helper()
+
+	switch family {
+	case FixtureFamilyRootDiscovery:
+		requireAnyKey(t, payload, "events", "leagues", "items")
+	case FixtureFamilyMatchesCompetition:
+		requireAnyKey(t, payload, "competitors", "status", "date")
+	case FixtureFamilyDetailsPlays:
+		requireAnyKey(t, payload, "items", "count")
+	case FixtureFamilyTeamCompetitor:
+		requireAnyKey(t, payload, "id", "team", "record")
+	case FixtureFamilyInningsDepth:
+		requireAnyKey(t, payload, "period", "runs", "wickets")
+	case FixtureFamilyPlayers:
+		requireAnyKey(t, payload, "id", "displayName", "fullName")
+	case FixtureFamilyLeagueSeason:
+		requireAnyKey(t, payload, "children", "items", "entries")
+	case FixtureFamilyAuxCompetitionMeta:
+		requireAnyKey(t, payload, "items", "count", "entries")
+	default:
+		t.Fatalf("unsupported family %q", family)
+	}
+}

package/internal/cricinfo/live_players_test.go

@@ -0,0 +1,122 @@
+package cricinfo
+
+import (
+	"context"
+	"encoding/json"
+	"testing"
+	"time"
+)
+
+func TestLivePlayerRoutes(t *testing.T) {
+	t.Parallel()
+	requireLiveMatrix(t)
+
+	client, err := NewClient(Config{
+		Timeout:    12 * time.Second,
+		MaxRetries: 3,
+	})
+	if err != nil {
+		t.Fatalf("NewClient error: %v", err)
+	}
+
+	routes := []struct {
+		name string
+		ref  string
+		keys []string
+	}{
+		{
+			name: "athlete-profile",
+			ref:  "/athletes/1361257",
+			keys: []string{"id", "displayName", "styles", "team"},
+		},
+		{
+			name: "athlete-news",
+			ref:  "/athletes/253802/news",
+			keys: []string{"items", "count"},
+		},
+		{
+			name: "athlete-statistics",
+			ref:  "/athletes/1361257/statistics",
+			keys: []string{"splits", "athlete"},
+		},
+	}
+
+	for _, tc := range routes {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+			defer cancel()
+
+			resolved, err := client.ResolveRefChain(ctx, tc.ref)
+			if err != nil {
+				if isLive503(err) {
+					t.Skipf("skipping %s after transient 503: %v", tc.name, err)
+				}
+				t.Fatalf("ResolveRefChain(%q) error: %v", tc.ref, err)
+			}
+
+			var payload map[string]any
+			if err := json.Unmarshal(resolved.Body, &payload); err != nil {
+				t.Fatalf("unmarshal %s payload: %v", tc.name, err)
+			}
+			requireAnyKey(t, payload, tc.keys...)
+		})
+	}
+}
+
+func TestLivePlayerMatchContextRoutes(t *testing.T) {
+	t.Parallel()
+	requireLiveMatrix(t)
+
+	client, err := NewClient(Config{
+		Timeout:    12 * time.Second,
+		MaxRetries: 3,
+	})
+	if err != nil {
+		t.Fatalf("NewClient error: %v", err)
+	}
+
+	routes := []struct {
+		name string
+		ref  string
+		keys []string
+	}{
+		{
+			name: "roster-player-statistics",
+			ref:  "/leagues/19138/events/1529474/competitions/1529474/competitors/789643/roster/1361257/statistics/0",
+			keys: []string{"splits", "athlete", "competition"},
+		},
+		{
+			name: "roster-player-linescores",
+			ref:  "/leagues/19138/events/1529474/competitions/1529474/competitors/789643/roster/1361257/linescores",
+			keys: []string{"items", "count"},
+		},
+		{
+			name: "roster-player-linescore-statistics",
+			ref:  "/leagues/19138/events/1529474/competitions/1529474/competitors/789643/roster/1361257/linescores/1/1/statistics/0",
+			keys: []string{"splits", "athlete", "competition"},
+		},
+	}
+
+	for _, tc := range routes {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+			defer cancel()
+
+			resolved, err := client.ResolveRefChain(ctx, tc.ref)
+			if err != nil {
+				if isLive503(err) {
+					t.Skipf("skipping %s after transient 503: %v", tc.name, err)
+				}
+				t.Fatalf("ResolveRefChain(%q) error: %v", tc.ref, err)
+			}
+
+			var payload map[string]any
+			if err := json.Unmarshal(resolved.Body, &payload); err != nil {
+				t.Fatalf("unmarshal %s payload: %v", tc.name, err)
+			}
+			requireAnyKey(t, payload, tc.keys...)
+		})
+	}
+}

package/internal/cricinfo/live_search_test.go

@@ -0,0 +1,86 @@
+package cricinfo
+
+import (
+	"context"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestLiveSearchDiscoveryAcrossEntityFamilies(t *testing.T) {
+	t.Parallel()
+	requireLiveMatrix(t)
+
+	resolver, err := NewResolver(ResolverConfig{
+		EventSeedTTL: time.Minute,
+		MaxEventSeed: 24,
+		IndexPath:    t.TempDir() + "/live-search-index.json",
+	})
+	if err != nil {
+		t.Fatalf("NewResolver error: %v", err)
+	}
+	defer func() {
+		_ = resolver.Close()
+	}()
+
+	tests := []struct {
+		name  string
+		kind  EntityKind
+		query string
+		opts  ResolveOptions
+		id    string
+	}{
+		{name: "player", kind: EntityPlayer, query: "1361257", opts: ResolveOptions{Limit: 5}, id: "1361257"},
+		{name: "team", kind: EntityTeam, query: "789643", opts: ResolveOptions{Limit: 5}, id: "789643"},
+		{name: "league", kind: EntityLeague, query: "19138", opts: ResolveOptions{Limit: 5}, id: "19138"},
+		{name: "match", kind: EntityMatch, query: "1529474", opts: ResolveOptions{Limit: 5, LeagueID: "19138"}, id: "1529474"},
+	}
+
+	for _, tc := range tests {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			ctx, cancel := context.WithTimeout(context.Background(), 45*time.Second)
+			defer cancel()
+
+			result, err := resolver.Search(ctx, tc.kind, tc.query, tc.opts)
+			if err != nil {
+				if isLiveSearchTransient503(err.Error()) {
+					t.Skipf("skipping %s search after transient 503: %v", tc.name, err)
+				}
+				t.Fatalf("Search error for %s: %v", tc.name, err)
+			}
+
+			if len(result.Entities) == 0 {
+				if hasLive503Warning(result.Warnings) {
+					t.Skipf("skipping %s search after transient 503 warnings: %v", tc.name, result.Warnings)
+				}
+				t.Fatalf("expected at least one %s result for query %q", tc.name, tc.query)
+			}
+
+			found := false
+			for _, entity := range result.Entities {
+				if entity.ID == tc.id {
+					found = true
+					break
+				}
+			}
+			if !found {
+				t.Fatalf("expected %s result set to contain id %s, got %+v", tc.name, tc.id, result.Entities)
+			}
+		})
+	}
+}
+
+func hasLive503Warning(warnings []string) bool {
+	for _, warning := range warnings {
+		if isLiveSearchTransient503(warning) {
+			return true
+		}
+	}
+	return false
+}
+
+func isLiveSearchTransient503(raw string) bool {
+	raw = strings.ToLower(strings.TrimSpace(raw))
+	return strings.Contains(raw, "status 503") || strings.Contains(raw, "503 service unavailable")
+}