mirror of
https://github.com/BaaRai/ARTEX.git
synced 2026-11-18 14:10:54 +08:00
list_untested_assets is a planner tool, not a worker tool; the fail-open assertion can only be made against PlannerTools.
114 lines
3.4 KiB
Go
114 lines
3.4 KiB
Go
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())
|
|
}
|
|
|
|
// record_coverage is the worker's coverage tool; list_untested_assets is the
|
|
// planner's, so each is checked on the tool set that actually carries it.
|
|
hasPlannerTool := func(ts *ToolSet, name string) bool {
|
|
for _, tool := range ts.DropCoverageTools(ts.PlannerTools()) {
|
|
if tool.Name() == name {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
offWorker := NewToolSet(nil, "worker-off")
|
|
offWorker.SetCoverageEnabled(false)
|
|
if hasTool(offWorker, "record_coverage") {
|
|
t.Fatal("record_coverage stayed available to a worker with coverage off")
|
|
}
|
|
offPlanner := NewToolSet(nil, "planner-off")
|
|
offPlanner.SetCoverageEnabled(false)
|
|
if hasPlannerTool(offPlanner, "list_untested_assets") {
|
|
t.Fatal("list_untested_assets stayed available to the planner with coverage off")
|
|
}
|
|
outage := coverageOn(broken.Assets(), task.ID)
|
|
outWorker := NewToolSet(nil, "worker-outage")
|
|
outWorker.SetCoverageEnabled(outage)
|
|
if !hasTool(outWorker, "record_coverage") {
|
|
t.Fatal("record_coverage dropped from the worker when the coverage read failed")
|
|
}
|
|
outPlanner := NewToolSet(nil, "planner-outage")
|
|
outPlanner.SetCoverageEnabled(outage)
|
|
if !hasPlannerTool(outPlanner, "list_untested_assets") {
|
|
t.Fatal("list_untested_assets dropped from the planner when the coverage read failed")
|
|
}
|
|
|
|
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")
|
|
}
|
|
}
|