316 lines
12 KiB
Go
316 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.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)
|
|
}
|
|
}
|