Crussell/backend/internal/s3/s3_dev_test.go

//go:build test && dev

package s3

import (
	"bytes"
	"context"
	"strings"
	"sync"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func TestInMemS3_UploadAndDownload(t *testing.T) {
	t.Parallel()
	s3 := &inMemS3{objects: make(map[string][]byte)}
	ctx := context.Background()

	body := "hello world"
	err := s3.Upload(ctx, "bucket1", "key1", strings.NewReader(body), "text/plain")
	require.NoError(t, err)

	var buf bytes.Buffer
	err = s3.Download(ctx, "bucket1", "key1", &buf)
	require.NoError(t, err)
	assert.Equal(t, body, buf.String())
}

func TestInMemS3_UploadOverwrite(t *testing.T) {
	t.Parallel()
	s3 := &inMemS3{objects: make(map[string][]byte)}
	ctx := context.Background()

	err := s3.Upload(ctx, "bucket", "key", strings.NewReader("first"), "")
	require.NoError(t, err)

	err = s3.Upload(ctx, "bucket", "key", strings.NewReader("second"), "")
	require.NoError(t, err)

	var buf bytes.Buffer
	err = s3.Download(ctx, "bucket", "key", &buf)
	require.NoError(t, err)
	assert.Equal(t, "second", buf.String())
}

func TestInMemS3_Download_NotFound(t *testing.T) {
	t.Parallel()
	s3 := &inMemS3{objects: make(map[string][]byte)}
	ctx := context.Background()

	var buf bytes.Buffer
	err := s3.Download(ctx, "bucket", "nonexistent", &buf)
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "not found")
}

func TestInMemS3_Delete(t *testing.T) {
	t.Parallel()
	s3 := &inMemS3{objects: make(map[string][]byte)}
	ctx := context.Background()

	err := s3.Upload(ctx, "bucket", "key", strings.NewReader("data"), "")
	require.NoError(t, err)

	err = s3.Delete(ctx, "bucket", "key")
	assert.NoError(t, err)

	var buf bytes.Buffer
	err = s3.Download(ctx, "bucket", "key", &buf)
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "not found")
}

func TestInMemS3_Delete_NotFound(t *testing.T) {
	t.Parallel()
	s3 := &inMemS3{objects: make(map[string][]byte)}
	ctx := context.Background()

	err := s3.Delete(ctx, "bucket", "does-not-exist")
	assert.NoError(t, err)
}

func TestInMemS3_GetURL(t *testing.T) {
	t.Parallel()
	s3 := &inMemS3{objects: make(map[string][]byte)}
	ctx := context.Background()

	url, err := s3.GetURL(ctx, "mybucket", "mykey")
	require.NoError(t, err)
	assert.Equal(t, "https://cdn.example.com/mybucket/mykey", url)
}

func TestInMemS3_HealthCheck(t *testing.T) {
	t.Parallel()
	s3 := &inMemS3{objects: make(map[string][]byte)}
	ctx := context.Background()

	err := s3.HealthCheck(ctx)
	assert.NoError(t, err)
}

func TestInMemS3_ConcurrentUpload(t *testing.T) {
	t.Parallel()
	s3 := &inMemS3{objects: make(map[string][]byte)}
	ctx := context.Background()

	var wg sync.WaitGroup
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(n int) {
			defer wg.Done()
			key := "key-" + string(rune('0'+n))
			err := s3.Upload(ctx, "bucket", key, strings.NewReader("data"), "")
			assert.NoError(t, err)
		}(i)
	}
	wg.Wait()

	for i := 0; i < 10; i++ {
		key := "key-" + string(rune('0'+i))
		var buf bytes.Buffer
		err := s3.Download(ctx, "bucket", key, &buf)
		assert.NoError(t, err)
		assert.Equal(t, "data", buf.String())
	}
}

func TestInMemS3_DownloadEmptyBody(t *testing.T) {
	t.Parallel()
	s3 := &inMemS3{objects: make(map[string][]byte)}
	ctx := context.Background()

	err := s3.Upload(ctx, "bucket", "empty", strings.NewReader(""), "")
	require.NoError(t, err)

	var buf bytes.Buffer
	err = s3.Download(ctx, "bucket", "empty", &buf)
	require.NoError(t, err)
	assert.Equal(t, "", buf.String())
}

func TestConnect_FallbackToInMemory(t *testing.T) {
	t.Parallel()
	ctx := context.Background()

	err := Connect()
	assert.NoError(t, err)
	assert.NotNil(t, Client)

	var buf bytes.Buffer
	err = Client.Download(ctx, "bucket", "nonexistent", &buf)
	assert.Error(t, err)
	assert.Contains(t, err.Error(), "not found")
}