From 6350eb7a2ff312880c015409eb853d62bdd97192 Mon Sep 17 00:00:00 2001 From: kkb0318 Date: Thu, 18 Apr 2024 23:27:41 +0900 Subject: [PATCH] mockgen --- Makefile | 10 ++ go.mod | 3 +- go.sum | 2 + internal/client/aws.go | 73 ++-------- internal/client/client.go | 59 ++++++++ internal/mock/aws_mock.go | 289 ++++++++++++++++++++++++++++++++++++++ 6 files changed, 374 insertions(+), 62 deletions(-) create mode 100644 internal/client/client.go create mode 100644 internal/mock/aws_mock.go diff --git a/Makefile b/Makefile index a92f76f..345ce17 100644 --- a/Makefile +++ b/Makefile @@ -48,6 +48,7 @@ HELM_DOCS ?= $(LOCALBIN)/helm-docs ENVTEST ?= $(LOCALBIN)/setup-envtest HELMIFY ?= $(LOCALBIN)/helmify CRD_REF_DOCS ?= $(LOCALBIN)/crd-ref-docs +MOCKGEN ?= $(LOCALBIN)/mockgen ## Tool Versions KUSTOMIZE_VERSION ?= v5.2.1 @@ -73,6 +74,10 @@ helm: manifests kustomize helmify $(KUSTOMIZE) build config/release | $(HELMIFY) -crd-dir charts/irsa-manager +.PHONY: mock +mock: mockgen + $(MOCKGEN) -source internal/client/aws.go -destination internal/mock/aws_mock.go -package mock + .PHONY: manifests manifests: controller-gen ## Generate WebhookConfiguration, ClusterRole and CustomResourceDefinition objects. @@ -176,6 +181,11 @@ $(CONTROLLER_GEN): $(LOCALBIN) test -s $(LOCALBIN)/controller-gen && $(LOCALBIN)/controller-gen --version | grep -q $(CONTROLLER_TOOLS_VERSION) || \ GOBIN=$(LOCALBIN) go install sigs.k8s.io/controller-tools/cmd/controller-gen@$(CONTROLLER_TOOLS_VERSION) +.PHONY: mockgen +mockgen: $(MOCKGEN) +$(MOCKGEN): $(LOCALBIN) + test -s $(LOCALBIN)/mockgen || GOBIN=$(LOCALBIN) go install go.uber.org/mock/mockgen@latest + .PHONY: envtest envtest: $(ENVTEST) ## Download envtest-setup locally if necessary. $(ENVTEST): $(LOCALBIN) diff --git a/go.mod b/go.mod index 3bd3055..8b283ea 100644 --- a/go.mod +++ b/go.mod @@ -9,12 +9,14 @@ require ( github.com/aws/aws-sdk-go-v2/config v1.27.11 github.com/aws/aws-sdk-go-v2/service/iam v1.32.0 github.com/aws/aws-sdk-go-v2/service/s3 v1.53.1 + github.com/aws/aws-sdk-go-v2/service/sts v1.28.6 github.com/aws/smithy-go v1.20.2 github.com/fluxcd/pkg/apis/meta v1.4.0 github.com/go-jose/go-jose/v4 v4.0.1 github.com/onsi/ginkgo/v2 v2.17.1 github.com/onsi/gomega v1.30.0 github.com/stretchr/testify v1.9.0 + go.uber.org/mock v0.4.0 k8s.io/api v0.29.3 k8s.io/apimachinery v0.29.3 k8s.io/client-go v0.29.3 @@ -35,7 +37,6 @@ require ( github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.17.5 // indirect github.com/aws/aws-sdk-go-v2/service/sso v1.20.5 // indirect github.com/aws/aws-sdk-go-v2/service/ssooidc v1.23.4 // indirect - github.com/aws/aws-sdk-go-v2/service/sts v1.28.6 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/davecgh/go-spew v1.1.1 // indirect diff --git a/go.sum b/go.sum index 7527925..7bc1ca9 100644 --- a/go.sum +++ b/go.sum @@ -135,6 +135,8 @@ github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9de github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= +go.uber.org/mock v0.4.0 h1:VcM4ZOtdbR4f6VXfiOpwpVJDL6lCReaZ6mw31wqh7KU= +go.uber.org/mock v0.4.0/go.mod h1:a6FSlNadKUHUa9IP5Vyt1zh4fC7uAwxMutEAscFbkZc= go.uber.org/multierr v1.11.0 h1:blXXJkSxSSfBVBlC76pxqeO+LN3aDfLQo+309xJstO0= go.uber.org/multierr v1.11.0/go.mod h1:20+QtiLqy0Nd6FdQB9TLXag12DsQkrbs3htMFfDN80Y= go.uber.org/zap v1.27.0 h1:aJMhYGrd5QSmlpLMr2MftRKl7t8J8PTZPA732ud/XR8= diff --git a/internal/client/aws.go b/internal/client/aws.go index e376676..118fa6e 100644 --- a/internal/client/aws.go +++ b/internal/client/aws.go @@ -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 diff --git a/internal/client/client.go b/internal/client/client.go new file mode 100644 index 0000000..ad19799 --- /dev/null +++ b/internal/client/client.go @@ -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, + } +} diff --git a/internal/mock/aws_mock.go b/internal/mock/aws_mock.go new file mode 100644 index 0000000..0e656e5 --- /dev/null +++ b/internal/mock/aws_mock.go @@ -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...) +}