Execute the private YouTube qualification plan through core-owned scheduling while retaining worker cleanup, proof sealing and legacy policy boundaries. Preserve unsafe collector failures alongside concurrent cancellation or deadlines. Send bounded Player JSON through stdin instead of argv and update all shared runner callers. Generic controller cutover and remote runtime acceptance remain pending. Co-authored-by: GPT-6 <gpt-6@openai.com>
174 lines
7.6 KiB
Go
174 lines
7.6 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, _ 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)
|
|
}
|
|
})
|
|
}
|
|
}
|