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 干净
380 lines
14 KiB
Go
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)
|
|
}
|
|
}
|