From 133dc68668f510ed71dac03c88f64199f93e84cc Mon Sep 17 00:00:00 2001 From: protonmatter Date: Tue, 17 Nov 2026 15:52:04 -0500 Subject: [PATCH] Test that a failed coverage read stays enabled, including auto-scope writes. A missing task and a query error both leave the flag on. The worker keeps the coverage tools and still records auto scope when the stored flag is off. --- agent/coverage_flag_test.go | 96 +++++++++++++++++++++++++++++++++++++ agent/worker.go | 24 +++++++--- db/task_scope_test.go | 26 ++++++++++ 3 files changed, 140 insertions(+), 6 deletions(-) create mode 100644 agent/coverage_flag_test.go diff --git a/agent/coverage_flag_test.go b/agent/coverage_flag_test.go new file mode 100644 index 0000000..04d9329 --- /dev/null +++ b/agent/coverage_flag_test.go @@ -0,0 +1,96 @@ +package agent + +import ( + "bytes" + "fmt" + "log" + "strings" + "testing" + "time" + + "github.com/Autumn-27/artex/db" +) + +// A failed coverage-flag read stays enabled: the log says so, the worker keeps +// record_coverage and list_untested_assets, and AddAutoScope still writes. That +// write happens even when the stored flag is off, which is the outage behaviour. +func TestCoverageReadFailureKeepsToolsAndWritesAutoScope(t *testing.T) { + d := testDB(t) + defer d.Close() + off := false + task, err := d.CreateTaskWithOptions("coverage outage", "goal", db.TaskCreateOptions{CoverageEnabled: &off}) + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = d.DeleteTask(task.ID) }) + + live := d.Assets() + stored, err := live.CoverageEnabled(task.ID) + if err != nil || stored { + t.Fatalf("stored flag enabled=%v err=%v, want off", stored, err) + } + if coverageOn(live, task.ID) { + t.Fatal("a readable off flag was treated as on") + } + + dsn, _, err := db.DSN() + if err != nil { + t.Fatal(err) + } + broken, err := db.Open(dsn) + if err != nil { + t.Fatal(err) + } + if err := broken.Close(); err != nil { + t.Fatal(err) + } + var logged bytes.Buffer + prev := log.Default().Writer() + log.SetOutput(&logged) + t.Cleanup(func() { log.SetOutput(prev) }) + if !coverageOn(broken.Assets(), task.ID) { + t.Fatal("a failed coverage read turned the feature off") + } + if !strings.Contains(logged.String(), "leaving coverage on") { + t.Fatalf("coverage read failure was not logged: %q", logged.String()) + } + + offTools := NewToolSet(nil, "worker-off") + offTools.SetCoverageEnabled(false) + for _, name := range []string{"record_coverage", "list_untested_assets"} { + if hasTool(offTools, name) { + t.Fatalf("%s stayed available with coverage off", name) + } + } + outageTools := NewToolSet(nil, "worker-outage") + outageTools.SetCoverageEnabled(coverageOn(broken.Assets(), task.ID)) + for _, name := range []string{"record_coverage", "list_untested_assets"} { + if !hasTool(outageTools, name) { + t.Fatalf("%s dropped when the coverage read failed", name) + } + } + + keptOff := fmt.Sprintf("off-%d.invalid", time.Now().UnixNano()) + writeIntentAutoScope(live, task.ID, []*db.Asset{{Type: "root_domain", Domain: keptOff}}, false) + wrote := fmt.Sprintf("outage-%d.invalid", time.Now().UnixNano()) + writeIntentAutoScope(live, task.ID, []*db.Asset{{Type: "root_domain", Domain: wrote}}, coverageOn(broken.Assets(), task.ID)) + scope, err := live.ListTaskScope(task.ID) + if err != nil { + t.Fatal(err) + } + var sawKept, sawWrote bool + for _, row := range scope { + if row.Domain == keptOff { + sawKept = true + } + if row.Domain == wrote { + sawWrote = true + } + } + if sawKept { + t.Fatal("auto scope was written while coverage was off") + } + if !sawWrote { + t.Fatal("auto scope was not written when the coverage read failed") + } +} diff --git a/agent/worker.go b/agent/worker.go index 9b68dd1..c43f94c 100644 --- a/agent/worker.go +++ b/agent/worker.go @@ -387,6 +387,21 @@ func renderWorkerGraphOverview(data map[string]any, env dataEnvelope) string { sections } +// writeIntentAutoScope records the intent's target assets as auto scope when +// coverage is on. coverageEnabled is fail-open: a failed flag read is true, so +// an outage still writes, including when the stored flag is off. +func writeIntentAutoScope(as *db.AssetStore, taskID int64, assets []*db.Asset, coverageEnabled bool) { + if as == nil || !coverageEnabled { + return + } + for _, a := range assets { + if a == nil { + continue + } + _ = as.AddAutoScope(taskID, a.Type, a.Domain, a.URL, a.IP) + } +} + // Execute runs one intent. hooks (the per-task Guard) gates every tool call; may // be nil. emit, if non-nil, receives one ActivityRecord per execution step. // notifyFinding, if non-nil, is called (intentID, summary) when this worker writes @@ -473,12 +488,9 @@ func (w *Worker) execute(ctx context.Context, name string, taskID int64, as *db. // toward coverage only under a declared domain or IP root (db.declaredScopeFilter); // coverage scope, not enforced. // When the asset-coverage feature is off, the test scope (denominator) is no - // longer accumulated. - if coverageEnabled { - for _, a := range assets { - _ = as.AddAutoScope(taskID, a.Type, a.Domain, a.URL, a.IP) - } - } + // longer accumulated. A failed flag read is treated as on, so an outage + // still writes, including for a task whose stored flag is off. + writeIntentAutoScope(as, taskID, assets, coverageEnabled) } } } diff --git a/db/task_scope_test.go b/db/task_scope_test.go index 9963c7e..25f7d7a 100644 --- a/db/task_scope_test.go +++ b/db/task_scope_test.go @@ -9,6 +9,32 @@ func TestCoverageEnabledWithoutTask(t *testing.T) { } } +func TestCoverageEnabledMissingRowStaysOn(t *testing.T) { + d, err := Open(testDSN(t)) + if err != nil { + t.Skipf("postgres unavailable (%v)", err) + } + defer d.Close() + on, err := d.Assets().CoverageEnabled(9_000_000_000_001) + if err != nil || !on { + t.Fatalf("missing task: enabled=%v err=%v, want enabled with no error", on, err) + } +} + +func TestCoverageEnabledQueryErrorStaysOn(t *testing.T) { + d, err := Open(testDSN(t)) + if err != nil { + t.Skipf("postgres unavailable (%v)", err) + } + if err := d.Close(); err != nil { + t.Fatal(err) + } + on, err := d.Assets().CoverageEnabled(1) + if err == nil || !on { + t.Fatalf("failed query: enabled=%v err=%v, want enabled and the error", on, err) + } +} + // TestStripHostPort covers the ip:port / [ipv6]:port stripping used by the // ip/cidr scope path so a target like "10.0.188.136:3000" no longer 404s. func TestStripHostPort(t *testing.T) {