Files
zapret-autotune/cmd/zapret-autotune/managed_cli_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

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")
}
}