WeKnora deployment source with the reviewed wiki identity, summary and recovery fixes

internal/agent/tools/data_analysis_materialize_test.go

@@ -0,0 +1,164 @@
+package tools
+
+import (
+	"bytes"
+	"context"
+	"errors"
+	"io"
+	"mime/multipart"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/Tencent/WeKnora/internal/types"
+)
+
+// fakeFileService implements interfaces.FileService just enough to drive
+// materializeKnowledgeFile. Every method we don't care about simply errors
+// out so accidental usage is loud.
+type fakeFileService struct {
+	readers map[string]func() (io.ReadCloser, error)
+}
+
+func (f *fakeFileService) CheckConnectivity(ctx context.Context) error { return nil }
+func (f *fakeFileService) SaveFile(ctx context.Context, _ *multipart.FileHeader, _ uint64, _ string) (string, error) {
+	return "", errors.New("not implemented in fake")
+}
+func (f *fakeFileService) SaveBytes(ctx context.Context, _ []byte, _ uint64, _ string, _ bool) (string, error) {
+	return "", errors.New("not implemented in fake")
+}
+func (f *fakeFileService) GetFile(ctx context.Context, filePath string) (io.ReadCloser, error) {
+	fn, ok := f.readers[filePath]
+	if !ok {
+		return nil, errors.New("unknown path: " + filePath)
+	}
+	return fn()
+}
+func (f *fakeFileService) GetFileURL(ctx context.Context, filePath string) (string, error) {
+	// Return a URL that DuckDB would NOT be able to open on its own; the
+	// production code must *not* pass this through to DuckDB.
+	return "local://" + strings.TrimPrefix(filePath, "/"), nil
+}
+func (f *fakeFileService) DeleteFile(ctx context.Context, _ string) error { return nil }
+func (f *fakeFileService) CopyFile(ctx context.Context, _ string, _ uint64, _ string) (string, error) {
+	return "", nil
+}
+
+// TestMaterializeKnowledgeFile_HandlesLocalScheme is the regression guard
+// for the dev-mode failure where DuckDB was handed a local:// URL it can't
+// resolve. The tool must pull bytes via FileService.GetFile and hand DuckDB
+// a concrete filesystem path with the right extension.
+func TestMaterializeKnowledgeFile_HandlesLocalScheme(t *testing.T) {
+	payload := []byte("col1,col2\n1,2\n3,4\n")
+
+	fs := &fakeFileService{
+		readers: map[string]func() (io.ReadCloser, error){
+			"tenants/42/data.csv": func() (io.ReadCloser, error) {
+				return io.NopCloser(bytes.NewReader(payload)), nil
+			},
+		},
+	}
+
+	tool := &DataAnalysisTool{
+		fileService: fs,
+		sessionID:   "test-materialize",
+	}
+
+	k := &types.Knowledge{
+		ID:       "k-abc",
+		FileType: "csv",
+		FilePath: "tenants/42/data.csv",
+	}
+
+	path, cleanup, err := tool.materializeKnowledgeFile(context.Background(), k)
+	if err != nil {
+		t.Fatalf("materialize: %v", err)
+	}
+	t.Cleanup(cleanup)
+
+	// Path must be a real filesystem path (no provider scheme) so DuckDB
+	// can st_read / read_xlsx / read_csv_auto it directly.
+	if strings.Contains(path, "://") {
+		t.Fatalf("expected bare filesystem path, got scheme URL: %q", path)
+	}
+	if filepath.Ext(path) != ".csv" {
+		t.Errorf("expected .csv suffix preserved for DuckDB format detection, got %q", path)
+	}
+
+	// File must actually exist and have the exact bytes we fed in.
+	got, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read temp file: %v", err)
+	}
+	if !bytes.Equal(got, payload) {
+		t.Errorf("payload roundtrip mismatch: got %q, want %q", got, payload)
+	}
+
+	// cleanup() must remove the temp file without error.
+	cleanup()
+	if _, err := os.Stat(path); !os.IsNotExist(err) {
+		t.Errorf("expected temp file to be removed after cleanup, stat err=%v", err)
+	}
+	// Double-cleanup must be safe (test harness may invoke it again).
+	cleanup()
+}
+
+func TestMaterializeKnowledgeFile_PropagatesGetFileError(t *testing.T) {
+	fs := &fakeFileService{
+		readers: map[string]func() (io.ReadCloser, error){
+			"bad/path": func() (io.ReadCloser, error) {
+				return nil, errors.New("boom")
+			},
+		},
+	}
+
+	tool := &DataAnalysisTool{fileService: fs, sessionID: "test-error"}
+
+	_, cleanup, err := tool.materializeKnowledgeFile(
+		context.Background(),
+		&types.Knowledge{ID: "k-err", FileType: "xlsx", FilePath: "bad/path"},
+	)
+	if err == nil {
+		defer cleanup()
+		t.Fatal("expected error from underlying GetFile, got nil")
+	}
+	if !strings.Contains(err.Error(), "boom") {
+		t.Errorf("expected wrapped 'boom' error, got: %v", err)
+	}
+}
+
+func TestMaterializeKnowledgeFile_PreservesExtension(t *testing.T) {
+	cases := []struct {
+		fileType string
+		wantExt  string
+	}{
+		{"xlsx", ".xlsx"},
+		{"XLSX", ".xlsx"}, // normalized lowercase
+		{"csv", ".csv"},
+		{"xls", ".xls"},
+	}
+	for _, c := range cases {
+		t.Run(c.fileType, func(t *testing.T) {
+			fs := &fakeFileService{
+				readers: map[string]func() (io.ReadCloser, error){
+					"p": func() (io.ReadCloser, error) {
+						return io.NopCloser(bytes.NewReader([]byte("x"))), nil
+					},
+				},
+			}
+			tool := &DataAnalysisTool{fileService: fs, sessionID: "ext"}
+			path, cleanup, err := tool.materializeKnowledgeFile(
+				context.Background(),
+				&types.Knowledge{ID: "k", FileType: c.fileType, FilePath: "p"},
+			)
+			if err != nil {
+				t.Fatalf("materialize: %v", err)
+			}
+			defer cleanup()
+			if filepath.Ext(path) != c.wantExt {
+				t.Errorf("fileType=%q: extension mismatch got %q want %q", c.fileType, filepath.Ext(path), c.wantExt)
+			}
+		})
+	}
+}