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>
612 lines
23 KiB
Go
612 lines
23 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"database/sql"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func managedCLIFixture(t *testing.T) (managedDeps, map[string]string, *int) {
|
|
t.Helper()
|
|
root := t.TempDir()
|
|
env := map[string]string{
|
|
"ZAPRET_AUTOTUNE_TARGET_ROLE": "managed-test", "ZAPRET_AUTOTUNE_TARGET_ID": managedTargetID,
|
|
"ZAPRET_AUTOTUNE_TARGET_DIR": managedTargetDirectory, "ZAPRET_CONFIG": managedTargetConfig,
|
|
"SOCKS_PORT": "11080", "ZAPRET_AUTOTUNE_SOCKS_PROXY": "socks5://127.0.0.1:11080",
|
|
}
|
|
calls := new(int)
|
|
d := managedDeps{
|
|
lookup: func(key string) (string, bool) { value, ok := env[key]; return value, ok },
|
|
script: filepath.Join(root, "zapret2"), directory: filepath.Join(root, "target"),
|
|
verifyRuntime: func(dir string) error {
|
|
if dir != managedTargetDirectory {
|
|
return errors.New("wrong runtime directory")
|
|
}
|
|
return nil
|
|
},
|
|
verifySOCKS: func(port int) error {
|
|
if port != 11080 {
|
|
return errors.New("wrong ss-local port")
|
|
}
|
|
return nil
|
|
},
|
|
run: func(path string, args ...string) error {
|
|
*calls++
|
|
if path != filepath.Join(root, "zapret2") || !reflect.DeepEqual(args, []string{"restart"}) {
|
|
t.Fatalf("unexpected executable/argv: %q %q", path, args)
|
|
}
|
|
return nil
|
|
},
|
|
player: func(_ context.Context, args []string, _ io.Reader, stdout, _ io.Writer) error {
|
|
if !strings.Contains(strings.Join(args, "|"), "--noproxy||--proxy|socks5h://127.0.0.1:11080|") {
|
|
t.Fatalf("unsafe health argv: %q", args)
|
|
}
|
|
_, err := io.WriteString(stdout, `{"playabilityStatus":{"status":"OK"}}`)
|
|
return err
|
|
},
|
|
openDB: func() (*sql.DB, error) { t.Fatal("unexpected DB access"); return nil, nil },
|
|
}
|
|
if err := os.WriteFile(d.script, []byte("not executed"), 0700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Mkdir(d.directory, 0700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return d, env, calls
|
|
}
|
|
|
|
func callManaged(t *testing.T, d managedDeps, args ...string) (int, string, string) {
|
|
t.Helper()
|
|
var out, diagnostic bytes.Buffer
|
|
code := managedCLI(args, &out, &diagnostic, d)
|
|
return code, out.String(), diagnostic.String()
|
|
}
|
|
|
|
func initManagedCLI(t *testing.T, d managedDeps) {
|
|
t.Helper()
|
|
if code, _, diagnostic := callManaged(t, d, "init"); code != 0 {
|
|
t.Fatalf("init: %d %s", code, diagnostic)
|
|
}
|
|
b, err := os.ReadFile(filepath.Join(d.directory, "config"))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
assertManagedFirewallConfig(t, string(b), "0")
|
|
if !strings.Contains(string(b), "\nNFQWS2_OPT=''\n") {
|
|
t.Fatal("baseline strategy is not disabled")
|
|
}
|
|
}
|
|
|
|
func TestManagedCLIArguments(t *testing.T) {
|
|
for _, args := range [][]string{nil, {"unknown"}, {"init", "--dir", "/etc"}, {"status", "extra"}, {"apply"}, {"apply", "--frontend-candidate", "1", "--frontend-candidate", "2"}, {"apply", "--frontend-candidate", "1", "--googlevideo-candidate", "1"}, {"apply", "--frontend-candidate", "-1", "--googlevideo-candidate", "2"}, {"apply", "--frontend-candidate", "1;id", "--googlevideo-candidate", "2"}, {"apply", "--frontend-candidate", "9223372036854775808", "--googlevideo-candidate", "2"}, {"apply", "--frontend-candidate", "0", "--googlevideo-candidate", "2"}} {
|
|
d, _, calls := managedCLIFixture(t)
|
|
if code, _, _ := callManaged(t, d, args...); code != 2 || *calls != 0 {
|
|
t.Fatalf("accepted %q", args)
|
|
}
|
|
}
|
|
command, ids, err := managedArguments([]string{"apply", "--googlevideo-candidate", "2", "--frontend-candidate", "1"})
|
|
if err != nil || command != "apply" || !reflect.DeepEqual(ids, []int64{1, 2}) {
|
|
t.Fatalf("%s %v %v", command, ids, err)
|
|
}
|
|
// Exercise the actual top-level dispatch without a runner or network call.
|
|
t.Setenv("ZAPRET_AUTOTUNE_TARGET_ROLE", "old-container")
|
|
var out, diagnostic bytes.Buffer
|
|
if code := run([]string{"managed", "status"}, &out, &diagnostic); code != 2 || !strings.Contains(diagnostic.String(), "TARGET_ROLE") {
|
|
t.Fatalf("dispatch: %d %s", code, diagnostic.String())
|
|
}
|
|
}
|
|
|
|
func TestManagedProductionRestartExecutable(t *testing.T) {
|
|
d := managedDependencies(nil)
|
|
if d.script != "/opt/zapret2/init.d/sysv/zapret2" {
|
|
t.Fatalf("unexpected production restart executable: %q", d.script)
|
|
}
|
|
}
|
|
|
|
func TestManagedCLIRoleAndDirectoryGuards(t *testing.T) {
|
|
for _, role := range []string{"", "dev", "managed-test ", "old-container"} {
|
|
d, env, _ := managedCLIFixture(t)
|
|
env["ZAPRET_AUTOTUNE_TARGET_ROLE"] = role
|
|
if code, _, _ := callManaged(t, d, "init"); code != 2 {
|
|
t.Fatalf("accepted role %q", role)
|
|
}
|
|
if entries, err := os.ReadDir(d.directory); err != nil || len(entries) != 0 {
|
|
t.Fatal("guard wrote target directory")
|
|
}
|
|
}
|
|
for _, path := range []string{"", "relative", "/", "/tmp/../etc"} {
|
|
d, env, _ := managedCLIFixture(t)
|
|
env["ZAPRET_AUTOTUNE_TARGET_DIR"] = path
|
|
if code, _, _ := callManaged(t, d, "init"); code == 0 {
|
|
t.Fatalf("accepted path %q", path)
|
|
}
|
|
}
|
|
for _, mode := range []string{"symlink", "public", "ancestor"} {
|
|
d, env, _ := managedCLIFixture(t)
|
|
dir := d.directory
|
|
var err error
|
|
if mode == "public" {
|
|
err = os.Chmod(dir, 0755)
|
|
} else {
|
|
if err := os.Remove(dir); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
err = os.Symlink(t.TempDir(), dir)
|
|
if mode == "ancestor" {
|
|
env["ZAPRET_AUTOTUNE_TARGET_DIR"] = filepath.Join(dir, "nested")
|
|
}
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if code, _, _ := callManaged(t, d, "init"); code == 0 {
|
|
t.Fatalf("accepted %s", mode)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestManagedCLIInitNonOverwrite(t *testing.T) {
|
|
d, _, calls := managedCLIFixture(t)
|
|
dir := d.directory
|
|
path := filepath.Join(dir, "config")
|
|
secret := "EXISTING_SECRET='do not overwrite'\n"
|
|
if err := os.WriteFile(path, []byte(secret), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if code, _, _ := callManaged(t, d, "init"); code == 0 {
|
|
t.Fatal("adopted non-baseline config")
|
|
}
|
|
b, err := os.ReadFile(path)
|
|
if err != nil || string(b) != secret || *calls != 0 {
|
|
t.Fatalf("config=%q err=%v", b, err)
|
|
}
|
|
if err := os.WriteFile(path, []byte(managedBaseline), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
initManagedCLI(t, d)
|
|
if code, _, _ := callManaged(t, d, "init"); code == 0 {
|
|
t.Fatal("reinitialized identity")
|
|
}
|
|
if code, out, diagnostic := callManaged(t, d, "status"); code != 0 || !strings.Contains(out, "generation=0") || !strings.Contains(out, "none (disabled)") {
|
|
t.Fatalf("status %d %s %s", code, out, diagnostic)
|
|
}
|
|
if *calls != 0 {
|
|
t.Fatal("init/status reloaded")
|
|
}
|
|
}
|
|
|
|
func TestManagedCLIApplyAndRollback(t *testing.T) {
|
|
for _, mode := range []string{"success", "health", "reload", "unqualified", "wrong-group", "missing-id", "missing-script", "wrong-binding", "bad-proxy", "missing-marker", "drift"} {
|
|
t.Run(mode, func(t *testing.T) {
|
|
d, env, calls := managedCLIFixture(t)
|
|
initManagedCLI(t, d)
|
|
db := testStore(t)
|
|
front := managedCandidateFixture(t, db, "frontend", "youtube.com", "--lua-desync=fake", mode != "unqualified")
|
|
ggc := managedCandidateFixture(t, db, "googlevideo", "rr1.googlevideo.com", "--lua-desync=multisplit", true)
|
|
d.openDB = func() (*sql.DB, error) { return db, nil }
|
|
config := filepath.Join(d.directory, "config")
|
|
fixedRestart := d.run
|
|
d.run = func(path string, args ...string) error {
|
|
if err := fixedRestart(path, args...); err != nil {
|
|
return err
|
|
}
|
|
b, err := os.ReadFile(config)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if *calls == 1 {
|
|
assertManagedFirewallConfig(t, string(b), "1")
|
|
} else if string(b) != managedBaseline {
|
|
t.Fatalf("rollback restart did not load disabled baseline: %s", b)
|
|
}
|
|
return nil
|
|
}
|
|
switch mode {
|
|
case "health":
|
|
d.player = func(_ context.Context, _ []string, _ io.Reader, stdout, _ io.Writer) error {
|
|
_, err := io.WriteString(stdout, `{"playabilityStatus":{"status":"ERROR","secret":"do-not-print"}}`)
|
|
return err
|
|
}
|
|
case "reload":
|
|
fixed := d.run
|
|
d.run = func(path string, args ...string) error {
|
|
if err := fixed(path, args...); err != nil {
|
|
return err
|
|
}
|
|
if *calls == 1 {
|
|
return errors.New("reload failed")
|
|
}
|
|
return nil
|
|
}
|
|
case "wrong-group":
|
|
front, ggc = ggc, front
|
|
case "missing-id":
|
|
front = 999999
|
|
case "missing-script":
|
|
if err := os.Remove(d.script); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
case "wrong-binding":
|
|
env["ZAPRET_CONFIG"] = "/opt/zapret2/config"
|
|
case "bad-proxy":
|
|
env["ZAPRET_AUTOTUNE_SOCKS_PROXY"] = "socks5://192.0.2.1:1080"
|
|
case "missing-marker":
|
|
if err := os.Remove(filepath.Join(d.directory, managedMarkerName)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
case "drift":
|
|
if err := os.WriteFile(config, []byte("EXTERNAL_SECRET=private\n"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
code, out, diagnostic := callManaged(t, d, "apply", "--frontend-candidate", fmt.Sprint(front), "--googlevideo-candidate", fmt.Sprint(ggc))
|
|
if (mode == "success") != (code == 0) {
|
|
t.Fatalf("apply: %d %s %s", code, out, diagnostic)
|
|
}
|
|
if strings.Contains(out+diagnostic, "do-not-print") || strings.Contains(out+diagnostic, "EXTERNAL_SECRET") {
|
|
t.Fatal("leaked config/response")
|
|
}
|
|
b, err := os.ReadFile(config)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
wantCalls := 0
|
|
if mode == "success" {
|
|
wantCalls = 1
|
|
assertManagedFirewallConfig(t, string(b), "1")
|
|
if !strings.Contains(string(b), "--hostlist-domains=^rr1.googlevideo.com") {
|
|
t.Fatalf("wrong applied scope: %s", b)
|
|
}
|
|
d.openDB = func() (*sql.DB, error) { return openHistoryStore(databasePath()) }
|
|
code, out, diagnostic = callManaged(t, d, "status")
|
|
if code != 0 || !strings.Contains(out, "generation=1") || !strings.Contains(out, "groups=frontend,googlevideo") || strings.Contains(out, "lua-desync") || strings.Contains(out, "rr1") {
|
|
t.Fatalf("status: %d %s %s", code, out, diagnostic)
|
|
}
|
|
} else if mode == "drift" {
|
|
if string(b) != "EXTERNAL_SECRET=private\n" {
|
|
t.Fatal("drift overwritten")
|
|
}
|
|
} else {
|
|
if string(b) != managedBaseline {
|
|
t.Fatalf("baseline not restored: %s", b)
|
|
}
|
|
if mode == "health" || mode == "reload" {
|
|
wantCalls = 2
|
|
}
|
|
}
|
|
if *calls != wantCalls {
|
|
t.Fatalf("reloads=%d want=%d", *calls, wantCalls)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestManagedCLIIdentityAndStatusRedaction(t *testing.T) {
|
|
for _, mode := range []string{"identity", "symlink", "hardlink", "journal", "drift"} {
|
|
t.Run(mode, func(t *testing.T) {
|
|
d, _, calls := managedCLIFixture(t)
|
|
initManagedCLI(t, d)
|
|
dir := d.directory
|
|
path := filepath.Join(dir, managedMarkerName)
|
|
switch mode {
|
|
case "identity":
|
|
if err := os.WriteFile(path, []byte(`{"Role":"dev","Directory":"secret"}`), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
case "symlink", "hardlink":
|
|
outside := filepath.Join(t.TempDir(), "outside")
|
|
if err := os.Rename(path, outside); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var err error
|
|
if mode == "symlink" {
|
|
err = os.Symlink(outside, path)
|
|
} else {
|
|
err = os.Link(outside, path)
|
|
}
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if mode == "hardlink" {
|
|
if err := os.Link(outside, outside+"-second"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
case "journal":
|
|
if err := os.Remove(filepath.Join(dir, managedJournalName)); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
case "drift":
|
|
if err := os.WriteFile(filepath.Join(dir, "config"), []byte("PASSWORD=secret\n"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
code, out, diagnostic := callManaged(t, d, "status")
|
|
if code == 0 || strings.Contains(out+diagnostic, "secret") || *calls != 0 {
|
|
t.Fatalf("status: %d %s %s", code, out, diagnostic)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestManagedCLIFreshTargetContract(t *testing.T) {
|
|
for _, mode := range []string{"wrong-id", "missing-id", "old-env", "other-directory", "old-config", "other-config", "non-mountpoint", "missing-base-runtime", "wrong-port", "other-loopback", "wrong-process", "missing-proxy", "missing-port"} {
|
|
for _, command := range []string{"init", "reconcile", "status", "apply"} {
|
|
t.Run(mode+"/"+command, func(t *testing.T) {
|
|
d, env, calls := managedCLIFixture(t)
|
|
if command != "init" {
|
|
initManagedCLI(t, d)
|
|
}
|
|
switch mode {
|
|
case "wrong-id":
|
|
env["ZAPRET_AUTOTUNE_TARGET_ID"] = "another-target"
|
|
case "missing-id":
|
|
delete(env, "ZAPRET_AUTOTUNE_TARGET_ID")
|
|
case "old-env":
|
|
// A role and a self-created directory/identity alone cannot pass.
|
|
delete(env, "ZAPRET_AUTOTUNE_TARGET_ID")
|
|
delete(env, "ZAPRET_CONFIG")
|
|
delete(env, "SOCKS_PORT")
|
|
case "other-directory":
|
|
env["ZAPRET_AUTOTUNE_TARGET_DIR"] = d.directory
|
|
case "old-config":
|
|
env["ZAPRET_CONFIG"] = "/opt/zapret2/config"
|
|
case "other-config":
|
|
env["ZAPRET_CONFIG"] = "/etc/config"
|
|
case "non-mountpoint", "missing-base-runtime":
|
|
d.verifyRuntime = func(string) error { return errors.New(mode) }
|
|
case "wrong-port":
|
|
env["SOCKS_PORT"] = "1080"
|
|
case "other-loopback":
|
|
env["ZAPRET_AUTOTUNE_SOCKS_PROXY"] = "socks5://127.0.0.1:1080"
|
|
case "wrong-process":
|
|
d.verifySOCKS = func(int) error { return errors.New("listener belongs to another process") }
|
|
case "missing-proxy":
|
|
delete(env, "ZAPRET_AUTOTUNE_SOCKS_PROXY")
|
|
case "missing-port":
|
|
delete(env, "SOCKS_PORT")
|
|
}
|
|
args := []string{command}
|
|
if command == "apply" {
|
|
args = append(args, "--frontend-candidate", "1", "--googlevideo-candidate", "2")
|
|
}
|
|
if code, _, _ := callManaged(t, d, args...); code == 0 || *calls != 0 {
|
|
t.Fatal("unsafe target contract accepted or reloaded")
|
|
}
|
|
if command == "reconcile" {
|
|
if _, err := os.Lstat(filepath.Join(d.directory, "candidates.db")); !errors.Is(err, os.ErrNotExist) {
|
|
t.Fatal("runtime guard opened database", err)
|
|
}
|
|
}
|
|
if command == "init" {
|
|
entries, err := os.ReadDir(d.directory)
|
|
if err != nil || len(entries) != 0 {
|
|
t.Fatal("refused init modified target")
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestManagedCLIStagedProfiles(t *testing.T) {
|
|
for _, group := range []string{"frontend", "googlevideo"} {
|
|
t.Run(group, func(t *testing.T) {
|
|
d, _, calls := managedCLIFixture(t)
|
|
initManagedCLI(t, d)
|
|
db := testStore(t)
|
|
front := managedCandidateFixture(t, db, "frontend", "youtube.com", "--lua-desync=fake", true)
|
|
ggc := managedCandidateFixture(t, db, "googlevideo", "rr1.googlevideo.com", "--lua-desync=fake", true)
|
|
id, missing := front, "googlevideo"
|
|
if group == "googlevideo" {
|
|
id, missing = ggc, "frontend"
|
|
}
|
|
d.openDB = func() (*sql.DB, error) { return openHistoryStore(databasePath()) }
|
|
if code, out, diagnostic := callManaged(t, d, "apply", "--"+group+"-candidate", fmt.Sprint(id)); code != 0 {
|
|
t.Fatalf("single group apply: %d %s %s", code, out, diagnostic)
|
|
}
|
|
if code, out, diagnostic := callManaged(t, d, "status"); code != 0 || !strings.Contains(out, "groups="+group+" ") || !strings.Contains(out, "unresolved_groups="+missing) || !strings.Contains(out, "NOT CHECKED") {
|
|
t.Fatalf("partial status: %d %s %s", code, out, diagnostic)
|
|
}
|
|
code, out, diagnostic := callManaged(t, d, "active-ids")
|
|
var state struct {
|
|
IDs []int64 `json:"active_candidate_ids"`
|
|
Missing []string `json:"unresolved_groups"`
|
|
}
|
|
if code != 0 || json.Unmarshal([]byte(out), &state) != nil || !reflect.DeepEqual(state.IDs, []int64{id}) || !reflect.DeepEqual(state.Missing, []string{missing}) || *calls != 1 {
|
|
t.Fatalf("active IDs: %d %s %s", code, out, diagnostic)
|
|
}
|
|
if _, err := db.Exec("DELETE FROM candidate_evidence WHERE candidate_id = ?", id); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if code, out, diagnostic := callManaged(t, d, "status"); code != 0 || !strings.Contains(out, "groups=unknown ") || !strings.Contains(out, "active_candidate_ids=[] ") || !strings.Contains(out, "unresolved_groups=frontend,googlevideo") {
|
|
t.Fatalf("invalid DB status: %d %s %s", code, out, diagnostic)
|
|
}
|
|
if code, out, diagnostic := callManaged(t, d, "active-ids"); code == 0 || out != "" || !strings.Contains(diagnostic, "active candidate IDs unresolved") || *calls != 1 {
|
|
t.Fatalf("invalid DB IDs trusted: %d %s %s", code, out, diagnostic)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestManagedCLILegacyIDsUnresolved(t *testing.T) {
|
|
d, _, calls := managedCLIFixture(t)
|
|
initManagedCLI(t, d)
|
|
m := &managedTransaction{Dir: d.directory, Name: "config", Reload: func() error { return nil }, Health: func() (string, error) { return "OK", nil }}
|
|
j, err := m.load()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
j.Version = 1
|
|
if err := m.journal(j); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if code, out, diagnostic := callManaged(t, d, "status"); code != 0 || !strings.Contains(out, "groups=unknown") || !strings.Contains(out, "unresolved_groups=frontend,googlevideo") {
|
|
t.Fatalf("legacy status: %d %s %s", code, out, diagnostic)
|
|
}
|
|
if code, out, _ := callManaged(t, d, "active-ids"); code == 0 || out != "" || *calls != 0 {
|
|
t.Fatal("legacy IDs inferred")
|
|
}
|
|
}
|
|
|
|
func TestManagedStatusOperatorCoverage(t *testing.T) {
|
|
for _, mode := range []string{"qualified", "experimental", "missing-candidate", "missing-db", "render-mismatch", "invalid-hash", "legacy", "pending"} {
|
|
t.Run(mode, func(t *testing.T) {
|
|
db := testStore(t)
|
|
front := managedCandidateFixture(t, db, "frontend", "www.youtube.com", "--lua-desync=fake", true)
|
|
ids := []int64{front}
|
|
scope := GooglevideoScopeExact
|
|
if mode == "qualified" {
|
|
ids = append(ids, managedCandidateFixture(t, db, "googlevideo", "rr1.googlevideo.com", "--lua-desync=fake", true))
|
|
} else {
|
|
asset := unitAssetCandidate(t, db, "i.ytimg.com", "--lua-desync=fake", true)
|
|
tx, err := db.Begin()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ggc, err := insertStrategyCandidate(tx, "googlevideo", []string{"rr1---sn-alpha.googlevideo.com"}, managedGooglevideoArgs, nil)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := tx.Commit(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ids = append(ids, asset, ggc)
|
|
scope = GooglevideoScopeExperimental
|
|
c, err := readStrategyCandidate(db, ggc)
|
|
if err != nil || c.Qualified || c.Mode != QualificationCold {
|
|
t.Fatalf("experimental candidate: %+v %v", c, err)
|
|
}
|
|
var evidence int
|
|
if err := db.QueryRow("SELECT count(*) FROM candidate_evidence WHERE candidate_id=?", ggc).Scan(&evidence); err != nil || evidence != 0 {
|
|
t.Fatalf("fabricated evidence: %d %v", evidence, err)
|
|
}
|
|
}
|
|
m, _ := managedFixture(t)
|
|
if err := m.Apply(db, ids, scope); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
j, err := m.load()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
openDB := func() (*sql.DB, error) { return openHistoryStore(databasePath()) }
|
|
switch mode {
|
|
case "missing-candidate":
|
|
j.Candidates[len(ids)-1] = 999999
|
|
case "missing-db":
|
|
openDB = func() (*sql.DB, error) { return nil, errors.New("unavailable") }
|
|
case "render-mismatch":
|
|
b := []byte("# not the rendered candidates\n" + managedBaseline)
|
|
if err := os.WriteFile(filepath.Join(m.Dir, m.Name), b, 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
j.Hash = managedHash(b)
|
|
case "invalid-hash":
|
|
j.Hash = managedHash([]byte("wrong hash"))
|
|
case "legacy":
|
|
j.Version, j.Scope = 2, ""
|
|
case "pending":
|
|
j.State, j.Next = "prepared", j.Hash
|
|
j.PendingCandidates, j.PendingScope = append([]int64{}, ids...), scope
|
|
}
|
|
if err := m.journal(j); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
before, err := os.ReadFile(filepath.Join(m.Dir, m.Name))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
journalBefore, err := os.ReadFile(filepath.Join(m.Dir, managedJournalName))
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
m.Health = func() (string, error) { t.Fatal("status checked live health"); return "", nil }
|
|
m.Reload = func() error { t.Fatal("status reloaded target"); return nil }
|
|
var out bytes.Buffer
|
|
err = managedReport(m, &out, openDB, false)
|
|
if mode == "invalid-hash" {
|
|
if !errors.Is(err, errManagedDrift) || out.Len() != 0 {
|
|
t.Fatalf("drift trusted: %s %v", out.String(), err)
|
|
}
|
|
} else {
|
|
if err != nil || !strings.Contains(out.String(), "Live health: NOT CHECKED") || strings.Contains(out.String(), "READY") {
|
|
t.Fatalf("status: %s %v", out.String(), err)
|
|
}
|
|
want := []string{"groups=unknown ", "covered=unknown", "active_candidate_ids=[] ", "unresolved_groups=frontend,googlevideo"}
|
|
if mode == "qualified" {
|
|
want = []string{"groups=frontend,googlevideo ", "covered=frontend,googlevideo", "unresolved_groups= covered="}
|
|
} else if mode == "experimental" {
|
|
want = []string{"groups=frontend,assets ", "covered=frontend,assets,googlevideo", "unresolved_groups=googlevideo,assets ", "experimental/unqualified", "one authorized composite profile", "not all hosts checked"}
|
|
}
|
|
for _, text := range want {
|
|
if !strings.Contains(out.String(), text) {
|
|
t.Fatalf("missing %q: %s", text, out.String())
|
|
}
|
|
}
|
|
}
|
|
out.Reset()
|
|
err = managedReport(m, &out, openDB, true)
|
|
if mode == "qualified" || mode == "experimental" {
|
|
var state struct {
|
|
IDs []int64 `json:"active_candidate_ids"`
|
|
Missing []string `json:"unresolved_groups"`
|
|
Covered []string `json:"covered_groups"`
|
|
Scope GooglevideoScope `json:"googlevideo_scope"`
|
|
}
|
|
if err != nil || json.Unmarshal(out.Bytes(), &state) != nil || !reflect.DeepEqual(state.IDs, ids) || state.Scope != scope {
|
|
t.Fatalf("JSON: %s %v", out.String(), err)
|
|
}
|
|
covered, missing := []string{"frontend", "googlevideo"}, []string(nil)
|
|
if mode == "experimental" {
|
|
covered, missing = []string{"frontend", "assets", "googlevideo"}, []string{"googlevideo", "assets"}
|
|
}
|
|
if !reflect.DeepEqual(state.Covered, covered) || !reflect.DeepEqual(state.Missing, missing) {
|
|
t.Fatalf("coverage changed qualification: %+v", state)
|
|
}
|
|
encoded, err := json.Marshal(state)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var roundtrip map[string]json.RawMessage
|
|
if err := json.Unmarshal(encoded, &roundtrip); err != nil || len(roundtrip) != 4 {
|
|
t.Fatalf("JSON roundtrip: %s %v", encoded, err)
|
|
}
|
|
} else if err == nil || out.Len() != 0 {
|
|
t.Fatalf("invalid IDs trusted: %s %v", out.String(), err)
|
|
}
|
|
after, err := os.ReadFile(filepath.Join(m.Dir, m.Name))
|
|
if err != nil || !bytes.Equal(before, after) {
|
|
t.Fatal("status changed config", err)
|
|
}
|
|
journalAfter, err := os.ReadFile(filepath.Join(m.Dir, managedJournalName))
|
|
if err != nil || !bytes.Equal(journalBefore, journalAfter) {
|
|
t.Fatal("status changed journal", err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestManagedMountpoint(t *testing.T) {
|
|
for _, path := range []string{"/", filepath.Dir(managedTargetDirectory), managedTargetDirectory + "-other"} {
|
|
if managedMountpoint("1 2 0:3 / "+path+" rw - tmpfs tmpfs rw\n", managedTargetDirectory) {
|
|
t.Fatal("accepted another mount")
|
|
}
|
|
}
|
|
if !managedMountpoint("1 2 0:3 / "+managedTargetDirectory+" rw - ext4 /dev/test rw\n", managedTargetDirectory) {
|
|
t.Fatal("dedicated mount rejected")
|
|
}
|
|
if err := verifyManagedRuntime("/opt/zapret2"); err == nil {
|
|
t.Fatal("production verifier accepted arbitrary directory")
|
|
}
|
|
}
|