From 977c294b93063a7f91d89609ae6911ea593db5d2 Mon Sep 17 00:00:00 2001 From: nolancon Date: Fri, 11 Sep 2026 11:36:46 +0000 Subject: [PATCH 1/3] Update generate tests script An earlier PR updated the generated files manually. The script itself fell behind. --- hack/generate-tests.sh | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/hack/generate-tests.sh b/hack/generate-tests.sh index 2c2cba85..3563a838 100755 --- a/hack/generate-tests.sh +++ b/hack/generate-tests.sh @@ -53,7 +53,9 @@ file=./.github/workflows/chainsaw-e2e-test-${major}.yaml ${HEADER} name: chainsaw e2e test ${major} on: - push: {} + push: + branches: + - main pull_request: {} concurrency: group: chainsaw-${major}-\${{ github.ref }}-1 From 1b9d24f88e6d4195f1625b9195c4e302c0f1933b Mon Sep 17 00:00:00 2001 From: nolancon Date: Fri, 11 Sep 2026 11:39:17 +0000 Subject: [PATCH 2/3] Update build module --- build | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/build b/build index 65819b05..38cdd2d9 160000 --- a/build +++ b/build @@ -1 +1 @@ -Subproject commit 65819b05239a0b22f1a98c3698a14acd22bc3cc0 +Subproject commit 38cdd2d9558259446cdf476a769e4c462fbc308f From 7332fe926e36073244d004639c570649bac015e5 Mon Sep 17 00:00:00 2001 From: nolancon Date: Fri, 11 Sep 2026 11:40:17 +0000 Subject: [PATCH 3/3] make generate-pkg --- go.mod | 18 +- go.sum | 36 +-- .../backendstorefakes/fake_s3client.go | 234 ++++++++++++++---- .../backendstorefakes/fake_stsclient.go | 9 +- 4 files changed, 216 insertions(+), 81 deletions(-) diff --git a/go.mod b/go.mod index 50dc21d3..248725c3 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/linode/provider-ceph -go 1.26 +go 1.26.0 toolchain go1.26.6 @@ -24,7 +24,7 @@ require ( go.opentelemetry.io/otel/sdk v1.46.0 go.opentelemetry.io/otel/trace v1.46.0 go.uber.org/zap v1.27.0 - golang.org/x/sync v0.22.0 + golang.org/x/sync v0.23.0 google.golang.org/grpc v1.83.2 k8s.io/api v0.33.0 k8s.io/apiextensions-apiserver v0.33.0 @@ -84,7 +84,7 @@ require ( github.com/modern-go/reflect2 v1.0.2 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/onsi/ginkgo/v2 v2.28.0 // indirect - github.com/onsi/gomega v1.39.1 // indirect + github.com/onsi/gomega v1.43.0 // indirect github.com/prometheus/client_golang v1.22.0 // indirect github.com/prometheus/client_model v0.6.1 // indirect github.com/prometheus/common v0.62.0 // indirect @@ -101,14 +101,14 @@ require ( go.uber.org/multierr v1.11.0 // indirect go.yaml.in/yaml/v3 v3.0.5 // indirect golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 // indirect - golang.org/x/mod v0.38.0 // indirect - golang.org/x/net v0.58.0 // indirect + golang.org/x/mod v0.41.0 // indirect + golang.org/x/net v0.59.0 // indirect golang.org/x/oauth2 v0.36.0 // indirect - golang.org/x/sys v0.47.0 // indirect - golang.org/x/term v0.45.0 // indirect - golang.org/x/text v0.41.0 // indirect + golang.org/x/sys v0.48.0 // indirect + golang.org/x/term v0.46.0 // indirect + golang.org/x/text v0.42.0 // indirect golang.org/x/time v0.9.0 // indirect - golang.org/x/tools v0.48.0 // indirect + golang.org/x/tools v0.50.0 // indirect golang.org/x/tools/go/packages/packagestest v0.1.1-deprecated // indirect gomodules.xyz/jsonpatch/v2 v2.4.0 // indirect google.golang.org/genproto/googleapis/api v0.0.0-20260526163538-3dc84a4a5aaa // indirect diff --git a/go.sum b/go.sum index 7f223a5c..9ea923d2 100644 --- a/go.sum +++ b/go.sum @@ -107,8 +107,8 @@ github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0= github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg= -github.com/google/pprof v0.0.0-20260115054156-294ebfa9ad83 h1:z2ogiKUYzX5Is6zr/vP9vJGqPwcdqsWjOt+V8J7+bTc= -github.com/google/pprof v0.0.0-20260115054156-294ebfa9ad83/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI= +github.com/google/pprof v0.0.0-20250403155104-27863c87afa6 h1:BHT72Gu3keYf3ZEu2J0b1vyeLSOYI8bm5wbJM/8yDe8= +github.com/google/pprof v0.0.0-20250403155104-27863c87afa6/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA= github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/grpc-ecosystem/grpc-gateway/v2 v2.27.7 h1:X+2YciYSxvMQK0UZ7sg45ZVabVZBeBuvMkmuI2V3Fak= @@ -152,8 +152,8 @@ github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= github.com/onsi/ginkgo/v2 v2.28.0 h1:Rrf+lVLmtlBIKv6KrIGJCjyY8N36vDVcutbGJkyqjJc= github.com/onsi/ginkgo/v2 v2.28.0/go.mod h1:ArE1D/XhNXBXCBkKOLkbsb2c81dQHCRcF5zwn/ykDRo= -github.com/onsi/gomega v1.39.1 h1:1IJLAad4zjPn2PsnhH70V4DKRFlrCzGBNrNaru+Vf28= -github.com/onsi/gomega v1.39.1/go.mod h1:hL6yVALoTOxeWudERyfppUcZXjMwIMLnuSfruD2lcfg= +github.com/onsi/gomega v1.43.0 h1:VlG/1FxqNxhSO+lq/OHBNaaqwiBK/mO8JbVkX9Y+FeU= +github.com/onsi/gomega v1.43.0/go.mod h1:REff/hsDsodHoKlWsP2mAPhu1+5/6hVYNf9rIEBpeSg= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= @@ -229,42 +229,42 @@ golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0 golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= -golang.org/x/mod v0.38.0 h1:MECBjubtXD7yj4HrhIUcywNaGeNVUdfVnxmPajOk4yk= -golang.org/x/mod v0.38.0/go.mod h1:V6Xz0pq8TQ3dGqVQ1FVHuelZpAL0uNhSkk9ogYP3c40= +golang.org/x/mod v0.41.0 h1:qJmnOUb4YB+FsEuM3HcWucdZASCPGhsX6uljO6pog0c= +golang.org/x/mod v0.41.0/go.mod h1:Ek9pY8RKWXwsWvd3rQiHYtMqkjSUV+s1Rj7j4H5Ur6o= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= -golang.org/x/net v0.58.0 h1:ynWG7rqYi4ccpTEuPZ2QGWHktVEM9DMCj9yzDE0Q7To= -golang.org/x/net v0.58.0/go.mod h1:YwCddHnFlT7eLQqVprV19OnhLGtc5xOKgE0RyqgfWAU= +golang.org/x/net v0.59.0 h1:5zfYln+w5XCxwrnMMJPufRgNoXEaGxl0wo5GqPXyues= +golang.org/x/net v0.59.0/go.mod h1:2DA/G1UfVbCpQPeWTmMPGY7Cs2PkBkwu743bVX5PIVg= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.22.0 h1:SZjpbeLmrCk4xhRSZFNZW5gFUeCeFgjekvI/+gfScek= -golang.org/x/sync v0.22.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= +golang.org/x/sync v0.23.0 h1:KameEIfc1IkluZyXWLn39Wd4tURc6GbCiISGiZm2bQk= +golang.org/x/sync v0.23.0/go.mod h1:sUUOizhqBxiL6pEWpqNLUiaJn1ShEbZ6BBqskPbjZm0= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.47.0 h1:o7XGOvZQCADBQQ4Y7VNq2dRWQR7JmOUW8Kxx4ZsNgWs= -golang.org/x/sys v0.47.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= -golang.org/x/term v0.45.0 h1:NwWyBmoJCbfTHpxrWoZ9C6/VxOf7ic219I8xZZFdrf0= -golang.org/x/term v0.45.0/go.mod h1:9aqxs0blBcrm/n0L9QW0aRVD+ktan8ssZromtqJC43w= +golang.org/x/sys v0.48.0 h1:bbX/i/6MgT9BVLM9RT1thmxL04yeTAhbEz4SyadbXoo= +golang.org/x/sys v0.48.0/go.mod h1:hNLxWAXmnKAxqDtdwIYC4bM9oQPEecfsnNMuSxOs3og= +golang.org/x/term v0.46.0 h1:3+OXuTbaKDgwk8jTi3aSLHRlmWqHEUDUtxnbFigO4YE= +golang.org/x/term v0.46.0/go.mod h1:+K02xbkittuwc0Am4abfA3Fc+XRGXkvBXNO88NCXPoc= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= -golang.org/x/text v0.41.0 h1:vz/seA0lnX87Othu2f/0L24RcgrXD9/YFTSuGjj3rH8= -golang.org/x/text v0.41.0/go.mod h1:jvf1O8ajNzZqhSrQBPbutR/EB83Cc0CFrezNQIwbb5M= +golang.org/x/text v0.42.0 h1:JbOZXgfeCPU9gacVtYliJqOhD+zhrEqK4LfdpmlUZqI= +golang.org/x/text v0.42.0/go.mod h1:ojzP1Z+2QtioaF8DTtO8K5q7JWVVYwZKenzujK0Zd0E= golang.org/x/time v0.9.0 h1:EsRrnYcQiGH+5FfbgvV4AP7qEZstoyrHB0DzarOQ4ZY= golang.org/x/time v0.9.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= -golang.org/x/tools v0.48.0 h1:3+hClM1aLL5mjMKm5ovokw9epgRXPuu2tILgismM6RE= -golang.org/x/tools v0.48.0/go.mod h1:08xX0orndb/F7jJxGDicx061tyd5pcMto75YMAXr6lk= +golang.org/x/tools v0.50.0 h1:c2ifzfcuY7L90lZ2aKd8S4K2NpASF08SZx9ZuJkHmSU= +golang.org/x/tools v0.50.0/go.mod h1:7ulVMw3831Mwi5EZD6RomGyffr4VFjuNYXf2BbCEAV0= golang.org/x/tools/go/expect v0.1.0-deprecated h1:jY2C5HGYR5lqex3gEniOQL0r7Dq5+VGVgY1nudX5lXY= golang.org/x/tools/go/expect v0.1.0-deprecated/go.mod h1:eihoPOH+FgIqa3FpoTwguz/bVUSGBlGQU67vpBeOrBY= golang.org/x/tools/go/packages/packagestest v0.1.1-deprecated h1:1h2MnaIAIXISqTFKdENegdpAgUXz6NrPEsbIeWaBRvM= diff --git a/internal/backendstore/backendstorefakes/fake_s3client.go b/internal/backendstore/backendstorefakes/fake_s3client.go index 6d58972f..741ceb5f 100644 --- a/internal/backendstore/backendstorefakes/fake_s3client.go +++ b/internal/backendstore/backendstorefakes/fake_s3client.go @@ -405,16 +405,21 @@ type FakeS3Client struct { } func (fake *FakeS3Client) CreateBucket(arg1 context.Context, arg2 *s3.CreateBucketInput, arg3 ...func(*s3.Options)) (*s3.CreateBucketOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.createBucketMutex.Lock() ret, specificReturn := fake.createBucketReturnsOnCall[len(fake.createBucketArgsForCall)] fake.createBucketArgsForCall = append(fake.createBucketArgsForCall, struct { arg1 context.Context arg2 *s3.CreateBucketInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.CreateBucketStub fakeReturns := fake.createBucketReturns - fake.recordInvocation("CreateBucket", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("CreateBucket", []interface{}{arg1, arg2, arg3Copy}) fake.createBucketMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -471,16 +476,21 @@ func (fake *FakeS3Client) CreateBucketReturnsOnCall(i int, result1 *s3.CreateBuc } func (fake *FakeS3Client) DeleteBucket(arg1 context.Context, arg2 *s3.DeleteBucketInput, arg3 ...func(*s3.Options)) (*s3.DeleteBucketOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.deleteBucketMutex.Lock() ret, specificReturn := fake.deleteBucketReturnsOnCall[len(fake.deleteBucketArgsForCall)] fake.deleteBucketArgsForCall = append(fake.deleteBucketArgsForCall, struct { arg1 context.Context arg2 *s3.DeleteBucketInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.DeleteBucketStub fakeReturns := fake.deleteBucketReturns - fake.recordInvocation("DeleteBucket", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("DeleteBucket", []interface{}{arg1, arg2, arg3Copy}) fake.deleteBucketMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -537,16 +547,21 @@ func (fake *FakeS3Client) DeleteBucketReturnsOnCall(i int, result1 *s3.DeleteBuc } func (fake *FakeS3Client) DeleteBucketCors(arg1 context.Context, arg2 *s3.DeleteBucketCorsInput, arg3 ...func(*s3.Options)) (*s3.DeleteBucketCorsOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.deleteBucketCorsMutex.Lock() ret, specificReturn := fake.deleteBucketCorsReturnsOnCall[len(fake.deleteBucketCorsArgsForCall)] fake.deleteBucketCorsArgsForCall = append(fake.deleteBucketCorsArgsForCall, struct { arg1 context.Context arg2 *s3.DeleteBucketCorsInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.DeleteBucketCorsStub fakeReturns := fake.deleteBucketCorsReturns - fake.recordInvocation("DeleteBucketCors", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("DeleteBucketCors", []interface{}{arg1, arg2, arg3Copy}) fake.deleteBucketCorsMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -603,16 +618,21 @@ func (fake *FakeS3Client) DeleteBucketCorsReturnsOnCall(i int, result1 *s3.Delet } func (fake *FakeS3Client) DeleteBucketEncryption(arg1 context.Context, arg2 *s3.DeleteBucketEncryptionInput, arg3 ...func(*s3.Options)) (*s3.DeleteBucketEncryptionOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.deleteBucketEncryptionMutex.Lock() ret, specificReturn := fake.deleteBucketEncryptionReturnsOnCall[len(fake.deleteBucketEncryptionArgsForCall)] fake.deleteBucketEncryptionArgsForCall = append(fake.deleteBucketEncryptionArgsForCall, struct { arg1 context.Context arg2 *s3.DeleteBucketEncryptionInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.DeleteBucketEncryptionStub fakeReturns := fake.deleteBucketEncryptionReturns - fake.recordInvocation("DeleteBucketEncryption", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("DeleteBucketEncryption", []interface{}{arg1, arg2, arg3Copy}) fake.deleteBucketEncryptionMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -669,16 +689,21 @@ func (fake *FakeS3Client) DeleteBucketEncryptionReturnsOnCall(i int, result1 *s3 } func (fake *FakeS3Client) DeleteBucketLifecycle(arg1 context.Context, arg2 *s3.DeleteBucketLifecycleInput, arg3 ...func(*s3.Options)) (*s3.DeleteBucketLifecycleOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.deleteBucketLifecycleMutex.Lock() ret, specificReturn := fake.deleteBucketLifecycleReturnsOnCall[len(fake.deleteBucketLifecycleArgsForCall)] fake.deleteBucketLifecycleArgsForCall = append(fake.deleteBucketLifecycleArgsForCall, struct { arg1 context.Context arg2 *s3.DeleteBucketLifecycleInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.DeleteBucketLifecycleStub fakeReturns := fake.deleteBucketLifecycleReturns - fake.recordInvocation("DeleteBucketLifecycle", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("DeleteBucketLifecycle", []interface{}{arg1, arg2, arg3Copy}) fake.deleteBucketLifecycleMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -735,16 +760,21 @@ func (fake *FakeS3Client) DeleteBucketLifecycleReturnsOnCall(i int, result1 *s3. } func (fake *FakeS3Client) DeleteBucketPolicy(arg1 context.Context, arg2 *s3.DeleteBucketPolicyInput, arg3 ...func(*s3.Options)) (*s3.DeleteBucketPolicyOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.deleteBucketPolicyMutex.Lock() ret, specificReturn := fake.deleteBucketPolicyReturnsOnCall[len(fake.deleteBucketPolicyArgsForCall)] fake.deleteBucketPolicyArgsForCall = append(fake.deleteBucketPolicyArgsForCall, struct { arg1 context.Context arg2 *s3.DeleteBucketPolicyInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.DeleteBucketPolicyStub fakeReturns := fake.deleteBucketPolicyReturns - fake.recordInvocation("DeleteBucketPolicy", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("DeleteBucketPolicy", []interface{}{arg1, arg2, arg3Copy}) fake.deleteBucketPolicyMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -801,16 +831,21 @@ func (fake *FakeS3Client) DeleteBucketPolicyReturnsOnCall(i int, result1 *s3.Del } func (fake *FakeS3Client) DeleteObject(arg1 context.Context, arg2 *s3.DeleteObjectInput, arg3 ...func(*s3.Options)) (*s3.DeleteObjectOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.deleteObjectMutex.Lock() ret, specificReturn := fake.deleteObjectReturnsOnCall[len(fake.deleteObjectArgsForCall)] fake.deleteObjectArgsForCall = append(fake.deleteObjectArgsForCall, struct { arg1 context.Context arg2 *s3.DeleteObjectInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.DeleteObjectStub fakeReturns := fake.deleteObjectReturns - fake.recordInvocation("DeleteObject", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("DeleteObject", []interface{}{arg1, arg2, arg3Copy}) fake.deleteObjectMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -867,16 +902,21 @@ func (fake *FakeS3Client) DeleteObjectReturnsOnCall(i int, result1 *s3.DeleteObj } func (fake *FakeS3Client) GetBucketAcl(arg1 context.Context, arg2 *s3.GetBucketAclInput, arg3 ...func(*s3.Options)) (*s3.GetBucketAclOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.getBucketAclMutex.Lock() ret, specificReturn := fake.getBucketAclReturnsOnCall[len(fake.getBucketAclArgsForCall)] fake.getBucketAclArgsForCall = append(fake.getBucketAclArgsForCall, struct { arg1 context.Context arg2 *s3.GetBucketAclInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.GetBucketAclStub fakeReturns := fake.getBucketAclReturns - fake.recordInvocation("GetBucketAcl", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("GetBucketAcl", []interface{}{arg1, arg2, arg3Copy}) fake.getBucketAclMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -933,16 +973,21 @@ func (fake *FakeS3Client) GetBucketAclReturnsOnCall(i int, result1 *s3.GetBucket } func (fake *FakeS3Client) GetBucketCors(arg1 context.Context, arg2 *s3.GetBucketCorsInput, arg3 ...func(*s3.Options)) (*s3.GetBucketCorsOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.getBucketCorsMutex.Lock() ret, specificReturn := fake.getBucketCorsReturnsOnCall[len(fake.getBucketCorsArgsForCall)] fake.getBucketCorsArgsForCall = append(fake.getBucketCorsArgsForCall, struct { arg1 context.Context arg2 *s3.GetBucketCorsInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.GetBucketCorsStub fakeReturns := fake.getBucketCorsReturns - fake.recordInvocation("GetBucketCors", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("GetBucketCors", []interface{}{arg1, arg2, arg3Copy}) fake.getBucketCorsMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -999,16 +1044,21 @@ func (fake *FakeS3Client) GetBucketCorsReturnsOnCall(i int, result1 *s3.GetBucke } func (fake *FakeS3Client) GetBucketEncryption(arg1 context.Context, arg2 *s3.GetBucketEncryptionInput, arg3 ...func(*s3.Options)) (*s3.GetBucketEncryptionOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.getBucketEncryptionMutex.Lock() ret, specificReturn := fake.getBucketEncryptionReturnsOnCall[len(fake.getBucketEncryptionArgsForCall)] fake.getBucketEncryptionArgsForCall = append(fake.getBucketEncryptionArgsForCall, struct { arg1 context.Context arg2 *s3.GetBucketEncryptionInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.GetBucketEncryptionStub fakeReturns := fake.getBucketEncryptionReturns - fake.recordInvocation("GetBucketEncryption", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("GetBucketEncryption", []interface{}{arg1, arg2, arg3Copy}) fake.getBucketEncryptionMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1065,16 +1115,21 @@ func (fake *FakeS3Client) GetBucketEncryptionReturnsOnCall(i int, result1 *s3.Ge } func (fake *FakeS3Client) GetBucketLifecycleConfiguration(arg1 context.Context, arg2 *s3.GetBucketLifecycleConfigurationInput, arg3 ...func(*s3.Options)) (*s3.GetBucketLifecycleConfigurationOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.getBucketLifecycleConfigurationMutex.Lock() ret, specificReturn := fake.getBucketLifecycleConfigurationReturnsOnCall[len(fake.getBucketLifecycleConfigurationArgsForCall)] fake.getBucketLifecycleConfigurationArgsForCall = append(fake.getBucketLifecycleConfigurationArgsForCall, struct { arg1 context.Context arg2 *s3.GetBucketLifecycleConfigurationInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.GetBucketLifecycleConfigurationStub fakeReturns := fake.getBucketLifecycleConfigurationReturns - fake.recordInvocation("GetBucketLifecycleConfiguration", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("GetBucketLifecycleConfiguration", []interface{}{arg1, arg2, arg3Copy}) fake.getBucketLifecycleConfigurationMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1131,16 +1186,21 @@ func (fake *FakeS3Client) GetBucketLifecycleConfigurationReturnsOnCall(i int, re } func (fake *FakeS3Client) GetBucketPolicy(arg1 context.Context, arg2 *s3.GetBucketPolicyInput, arg3 ...func(*s3.Options)) (*s3.GetBucketPolicyOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.getBucketPolicyMutex.Lock() ret, specificReturn := fake.getBucketPolicyReturnsOnCall[len(fake.getBucketPolicyArgsForCall)] fake.getBucketPolicyArgsForCall = append(fake.getBucketPolicyArgsForCall, struct { arg1 context.Context arg2 *s3.GetBucketPolicyInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.GetBucketPolicyStub fakeReturns := fake.getBucketPolicyReturns - fake.recordInvocation("GetBucketPolicy", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("GetBucketPolicy", []interface{}{arg1, arg2, arg3Copy}) fake.getBucketPolicyMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1197,16 +1257,21 @@ func (fake *FakeS3Client) GetBucketPolicyReturnsOnCall(i int, result1 *s3.GetBuc } func (fake *FakeS3Client) GetBucketVersioning(arg1 context.Context, arg2 *s3.GetBucketVersioningInput, arg3 ...func(*s3.Options)) (*s3.GetBucketVersioningOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.getBucketVersioningMutex.Lock() ret, specificReturn := fake.getBucketVersioningReturnsOnCall[len(fake.getBucketVersioningArgsForCall)] fake.getBucketVersioningArgsForCall = append(fake.getBucketVersioningArgsForCall, struct { arg1 context.Context arg2 *s3.GetBucketVersioningInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.GetBucketVersioningStub fakeReturns := fake.getBucketVersioningReturns - fake.recordInvocation("GetBucketVersioning", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("GetBucketVersioning", []interface{}{arg1, arg2, arg3Copy}) fake.getBucketVersioningMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1263,16 +1328,21 @@ func (fake *FakeS3Client) GetBucketVersioningReturnsOnCall(i int, result1 *s3.Ge } func (fake *FakeS3Client) GetObject(arg1 context.Context, arg2 *s3.GetObjectInput, arg3 ...func(*s3.Options)) (*s3.GetObjectOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.getObjectMutex.Lock() ret, specificReturn := fake.getObjectReturnsOnCall[len(fake.getObjectArgsForCall)] fake.getObjectArgsForCall = append(fake.getObjectArgsForCall, struct { arg1 context.Context arg2 *s3.GetObjectInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.GetObjectStub fakeReturns := fake.getObjectReturns - fake.recordInvocation("GetObject", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("GetObject", []interface{}{arg1, arg2, arg3Copy}) fake.getObjectMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1329,16 +1399,21 @@ func (fake *FakeS3Client) GetObjectReturnsOnCall(i int, result1 *s3.GetObjectOut } func (fake *FakeS3Client) GetObjectLockConfiguration(arg1 context.Context, arg2 *s3.GetObjectLockConfigurationInput, arg3 ...func(*s3.Options)) (*s3.GetObjectLockConfigurationOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.getObjectLockConfigurationMutex.Lock() ret, specificReturn := fake.getObjectLockConfigurationReturnsOnCall[len(fake.getObjectLockConfigurationArgsForCall)] fake.getObjectLockConfigurationArgsForCall = append(fake.getObjectLockConfigurationArgsForCall, struct { arg1 context.Context arg2 *s3.GetObjectLockConfigurationInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.GetObjectLockConfigurationStub fakeReturns := fake.getObjectLockConfigurationReturns - fake.recordInvocation("GetObjectLockConfiguration", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("GetObjectLockConfiguration", []interface{}{arg1, arg2, arg3Copy}) fake.getObjectLockConfigurationMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1395,16 +1470,21 @@ func (fake *FakeS3Client) GetObjectLockConfigurationReturnsOnCall(i int, result1 } func (fake *FakeS3Client) HeadBucket(arg1 context.Context, arg2 *s3.HeadBucketInput, arg3 ...func(*s3.Options)) (*s3.HeadBucketOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.headBucketMutex.Lock() ret, specificReturn := fake.headBucketReturnsOnCall[len(fake.headBucketArgsForCall)] fake.headBucketArgsForCall = append(fake.headBucketArgsForCall, struct { arg1 context.Context arg2 *s3.HeadBucketInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.HeadBucketStub fakeReturns := fake.headBucketReturns - fake.recordInvocation("HeadBucket", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("HeadBucket", []interface{}{arg1, arg2, arg3Copy}) fake.headBucketMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1461,16 +1541,21 @@ func (fake *FakeS3Client) HeadBucketReturnsOnCall(i int, result1 *s3.HeadBucketO } func (fake *FakeS3Client) ListObjectVersions(arg1 context.Context, arg2 *s3.ListObjectVersionsInput, arg3 ...func(*s3.Options)) (*s3.ListObjectVersionsOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.listObjectVersionsMutex.Lock() ret, specificReturn := fake.listObjectVersionsReturnsOnCall[len(fake.listObjectVersionsArgsForCall)] fake.listObjectVersionsArgsForCall = append(fake.listObjectVersionsArgsForCall, struct { arg1 context.Context arg2 *s3.ListObjectVersionsInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.ListObjectVersionsStub fakeReturns := fake.listObjectVersionsReturns - fake.recordInvocation("ListObjectVersions", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("ListObjectVersions", []interface{}{arg1, arg2, arg3Copy}) fake.listObjectVersionsMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1527,16 +1612,21 @@ func (fake *FakeS3Client) ListObjectVersionsReturnsOnCall(i int, result1 *s3.Lis } func (fake *FakeS3Client) ListObjectsV2(arg1 context.Context, arg2 *s3.ListObjectsV2Input, arg3 ...func(*s3.Options)) (*s3.ListObjectsV2Output, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.listObjectsV2Mutex.Lock() ret, specificReturn := fake.listObjectsV2ReturnsOnCall[len(fake.listObjectsV2ArgsForCall)] fake.listObjectsV2ArgsForCall = append(fake.listObjectsV2ArgsForCall, struct { arg1 context.Context arg2 *s3.ListObjectsV2Input arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.ListObjectsV2Stub fakeReturns := fake.listObjectsV2Returns - fake.recordInvocation("ListObjectsV2", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("ListObjectsV2", []interface{}{arg1, arg2, arg3Copy}) fake.listObjectsV2Mutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1593,16 +1683,21 @@ func (fake *FakeS3Client) ListObjectsV2ReturnsOnCall(i int, result1 *s3.ListObje } func (fake *FakeS3Client) PutBucketAcl(arg1 context.Context, arg2 *s3.PutBucketAclInput, arg3 ...func(*s3.Options)) (*s3.PutBucketAclOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.putBucketAclMutex.Lock() ret, specificReturn := fake.putBucketAclReturnsOnCall[len(fake.putBucketAclArgsForCall)] fake.putBucketAclArgsForCall = append(fake.putBucketAclArgsForCall, struct { arg1 context.Context arg2 *s3.PutBucketAclInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.PutBucketAclStub fakeReturns := fake.putBucketAclReturns - fake.recordInvocation("PutBucketAcl", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("PutBucketAcl", []interface{}{arg1, arg2, arg3Copy}) fake.putBucketAclMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1659,16 +1754,21 @@ func (fake *FakeS3Client) PutBucketAclReturnsOnCall(i int, result1 *s3.PutBucket } func (fake *FakeS3Client) PutBucketCors(arg1 context.Context, arg2 *s3.PutBucketCorsInput, arg3 ...func(*s3.Options)) (*s3.PutBucketCorsOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.putBucketCorsMutex.Lock() ret, specificReturn := fake.putBucketCorsReturnsOnCall[len(fake.putBucketCorsArgsForCall)] fake.putBucketCorsArgsForCall = append(fake.putBucketCorsArgsForCall, struct { arg1 context.Context arg2 *s3.PutBucketCorsInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.PutBucketCorsStub fakeReturns := fake.putBucketCorsReturns - fake.recordInvocation("PutBucketCors", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("PutBucketCors", []interface{}{arg1, arg2, arg3Copy}) fake.putBucketCorsMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1725,16 +1825,21 @@ func (fake *FakeS3Client) PutBucketCorsReturnsOnCall(i int, result1 *s3.PutBucke } func (fake *FakeS3Client) PutBucketEncryption(arg1 context.Context, arg2 *s3.PutBucketEncryptionInput, arg3 ...func(*s3.Options)) (*s3.PutBucketEncryptionOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.putBucketEncryptionMutex.Lock() ret, specificReturn := fake.putBucketEncryptionReturnsOnCall[len(fake.putBucketEncryptionArgsForCall)] fake.putBucketEncryptionArgsForCall = append(fake.putBucketEncryptionArgsForCall, struct { arg1 context.Context arg2 *s3.PutBucketEncryptionInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.PutBucketEncryptionStub fakeReturns := fake.putBucketEncryptionReturns - fake.recordInvocation("PutBucketEncryption", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("PutBucketEncryption", []interface{}{arg1, arg2, arg3Copy}) fake.putBucketEncryptionMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1791,16 +1896,21 @@ func (fake *FakeS3Client) PutBucketEncryptionReturnsOnCall(i int, result1 *s3.Pu } func (fake *FakeS3Client) PutBucketLifecycleConfiguration(arg1 context.Context, arg2 *s3.PutBucketLifecycleConfigurationInput, arg3 ...func(*s3.Options)) (*s3.PutBucketLifecycleConfigurationOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.putBucketLifecycleConfigurationMutex.Lock() ret, specificReturn := fake.putBucketLifecycleConfigurationReturnsOnCall[len(fake.putBucketLifecycleConfigurationArgsForCall)] fake.putBucketLifecycleConfigurationArgsForCall = append(fake.putBucketLifecycleConfigurationArgsForCall, struct { arg1 context.Context arg2 *s3.PutBucketLifecycleConfigurationInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.PutBucketLifecycleConfigurationStub fakeReturns := fake.putBucketLifecycleConfigurationReturns - fake.recordInvocation("PutBucketLifecycleConfiguration", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("PutBucketLifecycleConfiguration", []interface{}{arg1, arg2, arg3Copy}) fake.putBucketLifecycleConfigurationMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1857,16 +1967,21 @@ func (fake *FakeS3Client) PutBucketLifecycleConfigurationReturnsOnCall(i int, re } func (fake *FakeS3Client) PutBucketPolicy(arg1 context.Context, arg2 *s3.PutBucketPolicyInput, arg3 ...func(*s3.Options)) (*s3.PutBucketPolicyOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.putBucketPolicyMutex.Lock() ret, specificReturn := fake.putBucketPolicyReturnsOnCall[len(fake.putBucketPolicyArgsForCall)] fake.putBucketPolicyArgsForCall = append(fake.putBucketPolicyArgsForCall, struct { arg1 context.Context arg2 *s3.PutBucketPolicyInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.PutBucketPolicyStub fakeReturns := fake.putBucketPolicyReturns - fake.recordInvocation("PutBucketPolicy", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("PutBucketPolicy", []interface{}{arg1, arg2, arg3Copy}) fake.putBucketPolicyMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1923,16 +2038,21 @@ func (fake *FakeS3Client) PutBucketPolicyReturnsOnCall(i int, result1 *s3.PutBuc } func (fake *FakeS3Client) PutBucketVersioning(arg1 context.Context, arg2 *s3.PutBucketVersioningInput, arg3 ...func(*s3.Options)) (*s3.PutBucketVersioningOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.putBucketVersioningMutex.Lock() ret, specificReturn := fake.putBucketVersioningReturnsOnCall[len(fake.putBucketVersioningArgsForCall)] fake.putBucketVersioningArgsForCall = append(fake.putBucketVersioningArgsForCall, struct { arg1 context.Context arg2 *s3.PutBucketVersioningInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.PutBucketVersioningStub fakeReturns := fake.putBucketVersioningReturns - fake.recordInvocation("PutBucketVersioning", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("PutBucketVersioning", []interface{}{arg1, arg2, arg3Copy}) fake.putBucketVersioningMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -1989,16 +2109,21 @@ func (fake *FakeS3Client) PutBucketVersioningReturnsOnCall(i int, result1 *s3.Pu } func (fake *FakeS3Client) PutObject(arg1 context.Context, arg2 *s3.PutObjectInput, arg3 ...func(*s3.Options)) (*s3.PutObjectOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.putObjectMutex.Lock() ret, specificReturn := fake.putObjectReturnsOnCall[len(fake.putObjectArgsForCall)] fake.putObjectArgsForCall = append(fake.putObjectArgsForCall, struct { arg1 context.Context arg2 *s3.PutObjectInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.PutObjectStub fakeReturns := fake.putObjectReturns - fake.recordInvocation("PutObject", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("PutObject", []interface{}{arg1, arg2, arg3Copy}) fake.putObjectMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) @@ -2055,16 +2180,21 @@ func (fake *FakeS3Client) PutObjectReturnsOnCall(i int, result1 *s3.PutObjectOut } func (fake *FakeS3Client) PutObjectLockConfiguration(arg1 context.Context, arg2 *s3.PutObjectLockConfigurationInput, arg3 ...func(*s3.Options)) (*s3.PutObjectLockConfigurationOutput, error) { + var arg3Copy []func(*s3.Options) + if arg3 != nil { + arg3Copy = make([]func(*s3.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.putObjectLockConfigurationMutex.Lock() ret, specificReturn := fake.putObjectLockConfigurationReturnsOnCall[len(fake.putObjectLockConfigurationArgsForCall)] fake.putObjectLockConfigurationArgsForCall = append(fake.putObjectLockConfigurationArgsForCall, struct { arg1 context.Context arg2 *s3.PutObjectLockConfigurationInput arg3 []func(*s3.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.PutObjectLockConfigurationStub fakeReturns := fake.putObjectLockConfigurationReturns - fake.recordInvocation("PutObjectLockConfiguration", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("PutObjectLockConfiguration", []interface{}{arg1, arg2, arg3Copy}) fake.putObjectLockConfigurationMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) diff --git a/internal/backendstore/backendstorefakes/fake_stsclient.go b/internal/backendstore/backendstorefakes/fake_stsclient.go index fa214d10..eede1e16 100644 --- a/internal/backendstore/backendstorefakes/fake_stsclient.go +++ b/internal/backendstore/backendstorefakes/fake_stsclient.go @@ -30,16 +30,21 @@ type FakeSTSClient struct { } func (fake *FakeSTSClient) AssumeRole(arg1 context.Context, arg2 *sts.AssumeRoleInput, arg3 ...func(*sts.Options)) (*sts.AssumeRoleOutput, error) { + var arg3Copy []func(*sts.Options) + if arg3 != nil { + arg3Copy = make([]func(*sts.Options), len(arg3)) + copy(arg3Copy, arg3) + } fake.assumeRoleMutex.Lock() ret, specificReturn := fake.assumeRoleReturnsOnCall[len(fake.assumeRoleArgsForCall)] fake.assumeRoleArgsForCall = append(fake.assumeRoleArgsForCall, struct { arg1 context.Context arg2 *sts.AssumeRoleInput arg3 []func(*sts.Options) - }{arg1, arg2, arg3}) + }{arg1, arg2, arg3Copy}) stub := fake.AssumeRoleStub fakeReturns := fake.assumeRoleReturns - fake.recordInvocation("AssumeRole", []interface{}{arg1, arg2, arg3}) + fake.recordInvocation("AssumeRole", []interface{}{arg1, arg2, arg3Copy}) fake.assumeRoleMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...)