dcdc8d1ddd
全栈知识治理平台首次入库(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 干净
296 lines
8.6 KiB
Go
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
|
|
}
|