Files
zapret-autotune/cmd/zapret-autotune/store_test.go
T
2026-10-10 09:16:58 +03:00

515 lines
16 KiB
Go

package main
import (
"bytes"
"context"
"database/sql"
"errors"
"fmt"
"io"
"os"
"path/filepath"
"strings"
"sync"
"testing"
"time"
)
func testStore(t *testing.T) *sql.DB {
t.Helper()
t.Setenv("ZAPRET_AUTOTUNE_DB", filepath.Join(t.TempDir(), "data", "autotune.db"))
db, err := openStore(databasePath())
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { db.Close() })
return db
}
func saveProposal(t *testing.T, db *sql.DB, args string) string {
t.Helper()
report := combinedReportFixture(args)
output, err := combinedBlockcheckOutput(strings.NewReader(report), args)
if err != nil {
t.Fatal(err)
}
if err := saveRun(db, time.Now(), args, output, []byte(report), nil); err != nil {
t.Fatal(err)
}
return output
}
func assertRowCounts(t *testing.T, db *sql.DB, runs, results int) {
t.Helper()
for table, want := range map[string]int{"tune_runs": runs, "protocol_results": results} {
var got int
if err := db.QueryRow("SELECT count(*) FROM " + table).Scan(&got); err != nil || got != want {
t.Fatalf("%s: count=%d want=%d err=%v", table, got, want, err)
}
}
}
func assertProposedRun(t *testing.T, args, output string) {
t.Helper()
db, err := openStore(databasePath())
if err != nil {
t.Fatal(err)
}
defer db.Close()
r, err := latestRun(db)
if err != nil || r.State != "PROPOSED" || r.Args.String != args || r.Output.String != output || r.Error.Valid {
t.Fatalf("latest=%+v err=%v", r, err)
}
assertRowCounts(t, db, 1, 2)
assertSavedCandidate(t, db, r.ID, args)
for _, protocol := range []string{"tls12", "tls13"} {
var ok, total int
if err := db.QueryRow("SELECT passes_ok, passes_total FROM protocol_results WHERE run_id = ? AND protocol = ?", r.ID, protocol).Scan(&ok, &total); err != nil || ok != 3 || total != 3 {
t.Fatalf("%s: %d/%d err=%v", protocol, ok, total, err)
}
}
}
func TestStoreFilePermissions(t *testing.T) {
for _, name := range []string{"new", "existing"} {
t.Run(name, func(t *testing.T) {
path := filepath.Join(t.TempDir(), "data", "autotune.db")
wantRuns := 0
if name == "existing" {
db, err := openStore(path)
if err != nil {
t.Fatal(err)
}
if err := saveRun(db, time.Now(), "", "", nil, errors.New("scan failed")); err != nil {
db.Close()
t.Fatal(err)
}
if err := db.Close(); err != nil {
t.Fatal(err)
}
if err := os.Chmod(path, 0666); err != nil {
t.Fatal(err)
}
wantRuns = 1
}
db, err := openStore(path)
if err != nil {
t.Fatal(err)
}
defer db.Close()
info, err := os.Stat(path)
if err != nil {
t.Fatal(err)
}
if got := info.Mode().Perm(); got != 0600 {
t.Fatalf("database mode = %04o, want 0600", got)
}
assertRowCounts(t, db, wantRuns, 0)
})
}
}
func TestDatabasePathEnvironment(t *testing.T) {
t.Setenv("ZAPRET_AUTOTUNE_DB", "")
if got := databasePath(); got != "/var/lib/zapret-autotune/autotune.db" {
t.Fatalf("default database path = %q", got)
}
t.Setenv("ZAPRET_AUTOTUNE_DB", "data/custom?.db")
if got := databasePath(); got != "data/custom?.db" {
t.Fatalf("configured database path = %q", got)
}
}
func TestStoreRejectsDSNs(t *testing.T) {
for _, path := range []string{"", ":memory:", ":memory:?cache=shared", "file::memory:?cache=shared", "file:test.db?mode=memory", "file:///tmp/test.db", "FILE:test.db"} {
t.Run(path, func(t *testing.T) {
db, err := openStore(path)
if db != nil {
db.Close()
}
if err == nil {
t.Fatalf("accepted SQLite DSN %q", path)
}
})
}
}
func TestStoreFilesystemPaths(t *testing.T) {
for _, name := range []string{"plain.db", "question?.db", "options.db?mode=memory&cache=shared", "pragma.db?_pragma=query_only(1)", "hash#.db", "percent%3f.db", "space + ü.db"} {
t.Run(name, func(t *testing.T) {
path := filepath.Join(t.TempDir(), name)
cwd, err := os.Getwd()
if err != nil {
t.Fatal(err)
}
relative, err := filepath.Rel(cwd, path)
if err != nil {
t.Fatal(err)
}
t.Setenv("ZAPRET_AUTOTUNE_DB", relative)
db, err := openStore(databasePath())
if err != nil {
t.Fatal(err)
}
defer db.Close()
var sequence int
var schema, filename string
if err := db.QueryRow("PRAGMA database_list").Scan(&sequence, &schema, &filename); err != nil {
t.Fatal(err)
}
if filename != path {
t.Fatalf("SQLite opened %q, want %q", filename, path)
}
if err := saveRun(db, time.Now(), "", "", nil, errors.New("persisted failure")); err != nil {
t.Fatal(err)
}
if err := db.Close(); err != nil {
t.Fatal(err)
}
info, err := os.Stat(path)
if err != nil {
t.Fatal(err)
}
if info.Size() == 0 || info.Mode().Perm() != 0600 {
t.Fatalf("database size=%d mode=%04o", info.Size(), info.Mode().Perm())
}
entries, err := os.ReadDir(filepath.Dir(path))
if err != nil {
t.Fatal(err)
}
if len(entries) != 1 || entries[0].Name() != name {
t.Fatalf("unexpected database files: %v", entries)
}
db, err = openStore(path)
if err != nil {
t.Fatal(err)
}
defer db.Close()
assertRowCounts(t, db, 1, 0)
})
}
}
func TestConcurrentFirstOpens(t *testing.T) {
path := filepath.Join(t.TempDir(), "autotune.db")
const callers = 8
start := make(chan struct{})
type openResult struct {
db *sql.DB
err error
}
results := make(chan openResult, callers)
var ready sync.WaitGroup
ready.Add(callers)
for i := 0; i < callers; i++ {
go func() {
ready.Done()
<-start
db, err := openStore(path)
results <- openResult{db, err}
}()
}
ready.Wait()
close(start)
// Collect every result before assertions so failures still close all stores.
stores := make([]*sql.DB, 0, callers)
for i := 0; i < callers; i++ {
result := <-results
if result.err != nil {
t.Errorf("concurrent open: %v", result.err)
continue
}
stores = append(stores, result.db)
defer result.db.Close()
}
for _, db := range stores {
var version, objects int
if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 5 {
t.Fatalf("version=%d err=%v", version, err)
}
if err := db.QueryRow(`SELECT count(*) FROM sqlite_master WHERE
(type = 'table' AND name IN ('tune_runs', 'protocol_results')) OR
(type = 'trigger' AND name = 'proposed_results_only')`).Scan(&objects); err != nil || objects != 3 {
t.Fatalf("schema objects=%d err=%v", objects, err)
}
assertRowCounts(t, db, 0, 0)
var integrity string
if err := db.QueryRow("PRAGMA integrity_check").Scan(&integrity); err != nil || integrity != "ok" {
t.Fatalf("integrity=%q err=%v", integrity, err)
}
}
}
func TestMigrationAndLatest(t *testing.T) {
db := testStore(t)
if err := migrate(db); err != nil {
t.Fatal(err)
}
if _, err := latestRun(db); !errors.Is(err, sql.ErrNoRows) {
t.Fatalf("empty latest: %v", err)
}
args := "--lua-desync=multisplit"
output := saveProposal(t, db, args)
if err := migrate(db); err != nil {
t.Fatal(err)
}
assertProposedRun(t, args, output)
if err := saveRun(db, time.Now(), "", "", nil, errors.New("scan failed")); err != nil {
t.Fatal(err)
}
r, err := latestRun(db)
if err != nil || r.ID != 2 || r.State != "FAILED" || r.Error.String != "scan failed" || r.Args.Valid || r.Output.Valid {
t.Fatalf("latest=%+v err=%v", r, err)
}
assertRowCounts(t, db, 2, 2)
var stdout, stderr bytes.Buffer
if status(&stdout, &stderr) != 0 || !strings.Contains(stdout.String(), "FAILED") || strings.Contains(stdout.String(), output) {
t.Fatalf("failed status: %q %q", stdout.String(), stderr.String())
}
}
func TestStatusNoDataAndProposed(t *testing.T) {
db := testStore(t)
var stdout, stderr bytes.Buffer
if run([]string{"status"}, &stdout, &stderr) != 0 || !strings.Contains(stdout.String(), "no recorded tune run") || strings.Contains(stdout.String(), "NFQWS2_OPT") {
t.Fatalf("empty status: %q %q", stdout.String(), stderr.String())
}
output := saveProposal(t, db, "--lua-desync=multisplit")
stdout.Reset()
if run([]string{"status"}, &stdout, &stderr) != 0 {
t.Fatal(stderr.String())
}
for _, want := range []string{"PROPOSED, not active", "TLS1.2 3/3", "TLS1.3 3/3", output, "apply: BLOCKED", "NOT CHECKED"} {
if !strings.Contains(stdout.String(), want) {
t.Errorf("status %q missing %q", stdout.String(), want)
}
}
}
func TestPersistenceRollback(t *testing.T) {
db := testStore(t)
output := saveProposal(t, db, "--lua-desync=multisplit")
if _, err := db.Exec(`CREATE TRIGGER reject_tls13 BEFORE INSERT ON protocol_results WHEN NEW.protocol = 'tls13' BEGIN SELECT RAISE(ABORT, 'injected persistence failure'); END`); err != nil {
t.Fatal(err)
}
args := "--lua-desync=multisplit"
if err := saveRun(db, time.Now(), args, output, []byte(combinedReportFixture(args)), nil); err == nil {
t.Fatal("expected persistence failure")
}
assertRowCounts(t, db, 1, 2)
r, err := latestRun(db)
if err != nil || r.ID != 1 {
t.Fatalf("rollback changed latest: %+v %v", r, err)
}
}
func TestMigrationRollback(t *testing.T) {
db, err := sql.Open("sqlite", filepath.Join(t.TempDir(), "broken.db"))
if err != nil {
t.Fatal(err)
}
defer db.Close()
db.SetMaxOpenConns(1)
if _, err := db.Exec("CREATE TABLE protocol_results (id INTEGER)"); err != nil {
t.Fatal(err)
}
if err := migrate(db); err == nil {
t.Fatal("expected conflicting schema failure")
}
var version, tables int
if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 0 {
t.Fatalf("version=%d err=%v", version, err)
}
if err := db.QueryRow("SELECT count(*) FROM sqlite_master WHERE name = 'tune_runs'").Scan(&tables); err != nil || tables != 0 {
t.Fatalf("partial schema count=%d err=%v", tables, err)
}
if _, err := db.Exec("DROP TABLE protocol_results"); err != nil {
t.Fatal(err)
}
if err := migrate(db); err != nil {
t.Fatalf("migration after rollback: %v", err)
}
}
func TestDatabaseFailureFailsClosed(t *testing.T) {
parent := filepath.Join(t.TempDir(), "not-a-directory")
if err := os.WriteFile(parent, []byte("x"), 0600); err != nil {
t.Fatal(err)
}
t.Setenv("ZAPRET_AUTOTUNE_DB", filepath.Join(parent, "autotune.db"))
var stdout, stderr bytes.Buffer
scan := func(context.Context, string, string, io.Writer, io.Writer) (string, error) {
t.Fatal("scan must not start with an unavailable database")
return "", nil
}
if tuneYoutube(&stdout, &stderr, scan) != 1 || stdout.Len() != 0 || !strings.Contains(stderr.String(), "database") {
t.Fatalf("tune: out=%q err=%q", stdout.String(), stderr.String())
}
stderr.Reset()
if run([]string{"status"}, &stdout, &stderr) != 1 || stdout.Len() != 0 || !strings.Contains(stderr.String(), "database") {
t.Fatalf("status: out=%q err=%q", stdout.String(), stderr.String())
}
}
func TestSchemaConstraintsAndIncompleteEvidence(t *testing.T) {
db := testStore(t)
saveProposal(t, db, "--lua-desync=multisplit")
for _, statement := range []string{
`INSERT INTO protocol_results VALUES (999, 'tls12', 3, 3)`,
`UPDATE protocol_results SET protocol = 'quic' WHERE protocol = 'tls12'`,
`UPDATE protocol_results SET passes_ok = 2 WHERE protocol = 'tls12'`,
`UPDATE protocol_results SET passes_total = 4 WHERE protocol = 'tls12'`,
`UPDATE tune_runs SET state = 'ACTIVE'`,
`UPDATE tune_runs SET args = NULL`,
} {
if _, err := db.Exec(statement); err == nil {
t.Fatalf("constraint accepted %s", statement)
}
}
if _, err := db.Exec(`DELETE FROM protocol_results WHERE protocol = 'tls13'`); err != nil {
t.Fatal(err)
}
var stdout, stderr bytes.Buffer
if status(&stdout, &stderr) != 1 || stdout.Len() != 0 || !strings.Contains(stderr.String(), "incomplete protocol evidence") {
t.Fatalf("incomplete status: %q %q", stdout.String(), stderr.String())
}
}
func TestUnsupportedSchemaVersion(t *testing.T) {
db := testStore(t)
if _, err := db.Exec("PRAGMA user_version = 6"); err != nil {
t.Fatal(err)
}
if err := migrate(db); err == nil || !strings.Contains(err.Error(), "unsupported") {
t.Fatalf("future schema accepted: %v", err)
}
}
func TestFingerprintSchemaConstraints(t *testing.T) {
for _, source := range []string{"v0", "v1"} {
t.Run(source, func(t *testing.T) {
var db *sql.DB
if source == "v1" {
db = populatedV1Store(t, "--lua-desync=fake")
if err := migrate(db); err != nil {
t.Fatal(err)
}
} else {
db = testStore(t)
}
valid := strings.Repeat("a", 64)
for _, state := range []string{"PROPOSED", "FAILED"} {
var args, output, failure interface{}
if state == "PROPOSED" {
args, output = "--lua-desync=fake", "output"
} else {
failure = "failure"
}
var initial interface{}
if state == "PROPOSED" {
initial = valid
}
result, err := db.Exec(`INSERT INTO tune_runs (started_at, finished_at, target, state, args, output, error, fingerprint) VALUES ('start', 'finish', 'youtube.com', ?, ?, ?, ?, ?)`, state, args, output, failure, initial)
if err != nil {
t.Fatal(err)
}
id, err := result.LastInsertId()
if err != nil {
t.Fatal(err)
}
invalid := []interface{}{"", strings.Repeat("a", 63), strings.Repeat("a", 65), strings.Repeat("A", 64), strings.Repeat("g", 64), valid + "\x00x"}
if state == "PROPOSED" {
invalid = append(invalid, nil)
} else {
invalid = append(invalid, valid)
}
for _, fingerprint := range invalid {
if _, err := db.Exec(`INSERT INTO tune_runs (started_at, finished_at, target, state, args, output, error, fingerprint) VALUES ('start', 'finish', 'youtube.com', ?, ?, ?, ?, ?)`, state, args, output, failure, fingerprint); err == nil {
t.Fatalf("INSERT accepted %s fingerprint %q", state, fingerprint)
}
if _, err := db.Exec("UPDATE tune_runs SET fingerprint = ? WHERE id = ?", fingerprint, id); err == nil {
t.Fatalf("UPDATE accepted %s fingerprint %q", state, fingerprint)
}
}
// Change all other state-dependent fields too: only the hash is wrong.
statement := "UPDATE tune_runs SET state = 'FAILED', args = NULL, output = NULL, error = 'failure' WHERE id = ?"
if state == "FAILED" {
statement = "UPDATE tune_runs SET state = 'PROPOSED', args = '--lua-desync=fake', output = 'output', error = NULL WHERE id = ?"
}
if _, err := db.Exec(statement, id); err == nil {
t.Fatalf("accepted state change from %s with mismatched fingerprint", state)
}
}
})
}
}
func TestMalformedV1SchemaRollback(t *testing.T) {
for name, damage := range map[string]string{
"missing protocol table": "DROP TABLE protocol_results",
"altered protocol column": "ALTER TABLE protocol_results RENAME COLUMN passes_total TO unexpected",
"altered run column": "ALTER TABLE tune_runs RENAME COLUMN error TO unexpected",
"altered protocol type": `ALTER TABLE protocol_results RENAME TO old_results;
CREATE TABLE protocol_results (run_id INTEGER, protocol TEXT, passes_ok TEXT, passes_total INTEGER);
INSERT INTO protocol_results SELECT * FROM old_results; DROP TABLE old_results;`,
} {
t.Run(name, func(t *testing.T) {
db := populatedV1Store(t, "--lua-desync=fake")
if _, err := db.Exec(damage); err != nil {
t.Fatal(err)
}
snapshot := func() (string, string) {
t.Helper()
var schema, history string
if err := db.QueryRow(`SELECT group_concat(sql, ';') FROM (SELECT sql FROM sqlite_master ORDER BY name)`).Scan(&schema); err != nil {
t.Fatal(err)
}
for _, table := range []string{"tune_runs", "protocol_results"} {
if table == "protocol_results" && name == "missing protocol table" {
continue
}
rows, err := db.Query("SELECT * FROM " + table + " ORDER BY 1, 2")
if err != nil {
t.Fatal(err)
}
columns, err := rows.Columns()
if err != nil {
rows.Close()
t.Fatal(err)
}
values := make([]interface{}, len(columns))
pointers := make([]interface{}, len(columns))
for i := range values {
pointers[i] = &values[i]
}
for rows.Next() {
if err := rows.Scan(pointers...); err != nil {
rows.Close()
t.Fatal(err)
}
history += fmt.Sprintf("%s:%#v;", table, values)
}
err = rows.Err()
rows.Close()
if err != nil {
t.Fatal(err)
}
}
return schema, history
}
beforeSchema, beforeHistory := snapshot()
if err := migrate(db); err == nil || !strings.Contains(err.Error(), "invalid v1 schema") {
t.Fatalf("malformed schema accepted: %v", err)
}
var version int
if err := db.QueryRow("PRAGMA user_version").Scan(&version); err != nil || version != 1 {
t.Fatalf("version=%d err=%v", version, err)
}
afterSchema, afterHistory := snapshot()
if afterSchema != beforeSchema || afterHistory != beforeHistory {
t.Fatal("failed migration changed schema or history")
}
})
}
}