SeaweedFS is a distributed storage system for object storage (S3), file systems, Iceberg table buckets, and Lance vector buckets, designed to handle billions of files with O(1) disk access and effortless horizontal scaling.
Go blob-storagecloud-drivedistributed-file-systemdistributed-storageerasure-codingfusehadoop-hdfshdfskuberneteslancelancedbobject-storageposixs3s3-storageseaweedfstiered-file-systemvector-search
package dash
import (
"path"
"strings"
"testing"
"github.com/seaweedfs/seaweedfs/weed/util"
)
// TestGenerateBreadcrumbs tests the actual breadcrumb generation function
// from the production code with various path scenarios
func TestGenerateBreadcrumbs(t *testing.T) {
s := &AdminServer{}
tests := []struct {
name string
path string
expected []BreadcrumbItem
}{
{
name: "root path",
path: "/",
expected: []BreadcrumbItem{
{Name: "Root", Path: "/"},
},
},
{
name: "simple path",
path: "/folder",
expected: []BreadcrumbItem{
{Name: "Root", Path: "/"},
{Name: "folder", Path: "/folder"},
},
},
{
name: "nested path",
path: "/folder/subfolder",
expected: []BreadcrumbItem{
{Name: "Root", Path: "/"},
{Name: "folder", Path: "/folder"},
{Name: "subfolder", Path: "/folder/subfolder"},
},
},
{
name: "bucket path",
path: "/buckets/mybucket",
expected: []BreadcrumbItem{
{Name: "Root", Path: "/"},
{Name: "Object Store Buckets", Path: "/buckets"},
{Name: "📦 mybucket", Path: "/buckets/mybucket"},
},
},
{
name: "bucket nested path",
path: "/buckets/mybucket/folder",
expected: []BreadcrumbItem{
{Name: "Root", Path: "/"},
{Name: "Object Store Buckets", Path: "/buckets"},
{Name: "📦 mybucket", Path: "/buckets/mybucket"},
{Name: "folder", Path: "/buckets/mybucket/folder"},
},
},
{
name: "path with trailing slash",
path: "/folder/",
expected: []BreadcrumbItem{
{Name: "Root", Path: "/"},
{Name: "folder", Path: "/folder"},
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Call the actual production function
result := s.generateBreadcrumbs(tt.path)
if len(result) != len(tt.expected) {
t.Errorf("expected %d breadcrumbs, got %d", len(tt.expected), len(result))
return
}
for i, crumb := range result {
if crumb.Name != tt.expected[i].Name {
t.Errorf("breadcrumb %d: expected name %q, got %q", i, tt.expected[i].Name, crumb.Name)
}
if crumb.Path != tt.expected[i].Path {
t.Errorf("breadcrumb %d: expected path %q, got %q", i, tt.expected[i].Path, crumb.Path)
}
}
})
}
}
// TestS3ObjectURL verifies path-style S3 URL construction with per-segment
// percent-encoding
func TestS3ObjectURL(t *testing.T) {
tests := []struct {
name string
endpoint string
fullPath string
expected string
}{
{
name: "simple object",
endpoint: "https://s3.example.com",
fullPath: "/buckets/public-images/homarr/example.png",
expected: "https://s3.example.com/public-images/homarr/example.png",
},
{
name: "space hash and question mark in key",
endpoint: "https://s3.example.com",
fullPath: "/buckets/b/a b#c?d.txt",
expected: "https://s3.example.com/b/a%20b%23c%3Fd.txt",
},
{
name: "non-ascii key",
endpoint: "https://s3.example.com",
fullPath: "/buckets/b/图片.png",
expected: "https://s3.example.com/b/%E5%9B%BE%E7%89%87.png",
},
{
name: "percent in key",
endpoint: "https://s3.example.com",
fullPath: "/buckets/b/100%.txt",
expected: "https://s3.example.com/b/100%25.txt",
},
{
name: "trailing slash on endpoint",
endpoint: "https://s3.example.com/",
fullPath: "/buckets/b/k",
expected: "https://s3.example.com/b/k",
},
{
name: "not a bucket path",
endpoint: "https://s3.example.com",
fullPath: "/topics/t/k",
expected: "",
},
{
name: "empty endpoint",
endpoint: "",
fullPath: "/buckets/b/k",
expected: "",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
if got := S3ObjectURL(tt.endpoint, tt.fullPath); got != tt.expected {
t.Errorf("S3ObjectURL(%q, %q) = %q, expected %q", tt.endpoint, tt.fullPath, got, tt.expected)
}
})
}
}
// TestNormalizeS3PublicEndpoint verifies unusable configured endpoints are
// dropped rather than producing broken links
func TestNormalizeS3PublicEndpoint(t *testing.T) {
tests := []struct {
endpoint string
expected string
}{
{"https://s3.example.com", "https://s3.example.com"},
{"http://10.0.0.1:8333/", "http://10.0.0.1:8333"},
{"http://[::1]:8333", "http://[::1]:8333"},
{"https://proxy.example.com/s3", "https://proxy.example.com/s3"},
{"", ""},
{"/", ""},
{"s3.example.com", ""},
{"ftp://s3.example.com", ""},
{"https://", ""},
{"https://s3.example.com?x=1", ""},
{"https://s3.example.com/?", ""},
{"https://s3.example.com#frag", ""},
{"https://s3.example.com/#", ""},
{"http://user:[email protected]", ""},
}
for _, tt := range tests {
if got := normalizeS3PublicEndpoint(tt.endpoint); got != tt.expected {
t.Errorf("normalizeS3PublicEndpoint(%q) = %q, expected %q", tt.endpoint, got, tt.expected)
}
}
}
// TestPathHandlingWithForwardSlashes verifies that the production code
// correctly handles paths with forward slashes (not OS-specific backslashes)
func TestPathHandlingWithForwardSlashes(t *testing.T) {
tests := []struct {
name string
path string
hasSlash bool
}{
{
name: "root",
path: "/",
hasSlash: true,
},
{
name: "single level",
path: "/test",
hasSlash: true,
},
{
name: "multiple levels",
path: "/a/b/c",
hasSlash: true,
},
{
name: "bucket path",
path: "/buckets/mybucket/file",
hasSlash: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Verify no backslashes appear in paths (which would be wrong on Windows)
if strings.Contains(tt.path, "\\") {
t.Errorf("path contains backslash: %q", tt.path)
}
// Verify forward slashes are used
if tt.hasSlash && !strings.Contains(tt.path, "/") {
t.Errorf("path should contain forward slash: %q", tt.path)
}
})
}
}
// TestParentPathCalculationLogic verifies that parent path calculation
// uses path.Dir semantics (forward slashes), not filepath.Dir (OS-specific)
func TestParentPathCalculationLogic(t *testing.T) {
tests := []struct {
name string
currentDir string
expected string
}{
{
name: "root path",
currentDir: "/",
expected: "/",
},
{
name: "single level",
currentDir: "/folder",
expected: "/",
},
{
name: "two levels",
currentDir: "/folder/subfolder",
expected: "/folder",
},
{
name: "deep nesting",
currentDir: "/a/b/c/d",
expected: "/a/b/c",
},
{
name: "bucket root",
currentDir: "/buckets",
expected: "/",
},
{
name: "bucket directory",
currentDir: "/buckets/mybucket",
expected: "/buckets",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Verify using path.Dir (the correct approach for URLs)
// This demonstrates the expected behavior
parentPath := "/"
if tt.currentDir != "/" {
// path.Dir always uses forward slashes
parentPath = path.Dir(tt.currentDir)
if parentPath == "." {
parentPath = "/"
}
}
if parentPath != tt.expected {
t.Errorf("expected parent %q, got %q for %q", tt.expected, parentPath, tt.currentDir)
}
// Verify no backslashes in the result
if strings.Contains(parentPath, "\\") {
t.Errorf("parent path contains backslash: %q", parentPath)
}
})
}
}
// TestFileExtensionHandlingLogic verifies that file extensions are correctly
// identified using path semantics (always forward slashes)
func TestFileExtensionHandlingLogic(t *testing.T) {
tests := []struct {
filename string
expected string
}{
{"file.txt", ".txt"},
{"file.log", ".log"},
{"archive.tar.gz", ".gz"},
{"image.jpg", ".jpg"},
{"document.pdf", ".pdf"},
{"data.json", ".json"},
{"noextension", ""},
{".hidden", ".hidden"},
{"file.TXT", ".txt"},
{"file.JPG", ".jpg"},
}
for _, tt := range tests {
t.Run(tt.filename, func(t *testing.T) {
// Verify using path.Ext + strings.ToLower (the correct approach)
ext := strings.ToLower(path.Ext(tt.filename))
if ext != tt.expected {
t.Errorf("expected extension %q for %q, got %q", tt.expected, tt.filename, ext)
}
})
}
}
// TestBucketPathDetectionLogic verifies bucket path detection logic
func TestBucketPathDetectionLogic(t *testing.T) {
tests := []struct {
name string
path string
isBucket bool
expectedName string
}{
{
name: "root is not a bucket path",
path: "/",
isBucket: false,
expectedName: "",
},
{
name: "buckets root",
path: "/buckets/",
isBucket: true,
expectedName: "",
},
{
name: "single bucket",
path: "/buckets/mybucket",
isBucket: true,
expectedName: "mybucket",
},
{
name: "bucket with nested path",
path: "/buckets/mybucket/folder/file",
isBucket: true,
expectedName: "mybucket",
},
{
name: "non-bucket path",
path: "/data/folder",
isBucket: false,
expectedName: "",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Verify the bucket path detection logic
isBucketPath := false
bucketName := ""
if strings.HasPrefix(tt.path, "/buckets/") {
isBucketPath = true
pathParts := strings.Split(strings.Trim(tt.path, "/"), "/")
if len(pathParts) >= 2 {
bucketName = pathParts[1]
}
}
if isBucketPath != tt.isBucket {
t.Errorf("expected isBucketPath=%v, got %v for path %q", tt.isBucket, isBucketPath, tt.path)
}
if bucketName != tt.expectedName {
t.Errorf("expected bucket name %q, got %q for path %q", tt.expectedName, bucketName, tt.path)
}
})
}
}
// TestPathJoinHandlesEdgeCases verifies that path.Join handles edge cases
// properly for URL path construction (unlike filepath.Join which is OS-specific)
func TestPathJoinHandlesEdgeCases(t *testing.T) {
tests := []struct {
testName string
dir string
filename string
expected string
}{
{
testName: "root directory",
dir: "/",
filename: "file.txt",
expected: "/file.txt",
},
{
testName: "simple directory",
dir: "/folder",
filename: "file.txt",
expected: "/folder/file.txt",
},
{
testName: "nested directory",
dir: "/a/b/c",
filename: "file.txt",
expected: "/a/b/c/file.txt",
},
{
testName: "handles trailing slash",
dir: "/folder/",
filename: "file.txt",
expected: "/folder/file.txt",
},
{
testName: "handles empty name",
dir: "/folder",
filename: "",
expected: "/folder",
},
}
for _, tt := range tests {
t.Run(tt.testName, func(t *testing.T) {
// Verify path.Join behavior for URL paths
result := path.Join(tt.dir, tt.filename)
if result != tt.expected {
t.Errorf("path.Join(%q, %q) = %q, expected %q", tt.dir, tt.filename, result, tt.expected)
}
// Verify no backslashes in the result
if strings.Contains(result, "\\") {
t.Errorf("result contains backslash: %q", result)
}
})
}
}
// TestWindowsPathNormalizationBehavior validates that Windows-style paths
// are correctly converted to forward slashes for URL compatibility.
// This test verifies the actual util.CleanWindowsPath() function used in
// the ShowFileBrowser handler.
func TestWindowsPathNormalizationBehavior(t *testing.T) {
tests := []struct {
name string
windowsPath string
expectedNormPath string
}{
{
name: "backslash separator",
windowsPath: "\\folder\\subfolder",
expectedNormPath: "/folder/subfolder",
},
{
name: "mixed separators",
windowsPath: "/folder\\subfolder/file",
expectedNormPath: "/folder/subfolder/file",
},
{
name: "already normalized",
windowsPath: "/folder/file",
expectedNormPath: "/folder/file",
},
{
name: "simple backslash path",
windowsPath: "\\data",
expectedNormPath: "/data",
},
{
name: "deep nested path",
windowsPath: "\\a\\b\\c\\d",
expectedNormPath: "/a/b/c/d",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Test the actual production function
normalized := util.CleanWindowsPath(tt.windowsPath)
if normalized != tt.expectedNormPath {
t.Errorf("CleanWindowsPath(%q): expected %q, got %q",
tt.windowsPath, tt.expectedNormPath, normalized)
}
})
}
}
// TestBreadcrumbPathFormatting validates that breadcrumb paths always
// use forward slashes and maintain proper URL format
func TestBreadcrumbPathFormatting(t *testing.T) {
s := &AdminServer{}
testPaths := []string{
"/",
"/folder",
"/folder/subfolder",
"/buckets/mybucket",
"/buckets/mybucket/data",
}
for _, testPath := range testPaths {
t.Run("breadcrumbs_for_"+testPath, func(t *testing.T) {
breadcrumbs := s.generateBreadcrumbs(testPath)
// Verify all breadcrumb paths use forward slashes
for i, crumb := range breadcrumbs {
if strings.Contains(crumb.Path, "\\") {
t.Errorf("breadcrumb %d has backslash in path: %q", i, crumb.Path)
}
// Verify paths start with / (except when empty)
if crumb.Path != "" && !strings.HasPrefix(crumb.Path, "/") {
t.Errorf("breadcrumb %d path should start with /: %q", i, crumb.Path)
}
}
})
}
}
// TestDirectoryNavigation validates the complete navigation flow
// for various path scenarios
func TestDirectoryNavigation(t *testing.T) {
s := &AdminServer{}
tests := []struct {
name string
currentPath string
expectedParent string
expectedCrumbs int
}{
{
name: "navigate from root",
currentPath: "/",
expectedParent: "/",
expectedCrumbs: 1,
},
{
name: "navigate from single folder",
currentPath: "/documents",
expectedParent: "/",
expectedCrumbs: 2,
},
{
name: "navigate from nested folder",
currentPath: "/documents/projects/current",
expectedParent: "/documents/projects",
expectedCrumbs: 4,
},
{
name: "navigate bucket contents",
currentPath: "/buckets/data/files",
expectedParent: "/buckets/data",
expectedCrumbs: 4,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Verify breadcrumbs are generated correctly
breadcrumbs := s.generateBreadcrumbs(tt.currentPath)
if len(breadcrumbs) != tt.expectedCrumbs {
t.Errorf("expected %d breadcrumbs, got %d", tt.expectedCrumbs, len(breadcrumbs))
}
// Verify parent path calculation
expectedParent := "/"
if tt.currentPath != "/" {
expectedParent = path.Dir(tt.currentPath)
if expectedParent == "." {
expectedParent = "/"
}
}
if expectedParent != tt.expectedParent {
t.Errorf("expected parent %q, got %q", tt.expectedParent, expectedParent)
}
// Verify all paths use forward slashes
for i, crumb := range breadcrumbs {
if strings.Contains(crumb.Path, "\\") {
t.Errorf("breadcrumb %d contains backslash: %q", i, crumb.Path)
}
}
})
}
}