Files
zapret-autotune/cmd/zapret-autotune/managed_avatar_inventory_test.go
T
ZeusinaandGPT-6 Bot 1afee7d3bd fix: resolve managed probes through owned SS DNS
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>
2026-10-12 22:28:13 +03:00

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)
}
})
}
}