Canonicalize validated managed proxy schemes to socks5h for Player, metadata, resource and warmup probes; retain listener ownership, TLS/privacy checks and legacy CLI/pinned checker semantics. Stop canceled inventory requests before Player and metadata fallback, with explicit cancellation and runner-only DNS regressions. Verification: full native Go tests, affected race tests, go vet and static/config/supervision fixtures passed. An extra whole-package race attempt exceeded its 180s deadline in unrelated TestTuneCLI; affected race coverage completed separately. Co-authored-by: GPT-6 <gpt-6@openai.com>
174 lines
7.5 KiB
Go
174 lines
7.5 KiB
Go
package main
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"os/exec"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func TestAvatarPageClassification(t *testing.T) {
|
|
for _, tc := range []struct{ body, code string }{
|
|
{`<html></html>`, "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: `<html></html>`, 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, 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, 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)
|
|
}
|
|
})
|
|
}
|
|
}
|