Files
Enterprise-Knowledge-Base/internal/router/router_presigned_test.go
T
wizardchen ae4ec0cf06 fix(im): make presigned URL flow diagnosable end-to-end
When IM image rendering breaks, operators previously had no log line to
correlate against the IM platform's fetch attempt. Add observability
hooks on both ends and unblock HEAD probes so common IM previews work
at all.

- log rewriteStorageURLs success/failure/no-op with the full signed URL
  (operators can copy it from logs and verify public reachability)
- log presigned handler 4xx with client_ip + UA + tenant_id + file_path
  so failures correlate against IM platform fetch logs; use the request
  context so trace IDs are preserved
- accept HEAD on /api/v1/files/presigned: IM platforms (Feishu, Slack
  etc.) probe with HEAD before GET when rendering image previews, and a
  401 there is enough to break the inline image even when the GET would
  have succeeded
- add Admin-only GET /api/v1/files/presigned-preview that returns the
  exact URL an IM channel would embed for the calling tenant, for
  self-service verification without sending a real IM message
- clarify APP_EXTERNAL_URL and MINIO_ENDPOINT public-reachability rules
  in .env.example; misconfigured endpoints are the most common cause of
  "image broken in IM" reports
2026-05-28 08:03:57 +08:00

220 lines
7.2 KiB
Go

package router
import (
"context"
"net/http"
"net/http/httptest"
"net/url"
"os"
"path/filepath"
"strconv"
"strings"
"testing"
"time"
"github.com/gin-gonic/gin"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
secutils "github.com/Tencent/WeKnora/internal/utils"
)
// stubTenantService is a minimal stub of interfaces.TenantService that only
// implements GetTenantByID. Every other method panics — those code paths
// must not be exercised by presigned routes; the panic surfaces test bugs
// instead of silently returning zero values.
type stubTenantService struct {
get func(ctx context.Context, id uint64) (*types.Tenant, error)
}
var _ interfaces.TenantService = (*stubTenantService)(nil)
func (s *stubTenantService) GetTenantByID(ctx context.Context, id uint64) (*types.Tenant, error) {
if s.get == nil {
return nil, os.ErrNotExist
}
return s.get(ctx, id)
}
func (s *stubTenantService) CreateTenant(context.Context, *types.Tenant) (*types.Tenant, error) {
panic("unexpected")
}
func (s *stubTenantService) GetTenantsByIDs(context.Context, []uint64) (map[uint64]*types.Tenant, error) {
panic("unexpected")
}
func (s *stubTenantService) ListTenants(context.Context) ([]*types.Tenant, error) {
panic("unexpected")
}
func (s *stubTenantService) UpdateTenant(context.Context, *types.Tenant) (*types.Tenant, error) {
panic("unexpected")
}
func (s *stubTenantService) DeleteTenant(context.Context, uint64) error { panic("unexpected") }
func (s *stubTenantService) UpdateAPIKey(context.Context, uint64) (string, error) {
panic("unexpected")
}
func (s *stubTenantService) ExtractTenantIDFromAPIKey(string) (uint64, error) { panic("unexpected") }
func (s *stubTenantService) ListAllTenants(context.Context) ([]*types.Tenant, error) {
panic("unexpected")
}
func (s *stubTenantService) BulkSetStorageQuota(context.Context, int64) (int64, error) {
panic("unexpected")
}
func (s *stubTenantService) SearchTenants(context.Context, string, uint64, int, int) ([]*types.Tenant, int64, error) {
panic("unexpected")
}
func (s *stubTenantService) GetTenantByIDForUser(context.Context, uint64, string) (*types.Tenant, error) {
panic("unexpected")
}
func (s *stubTenantService) GetWeKnoraCloudCredentials(context.Context) *types.WeKnoraCloudCredentials {
panic("unexpected")
}
// setupPresignedTestServer wires presignedFileHandler with a real local file
// service rooted at a temp dir, returning the engine, baseDir, and the
// presigned URL generator helper.
func setupPresignedTestServer(t *testing.T) (engine *gin.Engine, baseDir string, signURL func(filePath string, tenantID uint64, ttl time.Duration) string) {
t.Helper()
gin.SetMode(gin.TestMode)
t.Setenv("SYSTEM_AES_KEY", "weknora-test-aes-key-32bytes!!!")
baseDir = t.TempDir()
tenant := &types.Tenant{
ID: 1,
StorageEngineConfig: &types.StorageEngineConfig{
DefaultProvider: "local",
Local: &types.LocalEngineConfig{},
},
}
stubTS := &stubTenantService{
get: func(_ context.Context, id uint64) (*types.Tenant, error) {
if id == tenant.ID {
return tenant, nil
}
return nil, os.ErrNotExist
},
}
engine = gin.New()
handler := presignedFileHandler(stubTS, baseDir)
engine.GET("/api/v1/files/presigned", handler)
engine.HEAD("/api/v1/files/presigned", handler)
signURL = func(filePath string, tenantID uint64, ttl time.Duration) string {
signed, err := secutils.SignFileURL("https://weknora.example.com", filePath, tenantID, ttl)
if err != nil {
t.Fatalf("SignFileURL: %v", err)
}
// Re-parse so we only keep the query part: the test server is on
// a different host than the canonical signing baseURL.
u, _ := url.Parse(signed)
return "/api/v1/files/presigned?" + u.RawQuery
}
return engine, baseDir, signURL
}
// writeTestFile creates baseDir/<relPath> with the given content and returns
// the matching `local://<relPath>` storage path.
func writeTestFile(t *testing.T, baseDir, relPath, content string) string {
t.Helper()
full := filepath.Join(baseDir, filepath.FromSlash(relPath))
if err := os.MkdirAll(filepath.Dir(full), 0o755); err != nil {
t.Fatalf("MkdirAll: %v", err)
}
if err := os.WriteFile(full, []byte(content), 0o644); err != nil {
t.Fatalf("WriteFile: %v", err)
}
return "local://" + relPath
}
func TestPresignedFile_HEAD_Returns200WithoutBody(t *testing.T) {
engine, baseDir, signURL := setupPresignedTestServer(t)
storagePath := writeTestFile(t, baseDir, "1/img.png", "PNG-BYTES")
req := httptest.NewRequest(http.MethodHead, signURL(storagePath, 1, time.Hour), nil)
w := httptest.NewRecorder()
engine.ServeHTTP(w, req)
if got, want := w.Code, http.StatusOK; got != want {
t.Fatalf("status = %d, want %d (body=%q)", got, want, w.Body.String())
}
if got := w.Header().Get("Content-Type"); got != "image/png" {
t.Fatalf("Content-Type = %q, want image/png", got)
}
// HEAD must not stream the body — protects backing storage from a
// full read on every IM preview probe.
if w.Body.Len() != 0 {
t.Fatalf("HEAD response body should be empty, got %d bytes", w.Body.Len())
}
}
func TestPresignedFile_GET_ReturnsContent(t *testing.T) {
engine, baseDir, signURL := setupPresignedTestServer(t)
storagePath := writeTestFile(t, baseDir, "1/img.png", "PNG-BYTES")
req := httptest.NewRequest(http.MethodGet, signURL(storagePath, 1, time.Hour), nil)
w := httptest.NewRecorder()
engine.ServeHTTP(w, req)
if got, want := w.Code, http.StatusOK; got != want {
t.Fatalf("status = %d, want %d", got, want)
}
if got := w.Body.String(); got != "PNG-BYTES" {
t.Fatalf("body = %q, want %q", got, "PNG-BYTES")
}
}
func TestPresignedFile_InvalidSig_403(t *testing.T) {
engine, _, _ := setupPresignedTestServer(t)
// Hand-craft a URL with a tampered signature.
q := url.Values{}
q.Set("file_path", "local://1/img.png")
q.Set("tenant_id", "1")
q.Set("expires", strconv.FormatInt(time.Now().Add(time.Hour).Unix(), 10))
q.Set("sig", "deadbeefdeadbeef")
for _, method := range []string{http.MethodGet, http.MethodHead} {
t.Run(method, func(t *testing.T) {
req := httptest.NewRequest(method, "/api/v1/files/presigned?"+q.Encode(), nil)
w := httptest.NewRecorder()
engine.ServeHTTP(w, req)
if got, want := w.Code, http.StatusForbidden; got != want {
t.Fatalf("status = %d, want %d", got, want)
}
})
}
}
func TestPresignedFile_MissingParams_400(t *testing.T) {
engine, _, _ := setupPresignedTestServer(t)
req := httptest.NewRequest(http.MethodGet, "/api/v1/files/presigned?file_path=local%3A%2F%2F1%2Fimg.png", nil)
w := httptest.NewRecorder()
engine.ServeHTTP(w, req)
if got, want := w.Code, http.StatusBadRequest; got != want {
t.Fatalf("status = %d, want %d", got, want)
}
if !strings.Contains(w.Body.String(), "missing required parameters") {
t.Fatalf("body = %q, want missing-params error", w.Body.String())
}
}
func TestPresignedFile_MissingFile_404(t *testing.T) {
engine, _, signURL := setupPresignedTestServer(t)
// A legitimately signed URL pointing at a file that does not exist.
req := httptest.NewRequest(http.MethodGet, signURL("local://1/nope.png", 1, time.Hour), nil)
w := httptest.NewRecorder()
engine.ServeHTTP(w, req)
if got, want := w.Code, http.StatusNotFound; got != want {
t.Fatalf("status = %d, want %d", got, want)
}
}