diff --git a/internal/client/aws.go b/internal/client/aws.go index 89a814e..2ce8ba6 100644 --- a/internal/client/aws.go +++ b/internal/client/aws.go @@ -17,6 +17,17 @@ type AwsClientFactory struct { config aws.Config } +type AwsIamAPI interface { + CreateOpenIDConnectProvider(ctx context.Context, params *iam.CreateOpenIDConnectProviderInput, optFns ...func(*iam.Options)) (*iam.CreateOpenIDConnectProviderOutput, error) +} + +type AwsS3API interface { + CreateBucket(ctx context.Context, params *s3.CreateBucketInput, optFns ...func(*s3.Options)) (*s3.CreateBucketOutput, error) + PutObject(ctx context.Context, params *s3.PutObjectInput, optFns ...func(*s3.Options)) (*s3.PutObjectOutput, error) + DeletePublicAccessBlock(ctx context.Context, params *s3.DeletePublicAccessBlockInput, optFns ...func(*s3.Options)) (*s3.DeletePublicAccessBlockOutput, error) + PutBucketOwnershipControls(ctx context.Context, params *s3.PutBucketOwnershipControlsInput, optFns ...func(*s3.Options)) (*s3.PutBucketOwnershipControlsOutput, error) +} + type AwsClient interface { IamCient() *AwsIamClient S3Cient(region, bucketName string) *AwsS3Client @@ -47,13 +58,13 @@ func (a *AwsClientFactory) S3Cient(bucketName, region string) *AwsS3Client { } type AwsS3Client struct { - client *s3.Client + AwsS3API region string bucketName string } func (a *AwsS3Client) PutObjectPublic(ctx context.Context, key string, body []byte) error { - _, err := a.client.PutObject(ctx, &s3.PutObjectInput{ + _, err := a.PutObject(ctx, &s3.PutObjectInput{ Bucket: aws.String(a.bucketName), Key: aws.String(key), ACL: types.ObjectCannedACLPublicRead, @@ -65,7 +76,7 @@ func (a *AwsS3Client) PutObjectPublic(ctx context.Context, key string, body []by func (a *AwsS3Client) CreateBucketPublic(ctx context.Context) error { bucket := aws.String(a.bucketName) - _, err := a.client.CreateBucket(ctx, &s3.CreateBucketInput{ + _, err := a.CreateBucket(ctx, &s3.CreateBucketInput{ Bucket: bucket, CreateBucketConfiguration: &types.CreateBucketConfiguration{ LocationConstraint: types.BucketLocationConstraint(a.Region()), @@ -74,11 +85,11 @@ func (a *AwsS3Client) CreateBucketPublic(ctx context.Context) error { if err != nil { return err } - _, err = a.client.DeletePublicAccessBlock(ctx, &s3.DeletePublicAccessBlockInput{Bucket: bucket}) + _, err = a.DeletePublicAccessBlock(ctx, &s3.DeletePublicAccessBlockInput{Bucket: bucket}) if err != nil { return err } - _, err = a.client.PutBucketOwnershipControls(ctx, &s3.PutBucketOwnershipControlsInput{ + _, err = a.PutBucketOwnershipControls(ctx, &s3.PutBucketOwnershipControlsInput{ Bucket: bucket, OwnershipControls: &types.OwnershipControls{ Rules: []types.OwnershipControlsRule{ @@ -103,11 +114,11 @@ func (a *AwsS3Client) Region() string { } type AwsIamClient struct { - client *iam.Client + AwsIamAPI } func (a *AwsIamClient) CreateOIDCProvider(ctx context.Context, providerUrl string) (string, error) { - result, err := a.client.CreateOpenIDConnectProvider(ctx, &iam.CreateOpenIDConnectProviderInput{ + result, err := a.CreateOpenIDConnectProvider(ctx, &iam.CreateOpenIDConnectProviderInput{ Url: &providerUrl, ClientIDList: []string{"sts.amazonaws.com"}, ThumbprintList: []string{ diff --git a/internal/mock/aws_mock.go b/internal/mock/aws_mock.go new file mode 100644 index 0000000..84f4d71 --- /dev/null +++ b/internal/mock/aws_mock.go @@ -0,0 +1,217 @@ +// 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" + client "github.com/kkb0318/irsa-manager/internal/client" + 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...) +} + +// 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...) +} + +// 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...) +} + +// 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...) +} + +// MockAwsClient is a mock of AwsClient interface. +type MockAwsClient struct { + ctrl *gomock.Controller + recorder *MockAwsClientMockRecorder +} + +// MockAwsClientMockRecorder is the mock recorder for MockAwsClient. +type MockAwsClientMockRecorder struct { + mock *MockAwsClient +} + +// NewMockAwsClient creates a new mock instance. +func NewMockAwsClient(ctrl *gomock.Controller) *MockAwsClient { + mock := &MockAwsClient{ctrl: ctrl} + mock.recorder = &MockAwsClientMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockAwsClient) EXPECT() *MockAwsClientMockRecorder { + return m.recorder +} + +// IamCient mocks base method. +func (m *MockAwsClient) IamCient() *client.AwsIamClient { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IamCient") + ret0, _ := ret[0].(*client.AwsIamClient) + return ret0 +} + +// IamCient indicates an expected call of IamCient. +func (mr *MockAwsClientMockRecorder) IamCient() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IamCient", reflect.TypeOf((*MockAwsClient)(nil).IamCient)) +} + +// S3Cient mocks base method. +func (m *MockAwsClient) S3Cient(region, bucketName string) *client.AwsS3Client { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "S3Cient", region, bucketName) + ret0, _ := ret[0].(*client.AwsS3Client) + return ret0 +} + +// S3Cient indicates an expected call of S3Cient. +func (mr *MockAwsClientMockRecorder) S3Cient(region, bucketName any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "S3Cient", reflect.TypeOf((*MockAwsClient)(nil).S3Cient), region, bucketName) +}