Files

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/mtusi2026lab6/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)
}
}