Files
knowledge-governance/internal/platform/weknora/client_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

380 lines
14 KiB
Go

package weknora
import (
"bytes"
"context"
"encoding/json"
"errors"
"io"
"net/http"
"net/http/httptest"
"strings"
"sync/atomic"
"testing"
"time"
)
func TestClientGetKnowledgeUsesPinnedOriginAndAPIKey(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodGet || r.URL.Path != "/api/v1/knowledge/knowledge-1" {
t.Fatalf("request = %s %s", r.Method, r.URL.Path)
}
if got := r.Header.Get("X-API-Key"); got != "test-api-key" {
t.Fatalf("X-API-Key = %q", got)
}
if got := r.Header.Get("Authorization"); got != "" {
t.Fatalf("Authorization must be absent, got %q", got)
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"success":true,"data":{"id":"knowledge-1","knowledge_base_id":"kb-1","parse_status":"processing","file_hash":"abc","updated_at":"2026-09-04T01:00:00Z","metadata":{"source":"legacy","process_overrides":{"parser":"mineru"}}}}`))
}))
defer server.Close()
client, err := NewClient(ClientConfig{
BaseURL: server.URL,
APIKey: "test-api-key",
Timeout: time.Second,
})
if err != nil {
t.Fatalf("NewClient() error = %v", err)
}
knowledge, err := client.GetKnowledge(context.Background(), "knowledge-1")
if err != nil {
t.Fatalf("GetKnowledge() error = %v", err)
}
if knowledge.ID != "knowledge-1" || knowledge.KnowledgeBaseID != "kb-1" || knowledge.ParseStatus != "processing" || knowledge.FileHash != "abc" {
t.Fatalf("knowledge = %#v", knowledge)
}
if knowledge.Metadata["source"] != "legacy" {
t.Fatalf("metadata = %#v", knowledge.Metadata)
}
}
func TestNewClientRequiresHTTPSExceptForLoopbackTests(t *testing.T) {
for _, rawURL := range []string{
"http://example.com",
"ftp://example.com",
"https://user:password@example.com",
"https://example.com?redirect=other",
} {
if _, err := NewClient(ClientConfig{BaseURL: rawURL, APIKey: "test-api-key", Timeout: time.Second}); err == nil {
t.Fatalf("NewClient(%q) error = nil", rawURL)
}
}
if _, err := NewClient(ClientConfig{BaseURL: "https://example.com", APIKey: "test-api-key", Timeout: time.Second}); err != nil {
t.Fatalf("NewClient(https) error = %v", err)
}
if _, err := NewClient(ClientConfig{BaseURL: "http://127.0.0.1:8080", APIKey: "key", Timeout: time.Second}); err != nil {
t.Fatalf("NewClient(loopback) error = %v", err)
}
}
func TestNewClientAllowsExplicitSingleLabelDockerHTTPOnly(t *testing.T) {
if _, err := NewClient(ClientConfig{
BaseURL: "http://app:8080",
APIKey: "key",
Timeout: time.Second,
AllowDockerHTTP: true,
}); err != nil {
t.Fatalf("NewClient(explicit docker HTTP) error = %v", err)
}
for _, rawURL := range []string{
"http://app:8080",
"http://host.docker.internal:8080",
"http://10.0.0.5:8080",
"http://example.com:8080",
} {
allow := rawURL != "http://app:8080"
_, err := NewClient(ClientConfig{
BaseURL: rawURL,
APIKey: "key",
Timeout: time.Second,
AllowDockerHTTP: allow,
})
if err == nil {
t.Fatalf("NewClient(%q) error = nil, want insecure HTTP rejected", rawURL)
}
}
}
func TestClientUploadFileStreamsExpectedMultipartFields(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodPost || r.URL.Path != "/api/v1/knowledge-bases/kb-1/knowledge/file" {
t.Fatalf("request = %s %s", r.Method, r.URL.Path)
}
if r.ContentLength != -1 {
t.Fatalf("ContentLength = %d, want streaming request", r.ContentLength)
}
if err := r.ParseMultipartForm(1 << 20); err != nil {
t.Fatalf("ParseMultipartForm() error = %v", err)
}
file, header, err := r.FormFile("file")
if err != nil {
t.Fatalf("FormFile() error = %v", err)
}
defer file.Close()
body, err := io.ReadAll(file)
if err != nil {
t.Fatal(err)
}
if header.Filename != "safe.md" || string(body) != "document body" {
t.Fatalf("upload = filename %q body %q", header.Filename, body)
}
if r.FormValue("metadata") != `{"content_sha256":"abc","publication_id":"publication-1"}` {
t.Fatalf("metadata = %q", r.FormValue("metadata"))
}
if r.FormValue("fileName") != "safe.md" || r.FormValue("channel") != "governance" {
t.Fatalf("fileName/channel = %q/%q", r.FormValue("fileName"), r.FormValue("channel"))
}
if r.FormValue("process_config") != `{"graph_enabled":false}` {
t.Fatalf("process_config = %q", r.FormValue("process_config"))
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"success":true,"data":{"id":"knowledge-new","knowledge_base_id":"kb-1","parse_status":"pending"}}`))
}))
defer server.Close()
client, err := NewClient(ClientConfig{BaseURL: server.URL, APIKey: "test-api-key", Timeout: time.Second})
if err != nil {
t.Fatal(err)
}
knowledge, err := client.UploadFile(context.Background(), UploadRequest{
KnowledgeBaseID: "kb-1",
FileName: "safe.md",
Content: bytes.NewBufferString("document body"),
Metadata: map[string]string{
"publication_id": "publication-1",
"content_sha256": "abc",
},
Channel: "governance",
ProcessConfig: map[string]any{"graph_enabled": false},
})
if err != nil {
t.Fatalf("UploadFile() error = %v", err)
}
if knowledge.ID != "knowledge-new" || knowledge.KnowledgeBaseID != "kb-1" || knowledge.ParseStatus != "pending" {
t.Fatalf("knowledge = %#v", knowledge)
}
}
func TestClientUploadFileReturnsTypedConflictWithoutClaimingSuccess(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if err := r.ParseMultipartForm(1 << 20); err != nil {
t.Fatal(err)
}
w.Header().Set("Content-Type", "application/json")
w.WriteHeader(http.StatusConflict)
_, _ = w.Write([]byte(`{"success":false,"data":{"id":"candidate-1","knowledge_base_id":"kb-1"},"code":"duplicate"}`))
}))
defer server.Close()
client, err := NewClient(ClientConfig{BaseURL: server.URL, APIKey: "test-api-key", Timeout: time.Second})
if err != nil {
t.Fatal(err)
}
knowledge, err := client.UploadFile(context.Background(), UploadRequest{
KnowledgeBaseID: "kb-1",
FileName: "safe.md",
Content: bytes.NewBufferString("document body"),
})
if !errors.Is(err, ErrConflict) {
t.Fatalf("UploadFile() error = %v, want ErrConflict", err)
}
if knowledge.ID != "candidate-1" {
t.Fatalf("candidate knowledge = %#v", knowledge)
}
}
func TestClientDeleteKnowledgeUsesPinnedOriginAndAPIKey(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Method != http.MethodDelete || r.URL.Path != "/api/v1/knowledge/knowledge-1" {
t.Fatalf("request = %s %s", r.Method, r.URL.Path)
}
if got := r.Header.Get("X-API-Key"); got != "test-api-key" {
t.Fatalf("X-API-Key = %q", got)
}
w.Header().Set("Content-Type", "application/json")
_, _ = w.Write([]byte(`{"success":true}`))
}))
defer server.Close()
client, err := NewClient(ClientConfig{BaseURL: server.URL, APIKey: "test-api-key", Timeout: time.Second})
if err != nil {
t.Fatal(err)
}
if err := client.DeleteKnowledge(context.Background(), "knowledge-1"); err != nil {
t.Fatalf("DeleteKnowledge() error = %v", err)
}
if err := client.DeleteKnowledge(context.Background(), "../knowledge-1"); err == nil {
t.Fatal("DeleteKnowledge() accepted an unsafe knowledge ID")
}
}
func TestClientProvidesPaginatedInventoryChunkAndScopedSearchReads(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("Content-Type", "application/json")
switch r.URL.Path {
case "/api/v1/knowledge-bases/kb-1/knowledge":
if r.Method != http.MethodGet || r.URL.Query().Get("page") != "2" || r.URL.Query().Get("page_size") != "50" {
t.Fatalf("knowledge list request = %s %s", r.Method, r.URL.RawQuery)
}
_, _ = w.Write([]byte(`{"success":true,"data":[{"id":"knowledge-1","knowledge_base_id":"kb-1","metadata":{"publication_id":"publication-1"}}],"total":51,"page":2,"page_size":50}`))
case "/api/v1/chunks/knowledge-1":
if r.Method != http.MethodGet || r.URL.Query().Get("page") != "1" || r.URL.Query().Get("page_size") != "100" {
t.Fatalf("chunk list request = %s %s", r.Method, r.URL.RawQuery)
}
types := r.URL.Query()["chunk_type"]
if len(types) != 2 || types[0] != "text" || types[1] != "image_ocr" {
t.Fatalf("chunk types = %#v", types)
}
_, _ = w.Write([]byte(`{"success":true,"data":[{"id":"chunk-1","knowledge_id":"knowledge-1","chunk_type":"text"}],"total":1,"page":1,"page_size":100}`))
case "/api/v1/knowledge-search":
if r.Method != http.MethodPost {
t.Fatalf("search method = %s", r.Method)
}
var request SearchRequest
if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
t.Fatal(err)
}
if request.Query != "unique question" || len(request.KnowledgeIDs) != 1 || request.KnowledgeIDs[0] != "knowledge-1" {
t.Fatalf("search request = %#v", request)
}
_, _ = w.Write([]byte(`{"success":true,"data":[{"id":"chunk-1","knowledge_id":"knowledge-1","score":0.02,"match_type":2,"chunk_type":"text"}]}`))
default:
t.Fatalf("unexpected path %s", r.URL.Path)
}
}))
defer server.Close()
client, err := NewClient(ClientConfig{BaseURL: server.URL, APIKey: "test-api-key", Timeout: time.Second})
if err != nil {
t.Fatal(err)
}
items, total, err := client.ListKnowledge(context.Background(), "kb-1", 2, 50)
if err != nil || total != 51 || len(items) != 1 || items[0].Metadata["publication_id"] != "publication-1" {
t.Fatalf("ListKnowledge() = %#v, %d, %v", items, total, err)
}
chunks, total, err := client.ListChunks(context.Background(), "knowledge-1", 1, 100, []string{"text", "image_ocr"})
if err != nil || total != 1 || len(chunks) != 1 || chunks[0].KnowledgeID != "knowledge-1" {
t.Fatalf("ListChunks() = %#v, %d, %v", chunks, total, err)
}
results, err := client.SearchKnowledge(context.Background(), SearchRequest{Query: "unique question", KnowledgeIDs: []string{"knowledge-1"}})
if err != nil || len(results) != 1 || results[0].KnowledgeID != "knowledge-1" || results[0].Score != 0.02 {
t.Fatalf("SearchKnowledge() = %#v, %v", results, err)
}
}
func TestClientRejectsRedirectWithoutForwardingAPIKey(t *testing.T) {
var targetHits atomic.Int32
target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
targetHits.Add(1)
if r.Header.Get("X-API-Key") != "" {
t.Error("redirect target received X-API-Key")
}
w.WriteHeader(http.StatusOK)
}))
defer target.Close()
origin := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
http.Redirect(w, r, target.URL, http.StatusFound)
}))
defer origin.Close()
client, err := NewClient(ClientConfig{BaseURL: origin.URL, APIKey: "test-api-key", Timeout: time.Second})
if err != nil {
t.Fatal(err)
}
if _, err := client.GetKnowledge(context.Background(), "knowledge-1"); err == nil {
t.Fatal("GetKnowledge() error = nil, want redirect rejected")
}
if targetHits.Load() != 0 {
t.Fatalf("redirect target hits = %d", targetHits.Load())
}
}
func TestClientBoundsAndRedactsRemoteResponses(t *testing.T) {
secret := "remote-secret-that-must-not-leak"
tests := []struct {
name string
body string
code int
}{
{name: "error body", code: http.StatusInternalServerError, body: secret},
{name: "malformed body", code: http.StatusOK, body: "{" + secret},
{name: "oversized body", code: http.StatusOK, body: strings.Repeat("x", 65)},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(tt.code)
_, _ = w.Write([]byte(tt.body))
}))
defer server.Close()
client, err := NewClient(ClientConfig{BaseURL: server.URL, APIKey: "test-api-key", Timeout: time.Second, MaxResponseBytes: 64})
if err != nil {
t.Fatal(err)
}
_, err = client.GetKnowledge(context.Background(), "knowledge-1")
if err == nil {
t.Fatal("GetKnowledge() error = nil")
}
if strings.Contains(err.Error(), secret) {
t.Fatalf("error leaked remote body: %v", err)
}
})
}
}
func TestClientClassifiesHTTPFailuresWithoutLeakingBody(t *testing.T) {
tests := []struct {
status int
retryable bool
}{
{status: http.StatusUnauthorized, retryable: false},
{status: http.StatusForbidden, retryable: false},
{status: http.StatusTooManyRequests, retryable: true},
{status: http.StatusInternalServerError, retryable: true},
}
for _, tt := range tests {
t.Run(http.StatusText(tt.status), func(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.WriteHeader(tt.status)
_, _ = w.Write([]byte("sensitive remote detail"))
}))
defer server.Close()
client, err := NewClient(ClientConfig{BaseURL: server.URL, APIKey: "test-api-key", Timeout: time.Second})
if err != nil {
t.Fatal(err)
}
_, err = client.GetKnowledge(context.Background(), "knowledge-1")
var httpErr *HTTPError
if !errors.As(err, &httpErr) || httpErr.StatusCode != tt.status {
t.Fatalf("GetKnowledge() error = %T %v", err, err)
}
if IsRetryable(err) != tt.retryable {
t.Fatalf("IsRetryable() = %v, want %v", IsRetryable(err), tt.retryable)
}
if strings.Contains(err.Error(), "sensitive remote detail") {
t.Fatalf("error leaked remote body: %v", err)
}
})
}
}
func TestClientClassifiesTimeoutAsRetryable(t *testing.T) {
server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
select {
case <-r.Context().Done():
case <-time.After(time.Second):
}
}))
defer server.Close()
client, err := NewClient(ClientConfig{BaseURL: server.URL, APIKey: "test-api-key", Timeout: 10 * time.Millisecond})
if err != nil {
t.Fatal(err)
}
_, err = client.GetKnowledge(context.Background(), "knowledge-1")
if err == nil || !IsRetryable(err) {
t.Fatalf("GetKnowledge() error = %v, want retryable timeout", err)
}
}