Files
Enterprise-Knowledge-Base/internal/application/service/knowledge_clone_image_test.go
T
wizardchen ac321a3e81 fix(knowledge): rewrite chunk content image URLs on clone
When cloning knowledge chunks, image_info was deep-copied to new storage
objects but Content still embedded the source markdown image URLs. After
the source knowledge is deleted, those in-content references break while
image_info points at the new copies. Rewrite Content alongside image_info
so both stay consistent.
2026-07-22 12:06:31 +08:00

227 lines
7.9 KiB
Go

package service
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"mime/multipart"
"testing"
"github.com/Tencent/WeKnora/internal/types"
)
// countingFileService is a minimal FileService stub for cloneChunkImageInfo tests.
// CopyFile records each invocation and returns a deterministic destination path
// derived from (knowledgeID, srcPath) so dedup and rewrite behaviour are verifiable.
type countingFileService struct {
copyCalls int
copiedFrom []string
failOnURL string // when non-empty, CopyFile returns an error for this srcPath
deleteCalls int
}
func (c *countingFileService) CheckConnectivity(ctx context.Context) error { return nil }
func (c *countingFileService) SaveFile(ctx context.Context, file *multipart.FileHeader, tenantID uint64, knowledgeID string) (string, error) {
return "", nil
}
func (c *countingFileService) SaveBytes(ctx context.Context, data []byte, tenantID uint64, fileName string, temp bool) (string, error) {
return "", nil
}
func (c *countingFileService) GetFile(ctx context.Context, filePath string) (io.ReadCloser, error) {
return nil, errors.New("not implemented")
}
func (c *countingFileService) GetFileURL(ctx context.Context, filePath string) (string, error) {
return filePath, nil
}
func (c *countingFileService) DeleteFile(ctx context.Context, filePath string) error {
c.deleteCalls++
return nil
}
func (c *countingFileService) CopyFile(ctx context.Context, srcPath string, tenantID uint64, knowledgeID string) (string, error) {
if c.failOnURL != "" && srcPath == c.failOnURL {
return "", fmt.Errorf("simulated copy failure for %s", srcPath)
}
c.copyCalls++
c.copiedFrom = append(c.copiedFrom, srcPath)
return fmt.Sprintf("local://%d/%s/copy-of-%s", tenantID, knowledgeID, srcPath), nil
}
func mustImageInfoJSON(t *testing.T, imgs []types.ImageInfo) string {
t.Helper()
b, err := json.Marshal(imgs)
if err != nil {
t.Fatalf("marshal image_info: %v", err)
}
return string(b)
}
func TestCloneChunkImageInfo_Empty(t *testing.T) {
svc := &countingFileService{}
content, out, copied, err := cloneChunkImageInfo(context.Background(), svc, "some text", "", 1, "kb-1", map[string]string{})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if out != "" || copied != nil {
t.Fatalf("expected empty result, got out=%q copied=%v", out, copied)
}
if content != "some text" {
t.Fatalf("content must pass through unchanged, got %q", content)
}
if svc.copyCalls != 0 {
t.Fatalf("expected 0 copies, got %d", svc.copyCalls)
}
}
func TestCloneChunkImageInfo_RewritesURLAndMatchedOriginal(t *testing.T) {
svc := &countingFileService{}
src := mustImageInfoJSON(t, []types.ImageInfo{
{URL: "local://1/k0/a.png", OriginalURL: "local://1/k0/a.png", Caption: "cap"},
})
_, out, copied, err := cloneChunkImageInfo(context.Background(), svc, "", src, 7, "k-dst", map[string]string{})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if svc.copyCalls != 1 || len(copied) != 1 {
t.Fatalf("expected exactly 1 copy, got calls=%d copied=%v", svc.copyCalls, copied)
}
var got []types.ImageInfo
if err := json.Unmarshal([]byte(out), &got); err != nil {
t.Fatalf("unmarshal out: %v", err)
}
want := "local://7/k-dst/copy-of-local://1/k0/a.png"
if got[0].URL != want {
t.Errorf("URL not rewritten: got %q want %q", got[0].URL, want)
}
// OriginalURL equalled URL -> must also be rewritten to the new object.
if got[0].OriginalURL != want {
t.Errorf("matched OriginalURL not rewritten: got %q want %q", got[0].OriginalURL, want)
}
if got[0].Caption != "cap" {
t.Errorf("Caption mutated: got %q", got[0].Caption)
}
}
func TestCloneChunkImageInfo_RewritesInContentMarkdownURLs(t *testing.T) {
svc := &countingFileService{}
src := mustImageInfoJSON(t, []types.ImageInfo{
{URL: "local://1/k0/a.png", OriginalURL: "local://1/k0/a.png"},
})
content := "See ![diagram](local://1/k0/a.png) here."
newContent, _, _, err := cloneChunkImageInfo(context.Background(), svc, content, src, 7, "k-dst", map[string]string{})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
want := "See ![diagram](local://7/k-dst/copy-of-local://1/k0/a.png) here."
if newContent != want {
t.Errorf("content image URL not rewritten:\n got %q\nwant %q", newContent, want)
}
}
func TestCloneChunkImageInfo_PreservesUnmatchedOriginalURL(t *testing.T) {
svc := &countingFileService{}
src := mustImageInfoJSON(t, []types.ImageInfo{
{URL: "local://1/k0/a.png", OriginalURL: "https://external.example.com/a.png"},
})
_, out, _, err := cloneChunkImageInfo(context.Background(), svc, "", src, 1, "k-dst", map[string]string{})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
var got []types.ImageInfo
if err := json.Unmarshal([]byte(out), &got); err != nil {
t.Fatalf("unmarshal out: %v", err)
}
if got[0].OriginalURL != "https://external.example.com/a.png" {
t.Errorf("external OriginalURL must be preserved, got %q", got[0].OriginalURL)
}
}
func TestCloneChunkImageInfo_DedupsIdenticalURLs(t *testing.T) {
svc := &countingFileService{}
src := mustImageInfoJSON(t, []types.ImageInfo{
{URL: "local://1/k0/same.png"},
{URL: "local://1/k0/same.png"},
{URL: "local://1/k0/other.png"},
})
_, _, copied, err := cloneChunkImageInfo(context.Background(), svc, "", src, 1, "k-dst", map[string]string{})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if svc.copyCalls != 2 {
t.Fatalf("expected 2 unique copies (dedup), got %d", svc.copyCalls)
}
if len(copied) != 2 {
t.Fatalf("expected 2 copied URLs, got %v", copied)
}
}
func TestCloneChunkImageInfo_DedupsAcrossCallsViaSharedCache(t *testing.T) {
svc := &countingFileService{}
cache := map[string]string{}
src := mustImageInfoJSON(t, []types.ImageInfo{{URL: "local://1/k0/shared.png"}})
if _, _, _, err := cloneChunkImageInfo(context.Background(), svc, "", src, 1, "k-dst", cache); err != nil {
t.Fatalf("first call error: %v", err)
}
if _, _, copied, err := cloneChunkImageInfo(context.Background(), svc, "", src, 1, "k-dst", cache); err != nil {
t.Fatalf("second call error: %v", err)
} else if len(copied) != 0 {
t.Fatalf("second call should reuse cache (0 new copies), got %v", copied)
}
if svc.copyCalls != 1 {
t.Fatalf("expected 1 copy total across calls, got %d", svc.copyCalls)
}
}
func TestCloneChunkImageInfo_ParseFailureAbortsClone(t *testing.T) {
svc := &countingFileService{}
_, _, _, err := cloneChunkImageInfo(context.Background(), svc, "", "{not valid json", 1, "k-dst", map[string]string{})
if err == nil {
t.Fatal("expected error on invalid image_info JSON, got nil")
}
if svc.copyCalls != 0 {
t.Fatalf("expected no copies on parse failure, got %d", svc.copyCalls)
}
}
func TestCloneChunkImageInfo_CopyFailureReturnsPartialForCleanup(t *testing.T) {
svc := &countingFileService{failOnURL: "local://1/k0/bad.png"}
src := mustImageInfoJSON(t, []types.ImageInfo{
{URL: "local://1/k0/good.png"},
{URL: "local://1/k0/bad.png"},
})
_, _, copied, err := cloneChunkImageInfo(context.Background(), svc, "", src, 1, "k-dst", map[string]string{})
if err == nil {
t.Fatal("expected error when an image copy fails")
}
// The already-copied "good.png" must be returned so the caller can clean it up.
if len(copied) != 1 {
t.Fatalf("expected 1 already-copied URL for rollback, got %v", copied)
}
}
func TestCloneChunkImageInfo_SkipsEmptyURL(t *testing.T) {
svc := &countingFileService{}
src := mustImageInfoJSON(t, []types.ImageInfo{{URL: "", Caption: "no-image"}})
_, out, copied, err := cloneChunkImageInfo(context.Background(), svc, "", src, 1, "k-dst", map[string]string{})
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if svc.copyCalls != 0 || len(copied) != 0 {
t.Fatalf("empty URL must be skipped, calls=%d copied=%v", svc.copyCalls, copied)
}
var got []types.ImageInfo
if err := json.Unmarshal([]byte(out), &got); err != nil {
t.Fatalf("unmarshal out: %v", err)
}
if got[0].URL != "" {
t.Errorf("empty URL should stay empty, got %q", got[0].URL)
}
}