1c80b07f2c
build / build (push) Successful in 1m59s
Dockerfile 运行阶段补齐 dws_dingtalk_scan(F12),并新增 runtime-scripts 门禁 做脚本依赖闭包正负例;就绪探测每次解析当前端点/绑定/凭据并区分 404、未配置、 不可达(F13);路由写入来源路径与父目录,历史空值仅按同连接同 item 的意图读时 补齐(F14);目标筛选显示短 ID 与当前绑定/历史并提供快捷筛选(F15);刷新终态 移除后台运行、展示失败时间/旧快照/脱敏原因/作业 ID 与重试(F16)。 验证:make verify 17 项全过(identity 本地按设计 skipped);一次性 schema 的 Monitor 目录/路由集成用例通过;8088 部署与真实 UI 验收仍由父会话执行。
139 lines
4.9 KiB
Go
139 lines
4.9 KiB
Go
package readiness
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
// fakeWeKnora answers /health and /api/v1/knowledge-bases/{kb}/knowledge.
|
|
// 404 is how WeKnora says "this knowledge base does not exist" (F13 的旧 env 绑定).
|
|
func fakeWeKnora(t *testing.T, known map[string]int, wantKey string) *httptest.Server {
|
|
t.Helper()
|
|
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
if got := r.Header.Get("X-API-Key"); wantKey != "" && got != wantKey {
|
|
w.WriteHeader(http.StatusUnauthorized)
|
|
return
|
|
}
|
|
switch {
|
|
case r.URL.Path == "/health":
|
|
_, _ = w.Write([]byte(`ok`))
|
|
case strings.HasPrefix(r.URL.Path, "/api/v1/knowledge-bases/"):
|
|
parts := strings.Split(strings.TrimPrefix(r.URL.Path, "/api/v1/knowledge-bases/"), "/")
|
|
total, ok := known[parts[0]]
|
|
if !ok || len(parts) != 2 || parts[1] != "knowledge" {
|
|
w.WriteHeader(http.StatusNotFound)
|
|
return
|
|
}
|
|
_, _ = fmt.Fprintf(w, `{"success":true,"total":%d,"data":[]}`, total)
|
|
default:
|
|
w.WriteHeader(http.StatusNotFound)
|
|
}
|
|
}))
|
|
t.Cleanup(server.Close)
|
|
return server
|
|
}
|
|
|
|
func TestProbeFollowsTheCurrentBindingWithinOneProcess(t *testing.T) {
|
|
oldKB := "1b52c140-2e18-4676-afc5-4c7d8d190a8c"
|
|
currentKB := "0c84a098-d3ed-4b82-a165-e6de9691d6a8"
|
|
server := fakeWeKnora(t, map[string]int{currentKB: 4}, "key-1")
|
|
var mu sync.Mutex
|
|
binding := oldKB
|
|
prober := Prober{
|
|
Timeout: 2 * time.Second,
|
|
Resolve: func(context.Context) (Target, error) {
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
return Target{BaseURL: server.URL, KnowledgeBaseID: binding, APIKey: "key-1"}, nil
|
|
},
|
|
}
|
|
first := prober.Check(context.Background())
|
|
if !errors.Is(first.Err, ErrKnowledgeBaseMissing) {
|
|
t.Fatalf("old binding probe = %v, want ErrKnowledgeBaseMissing", first.Err)
|
|
}
|
|
if !strings.Contains(first.Target, "1b52c140") || strings.Contains(first.Target, oldKB) {
|
|
t.Fatalf("probe target must name the probed KB in short form only: %q", first.Target)
|
|
}
|
|
mu.Lock()
|
|
binding = currentKB
|
|
mu.Unlock()
|
|
second := prober.Check(context.Background())
|
|
if second.Err != nil {
|
|
t.Fatalf("current binding probe = %v, want ready", second.Err)
|
|
}
|
|
if !strings.Contains(second.Target, "0c84a098") {
|
|
t.Fatalf("probe target did not follow the new binding: %q", second.Target)
|
|
}
|
|
}
|
|
|
|
func TestProbeReResolvesEndpointAndCredentialOnEveryCheck(t *testing.T) {
|
|
kb := "0c84a098-d3ed-4b82-a165-e6de9691d6a8"
|
|
denied := fakeWeKnora(t, map[string]int{kb: 4}, "new-key")
|
|
allowed := fakeWeKnora(t, map[string]int{kb: 4}, "new-key")
|
|
var mu sync.Mutex
|
|
endpoint, key := denied.URL, "old-key"
|
|
prober := Prober{
|
|
Timeout: 2 * time.Second,
|
|
Resolve: func(context.Context) (Target, error) {
|
|
mu.Lock()
|
|
defer mu.Unlock()
|
|
return Target{BaseURL: endpoint, KnowledgeBaseID: kb, APIKey: key}, nil
|
|
},
|
|
}
|
|
if err := prober.Check(context.Background()).Err; !errors.Is(err, ErrNoPermission) {
|
|
t.Fatalf("stale credential probe = %v, want ErrNoPermission", err)
|
|
}
|
|
mu.Lock()
|
|
endpoint, key = allowed.URL, "new-key"
|
|
mu.Unlock()
|
|
if err := prober.Check(context.Background()).Err; err != nil {
|
|
t.Fatalf("rotated endpoint/credential probe = %v, want ready", err)
|
|
}
|
|
}
|
|
|
|
func TestProbeDistinguishesMissingConfigurationFromUnreachable(t *testing.T) {
|
|
missing := Prober{Resolve: func(context.Context) (Target, error) {
|
|
return Target{BaseURL: "http://127.0.0.1:1", KnowledgeBaseID: ""}, nil
|
|
}}
|
|
if !errors.Is(missing.Check(context.Background()).Err, ErrNotConfigured) {
|
|
t.Fatalf("blank binding must be ErrNotConfigured, got %v", missing.Check(context.Background()).Err)
|
|
}
|
|
unreachable := Prober{Timeout: 200 * time.Millisecond, Resolve: func(context.Context) (Target, error) {
|
|
return Target{BaseURL: "http://127.0.0.1:1", KnowledgeBaseID: "kb-1", APIKey: "key"}, nil
|
|
}}
|
|
err := unreachable.Check(context.Background()).Err
|
|
if err == nil || errors.Is(err, ErrNotConfigured) || errors.Is(err, ErrKnowledgeBaseMissing) {
|
|
t.Fatalf("connection refused must stay a transport failure, got %v", err)
|
|
}
|
|
}
|
|
|
|
func TestProbeSurfaces404AsMissingKnowledgeBaseNotServiceDown(t *testing.T) {
|
|
server := fakeWeKnora(t, map[string]int{}, "key")
|
|
prober := Prober{Timeout: 2 * time.Second, Resolve: func(context.Context) (Target, error) {
|
|
return Target{BaseURL: server.URL, KnowledgeBaseID: "gone-kb", APIKey: "key"}, nil
|
|
}}
|
|
err := prober.Check(context.Background()).Err
|
|
if !errors.Is(err, ErrKnowledgeBaseMissing) {
|
|
t.Fatalf("404 = %v, want ErrKnowledgeBaseMissing", err)
|
|
}
|
|
if strings.Contains(err.Error(), "key") {
|
|
t.Fatalf("probe error leaked the credential: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestProbeRejectsAnUnusableResolverResult(t *testing.T) {
|
|
prober := Prober{Resolve: func(context.Context) (Target, error) {
|
|
return Target{}, errors.New("settings unavailable")
|
|
}}
|
|
if err := prober.Check(context.Background()).Err; err == nil || errors.Is(err, ErrNotConfigured) {
|
|
t.Fatalf("resolver failure must be reported, got %v", err)
|
|
}
|
|
}
|