mockgen

2026-10-09 00:09:43 +00:00 · 2024-04-18 23:27:41 +09:00
parent 05fe822ff4
commit 6350eb7a2f
6 changed files with 374 additions and 62 deletions
@@ -9,11 +9,10 @@ import (
 	"strings"

 	"github.com/aws/aws-sdk-go-v2/aws"
-	"github.com/aws/aws-sdk-go-v2/config"
 	"github.com/aws/aws-sdk-go-v2/service/iam"
 	iamtypes "github.com/aws/aws-sdk-go-v2/service/iam/types"
 	"github.com/aws/aws-sdk-go-v2/service/s3"
-	"github.com/aws/aws-sdk-go-v2/service/s3/types"
+	s3types "github.com/aws/aws-sdk-go-v2/service/s3/types"
 	"github.com/aws/aws-sdk-go-v2/service/sts"
 	"github.com/aws/smithy-go"
 )
@@ -41,54 +40,6 @@ type AwsS3API interface {
 	PutBucketOwnershipControls(ctx context.Context, params *s3.PutBucketOwnershipControlsInput, optFns ...func(*s3.Options)) (*s3.PutBucketOwnershipControlsOutput, error)
 }

-type AwsClient interface {
-	IamClient() *AwsIamClient
-	StsClient() *AwsStsClient
-	S3Client(region, bucketName string) *AwsS3Client
-}
-
-func NewAwsClientFactory(ctx context.Context) (*AwsClientFactory, error) {
-	cfg, err := config.LoadDefaultConfig(
-		ctx,
-	)
-	if err != nil {
-		return nil, fmt.Errorf("unable to load SDK config, %w", err)
-	}
-	return &AwsClientFactory{config: cfg}, nil
-}
-
-func (a *AwsClientFactory) IamClient() *AwsIamClient {
-	return &AwsIamClient{
-		iam.NewFromConfig(a.config),
-	}
-}
-
-func (a *AwsClientFactory) StsClient() *AwsStsClient {
-	return &AwsStsClient{
-		sts.NewFromConfig(a.config),
-	}
-}
-
-func (a *AwsClientFactory) S3Client(bucketName, region string) *AwsS3Client {
-	return &AwsS3Client{
-		s3.NewFromConfig(a.config),
-		region,
-		bucketName,
-	}
-}
-
-type AwsIamClient struct {
-	Client AwsIamAPI
-}
-type AwsStsClient struct {
-	Client AwsStsAPI
-}
-type AwsS3Client struct {
-	Client     AwsS3API
-	region     string
-	bucketName string
-}
-
 // CheckObjectExists checks if a specific object exists in the given bucket.
 func (a *AwsS3Client) CheckObjectExists(ctx context.Context, key string) (bool, error) {
 	_, err := a.Client.HeadObject(ctx, &s3.HeadObjectInput{
@@ -96,7 +47,7 @@ func (a *AwsS3Client) CheckObjectExists(ctx context.Context, key string) (bool,
 		Key:    aws.String(key),
 	})
 	if err != nil {
-		var nfe *types.NotFound
+		var nfe *s3types.NotFound
 		if errors.As(err, &nfe) {
 			return false, nil
 		}
@@ -152,7 +103,7 @@ func (a *AwsS3Client) PutObjectPublic(ctx context.Context, input ObjectInput) er
 	_, err := a.Client.PutObject(ctx, &s3.PutObjectInput{
 		Bucket:      aws.String(a.bucketName),
 		Key:         aws.String(input.Key),
-		ACL:         types.ObjectCannedACLPublicRead,
+		ACL:         s3types.ObjectCannedACLPublicRead,
 		Body:        bytes.NewReader(input.Body),
 		ContentType: aws.String("application/json"),
 	})
@@ -165,12 +116,12 @@ func (a *AwsS3Client) CreateBucketPublic(ctx context.Context) error {
 	bucket := aws.String(a.bucketName)
 	_, err := a.Client.CreateBucket(ctx, &s3.CreateBucketInput{
 		Bucket: bucket,
-		CreateBucketConfiguration: &types.CreateBucketConfiguration{
-			LocationConstraint: types.BucketLocationConstraint(a.Region()),
+		CreateBucketConfiguration: &s3types.CreateBucketConfiguration{
+			LocationConstraint: s3types.BucketLocationConstraint(a.Region()),
 		},
 	})
 	if err != nil {
-		var bucketAlreadyOwnedByYou *types.BucketAlreadyOwnedByYou
+		var bucketAlreadyOwnedByYou *s3types.BucketAlreadyOwnedByYou
 		if errors.As(err, &bucketAlreadyOwnedByYou) {
 			log.Println("skipped error", err)
 		} else {
@@ -183,10 +134,10 @@ func (a *AwsS3Client) CreateBucketPublic(ctx context.Context) error {
 	}
 	_, err = a.Client.PutBucketOwnershipControls(ctx, &s3.PutBucketOwnershipControlsInput{
 		Bucket: bucket,
-		OwnershipControls: &types.OwnershipControls{
-			Rules: []types.OwnershipControlsRule{
+		OwnershipControls: &s3types.OwnershipControls{
+			Rules: []s3types.OwnershipControlsRule{
 				{
-					ObjectOwnership: types.ObjectOwnershipBucketOwnerPreferred,
+					ObjectOwnership: s3types.ObjectOwnershipBucketOwnerPreferred,
 				},
 			},
 		},
@@ -216,13 +167,13 @@ func (a *AwsS3Client) DeleteBucket(ctx context.Context) error {

 // DeleteObjects removes a list of objects from a specified bucket.
 func (a *AwsS3Client) DeleteObjects(ctx context.Context, objectKeys []string) error {
-	objectIds := make([]types.ObjectIdentifier, len(objectKeys))
+	objectIds := make([]s3types.ObjectIdentifier, len(objectKeys))
 	for i, key := range objectKeys {
-		objectIds[i] = types.ObjectIdentifier{Key: aws.String(key)}
+		objectIds[i] = s3types.ObjectIdentifier{Key: aws.String(key)}
 	}
 	_, err := a.Client.DeleteObjects(ctx, &s3.DeleteObjectsInput{
 		Bucket: aws.String(a.bucketName),
-		Delete: &types.Delete{Objects: objectIds},
+		Delete: &s3types.Delete{Objects: objectIds},
 	})
 	if err != nil {
 		return err
@@ -0,0 +1,59 @@
+package client
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/aws/aws-sdk-go-v2/config"
+	"github.com/aws/aws-sdk-go-v2/service/iam"
+	"github.com/aws/aws-sdk-go-v2/service/s3"
+	"github.com/aws/aws-sdk-go-v2/service/sts"
+)
+
+type AwsClient interface {
+	IamClient() *AwsIamClient
+	StsClient() *AwsStsClient
+	S3Client(region, bucketName string) *AwsS3Client
+}
+
+type AwsIamClient struct {
+	Client AwsIamAPI
+}
+type AwsStsClient struct {
+	Client AwsStsAPI
+}
+type AwsS3Client struct {
+	Client     AwsS3API
+	region     string
+	bucketName string
+}
+
+func NewAwsClientFactory(ctx context.Context) (*AwsClientFactory, error) {
+	cfg, err := config.LoadDefaultConfig(
+		ctx,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("unable to load SDK config, %w", err)
+	}
+	return &AwsClientFactory{config: cfg}, nil
+}
+
+func (a *AwsClientFactory) IamClient() *AwsIamClient {
+	return &AwsIamClient{
+		iam.NewFromConfig(a.config),
+	}
+}
+
+func (a *AwsClientFactory) StsClient() *AwsStsClient {
+	return &AwsStsClient{
+		sts.NewFromConfig(a.config),
+	}
+}
+
+func (a *AwsClientFactory) S3Client(bucketName, region string) *AwsS3Client {
+	return &AwsS3Client{
+		s3.NewFromConfig(a.config),
+		region,
+		bucketName,
+	}
+}
@@ -0,0 +1,289 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: internal/client/aws.go
+//
+// Generated by this command:
+//
+//	mockgen -source internal/client/aws.go -destination internal/mock/aws_mock.go -package mock
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	iam "github.com/aws/aws-sdk-go-v2/service/iam"
+	s3 "github.com/aws/aws-sdk-go-v2/service/s3"
+	sts "github.com/aws/aws-sdk-go-v2/service/sts"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockAwsIamAPI is a mock of AwsIamAPI interface.
+type MockAwsIamAPI struct {
+	ctrl     *gomock.Controller
+	recorder *MockAwsIamAPIMockRecorder
+}
+
+// MockAwsIamAPIMockRecorder is the mock recorder for MockAwsIamAPI.
+type MockAwsIamAPIMockRecorder struct {
+	mock *MockAwsIamAPI
+}
+
+// NewMockAwsIamAPI creates a new mock instance.
+func NewMockAwsIamAPI(ctrl *gomock.Controller) *MockAwsIamAPI {
+	mock := &MockAwsIamAPI{ctrl: ctrl}
+	mock.recorder = &MockAwsIamAPIMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockAwsIamAPI) EXPECT() *MockAwsIamAPIMockRecorder {
+	return m.recorder
+}
+
+// CreateOpenIDConnectProvider mocks base method.
+func (m *MockAwsIamAPI) CreateOpenIDConnectProvider(ctx context.Context, params *iam.CreateOpenIDConnectProviderInput, optFns ...func(*iam.Options)) (*iam.CreateOpenIDConnectProviderOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range optFns {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateOpenIDConnectProvider", varargs...)
+	ret0, _ := ret[0].(*iam.CreateOpenIDConnectProviderOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateOpenIDConnectProvider indicates an expected call of CreateOpenIDConnectProvider.
+func (mr *MockAwsIamAPIMockRecorder) CreateOpenIDConnectProvider(ctx, params any, optFns ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, optFns...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOpenIDConnectProvider", reflect.TypeOf((*MockAwsIamAPI)(nil).CreateOpenIDConnectProvider), varargs...)
+}
+
+// DeleteOpenIDConnectProvider mocks base method.
+func (m *MockAwsIamAPI) DeleteOpenIDConnectProvider(ctx context.Context, params *iam.DeleteOpenIDConnectProviderInput, optFns ...func(*iam.Options)) (*iam.DeleteOpenIDConnectProviderOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range optFns {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteOpenIDConnectProvider", varargs...)
+	ret0, _ := ret[0].(*iam.DeleteOpenIDConnectProviderOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteOpenIDConnectProvider indicates an expected call of DeleteOpenIDConnectProvider.
+func (mr *MockAwsIamAPIMockRecorder) DeleteOpenIDConnectProvider(ctx, params any, optFns ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, optFns...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteOpenIDConnectProvider", reflect.TypeOf((*MockAwsIamAPI)(nil).DeleteOpenIDConnectProvider), varargs...)
+}
+
+// MockAwsStsAPI is a mock of AwsStsAPI interface.
+type MockAwsStsAPI struct {
+	ctrl     *gomock.Controller
+	recorder *MockAwsStsAPIMockRecorder
+}
+
+// MockAwsStsAPIMockRecorder is the mock recorder for MockAwsStsAPI.
+type MockAwsStsAPIMockRecorder struct {
+	mock *MockAwsStsAPI
+}
+
+// NewMockAwsStsAPI creates a new mock instance.
+func NewMockAwsStsAPI(ctrl *gomock.Controller) *MockAwsStsAPI {
+	mock := &MockAwsStsAPI{ctrl: ctrl}
+	mock.recorder = &MockAwsStsAPIMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockAwsStsAPI) EXPECT() *MockAwsStsAPIMockRecorder {
+	return m.recorder
+}
+
+// GetCallerIdentity mocks base method.
+func (m *MockAwsStsAPI) GetCallerIdentity(ctx context.Context, params *sts.GetCallerIdentityInput, optFns ...func(*sts.Options)) (*sts.GetCallerIdentityOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range optFns {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetCallerIdentity", varargs...)
+	ret0, _ := ret[0].(*sts.GetCallerIdentityOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCallerIdentity indicates an expected call of GetCallerIdentity.
+func (mr *MockAwsStsAPIMockRecorder) GetCallerIdentity(ctx, params any, optFns ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, optFns...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCallerIdentity", reflect.TypeOf((*MockAwsStsAPI)(nil).GetCallerIdentity), varargs...)
+}
+
+// MockAwsS3API is a mock of AwsS3API interface.
+type MockAwsS3API struct {
+	ctrl     *gomock.Controller
+	recorder *MockAwsS3APIMockRecorder
+}
+
+// MockAwsS3APIMockRecorder is the mock recorder for MockAwsS3API.
+type MockAwsS3APIMockRecorder struct {
+	mock *MockAwsS3API
+}
+
+// NewMockAwsS3API creates a new mock instance.
+func NewMockAwsS3API(ctrl *gomock.Controller) *MockAwsS3API {
+	mock := &MockAwsS3API{ctrl: ctrl}
+	mock.recorder = &MockAwsS3APIMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockAwsS3API) EXPECT() *MockAwsS3APIMockRecorder {
+	return m.recorder
+}
+
+// CreateBucket mocks base method.
+func (m *MockAwsS3API) CreateBucket(ctx context.Context, params *s3.CreateBucketInput, optFns ...func(*s3.Options)) (*s3.CreateBucketOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range optFns {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "CreateBucket", varargs...)
+	ret0, _ := ret[0].(*s3.CreateBucketOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateBucket indicates an expected call of CreateBucket.
+func (mr *MockAwsS3APIMockRecorder) CreateBucket(ctx, params any, optFns ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, optFns...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateBucket", reflect.TypeOf((*MockAwsS3API)(nil).CreateBucket), varargs...)
+}
+
+// DeleteBucket mocks base method.
+func (m *MockAwsS3API) DeleteBucket(ctx context.Context, params *s3.DeleteBucketInput, optFns ...func(*s3.Options)) (*s3.DeleteBucketOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range optFns {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteBucket", varargs...)
+	ret0, _ := ret[0].(*s3.DeleteBucketOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteBucket indicates an expected call of DeleteBucket.
+func (mr *MockAwsS3APIMockRecorder) DeleteBucket(ctx, params any, optFns ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, optFns...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteBucket", reflect.TypeOf((*MockAwsS3API)(nil).DeleteBucket), varargs...)
+}
+
+// DeleteObjects mocks base method.
+func (m *MockAwsS3API) DeleteObjects(ctx context.Context, params *s3.DeleteObjectsInput, optFns ...func(*s3.Options)) (*s3.DeleteObjectsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range optFns {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeleteObjects", varargs...)
+	ret0, _ := ret[0].(*s3.DeleteObjectsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteObjects indicates an expected call of DeleteObjects.
+func (mr *MockAwsS3APIMockRecorder) DeleteObjects(ctx, params any, optFns ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, optFns...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObjects", reflect.TypeOf((*MockAwsS3API)(nil).DeleteObjects), varargs...)
+}
+
+// DeletePublicAccessBlock mocks base method.
+func (m *MockAwsS3API) DeletePublicAccessBlock(ctx context.Context, params *s3.DeletePublicAccessBlockInput, optFns ...func(*s3.Options)) (*s3.DeletePublicAccessBlockOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range optFns {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "DeletePublicAccessBlock", varargs...)
+	ret0, _ := ret[0].(*s3.DeletePublicAccessBlockOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeletePublicAccessBlock indicates an expected call of DeletePublicAccessBlock.
+func (mr *MockAwsS3APIMockRecorder) DeletePublicAccessBlock(ctx, params any, optFns ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, optFns...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeletePublicAccessBlock", reflect.TypeOf((*MockAwsS3API)(nil).DeletePublicAccessBlock), varargs...)
+}
+
+// HeadObject mocks base method.
+func (m *MockAwsS3API) HeadObject(ctx context.Context, params *s3.HeadObjectInput, optFns ...func(*s3.Options)) (*s3.HeadObjectOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range optFns {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "HeadObject", varargs...)
+	ret0, _ := ret[0].(*s3.HeadObjectOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// HeadObject indicates an expected call of HeadObject.
+func (mr *MockAwsS3APIMockRecorder) HeadObject(ctx, params any, optFns ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, optFns...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HeadObject", reflect.TypeOf((*MockAwsS3API)(nil).HeadObject), varargs...)
+}
+
+// PutBucketOwnershipControls mocks base method.
+func (m *MockAwsS3API) PutBucketOwnershipControls(ctx context.Context, params *s3.PutBucketOwnershipControlsInput, optFns ...func(*s3.Options)) (*s3.PutBucketOwnershipControlsOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range optFns {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PutBucketOwnershipControls", varargs...)
+	ret0, _ := ret[0].(*s3.PutBucketOwnershipControlsOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PutBucketOwnershipControls indicates an expected call of PutBucketOwnershipControls.
+func (mr *MockAwsS3APIMockRecorder) PutBucketOwnershipControls(ctx, params any, optFns ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, optFns...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutBucketOwnershipControls", reflect.TypeOf((*MockAwsS3API)(nil).PutBucketOwnershipControls), varargs...)
+}
+
+// PutObject mocks base method.
+func (m *MockAwsS3API) PutObject(ctx context.Context, params *s3.PutObjectInput, optFns ...func(*s3.Options)) (*s3.PutObjectOutput, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, params}
+	for _, a := range optFns {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PutObject", varargs...)
+	ret0, _ := ret[0].(*s3.PutObjectOutput)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PutObject indicates an expected call of PutObject.
+func (mr *MockAwsS3APIMockRecorder) PutObject(ctx, params any, optFns ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, params}, optFns...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObject", reflect.TypeOf((*MockAwsS3API)(nil).PutObject), varargs...)
+}