Files
zapret-autotune/cmd/zapret-autotune/discover_test.go
T
2026-10-09 22:11:13 +03:00

183 lines
7.6 KiB
Go

package main
import (
"bytes"
"context"
"encoding/json"
"errors"
"io"
"reflect"
"strings"
"testing"
)
const discoveryFixture = `{"playabilityStatus":{"status":"OK"},"streamingData":{"serverAbrStreamingUrl":"https://rr16---sn-n8v7znsz.googlevideo.com/videoplayback?signature=SECRET"}}`
func discoveryArgs() []string {
return []string{"--video-id", "dQw4w9WgXcQ", "--proxy", "socks5://localhost:1080"}
}
func TestDiscoverYoutubeSuccess(t *testing.T) {
var stdout, stderr bytes.Buffer
called := false
runner := func(ctx context.Context, args []string, out, diagnostics io.Writer) error {
called = true
if _, ok := ctx.Deadline(); !ok {
t.Error("request must have a deadline")
}
prefix := []string{"--disable", "--silent", "--show-error", "--fail", "--max-time", "30", "--noproxy", "", "--proxy", "socks5://localhost:1080", "--user-agent", playerUserAgent, "--json"}
if len(args) != len(prefix)+2 || !reflect.DeepEqual(args[:len(prefix)], prefix) || args[len(args)-1] != playerURL {
t.Fatalf("unexpected curl arguments: %q", args)
}
var payload struct {
VideoID string `json:"videoId"`
Context struct {
Client struct {
ClientName string `json:"clientName"`
ClientVersion string `json:"clientVersion"`
AndroidSDKVersion int `json:"androidSdkVersion"`
UserAgent string `json:"userAgent"`
OSName string `json:"osName"`
OSVersion string `json:"osVersion"`
} `json:"client"`
} `json:"context"`
}
if err := json.Unmarshal([]byte(args[len(prefix)]), &payload); err != nil {
t.Fatal(err)
}
client := payload.Context.Client
if payload.VideoID != "dQw4w9WgXcQ" || client.ClientName != "ANDROID" || client.ClientVersion != "21.02.35" ||
client.AndroidSDKVersion != 30 || client.UserAgent != playerUserAgent || client.OSName != "Android" || client.OSVersion != "11" {
t.Fatal("unexpected player payload")
}
io.WriteString(diagnostics, "SECRET signed URL must not be printed")
_, err := io.WriteString(out, discoveryFixture)
return err
}
if code := discoverYoutube(discoveryArgs(), &stdout, &stderr, runner); code != 0 {
t.Fatalf("code %d: %s", code, &stderr)
}
if !called || stderr.Len() != 0 || stdout.String() != "{\"videoId\":\"dQw4w9WgXcQ\",\"hostnames\":[\"rr16---sn-n8v7znsz.googlevideo.com\"]}\n" {
t.Fatalf("unexpected output: stdout=%q stderr=%q", &stdout, &stderr)
}
}
func TestDiscoverYoutubeInvalidArgs(t *testing.T) {
tests := [][]string{
nil, {"--video-id", "dQw4w9WgXcQ"}, {"--proxy", "socks5://localhost:1080"},
{"--video-id", "short", "--proxy", "socks5://localhost:1080"},
{"--video-id", "dQw4w9WgXc!", "--proxy", "socks5://localhost:1080"},
{"--SECRET", "SECRET"}, append(discoveryArgs(), "SECRET"),
}
for _, proxy := range []string{
"http://localhost:1080", "socks5h://localhost:1080", "socks5://user:SECRET@localhost:1080",
"socks5://:1080", "socks5://localhost", "socks5://localhost:0", "socks5://localhost:65536",
"socks5://localhost:bad", "socks5://localhost:1080/path", "socks5://localhost:1080?SECRET",
"socks5://localhost:1080#SECRET", "socks5://bad_host:1080", "socks5://localhost:1080?",
} {
tests = append(tests, []string{"--video-id", "dQw4w9WgXcQ", "--proxy", proxy})
}
for _, args := range tests {
var stdout, stderr bytes.Buffer
runner := func(context.Context, []string, io.Writer, io.Writer) error {
t.Fatal("invalid arguments must not invoke curl")
return nil
}
if code := discoverYoutube(args, &stdout, &stderr, runner); code != 2 || stdout.Len() != 0 || stderr.Len() == 0 {
t.Errorf("args %q: code=%d stdout=%q stderr=%q", args, code, &stdout, &stderr)
}
if strings.Contains(stderr.String(), "SECRET") || strings.Contains(stderr.String(), "localhost") {
t.Error("argument leaked")
}
}
for _, proxy := range []string{"socks5://localhost:1080", "socks5://127.0.0.1:1080", "socks5://[::1]:1080", "socks5://proxy.example:1080"} {
if !validDiscoveryProxy(proxy) {
t.Errorf("valid proxy rejected: %s", proxy)
}
}
}
func TestPlayerHostnameFailsClosed(t *testing.T) {
fixtures := []string{
`SECRET`, `{} trailing SECRET`, `null`, `{}`, `{"playabilityStatus":{"status":"LOGIN_REQUIRED","reason":"SECRET"}}`,
`{"playabilityStatus":{"status":"OK"}}`, `{"playabilityStatus":{"status":"OK"},"streamingData":null}`,
}
for _, rawURL := range []string{
"", "http://rr.googlevideo.com/?SECRET", "//rr.googlevideo.com/?SECRET", "https://googlevideo.com/?SECRET",
"https://evilgooglevideo.com/?SECRET", "https://rr.googlevideo.com.evil.test/?SECRET",
"https://user:SECRET@rr.googlevideo.com/", "https://rr..googlevideo.com/?SECRET",
"https://-rr.googlevideo.com/?SECRET", "https://rr.googlevideo.com./?SECRET",
"https://rr.googlevideo.com:80/?SECRET", "https://rr.googlevideo.com:/?SECRET", "https://%SECRET",
} {
encoded, _ := json.Marshal(rawURL)
fixtures = append(fixtures, `{"playabilityStatus":{"status":"OK"},"streamingData":{"serverAbrStreamingUrl":`+string(encoded)+`}}`)
}
for _, fixture := range fixtures {
var stdout, stderr bytes.Buffer
runner := func(_ context.Context, _ []string, out, diagnostics io.Writer) error {
io.WriteString(diagnostics, "SECRET")
_, err := io.WriteString(out, fixture)
return err
}
if code := discoverYoutube(discoveryArgs(), &stdout, &stderr, runner); code != 1 || stdout.Len() != 0 || stderr.Len() == 0 {
t.Errorf("fixture %q: code=%d stdout=%q stderr=%q", fixture, code, &stdout, &stderr)
}
if strings.Contains(stderr.String(), "SECRET") || strings.Contains(stderr.String(), "https://") {
t.Error("response leaked")
}
}
upper := strings.Replace(discoveryFixture, "rr16---sn-n8v7znsz.googlevideo.com", "RR16---SN-N8V7ZNSZ.GOOGLEVIDEO.COM:443", 1)
if host, err := playerHostname([]byte(upper)); err != nil || host != "rr16---sn-n8v7znsz.googlevideo.com" {
t.Fatalf("hostname normalization: %q %v", host, err)
}
}
func TestDiscoverYoutubeRequestFailures(t *testing.T) {
for _, mode := range []string{"runner", "stdout limit", "stderr limit", "write result"} {
t.Run(mode, func(t *testing.T) {
var stdout, stderr bytes.Buffer
runner := func(_ context.Context, _ []string, out, diagnostics io.Writer) error {
switch mode {
case "runner":
io.WriteString(out, discoveryFixture)
io.WriteString(diagnostics, "https://signed.example/?SECRET")
return errors.New("SECRET socks5://user:password@localhost:1080")
case "stdout limit":
// Ignore the write error to ensure the command still fails closed.
out.Write(bytes.Repeat([]byte("S"), playerResponseLimit+1))
case "stderr limit":
diagnostics.Write(bytes.Repeat([]byte("S"), (64<<10)+1))
}
_, err := io.WriteString(out, discoveryFixture)
return err
}
var dest io.Writer = &stdout
if mode == "write result" {
dest = failingWriter{}
}
if code := discoverYoutube(discoveryArgs(), dest, &stderr, runner); code != 1 || stdout.Len() != 0 || stderr.Len() == 0 {
t.Fatalf("code=%d stdout=%q stderr=%q", code, &stdout, &stderr)
}
for _, forbidden := range []string{"SECRET", "https://", "password", "localhost"} {
if strings.Contains(stderr.String(), forbidden) {
t.Errorf("leaked %s", forbidden)
}
}
})
}
}
func TestPlayerOutputBound(t *testing.T) {
var dst bytes.Buffer
w := &playerBoundedWriter{dst: &dst, limit: 4}
if n, err := w.Write([]byte("1234")); n != 4 || err != nil {
t.Fatal("exact limit must be accepted")
}
if n, err := w.Write([]byte("5")); n != 0 || err == nil || !w.exceeded || dst.String() != "1234" {
t.Fatal("overflow must not be retained")
}
if _, err := playerHostname(bytes.Repeat([]byte(" "), playerResponseLimit+1)); err == nil {
t.Fatal("oversized parser input accepted")
}
}