Files
knowledge-governance/internal/jobs/worker_test.go
T
zheromiku dcdc8d1ddd feat: 知识治理平台(含已验证发布/回滚契约)
全栈知识治理平台首次入库(P1-P10 + 发布链路模拟验证闭环):

- 治理核心:源目录/变更集/人工审核/发布批次/发布执行(fail-closed 闸口)
- 测试通道:WeKnora 测试 KB 上传/轮询/验收;poll 完成时写入
  parser_generation/index_generation,修复 manual/seed 路径发布闸口永久拦截
- 发布适配器 v071(本地 source=测试角色 / 云端 target=生产角色 模拟验证通过):
  * ES 导出/导入 mapping 自适应(.keyword 子字段、可选 tenant_id)
  * OSS locator 支持嵌套 scheme;chunks.seq_id 由目标序列分配
  * bundle 归档同身份重试原子替换;verifier 按 bundle chunk_type 计数
  * 回滚 job payload 支持 prior_execution_id(strict 解码)
- 三通道发布+回滚演练实测:publish 4/4 verified,检索命中,
  rollback 4/4 rolled_back,目标端 PG is_enabled=false、ES is_enabled=false
- 前端 A·Data-console 风格全站统一,120 用例通过
- 门禁:go vet / go test 全包通过,gofmt 干净
2026-09-30 10:54:06 +08:00

296 lines
8.6 KiB
Go

package jobs
import (
"context"
"errors"
"slices"
"testing"
"time"
)
func TestWorkerRunOnceCompletesHandledJob(t *testing.T) {
now := time.Date(2026, time.September, 3, 9, 0, 0, 0, time.UTC)
queue := &recordingQueue{claimJob: &Job{ID: "job-1", Type: "demo", State: StateRunning, LeaseOwner: "worker-1"}}
called := false
worker, err := NewWorker(WorkerConfig{
Queue: queue,
WorkerID: "worker-1",
LeaseDuration: 30 * time.Second,
Now: func() time.Time { return now },
Handlers: map[string]Handler{
"demo": func(context.Context, Job) error {
called = true
return nil
},
},
})
if err != nil {
t.Fatalf("NewWorker() error = %v", err)
}
claimed, err := worker.RunOnce(context.Background())
if err != nil {
t.Fatalf("RunOnce() error = %v", err)
}
if !claimed {
t.Fatal("RunOnce() claimed = false, want true")
}
if !called {
t.Fatal("handler was not called")
}
if queue.completedID != "job-1" {
t.Fatalf("completed job = %q, want job-1", queue.completedID)
}
if queue.completedOwner != "worker-1" {
t.Fatalf("completion owner = %q, want worker-1", queue.completedOwner)
}
}
func TestWorkerCompletesAtHandlerFinishRatherThanClaimTime(t *testing.T) {
claimedAt := time.Date(2026, time.September, 3, 9, 0, 0, 0, time.UTC)
completedAt := claimedAt.Add(7*time.Minute + 13*time.Second)
times := []time.Time{claimedAt, completedAt}
queue := &recordingQueue{claimJob: &Job{ID: "job-duration", Type: "demo", State: StateRunning, LeaseOwner: "worker-1"}}
worker, err := NewWorker(WorkerConfig{
Queue: queue, WorkerID: "worker-1", LeaseDuration: 30 * time.Second,
Now: func() time.Time { value := times[0]; times = times[1:]; return value },
Handlers: map[string]Handler{"demo": func(context.Context, Job) error { return nil }},
})
if err != nil {
t.Fatal(err)
}
if _, err := worker.RunOnce(context.Background()); err != nil {
t.Fatal(err)
}
if !queue.completedAt.Equal(completedAt) {
t.Fatalf("completed at = %s, want handler finish %s", queue.completedAt, completedAt)
}
}
func TestWorkerRunOnceSchedulesFailedJobForRetry(t *testing.T) {
now := time.Date(2026, time.September, 3, 9, 0, 0, 0, time.UTC)
wantErr := errors.New("temporary failure")
queue := &recordingQueue{claimJob: &Job{ID: "job-2", Type: "demo", State: StateRunning, LeaseOwner: "worker-1"}}
worker, err := NewWorker(WorkerConfig{
Queue: queue,
WorkerID: "worker-1",
LeaseDuration: 30 * time.Second,
RetryDelay: 5 * time.Second,
Now: func() time.Time { return now },
Handlers: map[string]Handler{
"demo": func(context.Context, Job) error { return wantErr },
},
})
if err != nil {
t.Fatalf("NewWorker() error = %v", err)
}
claimed, err := worker.RunOnce(context.Background())
if !errors.Is(err, wantErr) {
t.Fatalf("RunOnce() error = %v, want %v", err, wantErr)
}
if !claimed {
t.Fatal("RunOnce() claimed = false, want true")
}
if queue.failedID != "job-2" {
t.Fatalf("failed job = %q, want job-2", queue.failedID)
}
if queue.failedMessage != wantErr.Error() {
t.Fatalf("failure message = %q, want %q", queue.failedMessage, wantErr.Error())
}
if want := now.Add(5 * time.Second); !queue.retryAt.Equal(want) {
t.Fatalf("retry at = %s, want %s", queue.retryAt, want)
}
}
func TestWorkerRunOnceParksPermanentFailureImmediately(t *testing.T) {
now := time.Date(2026, time.September, 3, 9, 0, 0, 0, time.UTC)
queue := &recordingQueue{claimJob: &Job{ID: "job-perm", Type: "demo", State: StateRunning, LeaseOwner: "worker-1"}}
worker, err := NewWorker(WorkerConfig{
Queue: queue,
WorkerID: "worker-1",
LeaseDuration: 30 * time.Second,
RetryDelay: 5 * time.Second,
Now: func() time.Time { return now },
Handlers: map[string]Handler{
"demo": func(context.Context, Job) error { return Permanent("artifact_invalid", errors.New("bad file")) },
},
})
if err != nil {
t.Fatalf("NewWorker() error = %v", err)
}
claimed, err := worker.RunOnce(context.Background())
if err == nil || !claimed {
t.Fatalf("RunOnce() = (%v, %v), want claimed error", claimed, err)
}
if queue.terminalID != "job-perm" {
t.Fatalf("terminal job = %q, want job-perm (FailTerminal path)", queue.terminalID)
}
if queue.terminalCode != "artifact_invalid" {
t.Fatalf("terminal code = %q, want artifact_invalid", queue.terminalCode)
}
if !queue.terminalAt.Equal(now) {
t.Fatalf("terminal at = %s, want %s", queue.terminalAt, now)
}
if queue.retryAt.IsZero() == false && queue.failedID != "" {
t.Fatal("permanent failure must not schedule a retry")
}
}
func TestPermanentFallsBackToCodeOnOrdinaryFail(t *testing.T) {
// A non-permanent error keeps the retry path with an empty code so the
// database preserves the previous classification.
if terminal, code := Terminal(errors.New("boom")); terminal || code != ErrCodeHandlerFallback {
t.Fatalf("Terminal(plain) = (%v, %q)", terminal, code)
}
}
func TestWorkerRunOnceHeartbeatsWhileHandlerRuns(t *testing.T) {
heartbeat := make(chan struct{}, 1)
queue := &recordingQueue{
claimJob: &Job{ID: "job-3", Type: "demo", State: StateRunning, LeaseOwner: "worker-1"},
heartbeat: heartbeat,
}
worker, err := NewWorker(WorkerConfig{
Queue: queue,
WorkerID: "worker-1",
LeaseDuration: 30 * time.Second,
HeartbeatInterval: 5 * time.Millisecond,
Handlers: map[string]Handler{
"demo": func(ctx context.Context, _ Job) error {
select {
case <-heartbeat:
return nil
case <-ctx.Done():
return ctx.Err()
case <-time.After(time.Second):
return errors.New("heartbeat was not sent")
}
},
},
})
if err != nil {
t.Fatalf("NewWorker() error = %v", err)
}
claimed, err := worker.RunOnce(context.Background())
if err != nil {
t.Fatalf("RunOnce() error = %v", err)
}
if !claimed {
t.Fatal("RunOnce() claimed = false, want true")
}
if queue.heartbeatCount == 0 {
t.Fatal("heartbeat count = 0, want at least 1")
}
}
func TestWorkerRunStopsWhenContextIsCanceled(t *testing.T) {
queue := &recordingQueue{}
worker, err := NewWorker(WorkerConfig{
Queue: queue,
WorkerID: "worker-1",
LeaseDuration: 30 * time.Second,
})
if err != nil {
t.Fatalf("NewWorker() error = %v", err)
}
ctx, cancel := context.WithCancel(context.Background())
done := make(chan error, 1)
go func() { done <- worker.Run(ctx, 5*time.Millisecond) }()
cancel()
select {
case err := <-done:
if err != nil {
t.Fatalf("Run() error = %v", err)
}
case <-time.After(time.Second):
t.Fatal("Run() did not stop after cancellation")
}
}
func TestWorkerClaimsOnlyRegisteredHandlerTypes(t *testing.T) {
queue := &recordingQueue{}
worker, err := NewWorker(WorkerConfig{
Queue: queue,
WorkerID: "worker-1",
LeaseDuration: 30 * time.Second,
Handlers: map[string]Handler{
"source.scan": func(context.Context, Job) error { return nil },
"test.ingest": func(context.Context, Job) error { return nil },
},
})
if err != nil {
t.Fatalf("NewWorker() error = %v", err)
}
if _, err := worker.RunOnce(context.Background()); err != nil {
t.Fatalf("RunOnce() error = %v", err)
}
want := []string{"source.scan", "test.ingest"}
if !slices.Equal(queue.claimTypes, want) {
t.Fatalf("claim types = %#v, want %#v", queue.claimTypes, want)
}
}
type recordingQueue struct {
claimJob *Job
claimTypes []string
completedID string
completedOwner string
completedAt time.Time
failedID string
failedMessage string
failedCode string
retryAt time.Time
terminalID string
terminalCode string
terminalAt time.Time
heartbeat chan struct{}
heartbeatCount int
}
func (q *recordingQueue) Claim(_ context.Context, _ string, types []string, _ time.Time, _ time.Duration) (*Job, error) {
q.claimTypes = append([]string(nil), types...)
return q.claimJob, nil
}
func (q *recordingQueue) Complete(_ context.Context, id, owner string, now time.Time) error {
q.completedID = id
q.completedOwner = owner
q.completedAt = now
return nil
}
func (q *recordingQueue) Fail(_ context.Context, id, _ string, message, code string, _, retryAt time.Time) error {
q.failedID = id
q.failedMessage = message
q.failedCode = code
q.retryAt = retryAt
return nil
}
func (q *recordingQueue) FailTerminal(_ context.Context, id, _, message, code string, now time.Time) error {
q.terminalID = id
q.failedMessage = message
q.terminalCode = code
q.terminalAt = now
return nil
}
func (q *recordingQueue) Heartbeat(context.Context, string, string, time.Time, time.Duration) error {
q.heartbeatCount++
if q.heartbeat != nil {
select {
case q.heartbeat <- struct{}{}:
default:
}
}
return nil
}