Overnight/test harness 2026 04 20

cmd/swartznet/cmd_aggregate_find_errors_test.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// TestCmdAggregateFindBadFlag covers cmdAggregateFind's
+// `if err := fs.Parse(args); err != nil { return exitUsage }` arm.
+// An unknown flag makes flag.Parse return ErrHelp.
+func TestCmdAggregateFindBadFlag(t *testing.T) {
+	t.Parallel()
+	stdout := &bytes.Buffer{}
+	stderr := &bytes.Buffer{}
+	code := cmdAggregate([]string{"find", "--no-such-flag", "x.bin", "p"}, stdout, stderr)
+	if code != exitUsage {
+		t.Errorf("bad-flag exit = %d, want exitUsage", code)
+	}
+}
+
+// TestCmdAggregateFindMissingArgs covers the
+// `if fs.NArg() != 2` usage arm.
+func TestCmdAggregateFindMissingArgs(t *testing.T) {
+	t.Parallel()
+	stdout := &bytes.Buffer{}
+	stderr := &bytes.Buffer{}
+	code := cmdAggregate([]string{"find"}, stdout, stderr)
+	if code != exitUsage {
+		t.Errorf("missing-args exit = %d, want exitUsage", code)
+	}
+}
+
+// TestCmdAggregateFindReadFileError covers the
+// `os.ReadFile err → exitRuntime` arm: pass a path that doesn't
+// exist.
+func TestCmdAggregateFindReadFileError(t *testing.T) {
+	t.Parallel()
+	missing := filepath.Join(t.TempDir(), "nope.bin")
+	stdout := &bytes.Buffer{}
+	stderr := &bytes.Buffer{}
+	code := cmdAggregate([]string{"find", missing, "prefix"}, stdout, stderr)
+	if code != exitRuntime {
+		t.Errorf("missing-file exit = %d, want exitRuntime", code)
+	}
+}
+
+// TestCmdAggregateFindOpenBTreeError covers the
+// `companion.OpenBTree err → exitRuntime` arm: hand it a real
+// file with garbage bytes so the b-tree header check fails.
+func TestCmdAggregateFindOpenBTreeError(t *testing.T) {
+	t.Parallel()
+	bogus := filepath.Join(t.TempDir(), "bogus.bin")
+	if err := os.WriteFile(bogus, []byte("this is not a btree page"), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	stdout := &bytes.Buffer{}
+	stderr := &bytes.Buffer{}
+	code := cmdAggregate([]string{"find", bogus, "prefix"}, stdout, stderr)
+	if code != exitRuntime {
+		t.Errorf("garbage-file exit = %d, want exitRuntime", code)
+	}
+}

cmd/swartznet/cmd_crawl_probe_more_test.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+
+	"github.com/anacrolix/dht/v2/krpc"
+)
+
+// TestCmdCrawlProbeBadFlag covers the
+// `if err := fs.Parse(args); err != nil { return exitUsage }`
+// arm. Unknown flag forces flag.Parse to return ErrHelp.
+func TestCmdCrawlProbeBadFlag(t *testing.T) {
+	t.Parallel()
+	var stdout, stderr bytes.Buffer
+	code := cmdCrawlProbe([]string{"--no-such-flag"}, &stdout, &stderr)
+	if code != exitUsage {
+		t.Errorf("bad-flag exit = %d, want exitUsage", code)
+	}
+}
+
+// TestCmdCrawlProbeBadAddr covers the `net.ResolveUDPAddr err →
+// exitUsage` arm. An obviously malformed addr fails resolution
+// without leaving the process.
+func TestCmdCrawlProbeBadAddr(t *testing.T) {
+	t.Parallel()
+	var stdout, stderr bytes.Buffer
+	code := cmdCrawlProbe([]string{"--addr", "totally::not::a::host"}, &stdout, &stderr)
+	if code != exitUsage {
+		t.Errorf("bad-addr exit = %d, want exitUsage", code)
+	}
+	if !strings.Contains(stderr.String(), "resolve") {
+		t.Errorf("expected 'resolve' in stderr, got %q", stderr.String())
+	}
+}
+
+// TestCmdCrawlProbeExplicitTargetText covers the
+// `else { raw, err := hex.DecodeString(targetHex); ... copy(target[:], raw) }`
+// happy-path branch — only the random-target branch is otherwise
+// covered. Pair with the responder so the request actually
+// completes and the text-output renderer runs.
+func TestCmdCrawlProbeExplicitTargetText(t *testing.T) {
+	t.Parallel()
+	addr := startBep51Responder(t, []krpc.ID{{0x77, 0x88}})
+
+	const target = "0123456789abcdef0123456789abcdef01234567" // 40 hex chars
+	var stdout, stderr bytes.Buffer
+	code := cmdCrawlProbe([]string{
+		"--addr", addr,
+		"--target", target,
+		"--timeout-ms", "3000",
+	}, &stdout, &stderr)
+	if code != exitOK {
+		t.Fatalf("exit = %d (stderr: %s)", code, stderr.String())
+	}
+	if !strings.Contains(stdout.String(), target) {
+		t.Errorf("expected target %q echoed in output: %s", target, stdout.String())
+	}
+}
+
+// TestCmdCrawlProbeQueryFails covers the
+// `dhtindex.SampleInfohashes err → exitRuntime` arm. Point at a
+// loopback port nothing's listening on; a short timeout makes the
+// query fail rather than wait forever.
+func TestCmdCrawlProbeQueryFails(t *testing.T) {
+	t.Parallel()
+	var stdout, stderr bytes.Buffer
+	// 127.0.0.1:1 is reserved + nothing listens. timeout 200ms.
+	code := cmdCrawlProbe([]string{
+		"--addr", "127.0.0.1:1",
+		"--timeout-ms", "200",
+	}, &stdout, &stderr)
+	if code != exitRuntime {
+		t.Errorf("query-fail exit = %d, want exitRuntime", code)
+	}
+}

cmd/swartznet/load_priv_key_test.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+// TestLoadPrivKeyExplicitPath covers loadPrivKey's explicit-path
+// branch: with keyPath != "", LoadOrCreate is called directly
+// against that path. On a fresh path it generates and persists a
+// new keypair, so subsequent calls return the same one.
+func TestLoadPrivKeyExplicitPath(t *testing.T) {
+	t.Parallel()
+	keyPath := filepath.Join(t.TempDir(), "id.key")
+
+	priv, pub, err := loadPrivKey(keyPath)
+	if err != nil {
+		t.Fatalf("loadPrivKey: %v", err)
+	}
+	if len(priv) == 0 || len(pub) == 0 {
+		t.Errorf("loadPrivKey returned empty keypair")
+	}
+
+	// Re-load — must round-trip to the same bytes.
+	priv2, pub2, err := loadPrivKey(keyPath)
+	if err != nil {
+		t.Fatalf("loadPrivKey (round trip): %v", err)
+	}
+	if string(priv) != string(priv2) || string(pub) != string(pub2) {
+		t.Error("loadPrivKey round-trip produced different keypair")
+	}
+}
+
+// TestLoadPrivKeyExplicitPathError covers loadPrivKey's
+// `if err != nil → return` arm in the explicit-path branch.
+// Plant a directory at the keyPath so LoadOrCreate's read fails.
+func TestLoadPrivKeyExplicitPathError(t *testing.T) {
+	t.Parallel()
+	keyDir := filepath.Join(t.TempDir(), "id.key")
+	if err := os.Mkdir(keyDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, _, err := loadPrivKey(keyDir); err == nil {
+		t.Error("loadPrivKey should fail when keyPath is a directory")
+	}
+}
+
+// TestLoadPrivKeyDefaultPath exercises loadPrivKey's empty-path
+// branch (keyPath == "" → defaultIdentityPath → LoadOrCreate).
+// Override HOME so the test never touches the user's real
+// identity file.
+func TestLoadPrivKeyDefaultPath(t *testing.T) {
+	t.Setenv("HOME", t.TempDir())
+
+	priv, pub, err := loadPrivKey("")
+	if err != nil {
+		t.Fatalf("loadPrivKey(\"\"): %v", err)
+	}
+	if len(priv) == 0 || len(pub) == 0 {
+		t.Errorf("loadPrivKey returned empty keypair")
+	}
+}
+
+// TestLoadPrivKeyDefaultPathHomeUnset covers the
+// `defaultIdentityPath err → return nil, nil, err` arm of
+// loadPrivKey, plus defaultIdentityPath's own UserHomeDir-err
+// arm. Empty HOME makes os.UserHomeDir fail with
+// "$HOME is not defined".
+func TestLoadPrivKeyDefaultPathHomeUnset(t *testing.T) {
+	t.Setenv("HOME", "")
+
+	if _, _, err := loadPrivKey(""); err == nil {
+		t.Error("loadPrivKey(\"\") should fail when HOME is unset")
+	}
+}

cmd/swartznet/read_records_test.go

@@ -0,0 +1,86 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+// TestReadRecordsHappyPath covers the successful JSONL read with
+// blank lines (exercises the `if len(b) == 0 { continue }` arm)
+// and a valid record per line.
+func TestReadRecordsHappyPath(t *testing.T) {
+	t.Parallel()
+	const ih = "0123456789abcdef0123456789abcdef01234567" // 40 hex chars
+	body := `
+{"ih":"` + ih + `","kw":"alpha","t":1}
+
+{"ih":"` + ih + `","kw":"beta","t":2}
+`
+	path := filepath.Join(t.TempDir(), "input.jsonl")
+	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	recs, err := readRecords(path)
+	if err != nil {
+		t.Fatalf("readRecords: %v", err)
+	}
+	if len(recs) != 2 {
+		t.Fatalf("got %d records, want 2", len(recs))
+	}
+	if recs[0].Kw != "alpha" || recs[1].Kw != "beta" {
+		t.Errorf("unexpected records: %+v", recs)
+	}
+}
+
+// TestReadRecordsOpenError covers the
+// `f, err := os.Open(path); if err != nil { return nil, err }` arm.
+func TestReadRecordsOpenError(t *testing.T) {
+	t.Parallel()
+	missing := filepath.Join(t.TempDir(), "nope.jsonl")
+	if _, err := readRecords(missing); err == nil {
+		t.Error("readRecords should fail on a missing file")
+	}
+}
+
+// TestReadRecordsEmptyKwError covers the
+// `if jr.Kw == "" { return nil, ... empty kw ... }` arm.
+func TestReadRecordsEmptyKwError(t *testing.T) {
+	t.Parallel()
+	const ih = "0123456789abcdef0123456789abcdef01234567"
+	body := `{"ih":"` + ih + `","kw":"","t":1}` + "\n"
+	path := filepath.Join(t.TempDir(), "input.jsonl")
+	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	_, err := readRecords(path)
+	if err == nil {
+		t.Fatal("readRecords should fail on empty kw")
+	}
+	if !strings.Contains(err.Error(), "empty kw") {
+		t.Errorf("unexpected err: %v", err)
+	}
+}
+
+// TestReadRecordsScannerError covers the
+// `if err := scanner.Err(); err != nil` arm. A line longer than
+// the 1 MiB scanner buffer triggers bufio.ErrTooLong, which
+// surfaces from scanner.Err() after Scan returns false.
+func TestReadRecordsScannerError(t *testing.T) {
+	t.Parallel()
+	const ih = "0123456789abcdef0123456789abcdef01234567"
+	// 2 MiB record — exceeds the 1 MiB scanner buffer.
+	huge := strings.Repeat("a", 2*1024*1024)
+	body := `{"ih":"` + ih + `","kw":"` + huge + `","t":1}` + "\n"
+	path := filepath.Join(t.TempDir(), "input.jsonl")
+	if err := os.WriteFile(path, []byte(body), 0o644); err != nil {
+		t.Fatal(err)
+	}
+
+	if _, err := readRecords(path); err == nil {
+		t.Error("readRecords should fail when a line exceeds the scanner buffer")
+	}
+}

internal/companion/collect_file_records_internal_test.go

@@ -0,0 +1,28 @@
+package companion
+
+import (
+	"testing"
+
+	"github.com/swartznet/swartznet/internal/indexer"
+)
+
+// TestCollectFileRecordsFillsLatePath covers collectFileRecords'
+// `if b.path == "" && c.FilePath != "" { b.path = c.FilePath }`
+// arm. Sequencing matters: the FIRST ContentDoc seen for a file
+// must have FilePath="", a LATER one for the same file must
+// have a non-empty FilePath. Internal test so we can control
+// ordering by calling collectFileRecords directly.
+func TestCollectFileRecordsFillsLatePath(t *testing.T) {
+	t.Parallel()
+	docs := []indexer.ContentDoc{
+		{InfoHash: "x", FileIndex: 0, FilePath: "", Text: "first"},
+		{InfoHash: "x", FileIndex: 0, FilePath: "late.txt", Text: "second"},
+	}
+	out := collectFileRecords([]string{"late.txt"}, docs, DefaultBuildOptions())
+	if len(out) != 1 {
+		t.Fatalf("len(out) = %d, want 1", len(out))
+	}
+	if out[0].Path != "late.txt" {
+		t.Errorf("FileRecord.Path = %q, want late.txt", out[0].Path)
+	}
+}

internal/companion/decode_read_error_test.go

@@ -0,0 +1,55 @@
+package companion_test
+
+import (
+	"bytes"
+	"compress/gzip"
+	"errors"
+	"io"
+	"testing"
+
+	"github.com/swartznet/swartznet/internal/companion"
+)
+
+// gzipPrefixThenError starts a valid gzip stream so
+// gzip.NewReader's header validation passes, then errors on
+// every subsequent Read so io.ReadAll inside Decode surfaces
+// the wrapped error.
+type gzipPrefixThenError struct {
+	prefix []byte
+	pos    int
+}
+
+func (g *gzipPrefixThenError) Read(p []byte) (int, error) {
+	if g.pos < len(g.prefix) {
+		n := copy(p, g.prefix[g.pos:])
+		g.pos += n
+		return n, nil
+	}
+	return 0, errors.New("companion test: forced read failure")
+}
+
+// TestDecodeReadAllError covers Decode's
+// `body, err := io.ReadAll(io.LimitReader(gz, ...))` error arm.
+// gzip.NewReader successfully reads the magic + header, then
+// the underlying reader errors on subsequent reads. Decode must
+// surface the wrapped 'read gzip' error rather than panic.
+func TestDecodeReadAllError(t *testing.T) {
+	t.Parallel()
+	// Build a real gzip header (10 bytes), enough for
+	// gzip.NewReader to succeed but not enough to decode any
+	// real content.
+	var buf bytes.Buffer
+	gz := gzip.NewWriter(&buf)
+	if _, err := gz.Write([]byte("partial")); err != nil {
+		t.Fatal(err)
+	}
+	// Don't close — keep the stream incomplete.
+
+	r := &gzipPrefixThenError{prefix: buf.Bytes()}
+	if _, err := companion.Decode(r); err == nil {
+		t.Error("Decode should surface read error")
+	}
+}
+
+// satisfy io import.
+var _ io.Reader = (*gzipPrefixThenError)(nil)