forked from mtusi2026/mtusi2026lab5
194 lines
5.2 KiB
Go
194 lines
5.2 KiB
Go
package objectstore
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"io"
|
|
"net/http"
|
|
"os"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/uuid"
|
|
|
|
"gitea.privcloud.tech/vlad_marlo/mtusi2026lab5/internal/config"
|
|
)
|
|
|
|
// testObjects creates a scoped client against an explicitly isolated S3 server.
|
|
func testObjects(t *testing.T) *Client {
|
|
t.Helper()
|
|
if os.Getenv("S3_ENDPOINT") == "" {
|
|
t.Skip("isolated S3_ENDPOINT required")
|
|
}
|
|
cfg, err := config.NewObjectStore()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
client, err := New(cfg)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return client
|
|
}
|
|
|
|
// TestOriginalRoundTrip checks real S3 publication, streaming, listing and explicit deletion.
|
|
func TestOriginalRoundTrip(t *testing.T) {
|
|
client := testObjects(t)
|
|
key := "original/" + uuid.NewString()
|
|
original := []byte("synthetic original bytes")
|
|
if err := client.Put(t.Context(), key, "application/octet-stream", bytes.NewReader(original), int64(len(original))); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() {
|
|
if err := client.Remove(context.Background(), key); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
reader, err := client.Get(t.Context(), key)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
data, err := io.ReadAll(reader)
|
|
if closeErr := reader.Close(); closeErr != nil {
|
|
t.Fatal(closeErr)
|
|
}
|
|
if err != nil || !bytes.Equal(data, original) {
|
|
t.Fatalf("original changed: %v", err)
|
|
}
|
|
found, err := client.Exists(t.Context(), key)
|
|
if err != nil || !found {
|
|
t.Fatalf("existence: %v", err)
|
|
}
|
|
entries, err := client.List(t.Context(), "")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
found = false
|
|
for _, entry := range entries {
|
|
found = found || entry.Key == key
|
|
}
|
|
if !found {
|
|
t.Fatal("original absent from inventory")
|
|
}
|
|
}
|
|
|
|
// TestMissingOriginal checks absence is distinct from unavailable S3.
|
|
func TestMissingOriginal(t *testing.T) {
|
|
client := testObjects(t)
|
|
key := "original/" + uuid.NewString()
|
|
exists, err := client.Exists(t.Context(), key)
|
|
if err != nil || exists {
|
|
t.Fatalf("missing: %v", err)
|
|
}
|
|
if reader, err := client.Get(t.Context(), key); err == nil {
|
|
_ = reader.Close()
|
|
t.Fatal("missing stream accepted")
|
|
}
|
|
}
|
|
|
|
// TestUnavailableS3 returns bounded failures instead of converting them into missing objects.
|
|
func TestUnavailableS3(t *testing.T) {
|
|
client, err := New(&config.ObjectStore{Endpoint: "127.0.0.1:1", Bucket: "attachments", AccessKey: "test", SecretKey: "test"})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
ctx, cancel := context.WithTimeout(t.Context(), 50*time.Millisecond)
|
|
defer cancel()
|
|
if err := client.Put(ctx, "original/test", "image/png", bytes.NewReader(nil), 0); err == nil {
|
|
t.Fatal("unavailable PUT succeeded")
|
|
}
|
|
if _, err := client.Get(ctx, "original/test"); err == nil {
|
|
t.Fatal("unavailable GET succeeded")
|
|
}
|
|
if _, err := client.Exists(ctx, "original/test"); err == nil {
|
|
t.Fatal("unavailable HEAD classified as missing")
|
|
}
|
|
if _, err := client.List(ctx, ""); err == nil {
|
|
t.Fatal("unavailable LIST succeeded")
|
|
}
|
|
if err := client.Ping(ctx); err == nil {
|
|
t.Fatal("unavailable bucket ready")
|
|
}
|
|
if err := client.Bootstrap(ctx); err == nil {
|
|
t.Fatal("unavailable bootstrap succeeded")
|
|
}
|
|
}
|
|
|
|
// TestInvalidEndpoint rejects malformed S3 configuration before a network request.
|
|
func TestInvalidEndpoint(t *testing.T) {
|
|
if _, err := New(&config.ObjectStore{Endpoint: "http://invalid/path"}); err == nil {
|
|
t.Fatal("invalid endpoint accepted")
|
|
}
|
|
}
|
|
|
|
// TestBucketBootstrap creates an isolated private bucket twice and verifies scoped credentials cannot access it.
|
|
func TestBucketBootstrap(t *testing.T) {
|
|
scoped := testObjects(t)
|
|
if err := scoped.Ping(t.Context()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
cfg, err := config.NewObjectStore()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
secret := os.Getenv("S3_ADMIN_SECRET")
|
|
if secret == "" {
|
|
t.Skip("isolated S3_ADMIN_SECRET required for bootstrap test")
|
|
}
|
|
cfg.AccessKey = "operator"
|
|
cfg.SecretKey = secret
|
|
cfg.Bucket = "test-" + uuid.NewString()
|
|
admin, err := New(cfg)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() {
|
|
if err := admin.client.RemoveBucket(context.Background(), cfg.Bucket); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
if err := admin.Bootstrap(t.Context()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := admin.Bootstrap(t.Context()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
scoped.bucket = cfg.Bucket
|
|
if _, err := scoped.List(t.Context(), ""); err == nil {
|
|
t.Fatal("service identity accessed another bucket")
|
|
}
|
|
}
|
|
|
|
// TestPrivateBucketRejectsAnonymous verifies object ACL independently of application authorization.
|
|
func TestPrivateBucketRejectsAnonymous(t *testing.T) {
|
|
client := testObjects(t)
|
|
key := "original/" + uuid.NewString()
|
|
if err := client.Put(t.Context(), key, "application/octet-stream", bytes.NewReader([]byte("private")), 7); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(func() {
|
|
if err := client.Remove(context.Background(), key); err != nil {
|
|
t.Error(err)
|
|
}
|
|
})
|
|
cfg, err := config.NewObjectStore()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
scheme := "https://"
|
|
if !cfg.Secure {
|
|
scheme = "http://"
|
|
}
|
|
httpClient := &http.Client{Timeout: time.Second}
|
|
response, err := httpClient.Get(scheme + cfg.Endpoint + "/" + cfg.Bucket + "/" + key)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := response.Body.Close(); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if response.StatusCode != http.StatusForbidden {
|
|
t.Fatalf("anonymous access status=%d", response.StatusCode)
|
|
}
|
|
}
|