[feature] migrate to monorepo

2025-02-21 00:49:20 +08:00 · 2025-02-21 00:49:20 +08:00 · 05ddc1f783
commit 05ddc1f783
267 changed files with 75165 additions and 0 deletions
--- a/backend/internal/storage/s3_test.go
+++ b/backend/internal/storage/s3_test.go
@ -0,0 +1,211 @@
+package storage
+
+import (
+	"bytes"
+	"context"
+	"io"
+	"testing"
+	"time"
+
+	"github.com/aws/aws-sdk-go-v2/aws"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/aws/aws-sdk-go-v2/service/s3/types"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/require"
+)
+
+// MockS3Client is a mock implementation of the S3 client interface
+type MockS3Client struct {
+	mock.Mock
+}
+
+func (m *MockS3Client) PutObject(ctx context.Context, params *s3.PutObjectInput, optFns ...func(*s3.Options)) (*s3.PutObjectOutput, error) {
+	args := m.Called(ctx, params)
+	return args.Get(0).(*s3.PutObjectOutput), args.Error(1)
+}
+
+func (m *MockS3Client) GetObject(ctx context.Context, params *s3.GetObjectInput, optFns ...func(*s3.Options)) (*s3.GetObjectOutput, error) {
+	args := m.Called(ctx, params)
+	return args.Get(0).(*s3.GetObjectOutput), args.Error(1)
+}
+
+func (m *MockS3Client) DeleteObject(ctx context.Context, params *s3.DeleteObjectInput, optFns ...func(*s3.Options)) (*s3.DeleteObjectOutput, error) {
+	args := m.Called(ctx, params)
+	return args.Get(0).(*s3.DeleteObjectOutput), args.Error(1)
+}
+
+func (m *MockS3Client) ListObjectsV2(ctx context.Context, params *s3.ListObjectsV2Input, optFns ...func(*s3.Options)) (*s3.ListObjectsV2Output, error) {
+	args := m.Called(ctx, params)
+	return args.Get(0).(*s3.ListObjectsV2Output), args.Error(1)
+}
+
+func (m *MockS3Client) HeadObject(ctx context.Context, params *s3.HeadObjectInput, optFns ...func(*s3.Options)) (*s3.HeadObjectOutput, error) {
+	args := m.Called(ctx, params)
+	return args.Get(0).(*s3.HeadObjectOutput), args.Error(1)
+}
+
+func TestS3Storage(t *testing.T) {
+	ctx := context.Background()
+	mockClient := new(MockS3Client)
+	storage := NewS3Storage(mockClient, "test-bucket", "", false)
+
+	t.Run("Save", func(t *testing.T) {
+		mockClient.ExpectedCalls = nil
+		mockClient.Calls = nil
+
+		content := []byte("test content")
+		reader := bytes.NewReader(content)
+
+		// Mock HeadObject to return NotFound error
+		mockClient.On("HeadObject", ctx, mock.MatchedBy(func(input *s3.HeadObjectInput) bool {
+			return aws.ToString(input.Bucket) == "test-bucket"
+		})).Return(&s3.HeadObjectOutput{}, &types.NoSuchKey{
+			Message: aws.String("The specified key does not exist."),
+		})
+
+		mockClient.On("PutObject", ctx, mock.MatchedBy(func(input *s3.PutObjectInput) bool {
+			return aws.ToString(input.Bucket) == "test-bucket" &&
+				aws.ToString(input.ContentType) == "text/plain"
+		})).Return(&s3.PutObjectOutput{}, nil)
+
+		fileInfo, err := storage.Save(ctx, "test.txt", "text/plain", reader)
+		require.NoError(t, err)
+		assert.NotEmpty(t, fileInfo.ID)
+		assert.Equal(t, "test.txt", fileInfo.Name)
+		assert.Equal(t, "text/plain", fileInfo.ContentType)
+
+		mockClient.AssertExpectations(t)
+	})
+
+	t.Run("Get", func(t *testing.T) {
+		content := []byte("test content")
+		mockClient.On("GetObject", ctx, mock.MatchedBy(func(input *s3.GetObjectInput) bool {
+			return aws.ToString(input.Bucket) == "test-bucket" &&
+				aws.ToString(input.Key) == "test-id"
+		})).Return(&s3.GetObjectOutput{
+			Body:         io.NopCloser(bytes.NewReader(content)),
+			ContentType:  aws.String("text/plain"),
+			ContentLength: aws.Int64(int64(len(content))),
+			LastModified: aws.Time(time.Now()),
+		}, nil)
+
+		readCloser, info, err := storage.Get(ctx, "test-id")
+		require.NoError(t, err)
+		defer readCloser.Close()
+
+		data, err := io.ReadAll(readCloser)
+		require.NoError(t, err)
+		assert.Equal(t, content, data)
+		assert.Equal(t, "test-id", info.ID)
+		assert.Equal(t, int64(len(content)), info.Size)
+
+		mockClient.AssertExpectations(t)
+	})
+
+	t.Run("List", func(t *testing.T) {
+		mockClient.ExpectedCalls = nil
+		mockClient.Calls = nil
+
+		mockClient.On("ListObjectsV2", ctx, mock.MatchedBy(func(input *s3.ListObjectsV2Input) bool {
+			return aws.ToString(input.Bucket) == "test-bucket" &&
+				aws.ToString(input.Prefix) == "test" &&
+				aws.ToInt32(input.MaxKeys) == 10
+		})).Return(&s3.ListObjectsV2Output{
+			Contents: []types.Object{
+				{
+					Key:          aws.String("test1"),
+					Size:         aws.Int64(100),
+					LastModified: aws.Time(time.Now()),
+				},
+				{
+					Key:          aws.String("test2"),
+					Size:         aws.Int64(200),
+					LastModified: aws.Time(time.Now()),
+				},
+			},
+		}, nil)
+
+		// Mock HeadObject for both files
+		mockClient.On("HeadObject", ctx, mock.MatchedBy(func(input *s3.HeadObjectInput) bool {
+			return aws.ToString(input.Bucket) == "test-bucket" &&
+				aws.ToString(input.Key) == "test1"
+		})).Return(&s3.HeadObjectOutput{
+			ContentType: aws.String("text/plain"),
+			Metadata: map[string]string{
+				"x-amz-meta-original-name": "test1.txt",
+			},
+		}, nil).Once()
+
+		mockClient.On("HeadObject", ctx, mock.MatchedBy(func(input *s3.HeadObjectInput) bool {
+			return aws.ToString(input.Bucket) == "test-bucket" &&
+				aws.ToString(input.Key) == "test2"
+		})).Return(&s3.HeadObjectOutput{
+			ContentType: aws.String("text/plain"),
+			Metadata: map[string]string{
+				"x-amz-meta-original-name": "test2.txt",
+			},
+		}, nil).Once()
+
+		files, err := storage.List(ctx, "test", 10, 0)
+		require.NoError(t, err)
+		assert.Len(t, files, 2)
+		assert.Equal(t, "test1", files[0].ID)
+		assert.Equal(t, int64(100), files[0].Size)
+		assert.Equal(t, "test1.txt", files[0].Name)
+		assert.Equal(t, "text/plain", files[0].ContentType)
+
+		mockClient.AssertExpectations(t)
+	})
+
+	t.Run("Delete", func(t *testing.T) {
+		mockClient.On("DeleteObject", ctx, mock.MatchedBy(func(input *s3.DeleteObjectInput) bool {
+			return aws.ToString(input.Bucket) == "test-bucket" &&
+				aws.ToString(input.Key) == "test-id"
+		})).Return(&s3.DeleteObjectOutput{}, nil)
+
+		err := storage.Delete(ctx, "test-id")
+		require.NoError(t, err)
+
+		mockClient.AssertExpectations(t)
+	})
+
+	t.Run("Exists", func(t *testing.T) {
+		mockClient.ExpectedCalls = nil
+		mockClient.Calls = nil
+
+		// Mock HeadObject for existing file
+		mockClient.On("HeadObject", ctx, mock.MatchedBy(func(input *s3.HeadObjectInput) bool {
+			return aws.ToString(input.Bucket) == "test-bucket" &&
+				aws.ToString(input.Key) == "test-id"
+		})).Return(&s3.HeadObjectOutput{}, nil).Once()
+
+		exists, err := storage.Exists(ctx, "test-id")
+		require.NoError(t, err)
+		assert.True(t, exists)
+
+		// Mock HeadObject for non-existing file
+		mockClient.On("HeadObject", ctx, mock.MatchedBy(func(input *s3.HeadObjectInput) bool {
+			return aws.ToString(input.Bucket) == "test-bucket" &&
+				aws.ToString(input.Key) == "non-existent"
+		})).Return(&s3.HeadObjectOutput{}, &types.NoSuchKey{
+			Message: aws.String("The specified key does not exist."),
+		}).Once()
+
+		exists, err = storage.Exists(ctx, "non-existent")
+		require.NoError(t, err)
+		assert.False(t, exists)
+
+		mockClient.AssertExpectations(t)
+	})
+
+	t.Run("Custom URL", func(t *testing.T) {
+		customStorage := &S3Storage{
+			client:    mockClient,
+			bucket:    "test-bucket",
+			customURL: "https://custom.domain",
+			proxyS3:   true,
+		}
+		assert.Contains(t, customStorage.getObjectURL("test-id"), "https://custom.domain")
+	})
+}