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.
This commit is contained in:
protonmatter
2026-11-17 15:52:04 -05:00
parent ce218c4b16
commit 133dc68668
3 changed files with 140 additions and 6 deletions
+96
View File
@@ -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")
}
}
+18 -6
View File
@@ -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)
}
}
}
+26
View File
@@ -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) {