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 lance
import "testing"
func TestParseIdentifier(t *testing.T) {
cases := []struct {
name string
encoded string
delimiter string
want []string
wantErr bool
}{
{name: "root is the delimiter", encoded: "$", delimiter: "$"},
{name: "empty is the root", encoded: "", delimiter: "$"},
{name: "bucket", encoded: "analytics", delimiter: "$", want: []string{"analytics"}},
{name: "namespace", encoded: "analytics$sales", delimiter: "$", want: []string{"analytics", "sales"}},
{name: "table", encoded: "analytics$sales$orders", delimiter: "$", want: []string{"analytics", "sales", "orders"}},
{name: "custom delimiter", encoded: "a.b.c", delimiter: ".", want: []string{"a", "b", "c"}},
{name: "empty part is rejected", encoded: "a$$b", delimiter: "$", wantErr: true},
{name: "trailing delimiter is rejected", encoded: "a$", delimiter: "$", wantErr: true},
}
for _, c := range cases {
t.Run(c.name, func(t *testing.T) {
got, err := parseIdentifier(c.encoded, c.delimiter)
if c.wantErr {
if err == nil {
t.Fatalf("parseIdentifier(%q) error = nil, want an error", c.encoded)
}
return
}
if err != nil {
t.Fatalf("parseIdentifier(%q) error = %v", c.encoded, err)
}
if len(got) != len(c.want) {
t.Fatalf("parseIdentifier(%q) = %v, want %v", c.encoded, got, c.want)
}
for i := range got {
if got[i] != c.want[i] {
t.Fatalf("parseIdentifier(%q) = %v, want %v", c.encoded, got, c.want)
}
}
})
}
}
func TestIdentifierNamespace(t *testing.T) {
bucket, ns := identifier(nil).namespace()
if bucket != "" || len(ns) != 0 {
t.Fatalf("root namespace() = %q %v, want empty", bucket, ns)
}
bucket, ns = identifier{"analytics"}.namespace()
if bucket != "analytics" || len(ns) != 0 {
t.Fatalf("bucket namespace() = %q %v", bucket, ns)
}
bucket, ns = identifier{"analytics", "sales", "eu"}.namespace()
if bucket != "analytics" || len(ns) != 2 || ns[0] != "sales" || ns[1] != "eu" {
t.Fatalf("nested namespace() = %q %v", bucket, ns)
}
}
// A table always needs a bucket, a namespace and a name: storage has no
// unnamespaced tables, so a two-part identifier is a client error rather than a
// table at the top of a bucket.
func TestIdentifierTable(t *testing.T) {
if _, _, _, err := (identifier{"analytics", "orders"}).table(); err == nil {
t.Fatal("table() on a two-part identifier error = nil, want an error")
}
bucket, ns, name, err := identifier{"analytics", "sales", "eu", "orders"}.table()
if err != nil {
t.Fatalf("table() error = %v", err)
}
if bucket != "analytics" || name != "orders" || len(ns) != 2 || ns[0] != "sales" || ns[1] != "eu" {
t.Fatalf("table() = %q %v %q", bucket, ns, name)
}
}
func TestIdentifierMatchesBody(t *testing.T) {
id := identifier{"a", "b", "c"}
if !id.matchesBody(nil) {
t.Fatal("an absent body identifier must defer to the route")
}
if !id.matchesBody([]string{"a", "b", "c"}) {
t.Fatal("an equal body identifier must match")
}
if id.matchesBody([]string{"a", "b"}) {
t.Fatal("a shorter body identifier must not match")
}
if id.matchesBody([]string{"a", "b", "d"}) {
t.Fatal("a different body identifier must not match")
}
}
func TestIdentifierString(t *testing.T) {
if got := identifier(nil).String("$"); got != "$" {
t.Fatalf("root String() = %q, want %q", got, "$")
}
if got := (identifier{"a", "b"}).String("$"); got != "a$b" {
t.Fatalf("String() = %q, want %q", got, "a$b")
}
}