Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

Go: fix context, part2 (#18296)

Jin Haifa5762336baa
diff --git a/internal/deepdoc/dla_test.go b/internal/deepdoc/dla_test.go
index 9e5ccee5d0..f5f60bccfe 100644
--- a/internal/deepdoc/dla_test.go
+++ b/internal/deepdoc/dla_test.go
@@ -116,7 +116,7 @@ func TestDLA_SuccessfulResponse(t *testing.T) {
defer srv.Close()
c := NewClientWithURL(srv.URL, fastBackoff())
- res, err := c.DLA(context.Background(), [][]byte{[]byte("jpg-bytes")})
+ res, err := c.DLA(t.Context(), [][]byte{[]byte("jpg-bytes")})
if err != nil {
t.Fatalf("DLA: %v", err)
}
@@ -163,7 +163,7 @@ func TestDLA_MultipartFieldNameAndContentType(t *testing.T) {
defer srv.Close()
c := NewClientWithURL(srv.URL, fastBackoff())
- if _, err := c.DLA(context.Background(), [][]byte{[]byte("PAYLOAD")}); err != nil {
+ if _, err := c.DLA(t.Context(), [][]byte{[]byte("PAYLOAD")}); err != nil {
t.Fatalf("DLA: %v", err)
}
if gotBody != "PAYLOAD" {
@@ -194,7 +194,7 @@ func TestDLA_PartContentType(t *testing.T) {
defer srv.Close()
c := NewClientWithURL(srv.URL, fastBackoff())
- if _, err := c.DLA(context.Background(), [][]byte{[]byte("img")}); err != nil {
+ if _, err := c.DLA(t.Context(), [][]byte{[]byte("img")}); err != nil {
t.Fatalf("DLA: %v", err)
}
if gotCT != "image/jpeg" {
@@ -211,7 +211,7 @@ func TestDLA_TrimsTrailingSlash(t *testing.T) {
defer srv.Close()
c := NewClientWithURL(srv.URL+"/", fastBackoff())
- if _, err := c.DLA(context.Background(), [][]byte{[]byte("img")}); err != nil {
+ if _, err := c.DLA(t.Context(), [][]byte{[]byte("img")}); err != nil {
t.Fatalf("DLA: %v", err)
}
if hit != "/predict" {
@@ -232,7 +232,7 @@ func TestDLA_RetriesOn5xxThenSucceeds(t *testing.T) {
defer srv.Close()
c := NewClientWithURL(srv.URL, fastBackoff(), WithMaxAttempts(3))
- res, err := c.DLA(context.Background(), [][]byte{[]byte("img")})
+ res, err := c.DLA(t.Context(), [][]byte{[]byte("img")})
if err != nil {
t.Fatalf("DLA: %v", err)
}
@@ -250,7 +250,7 @@ func TestDLA_ExhaustsRetriesOnPersistent5xx(t *testing.T) {
defer srv.Close()
c := NewClientWithURL(srv.URL, fastBackoff(), WithMaxAttempts(3))
- res, err := c.DLA(context.Background(), [][]byte{[]byte("img")})
+ res, err := c.DLA(t.Context(), [][]byte{[]byte("img")})
if err != nil {
t.Fatalf("DLA error=%v, want nil (per-image failures map to empty slot)", err)
}
@@ -271,7 +271,7 @@ func TestDLA_4xxReturnsEmpty(t *testing.T) {
defer srv.Close()
c := NewClientWithURL(srv.URL, fastBackoff(), WithMaxAttempts(5))
- res, err := c.DLA(context.Background(), [][]byte{[]byte("img")})
+ res, err := c.DLA(t.Context(), [][]byte{[]byte("img")})
if err != nil {
t.Fatalf("DLA error=%v, want nil", err)
}
@@ -297,7 +297,7 @@ func TestDLA_RetriesOnMalformedJSON(t *testing.T) {
defer srv.Close()
c := NewClientWithURL(srv.URL, fastBackoff(), WithMaxAttempts(3))
- res, err := c.DLA(context.Background(), [][]byte{[]byte("img")})
+ res, err := c.DLA(t.Context(), [][]byte{[]byte("img")})
if err != nil {
t.Fatalf("DLA: %v", err)
}
@@ -319,7 +319,7 @@ func TestDLA_RetriesOnMissingBBoxes(t *testing.T) {
defer srv.Close()
c := NewClientWithURL(srv.URL, fastBackoff(), WithMaxAttempts(3))
- res, err := c.DLA(context.Background(), [][]byte{[]byte("img")})
+ res, err := c.DLA(t.Context(), [][]byte{[]byte("img")})
if err != nil {
t.Fatalf("DLA: %v", err)
}
@@ -345,7 +345,7 @@ func TestDLA_PerImageIsolation(t *testing.T) {
defer srv.Close()
c := NewClientWithURL(srv.URL, fastBackoff(), WithMaxAttempts(2))
- res, err := c.DLA(context.Background(), [][]byte{[]byte("a"), []byte("b")})
+ res, err := c.DLA(t.Context(), [][]byte{[]byte("a"), []byte("b")})
if err != nil {
t.Fatalf("DLA: %v", err)
}
@@ -368,7 +368,7 @@ func TestDLA_SkipsShortBBoxes(t *testing.T) {
defer srv.Close()
c := NewClientWithURL(srv.URL, fastBackoff())
- res, err := c.DLA(context.Background(), [][]byte{[]byte("img")})
+ res, err := c.DLA(t.Context(), [][]byte{[]byte("img")})
if err != nil {
t.Fatalf("DLA: %v", err)
}
@@ -388,7 +388,7 @@ func TestDLA_OutOfRangeTypeIdxMapsToEmptyString(t *testing.T) {
defer srv.Close()
c := NewClientWithURL(srv.URL, fastBackoff())
- res, err := c.DLA(context.Background(), [][]byte{[]byte("img")})
+ res, err := c.DLA(t.Context(), [][]byte{[]byte("img")})
if err != nil {
t.Fatalf("DLA: %v", err)
}
@@ -418,7 +418,7 @@ func TestDLA_ContextCancelDuringBackoff(t *testing.T) {
// 2. The server is hit exactly once — no second retry attempt
// starts after ctx cancellation lands during the first backoff.
c := NewClientWithURL(srv.URL, WithBackoff(5*time.Second), WithMaxAttempts(5))
- ctx, cancel := context.WithCancel(context.Background())
+ ctx, cancel := context.WithCancel(t.Context())
go func() {
time.Sleep(50 * time.Millisecond)
cancel()
diff --git a/internal/deepdoc/parser/pdf/crop_integration_test.go b/internal/deepdoc/parser/pdf/crop_integration_test.go
index beb5ff25b2..1d6e0a47f4 100644
--- a/internal/deepdoc/parser/pdf/crop_integration_test.go
+++ b/internal/deepdoc/parser/pdf/crop_integration_test.go
@@ -4,7 +4,6 @@ package pdf
import (
"bytes"
- "context"
"encoding/base64"
"image/png"
"os"
@@ -28,7 +27,7 @@ func TestParse_CropSectionImages(t *testing.T) {
cfg := pdf.DefaultParserConfig()
p := NewParser(cfg)
- result, err := p.ParseRaw(context.Background(), eng, &MockDocAnalyzer{Healthy: true})
+ result, err := p.ParseRaw(t.Context(), eng, &MockDocAnalyzer{Healthy: true})
if err != nil {
t.Fatalf("Parse: %v", err)
}
@@ -80,7 +79,7 @@ func TestCrop_Regression_SnapshotPDFs(t *testing.T) {
defer eng.Close()
p := NewParser(pdf.DefaultParserConfig())
- result, err := p.ParseRaw(context.Background(), eng, &MockDocAnalyzer{Healthy: true})
+ result, err := p.ParseRaw(t.Context(), eng, &MockDocAnalyzer{Healthy: true})
if err != nil {
t.Fatalf("Parse: %v", err)
}
diff --git a/internal/deepdoc/parser/pdf/dla_tsr_compare_test.go b/internal/deepdoc/parser/pdf/dla_tsr_compare_test.go
index 32e5f91337..dcda1ce7c8 100644
--- a/internal/deepdoc/parser/pdf/dla_tsr_compare_test.go
+++ b/internal/deepdoc/parser/pdf/dla_tsr_compare_test.go
@@ -3,7 +3,6 @@
package pdf
import (
- "context"
"encoding/json"
"image"
"image/png"
@@ -45,8 +44,9 @@ func TestDLATSRResponseCompare(t *testing.T) {
os.WriteFile(imgPath, jpegData, 0644)
t.Logf("Input image saved: %s (%dx%d, %d bytes JPEG)", imgPath, pageImg.Bounds().Dx(), pageImg.Bounds().Dy(), len(jpegData))
+ ctx := t.Context()
// ── DLA ──
- regions, err := client.DLA(context.Background(), pageImg)
+ regions, err := client.DLA(ctx, pageImg)
if err != nil {
t.Fatalf("DLA: %v", err)
}
@@ -77,7 +77,7 @@ func TestDLATSRResponseCompare(t *testing.T) {
cropJPEG, _ := util.EncodeJPEG(cropped)
os.WriteFile(cropPath, cropJPEG, 0644)
- cells, err := client.TSR(context.Background(), cropped)
+ cells, err := client.TSR(ctx, cropped)
if err != nil {
t.Fatalf("TSR: %v", err)
}
@@ -90,7 +90,7 @@ func TestDLATSRResponseCompare(t *testing.T) {
}
// ── OCR Detect ──
- detectBoxes, err := client.OCRDetect(context.Background(), pageImg)
+ detectBoxes, err := client.OCRDetect(ctx, pageImg)
if err != nil {
t.Fatalf("OCRDetect: %v", err)
}
@@ -109,7 +109,8 @@ func TestDLATSRResponseCompare(t *testing.T) {
recJPEG, _ := util.EncodeJPEG(cropped)
os.WriteFile(cropPath, recJPEG, 0644)
- texts, err := client.OCRRecognize(context.Background(), cropped)
+ var texts []pdf.OCRText
+ texts, err = client.OCRRecognize(ctx, cropped)
if err != nil {
t.Fatalf("OCRRecognize: %v", err)
}
diff --git a/internal/deepdoc/parser/pdf/ocr_merge_test.go b/internal/deepdoc/parser/pdf/ocr_merge_test.go
index 5cf0e0e9bb..2ae249eb80 100644
--- a/internal/deepdoc/parser/pdf/ocr_merge_test.go
+++ b/internal/deepdoc/parser/pdf/ocr_merge_test.go
@@ -3,7 +3,6 @@
package pdf
import (
- "context"
"image/png"
"os"
"ragflow/internal/common"
@@ -64,8 +63,8 @@ func TestOCR_mergeChars_RealScanned(t *testing.T) {
}
p := NewParser(pdftype.ParserConfig{})
-
- boxes := p.ocrMergeChars(context.Background(), img, chars, dd, 0)
+ ctx := t.Context()
+ boxes := p.ocrMergeChars(ctx, img, chars, dd, 0)
t.Logf("ocrMergeChars boxes: %d", len(boxes))
for i, b := range boxes {
// Save go render for comparison
@@ -78,7 +77,7 @@ func TestOCR_mergeChars_RealScanned(t *testing.T) {
i, b.X0, b.Top, b.X1, b.Bottom, b.Text[:end])
}
- scanBoxes := p.ocrDetectAndRecognize(context.Background(), img, dd, 0, "scan page")
+ scanBoxes := p.ocrDetectAndRecognize(ctx, img, dd, 0, "scan page")
t.Logf("ocrScanPage boxes (no chars): %d", len(scanBoxes))
for i, b := range scanBoxes {
end := min(120, len(b.Text))
diff --git a/internal/deepdoc/parser/pdf/parser_ocr_test.go b/internal/deepdoc/parser/pdf/parser_ocr_test.go
index 109c76bb00..529e019844 100644
--- a/internal/deepdoc/parser/pdf/parser_ocr_test.go
+++ b/internal/deepdoc/parser/pdf/parser_ocr_test.go
@@ -1,7 +1,6 @@
package pdf
import (
- "context"
pdf "ragflow/internal/deepdoc/parser/pdf/type"
util "ragflow/internal/deepdoc/parser/pdf/util"
"testing"
@@ -26,7 +25,7 @@ func TestOCRMergeChars_FullCoverage(t *testing.T) {
{X0: 12, X1: 28, Top: 2, Bottom: 35, Text: "World"},
}
- boxes := p.ocrMergeChars(context.Background(), testPageImg(), chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), testPageImg(), chars, mock, 0)
if len(boxes) != 1 {
t.Fatalf("expected 1 box, got %d", len(boxes))
}
@@ -55,7 +54,7 @@ func TestOCRMergeChars_PartialCoverage(t *testing.T) {
{X0: 2, X1: 12, Top: 2, Bottom: 15, Text: "A"},
}
- boxes := p.ocrMergeChars(context.Background(), testPageImg(), chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), testPageImg(), chars, mock, 0)
if len(boxes) != 2 {
t.Fatalf("expected 2 boxes, got %d", len(boxes))
}
@@ -81,14 +80,15 @@ func TestOCRMergeChars_NoDetectBoxes(t *testing.T) {
{X0: 2, X1: 10, Top: 2, Bottom: 8, Text: "Hello"},
}
- boxes := p.ocrMergeChars(context.Background(), testPageImg(), chars, mock, 0)
+ ctx := t.Context()
+ boxes := p.ocrMergeChars(ctx, testPageImg(), chars, mock, 0)
if boxes != nil {
t.Errorf("expected nil for no detect boxes, got %d boxes", len(boxes))
}
// Also test empty OCRBoxes
mock.OCRBoxes = []pdf.OCRBox{}
- boxes = p.ocrMergeChars(context.Background(), testPageImg(), chars, mock, 0)
+ boxes = p.ocrMergeChars(ctx, testPageImg(), chars, mock, 0)
if boxes != nil {
t.Errorf("expected nil for empty detect boxes, got %d boxes", len(boxes))
}
@@ -114,7 +114,7 @@ func TestOCRMergeChars_GarbledChars(t *testing.T) {
{X0: 22, X1: 28, Top: 2, Bottom: 35, Text: "a"}, // normal
}
- boxes := p.ocrMergeChars(context.Background(), testPageImg(), chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), testPageImg(), chars, mock, 0)
if len(boxes) != 1 {
t.Fatalf("expected 1 box, got %d", len(boxes))
}
@@ -143,7 +143,7 @@ func TestOCRMergeChars_HeightGate(t *testing.T) {
{X0: 2, X1: 10, Top: 2, Bottom: 3, Text: "tiny"},
}
- boxes := p.ocrMergeChars(context.Background(), testPageImg(), chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), testPageImg(), chars, mock, 0)
if len(boxes) != 1 {
t.Fatalf("expected 1 box (OCR fallback after height gate), got %d", len(boxes))
}
@@ -174,7 +174,7 @@ func TestOCRMergeChars_FontEncodingGarbled(t *testing.T) {
Text: "#", FontName: "DY1+SimSun", PageNumber: 0,
}
}
- boxes := p.ocrMergeChars(context.Background(), testPageImg(), chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), testPageImg(), chars, mock, 0)
if len(boxes) != 1 {
t.Fatalf("expected 1 OCR-fallback box, got %d", len(boxes))
}
@@ -253,7 +253,7 @@ func TestOCRMergeChars_MixedFontSizes(t *testing.T) {
{X0: 12, X1: 24, Top: 5, Bottom: 35, Text: "大"}, // larger font, lower baseline
{X0: 24, X1: 36, Top: 5, Bottom: 35, Text: "号"}, // same size as 大, rightmost
}
- boxes := p.ocrMergeChars(context.Background(), testPageImg(), chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), testPageImg(), chars, mock, 0)
if len(boxes) != 1 {
t.Fatalf("expected 1 box, got %d", len(boxes))
}
@@ -285,7 +285,7 @@ func TestOCRMergeChars_BoxOrder(t *testing.T) {
{X0: 2, X1: 10, Top: 16, Bottom: 19, Text: "B"}, // box 2 (middle)
{X0: 2, X1: 10, Top: 32, Bottom: 37, Text: "C"}, // box 3 (bottom)
}
- boxes := p.ocrMergeChars(context.Background(), testPageImg(), chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), testPageImg(), chars, mock, 0)
if len(boxes) != 3 {
t.Fatalf("expected 3 boxes, got %d", len(boxes))
}
@@ -323,7 +323,7 @@ func TestOCRMergeChars_OverlappingBoxes(t *testing.T) {
{X0: 12, X1: 18, Top: 2, Bottom: 12, Text: "乙"}, // overlap zone
{X0: 22, X1: 28, Top: 2, Bottom: 12, Text: "丙"}, // Box B only
}
- boxes := p.ocrMergeChars(context.Background(), testPageImg(), chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), testPageImg(), chars, mock, 0)
if len(boxes) != 2 {
t.Fatalf("expected 2 boxes, got %d", len(boxes))
}
diff --git a/internal/deepdoc/parser/pdf/parser_test.go b/internal/deepdoc/parser/pdf/parser_test.go
index 38829c1075..797e961113 100644
--- a/internal/deepdoc/parser/pdf/parser_test.go
+++ b/internal/deepdoc/parser/pdf/parser_test.go
@@ -1,7 +1,6 @@
package pdf
import (
- "context"
"image"
"math"
"strings"
@@ -39,14 +38,14 @@ func TestOCR_Fallback(t *testing.T) {
dummyImg := image.NewRGBA(image.Rect(0, 0, 100, 100))
t.Run("nil image", func(t *testing.T) {
- if got := p.ocrDetectAndRecognize(context.Background(), nil, &MockDocAnalyzer{Healthy: true}, 0, "garbled page"); got != nil {
+ if got := p.ocrDetectAndRecognize(t.Context(), nil, &MockDocAnalyzer{Healthy: true}, 0, "garbled page"); got != nil {
t.Error("nil image → nil")
}
})
t.Run("detect returns no boxes", func(t *testing.T) {
mock := &MockDocAnalyzer{Healthy: true, OCRBoxes: nil}
- if got := p.ocrDetectAndRecognize(context.Background(), dummyImg, mock, 0, "garbled page"); got != nil {
+ if got := p.ocrDetectAndRecognize(t.Context(), dummyImg, mock, 0, "garbled page"); got != nil {
t.Error("no det boxes → nil")
}
})
@@ -57,7 +56,7 @@ func TestOCR_Fallback(t *testing.T) {
OCRBoxes: []pdf.OCRBox{{X0: 10, Y0: 20, X1: 90, Y1: 20, X2: 90, Y2: 40, X3: 10, Y3: 40}},
OCRTexts: []pdf.OCRText{{Text: "Hello", Confidence: 0.9}},
}
- got := p.ocrDetectAndRecognize(context.Background(), dummyImg, mock, 0, "garbled page")
+ got := p.ocrDetectAndRecognize(t.Context(), dummyImg, mock, 0, "garbled page")
if len(got) != 1 {
t.Fatalf("expected 1 pdf.TextChar, got %d", len(got))
}
@@ -72,7 +71,7 @@ func TestOCR_Fallback(t *testing.T) {
OCRBoxes: []pdf.OCRBox{{X0: 10, Y0: 20, X1: 90, Y1: 20, X2: 90, Y2: 40, X3: 10, Y3: 40}},
OCRTexts: []pdf.OCRText{{Text: "", Confidence: 0.1}},
}
- got := p.ocrDetectAndRecognize(context.Background(), dummyImg, mock, 0, "garbled page")
+ got := p.ocrDetectAndRecognize(t.Context(), dummyImg, mock, 0, "garbled page")
if len(got) != 0 {
t.Error("empty rec text → empty result")
}
@@ -88,14 +87,14 @@ func TestOCR_ScanPage(t *testing.T) {
dummyImg := image.NewRGBA(image.Rect(0, 0, 100, 100))
t.Run("nil image", func(t *testing.T) {
- if got := p.ocrDetectAndRecognize(context.Background(), nil, &MockDocAnalyzer{Healthy: true}, 0, "scan page"); got != nil {
+ if got := p.ocrDetectAndRecognize(t.Context(), nil, &MockDocAnalyzer{Healthy: true}, 0, "scan page"); got != nil {
t.Error("nil image → nil")
}
})
t.Run("detect returns no boxes", func(t *testing.T) {
mock := &MockDocAnalyzer{Healthy: true, OCRBoxes: nil}
- if got := p.ocrDetectAndRecognize(context.Background(), dummyImg, mock, 0, "scan page"); got != nil {
+ if got := p.ocrDetectAndRecognize(t.Context(), dummyImg, mock, 0, "scan page"); got != nil {
t.Error("no det boxes → nil")
}
})
@@ -109,7 +108,7 @@ func TestOCR_ScanPage(t *testing.T) {
},
OCRTexts: []pdf.OCRText{{Text: "Hello", Confidence: 0.9}, {Text: "World", Confidence: 0.8}},
}
- got := p.ocrDetectAndRecognize(context.Background(), dummyImg, mock, 0, "scan page")
+ got := p.ocrDetectAndRecognize(t.Context(), dummyImg, mock, 0, "scan page")
if len(got) < 1 {
t.Error("expected at least 1 pdf.TextChar")
}
@@ -121,7 +120,7 @@ func TestOCR_ScanPage(t *testing.T) {
OCRBoxes: []pdf.OCRBox{{X0: 10, Y0: 20, X1: 90, Y1: 20, X2: 90, Y2: 40, X3: 10, Y3: 40}},
OCRTexts: []pdf.OCRText{},
}
- got := p.ocrDetectAndRecognize(context.Background(), dummyImg, mock, 0, "scan page")
+ got := p.ocrDetectAndRecognize(t.Context(), dummyImg, mock, 0, "scan page")
if len(got) != 0 {
t.Error("no rec text → empty")
}
@@ -140,7 +139,7 @@ func TestOCR_TableCell(t *testing.T) {
mock := &MockDocAnalyzer{Healthy: true, OCRTexts: []pdf.OCRText{{Text: "识别结果", Confidence: 0.9}}}
dummy := image.NewRGBA(image.Rect(0, 0, 200, 50))
- p.ocrTableCells(context.Background(), cells, dummy, mock)
+ p.ocrTableCells(t.Context(), cells, dummy, mock)
if cells[0].Text != "识别结果" {
t.Errorf("empty cell not filled: %q", cells[0].Text)
@@ -155,20 +154,21 @@ func TestOCR_TableCell(t *testing.T) {
{X0: 0, Y0: 0, X1: 100, Y1: 50, Text: "A"},
{X0: 100, Y0: 0, X1: 200, Y1: 50, Text: "B"},
}
- p.ocrTableCells(context.Background(), cells, nil, nil) // should not panic
+ p.ocrTableCells(t.Context(), cells, nil, nil) // should not panic
if cells[0].Text != "A" || cells[1].Text != "B" {
t.Error("filled cells should not change")
}
})
t.Run("empty cells list", func(t *testing.T) {
- p.ocrTableCells(context.Background(), nil, nil, nil) // should not panic
- p.ocrTableCells(context.Background(), []pdf.TSRCell{}, nil, nil)
+ ctx := t.Context()
+ p.ocrTableCells(ctx, nil, nil, nil) // should not panic
+ p.ocrTableCells(ctx, []pdf.TSRCell{}, nil, nil)
})
t.Run("no DeepDoc — skip", func(t *testing.T) {
cells := []pdf.TSRCell{{X0: 0, Y0: 0, X1: 100, Y1: 50, Text: ""}}
- p.ocrTableCells(context.Background(), cells, nil, nil)
+ p.ocrTableCells(t.Context(), cells, nil, nil)
if cells[0].Text != "" {
t.Error("without DeepDoc, cell should stay empty")
}
@@ -177,7 +177,7 @@ func TestOCR_TableCell(t *testing.T) {
t.Run("no cropped image — skip", func(t *testing.T) {
cells := []pdf.TSRCell{{X0: 0, Y0: 0, X1: 100, Y1: 50, Text: ""}}
mock := &MockDocAnalyzer{Healthy: true, OCRTexts: []pdf.OCRText{{Text: "x", Confidence: 0.5}}}
- p.ocrTableCells(context.Background(), cells, nil, mock)
+ p.ocrTableCells(t.Context(), cells, nil, mock)
if cells[0].Text != "" {
t.Error("without image, cell should stay empty")
}
@@ -187,7 +187,7 @@ func TestOCR_TableCell(t *testing.T) {
cells := []pdf.TSRCell{{X0: 0, Y0: 0, X1: 100, Y1: 50, Text: ""}}
mock := &MockDocAnalyzer{Healthy: true, OCRTexts: []pdf.OCRText{}}
dummy := image.NewRGBA(image.Rect(0, 0, 100, 50))
- p.ocrTableCells(context.Background(), cells, dummy, mock)
+ p.ocrTableCells(t.Context(), cells, dummy, mock)
if cells[0].Text != "" {
t.Error("empty OCR result → cell stays empty")
}
@@ -198,7 +198,7 @@ func TestOCR_TableCell(t *testing.T) {
mock := &MockDocAnalyzer{Healthy: true, OCRTexts: []pdf.OCRText{{Text: "out of bounds", Confidence: 0.9}}}
dummy := image.NewRGBA(image.Rect(0, 0, 100, 100))
// Should not panic — gracefully degrade
- p.ocrTableCells(context.Background(), cells, dummy, mock)
+ p.ocrTableCells(t.Context(), cells, dummy, mock)
t.Logf("out-of-bounds cell: text=%q", cells[0].Text)
})
}
@@ -234,7 +234,7 @@ func TestOCR_FallbackIntegration_NoDeepDoc(t *testing.T) {
cfg := pdf.DefaultParserConfig()
p := NewParser(cfg)
- result, err := p.ParseRaw(context.Background(), mockEng, mockDLA)
+ result, err := p.ParseRaw(t.Context(), mockEng, mockDLA)
if err != nil {
t.Fatal(err)
}
@@ -267,7 +267,7 @@ func TestNoDeepDoc_PdfOxideUnmapped_KeepsChars(t *testing.T) {
mockEng := &MockEngine{Chars: map[int][]pdf.TextChar{0: chars}, NumPages: 1}
mockDLA := &MockDocAnalyzer{Healthy: true}
p := NewParser(pdf.DefaultParserConfig())
- result, err := p.ParseRaw(context.Background(), mockEng, mockDLA)
+ result, err := p.ParseRaw(t.Context(), mockEng, mockDLA)
if err != nil {
t.Fatal(err)
}
@@ -340,7 +340,7 @@ func TestOCR_Fallback_PUAGarbled(t *testing.T) {
OCRBoxes: []pdf.OCRBox{{X0: 10, Y0: 20, X1: 90, Y1: 20, X2: 90, Y2: 40, X3: 10, Y3: 40}},
OCRTexts: []pdf.OCRText{{Text: "PUA OCR text", Confidence: 0.9}},
}
- got := p.ocrDetectAndRecognize(context.Background(), dummyImg, mock, 0, "garbled page")
+ got := p.ocrDetectAndRecognize(t.Context(), dummyImg, mock, 0, "garbled page")
if len(got) != 1 || got[0].Text != "PUA OCR text" {
t.Errorf("PUA garbled should trigger OCR, got %v", got)
}
@@ -354,7 +354,7 @@ func TestOCR_MergeChars(t *testing.T) {
t.Run("nil image", func(t *testing.T) {
chars := []pdf.TextChar{{X0: 10, Top: 10, X1: 20, Bottom: 30, Text: "A", PageNumber: 0}}
- if boxes := p.ocrMergeChars(context.Background(), nil, chars, &MockDocAnalyzer{Healthy: true}, 0); boxes != nil {
+ if boxes := p.ocrMergeChars(t.Context(), nil, chars, &MockDocAnalyzer{Healthy: true}, 0); boxes != nil {
t.Error("nil image → nil")
}
})
@@ -362,7 +362,7 @@ func TestOCR_MergeChars(t *testing.T) {
t.Run("detect returns no boxes", func(t *testing.T) {
mock := &MockDocAnalyzer{Healthy: true, OCRBoxes: []pdf.OCRBox{}}
chars := []pdf.TextChar{{X0: 10, Top: 10, X1: 20, Bottom: 30, Text: "A", PageNumber: 0}}
- if boxes := p.ocrMergeChars(context.Background(), dummyImg, chars, mock, 0); boxes != nil {
+ if boxes := p.ocrMergeChars(t.Context(), dummyImg, chars, mock, 0); boxes != nil {
t.Error("no detect boxes → nil")
}
})
@@ -374,7 +374,7 @@ func TestOCR_MergeChars(t *testing.T) {
OCRTexts: []pdf.OCRText{{Text: "Hello OCR", Confidence: 0.9}},
}
chars := []pdf.TextChar{{X0: 10, X1: 30, Top: 10, Bottom: 30, Text: "Hello", PageNumber: 0}}
- boxes := p.ocrMergeChars(context.Background(), dummyImg, chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), dummyImg, chars, mock, 0)
if len(boxes) != 1 {
t.Fatalf("expected 1 box, got %d", len(boxes))
}
@@ -391,7 +391,7 @@ func TestOCR_MergeChars(t *testing.T) {
OCRTexts: []pdf.OCRText{{Text: "OCR", Confidence: 0.9}},
}
chars := []pdf.TextChar{{X0: 10, X1: 20, Top: 10, Bottom: 20, Text: "A", PageNumber: 0}}
- boxes := p.ocrMergeChars(context.Background(), dummyImg, chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), dummyImg, chars, mock, 0)
if len(boxes) != 1 {
t.Fatalf("expected 1 box (OCR), got %d", len(boxes))
}
@@ -407,7 +407,7 @@ func TestOCR_MergeChars(t *testing.T) {
OCRTexts: []pdf.OCRText{},
}
chars := []pdf.TextChar{{X0: 10, X1: 20, Top: 10, Bottom: 20, Text: "A", PageNumber: 0}}
- boxes := p.ocrMergeChars(context.Background(), dummyImg, chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), dummyImg, chars, mock, 0)
if len(boxes) != 0 {
t.Fatalf("expected 0 boxes (empty OCR), got %d", len(boxes))
}
@@ -426,7 +426,7 @@ func TestOCR_MergeChars(t *testing.T) {
},
}
chars := []pdf.TextChar{{X0: 10, X1: 30, Top: 10, Bottom: 30, Text: "Hello", PageNumber: 0}}
- boxes := p.ocrMergeChars(context.Background(), dummyImg, chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), dummyImg, chars, mock, 0)
if len(boxes) != 2 {
t.Fatalf("expected 2 boxes, got %d", len(boxes))
}
@@ -454,7 +454,7 @@ func TestOCR_MergeChars(t *testing.T) {
{X0: 70, X1: 90, Top: 110, Bottom: 130, Text: "c", PageNumber: 0},
{X0: 10, X1: 30, Top: 10, Bottom: 30, Text: "a", PageNumber: 0},
}
- boxes := p.ocrMergeChars(context.Background(), dummyImg, chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), dummyImg, chars, mock, 0)
if len(boxes) != 2 {
t.Fatalf("expected 2 detect boxes, got %d", len(boxes))
}
@@ -481,7 +481,7 @@ func TestOCR_MergeChars(t *testing.T) {
{X0: 10, X1: 30, Top: 30, Bottom: 50, Text: "A", PageNumber: 0},
{X0: 40, X1: 60, Top: 20, Bottom: 120, Text: "B", PageNumber: 0},
}
- boxes := p.ocrMergeChars(context.Background(), dummyImg, chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), dummyImg, chars, mock, 0)
if len(boxes) != 1 {
t.Fatalf("expected 1 box, got %d", len(boxes))
}
@@ -504,7 +504,7 @@ func TestOCR_MergeChars(t *testing.T) {
{X0: 30, X1: 40, Top: 10, Bottom: 20, Text: "", PageNumber: 0},
{X0: 50, X1: 60, Top: 10, Bottom: 20, Text: "a", PageNumber: 0},
}
- boxes := p.ocrMergeChars(context.Background(), dummyImg, chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), dummyImg, chars, mock, 0)
if len(boxes) != 1 {
t.Fatalf("expected 1 box, got %d", len(boxes))
}
@@ -526,7 +526,7 @@ func TestOCR_MergeChars(t *testing.T) {
{Text: "d", X0: 10, X1: 20, Top: 10, Bottom: 25, PageNumber: 0},
{Text: "o", X0: 21, X1: 30, Top: 10, Bottom: 25, PageNumber: 0},
}
- boxes := p.ocrMergeChars(context.Background(), dummyImg, chars, mock, 0)
+ boxes := p.ocrMergeChars(t.Context(), dummyImg, chars, mock, 0)
if len(boxes) != 1 {
t.Fatalf("expected 1 box, got %d", len(boxes))
}
@@ -591,7 +591,7 @@ func TestParser_ConcurrentSafety(t *testing.T) {
wg.Go(func() {
for range 5 {
eng := &MockEngine{NumPages: 2}
- if _, err := p.ParseRaw(context.Background(), eng, mockDLA); err != nil {
+ if _, err := p.ParseRaw(t.Context(), eng, mockDLA); err != nil {
t.Errorf("ParseRaw: %v", err)
}
}
@@ -610,7 +610,7 @@ func TestParseRaw_PageDimensions(t *testing.T) {
cfg := pdf.DefaultParserConfig()
cfg.Zoom = 3
p := NewParser(cfg)
- result, err := p.ParseRaw(context.Background(), eng, mockDLA)
+ result, err := p.ParseRaw(t.Context(), eng, mockDLA)
if err != nil {
t.Fatalf("ParseRaw: %v", err)
}
@@ -631,7 +631,7 @@ func TestParseRaw_ZeroZoom_NoNaN(t *testing.T) {
cfg := pdf.DefaultParserConfig()
cfg.Zoom = 0
p := NewParser(cfg)
- result, err := p.ParseRaw(context.Background(), eng, mockDLA)
+ result, err := p.ParseRaw(t.Context(), eng, mockDLA)
if err != nil {
t.Fatalf("ParseRaw: %v", err)
}
diff --git a/internal/deepdoc/parser/pdf/table_rotate_integration_test.go b/internal/deepdoc/parser/pdf/table_rotate_integration_test.go
index 77afea4402..30ecd030fe 100644
--- a/internal/deepdoc/parser/pdf/table_rotate_integration_test.go
+++ b/internal/deepdoc/parser/pdf/table_rotate_integration_test.go
@@ -3,7 +3,6 @@
package pdf
import (
- "context"
"os"
"path/filepath"
"ragflow/internal/common"
@@ -62,13 +61,14 @@ func TestTableRotation_Integration(t *testing.T) {
cfg.AutoRotateTables = &autoRotate
_ = NewParser(cfg) // verify construction does not panic
+ ctx := t.Context()
for pg := 0; pg < pageCount; pg++ {
pageImg, err := RenderPageToImage(eng, pg)
if err != nil {
t.Fatalf("render page %d: %v", pg, err)
}
- regions, err := dd.DLA(context.Background(), pageImg)
+ regions, err := dd.DLA(ctx, pageImg)
if err != nil {
t.Fatalf("DLA page %d: %v", pg, err)
}
@@ -88,7 +88,7 @@ func TestTableRotation_Integration(t *testing.T) {
}
// Evaluate rotation
- angle, _, scores := tbl.EvaluateTableOrientation(context.Background(), cropped, dd)
+ angle, _, scores := tbl.EvaluateTableOrientation(ctx, cropped, dd)
t.Logf(" Page %d Table %d: %dx%d, bestAngle=%d°, scores: 0=%.3f 90=%.3f 180=%.3f 270=%.3f",
pg, tableCount, cropped.Bounds().Dx(), cropped.Bounds().Dy(),
angle,
@@ -103,7 +103,7 @@ func TestTableRotation_Integration(t *testing.T) {
t.Logf(" NOTE: Page 1 rotated table detected as %d° (expect 90 or 270)", angle)
// Verify TSR returns labels (6th element in bbox array).
- testCells, tsrErr := dd.TSR(context.Background(), cropped)
+ testCells, tsrErr := dd.TSR(ctx, cropped)
if tsrErr == nil && len(testCells) > 0 {
hasLabel := false
for _, c := range testCells {
@@ -147,6 +147,7 @@ func TestTableRotation_Stability(t *testing.T) {
count := 0
maxCount := 3 // sample size
+ ctx := t.Context()
for _, e := range entries {
if e.IsDir() || filepath.Ext(e.Name()) != ".pdf" {
continue
@@ -170,7 +171,7 @@ func TestTableRotation_Stability(t *testing.T) {
continue
}
- regions, _ := dd.DLA(context.Background(), pageImg)
+ regions, _ := dd.DLA(ctx, pageImg)
tables := 0
rotated := 0
for _, r := range regions {
@@ -186,7 +187,7 @@ func TestTableRotation_Stability(t *testing.T) {
if cropped == nil {
continue
}
- angle, _, _ := tbl.EvaluateTableOrientation(context.Background(), cropped, dd)
+ angle, _, _ := tbl.EvaluateTableOrientation(ctx, cropped, dd)
if angle != 0 {
rotated++
t.Logf(" %s: rotated table detected (angle=%d°)", e.Name(), angle)
diff --git a/internal/deepdoc/parser/pdf/table_section_test.go b/internal/deepdoc/parser/pdf/table_section_test.go
index fcd77d671d..e2a1d86cf4 100644
--- a/internal/deepdoc/parser/pdf/table_section_test.go
+++ b/internal/deepdoc/parser/pdf/table_section_test.go
@@ -1,7 +1,6 @@
package pdf
import (
- "context"
"image"
"strings"
"testing"
@@ -43,8 +42,8 @@ func TestTableSection_TextFromTSR(t *testing.T) {
},
}
p := NewParser(pdf.DefaultParserConfig())
-
- result, err := p.ParseRaw(context.Background(), eng, mock)
+ ctx := t.Context()
+ result, err := p.ParseRaw(ctx, eng, mock)
if err != nil {
t.Fatalf("Parse: %v", err)
}
@@ -98,8 +97,9 @@ func TestEnrichOnePageWithDeepDoc_ImageOnlyPage(t *testing.T) {
// 0 text boxes, but page 0 has a rendered image.
boxes := []pdf.TextBox{}
dummyImg := image.NewRGBA(image.Rect(0, 0, 900, 600))
+ ctx := t.Context()
- _, tables, _ := p.enrichOnePageWithDeepDoc(context.Background(), dummyImg, boxes, 0, nil, mock, NewTableBuilderFor(mock), pdf.DlaScale)
+ _, tables, _ := p.enrichOnePageWithDeepDoc(ctx, dummyImg, boxes, 0, nil, mock, NewTableBuilderFor(mock), pdf.DlaScale)
if len(tables) == 0 {
t.Fatal("enrichOnePageWithDeepDoc: expected at least 1 table from DLA on page with image but no boxes, got 0")
}
@@ -131,8 +131,8 @@ func TestFigureCaption_MergedIntoFigure(t *testing.T) {
},
}
p := NewParser(pdf.DefaultParserConfig())
-
- result, err := p.ParseRaw(context.Background(), eng, mock)
+ ctx := t.Context()
+ result, err := p.ParseRaw(ctx, eng, mock)
if err != nil {
t.Fatalf("Parse: %v", err)
}
@@ -190,8 +190,8 @@ func TestTableCaption_MergedIntoTable(t *testing.T) {
},
}
p := NewParser(pdf.DefaultParserConfig())
-
- result, err := p.ParseRaw(context.Background(), eng, mock)
+ ctx := t.Context()
+ result, err := p.ParseRaw(ctx, eng, mock)
if err != nil {
t.Fatalf("Parse: %v", err)
}
@@ -247,8 +247,8 @@ func TestTextSectionsInsideTableRegion_Suppressed(t *testing.T) {
},
}
p := NewParser(pdf.DefaultParserConfig())
-
- result, err := p.ParseRaw(context.Background(), eng, mock)
+ ctx := t.Context()
+ result, err := p.ParseRaw(ctx, eng, mock)
if err != nil {
t.Fatalf("Parse: %v", err)
}
@@ -288,7 +288,8 @@ func TestEmptyDoc_NoCrash(t *testing.T) {
eng := &MockEngine{NumPages: 0}
mock := &MockDocAnalyzer{Healthy: true}
p := NewParser(pdf.DefaultParserConfig())
- result, err := p.ParseRaw(context.Background(), eng, mock)
+ ctx := t.Context()
+ result, err := p.ParseRaw(ctx, eng, mock)
if err != nil {
t.Fatalf("Parse: %v", err)
}
@@ -302,7 +303,8 @@ func TestNilChars_Handled(t *testing.T) {
eng := &MockEngine{NumPages: 1, RenderW: 200, RenderH: 200}
mock := &MockDocAnalyzer{Healthy: true}
p := NewParser(pdf.DefaultParserConfig())
- result, err := p.ParseRaw(context.Background(), eng, mock)
+ ctx := t.Context()
+ result, err := p.ParseRaw(ctx, eng, mock)
if err != nil {
t.Fatalf("Parse: %v", err)
}
diff --git a/internal/engine/elasticsearch/chunk_helpers_test.go b/internal/engine/elasticsearch/chunk_helpers_test.go
index 4959aecf23..4a76eb621c 100644
--- a/internal/engine/elasticsearch/chunk_helpers_test.go
+++ b/internal/engine/elasticsearch/chunk_helpers_test.go
@@ -1,7 +1,6 @@
package elasticsearch
import (
- "context"
"encoding/json"
"net/http"
"net/http/httptest"
@@ -62,9 +61,9 @@ func TestUpdateSingleMemoryMessageWaitsForRefresh(t *testing.T) {
if err != nil {
t.Fatalf("new elasticsearch client: %v", err)
}
-
+ ctx := t.Context()
engine := &Engine{client: client}
- if err = engine.updateSingleMemoryMessage(context.Background(), "memory_tenant", "memory-1_42", map[string]interface{}{"forget_at": "2026-07-27 10:00:00"}); err != nil {
+ if err = engine.updateSingleMemoryMessage(ctx, "memory_tenant", "memory-1_42", map[string]interface{}{"forget_at": "2026-07-27 10:00:00"}); err != nil {
t.Fatalf("updateSingleMemoryMessage: %v", err)
}
if gotRefresh != "wait_for" {
@@ -96,13 +95,13 @@ func TestDeleteChunksPreservesStringSliceCondition(t *testing.T) {
}
}))
defer server.Close()
-
+ ctx := t.Context()
client, err := elasticsearch.NewClient(elasticsearch.Config{Addresses: []string{server.URL}})
if err != nil {
t.Fatalf("new elasticsearch client: %v", err)
}
engine := &Engine{client: client}
- deleted, err := engine.DeleteChunks(context.Background(), map[string]interface{}{
+ deleted, err := engine.DeleteChunks(ctx, map[string]interface{}{
"kb_id": "kb-1",
"compile_kwd": []string{"wiki_entity", "wiki_relation"},
}, "ragflow_tenant", "kb-1")
@@ -157,13 +156,13 @@ func TestDeleteChunksIDStringSlice(t *testing.T) {
}
}))
defer server.Close()
-
+ ctx := t.Context()
client, err := elasticsearch.NewClient(elasticsearch.Config{Addresses: []string{server.URL}})
if err != nil {
t.Fatalf("new elasticsearch client: %v", err)
}
engine := &Engine{client: client}
- if _, err = engine.DeleteChunks(context.Background(), map[string]interface{}{
+ if _, err = engine.DeleteChunks(ctx, map[string]interface{}{
"id": []string{"doc-a", "doc-b"},
}, "ragflow_tenant", "kb-1"); err != nil {
t.Fatalf("DeleteChunks: %v", err)
diff --git a/internal/engine/elasticsearch/chunk_test.go b/internal/engine/elasticsearch/chunk_test.go
index c1f271ec35..2eeebd3841 100644
--- a/internal/engine/elasticsearch/chunk_test.go
+++ b/internal/engine/elasticsearch/chunk_test.go
@@ -159,7 +159,8 @@ func TestSearchAfterPaginateSimpleFirstPage(t *testing.T) {
scripted: []SearchResponse{makeResponse(5, 0, 5)},
scriptedTotal: 5,
}
- got, total, err := searchAfterPaginate(context.Background(), map[string]interface{}{}, 0, 5, m.fetch)
+ ctx := t.Context()
+ got, total, err := searchAfterPaginate(ctx, map[string]interface{}{}, 0, 5, m.fetch)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
@@ -202,8 +203,9 @@ func TestSearchAfterPaginateSkipsDeepOffset(t *testing.T) {
// Defensive: if the loop miscounts and asks for another take
// batch, this would surface as a 12th fetch.
m.scripted = append(m.scripted, makeResponse(10, 10500, 0))
+ ctx := t.Context()
- got, totalHits, err := searchAfterPaginate(context.Background(), map[string]interface{}{}, offset, limit, m.fetch)
+ got, totalHits, err := searchAfterPaginate(ctx, map[string]interface{}{}, offset, limit, m.fetch)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
@@ -248,7 +250,8 @@ func TestSearchAfterPaginateExhaustsIndex(t *testing.T) {
},
scriptedTotal: 500,
}
- got, total, err := searchAfterPaginate(context.Background(), map[string]interface{}{}, 400, 10, m.fetch)
+ ctx := t.Context()
+ got, total, err := searchAfterPaginate(ctx, map[string]interface{}{}, 400, 10, m.fetch)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
@@ -275,7 +278,8 @@ func TestSearchAfterPaginateEmptyResult(t *testing.T) {
scripted: []SearchResponse{makeResponse(0, 0, 0)},
scriptedTotal: 0,
}
- got, total, err := searchAfterPaginate(context.Background(), map[string]interface{}{}, 50, 10, m.fetch)
+ ctx := t.Context()
+ got, total, err := searchAfterPaginate(ctx, map[string]interface{}{}, 50, 10, m.fetch)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
@@ -306,7 +310,8 @@ func TestSearchAfterPaginateStopOnUnchangedCursor(t *testing.T) {
scriptedTotal: 5000,
}
// offset=500, limit=10.
- _, _, err := searchAfterPaginate(context.Background(), map[string]interface{}{}, 500, 10, m.fetch)
+ ctx := t.Context()
+ _, _, err := searchAfterPaginate(ctx, map[string]interface{}{}, 500, 10, m.fetch)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
@@ -330,7 +335,8 @@ func TestSearchAfterPaginateLimitLargerThanBatchSize(t *testing.T) {
},
scriptedTotal: 10000,
}
- got, total, err := searchAfterPaginate(context.Background(), map[string]interface{}{}, 0, limit, m.fetch)
+ ctx := t.Context()
+ got, total, err := searchAfterPaginate(ctx, map[string]interface{}{}, 0, limit, m.fetch)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
diff --git a/internal/engine/elasticsearch/sql_test.go b/internal/engine/elasticsearch/sql_test.go
index 6a4221a0f3..1c280392ee 100644
--- a/internal/engine/elasticsearch/sql_test.go
+++ b/internal/engine/elasticsearch/sql_test.go
@@ -98,8 +98,9 @@ const sampleESResponse = `{
func TestRunSQL_NoFilterAdded(t *testing.T) {
srv, cap := newCapturingServer(t, http.StatusOK, sampleESResponse)
e := newTestEngine(t, srv.URL)
+ ctx := t.Context()
- rows, err := e.RunSQL(context.Background(), "ragflow_t1", "SELECT doc_id FROM ragflow_t1", nil, "json")
+ rows, err := e.RunSQL(ctx, "ragflow_t1", "SELECT doc_id FROM ragflow_t1", nil, "json")
if err != nil {
t.Fatalf("RunSQL: %v", err)
}
@@ -130,10 +131,11 @@ func TestRunSQL_NoFilterAdded(t *testing.T) {
func TestRunSQL_WhitespaceNormalizedAndPercentStripped(t *testing.T) {
srv, cap := newCapturingServer(t, http.StatusOK, sampleESResponse)
e := newTestEngine(t, srv.URL)
+ ctx := t.Context()
// Input SQL has multiple backticks/spaces and trailing % characters.
in := "SELECT doc_id FROM `ragflow_t1` WHERE count > 0 %"
- _, err := e.RunSQL(context.Background(), "ragflow_t1", in, nil, "json")
+ _, err := e.RunSQL(ctx, "ragflow_t1", in, nil, "json")
if err != nil {
t.Fatalf("RunSQL: %v", err)
}
@@ -186,7 +188,7 @@ func TestRunSQL_PerAttemptTimeout(t *testing.T) {
// the retry loop or the timeout is broken; the test will report
// a clear "did not return within 15s" message rather than a
// fragile absolute wall-clock assertion.
- ctx, cancel := context.WithTimeout(context.Background(), 15*time.Second)
+ ctx, cancel := context.WithTimeout(t.Context(), 15*time.Second)
defer cancel()
type result struct {
@@ -252,7 +254,8 @@ func TestRunSQL_RetryOnTimeoutThenSucceed(t *testing.T) {
})
e := newTestEngine(t, srv.URL)
- rows, err := e.RunSQL(context.Background(), "ragflow_t1", "SELECT 1", nil, "json")
+ ctx := t.Context()
+ rows, err := e.RunSQL(ctx, "ragflow_t1", "SELECT 1", nil, "json")
if err != nil {
t.Fatalf("RunSQL: %v", err)
}
@@ -286,7 +289,8 @@ func TestRunSQL_NonTimeoutErrorSurfacesImmediately(t *testing.T) {
t.Cleanup(srv.Close)
e := newTestEngine(t, srv.URL)
- _, err := e.RunSQL(context.Background(), "ragflow_t1", "SELECT bad", nil, "json")
+ ctx := t.Context()
+ _, err := e.RunSQL(ctx, "ragflow_t1", "SELECT bad", nil, "json")
if err == nil {
t.Fatalf("RunSQL: got nil error, want error")
}
@@ -311,7 +315,8 @@ func TestRunSQL_RequestBodyHasFetchSizeAndFormat(t *testing.T) {
srv, cap := newCapturingServer(t, http.StatusOK, sampleESResponse)
e := newTestEngine(t, srv.URL)
- if _, err := e.RunSQL(context.Background(), "ragflow_t1", "SELECT 1", nil, "json"); err != nil {
+ ctx := t.Context()
+ if _, err := e.RunSQL(ctx, "ragflow_t1", "SELECT 1", nil, "json"); err != nil {
t.Fatalf("RunSQL: %v", err)
}
cap.mu.Lock()
@@ -339,7 +344,8 @@ func TestRunSQL_EmptyRowsReturnsNilNil(t *testing.T) {
srv, _ := newCapturingServer(t, http.StatusOK, empty)
e := newTestEngine(t, srv.URL)
- rows, err := e.RunSQL(context.Background(), "ragflow_t1", "SELECT doc_id FROM ragflow_t1", nil, "json")
+ ctx := t.Context()
+ rows, err := e.RunSQL(ctx, "ragflow_t1", "SELECT doc_id FROM ragflow_t1", nil, "json")
if err != nil {
t.Fatalf("RunSQL: %v", err)
}
@@ -358,7 +364,8 @@ func TestRunSQL_PostsToSQLPath(t *testing.T) {
srv, cap := newCapturingServer(t, http.StatusOK, sampleESResponse)
e := newTestEngine(t, srv.URL)
- if _, err := e.RunSQL(context.Background(), "ragflow_t1", "SELECT 1", nil, "json"); err != nil {
+ ctx := t.Context()
+ if _, err := e.RunSQL(ctx, "ragflow_t1", "SELECT 1", nil, "json"); err != nil {
t.Fatalf("RunSQL: %v", err)
}
cap.mu.Lock()
diff --git a/internal/entity/models/common_test.go b/internal/entity/models/common_test.go
index 61aafa5324..b9a572e5fe 100644
--- a/internal/entity/models/common_test.go
+++ b/internal/entity/models/common_test.go
@@ -1,7 +1,6 @@
package models
import (
- "context"
"fmt"
"io"
"net/http"
@@ -36,7 +35,7 @@ func TestBaseModelDoRequestAuthorizationHeader(t *testing.T) {
defer server.Close()
model := &BaseModel{httpClient: server.Client(), AllowEmptyAPIKey: true}
- if _, err := model.doRequest(context.Background(), server.URL, tt.apiConfig, map[string]any{"ok": true}, time.Second); err != nil {
+ if _, err := model.doRequest(t.Context(), server.URL, tt.apiConfig, map[string]any{"ok": true}, time.Second); err != nil {
t.Fatalf("doRequest() error = %v", err)
}
})
@@ -53,7 +52,7 @@ func TestBaseModelDoStreamRequestAllowsMissingAPIKey(t *testing.T) {
defer server.Close()
model := &BaseModel{httpClient: server.Client(), AllowEmptyAPIKey: true}
- err := model.doStreamRequest(context.Background(), server.URL, nil, map[string]any{"ok": true}, time.Second, func(body io.ReadCloser) error {
+ err := model.doStreamRequest(t.Context(), server.URL, nil, map[string]any{"ok": true}, time.Second, func(body io.ReadCloser) error {
_, err := io.ReadAll(body)
return err
})
diff --git a/internal/entity/models/google_test.go b/internal/entity/models/google_test.go
index cd52ac0961..ef94050a11 100644
--- a/internal/entity/models/google_test.go
+++ b/internal/entity/models/google_test.go
@@ -381,7 +381,7 @@ func TestCollectGoogleModelNamesPaginates(t *testing.T) {
}
var pageTokens []string
- models, err := collectGoogleModelNames(context.Background(), func(_ context.Context, pageToken string) (googleModelPage, error) {
+ models, err := collectGoogleModelNames(t.Context(), func(_ context.Context, pageToken string) (googleModelPage, error) {
pageTokens = append(pageTokens, pageToken)
if len(pageTokens) > len(pages) {
t.Fatalf("unexpected extra page request with token %q", pageToken)
@@ -406,7 +406,7 @@ func TestCollectGoogleModelNamesPaginates(t *testing.T) {
}
func TestCollectGoogleModelNamesPreservesEmptyResult(t *testing.T) {
- models, err := collectGoogleModelNames(context.Background(), func(context.Context, string) (googleModelPage, error) {
+ models, err := collectGoogleModelNames(t.Context(), func(context.Context, string) (googleModelPage, error) {
return googleModelPage{}, nil
})
if err != nil {
@@ -421,7 +421,7 @@ func TestCollectGoogleModelNamesReturnsPageError(t *testing.T) {
pageErr := errors.New("next page failed")
calls := 0
- _, err := collectGoogleModelNames(context.Background(), func(context.Context, string) (googleModelPage, error) {
+ _, err := collectGoogleModelNames(t.Context(), func(context.Context, string) (googleModelPage, error) {
calls++
if calls == 1 {
return googleModelPage{items: []ModelListItem{{ID: "Gemini 2.5 Flash", OwnedBy: "Google"}}, nextPageToken: "page-2"}, nil
diff --git a/internal/handler/agent_wait_for_user_test.go b/internal/handler/agent_wait_for_user_test.go
index 0aaffe60d6..37cfa7c57a 100644
--- a/internal/handler/agent_wait_for_user_test.go
+++ b/internal/handler/agent_wait_for_user_test.go
@@ -215,7 +215,7 @@ func TestWaitForUser_SSECycleRoundTrip(t *testing.T) {
// (since a raw signal has no wrapped InterruptCtx
// list — this is acceptable for V1 and matches
// the test's relaxed cpn_id assertion below).
- return nil, compose.Interrupt(context.Background(), map[string]any{
+ return nil, compose.Interrupt(t.Context(), map[string]any{
"kind": "user_fill_up",
"cpn_id": "answer-1",
"tips": "Do you want to continue?",
diff --git a/internal/harness/core/agent_loop_ctrl_test.go b/internal/harness/core/agent_loop_ctrl_test.go
index c286853ce2..9dd019b009 100644
--- a/internal/harness/core/agent_loop_ctrl_test.go
+++ b/internal/harness/core/agent_loop_ctrl_test.go
@@ -1,7 +1,6 @@
package core
import (
- "context"
"testing"
"time"
)
@@ -19,7 +18,7 @@ func TestPreemptController_Lifecycle(t *testing.T) {
}
// planning -> active
- ctx := context.Background()
+ ctx := t.Context()
ctrl.beginActiveTurn(ctx, "test-turn-context")
if ctrl.turnPhase != preemptTurnActive {
t.Error("expected turnPhase = active after beginActiveTurn")
@@ -57,7 +56,7 @@ func TestPreemptController_AbortPlanningTurn(t *testing.T) {
func TestPreemptController_PushCriticalSection(t *testing.T) {
ctrl := newPreemptController()
ctrl.beginPlanningTurn()
- ctrl.beginActiveTurn(context.Background(), nil)
+ ctrl.beginActiveTurn(t.Context(), nil)
// beginPush captures current turn state
snap := ctrl.beginPush()
@@ -85,9 +84,10 @@ func TestPreemptController_PushCriticalSection(t *testing.T) {
}
func TestPreemptController_StaleTurnPreempt(t *testing.T) {
+ ctx := t.Context()
ctrl := newPreemptController()
ctrl.beginPlanningTurn()
- ctrl.beginActiveTurn(context.Background(), nil)
+ ctrl.beginActiveTurn(ctx, nil)
// Capture snapshot of turn 1
snap := ctrl.beginPush()
@@ -98,7 +98,7 @@ func TestPreemptController_StaleTurnPreempt(t *testing.T) {
// Start turn 2
ctrl.beginPlanningTurn()
- ctrl.beginActiveTurn(context.Background(), nil)
+ ctrl.beginActiveTurn(ctx, nil)
// Request preempt on stale turn 1 snapshot - should be no-op
ack := make(chan struct{})
@@ -153,7 +153,7 @@ func TestPreemptController_WaitForPushes(t *testing.T) {
func TestPreemptController_CloseForLoopExit(t *testing.T) {
ctrl := newPreemptController()
ctrl.beginPlanningTurn()
- ctrl.beginActiveTurn(context.Background(), nil)
+ ctrl.beginActiveTurn(t.Context(), nil)
ctrl.closeForLoopExit()
if !ctrl.closed {
@@ -167,7 +167,7 @@ func TestPreemptController_CloseForLoopExit(t *testing.T) {
func TestPreemptController_RequestPreemptOnIdleTurn(t *testing.T) {
ctrl := newPreemptController()
ctrl.beginPlanningTurn()
- ctrl.beginActiveTurn(context.Background(), nil)
+ ctrl.beginActiveTurn(t.Context(), nil)
ctrl.endActiveTurn().ack()
// Turn is now idle
diff --git a/internal/harness/core/agent_loop_edge_test.go b/internal/harness/core/agent_loop_edge_test.go
index 77f32b562c..50504a2f06 100644
--- a/internal/harness/core/agent_loop_edge_test.go
+++ b/internal/harness/core/agent_loop_edge_test.go
@@ -20,7 +20,7 @@ func TestTurnLoop_UnhandledItemsOnStop(t *testing.T) {
loop := newTurnLoop("unhandled", "")
loop.Push(schema.UserMessage("item1"))
loop.Push(schema.UserMessage("item2"))
- loop.Run(context.Background())
+ loop.Run(t.Context())
loop.Stop()
state := loop.Wait()
_ = state
@@ -45,7 +45,7 @@ func TestTurnLoop_PrepareAgentError_RecoverItems(t *testing.T) {
},
})
loop.Push(schema.UserMessage("prepare_recover"))
- loop.Run(context.Background())
+ loop.Run(t.Context())
loop.Stop()
_ = loop.Wait()
}
@@ -63,7 +63,7 @@ func TestTurnLoop_GetAgentError_RecoverConsumed(t *testing.T) {
},
})
loop.Push(schema.UserMessage("recover_consumed"))
- loop.Run(context.Background())
+ loop.Run(t.Context())
loop.Stop()
state := loop.Wait()
_ = state
@@ -73,7 +73,7 @@ func TestTurnLoop_GetAgentError_RecoverConsumed(t *testing.T) {
func TestTurnLoop_BareStop_AgentRunsToCompletion(t *testing.T) {
loop := newTurnLoop("bare_stop", "bare result")
loop.Push(schema.UserMessage("bare"))
- loop.Run(context.Background())
+ loop.Run(t.Context())
time.Sleep(30 * time.Millisecond)
loop.Stop()
_ = loop.Wait()
@@ -83,7 +83,7 @@ func TestTurnLoop_BareStop_AgentRunsToCompletion(t *testing.T) {
func TestTurnLoop_StopAfterReceive_RecoverItem(t *testing.T) {
loop := newTurnLoop("stop_recv", "result")
loop.Push(schema.UserMessage("stop_after_recv"))
- loop.Run(context.Background())
+ loop.Run(t.Context())
time.Sleep(10 * time.Millisecond)
loop.Stop()
state := loop.Wait()
@@ -99,7 +99,7 @@ func TestFailover_StreamFailover(t *testing.T) {
fallback := &mockModel{}
fallback.addResp("fallback")
wrapped := WithModelFailover(primary, fallback)
- ctx := context.Background()
+ ctx := t.Context()
sr, err := wrapped.Stream(ctx, []Message{schema.UserMessage("hi")})
if err != nil {
t.Fatalf("Stream: %v", err)
@@ -117,7 +117,7 @@ func TestFailover_AllModelsFail_Stream(t *testing.T) {
primary := &alwaysFailModel{}
fallback := &alwaysFailModel{}
wrapped := WithModelFailover(primary, fallback)
- ctx := context.Background()
+ ctx := t.Context()
_, err := wrapped.Stream(ctx, []Message{schema.UserMessage("")})
if err == nil {
t.Error("expected error when all models fail in stream")
diff --git a/internal/harness/core/agent_loop_test.go b/internal/harness/core/agent_loop_test.go
index 28e05808a7..e1ff850f3d 100644
--- a/internal/harness/core/agent_loop_test.go
+++ b/internal/harness/core/agent_loop_test.go
@@ -285,7 +285,7 @@ func TestTurnLoop_PushRunAndWait(t *testing.T) {
tl := simpleTurnLoop(nil)
tl.Push("a")
tl.Push("b")
- ctx := context.Background()
+ ctx := t.Context()
tl.Stop()
tl.Run(ctx)
result := tl.Wait()
@@ -299,7 +299,7 @@ func TestTurnLoop_StopCause(t *testing.T) {
tl := simpleTurnLoop(nil)
tl.Push("x")
tl.Stop(WithStopCause("max_tokens"))
- tl.Run(context.Background())
+ tl.Run(t.Context())
result := tl.Wait()
if result.StopCause != "max_tokens" {
t.Errorf("StopCause = %q", result.StopCause)
@@ -319,7 +319,7 @@ func TestTurnLoop_OnAgentEventsCalled(t *testing.T) {
}
return nil
})
- ctx := context.Background()
+ ctx := t.Context()
tl.Run(ctx)
tl.Push("ev")
time.Sleep(50 * time.Millisecond)
@@ -334,7 +334,7 @@ func TestTurnLoop_OnAgentEventsReturnsError(t *testing.T) {
tl := simpleTurnLoop(func(ctx context.Context, tc *TurnContext[string], events *AsyncIterator[*AgentEvent]) error {
return errors.New("custom_events_error")
})
- ctx := context.Background()
+ ctx := t.Context()
tl.Run(ctx)
tl.Push("fail")
time.Sleep(50 * time.Millisecond)
@@ -361,7 +361,7 @@ func TestTurnLoop_GenInputErrors(t *testing.T) {
})
tl.Push("bad")
tl.Stop()
- tl.Run(context.Background())
+ tl.Run(t.Context())
result := tl.Wait()
if result.ExitReason == nil {
t.Log("no exit error (may not reach GenInput before stop)")
@@ -379,7 +379,7 @@ func TestTurnLoop_PrepareAgentErrors(t *testing.T) {
})
tl.Push("bad")
tl.Stop()
- tl.Run(context.Background())
+ tl.Run(t.Context())
result := tl.Wait()
if result.ExitReason == nil {
t.Log("no exit error (may not reach PrepareAgent)")
@@ -394,7 +394,7 @@ func TestTurnLoop_MultipleItems(t *testing.T) {
tl.Push(fmt.Sprintf("item-%d", i))
}
tl.Stop()
- tl.Run(context.Background())
+ tl.Run(t.Context())
result := tl.Wait()
t.Logf("10 items: unhandled=%d interrupted=%d", len(result.UnhandledItems), len(result.InterruptedItems))
}
@@ -403,11 +403,11 @@ func TestTurnLoop_ConcurrentPush(t *testing.T) {
tl := simpleTurnLoop(nil)
var wg sync.WaitGroup
for i := 0; i < 50; i++ {
- wg.Go(func() { ; tl.Push("c") })
+ wg.Go(func() { tl.Push("c") })
}
wg.Wait()
tl.Stop()
- tl.Run(context.Background())
+ tl.Run(t.Context())
result := tl.Wait()
t.Logf("50 concurrent: unhandled=%d", len(result.UnhandledItems))
}
@@ -435,7 +435,7 @@ func TestTurnLoop_WithCheckpoint(t *testing.T) {
})
tl.Push("cp1")
tl.Stop()
- tl.Run(context.Background())
+ tl.Run(t.Context())
result := tl.Wait()
t.Logf("checkpoint: unhandled=%d", len(result.UnhandledItems))
}
@@ -445,7 +445,7 @@ func TestTurnLoop_WithCheckpoint(t *testing.T) {
func TestTurnLoop_ImmediateStop(t *testing.T) {
tl := simpleTurnLoop(nil)
tl.Push("urgent")
- tl.Run(context.Background())
+ tl.Run(t.Context())
tl.Stop(WithImmediateStop(), WithSkipCheckpoint())
result := tl.Wait()
t.Logf("immediate: err=%v", result.ExitReason)
@@ -454,7 +454,7 @@ func TestTurnLoop_ImmediateStop(t *testing.T) {
func TestTurnLoop_StopWithNoItems(t *testing.T) {
tl := simpleTurnLoop(nil)
tl.Stop(WithStopCause("empty"))
- tl.Run(context.Background())
+ tl.Run(t.Context())
result := tl.Wait()
if result.StopCause != "empty" {
t.Errorf("StopCause = %q", result.StopCause)
@@ -466,7 +466,7 @@ func TestTurnLoop_StopMultipleTimes(t *testing.T) {
tl.Push("x")
tl.Stop(WithStopCause("first"))
tl.Stop(WithStopCause("second"))
- tl.Run(context.Background())
+ tl.Run(t.Context())
result := tl.Wait()
_ = result
}
@@ -476,7 +476,7 @@ func TestTurnLoop_StopMultipleTimes(t *testing.T) {
func TestTurnLoop_ContextCancel(t *testing.T) {
tl := simpleTurnLoop(nil)
tl.Push("task")
- ctx, cancel := context.WithCancel(context.Background())
+ ctx, cancel := context.WithCancel(t.Context())
cancel()
tl.Stop()
tl.Run(ctx)
@@ -492,7 +492,7 @@ func TestTurnLoop_PushAfterStop(t *testing.T) {
tl.Push("b")
tl.Stop()
tl.Push("c")
- tl.Run(context.Background())
+ tl.Run(t.Context())
tl.Wait()
}
@@ -522,7 +522,7 @@ func TestTurnLoop_WithToolAgent(t *testing.T) {
})
tl.Push("use tool")
tl.Stop()
- ctx := context.Background()
+ ctx := t.Context()
tl.Run(ctx)
result := tl.Wait()
t.Logf("tool agent: unhandled=%d", len(result.UnhandledItems))
@@ -547,7 +547,7 @@ func TestTurnLoop_GenInputAllConsumed(t *testing.T) {
tl.Push("1")
tl.Push("2")
tl.Stop()
- tl.Run(context.Background())
+ tl.Run(t.Context())
tl.Wait()
}
@@ -572,7 +572,7 @@ func TestTurnLoop_GenInputOneByOne(t *testing.T) {
tl.Push("y")
tl.Push("z")
tl.Stop()
- tl.Run(context.Background())
+ tl.Run(t.Context())
result := tl.Wait()
t.Logf("stream: unhandled=%d", len(result.UnhandledItems))
}
@@ -588,7 +588,7 @@ func TestTurnLoop_GenInputConsumedNone(t *testing.T) {
})
tl.Push("x")
tl.Stop()
- tl.Run(context.Background())
+ tl.Run(t.Context())
result := tl.Wait()
t.Logf("none consumed: unhandled=%d", len(result.UnhandledItems))
}
@@ -613,7 +613,7 @@ func TestTurnLoop_InterceptedItems(t *testing.T) {
},
})
tl.Push("a")
- tl.Run(context.Background())
+ tl.Run(t.Context())
tl.Stop(WithImmediateStop(), WithSkipCheckpoint())
result := tl.Wait()
_ = result
@@ -624,7 +624,7 @@ func TestTurnLoop_InterceptedItems(t *testing.T) {
func TestTurnLoop_NoPushBeforeRun(t *testing.T) {
tl := simpleTurnLoop(nil)
tl.Stop()
- tl.Run(context.Background())
+ tl.Run(t.Context())
result := tl.Wait()
if result == nil {
t.Fatal("nil result")
@@ -635,15 +635,15 @@ func TestTurnLoop_DoubleRunPanics(t *testing.T) {
tl := simpleTurnLoop(nil)
tl.Push("x")
tl.Stop()
- tl.Run(context.Background())
- tl.Run(context.Background()) // should be no-op
+ tl.Run(t.Context())
+ tl.Run(t.Context()) // should be no-op
tl.Wait()
}
func TestTurnLoop_RunThenStopThenWait(t *testing.T) {
tl := simpleTurnLoop(nil)
tl.Push("x")
- ctx := context.Background()
+ ctx := t.Context()
tl.Run(ctx)
tl.Stop()
result := tl.Wait()
@@ -656,7 +656,7 @@ func TestTurnLoop_RunThenStopThenWait(t *testing.T) {
// TestTurnLoop_StopIsIdempotent verifies multiple Stop() calls are safe.
func TestTurnLoop_StopIsIdempotent(t *testing.T) {
- loop := newAndRunTurnLoop(context.Background(), AgentLoopConfig[string]{
+ loop := newAndRunTurnLoop(t.Context(), AgentLoopConfig[string]{
GenInput: genInputConsumeAll,
PrepareAgent: prepareTestAgent,
})
@@ -673,7 +673,7 @@ func TestTurnLoop_StopIsIdempotent(t *testing.T) {
// TestTurnLoop_WaitMultipleGoroutines verifies Wait() is safe for concurrent callers.
func TestTurnLoop_WaitMultipleGoroutines(t *testing.T) {
- loop := newAndRunTurnLoop(context.Background(), AgentLoopConfig[string]{
+ loop := newAndRunTurnLoop(t.Context(), AgentLoopConfig[string]{
GenInput: genInputConsumeAll,
PrepareAgent: prepareTestAgent,
})
@@ -703,7 +703,7 @@ func TestTurnLoop_WaitMultipleGoroutines(t *testing.T) {
func TestTurnLoop_GetAgentError(t *testing.T) {
agentErr := errors.New("get agent error")
- loop := newAndRunTurnLoop(context.Background(), AgentLoopConfig[string]{
+ loop := newAndRunTurnLoop(t.Context(), AgentLoopConfig[string]{
GenInput: genInputConsumeAll,
PrepareAgent: func(ctx context.Context, _ *AgentLoop[string], consumed []string) (Agent, error) {
return nil, agentErr
@@ -723,7 +723,7 @@ func TestTurnLoop_BatchProcessing(t *testing.T) {
var batches [][]string
var mu sync.Mutex
- loop := newAndRunTurnLoop(context.Background(), AgentLoopConfig[string]{
+ loop := newAndRunTurnLoop(t.Context(), AgentLoopConfig[string]{
GenInput: func(ctx context.Context, _ *AgentLoop[string], items []string) (*GenInputResult[string], error) {
mu.Lock()
batches = append(batches, items)
@@ -756,7 +756,7 @@ func TestTurnLoop_BatchProcessing(t *testing.T) {
// TestTurnLoop_StopWithMode verifies Stop with WithGracefulStop works.
func TestTurnLoop_StopWithMode(t *testing.T) {
- loop := newAndRunTurnLoop(context.Background(), AgentLoopConfig[string]{
+ loop := newAndRunTurnLoop(t.Context(), AgentLoopConfig[string]{
GenInput: genInputConsumeAll,
PrepareAgent: prepareTestAgent,
})
@@ -772,7 +772,7 @@ func TestTurnLoop_StopWithMode(t *testing.T) {
// ======================== Context Cancel Variants ========================
func TestTurnLoop_ContextDeadlineExceeded(t *testing.T) {
- ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
+ ctx, cancel := context.WithTimeout(t.Context(), 50*time.Millisecond)
defer cancel()
loop := newAndRunTurnLoop(ctx, AgentLoopConfig[string]{
@@ -796,7 +796,7 @@ func TestTurnLoop_ContextDeadlineExceeded(t *testing.T) {
}
func TestTurnLoop_ContextCancelBeforeReceive(t *testing.T) {
- ctx, cancel := context.WithCancel(context.Background())
+ ctx, cancel := context.WithCancel(t.Context())
cancel()
loop := NewAgentLoop(AgentLoopConfig[string]{
@@ -814,7 +814,7 @@ func TestTurnLoop_ContextCancelBeforeReceive(t *testing.T) {
}
func TestTurnLoop_ContextCancelDuringBlockingReceive(t *testing.T) {
- ctx, cancel := context.WithCancel(context.Background())
+ ctx, cancel := context.WithCancel(t.Context())
loop := newAndRunTurnLoop(ctx, AgentLoopConfig[string]{
GenInput: genInputConsumeAll,
@@ -831,7 +831,7 @@ func TestTurnLoop_ContextCancelDuringBlockingReceive(t *testing.T) {
}
func TestTurnLoop_ContextCancelAfterGenInput_RecoverItems(t *testing.T) {
- ctx, cancel := context.WithCancel(context.Background())
+ ctx, cancel := context.WithCancel(t.Context())
genInputCount := 0
loop := newAndRunTurnLoop(ctx, AgentLoopConfig[string]{
@@ -873,7 +873,7 @@ func TestTurnLoop_OnAgentEventsReceivesEvents(t *testing.T) {
var receivedConsumed []string
var mu sync.Mutex
- loop := newAndRunTurnLoop(context.Background(), AgentLoopConfig[string]{
+ loop := newAndRunTurnLoop(t.Context(), AgentLoopConfig[string]{
GenInput: genInputConsumeAllWithMsg,
PrepareAgent: prepareTestAgent,
OnAgentEvents: func(ctx context.Context, tc *TurnContext[string], events *AsyncIterator[*AgentEvent]) error {
@@ -914,7 +914,7 @@ func TestTurnLoop_OnAgentEventsReceivesEvents(t *testing.T) {
// ======================== Stop with Checkpoint Cancel ========================
func TestTurnLoop_StopCheckPointIDInCancelError(t *testing.T) {
- ctx := context.Background()
+ ctx := t.Context()
modelStarted := make(chan struct{}, 1)
checkpointID := "turn-loop-cancel-ckpt-1"
store := newTestStore()
@@ -950,7 +950,7 @@ func TestTurnLoop_StopCheckPointIDInCancelError(t *testing.T) {
// ======================== CancelError Captured Independently ========================
func TestTurnLoop_CancelError_CapturedIndependentlyOfCallback(t *testing.T) {
- ctx := context.Background()
+ ctx := t.Context()
modelStarted := make(chan struct{}, 1)
checkpointID := "cancel-capture-independent-1"
store := newTestStore()
@@ -995,7 +995,7 @@ func TestTurnLoop_CancelError_CapturedIndependentlyOfCallback(t *testing.T) {
// ======================== Stop Without CheckpointID ========================
func TestTurnLoop_StopWithoutCheckpointIDDoesNotPersist(t *testing.T) {
- ctx := context.Background()
+ ctx := t.Context()
modelStarted := make(chan struct{}, 1)
store := newTestStore()
@@ -1028,7 +1028,7 @@ func TestTurnLoop_StopWithoutCheckpointIDDoesNotPersist(t *testing.T) {
// ======================== Stop While Idle ========================
func TestTurnLoop_StopWhileIdle_SkipsCheckpoint(t *testing.T) {
- ctx := context.Background()
+ ctx := t.Context()
store := newTestStore()
cpID := "idle-session"
@@ -1049,7 +1049,7 @@ func TestTurnLoop_StopWhileIdle_SkipsCheckpoint(t *testing.T) {
// ======================== Stop Call From GenInput ========================
func TestTurnLoop_StopCallFromGenInput(t *testing.T) {
- loop := newAndRunTurnLoop(context.Background(), AgentLoopConfig[string]{
+ loop := newAndRunTurnLoop(t.Context(), AgentLoopConfig[string]{
GenInput: func(ctx context.Context, loop *AgentLoop[string], items []string) (*GenInputResult[string], error) {
loop.Stop()
return &GenInputResult[string]{Input: &AgentInput{}, Consumed: items}, nil
@@ -1070,7 +1070,7 @@ func TestTurnLoop_StopCallFromGenInput(t *testing.T) {
func TestTurnLoop_PushFromOnAgentEvents(t *testing.T) {
pushCount := int32(0)
- loop := newAndRunTurnLoop(context.Background(), AgentLoopConfig[string]{
+ loop := newAndRunTurnLoop(t.Context(), AgentLoopConfig[string]{
GenInput: genInputConsumeFirst,
PrepareAgent: prepareTestAgent,
OnAgentEvents: func(ctx context.Context, tc *TurnContext[string], events *AsyncIterator[*AgentEvent]) error {
@@ -1129,7 +1129,7 @@ func TestNewTurnLoop_PushBeforeRun(t *testing.T) {
t.Error("Push returned false")
}
- loop.Run(context.Background())
+ loop.Run(t.Context())
time.Sleep(100 * time.Millisecond)
@@ -1168,7 +1168,7 @@ func TestNewTurnLoop_WaitBeforeRun(t *testing.T) {
loop.Push("msg1")
loop.Stop()
- loop.Run(context.Background())
+ loop.Run(t.Context())
select {
case result := <-waitDone:
@@ -1194,9 +1194,9 @@ func TestNewTurnLoop_RunIsIdempotent(t *testing.T) {
})
loop.Push("msg1")
- loop.Run(context.Background())
- loop.Run(context.Background())
- loop.Run(context.Background())
+ loop.Run(t.Context())
+ loop.Run(t.Context())
+ loop.Run(t.Context())
time.Sleep(100 * time.Millisecond)
@@ -1237,7 +1237,7 @@ func TestNewTurnLoop_ConcurrentPushAndRun(t *testing.T) {
go func() {
defer wg.Done()
- loop.Run(context.Background())
+ loop.Run(t.Context())
}()
wg.Wait()
@@ -1265,7 +1265,7 @@ func TestTurnLoop_CtxPropagation(t *testing.T) {
const traceVal = "trace-123"
var prepareCtxVal, eventsCtxVal string
- ctx := context.WithValue(context.Background(), turnCtxKey{}, traceVal)
+ ctx := context.WithValue(t.Context(), turnCtxKey{}, traceVal)
cfg := AgentLoopConfig[string]{
GenInput: func(ctx context.Context, loop *AgentLoop[string], items []string) (*GenInputResult[string], error) {
@@ -1321,7 +1321,7 @@ func TestTurnLoop_TurnContext_StoppedChannel(t *testing.T) {
stoppedSeen := make(chan struct{})
agentStarted := make(chan struct{})
- loop := newAndRunTurnLoop(context.Background(), AgentLoopConfig[string]{
+ loop := newAndRunTurnLoop(t.Context(), AgentLoopConfig[string]{
GenInput: genInputConsumeAllWithMsg,
PrepareAgent: func(ctx context.Context, _ *AgentLoop[string], consumed []string) (Agent, error) {
return &turnLoopCancellableMockAgent{
@@ -1366,7 +1366,7 @@ func TestTurnLoop_TurnContext_StoppedChannel(t *testing.T) {
// ======================== Stop With Skip Checkpoint ========================
func TestTurnLoop_StopWithSkipCheckpoint(t *testing.T) {
- ctx := context.Background()
+ ctx := t.Context()
store := newTestStore()
cpID := "skip-cp-session"
@@ -1391,7 +1391,7 @@ func TestTurnLoop_StopWithSkipCheckpoint(t *testing.T) {
// ======================== Stop With Stop Cause ========================
func TestTurnLoop_StopWithStopCause(t *testing.T) {
- ctx := context.Background()
+ ctx := t.Context()
cause := "user session timeout"
loop := newAndRunTurnLoop(ctx, AgentLoopConfig[string]{
@@ -1409,7 +1409,7 @@ func TestTurnLoop_StopWithStopCause(t *testing.T) {
}
func TestTurnLoop_StopCause_EmptyWhenNoStop(t *testing.T) {
- ctx := context.Background()
+ ctx := t.Context()
loop := newAndRunTurnLoop(ctx, AgentLoopConfig[string]{
GenInput: genInputConsumeAll,
@@ -1428,7 +1428,7 @@ func TestTurnLoop_StopCause_InTurnContext(t *testing.T) {
gotCause := make(chan string, 1)
agentStarted := make(chan struct{})
- loop := newAndRunTurnLoop(context.Background(), AgentLoopConfig[string]{
+ loop := newAndRunTurnLoop(t.Context(), AgentLoopConfig[string]{
GenInput: genInputConsumeAllWithMsg,
PrepareAgent: func(ctx context.Context, _ *AgentLoop[string], consumed []string) (Agent, error) {
return &turnLoopCancellableMockAgent{
@@ -1478,7 +1478,7 @@ func TestTurnLoop_StopCause_InTurnContext(t *testing.T) {
func TestTurnLoop_StopCause_FirstNonEmptyWins(t *testing.T) {
agentStarted := make(chan struct{})
- loop := newAndRunTurnLoop(context.Background(), AgentLoopConfig[string]{
+ loop := newAndRunTurnLoop(t.Context(), AgentLoopConfig[string]{
GenInput: genInputConsumeAllWithMsg,
PrepareAgent: func(ctx context.Context, _ *AgentLoop[string], consumed []string) (Agent, error) {
return &turnLoopCancellableMockAgent{
@@ -1535,7 +1535,7 @@ func TestTurnLoop_StopBeforeRun_PushThenStop(t *testing.T) {
}
loop.Stop()
- loop.Run(context.Background())
+ loop.Run(t.Context())
result := loop.Wait()
if result.ExitReason != nil {
@@ -1551,7 +1551,7 @@ func TestTurnLoop_SkipCheckpoint_Sticky(t *testing.T) {
store := newTestStore()
cpID := "sticky-skip-session"
- loop := newAndRunTurnLoop(context.Background(), AgentLoopConfig[string]{
+ loop := newAndRunTurnLoop(t.Context(), AgentLoopConfig[string]{
Store: store,
CheckpointID: cpID,
GenInput: genInputConsumeAllWithMsg,
@@ -1590,7 +1590,7 @@ func TestTurnLoop_SkipCheckpoint_Sticky(t *testing.T) {
func TestTurnLoop_GenInputError_RecoverItems(t *testing.T) {
genErr := errors.New("gen input error")
- loop := newAndRunTurnLoop(context.Background(), AgentLoopConfig[string]{
+ loop := newAndRunTurnLoop(t.Context(), AgentLoopConfig[string]{
GenInput: func(ctx context.Context, _ *AgentLoop[string], items []string) (*GenInputResult[string], error) {
return nil, genErr
},
@@ -1609,7 +1609,7 @@ func TestTurnLoop_GenInputError_RecoverItems(t *testing.T) {
// ======================== Checkpoint Not Found ========================
func TestTurnLoop_CheckpointNotFound_FreshStart(t *testing.T) {
- ctx := context.Background()
+ ctx := t.Context()
store := newTestStore()
var genInputCalled bool
loop := NewAgentLoop(AgentLoopConfig[string]{
diff --git a/internal/harness/core/agentcore_full_test.go b/internal/harness/core/agentcore_full_test.go
index 62538471cb..101b66abfa 100644
--- a/internal/harness/core/agentcore_full_test.go
+++ b/internal/harness/core/agentcore_full_test.go
@@ -27,7 +27,7 @@ func TestReActAgent_BasicGenerate(t *testing.T) {
model := &mockModel{}
model.addResp("Hello!")
agent := reActAgentSetup(model, nil)
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("Hi")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("Hi")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Fatal("expected events")
@@ -54,7 +54,7 @@ func TestReActAgent_ToolCallAndResponse(t *testing.T) {
}
tool := &mockTool{name: "search", desc: "Search tool"}
agent := reActAgentSetup(wrapperModel, []Tool{tool})
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("Search")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("Search")}})
drainAgentEvents(t, iter)
if !tool.executed {
t.Error("tool not executed")
@@ -68,7 +68,7 @@ func TestReActAgent_MaxIterationsExceeded(t *testing.T) {
name: "maxiter",
}
agent.config.Model = loopModel
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("Loop")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("Loop")}})
var lastErr error
for {
ev, ok := iter.Next()
@@ -89,7 +89,7 @@ func TestReActAgent_ZeroMaxIterations(t *testing.T) {
model.addResp("zero iter")
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model, MaxIterations: 0})
agent.name = "zero_iter"
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events even with zero iterations")
@@ -107,7 +107,7 @@ func TestReActAgent_ReturnDirectly(t *testing.T) {
ReturnDirectly: map[string]bool{"quick": true},
})
agent.name = "rd"
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events")
@@ -121,7 +121,7 @@ func TestRunner_CreateAndQuery(t *testing.T) {
model.addResp("Runner query")
agent := reActAgentSetup(model, nil)
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent})
- iter := runner.Query(context.Background(), "Test query")
+ iter := runner.Query(t.Context(), "Test query")
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events")
@@ -135,9 +135,9 @@ func TestRunner_MultipleRuns(t *testing.T) {
agent := reActAgentSetup(model, nil)
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent})
- iter1 := runner.Run(context.Background(), []Message{schema.UserMessage("A")})
+ iter1 := runner.Run(t.Context(), []Message{schema.UserMessage("A")})
e1 := drainAgentEvents(t, iter1)
- iter2 := runner.Run(context.Background(), []Message{schema.UserMessage("B")})
+ iter2 := runner.Run(t.Context(), []Message{schema.UserMessage("B")})
e2 := drainAgentEvents(t, iter2)
if len(e1) == 0 || len(e2) == 0 {
t.Errorf("events: %d %d", len(e1), len(e2))
@@ -149,7 +149,7 @@ func TestRunner_WithRunOptions(t *testing.T) {
model.addResp("Options")
agent := reActAgentSetup(model, nil)
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent})
- iter := runner.Run(context.Background(), []Message{schema.UserMessage("opts")}, WithSessionValues(map[string]any{"k": "v"}))
+ iter := runner.Run(t.Context(), []Message{schema.UserMessage("opts")}, WithSessionValues(map[string]any{"k": "v"}))
drainAgentEvents(t, iter)
}
@@ -159,7 +159,7 @@ func TestRunner_WithCheckpoint(t *testing.T) {
agent := reActAgentSetup(model, nil)
store := &memStore{}
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent, CheckPointStore: store})
- iter := runner.Run(context.Background(), []Message{schema.UserMessage("cp")})
+ iter := runner.Run(t.Context(), []Message{schema.UserMessage("cp")})
drainAgentEvents(t, iter)
}
@@ -178,7 +178,7 @@ func TestAgentTool_Basic(t *testing.T) {
subAgent := reActAgentSetup(subModel, nil)
subAgent.name = "sub_tool"
- ctx := context.Background()
+ ctx := t.Context()
agentTool := NewAgentTool(ctx, subAgent)
if agentTool.Name() != "sub_tool" {
t.Errorf("tool name = %s", agentTool.Name())
@@ -196,7 +196,7 @@ func TestAgentTool_WithFullChatHistory(t *testing.T) {
subModel.addResp("history result")
subAgent := reActAgentSetup(subModel, nil)
subAgent.name = "history_tool"
- ctx := context.Background()
+ ctx := t.Context()
agentTool := NewAgentTool(ctx, subAgent, WithFullChatHistoryAsInput())
_, err := agentTool.Invoke(ctx, `{"query":"test"}`)
if err != nil {
@@ -210,7 +210,7 @@ func TestAgentTool_FromRunner(t *testing.T) {
subAgent := reActAgentSetup(subModel, nil)
subAgent.name = "research"
- ctx := context.Background()
+ ctx := t.Context()
agentTool := NewAgentTool(ctx, subAgent)
mainModel := &forcedToolModel{
@@ -239,7 +239,7 @@ func TestToolsNode_Basic(t *testing.T) {
Role: schema.RoleAssistant, Content: "",
ToolCalls: []schema.ToolCall{{ID: "c1", Function: schema.ToolCallFunction{Name: "greet", Arguments: `{"name":"world"}`}}},
}
- results, action, err := tn.Execute(context.Background(), resp, nil, nil)
+ results, action, err := tn.Execute(t.Context(), resp, nil, nil)
if err != nil {
t.Fatalf("Execute: %v", err)
}
@@ -252,7 +252,7 @@ func TestToolsNode_Basic(t *testing.T) {
func TestToolsNode_NoToolCalls(t *testing.T) {
tn := NewToolsNode[*schema.Message](&ToolsNodeConfig{Tools: []Tool{&mockTool{name: "t", desc: "t"}}})
resp := &schema.Message{Role: schema.RoleAssistant, Content: "Just text"}
- results, action, err := tn.Execute(context.Background(), resp, nil, nil)
+ results, action, err := tn.Execute(t.Context(), resp, nil, nil)
if err != nil {
t.Fatalf("Execute: %v", err)
}
@@ -268,7 +268,7 @@ func TestToolsNode_ToolNotFound(t *testing.T) {
Role: schema.RoleAssistant, Content: "",
ToolCalls: []schema.ToolCall{{ID: "c1", Function: schema.ToolCallFunction{Name: "nonexistent", Arguments: "{}"}}},
}
- results, action, err := tn.Execute(context.Background(), resp, nil, nil)
+ results, action, err := tn.Execute(t.Context(), resp, nil, nil)
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
@@ -287,7 +287,7 @@ func TestToolsNode_ReturnDirectly(t *testing.T) {
Role: schema.RoleAssistant, Content: "",
ToolCalls: []schema.ToolCall{{ID: "c1", Function: schema.ToolCallFunction{Name: "quick", Arguments: "{}"}}},
}
- _, action, err := tn.Execute(context.Background(), resp, nil, nil)
+ _, action, err := tn.Execute(t.Context(), resp, nil, nil)
if err != nil {
t.Fatalf("Execute: %v", err)
}
@@ -301,7 +301,7 @@ func TestReActAgent_RetrySucceeds(t *testing.T) {
inner.addResp("final")
retryM := &retryModel{inner: inner, failAttempts: 2}
agent := reActAgentSetup(retryM, nil)
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
drainAgentEvents(t, iter)
}
@@ -310,7 +310,7 @@ func TestReActAgent_RetryExhausted(t *testing.T) {
inner.addResp("never")
retryM := &retryModel{inner: inner, failAttempts: 100}
agent := reActAgentSetup(retryM, nil)
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
var lastErr error
for {
ev, ok := iter.Next()
@@ -327,7 +327,7 @@ func TestReActAgent_RetryExhausted(t *testing.T) {
func TestReActAgent_AlwaysFails(t *testing.T) {
failing := &failModel{}
agent := reActAgentSetup(failing, nil)
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("hello")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("hello")}})
var lastErr error
for {
ev, ok := iter.Next()
@@ -347,7 +347,7 @@ func TestReActAgent_AlwaysFails(t *testing.T) {
func TestInterrupt_Basic(t *testing.T) {
agent := reActAgentSetup(&mockModel{}, nil)
- ctx := context.Background()
+ ctx := t.Context()
_ = TypedCompositeInterrupt[*schema.Message](ctx, "user_interrupt", nil)
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("test")}})
drainAgentEvents(t, iter)
@@ -358,7 +358,7 @@ func TestInterrupt_WithResumeData(t *testing.T) {
agent.name = "resume"
store := &memStore{}
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent, CheckPointStore: store})
- ctx := context.Background()
+ ctx := t.Context()
iter := runner.Run(ctx, []Message{schema.UserMessage("test")})
drainAgentEvents(t, iter)
}
@@ -375,7 +375,7 @@ func TestWorkflow_SequentialAgents(t *testing.T) {
a2 := reActAgentSetup(m2, nil)
a2.name = "a2"
- ctx := context.Background()
+ ctx := t.Context()
wf, err := NewSequential(ctx, &SequentialConfig{Name: "seq", Description: "test", SubAgents: []Agent{a1, a2}})
if err != nil {
t.Fatalf("NewSequential: %v", err)
@@ -398,7 +398,7 @@ func TestWorkflow_ParallelAgents(t *testing.T) {
a2 := reActAgentSetup(m2, nil)
a2.name = "p2"
- ctx := context.Background()
+ ctx := t.Context()
wf, err := NewParallel(ctx, &ParallelConfig{Name: "par", Description: "test", SubAgents: []Agent{a1, a2}})
if err != nil {
t.Fatalf("NewParallel: %v", err)
@@ -420,7 +420,7 @@ func TestWorkflow_LoopAgents(t *testing.T) {
a2 := reActAgentSetup(m2, nil)
a2.name = "critique"
- ctx := context.Background()
+ ctx := t.Context()
wf, err := NewLoop(ctx, &LoopConfig{
Name: "loop", Description: "test", SubAgents: []Agent{a1, a2}, MaxIterations: 2,
})
@@ -469,7 +469,7 @@ func TestMiddleware_ChainOrderPreserved(t *testing.T) {
Model: model, Middlewares: []ReActMiddleware{m1, m2},
})
agent.name = "chain"
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
drainAgentEvents(t, iter)
t.Logf("m1: %v", m1.executed)
t.Logf("m2: %v", m2.executed)
@@ -483,7 +483,7 @@ func TestMiddleware_ErrorPropagation(t *testing.T) {
mw := &errorMiddleware{failAt: failAt}
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model, Middlewares: []ReActMiddleware{mw}})
agent.name = "err_" + failAt
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
var lastErr error
for {
ev, ok := iter.Next()
@@ -510,7 +510,7 @@ func TestMiddleware_WrapModel(t *testing.T) {
model.addResp("wrapped")
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model, Middlewares: []ReActMiddleware{mw}})
agent.name = "wrap_m"
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}})
drainAgentEvents(t, iter)
if !wrapped {
t.Error("WrapModel not called")
@@ -530,7 +530,7 @@ func TestCallbacks_OnStartOnEnd(t *testing.T) {
agent := reActAgentSetup(model, nil)
agent.name = "cb_agent"
// Callbacks are wired in flowAgent.Run path
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("cb")}}, WithCallbacks(cb))
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("cb")}}, WithCallbacks(cb))
drainAgentEvents(t, iter)
_ = onStart
_ = onEnd
@@ -549,35 +549,35 @@ func TestCallbackFilter_AgentNameMatch(t *testing.T) {
// ======================== Callback Infrastructure Tests ========================
func TestInitAgentCallbacks_Nil(t *testing.T) {
- ctx := initAgentCallbacks(context.Background(), "test", "ReActAgent")
+ ctx := initAgentCallbacks(t.Context(), "test", "ReActAgent")
if cbs := getCallbacks(ctx); cbs != nil {
t.Error("expected nil callbacks")
}
}
func TestSetRunLocalValue_NoExecCtx(t *testing.T) {
- err := SetRunLocalValue(context.Background(), "k", "v")
+ err := SetRunLocalValue(t.Context(), "k", "v")
if err == nil {
t.Error("expected error with no exec ctx")
}
}
func TestGetRunLocalValue_NoExecCtx(t *testing.T) {
- _, _, err := GetRunLocalValue(context.Background(), "k")
+ _, _, err := GetRunLocalValue(t.Context(), "k")
if err == nil {
t.Error("expected error")
}
}
func TestDeleteRunLocalValue_NoExecCtx(t *testing.T) {
- err := DeleteRunLocalValue(context.Background(), "k")
+ err := DeleteRunLocalValue(t.Context(), "k")
if err == nil {
t.Error("expected error")
}
}
func TestSendEvent_NoExecCtx(t *testing.T) {
- err := SendEvent(context.Background(), nil)
+ err := SendEvent(t.Context(), nil)
if err == nil {
t.Error("expected error")
}
@@ -695,7 +695,7 @@ func TestConcurrentCancel(t *testing.T) {
agent := reActAgentSetup(model, nil)
agent.name = "cc"
opt, cancel := WithCancel()
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("test")}}, opt)
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("test")}}, opt)
cancel()
drainAgentEvents(t, iter)
}(i)
@@ -710,7 +710,7 @@ func TestConcurrentIterators(t *testing.T) {
model := &mockModel{}
model.addResp("conc")
agent := reActAgentSetup(model, nil)
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("hi")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("hi")}})
drainAgentEvents(t, iter)
})
}
@@ -748,7 +748,7 @@ func TestRunner_ResumeWithCheckpoint(t *testing.T) {
agent.name = "resume_test"
store := &memStore{}
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent, CheckPointStore: store})
- ctx := context.Background()
+ ctx := t.Context()
iter := runner.Run(ctx, []Message{schema.UserMessage("test")})
drainAgentEvents(t, iter)
}
diff --git a/internal/harness/core/agentic_integration_test.go b/internal/harness/core/agentic_integration_test.go
index 5815e496ab..4e8e2e99d7 100644
--- a/internal/harness/core/agentic_integration_test.go
+++ b/internal/harness/core/agentic_integration_test.go
@@ -20,7 +20,7 @@ func TestWorkflow_SequentialAgent(t *testing.T) {
a2 := reActAgentSetup(m2, nil)
a2.name = "seq_a2"
- ctx := context.Background()
+ ctx := t.Context()
wf, err := NewSequential(ctx, &SequentialConfig{
Name: "seq", Description: "test", SubAgents: []Agent{a1, a2},
})
@@ -45,7 +45,7 @@ func TestWorkflow_ParallelAgent(t *testing.T) {
a2 := reActAgentSetup(m2, nil)
a2.name = "par_a2"
- ctx := context.Background()
+ ctx := t.Context()
wf, err := NewParallel(ctx, &ParallelConfig{
Name: "par", Description: "test", SubAgents: []Agent{a1, a2},
})
@@ -73,7 +73,7 @@ func TestWorkflow_NestedParallel(t *testing.T) {
a2 := reActAgentSetup(m2, nil)
a2.name = "inner_b"
- innerPar, err := NewParallel(context.Background(), &ParallelConfig{
+ innerPar, err := NewParallel(t.Context(), &ParallelConfig{
Name: "inner-par", Description: "inner parallel", SubAgents: []Agent{a1, a2},
})
if err != nil {
@@ -82,14 +82,14 @@ func TestWorkflow_NestedParallel(t *testing.T) {
a3 := reActAgentSetup(m3, nil)
a3.name = "outer"
- wf, err := NewSequential(context.Background(), &SequentialConfig{
+ wf, err := NewSequential(t.Context(), &SequentialConfig{
Name: "nested", Description: "nested parallel", SubAgents: []Agent{innerPar, a3},
})
if err != nil {
t.Fatalf("NewSequential: %v", err)
}
- iter := wf.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("nested")}})
+ iter := wf.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("nested")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events from nested workflow")
@@ -103,7 +103,7 @@ func TestWorkflow_LoopAgent(t *testing.T) {
body := reActAgentSetup(m, nil)
body.name = "loop_body"
- ctx := context.Background()
+ ctx := t.Context()
wf, err := NewLoop(ctx, &LoopConfig{
Name: "loop", Description: "test", SubAgents: []Agent{body}, MaxIterations: 3,
})
@@ -120,7 +120,7 @@ func TestWorkflow_LoopAgent(t *testing.T) {
func TestWorkflow_UnsupportedMode(t *testing.T) {
wf := &workflowAgent{name: "bad", mode: workflowModeUnknown}
- iter := wf.Run(context.Background(), &AgentInput{})
+ iter := wf.Run(t.Context(), &AgentInput{})
ev, ok := iter.Next()
if !ok {
t.Fatal("expected an event")
@@ -139,7 +139,7 @@ func TestAgenticIntegration_BasicGenerate(t *testing.T) {
model.addResp("Hello!")
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model}).WithName("e2e")
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("Hi")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("Hi")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Fatal("expected events")
@@ -156,7 +156,7 @@ func TestAgenticIntegration_ToolInvocation(t *testing.T) {
Model: model, Tools: []Tool{tool},
}).WithName("tool_e2e")
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("search something")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("search something")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events")
@@ -170,7 +170,7 @@ func TestAgenticIntegration_StreamingOutput(t *testing.T) {
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model}).WithName("stream_e2e")
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("stream test")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
@@ -183,7 +183,7 @@ func TestAgenticIntegration_EmptyInput(t *testing.T) {
model.addResp("response")
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model}).WithName("empty")
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
@@ -210,7 +210,7 @@ func TestAgenticIntegration_ToolInvokeMiddlewareChain(t *testing.T) {
},
}).WithName("mw_chain_e2e")
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("search")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("search")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events")
@@ -236,7 +236,7 @@ func TestAgenticIntegration_ReflectToolAgent(t *testing.T) {
Tools: []Tool{weatherTool},
}).WithName("reflect_e2e")
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("weather in Tokyo")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("weather in Tokyo")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events")
@@ -261,7 +261,7 @@ func TestAgenticIntegration_ToolRegistryAgent(t *testing.T) {
Tools: r.ToSlice(),
}).WithName("registry_e2e")
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("search for London")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("search for London")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events")
@@ -289,7 +289,7 @@ func TestAgenticIntegration_RetryToolMiddleware(t *testing.T) {
},
}).WithName("retry_tool_e2e")
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("run")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("run")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events")
@@ -316,7 +316,7 @@ func TestAgenticIntegration_ToolFallback(t *testing.T) {
},
}).WithName("fallback_e2e")
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("run")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("run")}})
events := drainAgentEvents(t, iter)
if len(events) == 0 {
t.Error("expected events")
@@ -331,6 +331,6 @@ func TestAgenticIntegration_ModelErrorRecovery(t *testing.T) {
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: wrapped}).WithName("retry_e2e")
- iter := agent.Run(context.Background(), &AgentInput{Messages: []Message{schema.UserMessage("retry test")}})
+ iter := agent.Run(t.Context(), &AgentInput{Messages: []Message{schema.UserMessage("retry test")}})
_ = drainAgentEvents(t, iter)
}
diff --git a/internal/harness/core/callback_test.go b/internal/harness/core/callback_test.go
index 3c988609de..4be6993cc6 100644
--- a/internal/harness/core/callback_test.go
+++ b/internal/harness/core/callback_test.go
@@ -14,7 +14,7 @@ import (
// layer: context propagation, filtering, and option handling.
func TestInitAgentCallbacks_NoCallbacks(t *testing.T) {
- ctx := initAgentCallbacks(context.Background(), "test_agent", "ReActAgent")
+ ctx := initAgentCallbacks(t.Context(), "test_agent", "ReActAgent")
cbs := getCallbacks(ctx)
if cbs != nil {
t.Error("expected nil callbacks when no options provided")
@@ -75,7 +75,7 @@ func TestCallbacks_WithAgentNamesFilter_CallbackSavedAndFiltered(t *testing.T) {
opts := []RunOption{WithCallbacks(cb), WithAgentNames("filtered_agent")}
// Callback is at the option level; it gets injected during flowAgent.Run
- iter := agent.Run(context.Background(), &AgentInput{
+ iter := agent.Run(t.Context(), &AgentInput{
Messages: []Message{schema.UserMessage("test")},
}, opts...)
for {
@@ -92,7 +92,7 @@ func TestCallbacks_EmptyCallbacks(t *testing.T) {
model.addResp("no-cb")
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model})
agent.name = "no_cb"
- iter := agent.Run(context.Background(), &AgentInput{
+ iter := agent.Run(t.Context(), &AgentInput{
Messages: []Message{schema.UserMessage("test")},
})
for {
@@ -160,7 +160,7 @@ func TestFilterCallbackHandlersForNestedAgents_MatchingAgent(t *testing.T) {
// ---- RunLocalValue tests ----
func TestSetRunLocalValue_NotInAgentExec(t *testing.T) {
- err := SetRunLocalValue(context.Background(), "key", "value")
+ err := SetRunLocalValue(t.Context(), "key", "value")
if err == nil {
t.Error("expected error when not in agent execution context")
}
@@ -174,21 +174,21 @@ func TestSetRunLocalValue_NotInAgentExec(t *testing.T) {
}
func TestGetRunLocalValue_NotInAgentExec(t *testing.T) {
- _, _, err := GetRunLocalValue(context.Background(), "key")
+ _, _, err := GetRunLocalValue(t.Context(), "key")
if err == nil {
t.Error("expected error when not in agent execution context")
}
}
func TestDeleteRunLocalValue_NotInAgentExec(t *testing.T) {
- err := DeleteRunLocalValue(context.Background(), "key")
+ err := DeleteRunLocalValue(t.Context(), "key")
if err == nil {
t.Error("expected error when not in agent execution context")
}
}
func TestSendEvent_NotInAgentExec(t *testing.T) {
- err := SendEvent(context.Background(), nil)
+ err := SendEvent(t.Context(), nil)
if err == nil {
t.Error("expected error when not in agent execution context")
}
@@ -289,7 +289,7 @@ func TestWithCallbacks_Nil(t *testing.T) {
func TestWithCallbacks_Context(t *testing.T) {
cb := callbackHandler{}
- ctx := withCallbacks(context.Background(), []callbackHandler{cb})
+ ctx := withCallbacks(t.Context(), []callbackHandler{cb})
cbs := getCallbacks(ctx)
if len(cbs) != 1 {
t.Errorf("expected 1 callback, got %d", len(cbs))
@@ -297,15 +297,15 @@ func TestWithCallbacks_Context(t *testing.T) {
}
func TestGetCallbacks_NoCallbacks(t *testing.T) {
- cbs := getCallbacks(context.Background())
+ cbs := getCallbacks(t.Context())
if cbs != nil {
t.Error("expected nil")
}
}
func TestWithCallbacks_Empty(t *testing.T) {
- ctx := withCallbacks(context.Background(), nil)
- if ctx != context.Background() {
+ ctx := withCallbacks(t.Context(), nil)
+ if ctx != t.Context() {
t.Errorf("empty callbacks should return original context")
}
}
diff --git a/internal/harness/core/cancel_full_test.go b/internal/harness/core/cancel_full_test.go
index ff7a0f7264..166f0a9391 100644
--- a/internal/harness/core/cancel_full_test.go
+++ b/internal/harness/core/cancel_full_test.go
@@ -267,7 +267,7 @@ func TestBuildCancelFunc_CASFailStateDone(t *testing.T) {
cf := cc.buildCancelFunc()
var wg sync.WaitGroup
for j := 0; j < 100; j++ {
- wg.Go(func() { ; _, _ = cf() })
+ wg.Go(func() { _, _ = cf() })
}
wg.Wait()
cc.markHandled()
@@ -322,7 +322,7 @@ func TestDeriveAgentToolCancelContext(t *testing.T) {
t.Run("Shallow/GoroutineCleanup", func(t *testing.T) {
before := goroutineCount()
parent := newCancelContext()
- ctx, cancel := context.WithCancel(context.Background())
+ ctx, cancel := context.WithCancel(t.Context())
child := parent.deriveAgentToolCancelContext(ctx)
parent.triggerCancel(CancelAfterChatModel)
time.Sleep(100 * time.Millisecond)
@@ -405,7 +405,7 @@ func TestDeriveAgentToolCancelContext_Race(t *testing.T) {
t.Run("SetRecursiveConcurrentWithCancelChan", func(t *testing.T) {
for i := 0; i < 50; i++ {
parent := newCancelContext()
- ctx, cancel := context.WithCancel(context.Background())
+ ctx, cancel := context.WithCancel(t.Context())
child := parent.deriveAgentToolCancelContext(ctx)
var wg sync.WaitGroup
wg.Add(2)
@@ -518,7 +518,7 @@ func TestCancel_SafePointNeverFires_ErrExecutionEnded(t *testing.T) {
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: &mockModel{}})
agent.name = "never"
opt, cancel := WithCancel()
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("hi")}}, opt)
cancel(WithCancelMode(CancelAfterChatModel))
for {
@@ -534,12 +534,12 @@ func TestCancel_SafePointNeverFires_ErrExecutionEnded(t *testing.T) {
func TestCancelContextKey(t *testing.T) {
cc := newCancelContext()
- ctx := withCancelContext(context.Background(), cc)
+ ctx := withCancelContext(t.Context(), cc)
got := getCancelContext(ctx)
if got == nil {
t.Fatal("expected cancelContext")
}
- if v := getCancelContext(context.Background()); v != nil {
+ if v := getCancelContext(t.Context()); v != nil {
t.Error("expected nil")
}
}
@@ -555,7 +555,7 @@ func TestWithCancel_SequentialAgent(t *testing.T) {
a1.name = "s1"
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
a2.name = "s2"
- ctx := context.Background()
+ ctx := t.Context()
wf, err := NewSequential(ctx, &SequentialConfig{Name: "seq", Description: "test", SubAgents: []Agent{a1, a2}})
if err != nil {
t.Fatalf("NewSequential: %v", err)
@@ -575,7 +575,7 @@ func TestWithCancel_LoopAgent(t *testing.T) {
a1.name = "l1"
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
a2.name = "l2"
- ctx := context.Background()
+ ctx := t.Context()
wf, err := NewLoop(ctx, &LoopConfig{Name: "loop", Description: "test", SubAgents: []Agent{a1, a2}, MaxIterations: 5})
if err != nil {
t.Fatalf("NewLoop: %v", err)
@@ -595,7 +595,7 @@ func TestWithCancel_ParallelAgent(t *testing.T) {
a1.name = "p1"
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
a2.name = "p2"
- ctx := context.Background()
+ ctx := t.Context()
wf, err := NewParallel(ctx, &ParallelConfig{Name: "par", Description: "test", SubAgents: []Agent{a1, a2}})
if err != nil {
t.Fatalf("NewParallel: %v", err)
@@ -615,7 +615,7 @@ func TestCheckCancel_Sequential_BetweenSubAgents(t *testing.T) {
a1.name = "x1"
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
a2.name = "x2"
- ctx := context.Background()
+ ctx := t.Context()
wf, _ := NewSequential(ctx, &SequentialConfig{Name: "chk", Description: "test", SubAgents: []Agent{a1, a2}})
opt, cancel := WithCancel()
iter := wf.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
@@ -638,7 +638,7 @@ func TestCheckCancel_Loop_BetweenIterations(t *testing.T) {
a1.name = "y1"
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
a2.name = "y2"
- ctx := context.Background()
+ ctx := t.Context()
wf, _ := NewLoop(ctx, &LoopConfig{Name: "chk_loop", Description: "test", SubAgents: []Agent{a1, a2}, MaxIterations: 5})
opt, cancel := WithCancel()
iter := wf.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
@@ -661,7 +661,7 @@ func TestCheckCancel_Parallel_PreSpawn(t *testing.T) {
a1.name = "z1"
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
a2.name = "z2"
- ctx := context.Background()
+ ctx := t.Context()
wf, _ := NewParallel(ctx, &ParallelConfig{Name: "chk_par", Description: "test", SubAgents: []Agent{a1, a2}})
opt, cancel := WithCancel()
iter := wf.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
@@ -683,7 +683,7 @@ func TestWithCancel_AfterCompletion(t *testing.T) {
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model})
agent.name = "after"
opt, cancel := WithCancel()
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("hi")}}, opt)
for {
ev, ok := iter.Next()
@@ -706,7 +706,7 @@ func goroutineCount() int { n := runtime.NumGoroutine(); return n }
func setupParentChild(t *testing.T) (parent, child *cancelContext, cleanup func()) {
parent = newCancelContext()
- ctx, cancel := context.WithCancel(context.Background())
+ ctx, cancel := context.WithCancel(t.Context())
child = parent.deriveAgentToolCancelContext(ctx)
return parent, child, func() { child.markDone(); cancel() }
}
@@ -740,7 +740,7 @@ func TestCancelWithTools_CancelImmediate(t *testing.T) {
})
agent.name = "with_tools"
opt, cancel := WithCancel()
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
time.Sleep(50 * time.Millisecond)
cancel()
@@ -763,7 +763,7 @@ func TestCancelWithTools_CancelAfterChatModel(t *testing.T) {
})
agent.name = "after_chat"
opt, cancel := WithCancel()
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
time.Sleep(50 * time.Millisecond)
cancel(WithCancelMode(CancelAfterChatModel))
@@ -787,7 +787,7 @@ func TestCancelWithTools_CancelAfterToolCalls(t *testing.T) {
})
agent.name = "after_tool"
opt, cancel := WithCancel()
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
time.Sleep(50 * time.Millisecond)
cancel(WithCancelMode(CancelAfterToolCalls))
@@ -807,7 +807,7 @@ func TestWithCancel_WithCheckpoint(t *testing.T) {
agent.name = "ckpt"
store := newCancelTestStore()
opt, cancel := WithCancel()
- ctx := context.Background()
+ ctx := t.Context()
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent, CheckPointStore: store})
iter := runner.Run(ctx, []*schema.Message{schema.UserMessage("run")}, opt)
cancel()
@@ -827,7 +827,7 @@ func TestWithCancel_Streaming(t *testing.T) {
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model})
agent.name = "stream_cancel"
opt, cancel := WithCancel()
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}, EnableStreaming: true}, opt)
time.Sleep(30 * time.Millisecond)
cancel()
@@ -850,7 +850,7 @@ func TestWithCancel_Streaming(t *testing.T) {
})
agent.name = "stream_tool_cancel"
opt, cancel := WithCancel()
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}, EnableStreaming: true}, opt)
time.Sleep(50 * time.Millisecond)
cancel(WithCancelMode(CancelAfterToolCalls))
@@ -871,7 +871,7 @@ func TestWithCancel_Resume(t *testing.T) {
agent.name = "cancel_then_resume"
store := newCancelTestStore()
opt, cancel := WithCancel()
- ctx := context.Background()
+ ctx := t.Context()
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent, CheckPointStore: store})
iter := runner.Run(ctx, []*schema.Message{schema.UserMessage("run")}, opt)
cancel()
@@ -893,7 +893,7 @@ func TestCancel_SequentialWorkflow_CancelAfterChatModel(t *testing.T) {
a1.name = "s1"
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
a2.name = "s2"
- ctx := context.Background()
+ ctx := t.Context()
wf, _ := NewSequential(ctx, &SequentialConfig{Name: "seq", Description: "test", SubAgents: []Agent{a1, a2}})
store := newCancelTestStore()
opt, cancel := WithCancel()
@@ -919,7 +919,7 @@ func TestCancel_ParallelWorkflow_CancelAfterChatModel(t *testing.T) {
a1.name = "p1"
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
a2.name = "p2"
- ctx := context.Background()
+ ctx := t.Context()
wf, _ := NewParallel(ctx, &ParallelConfig{Name: "par", Description: "test", SubAgents: []Agent{a1, a2}})
opt, cancel := WithCancel()
iter := wf.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
@@ -943,7 +943,7 @@ func TestCancel_LoopWorkflow_CancelAfterChatModel(t *testing.T) {
a1.name = "l1"
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
a2.name = "l2"
- ctx := context.Background()
+ ctx := t.Context()
wf, _ := NewLoop(ctx, &LoopConfig{Name: "loop", Description: "test", SubAgents: []Agent{a1, a2}, MaxIterations: 5})
opt, cancel := WithCancel()
iter := wf.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
@@ -967,7 +967,7 @@ func TestCheckCancel_Transfer_BeforeTarget(t *testing.T) {
a1.name = "sup"
sAgent := NewReActAgent(&ReActConfig[*schema.Message]{Model: s1})
sAgent.name = "sub1"
- ctx := context.Background()
+ ctx := t.Context()
sup, err := SetSubAgents(ctx, a1, []Agent{sAgent})
if err != nil {
t.Fatalf("SetSubAgents: %v", err)
@@ -993,7 +993,7 @@ func TestCancelImmediate_SequentialTransitionBoundary(t *testing.T) {
a1.name = "x1"
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
a2.name = "x2"
- ctx := context.Background()
+ ctx := t.Context()
wf, _ := NewSequential(ctx, &SequentialConfig{Name: "seq_bound", Description: "test", SubAgents: []Agent{a1, a2}})
opt, cancel := WithCancel()
iter := wf.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
@@ -1017,7 +1017,7 @@ func TestCancelImmediate_LoopTransitionBoundary(t *testing.T) {
a1.name = "lx"
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
a2.name = "ly"
- ctx := context.Background()
+ ctx := t.Context()
wf, _ := NewLoop(ctx, &LoopConfig{Name: "loop_bound", Description: "test", SubAgents: []Agent{a1, a2}, MaxIterations: 5})
opt, cancel := WithCancel()
iter := wf.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
@@ -1041,7 +1041,7 @@ func TestCancelAfterChatModel_SequentialTransitionBoundary(t *testing.T) {
a1.name = "t1"
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
a2.name = "t2"
- ctx := context.Background()
+ ctx := t.Context()
wf, _ := NewSequential(ctx, &SequentialConfig{Name: "seq_trans", Description: "test", SubAgents: []Agent{a1, a2}})
opt, cancel := WithCancel()
iter := wf.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
@@ -1073,7 +1073,7 @@ func TestCancelImmediate_MultiLevelNesting(t *testing.T) {
a2.name = "mid"
a3 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m3})
a3.name = "leaf"
- ctx := context.Background()
+ ctx := t.Context()
midFlow, err := SetSubAgents(ctx, a2, []Agent{a3})
if err != nil {
t.Fatalf("SetSubAgents mid: %v", err)
@@ -1101,13 +1101,13 @@ func TestCancel_NestedWorkflow_AgentTool_CancelAfterChatModel(t *testing.T) {
mLeaf.addResp("leaf")
leafAgent := NewReActAgent(&ReActConfig[*schema.Message]{Model: mLeaf})
leafAgent.name = "leaf"
- tool := NewAgentTool(context.Background(), leafAgent)
+ tool := NewAgentTool(t.Context(), leafAgent)
rootAgent := NewReActAgent(&ReActConfig[*schema.Message]{
Model: mRoot, Tools: []Tool{tool}, ToolsConfig: &ToolsNodeConfig{Tools: []Tool{tool}},
})
rootAgent.name = "root"
opt, cancel := WithCancel()
- ctx := context.Background()
+ ctx := t.Context()
iter := rootAgent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("start")}}, opt)
time.Sleep(30 * time.Millisecond)
cancel(WithCancelMode(CancelAfterChatModel))
@@ -1133,7 +1133,7 @@ func TestCancel_CancelAfterToolCalls_InSequentialWorkflow(t *testing.T) {
a1.name = "with_tool"
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
a2.name = "after_tool"
- ctx := context.Background()
+ ctx := t.Context()
wf, _ := NewSequential(ctx, &SequentialConfig{Name: "seq_tool", Description: "test", SubAgents: []Agent{a1, a2}})
opt, cancel := WithCancel()
iter := wf.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
@@ -1151,7 +1151,7 @@ func TestCancel_CancelAfterToolCalls_InSequentialWorkflow(t *testing.T) {
func TestCancelImmediate_CancelUnawareAgent_GracePeriodFallback(t *testing.T) {
ua := &cancelUnawareAgent{name: "unaware", desc: "agent that ignores cancel"}
cc := newCancelContext()
- ctx := withCancelContext(context.Background(), cc)
+ ctx := withCancelContext(t.Context(), cc)
opt := WrapImplSpecificOptFn(func(o *runOptions) { o.cancelCtx = cc })
iter := ua.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("hi")}}, opt)
cc.triggerImmediate()
@@ -1173,7 +1173,7 @@ func TestCancelImmediate_ParallelWorkflow_WithAgentTool(t *testing.T) {
a1.name = "pt1"
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
a2.name = "pt2"
- ctx := context.Background()
+ ctx := t.Context()
wf, _ := NewParallel(ctx, &ParallelConfig{Name: "par_tool", Description: "test", SubAgents: []Agent{a1, a2}})
opt, cancel := WithCancel()
iter := wf.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
@@ -1285,7 +1285,7 @@ func TestCancelContext_RecursiveGraceBoundary(t *testing.T) {
func TestDeriveAgentToolCancelContext_ContextCancelConcurrentWithRecursive(t *testing.T) {
for i := 0; i < 20; i++ {
parent := newCancelContext()
- ctx, cxl := context.WithCancel(context.Background())
+ ctx, cxl := context.WithCancel(t.Context())
child := parent.deriveAgentToolCancelContext(ctx)
var wg sync.WaitGroup
wg.Add(2)
@@ -1299,11 +1299,11 @@ func TestDeriveAgentToolCancelContext_ContextCancelConcurrentWithRecursive(t *te
func TestDeriveAgentToolCancelContext_ConcurrentSetRecursive(t *testing.T) {
for i := 0; i < 20; i++ {
parent := newCancelContext()
- ctx, cancel := context.WithCancel(context.Background())
+ ctx, cancel := context.WithCancel(t.Context())
child := parent.deriveAgentToolCancelContext(ctx)
var wg sync.WaitGroup
for j := 0; j < 10; j++ {
- wg.Go(func() { ; parent.setRecursive(true) })
+ wg.Go(func() { parent.setRecursive(true) })
}
wg.Wait()
child.markDone()
@@ -1320,7 +1320,7 @@ func TestWithCancel_SupervisorAgent(t *testing.T) {
sup.name = "supervisor"
sub := NewReActAgent(&ReActConfig[*schema.Message]{Model: mSub})
sub.name = "sub1"
- ctx := context.Background()
+ ctx := t.Context()
flow, err := SetSubAgents(ctx, sup, []Agent{sub})
if err != nil {
t.Fatalf("SetSubAgents: %v", err)
@@ -1351,7 +1351,7 @@ func TestCancelAfterChatModel_Sequential_Agent1CompletesCancelBeforeAgent2Resume
a2.name = "b"
a3 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m3})
a3.name = "c"
- ctx := context.Background()
+ ctx := t.Context()
wf, _ := NewSequential(ctx, &SequentialConfig{Name: "seq3", Description: "test", SubAgents: []Agent{a1, a2, a3}})
store := newCancelTestStore()
opt, cancel := WithCancel()
@@ -1375,7 +1375,7 @@ func TestCancelImmediate_AgentTool_PreservesChildCheckpoint(t *testing.T) {
mLeaf.addResp("leaf")
leafAgent := NewReActAgent(&ReActConfig[*schema.Message]{Model: mLeaf})
leafAgent.name = "leaf"
- agt := NewAgentTool(context.Background(), leafAgent)
+ agt := NewAgentTool(t.Context(), leafAgent)
root := NewReActAgent(&ReActConfig[*schema.Message]{
Model: mRoot, Tools: []Tool{agt},
ToolsConfig: &ToolsNodeConfig{Tools: []Tool{agt}},
@@ -1384,7 +1384,7 @@ func TestCancelImmediate_AgentTool_PreservesChildCheckpoint(t *testing.T) {
store := newCancelTestStore()
opt, cancel := WithCancel()
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: root, CheckPointStore: store})
- ctx := context.Background()
+ ctx := t.Context()
iter := runner.Run(ctx, []*schema.Message{schema.UserMessage("run")}, opt)
time.Sleep(50 * time.Millisecond)
cancel()
@@ -1410,7 +1410,7 @@ func TestCancelAfterToolCalls_LoopTransitionBoundary(t *testing.T) {
l1.name = "l_tool"
l2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2})
l2.name = "l_done"
- ctx := context.Background()
+ ctx := t.Context()
wf, _ := NewLoop(ctx, &LoopConfig{Name: "loop_tool", Description: "test", SubAgents: []Agent{l1, l2}, MaxIterations: 5})
opt, cancel := WithCancel()
iter := wf.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
@@ -1436,7 +1436,7 @@ func TestCancel_BeforeExecutionStarts(t *testing.T) {
model.addResp("should not be called")
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model}).WithName("never_start")
opt, cancel := WithCancel()
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("fail")}}, opt)
cancel()
for {
@@ -1462,7 +1462,7 @@ func TestCancel_AfterBusinessInterrupt(t *testing.T) {
Model: model, Tools: []Tool{tool},
ToolsConfig: &ToolsNodeConfig{Tools: []Tool{tool}},
}).WithName("biz_interrupt")
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}})
for {
ev, ok := iter.Next()
@@ -1486,7 +1486,7 @@ func TestCancel_AfterError(t *testing.T) {
model := &mockModel{}
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model}).WithName("after_err")
opt, cancel := WithCancel()
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("fail")}}, opt)
for {
ev, ok := iter.Next()
@@ -1508,7 +1508,7 @@ func TestCancel_ModelError(t *testing.T) {
model := &mockModel{}
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model}).WithName("model_err")
opt, cancel := WithCancel()
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("fail")}}, opt)
for {
ev, ok := iter.Next()
@@ -1532,7 +1532,7 @@ func TestCancel_NoCheckpointStore(t *testing.T) {
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: model}).WithName("no_ckpt_cancel")
opt, cancel := WithCancel()
runner := NewTypedRunner(RunnerConfig[*schema.Message]{Agent: agent})
- ctx := context.Background()
+ ctx := t.Context()
iter := runner.Run(ctx, []*schema.Message{schema.UserMessage("run")}, opt)
cancel()
for {
@@ -1557,7 +1557,7 @@ func TestCancel_MultipleToolsConcurrent(t *testing.T) {
ToolsConfig: &ToolsNodeConfig{Tools: []Tool{tool1, tool2}},
}).WithName("multi_tool_cancel")
opt, cancel := WithCancel()
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{Messages: []Message{schema.UserMessage("run")}}, opt)
time.Sleep(30 * time.Millisecond)
cancel(WithCancelMode(CancelAfterToolCalls))
diff --git a/internal/harness/core/contracts_test.go b/internal/harness/core/contracts_test.go
index f25cf7e5f1..1b05cb494c 100644
--- a/internal/harness/core/contracts_test.go
+++ b/internal/harness/core/contracts_test.go
@@ -16,7 +16,7 @@ func TestBaseMiddleware_AllMethods(t *testing.T) {
s := NewReActAgentState([]*schema.Message{}, nil, 10)
mc := &ModelContext{}
- ctx, rc2, err := b.BeforeAgent(context.Background(), rc)
+ ctx, rc2, err := b.BeforeAgent(t.Context(), rc)
if err != nil {
t.Fatalf("BeforeAgent: %v", err)
}
@@ -25,13 +25,13 @@ func TestBaseMiddleware_AllMethods(t *testing.T) {
}
_ = ctx
- ctx, err = b.AfterAgent(context.Background(), s)
+ ctx, err = b.AfterAgent(t.Context(), s)
if err != nil {
t.Fatalf("AfterAgent: %v", err)
}
_ = ctx
- ctx, s2, err := b.BeforeModelRewrite(context.Background(), s, mc)
+ ctx, s2, err := b.BeforeModelRewrite(t.Context(), s, mc)
if err != nil {
t.Fatalf("BeforeModelRewrite: %v", err)
}
@@ -40,7 +40,7 @@ func TestBaseMiddleware_AllMethods(t *testing.T) {
}
_ = ctx
- ctx, s3, err := b.AfterModelRewrite(context.Background(), s, mc)
+ ctx, s3, err := b.AfterModelRewrite(t.Context(), s, mc)
if err != nil {
t.Fatalf("AfterModelRewrite: %v", err)
}
@@ -49,7 +49,7 @@ func TestBaseMiddleware_AllMethods(t *testing.T) {
}
_ = ctx
- m, err := b.WrapModel(context.Background(), nil, nil)
+ m, err := b.WrapModel(t.Context(), nil, nil)
if err != nil {
t.Fatalf("WrapModel: %v", err)
}
@@ -70,7 +70,7 @@ func TestMiddleware_BeforeAgentCanModifyInstruction(t *testing.T) {
Model: model, Middlewares: []ReActMiddleware{mw},
})
agent.name = "mod_agent"
- iter := agent.Run(context.Background(), &AgentInput{
+ iter := agent.Run(t.Context(), &AgentInput{
Messages: []Message{schema.UserMessage("test")},
})
for {
@@ -94,7 +94,7 @@ func TestMiddleware_BeforeModelRewriteCanModifyState(t *testing.T) {
Model: model, Middlewares: []ReActMiddleware{mw},
})
agent.name = "bmr_agent"
- iter := agent.Run(context.Background(), &AgentInput{
+ iter := agent.Run(t.Context(), &AgentInput{
Messages: []Message{schema.UserMessage("test")},
})
for {
@@ -120,7 +120,7 @@ func TestMiddleware_AfterModelRewriteModifiesState(t *testing.T) {
Model: model, Middlewares: []ReActMiddleware{mw},
})
agent.name = "amr_agent"
- iter := agent.Run(context.Background(), &AgentInput{
+ iter := agent.Run(t.Context(), &AgentInput{
Messages: []Message{schema.UserMessage("test")},
})
for {
@@ -150,7 +150,7 @@ func TestMiddleware_MultipleMiddlewares(t *testing.T) {
Model: model, Middlewares: []ReActMiddleware{mw1, mw2},
})
agent.name = "multi_mw"
- iter := agent.Run(context.Background(), &AgentInput{
+ iter := agent.Run(t.Context(), &AgentInput{
Messages: []Message{schema.UserMessage("test")},
})
for {
@@ -176,7 +176,7 @@ func TestMiddleware_BeforeAgentError(t *testing.T) {
Model: model, Middlewares: []ReActMiddleware{mw},
})
agent.name = "err_before"
- iter := agent.Run(context.Background(), &AgentInput{
+ iter := agent.Run(t.Context(), &AgentInput{
Messages: []Message{schema.UserMessage("test")},
})
var lastErr error
@@ -205,7 +205,7 @@ func TestMiddleware_BeforeModelRewriteError(t *testing.T) {
Model: model, Middlewares: []ReActMiddleware{mw},
})
agent.name = "err_bmr"
- iter := agent.Run(context.Background(), &AgentInput{
+ iter := agent.Run(t.Context(), &AgentInput{
Messages: []Message{schema.UserMessage("test")},
})
var lastErr error
@@ -234,7 +234,7 @@ func TestMiddleware_AfterModelRewriteError(t *testing.T) {
Model: model, Middlewares: []ReActMiddleware{mw},
})
agent.name = "err_amr"
- iter := agent.Run(context.Background(), &AgentInput{
+ iter := agent.Run(t.Context(), &AgentInput{
Messages: []Message{schema.UserMessage("test")},
})
var lastErr error
@@ -263,7 +263,7 @@ func TestMiddleware_AfterAgentError(t *testing.T) {
Model: model, Middlewares: []ReActMiddleware{mw},
})
agent.name = "err_aa"
- iter := agent.Run(context.Background(), &AgentInput{
+ iter := agent.Run(t.Context(), &AgentInput{
Messages: []Message{schema.UserMessage("test")},
})
var lastErr error
@@ -292,7 +292,7 @@ func TestMiddleware_WrapModelReturnsError(t *testing.T) {
Model: model, Middlewares: []ReActMiddleware{mw},
})
agent.name = "err_wm"
- iter := agent.Run(context.Background(), &AgentInput{
+ iter := agent.Run(t.Context(), &AgentInput{
Messages: []Message{schema.UserMessage("test")},
})
var lastErr error
diff --git a/internal/harness/core/evals/evals_test.go b/internal/harness/core/evals/evals_test.go
index 8ab48101b6..72c8572a86 100644
--- a/internal/harness/core/evals/evals_test.go
+++ b/internal/harness/core/evals/evals_test.go
@@ -80,7 +80,7 @@ func (m *mockT) Fatal(args ...any) {
// TestFinalTextContains verifies the FinalTextContains scorer.
func TestFinalTextContains(t *testing.T) {
scorer := FinalTextContains("hello")
- err := scorer(context.Background(), &EvalResult{
+ err := scorer(t.Context(), &EvalResult{
Messages: []*schema.Message{
{Role: schema.RoleAssistant, Content: "Hello, World!"},
},
@@ -90,7 +90,7 @@ func TestFinalTextContains(t *testing.T) {
}
// Should fail.
- err = scorer(context.Background(), &EvalResult{
+ err = scorer(t.Context(), &EvalResult{
Messages: []*schema.Message{
{Role: schema.RoleAssistant, Content: "Goodbye"},
},
@@ -103,7 +103,7 @@ func TestFinalTextContains(t *testing.T) {
// TestFinalTextExcludes verifies the FinalTextExcludes scorer.
func TestFinalTextExcludes(t *testing.T) {
scorer := FinalTextExcludes("forbidden")
- err := scorer(context.Background(), &EvalResult{
+ err := scorer(t.Context(), &EvalResult{
Messages: []*schema.Message{
{Role: schema.RoleAssistant, Content: "clean output"},
},
@@ -112,7 +112,7 @@ func TestFinalTextExcludes(t *testing.T) {
t.Errorf("expected pass, got: %v", err)
}
- err = scorer(context.Background(), &EvalResult{
+ err = scorer(t.Context(), &EvalResult{
Messages: []*schema.Message{
{Role: schema.RoleAssistant, Content: "forbidden content"},
},
@@ -125,7 +125,7 @@ func TestFinalTextExcludes(t *testing.T) {
// TestToolCalled verifies the ToolCalled scorer.
func TestToolCalled(t *testing.T) {
scorer := ToolCalled("web_search")
- err := scorer(context.Background(), &EvalResult{
+ err := scorer(t.Context(), &EvalResult{
Messages: []*schema.Message{
{Role: schema.RoleAssistant, ToolCalls: []schema.ToolCall{
{Function: schema.ToolCallFunction{Name: "read_file"}},
@@ -139,7 +139,7 @@ func TestToolCalled(t *testing.T) {
t.Errorf("expected pass, got: %v", err)
}
- err = scorer(context.Background(), &EvalResult{
+ err = scorer(t.Context(), &EvalResult{
Messages: []*schema.Message{
{Role: schema.RoleAssistant, Content: "no tools called"},
},
@@ -152,7 +152,7 @@ func TestToolCalled(t *testing.T) {
// TestSteps verifies the Steps scorer.
func TestSteps(t *testing.T) {
scorer := Steps(3)
- err := scorer(context.Background(), &EvalResult{
+ err := scorer(t.Context(), &EvalResult{
Messages: []*schema.Message{
{Role: schema.RoleAssistant},
{Role: schema.RoleTool},
@@ -165,7 +165,7 @@ func TestSteps(t *testing.T) {
t.Errorf("expected pass, got: %v", err)
}
- err = scorer(context.Background(), &EvalResult{
+ err = scorer(t.Context(), &EvalResult{
Messages: []*schema.Message{
{Role: schema.RoleAssistant},
},
@@ -182,13 +182,13 @@ func TestFileContentEquals(t *testing.T) {
os.WriteFile(path, []byte("hello world"), 0644)
scorer := FileContentEquals(path, "hello world")
- err := scorer(context.Background(), &EvalResult{})
+ err := scorer(t.Context(), &EvalResult{})
if err != nil {
t.Errorf("expected pass, got: %v", err)
}
scorer = FileContentEquals(path, "wrong content")
- err = scorer(context.Background(), &EvalResult{})
+ err = scorer(t.Context(), &EvalResult{})
if err == nil {
t.Error("expected failure for content mismatch")
}
@@ -201,13 +201,13 @@ func TestFileContains(t *testing.T) {
os.WriteFile(path, []byte("hello world foo bar"), 0644)
scorer := FileContains(path, "foo")
- err := scorer(context.Background(), &EvalResult{})
+ err := scorer(t.Context(), &EvalResult{})
if err != nil {
t.Errorf("expected pass, got: %v", err)
}
scorer = FileContains(path, "notfound")
- err = scorer(context.Background(), &EvalResult{})
+ err = scorer(t.Context(), &EvalResult{})
if err == nil {
t.Error("expected failure for missing content")
}
@@ -216,12 +216,12 @@ func TestFileContains(t *testing.T) {
// TestAgentError verifies the AgentError scorer.
func TestAgentError(t *testing.T) {
scorer := AgentError()
- err := scorer(context.Background(), &EvalResult{Err: nil})
+ err := scorer(t.Context(), &EvalResult{Err: nil})
if err != nil {
t.Errorf("expected pass for no error, got: %v", err)
}
- err = scorer(context.Background(), &EvalResult{Err: core.ErrCancelTimeout})
+ err = scorer(t.Context(), &EvalResult{Err: core.ErrCancelTimeout})
if err == nil {
t.Error("expected failure when error present")
}
@@ -230,20 +230,20 @@ func TestAgentError(t *testing.T) {
// TestAgentErrorContains verifies the AgentErrorContains scorer.
func TestAgentErrorContains(t *testing.T) {
scorer := AgentErrorContains("cancel")
- err := scorer(context.Background(), &EvalResult{
+ err := scorer(t.Context(), &EvalResult{
Err: core.ErrCancelTimeout,
})
if err != nil {
t.Errorf("expected pass, got: %v", err)
}
- err = scorer(context.Background(), &EvalResult{Err: nil})
+ err = scorer(t.Context(), &EvalResult{Err: nil})
if err == nil {
t.Error("expected failure when no error expected")
}
// Should fail for non-matching substring.
- err = scorer(context.Background(), &EvalResult{Err: core.ErrExecutionEnded})
+ err = scorer(t.Context(), &EvalResult{Err: core.ErrExecutionEnded})
if err == nil {
t.Error("expected failure for non-matching substring")
}
@@ -321,7 +321,7 @@ func TestRun_MultipleCases(t *testing.T) {
Model: model,
}).WithName("multi_eval")
- report := Run(context.Background(), &EvalConfig{
+ report := Run(t.Context(), &EvalConfig{
Model: model,
Agent: agent,
Cases: []EvalCase{
@@ -341,7 +341,7 @@ func TestRun_MultipleCases(t *testing.T) {
// TestRun_Parallel verifies parallel execution with independent per-case agents.
func TestRun_Parallel(t *testing.T) {
- report := Run(context.Background(), &EvalConfig{
+ report := Run(t.Context(), &EvalConfig{
MaxConcurrency: 4,
Cases: []EvalCase{
{
diff --git a/internal/harness/core/failover_test.go b/internal/harness/core/failover_test.go
index dc0f6b071d..ad386a4d53 100644
--- a/internal/harness/core/failover_test.go
+++ b/internal/harness/core/failover_test.go
@@ -19,7 +19,7 @@ func TestWithModelFailover_SingleModel(t *testing.T) {
}
// Verify it still works (delegates to underlying model)
model.addResp("ok")
- ctx := context.Background()
+ ctx := t.Context()
msgs := []Message{schema.UserMessage("hi")}
resp, err := wrapped.Generate(ctx, msgs)
if err != nil {
@@ -38,7 +38,7 @@ func TestWithModelFailover_PrimarySucceeds(t *testing.T) {
fallback.addResp("from fallback")
wrapped := WithModelFailover(primary, fallback)
- ctx := context.Background()
+ ctx := t.Context()
msgs := []Message{schema.UserMessage("hi")}
resp, err := wrapped.Generate(ctx, msgs)
@@ -56,7 +56,7 @@ func TestWithModelFailover_FallsBack(t *testing.T) {
fallback.addResp("fallback result")
wrapped := WithModelFailover(primary, fallback)
- ctx := context.Background()
+ ctx := t.Context()
msgs := []Message{schema.UserMessage("failover test")}
resp, err := wrapped.Generate(ctx, msgs)
@@ -73,7 +73,7 @@ func TestWithModelFailover_AllFail(t *testing.T) {
secondary := &alwaysFailModel{}
wrapped := WithModelFailover(primary, secondary)
- ctx := context.Background()
+ ctx := t.Context()
_, err := wrapped.Generate(ctx, []Message{schema.UserMessage("")})
if err == nil {
t.Error("expected error when all models fail")
@@ -110,7 +110,7 @@ func TestFailover_WithShouldFailoverCallback(t *testing.T) {
},
}
model := newFailoverModel([]Model[*schema.Message]{primary, secondary}, cfg)
- resp, err := model.Generate(context.Background(), []*schema.Message{{Content: "hi"}})
+ resp, err := model.Generate(t.Context(), []*schema.Message{{Content: "hi"}})
if err != nil {
t.Fatalf("Generate: %v", err)
}
@@ -134,7 +134,7 @@ func TestFailover_ShouldFailoverSkipsSecondary(t *testing.T) {
model := newFailoverModel([]Model[*schema.Message]{primary, secondary}, cfg)
// Primary fails, shouldFailover returns false, so we expect an error, not fallback
- _, err := model.Generate(context.Background(), []*schema.Message{{Content: "hi"}})
+ _, err := model.Generate(t.Context(), []*schema.Message{{Content: "hi"}})
if err == nil {
t.Error("expected error since ShouldFailover returns false")
}
diff --git a/internal/harness/core/fault_injection_test.go b/internal/harness/core/fault_injection_test.go
index 4db54cfdb0..589382743f 100644
--- a/internal/harness/core/fault_injection_test.go
+++ b/internal/harness/core/fault_injection_test.go
@@ -55,7 +55,7 @@ func TestFault_LLMRetryThenSuccess(t *testing.T) {
cfg := &ModelRetryConfig{MaxRetries: 3}
wrapped := WithModelRetry(inner, cfg)
- ctx := context.Background()
+ ctx := t.Context()
resp, err := wrapped.Generate(ctx, []Message{schema.UserMessage("hi")})
if err != nil {
t.Fatalf("expected success after retry: %v", err)
@@ -78,7 +78,7 @@ func TestFault_LLMRetryExhausted(t *testing.T) {
cfg := &ModelRetryConfig{MaxRetries: 3}
wrapped := WithModelRetry(inner, cfg)
- ctx := context.Background()
+ ctx := t.Context()
_, err := wrapped.Generate(ctx, []Message{schema.UserMessage("hi")})
if err == nil {
t.Fatal("expected error after retries exhausted")
@@ -99,7 +99,7 @@ func TestFault_LLMNoRetryOnSuccess(t *testing.T) {
cfg := &ModelRetryConfig{MaxRetries: 5}
wrapped := WithModelRetry(inner, cfg)
- ctx := context.Background()
+ ctx := t.Context()
resp, err := wrapped.Generate(ctx, []Message{schema.UserMessage("hi")})
if err != nil {
t.Fatalf("unexpected error: %v", err)
@@ -125,7 +125,7 @@ func TestFault_ToolAllFail(t *testing.T) {
Tools: []Tool{&alwaysFailTool{}},
}).WithName("fault_agent")
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{
Messages: []Message{schema.UserMessage("analyze this")},
})
@@ -159,7 +159,7 @@ func TestFault_ReActToolErrorDoesNotCrash(t *testing.T) {
Tools: []Tool{&alwaysFailTool{}},
}).WithName("crash_test")
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{
Messages: []Message{schema.UserMessage("trigger")},
})
@@ -211,7 +211,7 @@ func TestFault_ReActAgent_ModelError(t *testing.T) {
Model: model,
}).WithName("recovery_agent")
- ctx := context.Background()
+ ctx := t.Context()
iter := agent.Run(ctx, &AgentInput{
Messages: []Message{schema.UserMessage("do something")},
})
diff --git a/internal/harness/core/graph_integration_test.go b/internal/harness/core/graph_integration_test.go
index 17bd434afc..7ebe2be872 100644
--- a/internal/harness/core/graph_integration_test.go
+++ b/internal/harness/core/graph_integration_test.go
@@ -27,7 +27,7 @@ func TestGraphIntegration_SequentialWorkflow(t *testing.T) {
a1 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m1}).WithName("seq_first")
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2}).WithName("seq_second")
- gwf, err := NewSequentialGraph(context.Background(), &SequentialConfig{
+ gwf, err := NewSequentialGraph(t.Context(), &SequentialConfig{
Name: "seq_graph",
Description: "sequential graph test",
SubAgents: []Agent{a1, a2},
@@ -37,7 +37,7 @@ func TestGraphIntegration_SequentialWorkflow(t *testing.T) {
}
// Invoke and verify no error
- state, err := gwf.Invoke(context.Background(), &AgentInput{
+ state, err := gwf.Invoke(t.Context(), &AgentInput{
Messages: []*schema.Message{schema.UserMessage("run sequential")},
})
if err != nil {
@@ -62,7 +62,7 @@ func TestGraphIntegration_ParallelWorkflow(t *testing.T) {
a1 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m1}).WithName("par_first")
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2}).WithName("par_second")
- gwf, err := NewParallelGraph(context.Background(), &ParallelConfig{
+ gwf, err := NewParallelGraph(t.Context(), &ParallelConfig{
Name: "par_graph",
Description: "parallel graph test",
SubAgents: []Agent{a1, a2},
@@ -71,7 +71,7 @@ func TestGraphIntegration_ParallelWorkflow(t *testing.T) {
t.Fatalf("NewParallelGraph: %v", err)
}
- state, err := gwf.Invoke(context.Background(), &AgentInput{
+ state, err := gwf.Invoke(t.Context(), &AgentInput{
Messages: []*schema.Message{schema.UserMessage("run parallel")},
})
if err != nil {
@@ -97,7 +97,7 @@ func TestGraphIntegration_LoopWorkflow(t *testing.T) {
Tools: []Tool{&mockTool{name: "mock_tool", desc: "mock"}},
}).WithName("loop_body")
- gwf, err := NewLoopGraph(context.Background(), &LoopConfig{
+ gwf, err := NewLoopGraph(t.Context(), &LoopConfig{
Name: "loop_graph",
Description: "loop graph test",
SubAgents: []Agent{body},
@@ -107,7 +107,7 @@ func TestGraphIntegration_LoopWorkflow(t *testing.T) {
t.Fatalf("NewLoopGraph: %v", err)
}
- state, err := gwf.Invoke(context.Background(), &AgentInput{
+ state, err := gwf.Invoke(t.Context(), &AgentInput{
Messages: []*schema.Message{schema.UserMessage("run loop")},
})
if err != nil {
@@ -132,7 +132,8 @@ func TestGraphIntegration_SequentialGraphWithInterrupt(t *testing.T) {
a1 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m1}).WithName("interrupt_first")
a2 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m2}).WithName("interrupt_second")
- gwf, err := NewSequentialGraph(context.Background(), &SequentialConfig{
+ ctx := t.Context()
+ gwf, err := NewSequentialGraph(ctx, &SequentialConfig{
Name: "seq_interrupt",
Description: "sequential graph with interrupt",
SubAgents: []Agent{a1, a2},
@@ -141,7 +142,6 @@ func TestGraphIntegration_SequentialGraphWithInterrupt(t *testing.T) {
t.Fatalf("NewSequentialGraph: %v", err)
}
- ctx := context.Background()
_, err = gwf.Invoke(ctx, &AgentInput{
Messages: []*schema.Message{schema.UserMessage("test interrupt")},
})
@@ -163,7 +163,7 @@ func TestGraphIntegration_StreamingWorkflow(t *testing.T) {
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: m}).WithName("stream_agent")
- gwf, err := NewSequentialGraph(context.Background(), &SequentialConfig{
+ gwf, err := NewSequentialGraph(t.Context(), &SequentialConfig{
Name: "stream_graph",
Description: "streaming graph test",
SubAgents: []Agent{agent},
@@ -172,7 +172,7 @@ func TestGraphIntegration_StreamingWorkflow(t *testing.T) {
t.Fatalf("NewSequentialGraph: %v", err)
}
- ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+ ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second)
defer cancel()
outCh, errCh := gwf.Stream(ctx, &AgentInput{
@@ -188,7 +188,7 @@ loop:
break loop
}
events++
- case err := <-errCh:
+ case err = <-errCh:
if err != nil {
t.Logf("stream err: %v", err)
}
@@ -233,7 +233,7 @@ func TestGraphIntegration_ReActWithCheckpointResume(t *testing.T) {
t.Fatalf("NewReActGraph: %v", err)
}
- ctx := context.Background()
+ ctx := t.Context()
config := &types.RunnableConfig{ThreadID: "react-graph-001"}
// Phase 1: Invoke — should interrupt before execute_tools
@@ -270,7 +270,7 @@ func TestGraphIntegration_SequentialGraphCancel(t *testing.T) {
a1 := NewReActAgent(&ReActConfig[*schema.Message]{Model: m1}).WithName("cancel_first")
- gwf, err := NewSequentialGraph(context.Background(), &SequentialConfig{
+ gwf, err := NewSequentialGraph(t.Context(), &SequentialConfig{
Name: "cancel_graph",
Description: "sequential graph cancel test",
SubAgents: []Agent{a1},
@@ -279,7 +279,7 @@ func TestGraphIntegration_SequentialGraphCancel(t *testing.T) {
t.Fatalf("NewSequentialGraph: %v", err)
}
- ctx, cancel := context.WithCancel(context.Background())
+ ctx, cancel := context.WithCancel(t.Context())
cancel() // cancel immediately
_, err = gwf.Invoke(ctx, &AgentInput{
@@ -297,7 +297,7 @@ func TestGraphIntegration_WorkflowGraphCompile(t *testing.T) {
m.addResp("compile test")
agent := NewReActAgent(&ReActConfig[*schema.Message]{Model: m}).WithName("compile_test")
- gwf, err := NewSequentialGraph(context.Background(), &SequentialConfig{
+ gwf, err := NewSequentialGraph(t.Context(), &SequentialConfig{
Name: "compile_graph",
SubAgents: []Agent{agent},
}, nil)