vaultik/internal/s3/client_test.go

package s3_test

import (
	"bytes"
	"context"
	"io"
	"testing"

	"sneak.berlin/go/vaultik/internal/s3"
)

//nolint:paralleltest // test servers share a fixed localhost port
func TestClient(t *testing.T) {
	ts := NewTestServer(t)
	defer func() {
		err := ts.Cleanup()
		if err != nil {
			t.Errorf("cleanup failed: %v", err)
		}
	}()

	ctx := context.Background()

	// Create client
	client, err := s3.NewClient(ctx, s3.Config{
		Endpoint:        testEndpoint,
		Bucket:          testBucket,
		Prefix:          "test-prefix/",
		AccessKeyID:     testAccessKey,
		SecretAccessKey: testSecretKey,
		Region:          testRegion,
	})
	if err != nil {
		t.Fatalf("failed to create client: %v", err)
	}

	testKey := "foo/bar.txt"
	testData := []byte("test data")

	verifyPutGetHead(ctx, t, client, testKey, testData)
	verifyListAndDelete(ctx, t, client, testKey)
}

// verifyPutGetHead uploads an object, reads it back, and checks existence.
func verifyPutGetHead(
	ctx context.Context, t *testing.T, client *s3.Client,
	testKey string, testData []byte,
) {
	t.Helper()

	err := client.PutObject(ctx, testKey, bytes.NewReader(testData))
	if err != nil {
		t.Fatalf("failed to put object: %v", err)
	}

	// Test GetObject
	reader, err := client.GetObject(ctx, testKey)
	if err != nil {
		t.Fatalf("failed to get object: %v", err)
	}
	defer func() {
		err := reader.Close()
		if err != nil {
			t.Errorf("failed to close reader: %v", err)
		}
	}()

	data, err := io.ReadAll(reader)
	if err != nil {
		t.Fatalf("failed to read data: %v", err)
	}

	if !bytes.Equal(data, testData) {
		t.Errorf("data mismatch: got %q, want %q", data, testData)
	}

	// Test HeadObject
	exists, err := client.HeadObject(ctx, testKey)
	if err != nil {
		t.Fatalf("failed to head object: %v", err)
	}

	if !exists {
		t.Error("expected object to exist")
	}
}

// verifyListAndDelete lists the object's prefix, deletes it, and checks
// it is gone.
func verifyListAndDelete(
	ctx context.Context, t *testing.T, client *s3.Client, testKey string,
) {
	t.Helper()

	keys, err := client.ListObjects(ctx, "foo/")
	if err != nil {
		t.Fatalf("failed to list objects: %v", err)
	}

	if len(keys) != 1 {
		t.Errorf("expected 1 key, got %d", len(keys))
	}

	if keys[0] != testKey {
		t.Errorf("unexpected key: got %s, want %s", keys[0], testKey)
	}

	// Test DeleteObject
	err = client.DeleteObject(ctx, testKey)
	if err != nil {
		t.Fatalf("failed to delete object: %v", err)
	}

	// Verify deletion
	exists, err := client.HeadObject(ctx, testKey)
	if err != nil {
		t.Fatalf("failed to head object after deletion: %v", err)
	}

	if exists {
		t.Error("expected object to not exist after deletion")
	}
}