Files
mtusi2026lab5/internal/platform/s3store/integration_test.go
T

272 lines
9.3 KiB
Go

package s3store_test
import (
"context"
"errors"
"io"
"net"
"net/http"
"strings"
"testing"
"time"
"github.com/minio/minio-go/v7"
"github.com/minio/minio-go/v7/pkg/credentials"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/credentials/insecure"
"google.golang.org/grpc/status"
"google.golang.org/protobuf/types/known/emptypb"
"messenger/internal/attachment"
"messenger/internal/platform/config"
"messenger/internal/platform/s3store"
"messenger/internal/testenv"
)
func TestSeaweedStore(t *testing.T) {
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Minute)
defer cancel()
s, err := testenv.StartS3(ctx)
if err != nil {
t.Fatal(err)
}
defer s.Close()
newClient := func(access, secret string) *minio.Client {
t.Helper()
c, err := minio.New(strings.TrimPrefix(s.Endpoint, "http://"), &minio.Options{Creds: credentials.NewStaticV4(access, secret, ""), Region: s.Region, BucketLookup: minio.BucketLookupPath, MaxRetries: 1})
if err != nil {
t.Fatal(err)
}
return c
}
api := newClient(s.APIAccessKey, s.APISecretKey)
admin := newClient(s.AdminAccessKey, s.AdminSecretKey)
denied := func(t *testing.T, err error) {
t.Helper()
var response minio.ErrorResponse
if !errors.As(err, &response) || response.StatusCode != http.StatusForbidden {
t.Fatalf("expected access denied, got %v", err)
}
}
t.Run("remote gRPC cannot modify identity cache", func(t *testing.T) {
conn, err := grpc.NewClient("passthrough:///"+s.GRPCAddress, grpc.WithTransportCredentials(insecure.NewCredentials()),
grpc.WithContextDialer(func(ctx context.Context, address string) (net.Conn, error) {
return (&net.Dialer{Timeout: time.Second}).DialContext(ctx, "tcp", address)
}))
if err != nil {
t.Fatal(err)
}
defer conn.Close()
opCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
defer cancel()
err = conn.Invoke(opCtx, "/messaging_pb.SeaweedS3IamCache/PutIdentity", &emptypb.Empty{}, &emptypb.Empty{})
if code := status.Code(err); code != codes.PermissionDenied && code != codes.Unauthenticated {
t.Fatalf("remote IAM mutation was not rejected before argument validation: %v", err)
}
})
t.Run("bootstrap is idempotent and API cannot administer", func(t *testing.T) {
if err := s.Admin.Bootstrap(ctx); err != nil {
t.Fatal(err)
}
denied(t, s.APIStore.Bootstrap(ctx))
denied(t, api.MakeBucket(ctx, "forbidden-bucket", minio.MakeBucketOptions{Region: s.Region}))
denied(t, api.RemoveBucket(ctx, s.Bucket))
buckets, err := api.ListBuckets(ctx)
// SeaweedFS returns a filtered empty result for an authenticated caller
// without List rights, rather than rejecting ListBuckets outright.
if err != nil || len(buckets) != 0 {
t.Fatalf("API enumerated buckets: count=%d error=%v", len(buckets), err)
}
_, err = s.APIStore.List(ctx, "", "", 1)
denied(t, err)
})
t.Run("known length nonseekable put copy stat and stream", func(t *testing.T) {
const payload = "nonseekable image payload"
r := struct{ io.Reader }{strings.NewReader(payload)}
started := time.Now()
if err := s.APIStore.Put(ctx, "staging/source", r, int64(len(payload)), "image/png"); err != nil {
t.Fatal(err)
}
t.Logf("cold first PUT: %s", time.Since(started))
if err := s.APIStore.Copy(ctx, "staging/source", "blobs/durable"); err != nil {
t.Fatal(err)
}
obj, err := s.APIStore.Stat(ctx, "blobs/durable")
if err != nil {
t.Fatal(err)
}
if obj.Key != "blobs/durable" || obj.Size != 25 || obj.Modified.IsZero() {
t.Fatalf("wrong metadata: %+v", obj)
}
body, err := s.APIStore.Open(ctx, "blobs/durable")
if err != nil {
t.Fatal(err)
}
b, err := io.ReadAll(body)
body.Close()
if err != nil {
t.Fatal(err)
}
if string(b) != payload {
t.Fatalf("wrong body: %q", b)
}
meta, err := api.StatObject(ctx, s.Bucket, "blobs/durable", minio.StatObjectOptions{})
if err != nil {
t.Fatal(err)
}
if meta.ContentType != "image/png" {
t.Fatalf("copy lost MIME: %s", meta.ContentType)
}
for range 2 {
if err := s.APIStore.Delete(ctx, "staging/source"); err != nil {
t.Fatal(err)
}
}
if _, err := s.APIStore.Stat(ctx, "staging/source"); !errors.Is(err, attachment.ErrObjectMissing) {
t.Fatalf("API delete did not remove staging: %v", err)
}
})
t.Run("anonymous get put head and listing are refused", func(t *testing.T) {
client := &http.Client{Timeout: 3 * time.Second}
defer client.CloseIdleConnections()
for _, tc := range []struct{ method, path string }{{"GET", "/"}, {"GET", "/" + s.Bucket + "?list-type=2"}, {"GET", "/" + s.Bucket + "/blobs/durable"}, {"HEAD", "/" + s.Bucket + "/blobs/durable"}, {"PUT", "/" + s.Bucket + "/anonymous"}} {
req, _ := http.NewRequestWithContext(ctx, tc.method, s.Endpoint+tc.path, strings.NewReader("x"))
resp, err := client.Do(req)
if err != nil {
t.Fatal(err)
}
resp.Body.Close()
if resp.StatusCode != http.StatusForbidden {
t.Fatalf("anonymous %s %s: %d", tc.method, tc.path, resp.StatusCode)
}
}
})
t.Run("identities cannot escape their bucket", func(t *testing.T) {
if err := admin.MakeBucket(ctx, "private-other", minio.MakeBucketOptions{Region: s.Region}); err != nil {
t.Fatal(err)
}
if _, err := admin.PutObject(ctx, "private-other", "secret", strings.NewReader("private"), 7, minio.PutObjectOptions{DisableMultipart: true}); err != nil {
t.Fatal(err)
}
for _, pair := range [][2]string{{s.APIAccessKey, s.APISecretKey}, {s.AccessKey, s.SecretKey}} {
outside, err := s3store.New(config.S3{Endpoint: s.Endpoint, Region: s.Region, Bucket: "private-other", AccessKey: pair[0], SecretKey: pair[1]})
if err != nil {
t.Fatal(err)
}
_, err = outside.Stat(ctx, "secret")
denied(t, err)
_, err = outside.Open(ctx, "secret")
denied(t, err)
denied(t, outside.Put(ctx, "secret", strings.NewReader("x"), 1, "image/png"))
denied(t, outside.Delete(ctx, "secret"))
_, err = outside.List(ctx, "", "", 1)
denied(t, err)
c := newClient(pair[0], pair[1])
_, err = c.CopyObject(ctx, minio.CopyDestOptions{Bucket: s.Bucket, Object: "blobs/stolen"}, minio.CopySrcOptions{Bucket: "private-other", Object: "secret"})
denied(t, err)
}
})
t.Run("exclusive lexicographic pages including absent cursor", func(t *testing.T) {
for _, key := range []string{"page/z", "page/a", "page/a/nested", "page/b", "page/c"} {
if err := s.Store.Put(ctx, key, strings.NewReader("x"), 1, "image/png"); err != nil {
t.Fatal(err)
}
}
var got []string
after := ""
for {
page, err := s.Store.List(ctx, "page/", after, 2)
if err != nil {
t.Fatal(err)
}
if len(page) == 0 {
break
}
for _, obj := range page {
if obj.Size != 1 || obj.Modified.IsZero() {
t.Fatalf("wrong list metadata: %+v", obj)
}
got = append(got, obj.Key)
}
after = page[len(page)-1].Key
if len(got) > 5 {
t.Fatal("pagination did not advance")
}
}
if strings.Join(got, ",") != "page/a,page/a/nested,page/b,page/c,page/z" {
t.Fatalf("wrong order: %v", got)
}
page, err := s.Store.List(ctx, "page/", "page/az", 2)
if err != nil {
t.Fatal(err)
}
if len(page) != 2 || page[0].Key != "page/b" || page[1].Key != "page/c" {
t.Fatalf("absent cursor: %+v", page)
}
})
t.Run("missing objects differ from bucket and permission failures", func(t *testing.T) {
if _, err := s.Store.Stat(ctx, "absent"); !errors.Is(err, attachment.ErrObjectMissing) {
t.Fatalf("stat missing: %v", err)
}
if _, err := s.Store.Open(ctx, "absent"); !errors.Is(err, attachment.ErrObjectMissing) {
t.Fatalf("open missing: %v", err)
}
if err := s.Store.Copy(ctx, "absent", "blobs/absent"); !errors.Is(err, attachment.ErrObjectMissing) {
t.Fatalf("copy missing: %v", err)
}
for range 2 {
if err := s.Store.Delete(ctx, "absent"); err != nil {
t.Fatal(err)
}
}
missingBucket, err := s3store.New(config.S3{Endpoint: s.Endpoint, Region: s.Region, Bucket: "absent-bucket", AccessKey: s.AdminAccessKey, SecretKey: s.AdminSecretKey})
if err != nil {
t.Fatal(err)
}
if _, err := missingBucket.Stat(ctx, "absent"); err == nil || errors.Is(err, attachment.ErrObjectMissing) {
t.Fatalf("missing bucket treated as missing object: %v", err)
}
})
t.Run("short readers are not successful uploads", func(t *testing.T) {
if err := s.Store.Put(ctx, "staging/short", struct{ io.Reader }{strings.NewReader("short")}, 100, "image/png"); err == nil {
t.Fatal("short body accepted")
}
})
t.Run("container replacement preserves volume data and authentication", func(t *testing.T) {
if err := s.Recreate(ctx); err != nil {
t.Fatal(err)
}
body, err := s.APIStore.Open(ctx, "blobs/durable")
if err != nil {
t.Fatal(err)
}
b, err := io.ReadAll(body)
body.Close()
if err != nil {
t.Fatal(err)
}
if string(b) != "nonseekable image payload" {
t.Fatalf("object lost on replacement: %q", b)
}
if _, err := s.Store.List(ctx, "page/", "", 2); err != nil {
t.Fatal(err)
}
})
t.Run("outage is bounded and never missing", func(t *testing.T) {
if err := s.Stop(ctx); err != nil {
t.Fatal(err)
}
opCtx, stop := context.WithTimeout(ctx, 150*time.Millisecond)
defer stop()
start := time.Now()
_, err := s.Store.Stat(opCtx, "blobs/durable")
if err == nil || errors.Is(err, attachment.ErrObjectMissing) {
t.Fatalf("outage treated as missing: %v", err)
}
if time.Since(start) > 2*time.Second {
t.Fatal("outage exceeded caller deadline")
}
})
}