Files
zapret-autotune/cmd/zapret-autotune/assets_test.go
T
ZeusinaandGPT-6 Bot e270810f33 refactor: execute adapter plans through shared core
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>
2026-10-15 17:25:12 +03:00

318 lines
12 KiB
Go

package main
import (
"bytes"
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"image"
"image/png"
"io"
"os"
"path/filepath"
"reflect"
"strings"
"testing"
"time"
)
// Recreate an actual pre-assets schema, not just a misleading version number.
func restoreV5CandidateSchema(t *testing.T, db *sql.DB) {
t.Helper()
tx, err := db.Begin()
if err != nil {
t.Fatal(err)
}
defer tx.Rollback()
_, err = tx.Exec(`CREATE TEMP TABLE old_candidates AS SELECT id, source_run_id, strategy_group, endpoints, args, fingerprint FROM strategy_candidates;
CREATE TEMP TABLE old_evidence AS SELECT * FROM candidate_evidence;
DROP TABLE googlevideo_scope_evidence;
DROP TABLE candidate_evidence; DROP TABLE strategy_candidates;` + candidateSchema + `
INSERT INTO strategy_candidates SELECT * FROM old_candidates;
INSERT INTO candidate_evidence SELECT * FROM old_evidence;
DROP TABLE old_candidates; DROP TABLE old_evidence;
PRAGMA user_version = 5;`)
if err != nil {
t.Fatal(err)
}
if err := tx.Commit(); err != nil {
t.Fatal(err)
}
}
// Synthetic unit fixture only: no claim that any endpoint was reachable.
func unitImageMeasurement(t *testing.T, host, protocol, args string) assetMeasurement {
t.Helper()
var body bytes.Buffer
if err := png.Encode(&body, image.NewRGBA(image.Rect(0, 0, 1, 1))); err != nil {
t.Fatal(err)
}
v := uint16(0x0303)
if protocol == "tls13" {
v = 0x0304
}
m := assetMeasurement{Source: "image-transfer", Endpoint: host, Protocol: protocol, Args: args}
for i := 0; i < 3; i++ {
zero := 0
m.Transfers = append(m.Transfers, assetTransfer{EffectiveHost: host, SSLVerifyResult: &zero, ContentType: "image/png", TLSVersion: v, Status: 200, Body: body.Bytes(), LatencyMS: 10, SpeedKBPS: 100})
}
return m
}
func unitAssetCandidate(t *testing.T, db *sql.DB, host, args string, qualify bool) int64 {
t.Helper()
tx, err := db.Begin()
if err != nil {
t.Fatal(err)
}
defer tx.Rollback()
id, err := insertStrategyCandidate(tx, "assets", []string{host}, args, nil)
if err != nil {
t.Fatal(err)
}
if qualify {
for _, protocol := range []string{"tls12", "tls13"} {
if err := saveAssetEvidence(tx, id, unitImageMeasurement(t, host, protocol, args), time.Now()); err != nil {
t.Fatal(err)
}
}
}
if err := tx.Commit(); err != nil {
t.Fatal(err)
}
return id
}
func TestAssetMigrationLegacyBytesAndRollback(t *testing.T) {
db := testStore(t)
saveProposal(t, db, "--lua-desync=fake")
restoreV5CandidateSchema(t, db)
before, err := readStrategyCandidate(db, 1)
if err != nil {
t.Fatal(err)
}
config, err := renderManagedConfig(db, []int64{1})
if err != nil {
t.Fatal(err)
}
var evidence string
if err := db.QueryRow(`SELECT group_concat(raw_measurement) FROM candidate_evidence`).Scan(&evidence); err != nil {
t.Fatal(err)
}
if err := migrate(db); err != nil {
t.Fatal(err)
}
after, err := readStrategyCandidate(db, 1)
if err != nil || !reflect.DeepEqual(before, after) {
t.Fatalf("changed candidate: %+v %v", after, err)
}
rendered, err := renderManagedConfig(db, []int64{1})
if err != nil || !bytes.Equal(config, rendered) || managedHash(config) != managedHash(rendered) {
t.Fatalf("legacy bytes changed: %v", err)
}
var afterEvidence string
if err := db.QueryRow(`SELECT group_concat(raw_measurement) FROM candidate_evidence`).Scan(&afterEvidence); err != nil || evidence != afterEvidence {
t.Fatalf("evidence changed: %v", err)
}
if _, err := db.Exec(`UPDATE strategy_candidates SET args = '--lua-desync=multisplit'`); err == nil {
t.Fatal("immutable trigger lost")
}
restoreV5CandidateSchema(t, db)
// A foreign reference forces failure after the migration starts rebuilding.
if _, err := db.Exec(`CREATE TABLE candidate_external_ref (id INTEGER REFERENCES strategy_candidates(id)); INSERT INTO candidate_external_ref VALUES (1);`); err != nil {
t.Fatal(err)
}
if err := migrate(db); err == nil {
t.Fatal("expected atomic migration failure")
}
var version int
if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 5 {
t.Fatalf("version=%d %v", version, err)
}
rendered, err = renderManagedConfig(db, []int64{1})
if err != nil || !bytes.Equal(config, rendered) {
t.Fatalf("rollback lost legacy bytes: %v", err)
}
if _, err := db.Exec(`DROP TABLE candidate_external_ref; CREATE TRIGGER custom_candidate BEFORE INSERT ON strategy_candidates BEGIN SELECT 1; END;`); err != nil {
t.Fatal(err)
}
if err := migrate(db); err == nil {
t.Fatal("unknown schema silently adopted")
}
}
func TestAssetEvidenceAndDisjointRender(t *testing.T) {
db := testStore(t)
a := unitAssetCandidate(t, db, "i.ytimg.com", "--lua-desync=fake", true)
b := unitAssetCandidate(t, db, "yt3.ggpht.com", "--lua-desync=multisplit", true)
config, err := renderManagedConfig(db, []int64{a, b})
if err != nil || !strings.Contains(string(config), "--hostlist-domains=^i.ytimg.com --lua-desync=fake --new") || !strings.Contains(string(config), "--hostlist-domains=^yt3.ggpht.com --lua-desync=multisplit") {
t.Fatalf("render: %s %v", config, err)
}
ids, err := qualifiedCandidateIDs(db, "assets")
if err != nil || !reflect.DeepEqual(ids, []int64{b, a}) {
t.Fatalf("IDs %v %v", ids, err)
}
if _, err := db.Exec(`UPDATE candidate_evidence SET checked_at = 'fixture' WHERE candidate_id = ? AND protocol = 'tls12'`, a); err != nil {
t.Fatal(err)
}
if _, err := renderManagedConfig(db, []int64{a}); err == nil {
t.Fatal("invalid checked timestamp qualified")
}
if _, err := db.Exec(`UPDATE candidate_evidence SET checked_at = ? WHERE candidate_id = ? AND protocol = 'tls12'`, time.Now().UTC().Format(time.RFC3339Nano), a); err != nil {
t.Fatal(err)
}
overlap := unitAssetCandidate(t, db, "i.ytimg.com", "--lua-desync=multisplit", true)
if _, err := renderManagedConfig(db, []int64{a, overlap}); err == nil {
t.Fatal("accepted overlap")
}
missing := unitAssetCandidate(t, db, "yt3.ggpht.com", "--lua-desync=fake", false)
if _, err := renderManagedConfig(db, []int64{a, missing}); err == nil {
t.Fatal("accepted missing evidence")
}
tx, err := db.Begin()
if err != nil {
t.Fatal(err)
}
defer tx.Rollback()
for _, host := range []string{"ytimg.com", "other.ytimg.com", "*.ytimg.com", "youtube.com"} {
if _, err := insertStrategyCandidate(tx, "assets", []string{host}, "--lua-desync=fake", nil); err == nil {
t.Fatalf("accepted %s", host)
}
}
if err := saveCandidateEvidence(tx, missing, "yt3.ggpht.com", "tls12", []byte(`{}`), time.Now()); err == nil {
t.Fatal("accepted blockcheck for assets")
}
for _, damage := range []string{"status", "magic", "tls", "count", "source", "scope"} {
m := unitImageMeasurement(t, "yt3.ggpht.com", "tls12", "--lua-desync=fake")
switch damage {
case "status":
m.Transfers[0].Status = 400
case "magic":
m.Transfers[0].Body = []byte("not an image")
case "tls":
m.Transfers[0].TLSVersion = 0x0304
case "count":
m.Transfers = m.Transfers[:2]
case "source":
m.Source = "blockcheck"
case "scope":
m.Endpoint = "i.ytimg.com"
}
if err := saveAssetEvidence(tx, missing, m, time.Now()); err == nil {
t.Fatalf("accepted %s", damage)
}
}
tx.Rollback()
m := unitImageMeasurement(t, "yt3.ggpht.com", "tls13", "--lua-desync=multisplit")
m.Transfers[0].Status = 400
raw, _ := json.Marshal(m)
if _, err := db.Exec(`UPDATE candidate_evidence SET raw_measurement = ? WHERE candidate_id = ? AND protocol = 'tls13'`, string(raw), b); err != nil {
t.Fatal(err)
}
if _, err := renderManagedConfig(db, []int64{b}); err == nil {
t.Fatal("corrupt HTTP400 evidence qualified")
}
if _, err := db.Exec("PRAGMA user_version = 8"); err != nil {
t.Fatal(err)
}
if _, err := renderManagedConfig(db, []int64{a}); err == nil {
t.Fatal("unknown schema rendered")
}
}
func TestAssetCLIApplyPartialFailureAndStatus(t *testing.T) {
for _, fail := range []bool{false, true} {
t.Run(fmt.Sprint(fail), func(t *testing.T) {
d, env, _ := managedCLIFixture(t)
env["ZAPRET_AUTOTUNE_VIDEO_ID"] = "dQw4w9WgXcQ"
path := filepath.Join(t.TempDir(), "assets.db")
db, err := openStore(path)
if err != nil {
t.Fatal(err)
}
saveProposal(t, db, "--lua-desync=fake")
tx, err := db.Begin()
if err != nil {
t.Fatal(err)
}
ggc, err := insertStrategyCandidate(tx, "googlevideo", []string{"rr1.unit.googlevideo.com"}, "--lua-desync=fake", nil)
if err != nil {
tx.Rollback()
t.Fatal(err)
}
var report struct {
Strategies []json.RawMessage `json:"strategies"`
}
if err := json.Unmarshal([]byte(combinedReportFixture("--lua-desync=fake")), &report); err != nil {
tx.Rollback()
t.Fatal(err)
}
for i, protocol := range []string{"tls12", "tls13"} {
if err := saveCandidateEvidence(tx, ggc, "rr1.unit.googlevideo.com", protocol, report.Strategies[i], time.Now()); err != nil {
tx.Rollback()
t.Fatal(err)
}
}
if err := tx.Commit(); err != nil {
t.Fatal(err)
}
a := unitAssetCandidate(t, db, "i.ytimg.com", "--lua-desync=fake", true)
b := unitAssetCandidate(t, db, "yt3.ggpht.com", "--lua-desync=multisplit", true)
db.Close()
d.openDB = func() (*sql.DB, error) { return openHistoryStore(path) }
initManagedCLI(t, d)
if code, out, diagnostic := callManaged(t, d, "status"); code != 0 || strings.Contains(out, "assets") {
t.Fatalf("legacy status: %s %s", out, diagnostic)
}
if code, out, diagnostic := callManaged(t, d, "status", "--assets"); code != 0 || !strings.Contains(out, "unresolved_groups=frontend,googlevideo,assets") {
t.Fatalf("requested status: %s %s", out, diagnostic)
}
if fail {
d.player = func(context.Context, []string, io.Reader, io.Writer, io.Writer) error {
return errors.New("unit health failure")
}
}
code, _, diagnostic := callManaged(t, d, "apply", "--asset-candidate", fmt.Sprintf("%d,%d", a, b))
if (code != 0) != fail {
t.Fatalf("apply=%d %s", code, diagnostic)
}
config, err := os.ReadFile(filepath.Join(d.directory, "config"))
if err != nil {
t.Fatal(err)
}
if fail && string(config) != managedBaseline {
t.Fatal("failure did not restore baseline")
}
if !fail {
if code, out, diagnostic := callManaged(t, d, "status"); code != 0 || !strings.Contains(out, "groups=assets") || strings.Contains(out, "unresolved_groups=frontend,googlevideo,assets") {
t.Fatalf("asset status: %s %s", out, diagnostic)
}
if code, _, diagnostic := callManaged(t, d, "apply", "--asset-candidate", fmt.Sprint(a)); code != 0 {
t.Fatalf("partial apply: %s", diagnostic)
}
if code, out, diagnostic := callManaged(t, d, "status"); code != 0 || !strings.Contains(out, "unresolved_groups=frontend,googlevideo,assets") {
t.Fatalf("partial status: %s %s", out, diagnostic)
}
if code, _, diagnostic := callManaged(t, d, "apply", "--frontend-candidate", "1", "--googlevideo-candidate", fmt.Sprint(ggc), "--asset-candidate", fmt.Sprint(a), "--asset-candidate", fmt.Sprint(b)); code != 0 {
t.Fatalf("four candidate apply: %s", diagnostic)
}
if code, out, diagnostic := callManaged(t, d, "active-ids"); code != 0 || !strings.Contains(out, fmt.Sprintf(`"active_candidate_ids":[1,%d,%d,%d]`, ggc, a, b)) || !strings.Contains(out, `"unresolved_groups":null`) {
t.Fatalf("four IDs: %s %s", out, diagnostic)
}
}
})
}
for _, args := range [][]string{{"apply", "--asset-candidate", "1,1"}, {"apply", "--asset-candidate", "1,"}, {"apply", "--asset-candidate", "1,2,3"}, {"apply", "--frontend-candidate", "1,2"}, {"apply", "--frontend-candidate", "1", "--asset-candidate", "1"}} {
if _, _, err := managedArguments(args); err == nil {
t.Fatalf("accepted %v", args)
}
}
_, ids, err := managedArguments([]string{"apply", "--asset-candidate", "3", "--googlevideo-candidate", "2", "--asset-candidate", "4", "--frontend-candidate", "1"})
if err != nil || !reflect.DeepEqual(ids, []int64{1, 2, 3, 4}) {
t.Fatalf("IDs %v %v", ids, err)
}
}