Files
ARTEX/db/lessons_test.go
T
Coff0xc c73fec7471 fix(db): look up caution lessons by cue
The caution action carries the vulnclass, not the finding summary.
2026-11-17 19:13:32 +00:00

912 lines
29 KiB
Go

package db
import (
"fmt"
"strings"
"testing"
"time"
"unicode/utf8"
)
func TestRenderLessonsDataNotInstructions(t *testing.T) {
lessons := []Lesson{
{ID: 1, Kind: "positive", Cue: "xss", Action: "Confirmed xss: reflected in search", Support: 2,
Evidence: []string{"finding:10 (status=confirmed severity=high)"}},
{ID: 2, Kind: "negative", Cue: "ssrf", Action: "Do not\nre-report\x00 without new mechanics", Support: 1},
}
block, ids := RenderLessons(lessons, 2000)
if !strings.Contains(block, "not instructions") {
t.Fatalf("missing data-not-instructions header:\n%s", block)
}
if !strings.Contains(block, "[positive, 2 evidence]") || !strings.Contains(block, "[negative, 1 evidence]") {
t.Fatalf("missing kind/support labels:\n%s", block)
}
for _, line := range strings.Split(block, "\n") {
if strings.Contains(line, "\x00") {
t.Fatalf("control character survived: %q", line)
}
}
if !strings.Contains(block, "Do not re-report without new mechanics") {
t.Fatalf("lesson text was not flattened onto one line:\n%s", block)
}
if got, ids := RenderLessons(nil, 2000); got != "" || ids != nil {
t.Fatal("empty lesson set must render empty")
}
capped, cappedIDs := RenderLessons(lessons, 120)
if len(capped) > 160 {
t.Fatalf("cap not enforced: %d bytes", len(capped))
}
if len(ids) != 2 {
t.Fatalf("uncapped rendered IDs=%v, want both lessons", ids)
}
if len(cappedIDs) > len(ids) {
t.Fatalf("capped render logged more lessons than the full render")
}
}
func TestLessonTextDoesNotSplitUTF8(t *testing.T) {
// 60 CJK runes, 180 bytes. The old cut was s[:limit] in bytes.
in := strings.Repeat("验", 60)
got := lessonText(in, 20)
if !utf8.ValidString(got) {
t.Fatalf("truncated lesson text is not valid UTF-8: %q", got)
}
if n := utf8.RuneCountInString(got); n != 20 {
t.Fatalf("truncated to %d runes, want 20", n)
}
}
func TestRenderLessonsUsageOmitsTruncated(t *testing.T) {
lessons := []Lesson{
{ID: 11, Kind: "positive", Cue: "xss", Action: "Confirmed xss: " + strings.Repeat("a", 80), Support: 1},
{ID: 12, Kind: "negative", Cue: "ssrf", Action: "Do not re-report: " + strings.Repeat("b", 80), Support: 1},
}
block, ids := RenderLessons(lessons, 250)
if block == "" {
t.Fatal("expected at least the first lesson to fit")
}
if len(ids) == 0 || ids[0] != 11 {
t.Fatalf("rendered IDs=%v, want the first lesson", ids)
}
if len(ids) > 1 {
t.Fatalf("cap should have dropped the second lesson, got %v", ids)
}
}
func TestTaskLessonsUsesTaskScopeAndRanksCompanyFirst(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
cs := d.Companies()
companyA, _, err := cs.UpsertCompany(fmt.Sprintf("LessonCoA %d", stamp), "")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupCompany(d, companyA) })
companyB, _, err := cs.UpsertCompany(fmt.Sprintf("LessonCoB %d", stamp), "")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupCompany(d, companyB) })
taskA, err := d.CreateTaskWithOptions("lesson scope A", "goal", TaskCreateOptions{
Name: fmt.Sprintf("lesson-a-%d", stamp), CompanyIDs: []int64{companyA},
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task A", d.DeleteTask(taskA.ID)) })
taskB, err := d.CreateTaskWithOptions("lesson scope B", "goal", TaskCreateOptions{
Name: fmt.Sprintf("lesson-b-%d", stamp), CompanyIDs: []int64{companyB},
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task B", d.DeleteTask(taskB.ID)) })
genericKey := fmt.Sprintf("lesson-generic-%d", stamp)
aKey := fmt.Sprintf("lesson-a-%d", stamp)
bKey := fmt.Sprintf("lesson-b-%d", stamp)
var genericID, aID, bID int64
if err := d.QueryRow(`
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action,company_id)
VALUES ($1,'positive','xss','company A prior',$2) RETURNING id`, aKey, companyA).Scan(&aID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, aID) })
if err := d.QueryRow(`
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action,company_id)
VALUES ($1,'positive','xss','company B prior',$2) RETURNING id`, bKey, companyB).Scan(&bID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, bID) })
// Generic last: without the company rank term, id DESC would put this first.
if err := d.QueryRow(`
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action,company_id)
VALUES ($1,'positive','xss','generic prior',NULL) RETURNING id`, genericKey).Scan(&genericID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, genericID) })
got, err := d.TaskLessons(t.Context(), taskA.ID, 8)
if err != nil {
t.Fatal(err)
}
var sawGeneric, sawA, sawB bool
if len(got) == 0 {
t.Fatal("task A saw no lessons")
}
if got[0].ID != aID {
t.Fatalf("company-scoped lesson should rank first, got id=%d company=%d (want %d)", got[0].ID, got[0].CompanyID, aID)
}
for _, l := range got {
switch l.ID {
case genericID:
sawGeneric = true
case aID:
sawA = true
case bID:
sawB = true
}
}
if !sawA || !sawGeneric {
t.Fatalf("task A should see its company lesson and generic, sawA=%v sawGeneric=%v", sawA, sawGeneric)
}
if sawB {
t.Fatal("task A saw company B's lesson")
}
gotB, err := d.TaskLessons(t.Context(), taskB.ID, 8)
if err != nil {
t.Fatal(err)
}
for _, l := range gotB {
if l.ID == aID {
t.Fatal("task B saw company A's lesson")
}
}
}
func TestExtractLessonsScopesSingleCompanyFromTaskScope(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
companyID, _, err := d.Companies().UpsertCompany(fmt.Sprintf("LessonExtract %d", stamp), "")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupCompany(d, companyID) })
task, err := d.CreateTaskWithOptions("extract scope", "goal", TaskCreateOptions{
Name: fmt.Sprintf("lesson-extract-%d", stamp), CompanyIDs: []int64{companyID},
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "extract task", d.DeleteTask(task.ID)) })
if _, err := d.Exec(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,'xss','Reflected XSS','reflected in search','high','confirmed')`, task.ID); err != nil {
t.Fatal(err)
}
n, err := d.ExtractLessonsForTask(t.Context(), task.ID)
if err != nil {
t.Fatal(err)
}
if n != 1 {
t.Fatalf("extracted=%d, want 1", n)
}
lessons, err := d.TaskLessons(t.Context(), task.ID, 8)
if err != nil {
t.Fatal(err)
}
if len(lessons) == 0 {
t.Fatal("no lessons after extract")
}
var scoped *Lesson
for i := range lessons {
if lessons[i].CompanyID == companyID {
scoped = &lessons[i]
break
}
}
if scoped == nil {
t.Fatalf("extracted lesson was not scoped to company %d: %+v", companyID, lessons)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, scoped.ID) })
}
func TestExtractLessonsSkipsMultiCompanyTask(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
cs := d.Companies()
companyA, _, err := cs.UpsertCompany(fmt.Sprintf("LessonMultiA %d", stamp), "")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupCompany(d, companyA) })
companyB, _, err := cs.UpsertCompany(fmt.Sprintf("LessonMultiB %d", stamp), "")
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupCompany(d, companyB) })
task, err := d.CreateTaskWithOptions("extract multi company", "goal", TaskCreateOptions{
Name: fmt.Sprintf("lesson-multi-%d", stamp), CompanyIDs: []int64{companyA, companyB},
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "multi-company task", d.DeleteTask(task.ID)) })
findingID := insertLessonFinding(t, d, task.ID, "confirmed")
n, err := d.ExtractLessonsForTask(t.Context(), task.ID)
if err != nil {
t.Fatal(err)
}
if n != 0 {
t.Fatalf("extracted=%d, want 0 for a multi-company task", n)
}
var evidence int
if err := d.QueryRow(`
SELECT COUNT(*) FROM rsi_lesson_evidence
WHERE source_kind='finding' AND source_id=$1`, findingID).Scan(&evidence); err != nil {
t.Fatal(err)
}
if evidence != 0 {
t.Fatalf("multi-company extract wrote %d evidence rows", evidence)
}
}
func TestExtractLessonsGenericWhenTaskHasNoCompany(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTaskWithOptions("extract no company", "goal", TaskCreateOptions{
Name: fmt.Sprintf("lesson-nocompany-%d", stamp),
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "no-company task", d.DeleteTask(task.ID)) })
findingID := insertLessonFinding(t, d, task.ID, "confirmed")
n, err := d.ExtractLessonsForTask(t.Context(), task.ID)
if err != nil {
t.Fatal(err)
}
if n != 1 {
t.Fatalf("extracted=%d, want 1", n)
}
var lessonID, companyID int64
if err := d.QueryRow(`
SELECT l.id, COALESCE(l.company_id,0)
FROM rsi_lessons l
JOIN rsi_lesson_evidence e ON e.lesson_id=l.id
WHERE e.source_kind='finding' AND e.source_id=$1`, findingID).Scan(&lessonID, &companyID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, lessonID) })
if companyID != 0 {
t.Fatalf("no-company extract scoped lesson to company %d", companyID)
}
}
func TestTaskLessonsRanksCategoryBeforeGeneric(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
category, err := d.CreateTaskCategory(fmt.Sprintf("LessonCat %d", stamp))
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() {
_, err := d.DeleteTaskCategory(category.ID)
cleanupErr(t, "category", err)
})
task, err := d.CreateTaskWithOptions("lesson category rank", "goal", TaskCreateOptions{
Name: fmt.Sprintf("lesson-cat-%d", stamp), CategoryID: &category.ID,
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "category task", d.DeleteTask(task.ID)) })
var catID, genericID int64
if err := d.QueryRow(`
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action,category_id)
VALUES ($1,'positive','xss','category prior',$2) RETURNING id`,
fmt.Sprintf("lesson-cat-%d", stamp), category.ID).Scan(&catID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, catID) })
// Generic last: without the category rank term, id DESC would put this first.
if err := d.QueryRow(`
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action)
VALUES ($1,'positive','xss','generic prior') RETURNING id`,
fmt.Sprintf("lesson-cat-generic-%d", stamp)).Scan(&genericID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, genericID) })
got, err := d.TaskLessons(t.Context(), task.ID, 8)
if err != nil {
t.Fatal(err)
}
if len(got) == 0 {
t.Fatal("categorized task saw no lessons")
}
if got[0].ID != catID {
t.Fatalf("category-scoped lesson should rank first, got id=%d category=%d (want %d)",
got[0].ID, got[0].CategoryID, catID)
}
var sawCat, sawGeneric bool
for _, l := range got {
switch l.ID {
case catID:
sawCat = true
case genericID:
sawGeneric = true
}
}
if !sawCat || !sawGeneric {
t.Fatalf("want category and generic lessons, sawCat=%v sawGeneric=%v", sawCat, sawGeneric)
}
}
func TestLogLessonUsageRecordsOnlyRendered(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTaskWithOptions("lesson usage", "goal", TaskCreateOptions{
Name: fmt.Sprintf("lesson-usage-%d", stamp),
})
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "usage task", d.DeleteTask(task.ID)) })
var firstID, secondID int64
if err := d.QueryRow(`
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action)
VALUES ($1,'positive','xss',$2) RETURNING id`,
fmt.Sprintf("lesson-usage-a-%d", stamp),
"Confirmed xss: "+strings.Repeat("a", 80)).Scan(&firstID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, firstID) })
if err := d.QueryRow(`
INSERT INTO rsi_lessons(dedupe_key,kind,cue,action)
VALUES ($1,'negative','ssrf',$2) RETURNING id`,
fmt.Sprintf("lesson-usage-b-%d", stamp),
"Do not re-report: "+strings.Repeat("b", 80)).Scan(&secondID); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, secondID) })
lessons := []Lesson{
{ID: firstID, Kind: "positive", Cue: "xss", Action: "Confirmed xss: " + strings.Repeat("a", 80), Support: 1},
{ID: secondID, Kind: "negative", Cue: "ssrf", Action: "Do not re-report: " + strings.Repeat("b", 80), Support: 1},
}
_, ids := RenderLessons(lessons, 250)
if len(ids) != 1 || ids[0] != firstID {
t.Fatalf("rendered IDs=%v, want only %d", ids, firstID)
}
if err := d.LogLessonUsage(t.Context(), task.ID, ids, "shadow"); err != nil {
t.Fatal(err)
}
rows, err := d.Query(`SELECT lesson_id FROM rsi_lesson_usage WHERE task_id=$1 ORDER BY lesson_id`, task.ID)
if err != nil {
t.Fatal(err)
}
defer rows.Close()
var logged []int64
for rows.Next() {
var id int64
if err := rows.Scan(&id); err != nil {
t.Fatal(err)
}
logged = append(logged, id)
}
if err := rows.Err(); err != nil {
t.Fatal(err)
}
if len(logged) != 1 || logged[0] != firstID {
t.Fatalf("usage log=%v, want only rendered lesson %d (dropped %d)", logged, firstID, secondID)
}
}
func insertLessonFinding(t *testing.T, d *DB, taskID int64, status string) int64 {
t.Helper()
var id int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,'xss','Reflected XSS','reflected in search','high',$2)
RETURNING id`, taskID, status).Scan(&id); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, id) })
return id
}
func TestExtractLessonsRetractsReversedDisposition(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTask(fmt.Sprintf("lesson retract %d", stamp), "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
cue := fmt.Sprintf("xss-retract-%d", stamp)
label := fmt.Sprintf("reflected in search %d", stamp)
var fid int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&fid); err != nil {
t.Fatal(err)
}
n, err := d.ExtractLessonsForTask(t.Context(), task.ID)
if err != nil {
t.Fatal(err)
}
if n != 1 {
t.Fatalf("first extract=%d, want 1", n)
}
first, err := d.TaskLessons(t.Context(), task.ID, 8)
if err != nil {
t.Fatal(err)
}
var pos *Lesson
for i := range first {
if first[i].Kind == "positive" && strings.Contains(first[i].Action, label) {
pos = &first[i]
break
}
}
if pos == nil {
t.Fatalf("no positive lesson: %+v", first)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, pos.ID) })
posID := pos.ID
if _, err := d.SetFindingStatus(fid, FindingFalsePositive); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
var posStatus string
var posSupport int
if err := d.QueryRow(`SELECT status,
(SELECT COUNT(*) FROM rsi_lesson_evidence e WHERE e.lesson_id=rsi_lessons.id)
FROM rsi_lessons WHERE id=$1`, posID).Scan(&posStatus, &posSupport); err != nil {
t.Fatal(err)
}
if posStatus != "retired" || posSupport != 0 {
t.Fatalf("positive after FP: status=%s support=%d", posStatus, posSupport)
}
afterFP, err := d.TaskLessons(t.Context(), task.ID, 8)
if err != nil {
t.Fatal(err)
}
var neg *Lesson
for i := range afterFP {
if afterFP[i].ID == posID {
t.Fatal("retired positive still selected")
}
if afterFP[i].Kind == "negative" && strings.Contains(afterFP[i].Action, label) {
neg = &afterFP[i]
}
}
if neg == nil {
t.Fatalf("no negative lesson after FP: %+v", afterFP)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, neg.ID) })
if _, err := d.SetFindingStatus(fid, FindingConfirmed); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
if err := d.QueryRow(`SELECT status,
(SELECT COUNT(*) FROM rsi_lesson_evidence e WHERE e.lesson_id=rsi_lessons.id)
FROM rsi_lessons WHERE id=$1`, posID).Scan(&posStatus, &posSupport); err != nil {
t.Fatal(err)
}
if posStatus != "candidate" || posSupport != 1 {
t.Fatalf("positive after re-confirm: status=%s support=%d", posStatus, posSupport)
}
var negStatus string
var negSupport int
if err := d.QueryRow(`SELECT status,
(SELECT COUNT(*) FROM rsi_lesson_evidence e WHERE e.lesson_id=rsi_lessons.id)
FROM rsi_lessons WHERE id=$1`, neg.ID).Scan(&negStatus, &negSupport); err != nil {
t.Fatal(err)
}
if negStatus != "retired" || negSupport != 0 {
t.Fatalf("negative after re-confirm: status=%s support=%d", negStatus, negSupport)
}
}
func TestExtractLessonsRetireOnlyWhenLastEvidence(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTask(fmt.Sprintf("lesson shared retract %d", stamp), "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
cue := fmt.Sprintf("xss-shared-%d", stamp)
label := fmt.Sprintf("reflected in search %d", stamp)
var aID, bID int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&aID); err != nil {
t.Fatal(err)
}
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&bID); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
lessons, err := d.TaskLessons(t.Context(), task.ID, 8)
if err != nil {
t.Fatal(err)
}
var pos *Lesson
for i := range lessons {
if lessons[i].Kind == "positive" && strings.Contains(lessons[i].Action, label) {
pos = &lessons[i]
break
}
}
if pos == nil {
t.Fatalf("no shared positive lesson: %+v", lessons)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, pos.ID) })
if pos.Support != 2 {
t.Fatalf("shared support=%d, want 2", pos.Support)
}
if _, err := d.SetFindingStatus(aID, FindingFalsePositive); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
var status string
var support int
if err := d.QueryRow(`SELECT status,
(SELECT COUNT(*) FROM rsi_lesson_evidence e WHERE e.lesson_id=rsi_lessons.id)
FROM rsi_lessons WHERE id=$1`, pos.ID).Scan(&status, &support); err != nil {
t.Fatal(err)
}
if status == "retired" || support != 1 {
t.Fatalf("shared positive should stay active with support 1, got status=%s support=%d", status, support)
}
after, err := d.TaskLessons(t.Context(), task.ID, 8)
if err != nil {
t.Fatal(err)
}
var sawNeg bool
for i := range after {
if after[i].ID == pos.ID && after[i].Kind == "positive" {
if after[i].Support != 1 {
t.Fatalf("selected support=%d, want 1", after[i].Support)
}
}
if after[i].Kind == "negative" && strings.Contains(after[i].Action, label) {
sawNeg = true
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, after[i].ID) })
}
}
if !sawNeg {
t.Fatalf("expected a negative lesson for the flipped finding: %+v", after)
}
}
func TestExtractLessonsRetractsAllRetests(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTask(fmt.Sprintf("lesson all retests %d", stamp), "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
cue := fmt.Sprintf("xss-all-retest-%d", stamp)
label := fmt.Sprintf("reflected in search %d", stamp)
var fid int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&fid); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
r1 := insertLessonRetest(t, d, fid, "reproduced")
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
reproduced := findLessonByAction(t, d, task.ID, "positive", "Reproduced", label)
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, reproduced.ID) })
confirmed := findLessonByAction(t, d, task.ID, "positive", "Confirmed", label)
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, confirmed.ID) })
if positiveRetestEvidence(t, d, r1) != 1 {
t.Fatal("first retest was not extracted")
}
r2 := insertLessonRetest(t, d, fid, "fixed")
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
caution := findLessonByAction(t, d, task.ID, "caution", "Recheck", cue)
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, caution.ID) })
if positiveRetestEvidence(t, d, r1) != 1 {
t.Fatal("older reproduced retest lost its evidence after a later fixed retest")
}
if _, err := d.SetFindingStatus(fid, FindingFalsePositive); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
if n := positiveRetestEvidence(t, d, r1); n != 0 {
t.Fatalf("older retest still has %d positive evidence rows after FP", n)
}
if n := positiveRetestEvidence(t, d, r2); n != 0 {
t.Fatalf("latest retest still has %d positive evidence rows after FP", n)
}
status, support := lessonStatusSupport(t, d, reproduced.ID)
if status != "retired" || support != 0 {
t.Fatalf("reproduced retest lesson after FP: status=%s support=%d", status, support)
}
status, support = lessonStatusSupport(t, d, confirmed.ID)
if status != "retired" || support != 0 {
t.Fatalf("confirmed lesson after FP: status=%s support=%d", status, support)
}
neg := findLessonByAction(t, d, task.ID, "negative", "Do not re-report", label)
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, neg.ID) })
}
func TestExtractLessonsDoesNotUnretireWithEvidence(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTask(fmt.Sprintf("lesson keep retired %d", stamp), "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
cue := fmt.Sprintf("xss-keep-retired-%d", stamp)
label := fmt.Sprintf("reflected in search %d", stamp)
var fid int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&fid); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
pos := findLessonByAction(t, d, task.ID, "positive", "Confirmed", label)
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, pos.ID) })
if _, err := d.Exec(`UPDATE rsi_lessons SET status='retired' WHERE id=$1`, pos.ID); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
status, support := lessonStatusSupport(t, d, pos.ID)
if status != "retired" {
t.Fatalf("operator-retired lesson with evidence became %s", status)
}
if support != 1 {
t.Fatalf("support=%d, want 1", support)
}
}
func TestExtractLessonsLeavesAdopted(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTask(fmt.Sprintf("lesson keep adopted %d", stamp), "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
cue := fmt.Sprintf("xss-keep-adopted-%d", stamp)
label := fmt.Sprintf("reflected in search %d", stamp)
var fid int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&fid); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
pos := findLessonByAction(t, d, task.ID, "positive", "Confirmed", label)
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, pos.ID) })
if _, err := d.Exec(`UPDATE rsi_lessons SET status='adopted' WHERE id=$1`, pos.ID); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
status, _ := lessonStatusSupport(t, d, pos.ID)
if status != "adopted" {
t.Fatalf("adopted lesson became %s", status)
}
}
func TestExtractLessonsReopenRetractsNothing(t *testing.T) {
d, err := Open(testDSN(t))
if err != nil {
t.Skipf("postgres unavailable (%v) — skipping", err)
}
t.Cleanup(func() { d.Close() })
stamp := time.Now().UnixNano()
task, err := d.CreateTask(fmt.Sprintf("lesson reopen %d", stamp), "goal", nil, 0, 0)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupErr(t, "task", d.DeleteTask(task.ID)) })
cue := fmt.Sprintf("xss-reopen-%d", stamp)
label := fmt.Sprintf("reflected in search %d", stamp)
var fid int64
if err := d.QueryRow(`
INSERT INTO findings(task_id,vulnclass,name,summary,severity,status)
VALUES ($1,$2,'Reflected XSS',$3,'high','confirmed')
RETURNING id`, task.ID, cue, label).Scan(&fid); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM findings WHERE id=$1`, fid) })
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
pos := findLessonByAction(t, d, task.ID, "positive", "Confirmed", label)
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM rsi_lessons WHERE id=$1`, pos.ID) })
if _, err := d.SetFindingStatus(fid, FindingPending); err != nil {
t.Fatal(err)
}
if _, err := d.ExtractLessonsForTask(t.Context(), task.ID); err != nil {
t.Fatal(err)
}
status, support := lessonStatusSupport(t, d, pos.ID)
if status != "candidate" || support != 1 {
t.Fatalf("reopened finding retracted the lesson: status=%s support=%d", status, support)
}
}
func insertLessonRetest(t *testing.T, d *DB, findingID int64, verdict string) int64 {
t.Helper()
var id int64
if err := d.QueryRow(`
INSERT INTO finding_retests(finding_id,status,verdict,snapshot)
VALUES ($1,'completed',$2,'{}'::jsonb)
RETURNING id`, findingID, verdict).Scan(&id); err != nil {
t.Fatal(err)
}
t.Cleanup(func() { cleanupExec(t, d, `DELETE FROM finding_retests WHERE id=$1`, id) })
return id
}
func findLessonByAction(t *testing.T, d *DB, taskID int64, kind, actionPrefix, label string) *Lesson {
t.Helper()
lessons, err := d.TaskLessons(t.Context(), taskID, 8)
if err != nil {
t.Fatal(err)
}
for i := range lessons {
if lessons[i].Kind == kind && strings.Contains(lessons[i].Action, actionPrefix) && strings.Contains(lessons[i].Action, label) {
return &lessons[i]
}
}
t.Fatalf("no %s lesson with %q and %q: %+v", kind, actionPrefix, label, lessons)
return nil
}
func positiveRetestEvidence(t *testing.T, d *DB, retestID int64) int {
t.Helper()
var n int
if err := d.QueryRow(`
SELECT COUNT(*) FROM rsi_lesson_evidence e
JOIN rsi_lessons l ON l.id=e.lesson_id
WHERE e.source_kind='retest' AND e.source_id=$1 AND l.kind='positive'`, retestID).Scan(&n); err != nil {
t.Fatal(err)
}
return n
}
func lessonStatusSupport(t *testing.T, d *DB, lessonID int64) (status string, support int) {
t.Helper()
if err := d.QueryRow(`SELECT status,
(SELECT COUNT(*) FROM rsi_lesson_evidence e WHERE e.lesson_id=rsi_lessons.id)
FROM rsi_lessons WHERE id=$1`, lessonID).Scan(&status, &support); err != nil {
t.Fatal(err)
}
return status, support
}