package main import ( "context" "errors" "io" "os/exec" "strings" "testing" ) func TestAvatarPageClassification(t *testing.T) { for _, tc := range []struct{ body, code string }{ {``, "markerAbsent"}, {`var ytInitialData = {broken};`, "jsonInvalid"}, {`var ytInitialData = {"url":"https://yt3.ggpht.com.attacker.invalid/avatar"};`, "noAllowedAvatar"}, {`var ytInitialData = {"url":"http://yt3.ggpht.com/avatar"};`, "noAllowedAvatar"}, {`var ytInitialData = {"url":"https://user@yt3.ggpht.com/avatar"};`, "noAllowedAvatar"}, {`var ytInitialData = {"url":"https://yt3.ggpht.com/avatar?private=fixture"};`, "valid"}, } { t.Run(tc.code, func(t *testing.T) { raw, err := avatarResourceFromPage([]byte(tc.body)) if tc.code == "valid" { if err != nil || raw == "" { t.Fatal("missing validated resource", err) } return } var classified avatarMetadataError if raw != "" || !errors.As(err, &classified) || string(classified) != tc.code { t.Fatal("unexpected classification", err) } }) } } func TestManagedAvatarInventoryFallback(t *testing.T) { exit := func(code string) error { return exec.Command("sh", "-c", "exit "+code).Run() } for _, tc := range []struct { name, home, watch, video string pageErr, watchErr error calls int avatar, fatal bool }{ {name: "homeNoAvatarWatchHasValidatedURL", home: `var ytInitialData = {};`, watch: `var ytInitialData = {"url":"https://yt3.ggpht.com/fresh?private=fixture"};`, calls: 2, avatar: true}, {name: "homeAlreadyValid", home: `var ytInitialData = {"url":"https://yt3.ggpht.com/fresh"};`, calls: 1, avatar: true}, {name: "bothMissing", home: `var ytInitialData = {};`, watch: ``, calls: 2}, {name: "malformedHome", home: `var ytInitialData = {bad};`, calls: 1}, {name: "malformedWatch", home: `var ytInitialData = {};`, watch: `var ytInitialData = {bad};`, calls: 2}, {name: "watchHTTPMissing", home: `var ytInitialData = {};`, watchErr: exit("22"), calls: 2}, {name: "watchTimeout", home: `var ytInitialData = {};`, watchErr: exit("28"), calls: 2}, {name: "watchWrongCN", home: `var ytInitialData = {};`, watchErr: exit("60"), calls: 2}, {name: "watchMixedGuard", home: `var ytInitialData = {};`, watchErr: errors.Join(exit("28"), errors.New("owned proxy guard failed")), calls: 2, fatal: true}, {name: "untrustedWatchURL", watch: `var ytInitialData = {"url":"https://yt3.ggpht.com.evil.invalid/avatar"};`, calls: 2}, {name: "invalidVideo", video: "bad&injection", calls: 1, fatal: true}, {name: "timeoutNoFallback", pageErr: exit("28"), calls: 1}, {name: "wrongCNNoFallback", pageErr: exit("60"), calls: 1}, {name: "mixedGuardNoFallback", pageErr: errors.Join(exit("28"), errors.New("owned proxy guard failed")), calls: 1, fatal: true}, {name: "oversizedHomeNoFallback", home: strings.Repeat("x", (5<<20)+1), calls: 1, fatal: true}, } { t.Run(tc.name, func(t *testing.T) { cfg := healthConfig{SOCKSProxy: "socks5://127.0.0.1:11080", VideoID: "dQw4w9WgXcQ"} if tc.video != "" { cfg.VideoID = tc.video } calls := 0 resources := managedServiceResources(cfg, func(context.Context) ([]byte, error) { return []byte(`{"playabilityStatus":{"status":"OK"},"videoDetails":{"thumbnail":{"thumbnails":[{"url":"https://i.ytimg.com/fresh"}]}},"streamingData":{"formats":[{"url":"https://fresh.googlevideo.com/private","mimeType":"video/mp4"}]}}`), nil }, func(ctx context.Context, args []string, _ io.Reader, out, diagnostic io.Writer) error { calls++ if _, ok := ctx.Deadline(); !ok || diagnostic != io.Discard { t.Fatal("unbounded metadata or diagnostics") } joined := strings.Join(args, " ") if strings.Contains(joined, "private=") || strings.Contains(joined, "--insecure") || strings.Contains(joined, "--location") || !strings.Contains(joined, "--proto =https") || !strings.Contains(joined, "--max-filesize 5242880") || !strings.Contains(joined, "--proxy socks5h://127.0.0.1:11080") { t.Fatal("unsafe metadata request") } assertManagedDNSArgs(t, args, "socks5h://127.0.0.1:11080") body, origin := tc.home, "https://www.youtube.com/" if calls == 2 { body, origin = tc.watch, "https://www.youtube.com/watch?v="+cfg.VideoID } if args[len(args)-1] != origin { t.Fatal("unexpected metadata origin") } if tc.pageErr != nil { return tc.pageErr } if calls == 2 && tc.watchErr != nil { return tc.watchErr } _, err := io.WriteString(out, body) return err }) i, err := resources(context.Background()) var fatal *managedRecoveryFatal if calls != tc.calls || (i.images["yt3.ggpht.com"] != "") != tc.avatar || errors.As(err, &fatal) != tc.fatal { t.Fatal("fallback or guard contract", calls, err) } if (err == nil) != tc.avatar || i.images["i.ytimg.com"] == "" || i.media.url == "" || i.resourceErr != nil { t.Fatal("missing avatar masked or partial inventory lost", err) } if err != nil && strings.Contains(err.Error(), "private") { t.Fatal("private metadata leaked") } }) } } func TestManagedAvatarMetadataHealthClassification(t *testing.T) { for _, code := range []avatarMetadataError{"markerAbsent", "jsonInvalid", "noAllowedAvatar"} { failure := &managedResourceFailure{"avatar", "yt3.ggpht.com", code} err := managedResourceHealthError(context.Background(), failure) var missing *managedResourceFailure if !errors.As(err, &missing) || missing.Err != nil { t.Fatal("known metadata absence not normalized", code) } for _, mixed := range []error{ errors.Join(failure, errors.New("owned proxy guard failed")), &managedResourceFailure{"avatar", "yt3.ggpht.com", errors.Join(code, errors.New("collector unavailable"))}, &managedResourceFailure{"avatar", "yt3.ggpht.com", errors.Join(code, context.Canceled)}, } { err := managedResourceHealthError(context.Background(), mixed) if !errors.As(err, &missing) || missing.Err == nil { t.Fatal("mixed safety failure normalized", code) } } } unknown := avatarMetadataError("unknown") err := managedResourceHealthError(context.Background(), &managedResourceFailure{"avatar", "yt3.ggpht.com", unknown}) if !errors.Is(err, unknown) { t.Fatal("unknown parser error normalized") } } func TestManagedAvatarInventoryCancellationNoFallback(t *testing.T) { for _, timing := range []string{"before-player", "after-player", "during-home"} { t.Run(timing, func(t *testing.T) { ctx, cancel := context.WithCancel(context.Background()) defer cancel() if timing == "before-player" { cancel() } players, pages := 0, 0 resources := managedServiceResources(healthConfig{VideoID: "dQw4w9WgXcQ", SOCKSProxy: "socks5h://127.0.0.1:11080"}, func(context.Context) ([]byte, error) { players++ if timing == "after-player" { cancel() } return []byte(`{"playabilityStatus":{"status":"OK"}}`), nil }, func(ctx context.Context, args []string, _ io.Reader, out, _ io.Writer) error { pages++ assertManagedDNSArgs(t, args, "socks5h://127.0.0.1:11080") if args[len(args)-1] != "https://www.youtube.com/" { t.Fatal("watch fallback after cancellation", args) } cancel() _, err := io.WriteString(out, `var ytInitialData = {};`) return err }) i, err := resources(ctx) wantPlayers, wantPages := 1, 0 if timing == "before-player" { wantPlayers = 0 } else if timing == "during-home" { wantPages = 1 } if players != wantPlayers || pages != wantPages || !errors.Is(err, context.Canceled) || i.images["yt3.ggpht.com"] != "" { t.Fatal("cancellation lost or request after cancellation", players, pages, err) } }) } }