From 45f09ac6cdabe780bf5160c370dfd8d77b8945f5 Mon Sep 17 00:00:00 2001 From: Taylor Brennan Date: Wed, 14 Jun 2023 17:08:46 -0400 Subject: [PATCH 01/27] [CF-111] add wal monitor to export sqlite metrics --- pkg/cmd/ctlstore/main.go | 48 +++++------- pkg/ledger/ledger_monitor.go | 4 +- pkg/reflector/wal_monitor_test.go | 119 +++++------------------------- 3 files changed, 40 insertions(+), 131 deletions(-) diff --git a/pkg/cmd/ctlstore/main.go b/pkg/cmd/ctlstore/main.go index 8a09a0a2..2c70db0e 100644 --- a/pkg/cmd/ctlstore/main.go +++ b/pkg/cmd/ctlstore/main.go @@ -23,7 +23,6 @@ import ( "github.com/segmentio/ctlstore/pkg/errs" executivepkg "github.com/segmentio/ctlstore/pkg/executive" heartbeatpkg "github.com/segmentio/ctlstore/pkg/heartbeat" - "github.com/segmentio/ctlstore/pkg/ldbwriter" "github.com/segmentio/ctlstore/pkg/ledger" reflectorpkg "github.com/segmentio/ctlstore/pkg/reflector" sidecarpkg "github.com/segmentio/ctlstore/pkg/sidecar" @@ -47,25 +46,22 @@ type sidecarConfig struct { } type reflectorCliConfig struct { - LDBPath string `conf:"ldb-path" help:"Path to LDB file" validate:"nonzero"` - ChangelogPath string `conf:"changelog-path" help:"Path to changelog file"` - ChangelogSize int `conf:"changelog-size" help:"Maximum size of the changelog file"` - UpstreamDriver string `conf:"upstream-driver" help:"Upstream driver name (e.g. sqlite3)" validate:"nonzero"` - UpstreamDSN string `conf:"upstream-dsn" help:"Upstream DSN (e.g. path to file if sqlite3)" validate:"nonzero"` - UpstreamLedgerTable string `conf:"upstream-ledger-table" help:"Table on the upstream to look for statement ledger"` - BootstrapURL string `conf:"bootstrap-url" help:"Bootstraps LDB from an S3 URL"` - BootstrapRegion string `conf:"bootstrap-region" help:"If specified, indicates which region in which the S3 bucket lives"` - PollInterval time.Duration `conf:"poll-interval" help:"How often to pull the upstream" validate:"nonzero"` - PollJitterCoefficient float64 `conf:"poll-jitter-coefficient" help:"Coefficient for poll jittering"` - QueryBlockSize int `conf:"query-block-size" help:"Number of ledger entries to get at once"` - Debug bool `conf:"debug" help:"Turns on debug logging"` - LedgerHealth ledgerHealthConfig `conf:"ledger-latency" help:"Configure ledger latency behavior"` - Dogstatsd dogstatsdConfig `conf:"dogstatsd" help:"dogstatsd Configuration"` - MetricsBind string `conf:"metrics-bind" help:"address to serve Prometheus metircs"` - WALPollInterval time.Duration `conf:"wal-poll-interval" help:"How often to pull the sqlite's wal size and status. 0 indicates disabled monitoring'"` - WALCheckpointThresholdSize int `conf:"wal-checkpoint-threshold-size" help:"Performs a checkpoint after the WAL file exceeds this size in bytes"` - WALCheckpointType ldbwriter.CheckpointType `conf:"wal-checkpoint-type" help:"what type of checkpoint to manually perform once the wal size is exceeded"` - BusyTimeoutMS int `conf:"busy-timeout-ms" help:"Set a busy timeout on the connection string for sqlite in milliseconds"` + LDBPath string `conf:"ldb-path" help:"Path to LDB file" validate:"nonzero"` + ChangelogPath string `conf:"changelog-path" help:"Path to changelog file"` + ChangelogSize int `conf:"changelog-size" help:"Maximum size of the changelog file"` + UpstreamDriver string `conf:"upstream-driver" help:"Upstream driver name (e.g. sqlite3)" validate:"nonzero"` + UpstreamDSN string `conf:"upstream-dsn" help:"Upstream DSN (e.g. path to file if sqlite3)" validate:"nonzero"` + UpstreamLedgerTable string `conf:"upstream-ledger-table" help:"Table on the upstream to look for statement ledger"` + BootstrapURL string `conf:"bootstrap-url" help:"Bootstraps LDB from an S3 URL"` + BootstrapRegion string `conf:"bootstrap-region" help:"If specified, indicates which region in which the S3 bucket lives"` + PollInterval time.Duration `conf:"poll-interval" help:"How often to pull the upstream" validate:"nonzero"` + PollJitterCoefficient float64 `conf:"poll-jitter-coefficient" help:"Coefficient for poll jittering"` + QueryBlockSize int `conf:"query-block-size" help:"Number of ledger entries to get at once"` + Debug bool `conf:"debug" help:"Turns on debug logging"` + LedgerHealth ledgerHealthConfig `conf:"ledger-latency" help:"Configure ledger latency behavior"` + Dogstatsd dogstatsdConfig `conf:"dogstatsd" help:"dogstatsd Configuration"` + MetricsBind string `conf:"metrics-bind" help:"address to serve Prometheus metircs"` + WALPollInterval time.Duration `conf:"wal-poll-interval" help:"How often to pull the sqlite's wal size and status'"` } type executiveCliConfig struct { @@ -492,11 +488,7 @@ func defaultReflectorCLIConfig(isSupervisor bool) reflectorCliConfig { PollInterval: 10 * time.Second, AWSRegion: os.Getenv("AWS_REGION"), }, - // disabled by default - WALPollInterval: 0, - // 8 MB, double what a "healthy" WAL file should be https://www.sqlite.org/compile.html#default_wal_autocheckpoint - WALCheckpointThresholdSize: 8 * 1024 * 1024, - WALCheckpointType: ldbwriter.Passive, + WALPollInterval: 1 * time.Minute, } if isSupervisor { // the supervisor runs as an ECS task, so it cannot yet set @@ -554,10 +546,6 @@ func newReflector(cliCfg reflectorCliConfig, isSupervisor bool) (*reflectorpkg.R QueryBlockSize: cliCfg.QueryBlockSize, PollTimeout: 5 * time.Second, }, - WALPollInterval: cliCfg.WALPollInterval, - DoMonitorWAL: cliCfg.WALPollInterval > 0, - WALCheckpointThresholdSize: cliCfg.WALCheckpointThresholdSize, - WALCheckpointType: cliCfg.WALCheckpointType, - BusyTimeoutMS: cliCfg.BusyTimeoutMS, + WALPollInterval: cliCfg.WALPollInterval, }) } diff --git a/pkg/ledger/ledger_monitor.go b/pkg/ledger/ledger_monitor.go index 4354609d..e2ad1f58 100644 --- a/pkg/ledger/ledger_monitor.go +++ b/pkg/ledger/ledger_monitor.go @@ -4,7 +4,7 @@ import ( "context" "encoding/json" "fmt" - "io/ioutil" + "io" "net/http" "time" @@ -193,7 +193,7 @@ func (m *Monitor) getECSMetadata(ctx context.Context) (meta EcsMetadata, err err } defer resp.Body.Close() if resp.StatusCode != http.StatusOK { - b, _ := ioutil.ReadAll(resp.Body) + b, _ := io.ReadAll(resp.Body) return errors.Errorf("could not get ecs metadata: [%d]: %s", resp.StatusCode, b) } if err = json.NewDecoder(resp.Body).Decode(&meta); err != nil { diff --git a/pkg/reflector/wal_monitor_test.go b/pkg/reflector/wal_monitor_test.go index 24f7f89c..fc14a590 100644 --- a/pkg/reflector/wal_monitor_test.go +++ b/pkg/reflector/wal_monitor_test.go @@ -5,7 +5,6 @@ import ( "fmt" "os" "sync" - "sync/atomic" "testing" "time" @@ -13,18 +12,18 @@ import ( ) type fake struct { - size int64 - err error - wg sync.WaitGroup - statCallCount atomic.Int64 - cpCallCount atomic.Int64 + size int64 + err error + wg sync.WaitGroup + statCallCount int + checkCallCount int } func (f *fake) Stat() func(m *WALMonitor) { return func(m *WALMonitor) { m.walSizeFunc = func(p string) (int64, error) { defer f.wg.Done() - f.statCallCount.Add(1) + f.statCallCount++ v, err := m.getWALSize(p) f.size = v f.err = err @@ -44,60 +43,13 @@ func (f *fake) Ticker() func(m *WALMonitor) { func (f *fake) Checkpointer() func(m *WALMonitor) { return func(m *WALMonitor) { m.cpTesterFunc = func() (*ldbwriter.PragmaWALResult, error) { - defer f.wg.Done() - f.cpCallCount.Add(1) + f.checkCallCount++ return nil, fmt.Errorf("fail") } } } -func TestWALMonitorTooSmall(t *testing.T) { - tmpdir := t.TempDir() - f, err := os.CreateTemp(tmpdir, "*.ldb-wal") - if err != nil { - t.Fatal(err) - } - - n, err := f.WriteString("some random bytes!") - if err != nil { - t.Fatal(err) - } - - if f.Sync() != nil { - t.Fatal(err) - } - - var fake fake - fake.wg.Add(2) - mon := NewMonitor(MonitorConfig{ - PollInterval: time.Millisecond, - Path: f.Name(), - WALCheckpointThresholdSize: int64(n + 1), - }, nil, fake.Stat(), fake.Ticker(), fake.Checkpointer()) - - ctx, cancel := context.WithCancel(context.Background()) - go mon.Start(ctx) - // wait for fake stat call - fake.wg.Wait() - cancel() - - if fake.statCallCount.Load() == 0 { - t.Errorf("Stat should have been called at least once") - } - - if fake.cpCallCount.Load() != 0 { - t.Errorf("Checkpoint should not have been called since the file wasn't large enough") - } - if fake.err != nil { - t.Errorf("unexpected error on stat: %v", fake.err) - } - - if int64(n) != fake.size { - t.Errorf("expected file size of %d, got %d", n, fake.size) - } -} - -func TestWALMonitorBigEnough(t *testing.T) { +func TestWALMonitorSize(t *testing.T) { tmpdir := t.TempDir() f, err := os.CreateTemp(tmpdir, "*.ldb-wal") if err != nil { @@ -114,11 +66,10 @@ func TestWALMonitorBigEnough(t *testing.T) { } var fake fake - fake.wg.Add(2) + fake.wg.Add(1) mon := NewMonitor(MonitorConfig{ - PollInterval: time.Millisecond, - Path: f.Name(), - WALCheckpointThresholdSize: int64(n - 1), + PollInterval: time.Millisecond, + Path: f.Name(), }, nil, fake.Stat(), fake.Ticker(), fake.Checkpointer()) ctx, cancel := context.WithCancel(context.Background()) @@ -127,11 +78,11 @@ func TestWALMonitorBigEnough(t *testing.T) { fake.wg.Wait() cancel() - if fake.statCallCount.Load() == 0 { + if fake.statCallCount == 0 { t.Errorf("Stat should have been called at least once") } - if fake.cpCallCount.Load() == 0 { + if fake.checkCallCount == 0 { t.Errorf("Checkpoint should have been called at least once") } if fake.err != nil { @@ -152,16 +103,16 @@ func TestNoWALPath(t *testing.T) { mon.Start(context.Background()) - if fake.statCallCount.Load() != 0 { + if fake.statCallCount != 0 { t.Errorf("Stat should not have been called") } - if fake.cpCallCount.Load() != 0 { + if fake.checkCallCount != 0 { t.Errorf("Checkpoint should not have been called") } } -func TestWALMonitorStopsOnStatError(t *testing.T) { +func TestWALMonitorStopsOnError(t *testing.T) { var fake fake fake.wg.Add(5) mon := NewMonitor(MonitorConfig{ @@ -171,41 +122,11 @@ func TestWALMonitorStopsOnStatError(t *testing.T) { mon.Start(context.Background()) fake.wg.Wait() - if fake.statCallCount.Load() != 5 { - t.Errorf("Stat should have been called 5 times, got %d", fake.statCallCount.Load()) + if fake.statCallCount != 5 { + t.Errorf("Stat should have been called 5 times, got %d", fake.statCallCount) } - if fake.cpCallCount.Load() != 0 { - t.Errorf("Checkpoint should not have been called") - } -} - -func TestWALMonitorStopsOnCheckpointError(t *testing.T) { - tmpdir := t.TempDir() - f, err := os.CreateTemp(tmpdir, "*.ldb-wal") - if err != nil { - t.Fatal(err) - } - - _, err = f.WriteString("some random bytes!") - if err != nil { - t.Fatal(err) - } - - var fake fake - fake.wg.Add(10) - mon := NewMonitor(MonitorConfig{ - PollInterval: 50 * time.Microsecond, - Path: f.Name(), - }, nil, fake.Stat(), fake.Checkpointer()) - - mon.Start(context.Background()) - fake.wg.Wait() - if fake.statCallCount.Load() != 5 { - t.Errorf("Stat should have been called 5 times, got %d", fake.statCallCount.Load()) - } - - if fake.cpCallCount.Load() != 5 { - t.Errorf("Checkpoint should not have been called") + if fake.checkCallCount != 5 { + t.Errorf("Checkpoint should have have been called 5 times, got %d", fake.checkCallCount) } } From 84245c41e8602052ee00cd44ee886f8556f9572c Mon Sep 17 00:00:00 2001 From: Taylor Brennan Date: Wed, 14 Jun 2023 17:09:43 -0400 Subject: [PATCH 02/27] [CF-111] add rows metric for by prefix scan --- ldb_reader.go | 2 +- rows.go | 20 ++++++++++++++++++-- 2 files changed, 19 insertions(+), 3 deletions(-) diff --git a/ldb_reader.go b/ldb_reader.go index 1aea253c..0ed0200b 100644 --- a/ldb_reader.go +++ b/ldb_reader.go @@ -189,7 +189,7 @@ func (reader *LDBReader) GetRowsByKeyPrefix(ctx context.Context, familyName stri if err != nil { return nil, err } - res := &Rows{rows: rows, cols: cols} + res := &Rows{rows: rows, cols: cols, familyName: familyName, tableName: tableName} return res, nil case err == sql.ErrNoRows: return &Rows{}, nil diff --git a/rows.go b/rows.go index 31c15d2f..311cdf41 100644 --- a/rows.go +++ b/rows.go @@ -2,19 +2,29 @@ package ctlstore import ( "database/sql" + "sync" + "sync/atomic" + "github.com/segmentio/stats/v4" + + "github.com/segmentio/ctlstore/pkg/globalstats" "github.com/segmentio/ctlstore/pkg/scanfunc" "github.com/segmentio/ctlstore/pkg/schema" ) // Rows composes an *sql.Rows and allows scanning ctlstore table rows into // structs or maps, similar to how the GetRowByKey reader method works. +// It also keeps track of number of rows read and emits as a metric on Close // // The contract around Next/Err/Close is the same was it is for // *sql.Rows. type Rows struct { - rows *sql.Rows - cols []schema.DBColumnMeta + rows *sql.Rows + cols []schema.DBColumnMeta + familyName string + tableName string + count atomic.Uint32 + once sync.Once } // Next returns true if there's another row available. @@ -22,6 +32,7 @@ func (r *Rows) Next() bool { if r.rows == nil { return false } + r.count.Add(1) return r.rows.Next() } @@ -41,6 +52,11 @@ func (r *Rows) Close() error { if r.rows == nil { return nil } + r.once.Do(func() { + globalstats.Observe("get_rows_by_key_prefix_row_count", r.count.Load(), + stats.T("family", r.familyName), + stats.T("table", r.tableName)) + }) return r.rows.Close() } From a3f6589600d644becc1da7eac66d4b4bd2bab21b Mon Sep 17 00:00:00 2001 From: Taylor Brennan Date: Wed, 14 Jun 2023 17:10:09 -0400 Subject: [PATCH 03/27] [CF-111] add metric for time downloading ldb file --- pkg/reflector/download.go | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/pkg/reflector/download.go b/pkg/reflector/download.go index 7e7f958f..4eb3024d 100644 --- a/pkg/reflector/download.go +++ b/pkg/reflector/download.go @@ -37,9 +37,7 @@ func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { return -1, err } start := time.Now() - defer func() { - stats.Observe("snapshot_download_time", time.Now().Sub(start)) - }() + defer stats.Observe("snapshot_download_time", time.Now().Sub(start)) obj, err := client.GetObject(&s3.GetObjectInput{ Bucket: aws.String(d.Bucket), Key: aws.String(d.Key), From 2a037ab1794666c0c77a162fb047d8f90ebcf57a Mon Sep 17 00:00:00 2001 From: Taylor Brennan Date: Wed, 14 Jun 2023 17:15:15 -0400 Subject: [PATCH 04/27] revert to go 1.13 functions --- pkg/ledger/ledger_monitor.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/ledger/ledger_monitor.go b/pkg/ledger/ledger_monitor.go index e2ad1f58..4354609d 100644 --- a/pkg/ledger/ledger_monitor.go +++ b/pkg/ledger/ledger_monitor.go @@ -4,7 +4,7 @@ import ( "context" "encoding/json" "fmt" - "io" + "io/ioutil" "net/http" "time" @@ -193,7 +193,7 @@ func (m *Monitor) getECSMetadata(ctx context.Context) (meta EcsMetadata, err err } defer resp.Body.Close() if resp.StatusCode != http.StatusOK { - b, _ := io.ReadAll(resp.Body) + b, _ := ioutil.ReadAll(resp.Body) return errors.Errorf("could not get ecs metadata: [%d]: %s", resp.StatusCode, b) } if err = json.NewDecoder(resp.Body).Decode(&meta); err != nil { From 9158a1419ea2927fa24d7be906e8adc154cc419b Mon Sep 17 00:00:00 2001 From: Taylor Brennan Date: Wed, 14 Jun 2023 17:31:17 -0400 Subject: [PATCH 05/27] use make vendor in github workflow --- .github/workflows/build-ctlstore.yml | 38 ++++++++++++++++++++++++++++ 1 file changed, 38 insertions(+) create mode 100644 .github/workflows/build-ctlstore.yml diff --git a/.github/workflows/build-ctlstore.yml b/.github/workflows/build-ctlstore.yml new file mode 100644 index 00000000..950b100e --- /dev/null +++ b/.github/workflows/build-ctlstore.yml @@ -0,0 +1,38 @@ +name: build +on: + - push +jobs: + build: + name: Executes a full build + runs-on: ubuntu-latest + services: + mysql: + image: mysql:5.6 + env: + MYSQL_ROOT_PASSWORD: ctldbpw + MYSQL_DATABASE: ctldb + MYSQL_USER: ctldb + MYSQL_PASSWORD: ctldbpw + ports: + - 3306:3306 + + steps: + - name: checkout + uses: actions/checkout@v3 + + - name: setup go 1.20 + uses: actions/setup-go@v3 + with: + go-version: 1.20 + + - name: Deps + run: | + make vendor + + - name: Test + run: | + make test + + - name: build + run: | + make build \ No newline at end of file From f52d04913bab29bbf747ca8b39b23e1be7c4ffbe Mon Sep 17 00:00:00 2001 From: Taylor Brennan Date: Wed, 14 Jun 2023 17:45:08 -0400 Subject: [PATCH 06/27] Use go '1.20' not go 1.2 --- .github/workflows/build-ctlstore.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/build-ctlstore.yml b/.github/workflows/build-ctlstore.yml index 950b100e..38d75447 100644 --- a/.github/workflows/build-ctlstore.yml +++ b/.github/workflows/build-ctlstore.yml @@ -23,7 +23,7 @@ jobs: - name: setup go 1.20 uses: actions/setup-go@v3 with: - go-version: 1.20 + go-version: '1.20' - name: Deps run: | From cc96cb90d61bbdf725751d4a95960237bfd9dd4e Mon Sep 17 00:00:00 2001 From: Taylor Brennan Date: Thu, 15 Jun 2023 10:11:14 -0400 Subject: [PATCH 07/27] improve documentation, naming and add configuration option for disabling wal monitoring --- pkg/cmd/ctlstore/main.go | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/pkg/cmd/ctlstore/main.go b/pkg/cmd/ctlstore/main.go index 2c70db0e..5a938aaa 100644 --- a/pkg/cmd/ctlstore/main.go +++ b/pkg/cmd/ctlstore/main.go @@ -61,7 +61,7 @@ type reflectorCliConfig struct { LedgerHealth ledgerHealthConfig `conf:"ledger-latency" help:"Configure ledger latency behavior"` Dogstatsd dogstatsdConfig `conf:"dogstatsd" help:"dogstatsd Configuration"` MetricsBind string `conf:"metrics-bind" help:"address to serve Prometheus metircs"` - WALPollInterval time.Duration `conf:"wal-poll-interval" help:"How often to pull the sqlite's wal size and status'"` + WALPollInterval time.Duration `conf:"wal-poll-interval" help:"How often to pull the sqlite's wal size and status. 0 indicates disabled monitoring'"` } type executiveCliConfig struct { @@ -488,7 +488,8 @@ func defaultReflectorCLIConfig(isSupervisor bool) reflectorCliConfig { PollInterval: 10 * time.Second, AWSRegion: os.Getenv("AWS_REGION"), }, - WALPollInterval: 1 * time.Minute, + // disabled by default + WALPollInterval: 0, } if isSupervisor { // the supervisor runs as an ECS task, so it cannot yet set @@ -547,5 +548,6 @@ func newReflector(cliCfg reflectorCliConfig, isSupervisor bool) (*reflectorpkg.R PollTimeout: 5 * time.Second, }, WALPollInterval: cliCfg.WALPollInterval, + DoMonitorWAL: cliCfg.WALPollInterval > 0, }) } From 7f80d6eab93b755f1b79e082efb20902cdbea059 Mon Sep 17 00:00:00 2001 From: Taylor Brennan Date: Tue, 20 Jun 2023 13:51:38 -0400 Subject: [PATCH 08/27] upgrade docker to go 1.20 --- Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Dockerfile b/Dockerfile index 72e9c3d8..8b8f40b0 100644 --- a/Dockerfile +++ b/Dockerfile @@ -25,4 +25,4 @@ COPY --from=0 /go/src/github.com/segmentio/ctlstore/scripts/download.sh . COPY --from=0 /bin/chamber /bin/chamber COPY --from=0 /bin/s5cmd /bin/s5cmd COPY --from=0 /usr/local/bin/ctlstore /usr/local/bin/ -COPY --from=0 /usr/local/bin/ctlstore-cli /usr/local/bin/ +COPY --from=0 /usr/local/bin/ctlstore-cli /usr/local/bin/ \ No newline at end of file From 98e8af4e5110366b0f31a74e390c9b8e0e87b991 Mon Sep 17 00:00:00 2001 From: Taylor Brennan Date: Thu, 22 Jun 2023 11:36:01 -0400 Subject: [PATCH 09/27] revert to go 1.13 --- .github/workflows/build-ctlstore.yml | 5 ++--- Dockerfile | 2 +- go.mod | 19 +------------------ go.sum | 5 +++++ ldb_reader.go | 2 +- rows.go | 13 ++++++++++--- 6 files changed, 20 insertions(+), 26 deletions(-) diff --git a/.github/workflows/build-ctlstore.yml b/.github/workflows/build-ctlstore.yml index 38d75447..b4bf6b79 100644 --- a/.github/workflows/build-ctlstore.yml +++ b/.github/workflows/build-ctlstore.yml @@ -20,10 +20,10 @@ jobs: - name: checkout uses: actions/checkout@v3 - - name: setup go 1.20 + - name: setup go 1.13 uses: actions/setup-go@v3 with: - go-version: '1.20' + go-version: '1.13' - name: Deps run: | @@ -32,7 +32,6 @@ jobs: - name: Test run: | make test - - name: build run: | make build \ No newline at end of file diff --git a/Dockerfile b/Dockerfile index 8b8f40b0..445f00ee 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,4 +1,4 @@ -FROM golang:1.20-alpine +FROM golang:1.13-alpine ENV SRC github.com/segmentio/ctlstore ARG VERSION diff --git a/go.mod b/go.mod index b6204e36..a1907e98 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/segmentio/ctlstore -go 1.20 +go 1.13 require ( github.com/AlekSi/pointer v1.0.0 @@ -23,23 +23,6 @@ require ( ) require ( - github.com/davecgh/go-spew v1.1.1 // indirect - github.com/jmespath/go-jmespath v0.4.0 // indirect - github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851 // indirect - github.com/mdlayher/netlink v0.0.0-20190313131330-258ea9dff42c // indirect - github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072 // indirect - github.com/pmezard/go-difflib v1.0.0 // indirect - github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e // indirect - github.com/segmentio/go-snakecase v1.1.0 // indirect - github.com/segmentio/objconv v1.0.1 // indirect - golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect - golang.org/x/net v0.7.0 // indirect - golang.org/x/sys v0.5.0 // indirect - golang.org/x/tools v0.1.12 // indirect google.golang.org/appengine v1.6.7 // indirect gopkg.in/go-playground/assert.v1 v1.2.1 // indirect - gopkg.in/go-playground/mold.v2 v2.2.0 // indirect - gopkg.in/validator.v2 v2.0.0-20180514200540-135c24b11c19 // indirect - gopkg.in/yaml.v2 v2.4.0 // indirect - gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 578f101a..2e61c86e 100644 --- a/go.sum +++ b/go.sum @@ -19,6 +19,7 @@ github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:x github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= +github.com/golang/protobuf v1.4.3 h1:JjCZWpVbqXDqFVmTfYWEVTMIYrL/NPdPSCHPJ0T/raM= github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= @@ -50,8 +51,10 @@ github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072 h1:7YEPiUVGht4Z github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072/go.mod h1:sGdS7A6CAETR53zkdjGkgoFlh1vSm7MtX+i8XfEsTMA= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= +github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78= github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.12.1 h1:mFwc4LvZ0xpSvDZ3E+k8Yte0hLOMxXUlP+yXtJqkYfQ= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= github.com/onsi/gomega v1.11.0 h1:+CqWgvj0OZycCaqclBD1pxKHAU+tOkHmQIWvDHq2aug= @@ -164,6 +167,7 @@ google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= +google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM= google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b h1:QRR6H1YWRnHb4Y/HeNFCTJLFVxaq6wH4YuVdsUOr75U= @@ -173,6 +177,7 @@ gopkg.in/go-playground/assert.v1 v1.2.1 h1:xoYuJVE7KT85PYWrN730RguIQO0ePzVRfFMXa gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE= gopkg.in/go-playground/mold.v2 v2.2.0 h1:Y4IYB4/HYQfuq43zaKh6vs9cVelLE9qbqe2fkyfCTWQ= gopkg.in/go-playground/mold.v2 v2.2.0/go.mod h1:XMyyRsGtakkDPbxXbrA5VODo6bUXyvoDjLd5l3T0XoA= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= gopkg.in/validator.v2 v2.0.0-20180514200540-135c24b11c19 h1:WB265cn5OpO+hK3pikC9hpP1zI/KTwmyMFKloW9eOVc= gopkg.in/validator.v2 v2.0.0-20180514200540-135c24b11c19/go.mod h1:o4V0GXN9/CAmCsvJ0oXYZvrZOe7syiDZSN1GWGZTGzc= diff --git a/ldb_reader.go b/ldb_reader.go index 0ed0200b..fbdf6852 100644 --- a/ldb_reader.go +++ b/ldb_reader.go @@ -189,7 +189,7 @@ func (reader *LDBReader) GetRowsByKeyPrefix(ctx context.Context, familyName stri if err != nil { return nil, err } - res := &Rows{rows: rows, cols: cols, familyName: familyName, tableName: tableName} + res := &Rows{rows: rows, cols: cols, familyName: familyName, tableName: tableName, start: time.Now()} return res, nil case err == sql.ErrNoRows: return &Rows{}, nil diff --git a/rows.go b/rows.go index 311cdf41..7b750bb1 100644 --- a/rows.go +++ b/rows.go @@ -4,6 +4,7 @@ import ( "database/sql" "sync" "sync/atomic" + "time" "github.com/segmentio/stats/v4" @@ -23,8 +24,9 @@ type Rows struct { cols []schema.DBColumnMeta familyName string tableName string - count atomic.Uint32 + count uint32 once sync.Once + start time.Time } // Next returns true if there's another row available. @@ -32,7 +34,7 @@ func (r *Rows) Next() bool { if r.rows == nil { return false } - r.count.Add(1) + atomic.AddUint32(&r.count, 1) return r.rows.Next() } @@ -53,9 +55,14 @@ func (r *Rows) Close() error { return nil } r.once.Do(func() { - globalstats.Observe("get_rows_by_key_prefix_row_count", r.count.Load(), + globalstats.Observe("get_rows_by_key_prefix_row_count", atomic.LoadUint32(&r.count), stats.T("family", r.familyName), stats.T("table", r.tableName)) + if !r.start.IsZero() { + globalstats.Observe("get_rows_by_prefix_scan_time", time.Now().Sub(r.start), + stats.T("family", r.familyName), + stats.T("table", r.tableName)) + } }) return r.rows.Close() } From 697d4ae2caa8604bb882162da8375ed590b80f97 Mon Sep 17 00:00:00 2001 From: Taylor Brennan Date: Thu, 22 Jun 2023 14:25:01 -0400 Subject: [PATCH 10/27] Revert to go 1.20, close query --- .github/workflows/build-ctlstore.yml | 4 ++-- Dockerfile | 2 +- go.mod | 19 ++++++++++++++++++- go.sum | 5 ----- 4 files changed, 21 insertions(+), 9 deletions(-) diff --git a/.github/workflows/build-ctlstore.yml b/.github/workflows/build-ctlstore.yml index b4bf6b79..76b82efc 100644 --- a/.github/workflows/build-ctlstore.yml +++ b/.github/workflows/build-ctlstore.yml @@ -20,10 +20,10 @@ jobs: - name: checkout uses: actions/checkout@v3 - - name: setup go 1.13 + - name: setup go 1.20 uses: actions/setup-go@v3 with: - go-version: '1.13' + go-version: '1.20' - name: Deps run: | diff --git a/Dockerfile b/Dockerfile index 445f00ee..8b8f40b0 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,4 +1,4 @@ -FROM golang:1.13-alpine +FROM golang:1.20-alpine ENV SRC github.com/segmentio/ctlstore ARG VERSION diff --git a/go.mod b/go.mod index a1907e98..b6204e36 100644 --- a/go.mod +++ b/go.mod @@ -1,6 +1,6 @@ module github.com/segmentio/ctlstore -go 1.13 +go 1.20 require ( github.com/AlekSi/pointer v1.0.0 @@ -23,6 +23,23 @@ require ( ) require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/jmespath/go-jmespath v0.4.0 // indirect + github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851 // indirect + github.com/mdlayher/netlink v0.0.0-20190313131330-258ea9dff42c // indirect + github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/segmentio/fasthash v0.0.0-20180216231524-a72b379d632e // indirect + github.com/segmentio/go-snakecase v1.1.0 // indirect + github.com/segmentio/objconv v1.0.1 // indirect + golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect + golang.org/x/net v0.7.0 // indirect + golang.org/x/sys v0.5.0 // indirect + golang.org/x/tools v0.1.12 // indirect google.golang.org/appengine v1.6.7 // indirect gopkg.in/go-playground/assert.v1 v1.2.1 // indirect + gopkg.in/go-playground/mold.v2 v2.2.0 // indirect + gopkg.in/validator.v2 v2.0.0-20180514200540-135c24b11c19 // indirect + gopkg.in/yaml.v2 v2.4.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) diff --git a/go.sum b/go.sum index 2e61c86e..578f101a 100644 --- a/go.sum +++ b/go.sum @@ -19,7 +19,6 @@ github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:x github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs= github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w= github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0= -github.com/golang/protobuf v1.4.3 h1:JjCZWpVbqXDqFVmTfYWEVTMIYrL/NPdPSCHPJ0T/raM= github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI= github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= @@ -51,10 +50,8 @@ github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072 h1:7YEPiUVGht4Z github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072/go.mod h1:sGdS7A6CAETR53zkdjGkgoFlh1vSm7MtX+i8XfEsTMA= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno= -github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78= github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A= github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= -github.com/onsi/ginkgo v1.12.1 h1:mFwc4LvZ0xpSvDZ3E+k8Yte0hLOMxXUlP+yXtJqkYfQ= github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk= github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY= github.com/onsi/gomega v1.11.0 h1:+CqWgvj0OZycCaqclBD1pxKHAU+tOkHmQIWvDHq2aug= @@ -167,7 +164,6 @@ google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM= google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE= google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo= -google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM= google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20200902074654-038fdea0a05b h1:QRR6H1YWRnHb4Y/HeNFCTJLFVxaq6wH4YuVdsUOr75U= @@ -177,7 +173,6 @@ gopkg.in/go-playground/assert.v1 v1.2.1 h1:xoYuJVE7KT85PYWrN730RguIQO0ePzVRfFMXa gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE= gopkg.in/go-playground/mold.v2 v2.2.0 h1:Y4IYB4/HYQfuq43zaKh6vs9cVelLE9qbqe2fkyfCTWQ= gopkg.in/go-playground/mold.v2 v2.2.0/go.mod h1:XMyyRsGtakkDPbxXbrA5VODo6bUXyvoDjLd5l3T0XoA= -gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= gopkg.in/validator.v2 v2.0.0-20180514200540-135c24b11c19 h1:WB265cn5OpO+hK3pikC9hpP1zI/KTwmyMFKloW9eOVc= gopkg.in/validator.v2 v2.0.0-20180514200540-135c24b11c19/go.mod h1:o4V0GXN9/CAmCsvJ0oXYZvrZOe7syiDZSN1GWGZTGzc= From e9cbd43b8a35060d4bbabc1bfc518cde56cf945c Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Thu, 27 Jul 2023 16:37:54 -0400 Subject: [PATCH 11/27] wip --- go.mod | 21 ++++++++++++++++++- go.sum | 42 ++++++++++++++++++++++++++++++++++++-- pkg/reflector/download.go | 37 +++++++++++++++++++++++---------- pkg/reflector/s3_client.go | 4 ++-- 4 files changed, 88 insertions(+), 16 deletions(-) diff --git a/go.mod b/go.mod index b6204e36..6834ea08 100644 --- a/go.mod +++ b/go.mod @@ -5,9 +5,11 @@ go 1.20 require ( github.com/AlekSi/pointer v1.0.0 github.com/aws/aws-sdk-go v1.37.8 + github.com/aws/aws-sdk-go-v2/config v1.18.29 + github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.11.73 github.com/fsnotify/fsnotify v1.5.1 github.com/go-sql-driver/mysql v1.4.1 - github.com/google/go-cmp v0.5.6 + github.com/google/go-cmp v0.5.8 github.com/google/uuid v1.1.2 github.com/gorilla/mux v1.7.3 github.com/julienschmidt/httprouter v1.2.0 @@ -23,6 +25,23 @@ require ( ) require ( + github.com/aws/aws-sdk-go-v2 v1.19.0 // indirect + github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.4.10 // indirect + github.com/aws/aws-sdk-go-v2/credentials v1.13.28 // indirect + github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.13.5 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.35 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.29 // indirect + github.com/aws/aws-sdk-go-v2/internal/ini v1.3.36 // indirect + github.com/aws/aws-sdk-go-v2/internal/v4a v1.0.27 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.11 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.30 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.29 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.14.4 // indirect + github.com/aws/aws-sdk-go-v2/service/s3 v1.37.0 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.12.13 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.14.13 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.20.0 // indirect + github.com/aws/smithy-go v1.13.5 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/jmespath/go-jmespath v0.4.0 // indirect github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851 // indirect diff --git a/go.sum b/go.sum index 578f101a..a5347b88 100644 --- a/go.sum +++ b/go.sum @@ -4,6 +4,44 @@ github.com/PuerkitoBio/goquery v1.8.1/go.mod h1:Q8ICL1kNUJ2sXGoAhPGUdYDJvgQgHzJs github.com/andybalholm/cascadia v1.3.1/go.mod h1:R4bJ1UQfqADjvDa4P6HZHLh/3OxWWEqc0Sk8XGwHqvA= github.com/aws/aws-sdk-go v1.37.8 h1:9kywcbuz6vQuTf+FD+U7FshafrHzmqUCjgAEiLuIJ8U= github.com/aws/aws-sdk-go v1.37.8/go.mod h1:hcU610XS61/+aQV88ixoOzUoG7v3b31pl2zKMmprdro= +github.com/aws/aws-sdk-go-v2 v1.19.0 h1:klAT+y3pGFBU/qVf1uzwttpBbiuozJYWzNLHioyDJ+k= +github.com/aws/aws-sdk-go-v2 v1.19.0/go.mod h1:uzbQtefpm44goOPmdKyAlXSNcwlRgF3ePWVW6EtJvvw= +github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.4.10 h1:dK82zF6kkPeCo8J1e+tGx4JdvDIQzj7ygIoLg8WMuGs= +github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.4.10/go.mod h1:VeTZetY5KRJLuD/7fkQXMU6Mw7H5m/KP2J5Iy9osMno= +github.com/aws/aws-sdk-go-v2/config v1.18.29 h1:yA+bSSRGhBwWuprG9I4VgxfK//NBLZ/0BGOHiV3f9oM= +github.com/aws/aws-sdk-go-v2/config v1.18.29/go.mod h1:bJT6P8A+KU1qvNMp8aj+/NmaI06Z670dHNoWsrLOgMg= +github.com/aws/aws-sdk-go-v2/credentials v1.13.28 h1:WM9tEHgoOh5ThJZ042UKnSx7TXGSC/bz63X3fsrQL2o= +github.com/aws/aws-sdk-go-v2/credentials v1.13.28/go.mod h1:86BSbSeamnVVdr1hPfBZVN8SXM7KxSAZAvhNxVfi8fU= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.13.5 h1:kP3Me6Fy3vdi+9uHd7YLr6ewPxRL+PU6y15urfTaamU= +github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.13.5/go.mod h1:Gj7tm95r+QsDoN2Fhuz/3npQvcZbkEf5mL70n3Xfluc= +github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.11.73 h1:ez9K7LHdBxo+g1ExpUPsWEFfHxzHhiVZriWAJAiZwKc= +github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.11.73/go.mod h1:+eJGIv33Lpdk3pbgIzKisFleIOB9dfWuVuipuve5Gsw= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.35 h1:hMUCiE3Zi5AHrRNGf5j985u0WyqI6r2NULhUfo0N/No= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.35/go.mod h1:ipR5PvpSPqIqL5Mi82BxLnfMkHVbmco8kUwO2xrCi0M= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.29 h1:yOpYx+FTBdpk/g+sBU6Cb1H0U/TLEcYYp66mYqsPpcc= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.29/go.mod h1:M/eUABlDbw2uVrdAn+UsI6M727qp2fxkp8K0ejcBDUY= +github.com/aws/aws-sdk-go-v2/internal/ini v1.3.36 h1:8r5m1BoAWkn0TDC34lUculryf7nUF25EgIMdjvGCkgo= +github.com/aws/aws-sdk-go-v2/internal/ini v1.3.36/go.mod h1:Rmw2M1hMVTwiUhjwMoIBFWFJMhvJbct06sSidxInkhY= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.0.27 h1:cZG7psLfqpkB6H+fIrgUDWmlzM474St1LP0jcz272yI= +github.com/aws/aws-sdk-go-v2/internal/v4a v1.0.27/go.mod h1:ZdjYvJpDlefgh8/hWelJhqgqJeodxu4SmbVsSdBlL7E= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.11 h1:y2+VQzC6Zh2ojtV2LoC0MNwHWc6qXv/j2vrQtlftkdA= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.11/go.mod h1:iV4q2hsqtNECrfmlXyord9u4zyuFEJX9eLgLpSPzWA8= +github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.30 h1:Bje8Xkh2OWpjBdNfXLrnn8eZg569dUQmhgtydxAYyP0= +github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.30/go.mod h1:qQtIBl5OVMfmeQkz8HaVyh5DzFmmFXyvK27UgIgOr4c= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.29 h1:IiDolu/eLmuB18DRZibj77n1hHQT7z12jnGO7Ze3pLc= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.29/go.mod h1:fDbkK4o7fpPXWn8YAPmTieAMuB9mk/VgvW64uaUqxd4= +github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.14.4 h1:hx4WksB0NRQ9utR+2c3gEGzl6uKj3eM6PMQ6tN3lgXs= +github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.14.4/go.mod h1:JniVpqvw90sVjNqanGLufrVapWySL28fhBlYgl96Q/w= +github.com/aws/aws-sdk-go-v2/service/s3 v1.37.0 h1:PalLOEGZ/4XfQxpGZFTLaoJSmPoybnqJYotaIZEf/Rg= +github.com/aws/aws-sdk-go-v2/service/s3 v1.37.0/go.mod h1:PwyKKVL0cNkC37QwLcrhyeCrAk+5bY8O2ou7USyAS2A= +github.com/aws/aws-sdk-go-v2/service/sso v1.12.13 h1:sWDv7cMITPcZ21QdreULwxOOAmE05JjEsT6fCDtDA9k= +github.com/aws/aws-sdk-go-v2/service/sso v1.12.13/go.mod h1:DfX0sWuT46KpcqbMhJ9QWtxAIP1VozkDWf8VAkByjYY= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.14.13 h1:BFubHS/xN5bjl818QaroN6mQdjneYQ+AOx44KNXlyH4= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.14.13/go.mod h1:BzqsVVFduubEmzrVtUFQQIQdFqvUItF8XUq2EnS8Wog= +github.com/aws/aws-sdk-go-v2/service/sts v1.20.0 h1:jKmIOO+dFvCPuIhhM8u0Dy3dtd590n2kEDSYiGHoI98= +github.com/aws/aws-sdk-go-v2/service/sts v1.20.0/go.mod h1:yVGZA1CPkmUhBdA039jXNJJG7/6t+G+EBWmFq23xqnY= +github.com/aws/smithy-go v1.13.5 h1:hgz0X/DX0dGqTYpGALqXJoRKRj5oQ7150i5FdTePzO8= +github.com/aws/smithy-go v1.13.5/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= @@ -24,8 +62,8 @@ github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5a github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU= github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ= -github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= +github.com/google/go-cmp v0.5.8 h1:e6P7q2lk1O+qJJb4BtCQXlK8vWEO8V1ZeuEdJNOqZyg= +github.com/google/go-cmp v0.5.8/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/uuid v1.1.2 h1:EVhdT+1Kseyi1/pUmXKaFxYsDNy9RQYkMWRH68J/W7Y= github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/gorilla/mux v1.7.3 h1:gnP5JzjVOuiZD07fKKToCAOjS0yOpj/qPETTXCCS6hw= diff --git a/pkg/reflector/download.go b/pkg/reflector/download.go index 4eb3024d..74578a26 100644 --- a/pkg/reflector/download.go +++ b/pkg/reflector/download.go @@ -3,15 +3,18 @@ package reflector import ( "bytes" "compress/gzip" + "context" + "fmt" "io" "net/http" "strings" "time" - "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go-v2/aws" + "github.com/aws/aws-sdk-go-v2/config" + "github.com/aws/aws-sdk-go-v2/feature/s3/manager" + "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go/aws/awserr" - "github.com/aws/aws-sdk-go/aws/session" - "github.com/aws/aws-sdk-go/service/s3" "github.com/segmentio/errors-go" "github.com/segmentio/events/v2" "github.com/segmentio/stats/v4" @@ -33,15 +36,25 @@ type S3Downloader struct { func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { client, err := d.getS3Client() + downloader := manager.NewDownloader(client, func(d *manager.Downloader) { + d.PartSize = 64 * 1024 * 1024 // 64MB per part + d.Concurrency = 5 + }) if err != nil { return -1, err } start := time.Now() defer stats.Observe("snapshot_download_time", time.Now().Sub(start)) - obj, err := client.GetObject(&s3.GetObjectInput{ + buffer := manager.NewWriteAtBuffer([]byte{}) + numBytes, err := downloader.Download(context.TODO(), buffer, &s3.GetObjectInput{ Bucket: aws.String(d.Bucket), Key: aws.String(d.Key), }) + + //obj, err := client.GetObject(&s3.GetObjectInput{ + // Bucket: aws.String(d.Bucket), + // Key: aws.String(d.Key), + //}) if err != nil { switch err := err.(type) { case awserr.RequestFailure: @@ -77,14 +90,16 @@ func (d *S3Downloader) getS3Client() (S3Client, error) { if d.S3Client != nil { return d.S3Client, nil } - configs := []*aws.Config{} - if d.Region != "" { - configs = append(configs, &aws.Config{ - Region: aws.String(d.Region), - }) + + cfg, err := config.LoadDefaultConfig(context.TODO(), + config.WithRegion(d.Region), // Empty string will result in the region value being ignored + ) + + if err != nil { + panic(fmt.Sprintf("failed loading config, %v", err)) } - sess := session.Must(session.NewSession(configs...)) - client := s3.New(sess) + + client := s3.NewFromConfig(cfg) return client, nil } diff --git a/pkg/reflector/s3_client.go b/pkg/reflector/s3_client.go index 19468dc4..9e9e91b2 100644 --- a/pkg/reflector/s3_client.go +++ b/pkg/reflector/s3_client.go @@ -1,10 +1,10 @@ package reflector import ( - "github.com/aws/aws-sdk-go/service/s3/s3iface" + "github.com/aws/aws-sdk-go-v2/feature/s3/manager" ) //counterfeiter:generate -o ../fakes/s3_client.go . S3Client type S3Client interface { - s3iface.S3API + manager.DownloadAPIClient } From f3e229d99415b2c79e327ca6ef5f79e583c8ab9d Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Thu, 27 Jul 2023 17:53:56 -0400 Subject: [PATCH 12/27] WIP --- pkg/reflector/download.go | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/pkg/reflector/download.go b/pkg/reflector/download.go index 74578a26..63d766a5 100644 --- a/pkg/reflector/download.go +++ b/pkg/reflector/download.go @@ -46,7 +46,7 @@ func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { start := time.Now() defer stats.Observe("snapshot_download_time", time.Now().Sub(start)) buffer := manager.NewWriteAtBuffer([]byte{}) - numBytes, err := downloader.Download(context.TODO(), buffer, &s3.GetObjectInput{ + compressedSize, err := downloader.Download(context.TODO(), buffer, &s3.GetObjectInput{ Bucket: aws.String(d.Bucket), Key: aws.String(d.Key), }) @@ -67,7 +67,6 @@ func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { return -1, errors.WithTypes(errors.Wrap(err, "get s3 data"), errs.ErrTypeTemporary) } defer obj.Body.Close() - compressedSize := obj.ContentLength var reader io.Reader = obj.Body if strings.HasSuffix(d.Key, ".gz") { reader, err = gzip.NewReader(reader) @@ -79,9 +78,8 @@ func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { if err != nil { return n, errors.Wrap(err, "copy from s3 to writer") } - if compressedSize != nil { - events.Log("LDB inflated %d -> %d bytes", *compressedSize, n) - } + + events.Log("LDB inflated %d -> %d bytes", compressedSize, n) return } From c0b727e7bf2830342e49c9b45ce4fb5d15967850 Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Thu, 3 Aug 2023 11:45:32 -0400 Subject: [PATCH 13/27] WIP --- go.mod | 5 ++-- go.sum | 2 ++ pkg/reflector/download.go | 49 +++++++++++++++++++++++++-------------- 3 files changed, 37 insertions(+), 19 deletions(-) diff --git a/go.mod b/go.mod index 6834ea08..efea127b 100644 --- a/go.mod +++ b/go.mod @@ -5,14 +5,17 @@ go 1.20 require ( github.com/AlekSi/pointer v1.0.0 github.com/aws/aws-sdk-go v1.37.8 + github.com/aws/aws-sdk-go-v2 v1.19.0 github.com/aws/aws-sdk-go-v2/config v1.18.29 github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.11.73 + github.com/aws/aws-sdk-go-v2/service/s3 v1.37.0 github.com/fsnotify/fsnotify v1.5.1 github.com/go-sql-driver/mysql v1.4.1 github.com/google/go-cmp v0.5.8 github.com/google/uuid v1.1.2 github.com/gorilla/mux v1.7.3 github.com/julienschmidt/httprouter v1.2.0 + github.com/klauspost/compress v1.16.7 github.com/maxbrunsfeld/counterfeiter/v6 v6.4.1 github.com/pkg/errors v0.9.1 github.com/segmentio/cli v0.5.1 @@ -25,7 +28,6 @@ require ( ) require ( - github.com/aws/aws-sdk-go-v2 v1.19.0 // indirect github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.4.10 // indirect github.com/aws/aws-sdk-go-v2/credentials v1.13.28 // indirect github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.13.5 // indirect @@ -37,7 +39,6 @@ require ( github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.30 // indirect github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.29 // indirect github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.14.4 // indirect - github.com/aws/aws-sdk-go-v2/service/s3 v1.37.0 // indirect github.com/aws/aws-sdk-go-v2/service/sso v1.12.13 // indirect github.com/aws/aws-sdk-go-v2/service/ssooidc v1.14.13 // indirect github.com/aws/aws-sdk-go-v2/service/sts v1.20.0 // indirect diff --git a/go.sum b/go.sum index a5347b88..fab76d02 100644 --- a/go.sum +++ b/go.sum @@ -75,6 +75,8 @@ github.com/jmespath/go-jmespath/internal/testify v1.5.1 h1:shLQSRRSCCPj3f2gpwzGw github.com/jmespath/go-jmespath/internal/testify v1.5.1/go.mod h1:L3OGu8Wl2/fWfCI6z80xFu9LTZmf1ZRjMHUOPmWr69U= github.com/julienschmidt/httprouter v1.2.0 h1:TDTW5Yz1mjftljbcKqRcrYhd4XeOoI98t+9HbQbYf7g= github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= +github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I= +github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= diff --git a/pkg/reflector/download.go b/pkg/reflector/download.go index 63d766a5..d5cdf405 100644 --- a/pkg/reflector/download.go +++ b/pkg/reflector/download.go @@ -7,6 +7,7 @@ import ( "fmt" "io" "net/http" + "os" "strings" "time" @@ -15,11 +16,11 @@ import ( "github.com/aws/aws-sdk-go-v2/feature/s3/manager" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go/aws/awserr" + + "github.com/segmentio/ctlstore/pkg/errs" "github.com/segmentio/errors-go" "github.com/segmentio/events/v2" "github.com/segmentio/stats/v4" - - "github.com/segmentio/ctlstore/pkg/errs" ) type downloadTo interface { @@ -43,18 +44,21 @@ func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { if err != nil { return -1, err } + + tmpdir := os.TempDir() + file, err := os.CreateTemp(tmpdir, d.Key) + if err != nil { + return -1, errors.Wrap(err, "download snapshot into disk") + } + defer os.Remove(file.Name()) + start := time.Now() - defer stats.Observe("snapshot_download_time", time.Now().Sub(start)) - buffer := manager.NewWriteAtBuffer([]byte{}) - compressedSize, err := downloader.Download(context.TODO(), buffer, &s3.GetObjectInput{ + numBytes, err := downloader.Download(context.TODO(), file, &s3.GetObjectInput{ Bucket: aws.String(d.Bucket), Key: aws.String(d.Key), }) + stats.Observe("snapshot_download_time", time.Now().Sub(start)) - //obj, err := client.GetObject(&s3.GetObjectInput{ - // Bucket: aws.String(d.Bucket), - // Key: aws.String(d.Key), - //}) if err != nil { switch err := err.(type) { case awserr.RequestFailure: @@ -66,22 +70,33 @@ func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { // retry return -1, errors.WithTypes(errors.Wrap(err, "get s3 data"), errs.ErrTypeTemporary) } - defer obj.Body.Close() - var reader io.Reader = obj.Body + if strings.HasSuffix(d.Key, ".gz") { - reader, err = gzip.NewReader(reader) + n, err = Unzip(file, w) if err != nil { - return n, errors.Wrap(err, "create gzip reader") + return n, errors.Wrap(err, "unzip snapshot") } } - n, err = io.Copy(w, reader) + + events.Log("LDB inflated %d -> %d bytes", numBytes, n) + + return +} + +func Unzip(src io.Reader, dest io.Writer) (int64, error) { + r, err := gzip.NewReader(src) if err != nil { - return n, errors.Wrap(err, "copy from s3 to writer") + return -1, err } + defer r.Close() - events.Log("LDB inflated %d -> %d bytes", compressedSize, n) + n, err := io.Copy(dest, r) - return + if err != nil { + return -1, err + } + + return n, nil } func (d *S3Downloader) getS3Client() (S3Client, error) { From caa846369a2e568c4836101a89c62ef43219d6a4 Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Thu, 3 Aug 2023 11:59:24 -0400 Subject: [PATCH 14/27] fix test --- pkg/fakes/s3_client.go | 24299 +------------------------------ pkg/reflector/download_test.go | 11 +- 2 files changed, 55 insertions(+), 24255 deletions(-) diff --git a/pkg/fakes/s3_client.go b/pkg/fakes/s3_client.go index c00ced44..c1489c5c 100644 --- a/pkg/fakes/s3_client.go +++ b/pkg/fakes/s3_client.go @@ -5,23143 +5,42 @@ import ( "context" "sync" - "github.com/aws/aws-sdk-go/aws/request" - "github.com/aws/aws-sdk-go/service/s3" + "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/segmentio/ctlstore/pkg/reflector" ) type FakeS3Client struct { - AbortMultipartUploadStub func(*s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error) - abortMultipartUploadMutex sync.RWMutex - abortMultipartUploadArgsForCall []struct { - arg1 *s3.AbortMultipartUploadInput - } - abortMultipartUploadReturns struct { - result1 *s3.AbortMultipartUploadOutput - result2 error - } - abortMultipartUploadReturnsOnCall map[int]struct { - result1 *s3.AbortMultipartUploadOutput - result2 error - } - AbortMultipartUploadRequestStub func(*s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput) - abortMultipartUploadRequestMutex sync.RWMutex - abortMultipartUploadRequestArgsForCall []struct { - arg1 *s3.AbortMultipartUploadInput - } - abortMultipartUploadRequestReturns struct { - result1 *request.Request - result2 *s3.AbortMultipartUploadOutput - } - abortMultipartUploadRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.AbortMultipartUploadOutput - } - AbortMultipartUploadWithContextStub func(context.Context, *s3.AbortMultipartUploadInput, ...request.Option) (*s3.AbortMultipartUploadOutput, error) - abortMultipartUploadWithContextMutex sync.RWMutex - abortMultipartUploadWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.AbortMultipartUploadInput - arg3 []request.Option - } - abortMultipartUploadWithContextReturns struct { - result1 *s3.AbortMultipartUploadOutput - result2 error - } - abortMultipartUploadWithContextReturnsOnCall map[int]struct { - result1 *s3.AbortMultipartUploadOutput - result2 error - } - CompleteMultipartUploadStub func(*s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error) - completeMultipartUploadMutex sync.RWMutex - completeMultipartUploadArgsForCall []struct { - arg1 *s3.CompleteMultipartUploadInput - } - completeMultipartUploadReturns struct { - result1 *s3.CompleteMultipartUploadOutput - result2 error - } - completeMultipartUploadReturnsOnCall map[int]struct { - result1 *s3.CompleteMultipartUploadOutput - result2 error - } - CompleteMultipartUploadRequestStub func(*s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput) - completeMultipartUploadRequestMutex sync.RWMutex - completeMultipartUploadRequestArgsForCall []struct { - arg1 *s3.CompleteMultipartUploadInput - } - completeMultipartUploadRequestReturns struct { - result1 *request.Request - result2 *s3.CompleteMultipartUploadOutput - } - completeMultipartUploadRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.CompleteMultipartUploadOutput - } - CompleteMultipartUploadWithContextStub func(context.Context, *s3.CompleteMultipartUploadInput, ...request.Option) (*s3.CompleteMultipartUploadOutput, error) - completeMultipartUploadWithContextMutex sync.RWMutex - completeMultipartUploadWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.CompleteMultipartUploadInput - arg3 []request.Option - } - completeMultipartUploadWithContextReturns struct { - result1 *s3.CompleteMultipartUploadOutput - result2 error - } - completeMultipartUploadWithContextReturnsOnCall map[int]struct { - result1 *s3.CompleteMultipartUploadOutput - result2 error - } - CopyObjectStub func(*s3.CopyObjectInput) (*s3.CopyObjectOutput, error) - copyObjectMutex sync.RWMutex - copyObjectArgsForCall []struct { - arg1 *s3.CopyObjectInput - } - copyObjectReturns struct { - result1 *s3.CopyObjectOutput - result2 error - } - copyObjectReturnsOnCall map[int]struct { - result1 *s3.CopyObjectOutput - result2 error - } - CopyObjectRequestStub func(*s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput) - copyObjectRequestMutex sync.RWMutex - copyObjectRequestArgsForCall []struct { - arg1 *s3.CopyObjectInput - } - copyObjectRequestReturns struct { - result1 *request.Request - result2 *s3.CopyObjectOutput - } - copyObjectRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.CopyObjectOutput - } - CopyObjectWithContextStub func(context.Context, *s3.CopyObjectInput, ...request.Option) (*s3.CopyObjectOutput, error) - copyObjectWithContextMutex sync.RWMutex - copyObjectWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.CopyObjectInput - arg3 []request.Option - } - copyObjectWithContextReturns struct { - result1 *s3.CopyObjectOutput - result2 error - } - copyObjectWithContextReturnsOnCall map[int]struct { - result1 *s3.CopyObjectOutput - result2 error - } - CreateBucketStub func(*s3.CreateBucketInput) (*s3.CreateBucketOutput, error) - createBucketMutex sync.RWMutex - createBucketArgsForCall []struct { - arg1 *s3.CreateBucketInput - } - createBucketReturns struct { - result1 *s3.CreateBucketOutput - result2 error - } - createBucketReturnsOnCall map[int]struct { - result1 *s3.CreateBucketOutput - result2 error - } - CreateBucketRequestStub func(*s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput) - createBucketRequestMutex sync.RWMutex - createBucketRequestArgsForCall []struct { - arg1 *s3.CreateBucketInput - } - createBucketRequestReturns struct { - result1 *request.Request - result2 *s3.CreateBucketOutput - } - createBucketRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.CreateBucketOutput - } - CreateBucketWithContextStub func(context.Context, *s3.CreateBucketInput, ...request.Option) (*s3.CreateBucketOutput, error) - createBucketWithContextMutex sync.RWMutex - createBucketWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.CreateBucketInput - arg3 []request.Option - } - createBucketWithContextReturns struct { - result1 *s3.CreateBucketOutput - result2 error - } - createBucketWithContextReturnsOnCall map[int]struct { - result1 *s3.CreateBucketOutput - result2 error - } - CreateMultipartUploadStub func(*s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error) - createMultipartUploadMutex sync.RWMutex - createMultipartUploadArgsForCall []struct { - arg1 *s3.CreateMultipartUploadInput - } - createMultipartUploadReturns struct { - result1 *s3.CreateMultipartUploadOutput - result2 error - } - createMultipartUploadReturnsOnCall map[int]struct { - result1 *s3.CreateMultipartUploadOutput - result2 error - } - CreateMultipartUploadRequestStub func(*s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput) - createMultipartUploadRequestMutex sync.RWMutex - createMultipartUploadRequestArgsForCall []struct { - arg1 *s3.CreateMultipartUploadInput - } - createMultipartUploadRequestReturns struct { - result1 *request.Request - result2 *s3.CreateMultipartUploadOutput - } - createMultipartUploadRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.CreateMultipartUploadOutput - } - CreateMultipartUploadWithContextStub func(context.Context, *s3.CreateMultipartUploadInput, ...request.Option) (*s3.CreateMultipartUploadOutput, error) - createMultipartUploadWithContextMutex sync.RWMutex - createMultipartUploadWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.CreateMultipartUploadInput - arg3 []request.Option - } - createMultipartUploadWithContextReturns struct { - result1 *s3.CreateMultipartUploadOutput - result2 error - } - createMultipartUploadWithContextReturnsOnCall map[int]struct { - result1 *s3.CreateMultipartUploadOutput - result2 error - } - DeleteBucketStub func(*s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error) - deleteBucketMutex sync.RWMutex - deleteBucketArgsForCall []struct { - arg1 *s3.DeleteBucketInput - } - deleteBucketReturns struct { - result1 *s3.DeleteBucketOutput - result2 error - } - deleteBucketReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketOutput - result2 error - } - DeleteBucketAnalyticsConfigurationStub func(*s3.DeleteBucketAnalyticsConfigurationInput) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) - deleteBucketAnalyticsConfigurationMutex sync.RWMutex - deleteBucketAnalyticsConfigurationArgsForCall []struct { - arg1 *s3.DeleteBucketAnalyticsConfigurationInput - } - deleteBucketAnalyticsConfigurationReturns struct { - result1 *s3.DeleteBucketAnalyticsConfigurationOutput - result2 error - } - deleteBucketAnalyticsConfigurationReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketAnalyticsConfigurationOutput - result2 error - } - DeleteBucketAnalyticsConfigurationRequestStub func(*s3.DeleteBucketAnalyticsConfigurationInput) (*request.Request, *s3.DeleteBucketAnalyticsConfigurationOutput) - deleteBucketAnalyticsConfigurationRequestMutex sync.RWMutex - deleteBucketAnalyticsConfigurationRequestArgsForCall []struct { - arg1 *s3.DeleteBucketAnalyticsConfigurationInput - } - deleteBucketAnalyticsConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteBucketAnalyticsConfigurationOutput - } - deleteBucketAnalyticsConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketAnalyticsConfigurationOutput - } - DeleteBucketAnalyticsConfigurationWithContextStub func(context.Context, *s3.DeleteBucketAnalyticsConfigurationInput, ...request.Option) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) - deleteBucketAnalyticsConfigurationWithContextMutex sync.RWMutex - deleteBucketAnalyticsConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteBucketAnalyticsConfigurationInput - arg3 []request.Option - } - deleteBucketAnalyticsConfigurationWithContextReturns struct { - result1 *s3.DeleteBucketAnalyticsConfigurationOutput - result2 error - } - deleteBucketAnalyticsConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketAnalyticsConfigurationOutput - result2 error - } - DeleteBucketCorsStub func(*s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error) - deleteBucketCorsMutex sync.RWMutex - deleteBucketCorsArgsForCall []struct { - arg1 *s3.DeleteBucketCorsInput - } - deleteBucketCorsReturns struct { - result1 *s3.DeleteBucketCorsOutput - result2 error - } - deleteBucketCorsReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketCorsOutput - result2 error - } - DeleteBucketCorsRequestStub func(*s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput) - deleteBucketCorsRequestMutex sync.RWMutex - deleteBucketCorsRequestArgsForCall []struct { - arg1 *s3.DeleteBucketCorsInput - } - deleteBucketCorsRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteBucketCorsOutput - } - deleteBucketCorsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketCorsOutput - } - DeleteBucketCorsWithContextStub func(context.Context, *s3.DeleteBucketCorsInput, ...request.Option) (*s3.DeleteBucketCorsOutput, error) - deleteBucketCorsWithContextMutex sync.RWMutex - deleteBucketCorsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteBucketCorsInput - arg3 []request.Option - } - deleteBucketCorsWithContextReturns struct { - result1 *s3.DeleteBucketCorsOutput - result2 error - } - deleteBucketCorsWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketCorsOutput - result2 error - } - DeleteBucketEncryptionStub func(*s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error) - deleteBucketEncryptionMutex sync.RWMutex - deleteBucketEncryptionArgsForCall []struct { - arg1 *s3.DeleteBucketEncryptionInput - } - deleteBucketEncryptionReturns struct { - result1 *s3.DeleteBucketEncryptionOutput - result2 error - } - deleteBucketEncryptionReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketEncryptionOutput - result2 error - } - DeleteBucketEncryptionRequestStub func(*s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput) - deleteBucketEncryptionRequestMutex sync.RWMutex - deleteBucketEncryptionRequestArgsForCall []struct { - arg1 *s3.DeleteBucketEncryptionInput - } - deleteBucketEncryptionRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteBucketEncryptionOutput - } - deleteBucketEncryptionRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketEncryptionOutput - } - DeleteBucketEncryptionWithContextStub func(context.Context, *s3.DeleteBucketEncryptionInput, ...request.Option) (*s3.DeleteBucketEncryptionOutput, error) - deleteBucketEncryptionWithContextMutex sync.RWMutex - deleteBucketEncryptionWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteBucketEncryptionInput - arg3 []request.Option - } - deleteBucketEncryptionWithContextReturns struct { - result1 *s3.DeleteBucketEncryptionOutput - result2 error - } - deleteBucketEncryptionWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketEncryptionOutput - result2 error - } - DeleteBucketIntelligentTieringConfigurationStub func(*s3.DeleteBucketIntelligentTieringConfigurationInput) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error) - deleteBucketIntelligentTieringConfigurationMutex sync.RWMutex - deleteBucketIntelligentTieringConfigurationArgsForCall []struct { - arg1 *s3.DeleteBucketIntelligentTieringConfigurationInput - } - deleteBucketIntelligentTieringConfigurationReturns struct { - result1 *s3.DeleteBucketIntelligentTieringConfigurationOutput - result2 error - } - deleteBucketIntelligentTieringConfigurationReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketIntelligentTieringConfigurationOutput - result2 error - } - DeleteBucketIntelligentTieringConfigurationRequestStub func(*s3.DeleteBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.DeleteBucketIntelligentTieringConfigurationOutput) - deleteBucketIntelligentTieringConfigurationRequestMutex sync.RWMutex - deleteBucketIntelligentTieringConfigurationRequestArgsForCall []struct { - arg1 *s3.DeleteBucketIntelligentTieringConfigurationInput - } - deleteBucketIntelligentTieringConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteBucketIntelligentTieringConfigurationOutput - } - deleteBucketIntelligentTieringConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketIntelligentTieringConfigurationOutput - } - DeleteBucketIntelligentTieringConfigurationWithContextStub func(context.Context, *s3.DeleteBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error) - deleteBucketIntelligentTieringConfigurationWithContextMutex sync.RWMutex - deleteBucketIntelligentTieringConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteBucketIntelligentTieringConfigurationInput - arg3 []request.Option - } - deleteBucketIntelligentTieringConfigurationWithContextReturns struct { - result1 *s3.DeleteBucketIntelligentTieringConfigurationOutput - result2 error - } - deleteBucketIntelligentTieringConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketIntelligentTieringConfigurationOutput - result2 error - } - DeleteBucketInventoryConfigurationStub func(*s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error) - deleteBucketInventoryConfigurationMutex sync.RWMutex - deleteBucketInventoryConfigurationArgsForCall []struct { - arg1 *s3.DeleteBucketInventoryConfigurationInput - } - deleteBucketInventoryConfigurationReturns struct { - result1 *s3.DeleteBucketInventoryConfigurationOutput - result2 error - } - deleteBucketInventoryConfigurationReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketInventoryConfigurationOutput - result2 error - } - DeleteBucketInventoryConfigurationRequestStub func(*s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput) - deleteBucketInventoryConfigurationRequestMutex sync.RWMutex - deleteBucketInventoryConfigurationRequestArgsForCall []struct { - arg1 *s3.DeleteBucketInventoryConfigurationInput - } - deleteBucketInventoryConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteBucketInventoryConfigurationOutput - } - deleteBucketInventoryConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketInventoryConfigurationOutput - } - DeleteBucketInventoryConfigurationWithContextStub func(context.Context, *s3.DeleteBucketInventoryConfigurationInput, ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error) - deleteBucketInventoryConfigurationWithContextMutex sync.RWMutex - deleteBucketInventoryConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteBucketInventoryConfigurationInput - arg3 []request.Option - } - deleteBucketInventoryConfigurationWithContextReturns struct { - result1 *s3.DeleteBucketInventoryConfigurationOutput - result2 error - } - deleteBucketInventoryConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketInventoryConfigurationOutput - result2 error - } - DeleteBucketLifecycleStub func(*s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error) - deleteBucketLifecycleMutex sync.RWMutex - deleteBucketLifecycleArgsForCall []struct { - arg1 *s3.DeleteBucketLifecycleInput - } - deleteBucketLifecycleReturns struct { - result1 *s3.DeleteBucketLifecycleOutput - result2 error - } - deleteBucketLifecycleReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketLifecycleOutput - result2 error - } - DeleteBucketLifecycleRequestStub func(*s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput) - deleteBucketLifecycleRequestMutex sync.RWMutex - deleteBucketLifecycleRequestArgsForCall []struct { - arg1 *s3.DeleteBucketLifecycleInput - } - deleteBucketLifecycleRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteBucketLifecycleOutput - } - deleteBucketLifecycleRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketLifecycleOutput - } - DeleteBucketLifecycleWithContextStub func(context.Context, *s3.DeleteBucketLifecycleInput, ...request.Option) (*s3.DeleteBucketLifecycleOutput, error) - deleteBucketLifecycleWithContextMutex sync.RWMutex - deleteBucketLifecycleWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteBucketLifecycleInput - arg3 []request.Option - } - deleteBucketLifecycleWithContextReturns struct { - result1 *s3.DeleteBucketLifecycleOutput - result2 error - } - deleteBucketLifecycleWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketLifecycleOutput - result2 error - } - DeleteBucketMetricsConfigurationStub func(*s3.DeleteBucketMetricsConfigurationInput) (*s3.DeleteBucketMetricsConfigurationOutput, error) - deleteBucketMetricsConfigurationMutex sync.RWMutex - deleteBucketMetricsConfigurationArgsForCall []struct { - arg1 *s3.DeleteBucketMetricsConfigurationInput - } - deleteBucketMetricsConfigurationReturns struct { - result1 *s3.DeleteBucketMetricsConfigurationOutput - result2 error - } - deleteBucketMetricsConfigurationReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketMetricsConfigurationOutput - result2 error - } - DeleteBucketMetricsConfigurationRequestStub func(*s3.DeleteBucketMetricsConfigurationInput) (*request.Request, *s3.DeleteBucketMetricsConfigurationOutput) - deleteBucketMetricsConfigurationRequestMutex sync.RWMutex - deleteBucketMetricsConfigurationRequestArgsForCall []struct { - arg1 *s3.DeleteBucketMetricsConfigurationInput - } - deleteBucketMetricsConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteBucketMetricsConfigurationOutput - } - deleteBucketMetricsConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketMetricsConfigurationOutput - } - DeleteBucketMetricsConfigurationWithContextStub func(context.Context, *s3.DeleteBucketMetricsConfigurationInput, ...request.Option) (*s3.DeleteBucketMetricsConfigurationOutput, error) - deleteBucketMetricsConfigurationWithContextMutex sync.RWMutex - deleteBucketMetricsConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteBucketMetricsConfigurationInput - arg3 []request.Option - } - deleteBucketMetricsConfigurationWithContextReturns struct { - result1 *s3.DeleteBucketMetricsConfigurationOutput - result2 error - } - deleteBucketMetricsConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketMetricsConfigurationOutput - result2 error - } - DeleteBucketOwnershipControlsStub func(*s3.DeleteBucketOwnershipControlsInput) (*s3.DeleteBucketOwnershipControlsOutput, error) - deleteBucketOwnershipControlsMutex sync.RWMutex - deleteBucketOwnershipControlsArgsForCall []struct { - arg1 *s3.DeleteBucketOwnershipControlsInput - } - deleteBucketOwnershipControlsReturns struct { - result1 *s3.DeleteBucketOwnershipControlsOutput - result2 error - } - deleteBucketOwnershipControlsReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketOwnershipControlsOutput - result2 error - } - DeleteBucketOwnershipControlsRequestStub func(*s3.DeleteBucketOwnershipControlsInput) (*request.Request, *s3.DeleteBucketOwnershipControlsOutput) - deleteBucketOwnershipControlsRequestMutex sync.RWMutex - deleteBucketOwnershipControlsRequestArgsForCall []struct { - arg1 *s3.DeleteBucketOwnershipControlsInput - } - deleteBucketOwnershipControlsRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteBucketOwnershipControlsOutput - } - deleteBucketOwnershipControlsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketOwnershipControlsOutput - } - DeleteBucketOwnershipControlsWithContextStub func(context.Context, *s3.DeleteBucketOwnershipControlsInput, ...request.Option) (*s3.DeleteBucketOwnershipControlsOutput, error) - deleteBucketOwnershipControlsWithContextMutex sync.RWMutex - deleteBucketOwnershipControlsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteBucketOwnershipControlsInput - arg3 []request.Option - } - deleteBucketOwnershipControlsWithContextReturns struct { - result1 *s3.DeleteBucketOwnershipControlsOutput - result2 error - } - deleteBucketOwnershipControlsWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketOwnershipControlsOutput - result2 error - } - DeleteBucketPolicyStub func(*s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error) - deleteBucketPolicyMutex sync.RWMutex - deleteBucketPolicyArgsForCall []struct { - arg1 *s3.DeleteBucketPolicyInput - } - deleteBucketPolicyReturns struct { - result1 *s3.DeleteBucketPolicyOutput - result2 error - } - deleteBucketPolicyReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketPolicyOutput - result2 error - } - DeleteBucketPolicyRequestStub func(*s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput) - deleteBucketPolicyRequestMutex sync.RWMutex - deleteBucketPolicyRequestArgsForCall []struct { - arg1 *s3.DeleteBucketPolicyInput - } - deleteBucketPolicyRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteBucketPolicyOutput - } - deleteBucketPolicyRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketPolicyOutput - } - DeleteBucketPolicyWithContextStub func(context.Context, *s3.DeleteBucketPolicyInput, ...request.Option) (*s3.DeleteBucketPolicyOutput, error) - deleteBucketPolicyWithContextMutex sync.RWMutex - deleteBucketPolicyWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteBucketPolicyInput - arg3 []request.Option - } - deleteBucketPolicyWithContextReturns struct { - result1 *s3.DeleteBucketPolicyOutput - result2 error - } - deleteBucketPolicyWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketPolicyOutput - result2 error - } - DeleteBucketReplicationStub func(*s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error) - deleteBucketReplicationMutex sync.RWMutex - deleteBucketReplicationArgsForCall []struct { - arg1 *s3.DeleteBucketReplicationInput - } - deleteBucketReplicationReturns struct { - result1 *s3.DeleteBucketReplicationOutput - result2 error - } - deleteBucketReplicationReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketReplicationOutput - result2 error - } - DeleteBucketReplicationRequestStub func(*s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput) - deleteBucketReplicationRequestMutex sync.RWMutex - deleteBucketReplicationRequestArgsForCall []struct { - arg1 *s3.DeleteBucketReplicationInput - } - deleteBucketReplicationRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteBucketReplicationOutput - } - deleteBucketReplicationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketReplicationOutput - } - DeleteBucketReplicationWithContextStub func(context.Context, *s3.DeleteBucketReplicationInput, ...request.Option) (*s3.DeleteBucketReplicationOutput, error) - deleteBucketReplicationWithContextMutex sync.RWMutex - deleteBucketReplicationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteBucketReplicationInput - arg3 []request.Option - } - deleteBucketReplicationWithContextReturns struct { - result1 *s3.DeleteBucketReplicationOutput - result2 error - } - deleteBucketReplicationWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketReplicationOutput - result2 error - } - DeleteBucketRequestStub func(*s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput) - deleteBucketRequestMutex sync.RWMutex - deleteBucketRequestArgsForCall []struct { - arg1 *s3.DeleteBucketInput - } - deleteBucketRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteBucketOutput - } - deleteBucketRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketOutput - } - DeleteBucketTaggingStub func(*s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error) - deleteBucketTaggingMutex sync.RWMutex - deleteBucketTaggingArgsForCall []struct { - arg1 *s3.DeleteBucketTaggingInput - } - deleteBucketTaggingReturns struct { - result1 *s3.DeleteBucketTaggingOutput - result2 error - } - deleteBucketTaggingReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketTaggingOutput - result2 error - } - DeleteBucketTaggingRequestStub func(*s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput) - deleteBucketTaggingRequestMutex sync.RWMutex - deleteBucketTaggingRequestArgsForCall []struct { - arg1 *s3.DeleteBucketTaggingInput - } - deleteBucketTaggingRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteBucketTaggingOutput - } - deleteBucketTaggingRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketTaggingOutput - } - DeleteBucketTaggingWithContextStub func(context.Context, *s3.DeleteBucketTaggingInput, ...request.Option) (*s3.DeleteBucketTaggingOutput, error) - deleteBucketTaggingWithContextMutex sync.RWMutex - deleteBucketTaggingWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteBucketTaggingInput - arg3 []request.Option - } - deleteBucketTaggingWithContextReturns struct { - result1 *s3.DeleteBucketTaggingOutput - result2 error - } - deleteBucketTaggingWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketTaggingOutput - result2 error - } - DeleteBucketWebsiteStub func(*s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error) - deleteBucketWebsiteMutex sync.RWMutex - deleteBucketWebsiteArgsForCall []struct { - arg1 *s3.DeleteBucketWebsiteInput - } - deleteBucketWebsiteReturns struct { - result1 *s3.DeleteBucketWebsiteOutput - result2 error - } - deleteBucketWebsiteReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketWebsiteOutput - result2 error - } - DeleteBucketWebsiteRequestStub func(*s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput) - deleteBucketWebsiteRequestMutex sync.RWMutex - deleteBucketWebsiteRequestArgsForCall []struct { - arg1 *s3.DeleteBucketWebsiteInput - } - deleteBucketWebsiteRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteBucketWebsiteOutput - } - deleteBucketWebsiteRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketWebsiteOutput - } - DeleteBucketWebsiteWithContextStub func(context.Context, *s3.DeleteBucketWebsiteInput, ...request.Option) (*s3.DeleteBucketWebsiteOutput, error) - deleteBucketWebsiteWithContextMutex sync.RWMutex - deleteBucketWebsiteWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteBucketWebsiteInput - arg3 []request.Option - } - deleteBucketWebsiteWithContextReturns struct { - result1 *s3.DeleteBucketWebsiteOutput - result2 error - } - deleteBucketWebsiteWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketWebsiteOutput - result2 error - } - DeleteBucketWithContextStub func(context.Context, *s3.DeleteBucketInput, ...request.Option) (*s3.DeleteBucketOutput, error) - deleteBucketWithContextMutex sync.RWMutex - deleteBucketWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteBucketInput - arg3 []request.Option - } - deleteBucketWithContextReturns struct { - result1 *s3.DeleteBucketOutput - result2 error - } - deleteBucketWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteBucketOutput - result2 error - } - DeleteObjectStub func(*s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error) - deleteObjectMutex sync.RWMutex - deleteObjectArgsForCall []struct { - arg1 *s3.DeleteObjectInput - } - deleteObjectReturns struct { - result1 *s3.DeleteObjectOutput - result2 error - } - deleteObjectReturnsOnCall map[int]struct { - result1 *s3.DeleteObjectOutput - result2 error - } - DeleteObjectRequestStub func(*s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput) - deleteObjectRequestMutex sync.RWMutex - deleteObjectRequestArgsForCall []struct { - arg1 *s3.DeleteObjectInput - } - deleteObjectRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteObjectOutput - } - deleteObjectRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteObjectOutput - } - DeleteObjectTaggingStub func(*s3.DeleteObjectTaggingInput) (*s3.DeleteObjectTaggingOutput, error) - deleteObjectTaggingMutex sync.RWMutex - deleteObjectTaggingArgsForCall []struct { - arg1 *s3.DeleteObjectTaggingInput - } - deleteObjectTaggingReturns struct { - result1 *s3.DeleteObjectTaggingOutput - result2 error - } - deleteObjectTaggingReturnsOnCall map[int]struct { - result1 *s3.DeleteObjectTaggingOutput - result2 error - } - DeleteObjectTaggingRequestStub func(*s3.DeleteObjectTaggingInput) (*request.Request, *s3.DeleteObjectTaggingOutput) - deleteObjectTaggingRequestMutex sync.RWMutex - deleteObjectTaggingRequestArgsForCall []struct { - arg1 *s3.DeleteObjectTaggingInput - } - deleteObjectTaggingRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteObjectTaggingOutput - } - deleteObjectTaggingRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteObjectTaggingOutput - } - DeleteObjectTaggingWithContextStub func(context.Context, *s3.DeleteObjectTaggingInput, ...request.Option) (*s3.DeleteObjectTaggingOutput, error) - deleteObjectTaggingWithContextMutex sync.RWMutex - deleteObjectTaggingWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteObjectTaggingInput - arg3 []request.Option - } - deleteObjectTaggingWithContextReturns struct { - result1 *s3.DeleteObjectTaggingOutput - result2 error - } - deleteObjectTaggingWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteObjectTaggingOutput - result2 error - } - DeleteObjectWithContextStub func(context.Context, *s3.DeleteObjectInput, ...request.Option) (*s3.DeleteObjectOutput, error) - deleteObjectWithContextMutex sync.RWMutex - deleteObjectWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteObjectInput - arg3 []request.Option - } - deleteObjectWithContextReturns struct { - result1 *s3.DeleteObjectOutput - result2 error - } - deleteObjectWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteObjectOutput - result2 error - } - DeleteObjectsStub func(*s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error) - deleteObjectsMutex sync.RWMutex - deleteObjectsArgsForCall []struct { - arg1 *s3.DeleteObjectsInput - } - deleteObjectsReturns struct { - result1 *s3.DeleteObjectsOutput - result2 error - } - deleteObjectsReturnsOnCall map[int]struct { - result1 *s3.DeleteObjectsOutput - result2 error - } - DeleteObjectsRequestStub func(*s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput) - deleteObjectsRequestMutex sync.RWMutex - deleteObjectsRequestArgsForCall []struct { - arg1 *s3.DeleteObjectsInput - } - deleteObjectsRequestReturns struct { - result1 *request.Request - result2 *s3.DeleteObjectsOutput - } - deleteObjectsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeleteObjectsOutput - } - DeleteObjectsWithContextStub func(context.Context, *s3.DeleteObjectsInput, ...request.Option) (*s3.DeleteObjectsOutput, error) - deleteObjectsWithContextMutex sync.RWMutex - deleteObjectsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeleteObjectsInput - arg3 []request.Option - } - deleteObjectsWithContextReturns struct { - result1 *s3.DeleteObjectsOutput - result2 error - } - deleteObjectsWithContextReturnsOnCall map[int]struct { - result1 *s3.DeleteObjectsOutput - result2 error - } - DeletePublicAccessBlockStub func(*s3.DeletePublicAccessBlockInput) (*s3.DeletePublicAccessBlockOutput, error) - deletePublicAccessBlockMutex sync.RWMutex - deletePublicAccessBlockArgsForCall []struct { - arg1 *s3.DeletePublicAccessBlockInput - } - deletePublicAccessBlockReturns struct { - result1 *s3.DeletePublicAccessBlockOutput - result2 error - } - deletePublicAccessBlockReturnsOnCall map[int]struct { - result1 *s3.DeletePublicAccessBlockOutput - result2 error - } - DeletePublicAccessBlockRequestStub func(*s3.DeletePublicAccessBlockInput) (*request.Request, *s3.DeletePublicAccessBlockOutput) - deletePublicAccessBlockRequestMutex sync.RWMutex - deletePublicAccessBlockRequestArgsForCall []struct { - arg1 *s3.DeletePublicAccessBlockInput - } - deletePublicAccessBlockRequestReturns struct { - result1 *request.Request - result2 *s3.DeletePublicAccessBlockOutput - } - deletePublicAccessBlockRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.DeletePublicAccessBlockOutput - } - DeletePublicAccessBlockWithContextStub func(context.Context, *s3.DeletePublicAccessBlockInput, ...request.Option) (*s3.DeletePublicAccessBlockOutput, error) - deletePublicAccessBlockWithContextMutex sync.RWMutex - deletePublicAccessBlockWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.DeletePublicAccessBlockInput - arg3 []request.Option - } - deletePublicAccessBlockWithContextReturns struct { - result1 *s3.DeletePublicAccessBlockOutput - result2 error - } - deletePublicAccessBlockWithContextReturnsOnCall map[int]struct { - result1 *s3.DeletePublicAccessBlockOutput - result2 error - } - GetBucketAccelerateConfigurationStub func(*s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error) - getBucketAccelerateConfigurationMutex sync.RWMutex - getBucketAccelerateConfigurationArgsForCall []struct { - arg1 *s3.GetBucketAccelerateConfigurationInput - } - getBucketAccelerateConfigurationReturns struct { - result1 *s3.GetBucketAccelerateConfigurationOutput - result2 error - } - getBucketAccelerateConfigurationReturnsOnCall map[int]struct { - result1 *s3.GetBucketAccelerateConfigurationOutput - result2 error - } - GetBucketAccelerateConfigurationRequestStub func(*s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput) - getBucketAccelerateConfigurationRequestMutex sync.RWMutex - getBucketAccelerateConfigurationRequestArgsForCall []struct { - arg1 *s3.GetBucketAccelerateConfigurationInput - } - getBucketAccelerateConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketAccelerateConfigurationOutput - } - getBucketAccelerateConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketAccelerateConfigurationOutput - } - GetBucketAccelerateConfigurationWithContextStub func(context.Context, *s3.GetBucketAccelerateConfigurationInput, ...request.Option) (*s3.GetBucketAccelerateConfigurationOutput, error) - getBucketAccelerateConfigurationWithContextMutex sync.RWMutex - getBucketAccelerateConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketAccelerateConfigurationInput - arg3 []request.Option - } - getBucketAccelerateConfigurationWithContextReturns struct { - result1 *s3.GetBucketAccelerateConfigurationOutput - result2 error - } - getBucketAccelerateConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketAccelerateConfigurationOutput - result2 error - } - GetBucketAclStub func(*s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error) - getBucketAclMutex sync.RWMutex - getBucketAclArgsForCall []struct { - arg1 *s3.GetBucketAclInput - } - getBucketAclReturns struct { - result1 *s3.GetBucketAclOutput - result2 error - } - getBucketAclReturnsOnCall map[int]struct { - result1 *s3.GetBucketAclOutput - result2 error - } - GetBucketAclRequestStub func(*s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput) - getBucketAclRequestMutex sync.RWMutex - getBucketAclRequestArgsForCall []struct { - arg1 *s3.GetBucketAclInput - } - getBucketAclRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketAclOutput - } - getBucketAclRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketAclOutput - } - GetBucketAclWithContextStub func(context.Context, *s3.GetBucketAclInput, ...request.Option) (*s3.GetBucketAclOutput, error) - getBucketAclWithContextMutex sync.RWMutex - getBucketAclWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketAclInput - arg3 []request.Option - } - getBucketAclWithContextReturns struct { - result1 *s3.GetBucketAclOutput - result2 error - } - getBucketAclWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketAclOutput - result2 error - } - GetBucketAnalyticsConfigurationStub func(*s3.GetBucketAnalyticsConfigurationInput) (*s3.GetBucketAnalyticsConfigurationOutput, error) - getBucketAnalyticsConfigurationMutex sync.RWMutex - getBucketAnalyticsConfigurationArgsForCall []struct { - arg1 *s3.GetBucketAnalyticsConfigurationInput - } - getBucketAnalyticsConfigurationReturns struct { - result1 *s3.GetBucketAnalyticsConfigurationOutput - result2 error - } - getBucketAnalyticsConfigurationReturnsOnCall map[int]struct { - result1 *s3.GetBucketAnalyticsConfigurationOutput - result2 error - } - GetBucketAnalyticsConfigurationRequestStub func(*s3.GetBucketAnalyticsConfigurationInput) (*request.Request, *s3.GetBucketAnalyticsConfigurationOutput) - getBucketAnalyticsConfigurationRequestMutex sync.RWMutex - getBucketAnalyticsConfigurationRequestArgsForCall []struct { - arg1 *s3.GetBucketAnalyticsConfigurationInput - } - getBucketAnalyticsConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketAnalyticsConfigurationOutput - } - getBucketAnalyticsConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketAnalyticsConfigurationOutput - } - GetBucketAnalyticsConfigurationWithContextStub func(context.Context, *s3.GetBucketAnalyticsConfigurationInput, ...request.Option) (*s3.GetBucketAnalyticsConfigurationOutput, error) - getBucketAnalyticsConfigurationWithContextMutex sync.RWMutex - getBucketAnalyticsConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketAnalyticsConfigurationInput - arg3 []request.Option - } - getBucketAnalyticsConfigurationWithContextReturns struct { - result1 *s3.GetBucketAnalyticsConfigurationOutput - result2 error - } - getBucketAnalyticsConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketAnalyticsConfigurationOutput - result2 error - } - GetBucketCorsStub func(*s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error) - getBucketCorsMutex sync.RWMutex - getBucketCorsArgsForCall []struct { - arg1 *s3.GetBucketCorsInput - } - getBucketCorsReturns struct { - result1 *s3.GetBucketCorsOutput - result2 error - } - getBucketCorsReturnsOnCall map[int]struct { - result1 *s3.GetBucketCorsOutput - result2 error - } - GetBucketCorsRequestStub func(*s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput) - getBucketCorsRequestMutex sync.RWMutex - getBucketCorsRequestArgsForCall []struct { - arg1 *s3.GetBucketCorsInput - } - getBucketCorsRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketCorsOutput - } - getBucketCorsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketCorsOutput - } - GetBucketCorsWithContextStub func(context.Context, *s3.GetBucketCorsInput, ...request.Option) (*s3.GetBucketCorsOutput, error) - getBucketCorsWithContextMutex sync.RWMutex - getBucketCorsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketCorsInput - arg3 []request.Option - } - getBucketCorsWithContextReturns struct { - result1 *s3.GetBucketCorsOutput - result2 error - } - getBucketCorsWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketCorsOutput - result2 error - } - GetBucketEncryptionStub func(*s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error) - getBucketEncryptionMutex sync.RWMutex - getBucketEncryptionArgsForCall []struct { - arg1 *s3.GetBucketEncryptionInput - } - getBucketEncryptionReturns struct { - result1 *s3.GetBucketEncryptionOutput - result2 error - } - getBucketEncryptionReturnsOnCall map[int]struct { - result1 *s3.GetBucketEncryptionOutput - result2 error - } - GetBucketEncryptionRequestStub func(*s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput) - getBucketEncryptionRequestMutex sync.RWMutex - getBucketEncryptionRequestArgsForCall []struct { - arg1 *s3.GetBucketEncryptionInput - } - getBucketEncryptionRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketEncryptionOutput - } - getBucketEncryptionRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketEncryptionOutput - } - GetBucketEncryptionWithContextStub func(context.Context, *s3.GetBucketEncryptionInput, ...request.Option) (*s3.GetBucketEncryptionOutput, error) - getBucketEncryptionWithContextMutex sync.RWMutex - getBucketEncryptionWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketEncryptionInput - arg3 []request.Option - } - getBucketEncryptionWithContextReturns struct { - result1 *s3.GetBucketEncryptionOutput - result2 error - } - getBucketEncryptionWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketEncryptionOutput - result2 error - } - GetBucketIntelligentTieringConfigurationStub func(*s3.GetBucketIntelligentTieringConfigurationInput) (*s3.GetBucketIntelligentTieringConfigurationOutput, error) - getBucketIntelligentTieringConfigurationMutex sync.RWMutex - getBucketIntelligentTieringConfigurationArgsForCall []struct { - arg1 *s3.GetBucketIntelligentTieringConfigurationInput - } - getBucketIntelligentTieringConfigurationReturns struct { - result1 *s3.GetBucketIntelligentTieringConfigurationOutput - result2 error - } - getBucketIntelligentTieringConfigurationReturnsOnCall map[int]struct { - result1 *s3.GetBucketIntelligentTieringConfigurationOutput - result2 error - } - GetBucketIntelligentTieringConfigurationRequestStub func(*s3.GetBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.GetBucketIntelligentTieringConfigurationOutput) - getBucketIntelligentTieringConfigurationRequestMutex sync.RWMutex - getBucketIntelligentTieringConfigurationRequestArgsForCall []struct { - arg1 *s3.GetBucketIntelligentTieringConfigurationInput - } - getBucketIntelligentTieringConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketIntelligentTieringConfigurationOutput - } - getBucketIntelligentTieringConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketIntelligentTieringConfigurationOutput - } - GetBucketIntelligentTieringConfigurationWithContextStub func(context.Context, *s3.GetBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.GetBucketIntelligentTieringConfigurationOutput, error) - getBucketIntelligentTieringConfigurationWithContextMutex sync.RWMutex - getBucketIntelligentTieringConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketIntelligentTieringConfigurationInput - arg3 []request.Option - } - getBucketIntelligentTieringConfigurationWithContextReturns struct { - result1 *s3.GetBucketIntelligentTieringConfigurationOutput - result2 error - } - getBucketIntelligentTieringConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketIntelligentTieringConfigurationOutput - result2 error - } - GetBucketInventoryConfigurationStub func(*s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error) - getBucketInventoryConfigurationMutex sync.RWMutex - getBucketInventoryConfigurationArgsForCall []struct { - arg1 *s3.GetBucketInventoryConfigurationInput - } - getBucketInventoryConfigurationReturns struct { - result1 *s3.GetBucketInventoryConfigurationOutput - result2 error - } - getBucketInventoryConfigurationReturnsOnCall map[int]struct { - result1 *s3.GetBucketInventoryConfigurationOutput - result2 error - } - GetBucketInventoryConfigurationRequestStub func(*s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput) - getBucketInventoryConfigurationRequestMutex sync.RWMutex - getBucketInventoryConfigurationRequestArgsForCall []struct { - arg1 *s3.GetBucketInventoryConfigurationInput - } - getBucketInventoryConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketInventoryConfigurationOutput - } - getBucketInventoryConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketInventoryConfigurationOutput - } - GetBucketInventoryConfigurationWithContextStub func(context.Context, *s3.GetBucketInventoryConfigurationInput, ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error) - getBucketInventoryConfigurationWithContextMutex sync.RWMutex - getBucketInventoryConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketInventoryConfigurationInput - arg3 []request.Option - } - getBucketInventoryConfigurationWithContextReturns struct { - result1 *s3.GetBucketInventoryConfigurationOutput - result2 error - } - getBucketInventoryConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketInventoryConfigurationOutput - result2 error - } - GetBucketLifecycleStub func(*s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error) - getBucketLifecycleMutex sync.RWMutex - getBucketLifecycleArgsForCall []struct { - arg1 *s3.GetBucketLifecycleInput - } - getBucketLifecycleReturns struct { - result1 *s3.GetBucketLifecycleOutput - result2 error - } - getBucketLifecycleReturnsOnCall map[int]struct { - result1 *s3.GetBucketLifecycleOutput - result2 error - } - GetBucketLifecycleConfigurationStub func(*s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error) - getBucketLifecycleConfigurationMutex sync.RWMutex - getBucketLifecycleConfigurationArgsForCall []struct { - arg1 *s3.GetBucketLifecycleConfigurationInput - } - getBucketLifecycleConfigurationReturns struct { - result1 *s3.GetBucketLifecycleConfigurationOutput - result2 error - } - getBucketLifecycleConfigurationReturnsOnCall map[int]struct { - result1 *s3.GetBucketLifecycleConfigurationOutput - result2 error - } - GetBucketLifecycleConfigurationRequestStub func(*s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput) - getBucketLifecycleConfigurationRequestMutex sync.RWMutex - getBucketLifecycleConfigurationRequestArgsForCall []struct { - arg1 *s3.GetBucketLifecycleConfigurationInput - } - getBucketLifecycleConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketLifecycleConfigurationOutput - } - getBucketLifecycleConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketLifecycleConfigurationOutput - } - GetBucketLifecycleConfigurationWithContextStub func(context.Context, *s3.GetBucketLifecycleConfigurationInput, ...request.Option) (*s3.GetBucketLifecycleConfigurationOutput, error) - getBucketLifecycleConfigurationWithContextMutex sync.RWMutex - getBucketLifecycleConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketLifecycleConfigurationInput - arg3 []request.Option - } - getBucketLifecycleConfigurationWithContextReturns struct { - result1 *s3.GetBucketLifecycleConfigurationOutput - result2 error - } - getBucketLifecycleConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketLifecycleConfigurationOutput - result2 error - } - GetBucketLifecycleRequestStub func(*s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput) - getBucketLifecycleRequestMutex sync.RWMutex - getBucketLifecycleRequestArgsForCall []struct { - arg1 *s3.GetBucketLifecycleInput - } - getBucketLifecycleRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketLifecycleOutput - } - getBucketLifecycleRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketLifecycleOutput - } - GetBucketLifecycleWithContextStub func(context.Context, *s3.GetBucketLifecycleInput, ...request.Option) (*s3.GetBucketLifecycleOutput, error) - getBucketLifecycleWithContextMutex sync.RWMutex - getBucketLifecycleWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketLifecycleInput - arg3 []request.Option - } - getBucketLifecycleWithContextReturns struct { - result1 *s3.GetBucketLifecycleOutput - result2 error - } - getBucketLifecycleWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketLifecycleOutput - result2 error - } - GetBucketLocationStub func(*s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error) - getBucketLocationMutex sync.RWMutex - getBucketLocationArgsForCall []struct { - arg1 *s3.GetBucketLocationInput - } - getBucketLocationReturns struct { - result1 *s3.GetBucketLocationOutput - result2 error - } - getBucketLocationReturnsOnCall map[int]struct { - result1 *s3.GetBucketLocationOutput - result2 error - } - GetBucketLocationRequestStub func(*s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput) - getBucketLocationRequestMutex sync.RWMutex - getBucketLocationRequestArgsForCall []struct { - arg1 *s3.GetBucketLocationInput - } - getBucketLocationRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketLocationOutput - } - getBucketLocationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketLocationOutput - } - GetBucketLocationWithContextStub func(context.Context, *s3.GetBucketLocationInput, ...request.Option) (*s3.GetBucketLocationOutput, error) - getBucketLocationWithContextMutex sync.RWMutex - getBucketLocationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketLocationInput - arg3 []request.Option - } - getBucketLocationWithContextReturns struct { - result1 *s3.GetBucketLocationOutput - result2 error - } - getBucketLocationWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketLocationOutput - result2 error - } - GetBucketLoggingStub func(*s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error) - getBucketLoggingMutex sync.RWMutex - getBucketLoggingArgsForCall []struct { - arg1 *s3.GetBucketLoggingInput - } - getBucketLoggingReturns struct { - result1 *s3.GetBucketLoggingOutput - result2 error - } - getBucketLoggingReturnsOnCall map[int]struct { - result1 *s3.GetBucketLoggingOutput - result2 error - } - GetBucketLoggingRequestStub func(*s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput) - getBucketLoggingRequestMutex sync.RWMutex - getBucketLoggingRequestArgsForCall []struct { - arg1 *s3.GetBucketLoggingInput - } - getBucketLoggingRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketLoggingOutput - } - getBucketLoggingRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketLoggingOutput - } - GetBucketLoggingWithContextStub func(context.Context, *s3.GetBucketLoggingInput, ...request.Option) (*s3.GetBucketLoggingOutput, error) - getBucketLoggingWithContextMutex sync.RWMutex - getBucketLoggingWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketLoggingInput - arg3 []request.Option - } - getBucketLoggingWithContextReturns struct { - result1 *s3.GetBucketLoggingOutput - result2 error - } - getBucketLoggingWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketLoggingOutput - result2 error - } - GetBucketMetricsConfigurationStub func(*s3.GetBucketMetricsConfigurationInput) (*s3.GetBucketMetricsConfigurationOutput, error) - getBucketMetricsConfigurationMutex sync.RWMutex - getBucketMetricsConfigurationArgsForCall []struct { - arg1 *s3.GetBucketMetricsConfigurationInput - } - getBucketMetricsConfigurationReturns struct { - result1 *s3.GetBucketMetricsConfigurationOutput - result2 error - } - getBucketMetricsConfigurationReturnsOnCall map[int]struct { - result1 *s3.GetBucketMetricsConfigurationOutput - result2 error - } - GetBucketMetricsConfigurationRequestStub func(*s3.GetBucketMetricsConfigurationInput) (*request.Request, *s3.GetBucketMetricsConfigurationOutput) - getBucketMetricsConfigurationRequestMutex sync.RWMutex - getBucketMetricsConfigurationRequestArgsForCall []struct { - arg1 *s3.GetBucketMetricsConfigurationInput - } - getBucketMetricsConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketMetricsConfigurationOutput - } - getBucketMetricsConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketMetricsConfigurationOutput - } - GetBucketMetricsConfigurationWithContextStub func(context.Context, *s3.GetBucketMetricsConfigurationInput, ...request.Option) (*s3.GetBucketMetricsConfigurationOutput, error) - getBucketMetricsConfigurationWithContextMutex sync.RWMutex - getBucketMetricsConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketMetricsConfigurationInput - arg3 []request.Option - } - getBucketMetricsConfigurationWithContextReturns struct { - result1 *s3.GetBucketMetricsConfigurationOutput - result2 error - } - getBucketMetricsConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketMetricsConfigurationOutput - result2 error - } - GetBucketNotificationStub func(*s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error) - getBucketNotificationMutex sync.RWMutex - getBucketNotificationArgsForCall []struct { - arg1 *s3.GetBucketNotificationConfigurationRequest - } - getBucketNotificationReturns struct { - result1 *s3.NotificationConfigurationDeprecated - result2 error - } - getBucketNotificationReturnsOnCall map[int]struct { - result1 *s3.NotificationConfigurationDeprecated - result2 error - } - GetBucketNotificationConfigurationStub func(*s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error) - getBucketNotificationConfigurationMutex sync.RWMutex - getBucketNotificationConfigurationArgsForCall []struct { - arg1 *s3.GetBucketNotificationConfigurationRequest - } - getBucketNotificationConfigurationReturns struct { - result1 *s3.NotificationConfiguration - result2 error - } - getBucketNotificationConfigurationReturnsOnCall map[int]struct { - result1 *s3.NotificationConfiguration - result2 error - } - GetBucketNotificationConfigurationRequestStub func(*s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration) - getBucketNotificationConfigurationRequestMutex sync.RWMutex - getBucketNotificationConfigurationRequestArgsForCall []struct { - arg1 *s3.GetBucketNotificationConfigurationRequest - } - getBucketNotificationConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.NotificationConfiguration - } - getBucketNotificationConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.NotificationConfiguration - } - GetBucketNotificationConfigurationWithContextStub func(context.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) (*s3.NotificationConfiguration, error) - getBucketNotificationConfigurationWithContextMutex sync.RWMutex - getBucketNotificationConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketNotificationConfigurationRequest - arg3 []request.Option - } - getBucketNotificationConfigurationWithContextReturns struct { - result1 *s3.NotificationConfiguration - result2 error - } - getBucketNotificationConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.NotificationConfiguration - result2 error - } - GetBucketNotificationRequestStub func(*s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated) - getBucketNotificationRequestMutex sync.RWMutex - getBucketNotificationRequestArgsForCall []struct { - arg1 *s3.GetBucketNotificationConfigurationRequest - } - getBucketNotificationRequestReturns struct { - result1 *request.Request - result2 *s3.NotificationConfigurationDeprecated - } - getBucketNotificationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.NotificationConfigurationDeprecated - } - GetBucketNotificationWithContextStub func(context.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) (*s3.NotificationConfigurationDeprecated, error) - getBucketNotificationWithContextMutex sync.RWMutex - getBucketNotificationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketNotificationConfigurationRequest - arg3 []request.Option - } - getBucketNotificationWithContextReturns struct { - result1 *s3.NotificationConfigurationDeprecated - result2 error - } - getBucketNotificationWithContextReturnsOnCall map[int]struct { - result1 *s3.NotificationConfigurationDeprecated - result2 error - } - GetBucketOwnershipControlsStub func(*s3.GetBucketOwnershipControlsInput) (*s3.GetBucketOwnershipControlsOutput, error) - getBucketOwnershipControlsMutex sync.RWMutex - getBucketOwnershipControlsArgsForCall []struct { - arg1 *s3.GetBucketOwnershipControlsInput - } - getBucketOwnershipControlsReturns struct { - result1 *s3.GetBucketOwnershipControlsOutput - result2 error - } - getBucketOwnershipControlsReturnsOnCall map[int]struct { - result1 *s3.GetBucketOwnershipControlsOutput - result2 error - } - GetBucketOwnershipControlsRequestStub func(*s3.GetBucketOwnershipControlsInput) (*request.Request, *s3.GetBucketOwnershipControlsOutput) - getBucketOwnershipControlsRequestMutex sync.RWMutex - getBucketOwnershipControlsRequestArgsForCall []struct { - arg1 *s3.GetBucketOwnershipControlsInput - } - getBucketOwnershipControlsRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketOwnershipControlsOutput - } - getBucketOwnershipControlsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketOwnershipControlsOutput - } - GetBucketOwnershipControlsWithContextStub func(context.Context, *s3.GetBucketOwnershipControlsInput, ...request.Option) (*s3.GetBucketOwnershipControlsOutput, error) - getBucketOwnershipControlsWithContextMutex sync.RWMutex - getBucketOwnershipControlsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketOwnershipControlsInput - arg3 []request.Option - } - getBucketOwnershipControlsWithContextReturns struct { - result1 *s3.GetBucketOwnershipControlsOutput - result2 error - } - getBucketOwnershipControlsWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketOwnershipControlsOutput - result2 error - } - GetBucketPolicyStub func(*s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error) - getBucketPolicyMutex sync.RWMutex - getBucketPolicyArgsForCall []struct { - arg1 *s3.GetBucketPolicyInput - } - getBucketPolicyReturns struct { - result1 *s3.GetBucketPolicyOutput - result2 error - } - getBucketPolicyReturnsOnCall map[int]struct { - result1 *s3.GetBucketPolicyOutput - result2 error - } - GetBucketPolicyRequestStub func(*s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput) - getBucketPolicyRequestMutex sync.RWMutex - getBucketPolicyRequestArgsForCall []struct { - arg1 *s3.GetBucketPolicyInput - } - getBucketPolicyRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketPolicyOutput - } - getBucketPolicyRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketPolicyOutput - } - GetBucketPolicyStatusStub func(*s3.GetBucketPolicyStatusInput) (*s3.GetBucketPolicyStatusOutput, error) - getBucketPolicyStatusMutex sync.RWMutex - getBucketPolicyStatusArgsForCall []struct { - arg1 *s3.GetBucketPolicyStatusInput - } - getBucketPolicyStatusReturns struct { - result1 *s3.GetBucketPolicyStatusOutput - result2 error - } - getBucketPolicyStatusReturnsOnCall map[int]struct { - result1 *s3.GetBucketPolicyStatusOutput - result2 error - } - GetBucketPolicyStatusRequestStub func(*s3.GetBucketPolicyStatusInput) (*request.Request, *s3.GetBucketPolicyStatusOutput) - getBucketPolicyStatusRequestMutex sync.RWMutex - getBucketPolicyStatusRequestArgsForCall []struct { - arg1 *s3.GetBucketPolicyStatusInput - } - getBucketPolicyStatusRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketPolicyStatusOutput - } - getBucketPolicyStatusRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketPolicyStatusOutput - } - GetBucketPolicyStatusWithContextStub func(context.Context, *s3.GetBucketPolicyStatusInput, ...request.Option) (*s3.GetBucketPolicyStatusOutput, error) - getBucketPolicyStatusWithContextMutex sync.RWMutex - getBucketPolicyStatusWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketPolicyStatusInput - arg3 []request.Option - } - getBucketPolicyStatusWithContextReturns struct { - result1 *s3.GetBucketPolicyStatusOutput - result2 error - } - getBucketPolicyStatusWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketPolicyStatusOutput - result2 error - } - GetBucketPolicyWithContextStub func(context.Context, *s3.GetBucketPolicyInput, ...request.Option) (*s3.GetBucketPolicyOutput, error) - getBucketPolicyWithContextMutex sync.RWMutex - getBucketPolicyWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketPolicyInput - arg3 []request.Option - } - getBucketPolicyWithContextReturns struct { - result1 *s3.GetBucketPolicyOutput - result2 error - } - getBucketPolicyWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketPolicyOutput - result2 error - } - GetBucketReplicationStub func(*s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error) - getBucketReplicationMutex sync.RWMutex - getBucketReplicationArgsForCall []struct { - arg1 *s3.GetBucketReplicationInput - } - getBucketReplicationReturns struct { - result1 *s3.GetBucketReplicationOutput - result2 error - } - getBucketReplicationReturnsOnCall map[int]struct { - result1 *s3.GetBucketReplicationOutput - result2 error - } - GetBucketReplicationRequestStub func(*s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput) - getBucketReplicationRequestMutex sync.RWMutex - getBucketReplicationRequestArgsForCall []struct { - arg1 *s3.GetBucketReplicationInput - } - getBucketReplicationRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketReplicationOutput - } - getBucketReplicationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketReplicationOutput - } - GetBucketReplicationWithContextStub func(context.Context, *s3.GetBucketReplicationInput, ...request.Option) (*s3.GetBucketReplicationOutput, error) - getBucketReplicationWithContextMutex sync.RWMutex - getBucketReplicationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketReplicationInput - arg3 []request.Option - } - getBucketReplicationWithContextReturns struct { - result1 *s3.GetBucketReplicationOutput - result2 error - } - getBucketReplicationWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketReplicationOutput - result2 error - } - GetBucketRequestPaymentStub func(*s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error) - getBucketRequestPaymentMutex sync.RWMutex - getBucketRequestPaymentArgsForCall []struct { - arg1 *s3.GetBucketRequestPaymentInput - } - getBucketRequestPaymentReturns struct { - result1 *s3.GetBucketRequestPaymentOutput - result2 error - } - getBucketRequestPaymentReturnsOnCall map[int]struct { - result1 *s3.GetBucketRequestPaymentOutput - result2 error - } - GetBucketRequestPaymentRequestStub func(*s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput) - getBucketRequestPaymentRequestMutex sync.RWMutex - getBucketRequestPaymentRequestArgsForCall []struct { - arg1 *s3.GetBucketRequestPaymentInput - } - getBucketRequestPaymentRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketRequestPaymentOutput - } - getBucketRequestPaymentRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketRequestPaymentOutput - } - GetBucketRequestPaymentWithContextStub func(context.Context, *s3.GetBucketRequestPaymentInput, ...request.Option) (*s3.GetBucketRequestPaymentOutput, error) - getBucketRequestPaymentWithContextMutex sync.RWMutex - getBucketRequestPaymentWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketRequestPaymentInput - arg3 []request.Option - } - getBucketRequestPaymentWithContextReturns struct { - result1 *s3.GetBucketRequestPaymentOutput - result2 error - } - getBucketRequestPaymentWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketRequestPaymentOutput - result2 error - } - GetBucketTaggingStub func(*s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error) - getBucketTaggingMutex sync.RWMutex - getBucketTaggingArgsForCall []struct { - arg1 *s3.GetBucketTaggingInput - } - getBucketTaggingReturns struct { - result1 *s3.GetBucketTaggingOutput - result2 error - } - getBucketTaggingReturnsOnCall map[int]struct { - result1 *s3.GetBucketTaggingOutput - result2 error - } - GetBucketTaggingRequestStub func(*s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput) - getBucketTaggingRequestMutex sync.RWMutex - getBucketTaggingRequestArgsForCall []struct { - arg1 *s3.GetBucketTaggingInput - } - getBucketTaggingRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketTaggingOutput - } - getBucketTaggingRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketTaggingOutput - } - GetBucketTaggingWithContextStub func(context.Context, *s3.GetBucketTaggingInput, ...request.Option) (*s3.GetBucketTaggingOutput, error) - getBucketTaggingWithContextMutex sync.RWMutex - getBucketTaggingWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketTaggingInput - arg3 []request.Option - } - getBucketTaggingWithContextReturns struct { - result1 *s3.GetBucketTaggingOutput - result2 error - } - getBucketTaggingWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketTaggingOutput - result2 error - } - GetBucketVersioningStub func(*s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error) - getBucketVersioningMutex sync.RWMutex - getBucketVersioningArgsForCall []struct { - arg1 *s3.GetBucketVersioningInput - } - getBucketVersioningReturns struct { - result1 *s3.GetBucketVersioningOutput - result2 error - } - getBucketVersioningReturnsOnCall map[int]struct { - result1 *s3.GetBucketVersioningOutput - result2 error - } - GetBucketVersioningRequestStub func(*s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput) - getBucketVersioningRequestMutex sync.RWMutex - getBucketVersioningRequestArgsForCall []struct { - arg1 *s3.GetBucketVersioningInput - } - getBucketVersioningRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketVersioningOutput - } - getBucketVersioningRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketVersioningOutput - } - GetBucketVersioningWithContextStub func(context.Context, *s3.GetBucketVersioningInput, ...request.Option) (*s3.GetBucketVersioningOutput, error) - getBucketVersioningWithContextMutex sync.RWMutex - getBucketVersioningWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketVersioningInput - arg3 []request.Option - } - getBucketVersioningWithContextReturns struct { - result1 *s3.GetBucketVersioningOutput - result2 error - } - getBucketVersioningWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketVersioningOutput - result2 error - } - GetBucketWebsiteStub func(*s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error) - getBucketWebsiteMutex sync.RWMutex - getBucketWebsiteArgsForCall []struct { - arg1 *s3.GetBucketWebsiteInput - } - getBucketWebsiteReturns struct { - result1 *s3.GetBucketWebsiteOutput - result2 error - } - getBucketWebsiteReturnsOnCall map[int]struct { - result1 *s3.GetBucketWebsiteOutput - result2 error - } - GetBucketWebsiteRequestStub func(*s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput) - getBucketWebsiteRequestMutex sync.RWMutex - getBucketWebsiteRequestArgsForCall []struct { - arg1 *s3.GetBucketWebsiteInput - } - getBucketWebsiteRequestReturns struct { - result1 *request.Request - result2 *s3.GetBucketWebsiteOutput - } - getBucketWebsiteRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetBucketWebsiteOutput - } - GetBucketWebsiteWithContextStub func(context.Context, *s3.GetBucketWebsiteInput, ...request.Option) (*s3.GetBucketWebsiteOutput, error) - getBucketWebsiteWithContextMutex sync.RWMutex - getBucketWebsiteWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetBucketWebsiteInput - arg3 []request.Option - } - getBucketWebsiteWithContextReturns struct { - result1 *s3.GetBucketWebsiteOutput - result2 error - } - getBucketWebsiteWithContextReturnsOnCall map[int]struct { - result1 *s3.GetBucketWebsiteOutput - result2 error - } - GetObjectStub func(*s3.GetObjectInput) (*s3.GetObjectOutput, error) - getObjectMutex sync.RWMutex - getObjectArgsForCall []struct { - arg1 *s3.GetObjectInput - } - getObjectReturns struct { - result1 *s3.GetObjectOutput - result2 error - } - getObjectReturnsOnCall map[int]struct { - result1 *s3.GetObjectOutput - result2 error - } - GetObjectAclStub func(*s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) - getObjectAclMutex sync.RWMutex - getObjectAclArgsForCall []struct { - arg1 *s3.GetObjectAclInput - } - getObjectAclReturns struct { - result1 *s3.GetObjectAclOutput - result2 error - } - getObjectAclReturnsOnCall map[int]struct { - result1 *s3.GetObjectAclOutput - result2 error - } - GetObjectAclRequestStub func(*s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput) - getObjectAclRequestMutex sync.RWMutex - getObjectAclRequestArgsForCall []struct { - arg1 *s3.GetObjectAclInput - } - getObjectAclRequestReturns struct { - result1 *request.Request - result2 *s3.GetObjectAclOutput - } - getObjectAclRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetObjectAclOutput - } - GetObjectAclWithContextStub func(context.Context, *s3.GetObjectAclInput, ...request.Option) (*s3.GetObjectAclOutput, error) - getObjectAclWithContextMutex sync.RWMutex - getObjectAclWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetObjectAclInput - arg3 []request.Option - } - getObjectAclWithContextReturns struct { - result1 *s3.GetObjectAclOutput - result2 error - } - getObjectAclWithContextReturnsOnCall map[int]struct { - result1 *s3.GetObjectAclOutput - result2 error - } - GetObjectLegalHoldStub func(*s3.GetObjectLegalHoldInput) (*s3.GetObjectLegalHoldOutput, error) - getObjectLegalHoldMutex sync.RWMutex - getObjectLegalHoldArgsForCall []struct { - arg1 *s3.GetObjectLegalHoldInput - } - getObjectLegalHoldReturns struct { - result1 *s3.GetObjectLegalHoldOutput - result2 error - } - getObjectLegalHoldReturnsOnCall map[int]struct { - result1 *s3.GetObjectLegalHoldOutput - result2 error - } - GetObjectLegalHoldRequestStub func(*s3.GetObjectLegalHoldInput) (*request.Request, *s3.GetObjectLegalHoldOutput) - getObjectLegalHoldRequestMutex sync.RWMutex - getObjectLegalHoldRequestArgsForCall []struct { - arg1 *s3.GetObjectLegalHoldInput - } - getObjectLegalHoldRequestReturns struct { - result1 *request.Request - result2 *s3.GetObjectLegalHoldOutput - } - getObjectLegalHoldRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetObjectLegalHoldOutput - } - GetObjectLegalHoldWithContextStub func(context.Context, *s3.GetObjectLegalHoldInput, ...request.Option) (*s3.GetObjectLegalHoldOutput, error) - getObjectLegalHoldWithContextMutex sync.RWMutex - getObjectLegalHoldWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetObjectLegalHoldInput - arg3 []request.Option - } - getObjectLegalHoldWithContextReturns struct { - result1 *s3.GetObjectLegalHoldOutput - result2 error - } - getObjectLegalHoldWithContextReturnsOnCall map[int]struct { - result1 *s3.GetObjectLegalHoldOutput - result2 error - } - GetObjectLockConfigurationStub func(*s3.GetObjectLockConfigurationInput) (*s3.GetObjectLockConfigurationOutput, error) - getObjectLockConfigurationMutex sync.RWMutex - getObjectLockConfigurationArgsForCall []struct { - arg1 *s3.GetObjectLockConfigurationInput - } - getObjectLockConfigurationReturns struct { - result1 *s3.GetObjectLockConfigurationOutput - result2 error - } - getObjectLockConfigurationReturnsOnCall map[int]struct { - result1 *s3.GetObjectLockConfigurationOutput - result2 error - } - GetObjectLockConfigurationRequestStub func(*s3.GetObjectLockConfigurationInput) (*request.Request, *s3.GetObjectLockConfigurationOutput) - getObjectLockConfigurationRequestMutex sync.RWMutex - getObjectLockConfigurationRequestArgsForCall []struct { - arg1 *s3.GetObjectLockConfigurationInput - } - getObjectLockConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.GetObjectLockConfigurationOutput - } - getObjectLockConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetObjectLockConfigurationOutput - } - GetObjectLockConfigurationWithContextStub func(context.Context, *s3.GetObjectLockConfigurationInput, ...request.Option) (*s3.GetObjectLockConfigurationOutput, error) - getObjectLockConfigurationWithContextMutex sync.RWMutex - getObjectLockConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetObjectLockConfigurationInput - arg3 []request.Option - } - getObjectLockConfigurationWithContextReturns struct { - result1 *s3.GetObjectLockConfigurationOutput - result2 error - } - getObjectLockConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.GetObjectLockConfigurationOutput - result2 error - } - GetObjectRequestStub func(*s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput) - getObjectRequestMutex sync.RWMutex - getObjectRequestArgsForCall []struct { - arg1 *s3.GetObjectInput - } - getObjectRequestReturns struct { - result1 *request.Request - result2 *s3.GetObjectOutput - } - getObjectRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetObjectOutput - } - GetObjectRetentionStub func(*s3.GetObjectRetentionInput) (*s3.GetObjectRetentionOutput, error) - getObjectRetentionMutex sync.RWMutex - getObjectRetentionArgsForCall []struct { - arg1 *s3.GetObjectRetentionInput - } - getObjectRetentionReturns struct { - result1 *s3.GetObjectRetentionOutput - result2 error - } - getObjectRetentionReturnsOnCall map[int]struct { - result1 *s3.GetObjectRetentionOutput - result2 error - } - GetObjectRetentionRequestStub func(*s3.GetObjectRetentionInput) (*request.Request, *s3.GetObjectRetentionOutput) - getObjectRetentionRequestMutex sync.RWMutex - getObjectRetentionRequestArgsForCall []struct { - arg1 *s3.GetObjectRetentionInput - } - getObjectRetentionRequestReturns struct { - result1 *request.Request - result2 *s3.GetObjectRetentionOutput - } - getObjectRetentionRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetObjectRetentionOutput - } - GetObjectRetentionWithContextStub func(context.Context, *s3.GetObjectRetentionInput, ...request.Option) (*s3.GetObjectRetentionOutput, error) - getObjectRetentionWithContextMutex sync.RWMutex - getObjectRetentionWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetObjectRetentionInput - arg3 []request.Option - } - getObjectRetentionWithContextReturns struct { - result1 *s3.GetObjectRetentionOutput - result2 error - } - getObjectRetentionWithContextReturnsOnCall map[int]struct { - result1 *s3.GetObjectRetentionOutput - result2 error - } - GetObjectTaggingStub func(*s3.GetObjectTaggingInput) (*s3.GetObjectTaggingOutput, error) - getObjectTaggingMutex sync.RWMutex - getObjectTaggingArgsForCall []struct { - arg1 *s3.GetObjectTaggingInput - } - getObjectTaggingReturns struct { - result1 *s3.GetObjectTaggingOutput - result2 error - } - getObjectTaggingReturnsOnCall map[int]struct { - result1 *s3.GetObjectTaggingOutput - result2 error - } - GetObjectTaggingRequestStub func(*s3.GetObjectTaggingInput) (*request.Request, *s3.GetObjectTaggingOutput) - getObjectTaggingRequestMutex sync.RWMutex - getObjectTaggingRequestArgsForCall []struct { - arg1 *s3.GetObjectTaggingInput - } - getObjectTaggingRequestReturns struct { - result1 *request.Request - result2 *s3.GetObjectTaggingOutput - } - getObjectTaggingRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetObjectTaggingOutput - } - GetObjectTaggingWithContextStub func(context.Context, *s3.GetObjectTaggingInput, ...request.Option) (*s3.GetObjectTaggingOutput, error) - getObjectTaggingWithContextMutex sync.RWMutex - getObjectTaggingWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetObjectTaggingInput - arg3 []request.Option - } - getObjectTaggingWithContextReturns struct { - result1 *s3.GetObjectTaggingOutput - result2 error - } - getObjectTaggingWithContextReturnsOnCall map[int]struct { - result1 *s3.GetObjectTaggingOutput - result2 error - } - GetObjectTorrentStub func(*s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error) - getObjectTorrentMutex sync.RWMutex - getObjectTorrentArgsForCall []struct { - arg1 *s3.GetObjectTorrentInput - } - getObjectTorrentReturns struct { - result1 *s3.GetObjectTorrentOutput - result2 error - } - getObjectTorrentReturnsOnCall map[int]struct { - result1 *s3.GetObjectTorrentOutput - result2 error - } - GetObjectTorrentRequestStub func(*s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput) - getObjectTorrentRequestMutex sync.RWMutex - getObjectTorrentRequestArgsForCall []struct { - arg1 *s3.GetObjectTorrentInput - } - getObjectTorrentRequestReturns struct { - result1 *request.Request - result2 *s3.GetObjectTorrentOutput - } - getObjectTorrentRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetObjectTorrentOutput - } - GetObjectTorrentWithContextStub func(context.Context, *s3.GetObjectTorrentInput, ...request.Option) (*s3.GetObjectTorrentOutput, error) - getObjectTorrentWithContextMutex sync.RWMutex - getObjectTorrentWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetObjectTorrentInput - arg3 []request.Option - } - getObjectTorrentWithContextReturns struct { - result1 *s3.GetObjectTorrentOutput - result2 error - } - getObjectTorrentWithContextReturnsOnCall map[int]struct { - result1 *s3.GetObjectTorrentOutput - result2 error - } - GetObjectWithContextStub func(context.Context, *s3.GetObjectInput, ...request.Option) (*s3.GetObjectOutput, error) - getObjectWithContextMutex sync.RWMutex - getObjectWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetObjectInput - arg3 []request.Option - } - getObjectWithContextReturns struct { - result1 *s3.GetObjectOutput - result2 error - } - getObjectWithContextReturnsOnCall map[int]struct { - result1 *s3.GetObjectOutput - result2 error - } - GetPublicAccessBlockStub func(*s3.GetPublicAccessBlockInput) (*s3.GetPublicAccessBlockOutput, error) - getPublicAccessBlockMutex sync.RWMutex - getPublicAccessBlockArgsForCall []struct { - arg1 *s3.GetPublicAccessBlockInput - } - getPublicAccessBlockReturns struct { - result1 *s3.GetPublicAccessBlockOutput - result2 error - } - getPublicAccessBlockReturnsOnCall map[int]struct { - result1 *s3.GetPublicAccessBlockOutput - result2 error - } - GetPublicAccessBlockRequestStub func(*s3.GetPublicAccessBlockInput) (*request.Request, *s3.GetPublicAccessBlockOutput) - getPublicAccessBlockRequestMutex sync.RWMutex - getPublicAccessBlockRequestArgsForCall []struct { - arg1 *s3.GetPublicAccessBlockInput - } - getPublicAccessBlockRequestReturns struct { - result1 *request.Request - result2 *s3.GetPublicAccessBlockOutput - } - getPublicAccessBlockRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.GetPublicAccessBlockOutput - } - GetPublicAccessBlockWithContextStub func(context.Context, *s3.GetPublicAccessBlockInput, ...request.Option) (*s3.GetPublicAccessBlockOutput, error) - getPublicAccessBlockWithContextMutex sync.RWMutex - getPublicAccessBlockWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.GetPublicAccessBlockInput - arg3 []request.Option - } - getPublicAccessBlockWithContextReturns struct { - result1 *s3.GetPublicAccessBlockOutput - result2 error - } - getPublicAccessBlockWithContextReturnsOnCall map[int]struct { - result1 *s3.GetPublicAccessBlockOutput - result2 error - } - HeadBucketStub func(*s3.HeadBucketInput) (*s3.HeadBucketOutput, error) - headBucketMutex sync.RWMutex - headBucketArgsForCall []struct { - arg1 *s3.HeadBucketInput - } - headBucketReturns struct { - result1 *s3.HeadBucketOutput - result2 error - } - headBucketReturnsOnCall map[int]struct { - result1 *s3.HeadBucketOutput - result2 error - } - HeadBucketRequestStub func(*s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput) - headBucketRequestMutex sync.RWMutex - headBucketRequestArgsForCall []struct { - arg1 *s3.HeadBucketInput - } - headBucketRequestReturns struct { - result1 *request.Request - result2 *s3.HeadBucketOutput - } - headBucketRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.HeadBucketOutput - } - HeadBucketWithContextStub func(context.Context, *s3.HeadBucketInput, ...request.Option) (*s3.HeadBucketOutput, error) - headBucketWithContextMutex sync.RWMutex - headBucketWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.HeadBucketInput - arg3 []request.Option - } - headBucketWithContextReturns struct { - result1 *s3.HeadBucketOutput - result2 error - } - headBucketWithContextReturnsOnCall map[int]struct { - result1 *s3.HeadBucketOutput - result2 error - } - HeadObjectStub func(*s3.HeadObjectInput) (*s3.HeadObjectOutput, error) - headObjectMutex sync.RWMutex - headObjectArgsForCall []struct { - arg1 *s3.HeadObjectInput - } - headObjectReturns struct { - result1 *s3.HeadObjectOutput - result2 error - } - headObjectReturnsOnCall map[int]struct { - result1 *s3.HeadObjectOutput - result2 error - } - HeadObjectRequestStub func(*s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput) - headObjectRequestMutex sync.RWMutex - headObjectRequestArgsForCall []struct { - arg1 *s3.HeadObjectInput - } - headObjectRequestReturns struct { - result1 *request.Request - result2 *s3.HeadObjectOutput - } - headObjectRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.HeadObjectOutput - } - HeadObjectWithContextStub func(context.Context, *s3.HeadObjectInput, ...request.Option) (*s3.HeadObjectOutput, error) - headObjectWithContextMutex sync.RWMutex - headObjectWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.HeadObjectInput - arg3 []request.Option - } - headObjectWithContextReturns struct { - result1 *s3.HeadObjectOutput - result2 error - } - headObjectWithContextReturnsOnCall map[int]struct { - result1 *s3.HeadObjectOutput - result2 error - } - ListBucketAnalyticsConfigurationsStub func(*s3.ListBucketAnalyticsConfigurationsInput) (*s3.ListBucketAnalyticsConfigurationsOutput, error) - listBucketAnalyticsConfigurationsMutex sync.RWMutex - listBucketAnalyticsConfigurationsArgsForCall []struct { - arg1 *s3.ListBucketAnalyticsConfigurationsInput - } - listBucketAnalyticsConfigurationsReturns struct { - result1 *s3.ListBucketAnalyticsConfigurationsOutput - result2 error - } - listBucketAnalyticsConfigurationsReturnsOnCall map[int]struct { - result1 *s3.ListBucketAnalyticsConfigurationsOutput - result2 error - } - ListBucketAnalyticsConfigurationsRequestStub func(*s3.ListBucketAnalyticsConfigurationsInput) (*request.Request, *s3.ListBucketAnalyticsConfigurationsOutput) - listBucketAnalyticsConfigurationsRequestMutex sync.RWMutex - listBucketAnalyticsConfigurationsRequestArgsForCall []struct { - arg1 *s3.ListBucketAnalyticsConfigurationsInput - } - listBucketAnalyticsConfigurationsRequestReturns struct { - result1 *request.Request - result2 *s3.ListBucketAnalyticsConfigurationsOutput - } - listBucketAnalyticsConfigurationsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.ListBucketAnalyticsConfigurationsOutput - } - ListBucketAnalyticsConfigurationsWithContextStub func(context.Context, *s3.ListBucketAnalyticsConfigurationsInput, ...request.Option) (*s3.ListBucketAnalyticsConfigurationsOutput, error) - listBucketAnalyticsConfigurationsWithContextMutex sync.RWMutex - listBucketAnalyticsConfigurationsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListBucketAnalyticsConfigurationsInput - arg3 []request.Option - } - listBucketAnalyticsConfigurationsWithContextReturns struct { - result1 *s3.ListBucketAnalyticsConfigurationsOutput - result2 error - } - listBucketAnalyticsConfigurationsWithContextReturnsOnCall map[int]struct { - result1 *s3.ListBucketAnalyticsConfigurationsOutput - result2 error - } - ListBucketIntelligentTieringConfigurationsStub func(*s3.ListBucketIntelligentTieringConfigurationsInput) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error) - listBucketIntelligentTieringConfigurationsMutex sync.RWMutex - listBucketIntelligentTieringConfigurationsArgsForCall []struct { - arg1 *s3.ListBucketIntelligentTieringConfigurationsInput - } - listBucketIntelligentTieringConfigurationsReturns struct { - result1 *s3.ListBucketIntelligentTieringConfigurationsOutput - result2 error - } - listBucketIntelligentTieringConfigurationsReturnsOnCall map[int]struct { - result1 *s3.ListBucketIntelligentTieringConfigurationsOutput - result2 error - } - ListBucketIntelligentTieringConfigurationsRequestStub func(*s3.ListBucketIntelligentTieringConfigurationsInput) (*request.Request, *s3.ListBucketIntelligentTieringConfigurationsOutput) - listBucketIntelligentTieringConfigurationsRequestMutex sync.RWMutex - listBucketIntelligentTieringConfigurationsRequestArgsForCall []struct { - arg1 *s3.ListBucketIntelligentTieringConfigurationsInput - } - listBucketIntelligentTieringConfigurationsRequestReturns struct { - result1 *request.Request - result2 *s3.ListBucketIntelligentTieringConfigurationsOutput - } - listBucketIntelligentTieringConfigurationsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.ListBucketIntelligentTieringConfigurationsOutput - } - ListBucketIntelligentTieringConfigurationsWithContextStub func(context.Context, *s3.ListBucketIntelligentTieringConfigurationsInput, ...request.Option) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error) - listBucketIntelligentTieringConfigurationsWithContextMutex sync.RWMutex - listBucketIntelligentTieringConfigurationsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListBucketIntelligentTieringConfigurationsInput - arg3 []request.Option - } - listBucketIntelligentTieringConfigurationsWithContextReturns struct { - result1 *s3.ListBucketIntelligentTieringConfigurationsOutput - result2 error - } - listBucketIntelligentTieringConfigurationsWithContextReturnsOnCall map[int]struct { - result1 *s3.ListBucketIntelligentTieringConfigurationsOutput - result2 error - } - ListBucketInventoryConfigurationsStub func(*s3.ListBucketInventoryConfigurationsInput) (*s3.ListBucketInventoryConfigurationsOutput, error) - listBucketInventoryConfigurationsMutex sync.RWMutex - listBucketInventoryConfigurationsArgsForCall []struct { - arg1 *s3.ListBucketInventoryConfigurationsInput - } - listBucketInventoryConfigurationsReturns struct { - result1 *s3.ListBucketInventoryConfigurationsOutput - result2 error - } - listBucketInventoryConfigurationsReturnsOnCall map[int]struct { - result1 *s3.ListBucketInventoryConfigurationsOutput - result2 error - } - ListBucketInventoryConfigurationsRequestStub func(*s3.ListBucketInventoryConfigurationsInput) (*request.Request, *s3.ListBucketInventoryConfigurationsOutput) - listBucketInventoryConfigurationsRequestMutex sync.RWMutex - listBucketInventoryConfigurationsRequestArgsForCall []struct { - arg1 *s3.ListBucketInventoryConfigurationsInput - } - listBucketInventoryConfigurationsRequestReturns struct { - result1 *request.Request - result2 *s3.ListBucketInventoryConfigurationsOutput - } - listBucketInventoryConfigurationsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.ListBucketInventoryConfigurationsOutput - } - ListBucketInventoryConfigurationsWithContextStub func(context.Context, *s3.ListBucketInventoryConfigurationsInput, ...request.Option) (*s3.ListBucketInventoryConfigurationsOutput, error) - listBucketInventoryConfigurationsWithContextMutex sync.RWMutex - listBucketInventoryConfigurationsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListBucketInventoryConfigurationsInput - arg3 []request.Option - } - listBucketInventoryConfigurationsWithContextReturns struct { - result1 *s3.ListBucketInventoryConfigurationsOutput - result2 error - } - listBucketInventoryConfigurationsWithContextReturnsOnCall map[int]struct { - result1 *s3.ListBucketInventoryConfigurationsOutput - result2 error - } - ListBucketMetricsConfigurationsStub func(*s3.ListBucketMetricsConfigurationsInput) (*s3.ListBucketMetricsConfigurationsOutput, error) - listBucketMetricsConfigurationsMutex sync.RWMutex - listBucketMetricsConfigurationsArgsForCall []struct { - arg1 *s3.ListBucketMetricsConfigurationsInput - } - listBucketMetricsConfigurationsReturns struct { - result1 *s3.ListBucketMetricsConfigurationsOutput - result2 error - } - listBucketMetricsConfigurationsReturnsOnCall map[int]struct { - result1 *s3.ListBucketMetricsConfigurationsOutput - result2 error - } - ListBucketMetricsConfigurationsRequestStub func(*s3.ListBucketMetricsConfigurationsInput) (*request.Request, *s3.ListBucketMetricsConfigurationsOutput) - listBucketMetricsConfigurationsRequestMutex sync.RWMutex - listBucketMetricsConfigurationsRequestArgsForCall []struct { - arg1 *s3.ListBucketMetricsConfigurationsInput - } - listBucketMetricsConfigurationsRequestReturns struct { - result1 *request.Request - result2 *s3.ListBucketMetricsConfigurationsOutput - } - listBucketMetricsConfigurationsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.ListBucketMetricsConfigurationsOutput - } - ListBucketMetricsConfigurationsWithContextStub func(context.Context, *s3.ListBucketMetricsConfigurationsInput, ...request.Option) (*s3.ListBucketMetricsConfigurationsOutput, error) - listBucketMetricsConfigurationsWithContextMutex sync.RWMutex - listBucketMetricsConfigurationsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListBucketMetricsConfigurationsInput - arg3 []request.Option - } - listBucketMetricsConfigurationsWithContextReturns struct { - result1 *s3.ListBucketMetricsConfigurationsOutput - result2 error - } - listBucketMetricsConfigurationsWithContextReturnsOnCall map[int]struct { - result1 *s3.ListBucketMetricsConfigurationsOutput - result2 error - } - ListBucketsStub func(*s3.ListBucketsInput) (*s3.ListBucketsOutput, error) - listBucketsMutex sync.RWMutex - listBucketsArgsForCall []struct { - arg1 *s3.ListBucketsInput - } - listBucketsReturns struct { - result1 *s3.ListBucketsOutput - result2 error - } - listBucketsReturnsOnCall map[int]struct { - result1 *s3.ListBucketsOutput - result2 error - } - ListBucketsRequestStub func(*s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput) - listBucketsRequestMutex sync.RWMutex - listBucketsRequestArgsForCall []struct { - arg1 *s3.ListBucketsInput - } - listBucketsRequestReturns struct { - result1 *request.Request - result2 *s3.ListBucketsOutput - } - listBucketsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.ListBucketsOutput - } - ListBucketsWithContextStub func(context.Context, *s3.ListBucketsInput, ...request.Option) (*s3.ListBucketsOutput, error) - listBucketsWithContextMutex sync.RWMutex - listBucketsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListBucketsInput - arg3 []request.Option - } - listBucketsWithContextReturns struct { - result1 *s3.ListBucketsOutput - result2 error - } - listBucketsWithContextReturnsOnCall map[int]struct { - result1 *s3.ListBucketsOutput - result2 error - } - ListMultipartUploadsStub func(*s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error) - listMultipartUploadsMutex sync.RWMutex - listMultipartUploadsArgsForCall []struct { - arg1 *s3.ListMultipartUploadsInput - } - listMultipartUploadsReturns struct { - result1 *s3.ListMultipartUploadsOutput - result2 error - } - listMultipartUploadsReturnsOnCall map[int]struct { - result1 *s3.ListMultipartUploadsOutput - result2 error - } - ListMultipartUploadsPagesStub func(*s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool) error - listMultipartUploadsPagesMutex sync.RWMutex - listMultipartUploadsPagesArgsForCall []struct { - arg1 *s3.ListMultipartUploadsInput - arg2 func(*s3.ListMultipartUploadsOutput, bool) bool - } - listMultipartUploadsPagesReturns struct { - result1 error - } - listMultipartUploadsPagesReturnsOnCall map[int]struct { - result1 error - } - ListMultipartUploadsPagesWithContextStub func(context.Context, *s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool, ...request.Option) error - listMultipartUploadsPagesWithContextMutex sync.RWMutex - listMultipartUploadsPagesWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListMultipartUploadsInput - arg3 func(*s3.ListMultipartUploadsOutput, bool) bool - arg4 []request.Option - } - listMultipartUploadsPagesWithContextReturns struct { - result1 error - } - listMultipartUploadsPagesWithContextReturnsOnCall map[int]struct { - result1 error - } - ListMultipartUploadsRequestStub func(*s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput) - listMultipartUploadsRequestMutex sync.RWMutex - listMultipartUploadsRequestArgsForCall []struct { - arg1 *s3.ListMultipartUploadsInput - } - listMultipartUploadsRequestReturns struct { - result1 *request.Request - result2 *s3.ListMultipartUploadsOutput - } - listMultipartUploadsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.ListMultipartUploadsOutput - } - ListMultipartUploadsWithContextStub func(context.Context, *s3.ListMultipartUploadsInput, ...request.Option) (*s3.ListMultipartUploadsOutput, error) - listMultipartUploadsWithContextMutex sync.RWMutex - listMultipartUploadsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListMultipartUploadsInput - arg3 []request.Option - } - listMultipartUploadsWithContextReturns struct { - result1 *s3.ListMultipartUploadsOutput - result2 error - } - listMultipartUploadsWithContextReturnsOnCall map[int]struct { - result1 *s3.ListMultipartUploadsOutput - result2 error - } - ListObjectVersionsStub func(*s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error) - listObjectVersionsMutex sync.RWMutex - listObjectVersionsArgsForCall []struct { - arg1 *s3.ListObjectVersionsInput - } - listObjectVersionsReturns struct { - result1 *s3.ListObjectVersionsOutput - result2 error - } - listObjectVersionsReturnsOnCall map[int]struct { - result1 *s3.ListObjectVersionsOutput - result2 error - } - ListObjectVersionsPagesStub func(*s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool) error - listObjectVersionsPagesMutex sync.RWMutex - listObjectVersionsPagesArgsForCall []struct { - arg1 *s3.ListObjectVersionsInput - arg2 func(*s3.ListObjectVersionsOutput, bool) bool - } - listObjectVersionsPagesReturns struct { - result1 error - } - listObjectVersionsPagesReturnsOnCall map[int]struct { - result1 error - } - ListObjectVersionsPagesWithContextStub func(context.Context, *s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool, ...request.Option) error - listObjectVersionsPagesWithContextMutex sync.RWMutex - listObjectVersionsPagesWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListObjectVersionsInput - arg3 func(*s3.ListObjectVersionsOutput, bool) bool - arg4 []request.Option - } - listObjectVersionsPagesWithContextReturns struct { - result1 error - } - listObjectVersionsPagesWithContextReturnsOnCall map[int]struct { - result1 error - } - ListObjectVersionsRequestStub func(*s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput) - listObjectVersionsRequestMutex sync.RWMutex - listObjectVersionsRequestArgsForCall []struct { - arg1 *s3.ListObjectVersionsInput - } - listObjectVersionsRequestReturns struct { - result1 *request.Request - result2 *s3.ListObjectVersionsOutput - } - listObjectVersionsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.ListObjectVersionsOutput - } - ListObjectVersionsWithContextStub func(context.Context, *s3.ListObjectVersionsInput, ...request.Option) (*s3.ListObjectVersionsOutput, error) - listObjectVersionsWithContextMutex sync.RWMutex - listObjectVersionsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListObjectVersionsInput - arg3 []request.Option - } - listObjectVersionsWithContextReturns struct { - result1 *s3.ListObjectVersionsOutput - result2 error - } - listObjectVersionsWithContextReturnsOnCall map[int]struct { - result1 *s3.ListObjectVersionsOutput - result2 error - } - ListObjectsStub func(*s3.ListObjectsInput) (*s3.ListObjectsOutput, error) - listObjectsMutex sync.RWMutex - listObjectsArgsForCall []struct { - arg1 *s3.ListObjectsInput - } - listObjectsReturns struct { - result1 *s3.ListObjectsOutput - result2 error - } - listObjectsReturnsOnCall map[int]struct { - result1 *s3.ListObjectsOutput - result2 error - } - ListObjectsPagesStub func(*s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool) error - listObjectsPagesMutex sync.RWMutex - listObjectsPagesArgsForCall []struct { - arg1 *s3.ListObjectsInput - arg2 func(*s3.ListObjectsOutput, bool) bool - } - listObjectsPagesReturns struct { - result1 error - } - listObjectsPagesReturnsOnCall map[int]struct { - result1 error - } - ListObjectsPagesWithContextStub func(context.Context, *s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool, ...request.Option) error - listObjectsPagesWithContextMutex sync.RWMutex - listObjectsPagesWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListObjectsInput - arg3 func(*s3.ListObjectsOutput, bool) bool - arg4 []request.Option - } - listObjectsPagesWithContextReturns struct { - result1 error - } - listObjectsPagesWithContextReturnsOnCall map[int]struct { - result1 error - } - ListObjectsRequestStub func(*s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput) - listObjectsRequestMutex sync.RWMutex - listObjectsRequestArgsForCall []struct { - arg1 *s3.ListObjectsInput - } - listObjectsRequestReturns struct { - result1 *request.Request - result2 *s3.ListObjectsOutput - } - listObjectsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.ListObjectsOutput - } - ListObjectsV2Stub func(*s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error) - listObjectsV2Mutex sync.RWMutex - listObjectsV2ArgsForCall []struct { - arg1 *s3.ListObjectsV2Input - } - listObjectsV2Returns struct { - result1 *s3.ListObjectsV2Output - result2 error - } - listObjectsV2ReturnsOnCall map[int]struct { - result1 *s3.ListObjectsV2Output - result2 error - } - ListObjectsV2PagesStub func(*s3.ListObjectsV2Input, func(*s3.ListObjectsV2Output, bool) bool) error - listObjectsV2PagesMutex sync.RWMutex - listObjectsV2PagesArgsForCall []struct { - arg1 *s3.ListObjectsV2Input - arg2 func(*s3.ListObjectsV2Output, bool) bool - } - listObjectsV2PagesReturns struct { - result1 error - } - listObjectsV2PagesReturnsOnCall map[int]struct { - result1 error - } - ListObjectsV2PagesWithContextStub func(context.Context, *s3.ListObjectsV2Input, func(*s3.ListObjectsV2Output, bool) bool, ...request.Option) error - listObjectsV2PagesWithContextMutex sync.RWMutex - listObjectsV2PagesWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListObjectsV2Input - arg3 func(*s3.ListObjectsV2Output, bool) bool - arg4 []request.Option - } - listObjectsV2PagesWithContextReturns struct { - result1 error - } - listObjectsV2PagesWithContextReturnsOnCall map[int]struct { - result1 error - } - ListObjectsV2RequestStub func(*s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output) - listObjectsV2RequestMutex sync.RWMutex - listObjectsV2RequestArgsForCall []struct { - arg1 *s3.ListObjectsV2Input - } - listObjectsV2RequestReturns struct { - result1 *request.Request - result2 *s3.ListObjectsV2Output - } - listObjectsV2RequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.ListObjectsV2Output - } - ListObjectsV2WithContextStub func(context.Context, *s3.ListObjectsV2Input, ...request.Option) (*s3.ListObjectsV2Output, error) - listObjectsV2WithContextMutex sync.RWMutex - listObjectsV2WithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListObjectsV2Input - arg3 []request.Option - } - listObjectsV2WithContextReturns struct { - result1 *s3.ListObjectsV2Output - result2 error - } - listObjectsV2WithContextReturnsOnCall map[int]struct { - result1 *s3.ListObjectsV2Output - result2 error - } - ListObjectsWithContextStub func(context.Context, *s3.ListObjectsInput, ...request.Option) (*s3.ListObjectsOutput, error) - listObjectsWithContextMutex sync.RWMutex - listObjectsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListObjectsInput - arg3 []request.Option - } - listObjectsWithContextReturns struct { - result1 *s3.ListObjectsOutput - result2 error - } - listObjectsWithContextReturnsOnCall map[int]struct { - result1 *s3.ListObjectsOutput - result2 error - } - ListPartsStub func(*s3.ListPartsInput) (*s3.ListPartsOutput, error) - listPartsMutex sync.RWMutex - listPartsArgsForCall []struct { - arg1 *s3.ListPartsInput - } - listPartsReturns struct { - result1 *s3.ListPartsOutput - result2 error - } - listPartsReturnsOnCall map[int]struct { - result1 *s3.ListPartsOutput - result2 error - } - ListPartsPagesStub func(*s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool) error - listPartsPagesMutex sync.RWMutex - listPartsPagesArgsForCall []struct { - arg1 *s3.ListPartsInput - arg2 func(*s3.ListPartsOutput, bool) bool - } - listPartsPagesReturns struct { - result1 error - } - listPartsPagesReturnsOnCall map[int]struct { - result1 error - } - ListPartsPagesWithContextStub func(context.Context, *s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool, ...request.Option) error - listPartsPagesWithContextMutex sync.RWMutex - listPartsPagesWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListPartsInput - arg3 func(*s3.ListPartsOutput, bool) bool - arg4 []request.Option - } - listPartsPagesWithContextReturns struct { - result1 error - } - listPartsPagesWithContextReturnsOnCall map[int]struct { - result1 error - } - ListPartsRequestStub func(*s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput) - listPartsRequestMutex sync.RWMutex - listPartsRequestArgsForCall []struct { - arg1 *s3.ListPartsInput - } - listPartsRequestReturns struct { - result1 *request.Request - result2 *s3.ListPartsOutput - } - listPartsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.ListPartsOutput - } - ListPartsWithContextStub func(context.Context, *s3.ListPartsInput, ...request.Option) (*s3.ListPartsOutput, error) - listPartsWithContextMutex sync.RWMutex - listPartsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.ListPartsInput - arg3 []request.Option - } - listPartsWithContextReturns struct { - result1 *s3.ListPartsOutput - result2 error - } - listPartsWithContextReturnsOnCall map[int]struct { - result1 *s3.ListPartsOutput - result2 error - } - PutBucketAccelerateConfigurationStub func(*s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error) - putBucketAccelerateConfigurationMutex sync.RWMutex - putBucketAccelerateConfigurationArgsForCall []struct { - arg1 *s3.PutBucketAccelerateConfigurationInput - } - putBucketAccelerateConfigurationReturns struct { - result1 *s3.PutBucketAccelerateConfigurationOutput - result2 error - } - putBucketAccelerateConfigurationReturnsOnCall map[int]struct { - result1 *s3.PutBucketAccelerateConfigurationOutput - result2 error - } - PutBucketAccelerateConfigurationRequestStub func(*s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput) - putBucketAccelerateConfigurationRequestMutex sync.RWMutex - putBucketAccelerateConfigurationRequestArgsForCall []struct { - arg1 *s3.PutBucketAccelerateConfigurationInput - } - putBucketAccelerateConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketAccelerateConfigurationOutput - } - putBucketAccelerateConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketAccelerateConfigurationOutput - } - PutBucketAccelerateConfigurationWithContextStub func(context.Context, *s3.PutBucketAccelerateConfigurationInput, ...request.Option) (*s3.PutBucketAccelerateConfigurationOutput, error) - putBucketAccelerateConfigurationWithContextMutex sync.RWMutex - putBucketAccelerateConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketAccelerateConfigurationInput - arg3 []request.Option - } - putBucketAccelerateConfigurationWithContextReturns struct { - result1 *s3.PutBucketAccelerateConfigurationOutput - result2 error - } - putBucketAccelerateConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketAccelerateConfigurationOutput - result2 error - } - PutBucketAclStub func(*s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error) - putBucketAclMutex sync.RWMutex - putBucketAclArgsForCall []struct { - arg1 *s3.PutBucketAclInput - } - putBucketAclReturns struct { - result1 *s3.PutBucketAclOutput - result2 error - } - putBucketAclReturnsOnCall map[int]struct { - result1 *s3.PutBucketAclOutput - result2 error - } - PutBucketAclRequestStub func(*s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput) - putBucketAclRequestMutex sync.RWMutex - putBucketAclRequestArgsForCall []struct { - arg1 *s3.PutBucketAclInput - } - putBucketAclRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketAclOutput - } - putBucketAclRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketAclOutput - } - PutBucketAclWithContextStub func(context.Context, *s3.PutBucketAclInput, ...request.Option) (*s3.PutBucketAclOutput, error) - putBucketAclWithContextMutex sync.RWMutex - putBucketAclWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketAclInput - arg3 []request.Option - } - putBucketAclWithContextReturns struct { - result1 *s3.PutBucketAclOutput - result2 error - } - putBucketAclWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketAclOutput - result2 error - } - PutBucketAnalyticsConfigurationStub func(*s3.PutBucketAnalyticsConfigurationInput) (*s3.PutBucketAnalyticsConfigurationOutput, error) - putBucketAnalyticsConfigurationMutex sync.RWMutex - putBucketAnalyticsConfigurationArgsForCall []struct { - arg1 *s3.PutBucketAnalyticsConfigurationInput - } - putBucketAnalyticsConfigurationReturns struct { - result1 *s3.PutBucketAnalyticsConfigurationOutput - result2 error - } - putBucketAnalyticsConfigurationReturnsOnCall map[int]struct { - result1 *s3.PutBucketAnalyticsConfigurationOutput - result2 error - } - PutBucketAnalyticsConfigurationRequestStub func(*s3.PutBucketAnalyticsConfigurationInput) (*request.Request, *s3.PutBucketAnalyticsConfigurationOutput) - putBucketAnalyticsConfigurationRequestMutex sync.RWMutex - putBucketAnalyticsConfigurationRequestArgsForCall []struct { - arg1 *s3.PutBucketAnalyticsConfigurationInput - } - putBucketAnalyticsConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketAnalyticsConfigurationOutput - } - putBucketAnalyticsConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketAnalyticsConfigurationOutput - } - PutBucketAnalyticsConfigurationWithContextStub func(context.Context, *s3.PutBucketAnalyticsConfigurationInput, ...request.Option) (*s3.PutBucketAnalyticsConfigurationOutput, error) - putBucketAnalyticsConfigurationWithContextMutex sync.RWMutex - putBucketAnalyticsConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketAnalyticsConfigurationInput - arg3 []request.Option - } - putBucketAnalyticsConfigurationWithContextReturns struct { - result1 *s3.PutBucketAnalyticsConfigurationOutput - result2 error - } - putBucketAnalyticsConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketAnalyticsConfigurationOutput - result2 error - } - PutBucketCorsStub func(*s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error) - putBucketCorsMutex sync.RWMutex - putBucketCorsArgsForCall []struct { - arg1 *s3.PutBucketCorsInput - } - putBucketCorsReturns struct { - result1 *s3.PutBucketCorsOutput - result2 error - } - putBucketCorsReturnsOnCall map[int]struct { - result1 *s3.PutBucketCorsOutput - result2 error - } - PutBucketCorsRequestStub func(*s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput) - putBucketCorsRequestMutex sync.RWMutex - putBucketCorsRequestArgsForCall []struct { - arg1 *s3.PutBucketCorsInput - } - putBucketCorsRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketCorsOutput - } - putBucketCorsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketCorsOutput - } - PutBucketCorsWithContextStub func(context.Context, *s3.PutBucketCorsInput, ...request.Option) (*s3.PutBucketCorsOutput, error) - putBucketCorsWithContextMutex sync.RWMutex - putBucketCorsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketCorsInput - arg3 []request.Option - } - putBucketCorsWithContextReturns struct { - result1 *s3.PutBucketCorsOutput - result2 error - } - putBucketCorsWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketCorsOutput - result2 error - } - PutBucketEncryptionStub func(*s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error) - putBucketEncryptionMutex sync.RWMutex - putBucketEncryptionArgsForCall []struct { - arg1 *s3.PutBucketEncryptionInput - } - putBucketEncryptionReturns struct { - result1 *s3.PutBucketEncryptionOutput - result2 error - } - putBucketEncryptionReturnsOnCall map[int]struct { - result1 *s3.PutBucketEncryptionOutput - result2 error - } - PutBucketEncryptionRequestStub func(*s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput) - putBucketEncryptionRequestMutex sync.RWMutex - putBucketEncryptionRequestArgsForCall []struct { - arg1 *s3.PutBucketEncryptionInput - } - putBucketEncryptionRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketEncryptionOutput - } - putBucketEncryptionRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketEncryptionOutput - } - PutBucketEncryptionWithContextStub func(context.Context, *s3.PutBucketEncryptionInput, ...request.Option) (*s3.PutBucketEncryptionOutput, error) - putBucketEncryptionWithContextMutex sync.RWMutex - putBucketEncryptionWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketEncryptionInput - arg3 []request.Option - } - putBucketEncryptionWithContextReturns struct { - result1 *s3.PutBucketEncryptionOutput - result2 error - } - putBucketEncryptionWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketEncryptionOutput - result2 error - } - PutBucketIntelligentTieringConfigurationStub func(*s3.PutBucketIntelligentTieringConfigurationInput) (*s3.PutBucketIntelligentTieringConfigurationOutput, error) - putBucketIntelligentTieringConfigurationMutex sync.RWMutex - putBucketIntelligentTieringConfigurationArgsForCall []struct { - arg1 *s3.PutBucketIntelligentTieringConfigurationInput - } - putBucketIntelligentTieringConfigurationReturns struct { - result1 *s3.PutBucketIntelligentTieringConfigurationOutput - result2 error - } - putBucketIntelligentTieringConfigurationReturnsOnCall map[int]struct { - result1 *s3.PutBucketIntelligentTieringConfigurationOutput - result2 error - } - PutBucketIntelligentTieringConfigurationRequestStub func(*s3.PutBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.PutBucketIntelligentTieringConfigurationOutput) - putBucketIntelligentTieringConfigurationRequestMutex sync.RWMutex - putBucketIntelligentTieringConfigurationRequestArgsForCall []struct { - arg1 *s3.PutBucketIntelligentTieringConfigurationInput - } - putBucketIntelligentTieringConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketIntelligentTieringConfigurationOutput - } - putBucketIntelligentTieringConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketIntelligentTieringConfigurationOutput - } - PutBucketIntelligentTieringConfigurationWithContextStub func(context.Context, *s3.PutBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.PutBucketIntelligentTieringConfigurationOutput, error) - putBucketIntelligentTieringConfigurationWithContextMutex sync.RWMutex - putBucketIntelligentTieringConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketIntelligentTieringConfigurationInput - arg3 []request.Option - } - putBucketIntelligentTieringConfigurationWithContextReturns struct { - result1 *s3.PutBucketIntelligentTieringConfigurationOutput - result2 error - } - putBucketIntelligentTieringConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketIntelligentTieringConfigurationOutput - result2 error - } - PutBucketInventoryConfigurationStub func(*s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error) - putBucketInventoryConfigurationMutex sync.RWMutex - putBucketInventoryConfigurationArgsForCall []struct { - arg1 *s3.PutBucketInventoryConfigurationInput - } - putBucketInventoryConfigurationReturns struct { - result1 *s3.PutBucketInventoryConfigurationOutput - result2 error - } - putBucketInventoryConfigurationReturnsOnCall map[int]struct { - result1 *s3.PutBucketInventoryConfigurationOutput - result2 error - } - PutBucketInventoryConfigurationRequestStub func(*s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput) - putBucketInventoryConfigurationRequestMutex sync.RWMutex - putBucketInventoryConfigurationRequestArgsForCall []struct { - arg1 *s3.PutBucketInventoryConfigurationInput - } - putBucketInventoryConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketInventoryConfigurationOutput - } - putBucketInventoryConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketInventoryConfigurationOutput - } - PutBucketInventoryConfigurationWithContextStub func(context.Context, *s3.PutBucketInventoryConfigurationInput, ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error) - putBucketInventoryConfigurationWithContextMutex sync.RWMutex - putBucketInventoryConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketInventoryConfigurationInput - arg3 []request.Option - } - putBucketInventoryConfigurationWithContextReturns struct { - result1 *s3.PutBucketInventoryConfigurationOutput - result2 error - } - putBucketInventoryConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketInventoryConfigurationOutput - result2 error - } - PutBucketLifecycleStub func(*s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error) - putBucketLifecycleMutex sync.RWMutex - putBucketLifecycleArgsForCall []struct { - arg1 *s3.PutBucketLifecycleInput - } - putBucketLifecycleReturns struct { - result1 *s3.PutBucketLifecycleOutput - result2 error - } - putBucketLifecycleReturnsOnCall map[int]struct { - result1 *s3.PutBucketLifecycleOutput - result2 error - } - PutBucketLifecycleConfigurationStub func(*s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error) - putBucketLifecycleConfigurationMutex sync.RWMutex - putBucketLifecycleConfigurationArgsForCall []struct { - arg1 *s3.PutBucketLifecycleConfigurationInput - } - putBucketLifecycleConfigurationReturns struct { - result1 *s3.PutBucketLifecycleConfigurationOutput - result2 error - } - putBucketLifecycleConfigurationReturnsOnCall map[int]struct { - result1 *s3.PutBucketLifecycleConfigurationOutput - result2 error - } - PutBucketLifecycleConfigurationRequestStub func(*s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput) - putBucketLifecycleConfigurationRequestMutex sync.RWMutex - putBucketLifecycleConfigurationRequestArgsForCall []struct { - arg1 *s3.PutBucketLifecycleConfigurationInput - } - putBucketLifecycleConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketLifecycleConfigurationOutput - } - putBucketLifecycleConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketLifecycleConfigurationOutput - } - PutBucketLifecycleConfigurationWithContextStub func(context.Context, *s3.PutBucketLifecycleConfigurationInput, ...request.Option) (*s3.PutBucketLifecycleConfigurationOutput, error) - putBucketLifecycleConfigurationWithContextMutex sync.RWMutex - putBucketLifecycleConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketLifecycleConfigurationInput - arg3 []request.Option - } - putBucketLifecycleConfigurationWithContextReturns struct { - result1 *s3.PutBucketLifecycleConfigurationOutput - result2 error - } - putBucketLifecycleConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketLifecycleConfigurationOutput - result2 error - } - PutBucketLifecycleRequestStub func(*s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput) - putBucketLifecycleRequestMutex sync.RWMutex - putBucketLifecycleRequestArgsForCall []struct { - arg1 *s3.PutBucketLifecycleInput - } - putBucketLifecycleRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketLifecycleOutput - } - putBucketLifecycleRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketLifecycleOutput - } - PutBucketLifecycleWithContextStub func(context.Context, *s3.PutBucketLifecycleInput, ...request.Option) (*s3.PutBucketLifecycleOutput, error) - putBucketLifecycleWithContextMutex sync.RWMutex - putBucketLifecycleWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketLifecycleInput - arg3 []request.Option - } - putBucketLifecycleWithContextReturns struct { - result1 *s3.PutBucketLifecycleOutput - result2 error - } - putBucketLifecycleWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketLifecycleOutput - result2 error - } - PutBucketLoggingStub func(*s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error) - putBucketLoggingMutex sync.RWMutex - putBucketLoggingArgsForCall []struct { - arg1 *s3.PutBucketLoggingInput - } - putBucketLoggingReturns struct { - result1 *s3.PutBucketLoggingOutput - result2 error - } - putBucketLoggingReturnsOnCall map[int]struct { - result1 *s3.PutBucketLoggingOutput - result2 error - } - PutBucketLoggingRequestStub func(*s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput) - putBucketLoggingRequestMutex sync.RWMutex - putBucketLoggingRequestArgsForCall []struct { - arg1 *s3.PutBucketLoggingInput - } - putBucketLoggingRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketLoggingOutput - } - putBucketLoggingRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketLoggingOutput - } - PutBucketLoggingWithContextStub func(context.Context, *s3.PutBucketLoggingInput, ...request.Option) (*s3.PutBucketLoggingOutput, error) - putBucketLoggingWithContextMutex sync.RWMutex - putBucketLoggingWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketLoggingInput - arg3 []request.Option - } - putBucketLoggingWithContextReturns struct { - result1 *s3.PutBucketLoggingOutput - result2 error - } - putBucketLoggingWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketLoggingOutput - result2 error - } - PutBucketMetricsConfigurationStub func(*s3.PutBucketMetricsConfigurationInput) (*s3.PutBucketMetricsConfigurationOutput, error) - putBucketMetricsConfigurationMutex sync.RWMutex - putBucketMetricsConfigurationArgsForCall []struct { - arg1 *s3.PutBucketMetricsConfigurationInput - } - putBucketMetricsConfigurationReturns struct { - result1 *s3.PutBucketMetricsConfigurationOutput - result2 error - } - putBucketMetricsConfigurationReturnsOnCall map[int]struct { - result1 *s3.PutBucketMetricsConfigurationOutput - result2 error - } - PutBucketMetricsConfigurationRequestStub func(*s3.PutBucketMetricsConfigurationInput) (*request.Request, *s3.PutBucketMetricsConfigurationOutput) - putBucketMetricsConfigurationRequestMutex sync.RWMutex - putBucketMetricsConfigurationRequestArgsForCall []struct { - arg1 *s3.PutBucketMetricsConfigurationInput - } - putBucketMetricsConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketMetricsConfigurationOutput - } - putBucketMetricsConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketMetricsConfigurationOutput - } - PutBucketMetricsConfigurationWithContextStub func(context.Context, *s3.PutBucketMetricsConfigurationInput, ...request.Option) (*s3.PutBucketMetricsConfigurationOutput, error) - putBucketMetricsConfigurationWithContextMutex sync.RWMutex - putBucketMetricsConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketMetricsConfigurationInput - arg3 []request.Option - } - putBucketMetricsConfigurationWithContextReturns struct { - result1 *s3.PutBucketMetricsConfigurationOutput - result2 error - } - putBucketMetricsConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketMetricsConfigurationOutput - result2 error - } - PutBucketNotificationStub func(*s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error) - putBucketNotificationMutex sync.RWMutex - putBucketNotificationArgsForCall []struct { - arg1 *s3.PutBucketNotificationInput - } - putBucketNotificationReturns struct { - result1 *s3.PutBucketNotificationOutput - result2 error - } - putBucketNotificationReturnsOnCall map[int]struct { - result1 *s3.PutBucketNotificationOutput - result2 error - } - PutBucketNotificationConfigurationStub func(*s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error) - putBucketNotificationConfigurationMutex sync.RWMutex - putBucketNotificationConfigurationArgsForCall []struct { - arg1 *s3.PutBucketNotificationConfigurationInput - } - putBucketNotificationConfigurationReturns struct { - result1 *s3.PutBucketNotificationConfigurationOutput - result2 error - } - putBucketNotificationConfigurationReturnsOnCall map[int]struct { - result1 *s3.PutBucketNotificationConfigurationOutput - result2 error - } - PutBucketNotificationConfigurationRequestStub func(*s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput) - putBucketNotificationConfigurationRequestMutex sync.RWMutex - putBucketNotificationConfigurationRequestArgsForCall []struct { - arg1 *s3.PutBucketNotificationConfigurationInput - } - putBucketNotificationConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketNotificationConfigurationOutput - } - putBucketNotificationConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketNotificationConfigurationOutput - } - PutBucketNotificationConfigurationWithContextStub func(context.Context, *s3.PutBucketNotificationConfigurationInput, ...request.Option) (*s3.PutBucketNotificationConfigurationOutput, error) - putBucketNotificationConfigurationWithContextMutex sync.RWMutex - putBucketNotificationConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketNotificationConfigurationInput - arg3 []request.Option - } - putBucketNotificationConfigurationWithContextReturns struct { - result1 *s3.PutBucketNotificationConfigurationOutput - result2 error - } - putBucketNotificationConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketNotificationConfigurationOutput - result2 error - } - PutBucketNotificationRequestStub func(*s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput) - putBucketNotificationRequestMutex sync.RWMutex - putBucketNotificationRequestArgsForCall []struct { - arg1 *s3.PutBucketNotificationInput - } - putBucketNotificationRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketNotificationOutput - } - putBucketNotificationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketNotificationOutput - } - PutBucketNotificationWithContextStub func(context.Context, *s3.PutBucketNotificationInput, ...request.Option) (*s3.PutBucketNotificationOutput, error) - putBucketNotificationWithContextMutex sync.RWMutex - putBucketNotificationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketNotificationInput - arg3 []request.Option - } - putBucketNotificationWithContextReturns struct { - result1 *s3.PutBucketNotificationOutput - result2 error - } - putBucketNotificationWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketNotificationOutput - result2 error - } - PutBucketOwnershipControlsStub func(*s3.PutBucketOwnershipControlsInput) (*s3.PutBucketOwnershipControlsOutput, error) - putBucketOwnershipControlsMutex sync.RWMutex - putBucketOwnershipControlsArgsForCall []struct { - arg1 *s3.PutBucketOwnershipControlsInput - } - putBucketOwnershipControlsReturns struct { - result1 *s3.PutBucketOwnershipControlsOutput - result2 error - } - putBucketOwnershipControlsReturnsOnCall map[int]struct { - result1 *s3.PutBucketOwnershipControlsOutput - result2 error - } - PutBucketOwnershipControlsRequestStub func(*s3.PutBucketOwnershipControlsInput) (*request.Request, *s3.PutBucketOwnershipControlsOutput) - putBucketOwnershipControlsRequestMutex sync.RWMutex - putBucketOwnershipControlsRequestArgsForCall []struct { - arg1 *s3.PutBucketOwnershipControlsInput - } - putBucketOwnershipControlsRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketOwnershipControlsOutput - } - putBucketOwnershipControlsRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketOwnershipControlsOutput - } - PutBucketOwnershipControlsWithContextStub func(context.Context, *s3.PutBucketOwnershipControlsInput, ...request.Option) (*s3.PutBucketOwnershipControlsOutput, error) - putBucketOwnershipControlsWithContextMutex sync.RWMutex - putBucketOwnershipControlsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketOwnershipControlsInput - arg3 []request.Option - } - putBucketOwnershipControlsWithContextReturns struct { - result1 *s3.PutBucketOwnershipControlsOutput - result2 error - } - putBucketOwnershipControlsWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketOwnershipControlsOutput - result2 error - } - PutBucketPolicyStub func(*s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error) - putBucketPolicyMutex sync.RWMutex - putBucketPolicyArgsForCall []struct { - arg1 *s3.PutBucketPolicyInput - } - putBucketPolicyReturns struct { - result1 *s3.PutBucketPolicyOutput - result2 error - } - putBucketPolicyReturnsOnCall map[int]struct { - result1 *s3.PutBucketPolicyOutput - result2 error - } - PutBucketPolicyRequestStub func(*s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput) - putBucketPolicyRequestMutex sync.RWMutex - putBucketPolicyRequestArgsForCall []struct { - arg1 *s3.PutBucketPolicyInput - } - putBucketPolicyRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketPolicyOutput - } - putBucketPolicyRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketPolicyOutput - } - PutBucketPolicyWithContextStub func(context.Context, *s3.PutBucketPolicyInput, ...request.Option) (*s3.PutBucketPolicyOutput, error) - putBucketPolicyWithContextMutex sync.RWMutex - putBucketPolicyWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketPolicyInput - arg3 []request.Option - } - putBucketPolicyWithContextReturns struct { - result1 *s3.PutBucketPolicyOutput - result2 error - } - putBucketPolicyWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketPolicyOutput - result2 error - } - PutBucketReplicationStub func(*s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error) - putBucketReplicationMutex sync.RWMutex - putBucketReplicationArgsForCall []struct { - arg1 *s3.PutBucketReplicationInput - } - putBucketReplicationReturns struct { - result1 *s3.PutBucketReplicationOutput - result2 error - } - putBucketReplicationReturnsOnCall map[int]struct { - result1 *s3.PutBucketReplicationOutput - result2 error - } - PutBucketReplicationRequestStub func(*s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput) - putBucketReplicationRequestMutex sync.RWMutex - putBucketReplicationRequestArgsForCall []struct { - arg1 *s3.PutBucketReplicationInput - } - putBucketReplicationRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketReplicationOutput - } - putBucketReplicationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketReplicationOutput - } - PutBucketReplicationWithContextStub func(context.Context, *s3.PutBucketReplicationInput, ...request.Option) (*s3.PutBucketReplicationOutput, error) - putBucketReplicationWithContextMutex sync.RWMutex - putBucketReplicationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketReplicationInput - arg3 []request.Option - } - putBucketReplicationWithContextReturns struct { - result1 *s3.PutBucketReplicationOutput - result2 error - } - putBucketReplicationWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketReplicationOutput - result2 error - } - PutBucketRequestPaymentStub func(*s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error) - putBucketRequestPaymentMutex sync.RWMutex - putBucketRequestPaymentArgsForCall []struct { - arg1 *s3.PutBucketRequestPaymentInput - } - putBucketRequestPaymentReturns struct { - result1 *s3.PutBucketRequestPaymentOutput - result2 error - } - putBucketRequestPaymentReturnsOnCall map[int]struct { - result1 *s3.PutBucketRequestPaymentOutput - result2 error - } - PutBucketRequestPaymentRequestStub func(*s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput) - putBucketRequestPaymentRequestMutex sync.RWMutex - putBucketRequestPaymentRequestArgsForCall []struct { - arg1 *s3.PutBucketRequestPaymentInput - } - putBucketRequestPaymentRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketRequestPaymentOutput - } - putBucketRequestPaymentRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketRequestPaymentOutput - } - PutBucketRequestPaymentWithContextStub func(context.Context, *s3.PutBucketRequestPaymentInput, ...request.Option) (*s3.PutBucketRequestPaymentOutput, error) - putBucketRequestPaymentWithContextMutex sync.RWMutex - putBucketRequestPaymentWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketRequestPaymentInput - arg3 []request.Option - } - putBucketRequestPaymentWithContextReturns struct { - result1 *s3.PutBucketRequestPaymentOutput - result2 error - } - putBucketRequestPaymentWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketRequestPaymentOutput - result2 error - } - PutBucketTaggingStub func(*s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error) - putBucketTaggingMutex sync.RWMutex - putBucketTaggingArgsForCall []struct { - arg1 *s3.PutBucketTaggingInput - } - putBucketTaggingReturns struct { - result1 *s3.PutBucketTaggingOutput - result2 error - } - putBucketTaggingReturnsOnCall map[int]struct { - result1 *s3.PutBucketTaggingOutput - result2 error - } - PutBucketTaggingRequestStub func(*s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput) - putBucketTaggingRequestMutex sync.RWMutex - putBucketTaggingRequestArgsForCall []struct { - arg1 *s3.PutBucketTaggingInput - } - putBucketTaggingRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketTaggingOutput - } - putBucketTaggingRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketTaggingOutput - } - PutBucketTaggingWithContextStub func(context.Context, *s3.PutBucketTaggingInput, ...request.Option) (*s3.PutBucketTaggingOutput, error) - putBucketTaggingWithContextMutex sync.RWMutex - putBucketTaggingWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketTaggingInput - arg3 []request.Option - } - putBucketTaggingWithContextReturns struct { - result1 *s3.PutBucketTaggingOutput - result2 error - } - putBucketTaggingWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketTaggingOutput - result2 error - } - PutBucketVersioningStub func(*s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error) - putBucketVersioningMutex sync.RWMutex - putBucketVersioningArgsForCall []struct { - arg1 *s3.PutBucketVersioningInput - } - putBucketVersioningReturns struct { - result1 *s3.PutBucketVersioningOutput - result2 error - } - putBucketVersioningReturnsOnCall map[int]struct { - result1 *s3.PutBucketVersioningOutput - result2 error - } - PutBucketVersioningRequestStub func(*s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput) - putBucketVersioningRequestMutex sync.RWMutex - putBucketVersioningRequestArgsForCall []struct { - arg1 *s3.PutBucketVersioningInput - } - putBucketVersioningRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketVersioningOutput - } - putBucketVersioningRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketVersioningOutput - } - PutBucketVersioningWithContextStub func(context.Context, *s3.PutBucketVersioningInput, ...request.Option) (*s3.PutBucketVersioningOutput, error) - putBucketVersioningWithContextMutex sync.RWMutex - putBucketVersioningWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketVersioningInput - arg3 []request.Option - } - putBucketVersioningWithContextReturns struct { - result1 *s3.PutBucketVersioningOutput - result2 error - } - putBucketVersioningWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketVersioningOutput - result2 error - } - PutBucketWebsiteStub func(*s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error) - putBucketWebsiteMutex sync.RWMutex - putBucketWebsiteArgsForCall []struct { - arg1 *s3.PutBucketWebsiteInput - } - putBucketWebsiteReturns struct { - result1 *s3.PutBucketWebsiteOutput - result2 error - } - putBucketWebsiteReturnsOnCall map[int]struct { - result1 *s3.PutBucketWebsiteOutput - result2 error - } - PutBucketWebsiteRequestStub func(*s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput) - putBucketWebsiteRequestMutex sync.RWMutex - putBucketWebsiteRequestArgsForCall []struct { - arg1 *s3.PutBucketWebsiteInput - } - putBucketWebsiteRequestReturns struct { - result1 *request.Request - result2 *s3.PutBucketWebsiteOutput - } - putBucketWebsiteRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutBucketWebsiteOutput - } - PutBucketWebsiteWithContextStub func(context.Context, *s3.PutBucketWebsiteInput, ...request.Option) (*s3.PutBucketWebsiteOutput, error) - putBucketWebsiteWithContextMutex sync.RWMutex - putBucketWebsiteWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutBucketWebsiteInput - arg3 []request.Option - } - putBucketWebsiteWithContextReturns struct { - result1 *s3.PutBucketWebsiteOutput - result2 error - } - putBucketWebsiteWithContextReturnsOnCall map[int]struct { - result1 *s3.PutBucketWebsiteOutput - result2 error - } - PutObjectStub func(*s3.PutObjectInput) (*s3.PutObjectOutput, error) - putObjectMutex sync.RWMutex - putObjectArgsForCall []struct { - arg1 *s3.PutObjectInput - } - putObjectReturns struct { - result1 *s3.PutObjectOutput - result2 error - } - putObjectReturnsOnCall map[int]struct { - result1 *s3.PutObjectOutput - result2 error - } - PutObjectAclStub func(*s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error) - putObjectAclMutex sync.RWMutex - putObjectAclArgsForCall []struct { - arg1 *s3.PutObjectAclInput - } - putObjectAclReturns struct { - result1 *s3.PutObjectAclOutput - result2 error - } - putObjectAclReturnsOnCall map[int]struct { - result1 *s3.PutObjectAclOutput - result2 error - } - PutObjectAclRequestStub func(*s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput) - putObjectAclRequestMutex sync.RWMutex - putObjectAclRequestArgsForCall []struct { - arg1 *s3.PutObjectAclInput - } - putObjectAclRequestReturns struct { - result1 *request.Request - result2 *s3.PutObjectAclOutput - } - putObjectAclRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutObjectAclOutput - } - PutObjectAclWithContextStub func(context.Context, *s3.PutObjectAclInput, ...request.Option) (*s3.PutObjectAclOutput, error) - putObjectAclWithContextMutex sync.RWMutex - putObjectAclWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutObjectAclInput - arg3 []request.Option - } - putObjectAclWithContextReturns struct { - result1 *s3.PutObjectAclOutput - result2 error - } - putObjectAclWithContextReturnsOnCall map[int]struct { - result1 *s3.PutObjectAclOutput - result2 error - } - PutObjectLegalHoldStub func(*s3.PutObjectLegalHoldInput) (*s3.PutObjectLegalHoldOutput, error) - putObjectLegalHoldMutex sync.RWMutex - putObjectLegalHoldArgsForCall []struct { - arg1 *s3.PutObjectLegalHoldInput - } - putObjectLegalHoldReturns struct { - result1 *s3.PutObjectLegalHoldOutput - result2 error - } - putObjectLegalHoldReturnsOnCall map[int]struct { - result1 *s3.PutObjectLegalHoldOutput - result2 error - } - PutObjectLegalHoldRequestStub func(*s3.PutObjectLegalHoldInput) (*request.Request, *s3.PutObjectLegalHoldOutput) - putObjectLegalHoldRequestMutex sync.RWMutex - putObjectLegalHoldRequestArgsForCall []struct { - arg1 *s3.PutObjectLegalHoldInput - } - putObjectLegalHoldRequestReturns struct { - result1 *request.Request - result2 *s3.PutObjectLegalHoldOutput - } - putObjectLegalHoldRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutObjectLegalHoldOutput - } - PutObjectLegalHoldWithContextStub func(context.Context, *s3.PutObjectLegalHoldInput, ...request.Option) (*s3.PutObjectLegalHoldOutput, error) - putObjectLegalHoldWithContextMutex sync.RWMutex - putObjectLegalHoldWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutObjectLegalHoldInput - arg3 []request.Option - } - putObjectLegalHoldWithContextReturns struct { - result1 *s3.PutObjectLegalHoldOutput - result2 error - } - putObjectLegalHoldWithContextReturnsOnCall map[int]struct { - result1 *s3.PutObjectLegalHoldOutput - result2 error - } - PutObjectLockConfigurationStub func(*s3.PutObjectLockConfigurationInput) (*s3.PutObjectLockConfigurationOutput, error) - putObjectLockConfigurationMutex sync.RWMutex - putObjectLockConfigurationArgsForCall []struct { - arg1 *s3.PutObjectLockConfigurationInput - } - putObjectLockConfigurationReturns struct { - result1 *s3.PutObjectLockConfigurationOutput - result2 error - } - putObjectLockConfigurationReturnsOnCall map[int]struct { - result1 *s3.PutObjectLockConfigurationOutput - result2 error - } - PutObjectLockConfigurationRequestStub func(*s3.PutObjectLockConfigurationInput) (*request.Request, *s3.PutObjectLockConfigurationOutput) - putObjectLockConfigurationRequestMutex sync.RWMutex - putObjectLockConfigurationRequestArgsForCall []struct { - arg1 *s3.PutObjectLockConfigurationInput - } - putObjectLockConfigurationRequestReturns struct { - result1 *request.Request - result2 *s3.PutObjectLockConfigurationOutput - } - putObjectLockConfigurationRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutObjectLockConfigurationOutput - } - PutObjectLockConfigurationWithContextStub func(context.Context, *s3.PutObjectLockConfigurationInput, ...request.Option) (*s3.PutObjectLockConfigurationOutput, error) - putObjectLockConfigurationWithContextMutex sync.RWMutex - putObjectLockConfigurationWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutObjectLockConfigurationInput - arg3 []request.Option - } - putObjectLockConfigurationWithContextReturns struct { - result1 *s3.PutObjectLockConfigurationOutput - result2 error - } - putObjectLockConfigurationWithContextReturnsOnCall map[int]struct { - result1 *s3.PutObjectLockConfigurationOutput - result2 error - } - PutObjectRequestStub func(*s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput) - putObjectRequestMutex sync.RWMutex - putObjectRequestArgsForCall []struct { - arg1 *s3.PutObjectInput - } - putObjectRequestReturns struct { - result1 *request.Request - result2 *s3.PutObjectOutput - } - putObjectRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutObjectOutput - } - PutObjectRetentionStub func(*s3.PutObjectRetentionInput) (*s3.PutObjectRetentionOutput, error) - putObjectRetentionMutex sync.RWMutex - putObjectRetentionArgsForCall []struct { - arg1 *s3.PutObjectRetentionInput - } - putObjectRetentionReturns struct { - result1 *s3.PutObjectRetentionOutput - result2 error - } - putObjectRetentionReturnsOnCall map[int]struct { - result1 *s3.PutObjectRetentionOutput - result2 error - } - PutObjectRetentionRequestStub func(*s3.PutObjectRetentionInput) (*request.Request, *s3.PutObjectRetentionOutput) - putObjectRetentionRequestMutex sync.RWMutex - putObjectRetentionRequestArgsForCall []struct { - arg1 *s3.PutObjectRetentionInput - } - putObjectRetentionRequestReturns struct { - result1 *request.Request - result2 *s3.PutObjectRetentionOutput - } - putObjectRetentionRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutObjectRetentionOutput - } - PutObjectRetentionWithContextStub func(context.Context, *s3.PutObjectRetentionInput, ...request.Option) (*s3.PutObjectRetentionOutput, error) - putObjectRetentionWithContextMutex sync.RWMutex - putObjectRetentionWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutObjectRetentionInput - arg3 []request.Option - } - putObjectRetentionWithContextReturns struct { - result1 *s3.PutObjectRetentionOutput - result2 error - } - putObjectRetentionWithContextReturnsOnCall map[int]struct { - result1 *s3.PutObjectRetentionOutput - result2 error - } - PutObjectTaggingStub func(*s3.PutObjectTaggingInput) (*s3.PutObjectTaggingOutput, error) - putObjectTaggingMutex sync.RWMutex - putObjectTaggingArgsForCall []struct { - arg1 *s3.PutObjectTaggingInput - } - putObjectTaggingReturns struct { - result1 *s3.PutObjectTaggingOutput - result2 error - } - putObjectTaggingReturnsOnCall map[int]struct { - result1 *s3.PutObjectTaggingOutput - result2 error - } - PutObjectTaggingRequestStub func(*s3.PutObjectTaggingInput) (*request.Request, *s3.PutObjectTaggingOutput) - putObjectTaggingRequestMutex sync.RWMutex - putObjectTaggingRequestArgsForCall []struct { - arg1 *s3.PutObjectTaggingInput - } - putObjectTaggingRequestReturns struct { - result1 *request.Request - result2 *s3.PutObjectTaggingOutput - } - putObjectTaggingRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutObjectTaggingOutput - } - PutObjectTaggingWithContextStub func(context.Context, *s3.PutObjectTaggingInput, ...request.Option) (*s3.PutObjectTaggingOutput, error) - putObjectTaggingWithContextMutex sync.RWMutex - putObjectTaggingWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutObjectTaggingInput - arg3 []request.Option - } - putObjectTaggingWithContextReturns struct { - result1 *s3.PutObjectTaggingOutput - result2 error - } - putObjectTaggingWithContextReturnsOnCall map[int]struct { - result1 *s3.PutObjectTaggingOutput - result2 error - } - PutObjectWithContextStub func(context.Context, *s3.PutObjectInput, ...request.Option) (*s3.PutObjectOutput, error) - putObjectWithContextMutex sync.RWMutex - putObjectWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutObjectInput - arg3 []request.Option - } - putObjectWithContextReturns struct { - result1 *s3.PutObjectOutput - result2 error - } - putObjectWithContextReturnsOnCall map[int]struct { - result1 *s3.PutObjectOutput - result2 error - } - PutPublicAccessBlockStub func(*s3.PutPublicAccessBlockInput) (*s3.PutPublicAccessBlockOutput, error) - putPublicAccessBlockMutex sync.RWMutex - putPublicAccessBlockArgsForCall []struct { - arg1 *s3.PutPublicAccessBlockInput - } - putPublicAccessBlockReturns struct { - result1 *s3.PutPublicAccessBlockOutput - result2 error - } - putPublicAccessBlockReturnsOnCall map[int]struct { - result1 *s3.PutPublicAccessBlockOutput - result2 error - } - PutPublicAccessBlockRequestStub func(*s3.PutPublicAccessBlockInput) (*request.Request, *s3.PutPublicAccessBlockOutput) - putPublicAccessBlockRequestMutex sync.RWMutex - putPublicAccessBlockRequestArgsForCall []struct { - arg1 *s3.PutPublicAccessBlockInput - } - putPublicAccessBlockRequestReturns struct { - result1 *request.Request - result2 *s3.PutPublicAccessBlockOutput - } - putPublicAccessBlockRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.PutPublicAccessBlockOutput - } - PutPublicAccessBlockWithContextStub func(context.Context, *s3.PutPublicAccessBlockInput, ...request.Option) (*s3.PutPublicAccessBlockOutput, error) - putPublicAccessBlockWithContextMutex sync.RWMutex - putPublicAccessBlockWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.PutPublicAccessBlockInput - arg3 []request.Option - } - putPublicAccessBlockWithContextReturns struct { - result1 *s3.PutPublicAccessBlockOutput - result2 error - } - putPublicAccessBlockWithContextReturnsOnCall map[int]struct { - result1 *s3.PutPublicAccessBlockOutput - result2 error - } - RestoreObjectStub func(*s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error) - restoreObjectMutex sync.RWMutex - restoreObjectArgsForCall []struct { - arg1 *s3.RestoreObjectInput - } - restoreObjectReturns struct { - result1 *s3.RestoreObjectOutput - result2 error - } - restoreObjectReturnsOnCall map[int]struct { - result1 *s3.RestoreObjectOutput - result2 error - } - RestoreObjectRequestStub func(*s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput) - restoreObjectRequestMutex sync.RWMutex - restoreObjectRequestArgsForCall []struct { - arg1 *s3.RestoreObjectInput - } - restoreObjectRequestReturns struct { - result1 *request.Request - result2 *s3.RestoreObjectOutput - } - restoreObjectRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.RestoreObjectOutput - } - RestoreObjectWithContextStub func(context.Context, *s3.RestoreObjectInput, ...request.Option) (*s3.RestoreObjectOutput, error) - restoreObjectWithContextMutex sync.RWMutex - restoreObjectWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.RestoreObjectInput - arg3 []request.Option - } - restoreObjectWithContextReturns struct { - result1 *s3.RestoreObjectOutput - result2 error - } - restoreObjectWithContextReturnsOnCall map[int]struct { - result1 *s3.RestoreObjectOutput - result2 error - } - SelectObjectContentStub func(*s3.SelectObjectContentInput) (*s3.SelectObjectContentOutput, error) - selectObjectContentMutex sync.RWMutex - selectObjectContentArgsForCall []struct { - arg1 *s3.SelectObjectContentInput - } - selectObjectContentReturns struct { - result1 *s3.SelectObjectContentOutput - result2 error - } - selectObjectContentReturnsOnCall map[int]struct { - result1 *s3.SelectObjectContentOutput - result2 error - } - SelectObjectContentRequestStub func(*s3.SelectObjectContentInput) (*request.Request, *s3.SelectObjectContentOutput) - selectObjectContentRequestMutex sync.RWMutex - selectObjectContentRequestArgsForCall []struct { - arg1 *s3.SelectObjectContentInput - } - selectObjectContentRequestReturns struct { - result1 *request.Request - result2 *s3.SelectObjectContentOutput - } - selectObjectContentRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.SelectObjectContentOutput - } - SelectObjectContentWithContextStub func(context.Context, *s3.SelectObjectContentInput, ...request.Option) (*s3.SelectObjectContentOutput, error) - selectObjectContentWithContextMutex sync.RWMutex - selectObjectContentWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.SelectObjectContentInput - arg3 []request.Option - } - selectObjectContentWithContextReturns struct { - result1 *s3.SelectObjectContentOutput - result2 error - } - selectObjectContentWithContextReturnsOnCall map[int]struct { - result1 *s3.SelectObjectContentOutput - result2 error - } - UploadPartStub func(*s3.UploadPartInput) (*s3.UploadPartOutput, error) - uploadPartMutex sync.RWMutex - uploadPartArgsForCall []struct { - arg1 *s3.UploadPartInput - } - uploadPartReturns struct { - result1 *s3.UploadPartOutput - result2 error - } - uploadPartReturnsOnCall map[int]struct { - result1 *s3.UploadPartOutput - result2 error - } - UploadPartCopyStub func(*s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error) - uploadPartCopyMutex sync.RWMutex - uploadPartCopyArgsForCall []struct { - arg1 *s3.UploadPartCopyInput - } - uploadPartCopyReturns struct { - result1 *s3.UploadPartCopyOutput - result2 error - } - uploadPartCopyReturnsOnCall map[int]struct { - result1 *s3.UploadPartCopyOutput - result2 error - } - UploadPartCopyRequestStub func(*s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput) - uploadPartCopyRequestMutex sync.RWMutex - uploadPartCopyRequestArgsForCall []struct { - arg1 *s3.UploadPartCopyInput - } - uploadPartCopyRequestReturns struct { - result1 *request.Request - result2 *s3.UploadPartCopyOutput - } - uploadPartCopyRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.UploadPartCopyOutput - } - UploadPartCopyWithContextStub func(context.Context, *s3.UploadPartCopyInput, ...request.Option) (*s3.UploadPartCopyOutput, error) - uploadPartCopyWithContextMutex sync.RWMutex - uploadPartCopyWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.UploadPartCopyInput - arg3 []request.Option - } - uploadPartCopyWithContextReturns struct { - result1 *s3.UploadPartCopyOutput - result2 error - } - uploadPartCopyWithContextReturnsOnCall map[int]struct { - result1 *s3.UploadPartCopyOutput - result2 error - } - UploadPartRequestStub func(*s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput) - uploadPartRequestMutex sync.RWMutex - uploadPartRequestArgsForCall []struct { - arg1 *s3.UploadPartInput - } - uploadPartRequestReturns struct { - result1 *request.Request - result2 *s3.UploadPartOutput - } - uploadPartRequestReturnsOnCall map[int]struct { - result1 *request.Request - result2 *s3.UploadPartOutput - } - UploadPartWithContextStub func(context.Context, *s3.UploadPartInput, ...request.Option) (*s3.UploadPartOutput, error) - uploadPartWithContextMutex sync.RWMutex - uploadPartWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.UploadPartInput - arg3 []request.Option - } - uploadPartWithContextReturns struct { - result1 *s3.UploadPartOutput - result2 error - } - uploadPartWithContextReturnsOnCall map[int]struct { - result1 *s3.UploadPartOutput - result2 error - } - WaitUntilBucketExistsStub func(*s3.HeadBucketInput) error - waitUntilBucketExistsMutex sync.RWMutex - waitUntilBucketExistsArgsForCall []struct { - arg1 *s3.HeadBucketInput - } - waitUntilBucketExistsReturns struct { - result1 error - } - waitUntilBucketExistsReturnsOnCall map[int]struct { - result1 error - } - WaitUntilBucketExistsWithContextStub func(context.Context, *s3.HeadBucketInput, ...request.WaiterOption) error - waitUntilBucketExistsWithContextMutex sync.RWMutex - waitUntilBucketExistsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.HeadBucketInput - arg3 []request.WaiterOption - } - waitUntilBucketExistsWithContextReturns struct { - result1 error - } - waitUntilBucketExistsWithContextReturnsOnCall map[int]struct { - result1 error - } - WaitUntilBucketNotExistsStub func(*s3.HeadBucketInput) error - waitUntilBucketNotExistsMutex sync.RWMutex - waitUntilBucketNotExistsArgsForCall []struct { - arg1 *s3.HeadBucketInput - } - waitUntilBucketNotExistsReturns struct { - result1 error - } - waitUntilBucketNotExistsReturnsOnCall map[int]struct { - result1 error - } - WaitUntilBucketNotExistsWithContextStub func(context.Context, *s3.HeadBucketInput, ...request.WaiterOption) error - waitUntilBucketNotExistsWithContextMutex sync.RWMutex - waitUntilBucketNotExistsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.HeadBucketInput - arg3 []request.WaiterOption - } - waitUntilBucketNotExistsWithContextReturns struct { - result1 error - } - waitUntilBucketNotExistsWithContextReturnsOnCall map[int]struct { - result1 error - } - WaitUntilObjectExistsStub func(*s3.HeadObjectInput) error - waitUntilObjectExistsMutex sync.RWMutex - waitUntilObjectExistsArgsForCall []struct { - arg1 *s3.HeadObjectInput - } - waitUntilObjectExistsReturns struct { - result1 error - } - waitUntilObjectExistsReturnsOnCall map[int]struct { - result1 error - } - WaitUntilObjectExistsWithContextStub func(context.Context, *s3.HeadObjectInput, ...request.WaiterOption) error - waitUntilObjectExistsWithContextMutex sync.RWMutex - waitUntilObjectExistsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.HeadObjectInput - arg3 []request.WaiterOption - } - waitUntilObjectExistsWithContextReturns struct { - result1 error - } - waitUntilObjectExistsWithContextReturnsOnCall map[int]struct { - result1 error - } - WaitUntilObjectNotExistsStub func(*s3.HeadObjectInput) error - waitUntilObjectNotExistsMutex sync.RWMutex - waitUntilObjectNotExistsArgsForCall []struct { - arg1 *s3.HeadObjectInput - } - waitUntilObjectNotExistsReturns struct { - result1 error - } - waitUntilObjectNotExistsReturnsOnCall map[int]struct { - result1 error - } - WaitUntilObjectNotExistsWithContextStub func(context.Context, *s3.HeadObjectInput, ...request.WaiterOption) error - waitUntilObjectNotExistsWithContextMutex sync.RWMutex - waitUntilObjectNotExistsWithContextArgsForCall []struct { - arg1 context.Context - arg2 *s3.HeadObjectInput - arg3 []request.WaiterOption - } - waitUntilObjectNotExistsWithContextReturns struct { - result1 error - } - waitUntilObjectNotExistsWithContextReturnsOnCall map[int]struct { - result1 error - } - invocations map[string][][]interface{} - invocationsMutex sync.RWMutex -} - -func (fake *FakeS3Client) AbortMultipartUpload(arg1 *s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error) { - fake.abortMultipartUploadMutex.Lock() - ret, specificReturn := fake.abortMultipartUploadReturnsOnCall[len(fake.abortMultipartUploadArgsForCall)] - fake.abortMultipartUploadArgsForCall = append(fake.abortMultipartUploadArgsForCall, struct { - arg1 *s3.AbortMultipartUploadInput - }{arg1}) - stub := fake.AbortMultipartUploadStub - fakeReturns := fake.abortMultipartUploadReturns - fake.recordInvocation("AbortMultipartUpload", []interface{}{arg1}) - fake.abortMultipartUploadMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) AbortMultipartUploadCallCount() int { - fake.abortMultipartUploadMutex.RLock() - defer fake.abortMultipartUploadMutex.RUnlock() - return len(fake.abortMultipartUploadArgsForCall) -} - -func (fake *FakeS3Client) AbortMultipartUploadCalls(stub func(*s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error)) { - fake.abortMultipartUploadMutex.Lock() - defer fake.abortMultipartUploadMutex.Unlock() - fake.AbortMultipartUploadStub = stub -} - -func (fake *FakeS3Client) AbortMultipartUploadArgsForCall(i int) *s3.AbortMultipartUploadInput { - fake.abortMultipartUploadMutex.RLock() - defer fake.abortMultipartUploadMutex.RUnlock() - argsForCall := fake.abortMultipartUploadArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) AbortMultipartUploadReturns(result1 *s3.AbortMultipartUploadOutput, result2 error) { - fake.abortMultipartUploadMutex.Lock() - defer fake.abortMultipartUploadMutex.Unlock() - fake.AbortMultipartUploadStub = nil - fake.abortMultipartUploadReturns = struct { - result1 *s3.AbortMultipartUploadOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) AbortMultipartUploadReturnsOnCall(i int, result1 *s3.AbortMultipartUploadOutput, result2 error) { - fake.abortMultipartUploadMutex.Lock() - defer fake.abortMultipartUploadMutex.Unlock() - fake.AbortMultipartUploadStub = nil - if fake.abortMultipartUploadReturnsOnCall == nil { - fake.abortMultipartUploadReturnsOnCall = make(map[int]struct { - result1 *s3.AbortMultipartUploadOutput - result2 error - }) - } - fake.abortMultipartUploadReturnsOnCall[i] = struct { - result1 *s3.AbortMultipartUploadOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) AbortMultipartUploadRequest(arg1 *s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput) { - fake.abortMultipartUploadRequestMutex.Lock() - ret, specificReturn := fake.abortMultipartUploadRequestReturnsOnCall[len(fake.abortMultipartUploadRequestArgsForCall)] - fake.abortMultipartUploadRequestArgsForCall = append(fake.abortMultipartUploadRequestArgsForCall, struct { - arg1 *s3.AbortMultipartUploadInput - }{arg1}) - stub := fake.AbortMultipartUploadRequestStub - fakeReturns := fake.abortMultipartUploadRequestReturns - fake.recordInvocation("AbortMultipartUploadRequest", []interface{}{arg1}) - fake.abortMultipartUploadRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) AbortMultipartUploadRequestCallCount() int { - fake.abortMultipartUploadRequestMutex.RLock() - defer fake.abortMultipartUploadRequestMutex.RUnlock() - return len(fake.abortMultipartUploadRequestArgsForCall) -} - -func (fake *FakeS3Client) AbortMultipartUploadRequestCalls(stub func(*s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput)) { - fake.abortMultipartUploadRequestMutex.Lock() - defer fake.abortMultipartUploadRequestMutex.Unlock() - fake.AbortMultipartUploadRequestStub = stub -} - -func (fake *FakeS3Client) AbortMultipartUploadRequestArgsForCall(i int) *s3.AbortMultipartUploadInput { - fake.abortMultipartUploadRequestMutex.RLock() - defer fake.abortMultipartUploadRequestMutex.RUnlock() - argsForCall := fake.abortMultipartUploadRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) AbortMultipartUploadRequestReturns(result1 *request.Request, result2 *s3.AbortMultipartUploadOutput) { - fake.abortMultipartUploadRequestMutex.Lock() - defer fake.abortMultipartUploadRequestMutex.Unlock() - fake.AbortMultipartUploadRequestStub = nil - fake.abortMultipartUploadRequestReturns = struct { - result1 *request.Request - result2 *s3.AbortMultipartUploadOutput - }{result1, result2} -} - -func (fake *FakeS3Client) AbortMultipartUploadRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.AbortMultipartUploadOutput) { - fake.abortMultipartUploadRequestMutex.Lock() - defer fake.abortMultipartUploadRequestMutex.Unlock() - fake.AbortMultipartUploadRequestStub = nil - if fake.abortMultipartUploadRequestReturnsOnCall == nil { - fake.abortMultipartUploadRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.AbortMultipartUploadOutput - }) - } - fake.abortMultipartUploadRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.AbortMultipartUploadOutput - }{result1, result2} -} - -func (fake *FakeS3Client) AbortMultipartUploadWithContext(arg1 context.Context, arg2 *s3.AbortMultipartUploadInput, arg3 ...request.Option) (*s3.AbortMultipartUploadOutput, error) { - fake.abortMultipartUploadWithContextMutex.Lock() - ret, specificReturn := fake.abortMultipartUploadWithContextReturnsOnCall[len(fake.abortMultipartUploadWithContextArgsForCall)] - fake.abortMultipartUploadWithContextArgsForCall = append(fake.abortMultipartUploadWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.AbortMultipartUploadInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.AbortMultipartUploadWithContextStub - fakeReturns := fake.abortMultipartUploadWithContextReturns - fake.recordInvocation("AbortMultipartUploadWithContext", []interface{}{arg1, arg2, arg3}) - fake.abortMultipartUploadWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) AbortMultipartUploadWithContextCallCount() int { - fake.abortMultipartUploadWithContextMutex.RLock() - defer fake.abortMultipartUploadWithContextMutex.RUnlock() - return len(fake.abortMultipartUploadWithContextArgsForCall) -} - -func (fake *FakeS3Client) AbortMultipartUploadWithContextCalls(stub func(context.Context, *s3.AbortMultipartUploadInput, ...request.Option) (*s3.AbortMultipartUploadOutput, error)) { - fake.abortMultipartUploadWithContextMutex.Lock() - defer fake.abortMultipartUploadWithContextMutex.Unlock() - fake.AbortMultipartUploadWithContextStub = stub -} - -func (fake *FakeS3Client) AbortMultipartUploadWithContextArgsForCall(i int) (context.Context, *s3.AbortMultipartUploadInput, []request.Option) { - fake.abortMultipartUploadWithContextMutex.RLock() - defer fake.abortMultipartUploadWithContextMutex.RUnlock() - argsForCall := fake.abortMultipartUploadWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) AbortMultipartUploadWithContextReturns(result1 *s3.AbortMultipartUploadOutput, result2 error) { - fake.abortMultipartUploadWithContextMutex.Lock() - defer fake.abortMultipartUploadWithContextMutex.Unlock() - fake.AbortMultipartUploadWithContextStub = nil - fake.abortMultipartUploadWithContextReturns = struct { - result1 *s3.AbortMultipartUploadOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) AbortMultipartUploadWithContextReturnsOnCall(i int, result1 *s3.AbortMultipartUploadOutput, result2 error) { - fake.abortMultipartUploadWithContextMutex.Lock() - defer fake.abortMultipartUploadWithContextMutex.Unlock() - fake.AbortMultipartUploadWithContextStub = nil - if fake.abortMultipartUploadWithContextReturnsOnCall == nil { - fake.abortMultipartUploadWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.AbortMultipartUploadOutput - result2 error - }) - } - fake.abortMultipartUploadWithContextReturnsOnCall[i] = struct { - result1 *s3.AbortMultipartUploadOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CompleteMultipartUpload(arg1 *s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error) { - fake.completeMultipartUploadMutex.Lock() - ret, specificReturn := fake.completeMultipartUploadReturnsOnCall[len(fake.completeMultipartUploadArgsForCall)] - fake.completeMultipartUploadArgsForCall = append(fake.completeMultipartUploadArgsForCall, struct { - arg1 *s3.CompleteMultipartUploadInput - }{arg1}) - stub := fake.CompleteMultipartUploadStub - fakeReturns := fake.completeMultipartUploadReturns - fake.recordInvocation("CompleteMultipartUpload", []interface{}{arg1}) - fake.completeMultipartUploadMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) CompleteMultipartUploadCallCount() int { - fake.completeMultipartUploadMutex.RLock() - defer fake.completeMultipartUploadMutex.RUnlock() - return len(fake.completeMultipartUploadArgsForCall) -} - -func (fake *FakeS3Client) CompleteMultipartUploadCalls(stub func(*s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error)) { - fake.completeMultipartUploadMutex.Lock() - defer fake.completeMultipartUploadMutex.Unlock() - fake.CompleteMultipartUploadStub = stub -} - -func (fake *FakeS3Client) CompleteMultipartUploadArgsForCall(i int) *s3.CompleteMultipartUploadInput { - fake.completeMultipartUploadMutex.RLock() - defer fake.completeMultipartUploadMutex.RUnlock() - argsForCall := fake.completeMultipartUploadArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) CompleteMultipartUploadReturns(result1 *s3.CompleteMultipartUploadOutput, result2 error) { - fake.completeMultipartUploadMutex.Lock() - defer fake.completeMultipartUploadMutex.Unlock() - fake.CompleteMultipartUploadStub = nil - fake.completeMultipartUploadReturns = struct { - result1 *s3.CompleteMultipartUploadOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CompleteMultipartUploadReturnsOnCall(i int, result1 *s3.CompleteMultipartUploadOutput, result2 error) { - fake.completeMultipartUploadMutex.Lock() - defer fake.completeMultipartUploadMutex.Unlock() - fake.CompleteMultipartUploadStub = nil - if fake.completeMultipartUploadReturnsOnCall == nil { - fake.completeMultipartUploadReturnsOnCall = make(map[int]struct { - result1 *s3.CompleteMultipartUploadOutput - result2 error - }) - } - fake.completeMultipartUploadReturnsOnCall[i] = struct { - result1 *s3.CompleteMultipartUploadOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CompleteMultipartUploadRequest(arg1 *s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput) { - fake.completeMultipartUploadRequestMutex.Lock() - ret, specificReturn := fake.completeMultipartUploadRequestReturnsOnCall[len(fake.completeMultipartUploadRequestArgsForCall)] - fake.completeMultipartUploadRequestArgsForCall = append(fake.completeMultipartUploadRequestArgsForCall, struct { - arg1 *s3.CompleteMultipartUploadInput - }{arg1}) - stub := fake.CompleteMultipartUploadRequestStub - fakeReturns := fake.completeMultipartUploadRequestReturns - fake.recordInvocation("CompleteMultipartUploadRequest", []interface{}{arg1}) - fake.completeMultipartUploadRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) CompleteMultipartUploadRequestCallCount() int { - fake.completeMultipartUploadRequestMutex.RLock() - defer fake.completeMultipartUploadRequestMutex.RUnlock() - return len(fake.completeMultipartUploadRequestArgsForCall) -} - -func (fake *FakeS3Client) CompleteMultipartUploadRequestCalls(stub func(*s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput)) { - fake.completeMultipartUploadRequestMutex.Lock() - defer fake.completeMultipartUploadRequestMutex.Unlock() - fake.CompleteMultipartUploadRequestStub = stub -} - -func (fake *FakeS3Client) CompleteMultipartUploadRequestArgsForCall(i int) *s3.CompleteMultipartUploadInput { - fake.completeMultipartUploadRequestMutex.RLock() - defer fake.completeMultipartUploadRequestMutex.RUnlock() - argsForCall := fake.completeMultipartUploadRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) CompleteMultipartUploadRequestReturns(result1 *request.Request, result2 *s3.CompleteMultipartUploadOutput) { - fake.completeMultipartUploadRequestMutex.Lock() - defer fake.completeMultipartUploadRequestMutex.Unlock() - fake.CompleteMultipartUploadRequestStub = nil - fake.completeMultipartUploadRequestReturns = struct { - result1 *request.Request - result2 *s3.CompleteMultipartUploadOutput - }{result1, result2} -} - -func (fake *FakeS3Client) CompleteMultipartUploadRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.CompleteMultipartUploadOutput) { - fake.completeMultipartUploadRequestMutex.Lock() - defer fake.completeMultipartUploadRequestMutex.Unlock() - fake.CompleteMultipartUploadRequestStub = nil - if fake.completeMultipartUploadRequestReturnsOnCall == nil { - fake.completeMultipartUploadRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.CompleteMultipartUploadOutput - }) - } - fake.completeMultipartUploadRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.CompleteMultipartUploadOutput - }{result1, result2} -} - -func (fake *FakeS3Client) CompleteMultipartUploadWithContext(arg1 context.Context, arg2 *s3.CompleteMultipartUploadInput, arg3 ...request.Option) (*s3.CompleteMultipartUploadOutput, error) { - fake.completeMultipartUploadWithContextMutex.Lock() - ret, specificReturn := fake.completeMultipartUploadWithContextReturnsOnCall[len(fake.completeMultipartUploadWithContextArgsForCall)] - fake.completeMultipartUploadWithContextArgsForCall = append(fake.completeMultipartUploadWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.CompleteMultipartUploadInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.CompleteMultipartUploadWithContextStub - fakeReturns := fake.completeMultipartUploadWithContextReturns - fake.recordInvocation("CompleteMultipartUploadWithContext", []interface{}{arg1, arg2, arg3}) - fake.completeMultipartUploadWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) CompleteMultipartUploadWithContextCallCount() int { - fake.completeMultipartUploadWithContextMutex.RLock() - defer fake.completeMultipartUploadWithContextMutex.RUnlock() - return len(fake.completeMultipartUploadWithContextArgsForCall) -} - -func (fake *FakeS3Client) CompleteMultipartUploadWithContextCalls(stub func(context.Context, *s3.CompleteMultipartUploadInput, ...request.Option) (*s3.CompleteMultipartUploadOutput, error)) { - fake.completeMultipartUploadWithContextMutex.Lock() - defer fake.completeMultipartUploadWithContextMutex.Unlock() - fake.CompleteMultipartUploadWithContextStub = stub -} - -func (fake *FakeS3Client) CompleteMultipartUploadWithContextArgsForCall(i int) (context.Context, *s3.CompleteMultipartUploadInput, []request.Option) { - fake.completeMultipartUploadWithContextMutex.RLock() - defer fake.completeMultipartUploadWithContextMutex.RUnlock() - argsForCall := fake.completeMultipartUploadWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) CompleteMultipartUploadWithContextReturns(result1 *s3.CompleteMultipartUploadOutput, result2 error) { - fake.completeMultipartUploadWithContextMutex.Lock() - defer fake.completeMultipartUploadWithContextMutex.Unlock() - fake.CompleteMultipartUploadWithContextStub = nil - fake.completeMultipartUploadWithContextReturns = struct { - result1 *s3.CompleteMultipartUploadOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CompleteMultipartUploadWithContextReturnsOnCall(i int, result1 *s3.CompleteMultipartUploadOutput, result2 error) { - fake.completeMultipartUploadWithContextMutex.Lock() - defer fake.completeMultipartUploadWithContextMutex.Unlock() - fake.CompleteMultipartUploadWithContextStub = nil - if fake.completeMultipartUploadWithContextReturnsOnCall == nil { - fake.completeMultipartUploadWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.CompleteMultipartUploadOutput - result2 error - }) - } - fake.completeMultipartUploadWithContextReturnsOnCall[i] = struct { - result1 *s3.CompleteMultipartUploadOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CopyObject(arg1 *s3.CopyObjectInput) (*s3.CopyObjectOutput, error) { - fake.copyObjectMutex.Lock() - ret, specificReturn := fake.copyObjectReturnsOnCall[len(fake.copyObjectArgsForCall)] - fake.copyObjectArgsForCall = append(fake.copyObjectArgsForCall, struct { - arg1 *s3.CopyObjectInput - }{arg1}) - stub := fake.CopyObjectStub - fakeReturns := fake.copyObjectReturns - fake.recordInvocation("CopyObject", []interface{}{arg1}) - fake.copyObjectMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) CopyObjectCallCount() int { - fake.copyObjectMutex.RLock() - defer fake.copyObjectMutex.RUnlock() - return len(fake.copyObjectArgsForCall) -} - -func (fake *FakeS3Client) CopyObjectCalls(stub func(*s3.CopyObjectInput) (*s3.CopyObjectOutput, error)) { - fake.copyObjectMutex.Lock() - defer fake.copyObjectMutex.Unlock() - fake.CopyObjectStub = stub -} - -func (fake *FakeS3Client) CopyObjectArgsForCall(i int) *s3.CopyObjectInput { - fake.copyObjectMutex.RLock() - defer fake.copyObjectMutex.RUnlock() - argsForCall := fake.copyObjectArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) CopyObjectReturns(result1 *s3.CopyObjectOutput, result2 error) { - fake.copyObjectMutex.Lock() - defer fake.copyObjectMutex.Unlock() - fake.CopyObjectStub = nil - fake.copyObjectReturns = struct { - result1 *s3.CopyObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CopyObjectReturnsOnCall(i int, result1 *s3.CopyObjectOutput, result2 error) { - fake.copyObjectMutex.Lock() - defer fake.copyObjectMutex.Unlock() - fake.CopyObjectStub = nil - if fake.copyObjectReturnsOnCall == nil { - fake.copyObjectReturnsOnCall = make(map[int]struct { - result1 *s3.CopyObjectOutput - result2 error - }) - } - fake.copyObjectReturnsOnCall[i] = struct { - result1 *s3.CopyObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CopyObjectRequest(arg1 *s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput) { - fake.copyObjectRequestMutex.Lock() - ret, specificReturn := fake.copyObjectRequestReturnsOnCall[len(fake.copyObjectRequestArgsForCall)] - fake.copyObjectRequestArgsForCall = append(fake.copyObjectRequestArgsForCall, struct { - arg1 *s3.CopyObjectInput - }{arg1}) - stub := fake.CopyObjectRequestStub - fakeReturns := fake.copyObjectRequestReturns - fake.recordInvocation("CopyObjectRequest", []interface{}{arg1}) - fake.copyObjectRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) CopyObjectRequestCallCount() int { - fake.copyObjectRequestMutex.RLock() - defer fake.copyObjectRequestMutex.RUnlock() - return len(fake.copyObjectRequestArgsForCall) -} - -func (fake *FakeS3Client) CopyObjectRequestCalls(stub func(*s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput)) { - fake.copyObjectRequestMutex.Lock() - defer fake.copyObjectRequestMutex.Unlock() - fake.CopyObjectRequestStub = stub -} - -func (fake *FakeS3Client) CopyObjectRequestArgsForCall(i int) *s3.CopyObjectInput { - fake.copyObjectRequestMutex.RLock() - defer fake.copyObjectRequestMutex.RUnlock() - argsForCall := fake.copyObjectRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) CopyObjectRequestReturns(result1 *request.Request, result2 *s3.CopyObjectOutput) { - fake.copyObjectRequestMutex.Lock() - defer fake.copyObjectRequestMutex.Unlock() - fake.CopyObjectRequestStub = nil - fake.copyObjectRequestReturns = struct { - result1 *request.Request - result2 *s3.CopyObjectOutput - }{result1, result2} -} - -func (fake *FakeS3Client) CopyObjectRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.CopyObjectOutput) { - fake.copyObjectRequestMutex.Lock() - defer fake.copyObjectRequestMutex.Unlock() - fake.CopyObjectRequestStub = nil - if fake.copyObjectRequestReturnsOnCall == nil { - fake.copyObjectRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.CopyObjectOutput - }) - } - fake.copyObjectRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.CopyObjectOutput - }{result1, result2} -} - -func (fake *FakeS3Client) CopyObjectWithContext(arg1 context.Context, arg2 *s3.CopyObjectInput, arg3 ...request.Option) (*s3.CopyObjectOutput, error) { - fake.copyObjectWithContextMutex.Lock() - ret, specificReturn := fake.copyObjectWithContextReturnsOnCall[len(fake.copyObjectWithContextArgsForCall)] - fake.copyObjectWithContextArgsForCall = append(fake.copyObjectWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.CopyObjectInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.CopyObjectWithContextStub - fakeReturns := fake.copyObjectWithContextReturns - fake.recordInvocation("CopyObjectWithContext", []interface{}{arg1, arg2, arg3}) - fake.copyObjectWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) CopyObjectWithContextCallCount() int { - fake.copyObjectWithContextMutex.RLock() - defer fake.copyObjectWithContextMutex.RUnlock() - return len(fake.copyObjectWithContextArgsForCall) -} - -func (fake *FakeS3Client) CopyObjectWithContextCalls(stub func(context.Context, *s3.CopyObjectInput, ...request.Option) (*s3.CopyObjectOutput, error)) { - fake.copyObjectWithContextMutex.Lock() - defer fake.copyObjectWithContextMutex.Unlock() - fake.CopyObjectWithContextStub = stub -} - -func (fake *FakeS3Client) CopyObjectWithContextArgsForCall(i int) (context.Context, *s3.CopyObjectInput, []request.Option) { - fake.copyObjectWithContextMutex.RLock() - defer fake.copyObjectWithContextMutex.RUnlock() - argsForCall := fake.copyObjectWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) CopyObjectWithContextReturns(result1 *s3.CopyObjectOutput, result2 error) { - fake.copyObjectWithContextMutex.Lock() - defer fake.copyObjectWithContextMutex.Unlock() - fake.CopyObjectWithContextStub = nil - fake.copyObjectWithContextReturns = struct { - result1 *s3.CopyObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CopyObjectWithContextReturnsOnCall(i int, result1 *s3.CopyObjectOutput, result2 error) { - fake.copyObjectWithContextMutex.Lock() - defer fake.copyObjectWithContextMutex.Unlock() - fake.CopyObjectWithContextStub = nil - if fake.copyObjectWithContextReturnsOnCall == nil { - fake.copyObjectWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.CopyObjectOutput - result2 error - }) - } - fake.copyObjectWithContextReturnsOnCall[i] = struct { - result1 *s3.CopyObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CreateBucket(arg1 *s3.CreateBucketInput) (*s3.CreateBucketOutput, error) { - fake.createBucketMutex.Lock() - ret, specificReturn := fake.createBucketReturnsOnCall[len(fake.createBucketArgsForCall)] - fake.createBucketArgsForCall = append(fake.createBucketArgsForCall, struct { - arg1 *s3.CreateBucketInput - }{arg1}) - stub := fake.CreateBucketStub - fakeReturns := fake.createBucketReturns - fake.recordInvocation("CreateBucket", []interface{}{arg1}) - fake.createBucketMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) CreateBucketCallCount() int { - fake.createBucketMutex.RLock() - defer fake.createBucketMutex.RUnlock() - return len(fake.createBucketArgsForCall) -} - -func (fake *FakeS3Client) CreateBucketCalls(stub func(*s3.CreateBucketInput) (*s3.CreateBucketOutput, error)) { - fake.createBucketMutex.Lock() - defer fake.createBucketMutex.Unlock() - fake.CreateBucketStub = stub -} - -func (fake *FakeS3Client) CreateBucketArgsForCall(i int) *s3.CreateBucketInput { - fake.createBucketMutex.RLock() - defer fake.createBucketMutex.RUnlock() - argsForCall := fake.createBucketArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) CreateBucketReturns(result1 *s3.CreateBucketOutput, result2 error) { - fake.createBucketMutex.Lock() - defer fake.createBucketMutex.Unlock() - fake.CreateBucketStub = nil - fake.createBucketReturns = struct { - result1 *s3.CreateBucketOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CreateBucketReturnsOnCall(i int, result1 *s3.CreateBucketOutput, result2 error) { - fake.createBucketMutex.Lock() - defer fake.createBucketMutex.Unlock() - fake.CreateBucketStub = nil - if fake.createBucketReturnsOnCall == nil { - fake.createBucketReturnsOnCall = make(map[int]struct { - result1 *s3.CreateBucketOutput - result2 error - }) - } - fake.createBucketReturnsOnCall[i] = struct { - result1 *s3.CreateBucketOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CreateBucketRequest(arg1 *s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput) { - fake.createBucketRequestMutex.Lock() - ret, specificReturn := fake.createBucketRequestReturnsOnCall[len(fake.createBucketRequestArgsForCall)] - fake.createBucketRequestArgsForCall = append(fake.createBucketRequestArgsForCall, struct { - arg1 *s3.CreateBucketInput - }{arg1}) - stub := fake.CreateBucketRequestStub - fakeReturns := fake.createBucketRequestReturns - fake.recordInvocation("CreateBucketRequest", []interface{}{arg1}) - fake.createBucketRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) CreateBucketRequestCallCount() int { - fake.createBucketRequestMutex.RLock() - defer fake.createBucketRequestMutex.RUnlock() - return len(fake.createBucketRequestArgsForCall) -} - -func (fake *FakeS3Client) CreateBucketRequestCalls(stub func(*s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput)) { - fake.createBucketRequestMutex.Lock() - defer fake.createBucketRequestMutex.Unlock() - fake.CreateBucketRequestStub = stub -} - -func (fake *FakeS3Client) CreateBucketRequestArgsForCall(i int) *s3.CreateBucketInput { - fake.createBucketRequestMutex.RLock() - defer fake.createBucketRequestMutex.RUnlock() - argsForCall := fake.createBucketRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) CreateBucketRequestReturns(result1 *request.Request, result2 *s3.CreateBucketOutput) { - fake.createBucketRequestMutex.Lock() - defer fake.createBucketRequestMutex.Unlock() - fake.CreateBucketRequestStub = nil - fake.createBucketRequestReturns = struct { - result1 *request.Request - result2 *s3.CreateBucketOutput - }{result1, result2} -} - -func (fake *FakeS3Client) CreateBucketRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.CreateBucketOutput) { - fake.createBucketRequestMutex.Lock() - defer fake.createBucketRequestMutex.Unlock() - fake.CreateBucketRequestStub = nil - if fake.createBucketRequestReturnsOnCall == nil { - fake.createBucketRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.CreateBucketOutput - }) - } - fake.createBucketRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.CreateBucketOutput - }{result1, result2} -} - -func (fake *FakeS3Client) CreateBucketWithContext(arg1 context.Context, arg2 *s3.CreateBucketInput, arg3 ...request.Option) (*s3.CreateBucketOutput, error) { - fake.createBucketWithContextMutex.Lock() - ret, specificReturn := fake.createBucketWithContextReturnsOnCall[len(fake.createBucketWithContextArgsForCall)] - fake.createBucketWithContextArgsForCall = append(fake.createBucketWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.CreateBucketInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.CreateBucketWithContextStub - fakeReturns := fake.createBucketWithContextReturns - fake.recordInvocation("CreateBucketWithContext", []interface{}{arg1, arg2, arg3}) - fake.createBucketWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) CreateBucketWithContextCallCount() int { - fake.createBucketWithContextMutex.RLock() - defer fake.createBucketWithContextMutex.RUnlock() - return len(fake.createBucketWithContextArgsForCall) -} - -func (fake *FakeS3Client) CreateBucketWithContextCalls(stub func(context.Context, *s3.CreateBucketInput, ...request.Option) (*s3.CreateBucketOutput, error)) { - fake.createBucketWithContextMutex.Lock() - defer fake.createBucketWithContextMutex.Unlock() - fake.CreateBucketWithContextStub = stub -} - -func (fake *FakeS3Client) CreateBucketWithContextArgsForCall(i int) (context.Context, *s3.CreateBucketInput, []request.Option) { - fake.createBucketWithContextMutex.RLock() - defer fake.createBucketWithContextMutex.RUnlock() - argsForCall := fake.createBucketWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) CreateBucketWithContextReturns(result1 *s3.CreateBucketOutput, result2 error) { - fake.createBucketWithContextMutex.Lock() - defer fake.createBucketWithContextMutex.Unlock() - fake.CreateBucketWithContextStub = nil - fake.createBucketWithContextReturns = struct { - result1 *s3.CreateBucketOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CreateBucketWithContextReturnsOnCall(i int, result1 *s3.CreateBucketOutput, result2 error) { - fake.createBucketWithContextMutex.Lock() - defer fake.createBucketWithContextMutex.Unlock() - fake.CreateBucketWithContextStub = nil - if fake.createBucketWithContextReturnsOnCall == nil { - fake.createBucketWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.CreateBucketOutput - result2 error - }) - } - fake.createBucketWithContextReturnsOnCall[i] = struct { - result1 *s3.CreateBucketOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CreateMultipartUpload(arg1 *s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error) { - fake.createMultipartUploadMutex.Lock() - ret, specificReturn := fake.createMultipartUploadReturnsOnCall[len(fake.createMultipartUploadArgsForCall)] - fake.createMultipartUploadArgsForCall = append(fake.createMultipartUploadArgsForCall, struct { - arg1 *s3.CreateMultipartUploadInput - }{arg1}) - stub := fake.CreateMultipartUploadStub - fakeReturns := fake.createMultipartUploadReturns - fake.recordInvocation("CreateMultipartUpload", []interface{}{arg1}) - fake.createMultipartUploadMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) CreateMultipartUploadCallCount() int { - fake.createMultipartUploadMutex.RLock() - defer fake.createMultipartUploadMutex.RUnlock() - return len(fake.createMultipartUploadArgsForCall) -} - -func (fake *FakeS3Client) CreateMultipartUploadCalls(stub func(*s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error)) { - fake.createMultipartUploadMutex.Lock() - defer fake.createMultipartUploadMutex.Unlock() - fake.CreateMultipartUploadStub = stub -} - -func (fake *FakeS3Client) CreateMultipartUploadArgsForCall(i int) *s3.CreateMultipartUploadInput { - fake.createMultipartUploadMutex.RLock() - defer fake.createMultipartUploadMutex.RUnlock() - argsForCall := fake.createMultipartUploadArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) CreateMultipartUploadReturns(result1 *s3.CreateMultipartUploadOutput, result2 error) { - fake.createMultipartUploadMutex.Lock() - defer fake.createMultipartUploadMutex.Unlock() - fake.CreateMultipartUploadStub = nil - fake.createMultipartUploadReturns = struct { - result1 *s3.CreateMultipartUploadOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CreateMultipartUploadReturnsOnCall(i int, result1 *s3.CreateMultipartUploadOutput, result2 error) { - fake.createMultipartUploadMutex.Lock() - defer fake.createMultipartUploadMutex.Unlock() - fake.CreateMultipartUploadStub = nil - if fake.createMultipartUploadReturnsOnCall == nil { - fake.createMultipartUploadReturnsOnCall = make(map[int]struct { - result1 *s3.CreateMultipartUploadOutput - result2 error - }) - } - fake.createMultipartUploadReturnsOnCall[i] = struct { - result1 *s3.CreateMultipartUploadOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CreateMultipartUploadRequest(arg1 *s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput) { - fake.createMultipartUploadRequestMutex.Lock() - ret, specificReturn := fake.createMultipartUploadRequestReturnsOnCall[len(fake.createMultipartUploadRequestArgsForCall)] - fake.createMultipartUploadRequestArgsForCall = append(fake.createMultipartUploadRequestArgsForCall, struct { - arg1 *s3.CreateMultipartUploadInput - }{arg1}) - stub := fake.CreateMultipartUploadRequestStub - fakeReturns := fake.createMultipartUploadRequestReturns - fake.recordInvocation("CreateMultipartUploadRequest", []interface{}{arg1}) - fake.createMultipartUploadRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) CreateMultipartUploadRequestCallCount() int { - fake.createMultipartUploadRequestMutex.RLock() - defer fake.createMultipartUploadRequestMutex.RUnlock() - return len(fake.createMultipartUploadRequestArgsForCall) -} - -func (fake *FakeS3Client) CreateMultipartUploadRequestCalls(stub func(*s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput)) { - fake.createMultipartUploadRequestMutex.Lock() - defer fake.createMultipartUploadRequestMutex.Unlock() - fake.CreateMultipartUploadRequestStub = stub -} - -func (fake *FakeS3Client) CreateMultipartUploadRequestArgsForCall(i int) *s3.CreateMultipartUploadInput { - fake.createMultipartUploadRequestMutex.RLock() - defer fake.createMultipartUploadRequestMutex.RUnlock() - argsForCall := fake.createMultipartUploadRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) CreateMultipartUploadRequestReturns(result1 *request.Request, result2 *s3.CreateMultipartUploadOutput) { - fake.createMultipartUploadRequestMutex.Lock() - defer fake.createMultipartUploadRequestMutex.Unlock() - fake.CreateMultipartUploadRequestStub = nil - fake.createMultipartUploadRequestReturns = struct { - result1 *request.Request - result2 *s3.CreateMultipartUploadOutput - }{result1, result2} -} - -func (fake *FakeS3Client) CreateMultipartUploadRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.CreateMultipartUploadOutput) { - fake.createMultipartUploadRequestMutex.Lock() - defer fake.createMultipartUploadRequestMutex.Unlock() - fake.CreateMultipartUploadRequestStub = nil - if fake.createMultipartUploadRequestReturnsOnCall == nil { - fake.createMultipartUploadRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.CreateMultipartUploadOutput - }) - } - fake.createMultipartUploadRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.CreateMultipartUploadOutput - }{result1, result2} -} - -func (fake *FakeS3Client) CreateMultipartUploadWithContext(arg1 context.Context, arg2 *s3.CreateMultipartUploadInput, arg3 ...request.Option) (*s3.CreateMultipartUploadOutput, error) { - fake.createMultipartUploadWithContextMutex.Lock() - ret, specificReturn := fake.createMultipartUploadWithContextReturnsOnCall[len(fake.createMultipartUploadWithContextArgsForCall)] - fake.createMultipartUploadWithContextArgsForCall = append(fake.createMultipartUploadWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.CreateMultipartUploadInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.CreateMultipartUploadWithContextStub - fakeReturns := fake.createMultipartUploadWithContextReturns - fake.recordInvocation("CreateMultipartUploadWithContext", []interface{}{arg1, arg2, arg3}) - fake.createMultipartUploadWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) CreateMultipartUploadWithContextCallCount() int { - fake.createMultipartUploadWithContextMutex.RLock() - defer fake.createMultipartUploadWithContextMutex.RUnlock() - return len(fake.createMultipartUploadWithContextArgsForCall) -} - -func (fake *FakeS3Client) CreateMultipartUploadWithContextCalls(stub func(context.Context, *s3.CreateMultipartUploadInput, ...request.Option) (*s3.CreateMultipartUploadOutput, error)) { - fake.createMultipartUploadWithContextMutex.Lock() - defer fake.createMultipartUploadWithContextMutex.Unlock() - fake.CreateMultipartUploadWithContextStub = stub -} - -func (fake *FakeS3Client) CreateMultipartUploadWithContextArgsForCall(i int) (context.Context, *s3.CreateMultipartUploadInput, []request.Option) { - fake.createMultipartUploadWithContextMutex.RLock() - defer fake.createMultipartUploadWithContextMutex.RUnlock() - argsForCall := fake.createMultipartUploadWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) CreateMultipartUploadWithContextReturns(result1 *s3.CreateMultipartUploadOutput, result2 error) { - fake.createMultipartUploadWithContextMutex.Lock() - defer fake.createMultipartUploadWithContextMutex.Unlock() - fake.CreateMultipartUploadWithContextStub = nil - fake.createMultipartUploadWithContextReturns = struct { - result1 *s3.CreateMultipartUploadOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) CreateMultipartUploadWithContextReturnsOnCall(i int, result1 *s3.CreateMultipartUploadOutput, result2 error) { - fake.createMultipartUploadWithContextMutex.Lock() - defer fake.createMultipartUploadWithContextMutex.Unlock() - fake.CreateMultipartUploadWithContextStub = nil - if fake.createMultipartUploadWithContextReturnsOnCall == nil { - fake.createMultipartUploadWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.CreateMultipartUploadOutput - result2 error - }) - } - fake.createMultipartUploadWithContextReturnsOnCall[i] = struct { - result1 *s3.CreateMultipartUploadOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucket(arg1 *s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error) { - fake.deleteBucketMutex.Lock() - ret, specificReturn := fake.deleteBucketReturnsOnCall[len(fake.deleteBucketArgsForCall)] - fake.deleteBucketArgsForCall = append(fake.deleteBucketArgsForCall, struct { - arg1 *s3.DeleteBucketInput - }{arg1}) - stub := fake.DeleteBucketStub - fakeReturns := fake.deleteBucketReturns - fake.recordInvocation("DeleteBucket", []interface{}{arg1}) - fake.deleteBucketMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketCallCount() int { - fake.deleteBucketMutex.RLock() - defer fake.deleteBucketMutex.RUnlock() - return len(fake.deleteBucketArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketCalls(stub func(*s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error)) { - fake.deleteBucketMutex.Lock() - defer fake.deleteBucketMutex.Unlock() - fake.DeleteBucketStub = stub -} - -func (fake *FakeS3Client) DeleteBucketArgsForCall(i int) *s3.DeleteBucketInput { - fake.deleteBucketMutex.RLock() - defer fake.deleteBucketMutex.RUnlock() - argsForCall := fake.deleteBucketArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketReturns(result1 *s3.DeleteBucketOutput, result2 error) { - fake.deleteBucketMutex.Lock() - defer fake.deleteBucketMutex.Unlock() - fake.DeleteBucketStub = nil - fake.deleteBucketReturns = struct { - result1 *s3.DeleteBucketOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketReturnsOnCall(i int, result1 *s3.DeleteBucketOutput, result2 error) { - fake.deleteBucketMutex.Lock() - defer fake.deleteBucketMutex.Unlock() - fake.DeleteBucketStub = nil - if fake.deleteBucketReturnsOnCall == nil { - fake.deleteBucketReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketOutput - result2 error - }) - } - fake.deleteBucketReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfiguration(arg1 *s3.DeleteBucketAnalyticsConfigurationInput) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) { - fake.deleteBucketAnalyticsConfigurationMutex.Lock() - ret, specificReturn := fake.deleteBucketAnalyticsConfigurationReturnsOnCall[len(fake.deleteBucketAnalyticsConfigurationArgsForCall)] - fake.deleteBucketAnalyticsConfigurationArgsForCall = append(fake.deleteBucketAnalyticsConfigurationArgsForCall, struct { - arg1 *s3.DeleteBucketAnalyticsConfigurationInput - }{arg1}) - stub := fake.DeleteBucketAnalyticsConfigurationStub - fakeReturns := fake.deleteBucketAnalyticsConfigurationReturns - fake.recordInvocation("DeleteBucketAnalyticsConfiguration", []interface{}{arg1}) - fake.deleteBucketAnalyticsConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationCallCount() int { - fake.deleteBucketAnalyticsConfigurationMutex.RLock() - defer fake.deleteBucketAnalyticsConfigurationMutex.RUnlock() - return len(fake.deleteBucketAnalyticsConfigurationArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationCalls(stub func(*s3.DeleteBucketAnalyticsConfigurationInput) (*s3.DeleteBucketAnalyticsConfigurationOutput, error)) { - fake.deleteBucketAnalyticsConfigurationMutex.Lock() - defer fake.deleteBucketAnalyticsConfigurationMutex.Unlock() - fake.DeleteBucketAnalyticsConfigurationStub = stub -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationArgsForCall(i int) *s3.DeleteBucketAnalyticsConfigurationInput { - fake.deleteBucketAnalyticsConfigurationMutex.RLock() - defer fake.deleteBucketAnalyticsConfigurationMutex.RUnlock() - argsForCall := fake.deleteBucketAnalyticsConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationReturns(result1 *s3.DeleteBucketAnalyticsConfigurationOutput, result2 error) { - fake.deleteBucketAnalyticsConfigurationMutex.Lock() - defer fake.deleteBucketAnalyticsConfigurationMutex.Unlock() - fake.DeleteBucketAnalyticsConfigurationStub = nil - fake.deleteBucketAnalyticsConfigurationReturns = struct { - result1 *s3.DeleteBucketAnalyticsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationReturnsOnCall(i int, result1 *s3.DeleteBucketAnalyticsConfigurationOutput, result2 error) { - fake.deleteBucketAnalyticsConfigurationMutex.Lock() - defer fake.deleteBucketAnalyticsConfigurationMutex.Unlock() - fake.DeleteBucketAnalyticsConfigurationStub = nil - if fake.deleteBucketAnalyticsConfigurationReturnsOnCall == nil { - fake.deleteBucketAnalyticsConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketAnalyticsConfigurationOutput - result2 error - }) - } - fake.deleteBucketAnalyticsConfigurationReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketAnalyticsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationRequest(arg1 *s3.DeleteBucketAnalyticsConfigurationInput) (*request.Request, *s3.DeleteBucketAnalyticsConfigurationOutput) { - fake.deleteBucketAnalyticsConfigurationRequestMutex.Lock() - ret, specificReturn := fake.deleteBucketAnalyticsConfigurationRequestReturnsOnCall[len(fake.deleteBucketAnalyticsConfigurationRequestArgsForCall)] - fake.deleteBucketAnalyticsConfigurationRequestArgsForCall = append(fake.deleteBucketAnalyticsConfigurationRequestArgsForCall, struct { - arg1 *s3.DeleteBucketAnalyticsConfigurationInput - }{arg1}) - stub := fake.DeleteBucketAnalyticsConfigurationRequestStub - fakeReturns := fake.deleteBucketAnalyticsConfigurationRequestReturns - fake.recordInvocation("DeleteBucketAnalyticsConfigurationRequest", []interface{}{arg1}) - fake.deleteBucketAnalyticsConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationRequestCallCount() int { - fake.deleteBucketAnalyticsConfigurationRequestMutex.RLock() - defer fake.deleteBucketAnalyticsConfigurationRequestMutex.RUnlock() - return len(fake.deleteBucketAnalyticsConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationRequestCalls(stub func(*s3.DeleteBucketAnalyticsConfigurationInput) (*request.Request, *s3.DeleteBucketAnalyticsConfigurationOutput)) { - fake.deleteBucketAnalyticsConfigurationRequestMutex.Lock() - defer fake.deleteBucketAnalyticsConfigurationRequestMutex.Unlock() - fake.DeleteBucketAnalyticsConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationRequestArgsForCall(i int) *s3.DeleteBucketAnalyticsConfigurationInput { - fake.deleteBucketAnalyticsConfigurationRequestMutex.RLock() - defer fake.deleteBucketAnalyticsConfigurationRequestMutex.RUnlock() - argsForCall := fake.deleteBucketAnalyticsConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationRequestReturns(result1 *request.Request, result2 *s3.DeleteBucketAnalyticsConfigurationOutput) { - fake.deleteBucketAnalyticsConfigurationRequestMutex.Lock() - defer fake.deleteBucketAnalyticsConfigurationRequestMutex.Unlock() - fake.DeleteBucketAnalyticsConfigurationRequestStub = nil - fake.deleteBucketAnalyticsConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteBucketAnalyticsConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteBucketAnalyticsConfigurationOutput) { - fake.deleteBucketAnalyticsConfigurationRequestMutex.Lock() - defer fake.deleteBucketAnalyticsConfigurationRequestMutex.Unlock() - fake.DeleteBucketAnalyticsConfigurationRequestStub = nil - if fake.deleteBucketAnalyticsConfigurationRequestReturnsOnCall == nil { - fake.deleteBucketAnalyticsConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketAnalyticsConfigurationOutput - }) - } - fake.deleteBucketAnalyticsConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteBucketAnalyticsConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationWithContext(arg1 context.Context, arg2 *s3.DeleteBucketAnalyticsConfigurationInput, arg3 ...request.Option) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) { - fake.deleteBucketAnalyticsConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.deleteBucketAnalyticsConfigurationWithContextReturnsOnCall[len(fake.deleteBucketAnalyticsConfigurationWithContextArgsForCall)] - fake.deleteBucketAnalyticsConfigurationWithContextArgsForCall = append(fake.deleteBucketAnalyticsConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteBucketAnalyticsConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteBucketAnalyticsConfigurationWithContextStub - fakeReturns := fake.deleteBucketAnalyticsConfigurationWithContextReturns - fake.recordInvocation("DeleteBucketAnalyticsConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteBucketAnalyticsConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationWithContextCallCount() int { - fake.deleteBucketAnalyticsConfigurationWithContextMutex.RLock() - defer fake.deleteBucketAnalyticsConfigurationWithContextMutex.RUnlock() - return len(fake.deleteBucketAnalyticsConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationWithContextCalls(stub func(context.Context, *s3.DeleteBucketAnalyticsConfigurationInput, ...request.Option) (*s3.DeleteBucketAnalyticsConfigurationOutput, error)) { - fake.deleteBucketAnalyticsConfigurationWithContextMutex.Lock() - defer fake.deleteBucketAnalyticsConfigurationWithContextMutex.Unlock() - fake.DeleteBucketAnalyticsConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationWithContextArgsForCall(i int) (context.Context, *s3.DeleteBucketAnalyticsConfigurationInput, []request.Option) { - fake.deleteBucketAnalyticsConfigurationWithContextMutex.RLock() - defer fake.deleteBucketAnalyticsConfigurationWithContextMutex.RUnlock() - argsForCall := fake.deleteBucketAnalyticsConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationWithContextReturns(result1 *s3.DeleteBucketAnalyticsConfigurationOutput, result2 error) { - fake.deleteBucketAnalyticsConfigurationWithContextMutex.Lock() - defer fake.deleteBucketAnalyticsConfigurationWithContextMutex.Unlock() - fake.DeleteBucketAnalyticsConfigurationWithContextStub = nil - fake.deleteBucketAnalyticsConfigurationWithContextReturns = struct { - result1 *s3.DeleteBucketAnalyticsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketAnalyticsConfigurationWithContextReturnsOnCall(i int, result1 *s3.DeleteBucketAnalyticsConfigurationOutput, result2 error) { - fake.deleteBucketAnalyticsConfigurationWithContextMutex.Lock() - defer fake.deleteBucketAnalyticsConfigurationWithContextMutex.Unlock() - fake.DeleteBucketAnalyticsConfigurationWithContextStub = nil - if fake.deleteBucketAnalyticsConfigurationWithContextReturnsOnCall == nil { - fake.deleteBucketAnalyticsConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketAnalyticsConfigurationOutput - result2 error - }) - } - fake.deleteBucketAnalyticsConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketAnalyticsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketCors(arg1 *s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error) { - fake.deleteBucketCorsMutex.Lock() - ret, specificReturn := fake.deleteBucketCorsReturnsOnCall[len(fake.deleteBucketCorsArgsForCall)] - fake.deleteBucketCorsArgsForCall = append(fake.deleteBucketCorsArgsForCall, struct { - arg1 *s3.DeleteBucketCorsInput - }{arg1}) - stub := fake.DeleteBucketCorsStub - fakeReturns := fake.deleteBucketCorsReturns - fake.recordInvocation("DeleteBucketCors", []interface{}{arg1}) - fake.deleteBucketCorsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketCorsCallCount() int { - fake.deleteBucketCorsMutex.RLock() - defer fake.deleteBucketCorsMutex.RUnlock() - return len(fake.deleteBucketCorsArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketCorsCalls(stub func(*s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error)) { - fake.deleteBucketCorsMutex.Lock() - defer fake.deleteBucketCorsMutex.Unlock() - fake.DeleteBucketCorsStub = stub -} - -func (fake *FakeS3Client) DeleteBucketCorsArgsForCall(i int) *s3.DeleteBucketCorsInput { - fake.deleteBucketCorsMutex.RLock() - defer fake.deleteBucketCorsMutex.RUnlock() - argsForCall := fake.deleteBucketCorsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketCorsReturns(result1 *s3.DeleteBucketCorsOutput, result2 error) { - fake.deleteBucketCorsMutex.Lock() - defer fake.deleteBucketCorsMutex.Unlock() - fake.DeleteBucketCorsStub = nil - fake.deleteBucketCorsReturns = struct { - result1 *s3.DeleteBucketCorsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketCorsReturnsOnCall(i int, result1 *s3.DeleteBucketCorsOutput, result2 error) { - fake.deleteBucketCorsMutex.Lock() - defer fake.deleteBucketCorsMutex.Unlock() - fake.DeleteBucketCorsStub = nil - if fake.deleteBucketCorsReturnsOnCall == nil { - fake.deleteBucketCorsReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketCorsOutput - result2 error - }) - } - fake.deleteBucketCorsReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketCorsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketCorsRequest(arg1 *s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput) { - fake.deleteBucketCorsRequestMutex.Lock() - ret, specificReturn := fake.deleteBucketCorsRequestReturnsOnCall[len(fake.deleteBucketCorsRequestArgsForCall)] - fake.deleteBucketCorsRequestArgsForCall = append(fake.deleteBucketCorsRequestArgsForCall, struct { - arg1 *s3.DeleteBucketCorsInput - }{arg1}) - stub := fake.DeleteBucketCorsRequestStub - fakeReturns := fake.deleteBucketCorsRequestReturns - fake.recordInvocation("DeleteBucketCorsRequest", []interface{}{arg1}) - fake.deleteBucketCorsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketCorsRequestCallCount() int { - fake.deleteBucketCorsRequestMutex.RLock() - defer fake.deleteBucketCorsRequestMutex.RUnlock() - return len(fake.deleteBucketCorsRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketCorsRequestCalls(stub func(*s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput)) { - fake.deleteBucketCorsRequestMutex.Lock() - defer fake.deleteBucketCorsRequestMutex.Unlock() - fake.DeleteBucketCorsRequestStub = stub -} - -func (fake *FakeS3Client) DeleteBucketCorsRequestArgsForCall(i int) *s3.DeleteBucketCorsInput { - fake.deleteBucketCorsRequestMutex.RLock() - defer fake.deleteBucketCorsRequestMutex.RUnlock() - argsForCall := fake.deleteBucketCorsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketCorsRequestReturns(result1 *request.Request, result2 *s3.DeleteBucketCorsOutput) { - fake.deleteBucketCorsRequestMutex.Lock() - defer fake.deleteBucketCorsRequestMutex.Unlock() - fake.DeleteBucketCorsRequestStub = nil - fake.deleteBucketCorsRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteBucketCorsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketCorsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteBucketCorsOutput) { - fake.deleteBucketCorsRequestMutex.Lock() - defer fake.deleteBucketCorsRequestMutex.Unlock() - fake.DeleteBucketCorsRequestStub = nil - if fake.deleteBucketCorsRequestReturnsOnCall == nil { - fake.deleteBucketCorsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketCorsOutput - }) - } - fake.deleteBucketCorsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteBucketCorsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketCorsWithContext(arg1 context.Context, arg2 *s3.DeleteBucketCorsInput, arg3 ...request.Option) (*s3.DeleteBucketCorsOutput, error) { - fake.deleteBucketCorsWithContextMutex.Lock() - ret, specificReturn := fake.deleteBucketCorsWithContextReturnsOnCall[len(fake.deleteBucketCorsWithContextArgsForCall)] - fake.deleteBucketCorsWithContextArgsForCall = append(fake.deleteBucketCorsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteBucketCorsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteBucketCorsWithContextStub - fakeReturns := fake.deleteBucketCorsWithContextReturns - fake.recordInvocation("DeleteBucketCorsWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteBucketCorsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketCorsWithContextCallCount() int { - fake.deleteBucketCorsWithContextMutex.RLock() - defer fake.deleteBucketCorsWithContextMutex.RUnlock() - return len(fake.deleteBucketCorsWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketCorsWithContextCalls(stub func(context.Context, *s3.DeleteBucketCorsInput, ...request.Option) (*s3.DeleteBucketCorsOutput, error)) { - fake.deleteBucketCorsWithContextMutex.Lock() - defer fake.deleteBucketCorsWithContextMutex.Unlock() - fake.DeleteBucketCorsWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteBucketCorsWithContextArgsForCall(i int) (context.Context, *s3.DeleteBucketCorsInput, []request.Option) { - fake.deleteBucketCorsWithContextMutex.RLock() - defer fake.deleteBucketCorsWithContextMutex.RUnlock() - argsForCall := fake.deleteBucketCorsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteBucketCorsWithContextReturns(result1 *s3.DeleteBucketCorsOutput, result2 error) { - fake.deleteBucketCorsWithContextMutex.Lock() - defer fake.deleteBucketCorsWithContextMutex.Unlock() - fake.DeleteBucketCorsWithContextStub = nil - fake.deleteBucketCorsWithContextReturns = struct { - result1 *s3.DeleteBucketCorsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketCorsWithContextReturnsOnCall(i int, result1 *s3.DeleteBucketCorsOutput, result2 error) { - fake.deleteBucketCorsWithContextMutex.Lock() - defer fake.deleteBucketCorsWithContextMutex.Unlock() - fake.DeleteBucketCorsWithContextStub = nil - if fake.deleteBucketCorsWithContextReturnsOnCall == nil { - fake.deleteBucketCorsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketCorsOutput - result2 error - }) - } - fake.deleteBucketCorsWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketCorsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketEncryption(arg1 *s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error) { - fake.deleteBucketEncryptionMutex.Lock() - ret, specificReturn := fake.deleteBucketEncryptionReturnsOnCall[len(fake.deleteBucketEncryptionArgsForCall)] - fake.deleteBucketEncryptionArgsForCall = append(fake.deleteBucketEncryptionArgsForCall, struct { - arg1 *s3.DeleteBucketEncryptionInput - }{arg1}) - stub := fake.DeleteBucketEncryptionStub - fakeReturns := fake.deleteBucketEncryptionReturns - fake.recordInvocation("DeleteBucketEncryption", []interface{}{arg1}) - fake.deleteBucketEncryptionMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketEncryptionCallCount() int { - fake.deleteBucketEncryptionMutex.RLock() - defer fake.deleteBucketEncryptionMutex.RUnlock() - return len(fake.deleteBucketEncryptionArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketEncryptionCalls(stub func(*s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error)) { - fake.deleteBucketEncryptionMutex.Lock() - defer fake.deleteBucketEncryptionMutex.Unlock() - fake.DeleteBucketEncryptionStub = stub -} - -func (fake *FakeS3Client) DeleteBucketEncryptionArgsForCall(i int) *s3.DeleteBucketEncryptionInput { - fake.deleteBucketEncryptionMutex.RLock() - defer fake.deleteBucketEncryptionMutex.RUnlock() - argsForCall := fake.deleteBucketEncryptionArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketEncryptionReturns(result1 *s3.DeleteBucketEncryptionOutput, result2 error) { - fake.deleteBucketEncryptionMutex.Lock() - defer fake.deleteBucketEncryptionMutex.Unlock() - fake.DeleteBucketEncryptionStub = nil - fake.deleteBucketEncryptionReturns = struct { - result1 *s3.DeleteBucketEncryptionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketEncryptionReturnsOnCall(i int, result1 *s3.DeleteBucketEncryptionOutput, result2 error) { - fake.deleteBucketEncryptionMutex.Lock() - defer fake.deleteBucketEncryptionMutex.Unlock() - fake.DeleteBucketEncryptionStub = nil - if fake.deleteBucketEncryptionReturnsOnCall == nil { - fake.deleteBucketEncryptionReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketEncryptionOutput - result2 error - }) - } - fake.deleteBucketEncryptionReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketEncryptionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketEncryptionRequest(arg1 *s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput) { - fake.deleteBucketEncryptionRequestMutex.Lock() - ret, specificReturn := fake.deleteBucketEncryptionRequestReturnsOnCall[len(fake.deleteBucketEncryptionRequestArgsForCall)] - fake.deleteBucketEncryptionRequestArgsForCall = append(fake.deleteBucketEncryptionRequestArgsForCall, struct { - arg1 *s3.DeleteBucketEncryptionInput - }{arg1}) - stub := fake.DeleteBucketEncryptionRequestStub - fakeReturns := fake.deleteBucketEncryptionRequestReturns - fake.recordInvocation("DeleteBucketEncryptionRequest", []interface{}{arg1}) - fake.deleteBucketEncryptionRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketEncryptionRequestCallCount() int { - fake.deleteBucketEncryptionRequestMutex.RLock() - defer fake.deleteBucketEncryptionRequestMutex.RUnlock() - return len(fake.deleteBucketEncryptionRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketEncryptionRequestCalls(stub func(*s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput)) { - fake.deleteBucketEncryptionRequestMutex.Lock() - defer fake.deleteBucketEncryptionRequestMutex.Unlock() - fake.DeleteBucketEncryptionRequestStub = stub -} - -func (fake *FakeS3Client) DeleteBucketEncryptionRequestArgsForCall(i int) *s3.DeleteBucketEncryptionInput { - fake.deleteBucketEncryptionRequestMutex.RLock() - defer fake.deleteBucketEncryptionRequestMutex.RUnlock() - argsForCall := fake.deleteBucketEncryptionRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketEncryptionRequestReturns(result1 *request.Request, result2 *s3.DeleteBucketEncryptionOutput) { - fake.deleteBucketEncryptionRequestMutex.Lock() - defer fake.deleteBucketEncryptionRequestMutex.Unlock() - fake.DeleteBucketEncryptionRequestStub = nil - fake.deleteBucketEncryptionRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteBucketEncryptionOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketEncryptionRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteBucketEncryptionOutput) { - fake.deleteBucketEncryptionRequestMutex.Lock() - defer fake.deleteBucketEncryptionRequestMutex.Unlock() - fake.DeleteBucketEncryptionRequestStub = nil - if fake.deleteBucketEncryptionRequestReturnsOnCall == nil { - fake.deleteBucketEncryptionRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketEncryptionOutput - }) - } - fake.deleteBucketEncryptionRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteBucketEncryptionOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketEncryptionWithContext(arg1 context.Context, arg2 *s3.DeleteBucketEncryptionInput, arg3 ...request.Option) (*s3.DeleteBucketEncryptionOutput, error) { - fake.deleteBucketEncryptionWithContextMutex.Lock() - ret, specificReturn := fake.deleteBucketEncryptionWithContextReturnsOnCall[len(fake.deleteBucketEncryptionWithContextArgsForCall)] - fake.deleteBucketEncryptionWithContextArgsForCall = append(fake.deleteBucketEncryptionWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteBucketEncryptionInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteBucketEncryptionWithContextStub - fakeReturns := fake.deleteBucketEncryptionWithContextReturns - fake.recordInvocation("DeleteBucketEncryptionWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteBucketEncryptionWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketEncryptionWithContextCallCount() int { - fake.deleteBucketEncryptionWithContextMutex.RLock() - defer fake.deleteBucketEncryptionWithContextMutex.RUnlock() - return len(fake.deleteBucketEncryptionWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketEncryptionWithContextCalls(stub func(context.Context, *s3.DeleteBucketEncryptionInput, ...request.Option) (*s3.DeleteBucketEncryptionOutput, error)) { - fake.deleteBucketEncryptionWithContextMutex.Lock() - defer fake.deleteBucketEncryptionWithContextMutex.Unlock() - fake.DeleteBucketEncryptionWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteBucketEncryptionWithContextArgsForCall(i int) (context.Context, *s3.DeleteBucketEncryptionInput, []request.Option) { - fake.deleteBucketEncryptionWithContextMutex.RLock() - defer fake.deleteBucketEncryptionWithContextMutex.RUnlock() - argsForCall := fake.deleteBucketEncryptionWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteBucketEncryptionWithContextReturns(result1 *s3.DeleteBucketEncryptionOutput, result2 error) { - fake.deleteBucketEncryptionWithContextMutex.Lock() - defer fake.deleteBucketEncryptionWithContextMutex.Unlock() - fake.DeleteBucketEncryptionWithContextStub = nil - fake.deleteBucketEncryptionWithContextReturns = struct { - result1 *s3.DeleteBucketEncryptionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketEncryptionWithContextReturnsOnCall(i int, result1 *s3.DeleteBucketEncryptionOutput, result2 error) { - fake.deleteBucketEncryptionWithContextMutex.Lock() - defer fake.deleteBucketEncryptionWithContextMutex.Unlock() - fake.DeleteBucketEncryptionWithContextStub = nil - if fake.deleteBucketEncryptionWithContextReturnsOnCall == nil { - fake.deleteBucketEncryptionWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketEncryptionOutput - result2 error - }) - } - fake.deleteBucketEncryptionWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketEncryptionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfiguration(arg1 *s3.DeleteBucketIntelligentTieringConfigurationInput) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error) { - fake.deleteBucketIntelligentTieringConfigurationMutex.Lock() - ret, specificReturn := fake.deleteBucketIntelligentTieringConfigurationReturnsOnCall[len(fake.deleteBucketIntelligentTieringConfigurationArgsForCall)] - fake.deleteBucketIntelligentTieringConfigurationArgsForCall = append(fake.deleteBucketIntelligentTieringConfigurationArgsForCall, struct { - arg1 *s3.DeleteBucketIntelligentTieringConfigurationInput - }{arg1}) - stub := fake.DeleteBucketIntelligentTieringConfigurationStub - fakeReturns := fake.deleteBucketIntelligentTieringConfigurationReturns - fake.recordInvocation("DeleteBucketIntelligentTieringConfiguration", []interface{}{arg1}) - fake.deleteBucketIntelligentTieringConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationCallCount() int { - fake.deleteBucketIntelligentTieringConfigurationMutex.RLock() - defer fake.deleteBucketIntelligentTieringConfigurationMutex.RUnlock() - return len(fake.deleteBucketIntelligentTieringConfigurationArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationCalls(stub func(*s3.DeleteBucketIntelligentTieringConfigurationInput) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error)) { - fake.deleteBucketIntelligentTieringConfigurationMutex.Lock() - defer fake.deleteBucketIntelligentTieringConfigurationMutex.Unlock() - fake.DeleteBucketIntelligentTieringConfigurationStub = stub -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationArgsForCall(i int) *s3.DeleteBucketIntelligentTieringConfigurationInput { - fake.deleteBucketIntelligentTieringConfigurationMutex.RLock() - defer fake.deleteBucketIntelligentTieringConfigurationMutex.RUnlock() - argsForCall := fake.deleteBucketIntelligentTieringConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationReturns(result1 *s3.DeleteBucketIntelligentTieringConfigurationOutput, result2 error) { - fake.deleteBucketIntelligentTieringConfigurationMutex.Lock() - defer fake.deleteBucketIntelligentTieringConfigurationMutex.Unlock() - fake.DeleteBucketIntelligentTieringConfigurationStub = nil - fake.deleteBucketIntelligentTieringConfigurationReturns = struct { - result1 *s3.DeleteBucketIntelligentTieringConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationReturnsOnCall(i int, result1 *s3.DeleteBucketIntelligentTieringConfigurationOutput, result2 error) { - fake.deleteBucketIntelligentTieringConfigurationMutex.Lock() - defer fake.deleteBucketIntelligentTieringConfigurationMutex.Unlock() - fake.DeleteBucketIntelligentTieringConfigurationStub = nil - if fake.deleteBucketIntelligentTieringConfigurationReturnsOnCall == nil { - fake.deleteBucketIntelligentTieringConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketIntelligentTieringConfigurationOutput - result2 error - }) - } - fake.deleteBucketIntelligentTieringConfigurationReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketIntelligentTieringConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationRequest(arg1 *s3.DeleteBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.DeleteBucketIntelligentTieringConfigurationOutput) { - fake.deleteBucketIntelligentTieringConfigurationRequestMutex.Lock() - ret, specificReturn := fake.deleteBucketIntelligentTieringConfigurationRequestReturnsOnCall[len(fake.deleteBucketIntelligentTieringConfigurationRequestArgsForCall)] - fake.deleteBucketIntelligentTieringConfigurationRequestArgsForCall = append(fake.deleteBucketIntelligentTieringConfigurationRequestArgsForCall, struct { - arg1 *s3.DeleteBucketIntelligentTieringConfigurationInput - }{arg1}) - stub := fake.DeleteBucketIntelligentTieringConfigurationRequestStub - fakeReturns := fake.deleteBucketIntelligentTieringConfigurationRequestReturns - fake.recordInvocation("DeleteBucketIntelligentTieringConfigurationRequest", []interface{}{arg1}) - fake.deleteBucketIntelligentTieringConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationRequestCallCount() int { - fake.deleteBucketIntelligentTieringConfigurationRequestMutex.RLock() - defer fake.deleteBucketIntelligentTieringConfigurationRequestMutex.RUnlock() - return len(fake.deleteBucketIntelligentTieringConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationRequestCalls(stub func(*s3.DeleteBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.DeleteBucketIntelligentTieringConfigurationOutput)) { - fake.deleteBucketIntelligentTieringConfigurationRequestMutex.Lock() - defer fake.deleteBucketIntelligentTieringConfigurationRequestMutex.Unlock() - fake.DeleteBucketIntelligentTieringConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationRequestArgsForCall(i int) *s3.DeleteBucketIntelligentTieringConfigurationInput { - fake.deleteBucketIntelligentTieringConfigurationRequestMutex.RLock() - defer fake.deleteBucketIntelligentTieringConfigurationRequestMutex.RUnlock() - argsForCall := fake.deleteBucketIntelligentTieringConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationRequestReturns(result1 *request.Request, result2 *s3.DeleteBucketIntelligentTieringConfigurationOutput) { - fake.deleteBucketIntelligentTieringConfigurationRequestMutex.Lock() - defer fake.deleteBucketIntelligentTieringConfigurationRequestMutex.Unlock() - fake.DeleteBucketIntelligentTieringConfigurationRequestStub = nil - fake.deleteBucketIntelligentTieringConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteBucketIntelligentTieringConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteBucketIntelligentTieringConfigurationOutput) { - fake.deleteBucketIntelligentTieringConfigurationRequestMutex.Lock() - defer fake.deleteBucketIntelligentTieringConfigurationRequestMutex.Unlock() - fake.DeleteBucketIntelligentTieringConfigurationRequestStub = nil - if fake.deleteBucketIntelligentTieringConfigurationRequestReturnsOnCall == nil { - fake.deleteBucketIntelligentTieringConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketIntelligentTieringConfigurationOutput - }) - } - fake.deleteBucketIntelligentTieringConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteBucketIntelligentTieringConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationWithContext(arg1 context.Context, arg2 *s3.DeleteBucketIntelligentTieringConfigurationInput, arg3 ...request.Option) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error) { - fake.deleteBucketIntelligentTieringConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.deleteBucketIntelligentTieringConfigurationWithContextReturnsOnCall[len(fake.deleteBucketIntelligentTieringConfigurationWithContextArgsForCall)] - fake.deleteBucketIntelligentTieringConfigurationWithContextArgsForCall = append(fake.deleteBucketIntelligentTieringConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteBucketIntelligentTieringConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteBucketIntelligentTieringConfigurationWithContextStub - fakeReturns := fake.deleteBucketIntelligentTieringConfigurationWithContextReturns - fake.recordInvocation("DeleteBucketIntelligentTieringConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteBucketIntelligentTieringConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationWithContextCallCount() int { - fake.deleteBucketIntelligentTieringConfigurationWithContextMutex.RLock() - defer fake.deleteBucketIntelligentTieringConfigurationWithContextMutex.RUnlock() - return len(fake.deleteBucketIntelligentTieringConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationWithContextCalls(stub func(context.Context, *s3.DeleteBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error)) { - fake.deleteBucketIntelligentTieringConfigurationWithContextMutex.Lock() - defer fake.deleteBucketIntelligentTieringConfigurationWithContextMutex.Unlock() - fake.DeleteBucketIntelligentTieringConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationWithContextArgsForCall(i int) (context.Context, *s3.DeleteBucketIntelligentTieringConfigurationInput, []request.Option) { - fake.deleteBucketIntelligentTieringConfigurationWithContextMutex.RLock() - defer fake.deleteBucketIntelligentTieringConfigurationWithContextMutex.RUnlock() - argsForCall := fake.deleteBucketIntelligentTieringConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationWithContextReturns(result1 *s3.DeleteBucketIntelligentTieringConfigurationOutput, result2 error) { - fake.deleteBucketIntelligentTieringConfigurationWithContextMutex.Lock() - defer fake.deleteBucketIntelligentTieringConfigurationWithContextMutex.Unlock() - fake.DeleteBucketIntelligentTieringConfigurationWithContextStub = nil - fake.deleteBucketIntelligentTieringConfigurationWithContextReturns = struct { - result1 *s3.DeleteBucketIntelligentTieringConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketIntelligentTieringConfigurationWithContextReturnsOnCall(i int, result1 *s3.DeleteBucketIntelligentTieringConfigurationOutput, result2 error) { - fake.deleteBucketIntelligentTieringConfigurationWithContextMutex.Lock() - defer fake.deleteBucketIntelligentTieringConfigurationWithContextMutex.Unlock() - fake.DeleteBucketIntelligentTieringConfigurationWithContextStub = nil - if fake.deleteBucketIntelligentTieringConfigurationWithContextReturnsOnCall == nil { - fake.deleteBucketIntelligentTieringConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketIntelligentTieringConfigurationOutput - result2 error - }) - } - fake.deleteBucketIntelligentTieringConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketIntelligentTieringConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfiguration(arg1 *s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error) { - fake.deleteBucketInventoryConfigurationMutex.Lock() - ret, specificReturn := fake.deleteBucketInventoryConfigurationReturnsOnCall[len(fake.deleteBucketInventoryConfigurationArgsForCall)] - fake.deleteBucketInventoryConfigurationArgsForCall = append(fake.deleteBucketInventoryConfigurationArgsForCall, struct { - arg1 *s3.DeleteBucketInventoryConfigurationInput - }{arg1}) - stub := fake.DeleteBucketInventoryConfigurationStub - fakeReturns := fake.deleteBucketInventoryConfigurationReturns - fake.recordInvocation("DeleteBucketInventoryConfiguration", []interface{}{arg1}) - fake.deleteBucketInventoryConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationCallCount() int { - fake.deleteBucketInventoryConfigurationMutex.RLock() - defer fake.deleteBucketInventoryConfigurationMutex.RUnlock() - return len(fake.deleteBucketInventoryConfigurationArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationCalls(stub func(*s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error)) { - fake.deleteBucketInventoryConfigurationMutex.Lock() - defer fake.deleteBucketInventoryConfigurationMutex.Unlock() - fake.DeleteBucketInventoryConfigurationStub = stub -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationArgsForCall(i int) *s3.DeleteBucketInventoryConfigurationInput { - fake.deleteBucketInventoryConfigurationMutex.RLock() - defer fake.deleteBucketInventoryConfigurationMutex.RUnlock() - argsForCall := fake.deleteBucketInventoryConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationReturns(result1 *s3.DeleteBucketInventoryConfigurationOutput, result2 error) { - fake.deleteBucketInventoryConfigurationMutex.Lock() - defer fake.deleteBucketInventoryConfigurationMutex.Unlock() - fake.DeleteBucketInventoryConfigurationStub = nil - fake.deleteBucketInventoryConfigurationReturns = struct { - result1 *s3.DeleteBucketInventoryConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationReturnsOnCall(i int, result1 *s3.DeleteBucketInventoryConfigurationOutput, result2 error) { - fake.deleteBucketInventoryConfigurationMutex.Lock() - defer fake.deleteBucketInventoryConfigurationMutex.Unlock() - fake.DeleteBucketInventoryConfigurationStub = nil - if fake.deleteBucketInventoryConfigurationReturnsOnCall == nil { - fake.deleteBucketInventoryConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketInventoryConfigurationOutput - result2 error - }) - } - fake.deleteBucketInventoryConfigurationReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketInventoryConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationRequest(arg1 *s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput) { - fake.deleteBucketInventoryConfigurationRequestMutex.Lock() - ret, specificReturn := fake.deleteBucketInventoryConfigurationRequestReturnsOnCall[len(fake.deleteBucketInventoryConfigurationRequestArgsForCall)] - fake.deleteBucketInventoryConfigurationRequestArgsForCall = append(fake.deleteBucketInventoryConfigurationRequestArgsForCall, struct { - arg1 *s3.DeleteBucketInventoryConfigurationInput - }{arg1}) - stub := fake.DeleteBucketInventoryConfigurationRequestStub - fakeReturns := fake.deleteBucketInventoryConfigurationRequestReturns - fake.recordInvocation("DeleteBucketInventoryConfigurationRequest", []interface{}{arg1}) - fake.deleteBucketInventoryConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationRequestCallCount() int { - fake.deleteBucketInventoryConfigurationRequestMutex.RLock() - defer fake.deleteBucketInventoryConfigurationRequestMutex.RUnlock() - return len(fake.deleteBucketInventoryConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationRequestCalls(stub func(*s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput)) { - fake.deleteBucketInventoryConfigurationRequestMutex.Lock() - defer fake.deleteBucketInventoryConfigurationRequestMutex.Unlock() - fake.DeleteBucketInventoryConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationRequestArgsForCall(i int) *s3.DeleteBucketInventoryConfigurationInput { - fake.deleteBucketInventoryConfigurationRequestMutex.RLock() - defer fake.deleteBucketInventoryConfigurationRequestMutex.RUnlock() - argsForCall := fake.deleteBucketInventoryConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationRequestReturns(result1 *request.Request, result2 *s3.DeleteBucketInventoryConfigurationOutput) { - fake.deleteBucketInventoryConfigurationRequestMutex.Lock() - defer fake.deleteBucketInventoryConfigurationRequestMutex.Unlock() - fake.DeleteBucketInventoryConfigurationRequestStub = nil - fake.deleteBucketInventoryConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteBucketInventoryConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteBucketInventoryConfigurationOutput) { - fake.deleteBucketInventoryConfigurationRequestMutex.Lock() - defer fake.deleteBucketInventoryConfigurationRequestMutex.Unlock() - fake.DeleteBucketInventoryConfigurationRequestStub = nil - if fake.deleteBucketInventoryConfigurationRequestReturnsOnCall == nil { - fake.deleteBucketInventoryConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketInventoryConfigurationOutput - }) - } - fake.deleteBucketInventoryConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteBucketInventoryConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationWithContext(arg1 context.Context, arg2 *s3.DeleteBucketInventoryConfigurationInput, arg3 ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error) { - fake.deleteBucketInventoryConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.deleteBucketInventoryConfigurationWithContextReturnsOnCall[len(fake.deleteBucketInventoryConfigurationWithContextArgsForCall)] - fake.deleteBucketInventoryConfigurationWithContextArgsForCall = append(fake.deleteBucketInventoryConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteBucketInventoryConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteBucketInventoryConfigurationWithContextStub - fakeReturns := fake.deleteBucketInventoryConfigurationWithContextReturns - fake.recordInvocation("DeleteBucketInventoryConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteBucketInventoryConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationWithContextCallCount() int { - fake.deleteBucketInventoryConfigurationWithContextMutex.RLock() - defer fake.deleteBucketInventoryConfigurationWithContextMutex.RUnlock() - return len(fake.deleteBucketInventoryConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationWithContextCalls(stub func(context.Context, *s3.DeleteBucketInventoryConfigurationInput, ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error)) { - fake.deleteBucketInventoryConfigurationWithContextMutex.Lock() - defer fake.deleteBucketInventoryConfigurationWithContextMutex.Unlock() - fake.DeleteBucketInventoryConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationWithContextArgsForCall(i int) (context.Context, *s3.DeleteBucketInventoryConfigurationInput, []request.Option) { - fake.deleteBucketInventoryConfigurationWithContextMutex.RLock() - defer fake.deleteBucketInventoryConfigurationWithContextMutex.RUnlock() - argsForCall := fake.deleteBucketInventoryConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationWithContextReturns(result1 *s3.DeleteBucketInventoryConfigurationOutput, result2 error) { - fake.deleteBucketInventoryConfigurationWithContextMutex.Lock() - defer fake.deleteBucketInventoryConfigurationWithContextMutex.Unlock() - fake.DeleteBucketInventoryConfigurationWithContextStub = nil - fake.deleteBucketInventoryConfigurationWithContextReturns = struct { - result1 *s3.DeleteBucketInventoryConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketInventoryConfigurationWithContextReturnsOnCall(i int, result1 *s3.DeleteBucketInventoryConfigurationOutput, result2 error) { - fake.deleteBucketInventoryConfigurationWithContextMutex.Lock() - defer fake.deleteBucketInventoryConfigurationWithContextMutex.Unlock() - fake.DeleteBucketInventoryConfigurationWithContextStub = nil - if fake.deleteBucketInventoryConfigurationWithContextReturnsOnCall == nil { - fake.deleteBucketInventoryConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketInventoryConfigurationOutput - result2 error - }) - } - fake.deleteBucketInventoryConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketInventoryConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketLifecycle(arg1 *s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error) { - fake.deleteBucketLifecycleMutex.Lock() - ret, specificReturn := fake.deleteBucketLifecycleReturnsOnCall[len(fake.deleteBucketLifecycleArgsForCall)] - fake.deleteBucketLifecycleArgsForCall = append(fake.deleteBucketLifecycleArgsForCall, struct { - arg1 *s3.DeleteBucketLifecycleInput - }{arg1}) - stub := fake.DeleteBucketLifecycleStub - fakeReturns := fake.deleteBucketLifecycleReturns - fake.recordInvocation("DeleteBucketLifecycle", []interface{}{arg1}) - fake.deleteBucketLifecycleMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketLifecycleCallCount() int { - fake.deleteBucketLifecycleMutex.RLock() - defer fake.deleteBucketLifecycleMutex.RUnlock() - return len(fake.deleteBucketLifecycleArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketLifecycleCalls(stub func(*s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error)) { - fake.deleteBucketLifecycleMutex.Lock() - defer fake.deleteBucketLifecycleMutex.Unlock() - fake.DeleteBucketLifecycleStub = stub -} - -func (fake *FakeS3Client) DeleteBucketLifecycleArgsForCall(i int) *s3.DeleteBucketLifecycleInput { - fake.deleteBucketLifecycleMutex.RLock() - defer fake.deleteBucketLifecycleMutex.RUnlock() - argsForCall := fake.deleteBucketLifecycleArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketLifecycleReturns(result1 *s3.DeleteBucketLifecycleOutput, result2 error) { - fake.deleteBucketLifecycleMutex.Lock() - defer fake.deleteBucketLifecycleMutex.Unlock() - fake.DeleteBucketLifecycleStub = nil - fake.deleteBucketLifecycleReturns = struct { - result1 *s3.DeleteBucketLifecycleOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketLifecycleReturnsOnCall(i int, result1 *s3.DeleteBucketLifecycleOutput, result2 error) { - fake.deleteBucketLifecycleMutex.Lock() - defer fake.deleteBucketLifecycleMutex.Unlock() - fake.DeleteBucketLifecycleStub = nil - if fake.deleteBucketLifecycleReturnsOnCall == nil { - fake.deleteBucketLifecycleReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketLifecycleOutput - result2 error - }) - } - fake.deleteBucketLifecycleReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketLifecycleOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketLifecycleRequest(arg1 *s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput) { - fake.deleteBucketLifecycleRequestMutex.Lock() - ret, specificReturn := fake.deleteBucketLifecycleRequestReturnsOnCall[len(fake.deleteBucketLifecycleRequestArgsForCall)] - fake.deleteBucketLifecycleRequestArgsForCall = append(fake.deleteBucketLifecycleRequestArgsForCall, struct { - arg1 *s3.DeleteBucketLifecycleInput - }{arg1}) - stub := fake.DeleteBucketLifecycleRequestStub - fakeReturns := fake.deleteBucketLifecycleRequestReturns - fake.recordInvocation("DeleteBucketLifecycleRequest", []interface{}{arg1}) - fake.deleteBucketLifecycleRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketLifecycleRequestCallCount() int { - fake.deleteBucketLifecycleRequestMutex.RLock() - defer fake.deleteBucketLifecycleRequestMutex.RUnlock() - return len(fake.deleteBucketLifecycleRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketLifecycleRequestCalls(stub func(*s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput)) { - fake.deleteBucketLifecycleRequestMutex.Lock() - defer fake.deleteBucketLifecycleRequestMutex.Unlock() - fake.DeleteBucketLifecycleRequestStub = stub -} - -func (fake *FakeS3Client) DeleteBucketLifecycleRequestArgsForCall(i int) *s3.DeleteBucketLifecycleInput { - fake.deleteBucketLifecycleRequestMutex.RLock() - defer fake.deleteBucketLifecycleRequestMutex.RUnlock() - argsForCall := fake.deleteBucketLifecycleRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketLifecycleRequestReturns(result1 *request.Request, result2 *s3.DeleteBucketLifecycleOutput) { - fake.deleteBucketLifecycleRequestMutex.Lock() - defer fake.deleteBucketLifecycleRequestMutex.Unlock() - fake.DeleteBucketLifecycleRequestStub = nil - fake.deleteBucketLifecycleRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteBucketLifecycleOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketLifecycleRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteBucketLifecycleOutput) { - fake.deleteBucketLifecycleRequestMutex.Lock() - defer fake.deleteBucketLifecycleRequestMutex.Unlock() - fake.DeleteBucketLifecycleRequestStub = nil - if fake.deleteBucketLifecycleRequestReturnsOnCall == nil { - fake.deleteBucketLifecycleRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketLifecycleOutput - }) - } - fake.deleteBucketLifecycleRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteBucketLifecycleOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketLifecycleWithContext(arg1 context.Context, arg2 *s3.DeleteBucketLifecycleInput, arg3 ...request.Option) (*s3.DeleteBucketLifecycleOutput, error) { - fake.deleteBucketLifecycleWithContextMutex.Lock() - ret, specificReturn := fake.deleteBucketLifecycleWithContextReturnsOnCall[len(fake.deleteBucketLifecycleWithContextArgsForCall)] - fake.deleteBucketLifecycleWithContextArgsForCall = append(fake.deleteBucketLifecycleWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteBucketLifecycleInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteBucketLifecycleWithContextStub - fakeReturns := fake.deleteBucketLifecycleWithContextReturns - fake.recordInvocation("DeleteBucketLifecycleWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteBucketLifecycleWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketLifecycleWithContextCallCount() int { - fake.deleteBucketLifecycleWithContextMutex.RLock() - defer fake.deleteBucketLifecycleWithContextMutex.RUnlock() - return len(fake.deleteBucketLifecycleWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketLifecycleWithContextCalls(stub func(context.Context, *s3.DeleteBucketLifecycleInput, ...request.Option) (*s3.DeleteBucketLifecycleOutput, error)) { - fake.deleteBucketLifecycleWithContextMutex.Lock() - defer fake.deleteBucketLifecycleWithContextMutex.Unlock() - fake.DeleteBucketLifecycleWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteBucketLifecycleWithContextArgsForCall(i int) (context.Context, *s3.DeleteBucketLifecycleInput, []request.Option) { - fake.deleteBucketLifecycleWithContextMutex.RLock() - defer fake.deleteBucketLifecycleWithContextMutex.RUnlock() - argsForCall := fake.deleteBucketLifecycleWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteBucketLifecycleWithContextReturns(result1 *s3.DeleteBucketLifecycleOutput, result2 error) { - fake.deleteBucketLifecycleWithContextMutex.Lock() - defer fake.deleteBucketLifecycleWithContextMutex.Unlock() - fake.DeleteBucketLifecycleWithContextStub = nil - fake.deleteBucketLifecycleWithContextReturns = struct { - result1 *s3.DeleteBucketLifecycleOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketLifecycleWithContextReturnsOnCall(i int, result1 *s3.DeleteBucketLifecycleOutput, result2 error) { - fake.deleteBucketLifecycleWithContextMutex.Lock() - defer fake.deleteBucketLifecycleWithContextMutex.Unlock() - fake.DeleteBucketLifecycleWithContextStub = nil - if fake.deleteBucketLifecycleWithContextReturnsOnCall == nil { - fake.deleteBucketLifecycleWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketLifecycleOutput - result2 error - }) - } - fake.deleteBucketLifecycleWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketLifecycleOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfiguration(arg1 *s3.DeleteBucketMetricsConfigurationInput) (*s3.DeleteBucketMetricsConfigurationOutput, error) { - fake.deleteBucketMetricsConfigurationMutex.Lock() - ret, specificReturn := fake.deleteBucketMetricsConfigurationReturnsOnCall[len(fake.deleteBucketMetricsConfigurationArgsForCall)] - fake.deleteBucketMetricsConfigurationArgsForCall = append(fake.deleteBucketMetricsConfigurationArgsForCall, struct { - arg1 *s3.DeleteBucketMetricsConfigurationInput - }{arg1}) - stub := fake.DeleteBucketMetricsConfigurationStub - fakeReturns := fake.deleteBucketMetricsConfigurationReturns - fake.recordInvocation("DeleteBucketMetricsConfiguration", []interface{}{arg1}) - fake.deleteBucketMetricsConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationCallCount() int { - fake.deleteBucketMetricsConfigurationMutex.RLock() - defer fake.deleteBucketMetricsConfigurationMutex.RUnlock() - return len(fake.deleteBucketMetricsConfigurationArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationCalls(stub func(*s3.DeleteBucketMetricsConfigurationInput) (*s3.DeleteBucketMetricsConfigurationOutput, error)) { - fake.deleteBucketMetricsConfigurationMutex.Lock() - defer fake.deleteBucketMetricsConfigurationMutex.Unlock() - fake.DeleteBucketMetricsConfigurationStub = stub -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationArgsForCall(i int) *s3.DeleteBucketMetricsConfigurationInput { - fake.deleteBucketMetricsConfigurationMutex.RLock() - defer fake.deleteBucketMetricsConfigurationMutex.RUnlock() - argsForCall := fake.deleteBucketMetricsConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationReturns(result1 *s3.DeleteBucketMetricsConfigurationOutput, result2 error) { - fake.deleteBucketMetricsConfigurationMutex.Lock() - defer fake.deleteBucketMetricsConfigurationMutex.Unlock() - fake.DeleteBucketMetricsConfigurationStub = nil - fake.deleteBucketMetricsConfigurationReturns = struct { - result1 *s3.DeleteBucketMetricsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationReturnsOnCall(i int, result1 *s3.DeleteBucketMetricsConfigurationOutput, result2 error) { - fake.deleteBucketMetricsConfigurationMutex.Lock() - defer fake.deleteBucketMetricsConfigurationMutex.Unlock() - fake.DeleteBucketMetricsConfigurationStub = nil - if fake.deleteBucketMetricsConfigurationReturnsOnCall == nil { - fake.deleteBucketMetricsConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketMetricsConfigurationOutput - result2 error - }) - } - fake.deleteBucketMetricsConfigurationReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketMetricsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationRequest(arg1 *s3.DeleteBucketMetricsConfigurationInput) (*request.Request, *s3.DeleteBucketMetricsConfigurationOutput) { - fake.deleteBucketMetricsConfigurationRequestMutex.Lock() - ret, specificReturn := fake.deleteBucketMetricsConfigurationRequestReturnsOnCall[len(fake.deleteBucketMetricsConfigurationRequestArgsForCall)] - fake.deleteBucketMetricsConfigurationRequestArgsForCall = append(fake.deleteBucketMetricsConfigurationRequestArgsForCall, struct { - arg1 *s3.DeleteBucketMetricsConfigurationInput - }{arg1}) - stub := fake.DeleteBucketMetricsConfigurationRequestStub - fakeReturns := fake.deleteBucketMetricsConfigurationRequestReturns - fake.recordInvocation("DeleteBucketMetricsConfigurationRequest", []interface{}{arg1}) - fake.deleteBucketMetricsConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationRequestCallCount() int { - fake.deleteBucketMetricsConfigurationRequestMutex.RLock() - defer fake.deleteBucketMetricsConfigurationRequestMutex.RUnlock() - return len(fake.deleteBucketMetricsConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationRequestCalls(stub func(*s3.DeleteBucketMetricsConfigurationInput) (*request.Request, *s3.DeleteBucketMetricsConfigurationOutput)) { - fake.deleteBucketMetricsConfigurationRequestMutex.Lock() - defer fake.deleteBucketMetricsConfigurationRequestMutex.Unlock() - fake.DeleteBucketMetricsConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationRequestArgsForCall(i int) *s3.DeleteBucketMetricsConfigurationInput { - fake.deleteBucketMetricsConfigurationRequestMutex.RLock() - defer fake.deleteBucketMetricsConfigurationRequestMutex.RUnlock() - argsForCall := fake.deleteBucketMetricsConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationRequestReturns(result1 *request.Request, result2 *s3.DeleteBucketMetricsConfigurationOutput) { - fake.deleteBucketMetricsConfigurationRequestMutex.Lock() - defer fake.deleteBucketMetricsConfigurationRequestMutex.Unlock() - fake.DeleteBucketMetricsConfigurationRequestStub = nil - fake.deleteBucketMetricsConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteBucketMetricsConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteBucketMetricsConfigurationOutput) { - fake.deleteBucketMetricsConfigurationRequestMutex.Lock() - defer fake.deleteBucketMetricsConfigurationRequestMutex.Unlock() - fake.DeleteBucketMetricsConfigurationRequestStub = nil - if fake.deleteBucketMetricsConfigurationRequestReturnsOnCall == nil { - fake.deleteBucketMetricsConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketMetricsConfigurationOutput - }) - } - fake.deleteBucketMetricsConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteBucketMetricsConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationWithContext(arg1 context.Context, arg2 *s3.DeleteBucketMetricsConfigurationInput, arg3 ...request.Option) (*s3.DeleteBucketMetricsConfigurationOutput, error) { - fake.deleteBucketMetricsConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.deleteBucketMetricsConfigurationWithContextReturnsOnCall[len(fake.deleteBucketMetricsConfigurationWithContextArgsForCall)] - fake.deleteBucketMetricsConfigurationWithContextArgsForCall = append(fake.deleteBucketMetricsConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteBucketMetricsConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteBucketMetricsConfigurationWithContextStub - fakeReturns := fake.deleteBucketMetricsConfigurationWithContextReturns - fake.recordInvocation("DeleteBucketMetricsConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteBucketMetricsConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationWithContextCallCount() int { - fake.deleteBucketMetricsConfigurationWithContextMutex.RLock() - defer fake.deleteBucketMetricsConfigurationWithContextMutex.RUnlock() - return len(fake.deleteBucketMetricsConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationWithContextCalls(stub func(context.Context, *s3.DeleteBucketMetricsConfigurationInput, ...request.Option) (*s3.DeleteBucketMetricsConfigurationOutput, error)) { - fake.deleteBucketMetricsConfigurationWithContextMutex.Lock() - defer fake.deleteBucketMetricsConfigurationWithContextMutex.Unlock() - fake.DeleteBucketMetricsConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationWithContextArgsForCall(i int) (context.Context, *s3.DeleteBucketMetricsConfigurationInput, []request.Option) { - fake.deleteBucketMetricsConfigurationWithContextMutex.RLock() - defer fake.deleteBucketMetricsConfigurationWithContextMutex.RUnlock() - argsForCall := fake.deleteBucketMetricsConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationWithContextReturns(result1 *s3.DeleteBucketMetricsConfigurationOutput, result2 error) { - fake.deleteBucketMetricsConfigurationWithContextMutex.Lock() - defer fake.deleteBucketMetricsConfigurationWithContextMutex.Unlock() - fake.DeleteBucketMetricsConfigurationWithContextStub = nil - fake.deleteBucketMetricsConfigurationWithContextReturns = struct { - result1 *s3.DeleteBucketMetricsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketMetricsConfigurationWithContextReturnsOnCall(i int, result1 *s3.DeleteBucketMetricsConfigurationOutput, result2 error) { - fake.deleteBucketMetricsConfigurationWithContextMutex.Lock() - defer fake.deleteBucketMetricsConfigurationWithContextMutex.Unlock() - fake.DeleteBucketMetricsConfigurationWithContextStub = nil - if fake.deleteBucketMetricsConfigurationWithContextReturnsOnCall == nil { - fake.deleteBucketMetricsConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketMetricsConfigurationOutput - result2 error - }) - } - fake.deleteBucketMetricsConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketMetricsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControls(arg1 *s3.DeleteBucketOwnershipControlsInput) (*s3.DeleteBucketOwnershipControlsOutput, error) { - fake.deleteBucketOwnershipControlsMutex.Lock() - ret, specificReturn := fake.deleteBucketOwnershipControlsReturnsOnCall[len(fake.deleteBucketOwnershipControlsArgsForCall)] - fake.deleteBucketOwnershipControlsArgsForCall = append(fake.deleteBucketOwnershipControlsArgsForCall, struct { - arg1 *s3.DeleteBucketOwnershipControlsInput - }{arg1}) - stub := fake.DeleteBucketOwnershipControlsStub - fakeReturns := fake.deleteBucketOwnershipControlsReturns - fake.recordInvocation("DeleteBucketOwnershipControls", []interface{}{arg1}) - fake.deleteBucketOwnershipControlsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsCallCount() int { - fake.deleteBucketOwnershipControlsMutex.RLock() - defer fake.deleteBucketOwnershipControlsMutex.RUnlock() - return len(fake.deleteBucketOwnershipControlsArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsCalls(stub func(*s3.DeleteBucketOwnershipControlsInput) (*s3.DeleteBucketOwnershipControlsOutput, error)) { - fake.deleteBucketOwnershipControlsMutex.Lock() - defer fake.deleteBucketOwnershipControlsMutex.Unlock() - fake.DeleteBucketOwnershipControlsStub = stub -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsArgsForCall(i int) *s3.DeleteBucketOwnershipControlsInput { - fake.deleteBucketOwnershipControlsMutex.RLock() - defer fake.deleteBucketOwnershipControlsMutex.RUnlock() - argsForCall := fake.deleteBucketOwnershipControlsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsReturns(result1 *s3.DeleteBucketOwnershipControlsOutput, result2 error) { - fake.deleteBucketOwnershipControlsMutex.Lock() - defer fake.deleteBucketOwnershipControlsMutex.Unlock() - fake.DeleteBucketOwnershipControlsStub = nil - fake.deleteBucketOwnershipControlsReturns = struct { - result1 *s3.DeleteBucketOwnershipControlsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsReturnsOnCall(i int, result1 *s3.DeleteBucketOwnershipControlsOutput, result2 error) { - fake.deleteBucketOwnershipControlsMutex.Lock() - defer fake.deleteBucketOwnershipControlsMutex.Unlock() - fake.DeleteBucketOwnershipControlsStub = nil - if fake.deleteBucketOwnershipControlsReturnsOnCall == nil { - fake.deleteBucketOwnershipControlsReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketOwnershipControlsOutput - result2 error - }) - } - fake.deleteBucketOwnershipControlsReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketOwnershipControlsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsRequest(arg1 *s3.DeleteBucketOwnershipControlsInput) (*request.Request, *s3.DeleteBucketOwnershipControlsOutput) { - fake.deleteBucketOwnershipControlsRequestMutex.Lock() - ret, specificReturn := fake.deleteBucketOwnershipControlsRequestReturnsOnCall[len(fake.deleteBucketOwnershipControlsRequestArgsForCall)] - fake.deleteBucketOwnershipControlsRequestArgsForCall = append(fake.deleteBucketOwnershipControlsRequestArgsForCall, struct { - arg1 *s3.DeleteBucketOwnershipControlsInput - }{arg1}) - stub := fake.DeleteBucketOwnershipControlsRequestStub - fakeReturns := fake.deleteBucketOwnershipControlsRequestReturns - fake.recordInvocation("DeleteBucketOwnershipControlsRequest", []interface{}{arg1}) - fake.deleteBucketOwnershipControlsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsRequestCallCount() int { - fake.deleteBucketOwnershipControlsRequestMutex.RLock() - defer fake.deleteBucketOwnershipControlsRequestMutex.RUnlock() - return len(fake.deleteBucketOwnershipControlsRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsRequestCalls(stub func(*s3.DeleteBucketOwnershipControlsInput) (*request.Request, *s3.DeleteBucketOwnershipControlsOutput)) { - fake.deleteBucketOwnershipControlsRequestMutex.Lock() - defer fake.deleteBucketOwnershipControlsRequestMutex.Unlock() - fake.DeleteBucketOwnershipControlsRequestStub = stub -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsRequestArgsForCall(i int) *s3.DeleteBucketOwnershipControlsInput { - fake.deleteBucketOwnershipControlsRequestMutex.RLock() - defer fake.deleteBucketOwnershipControlsRequestMutex.RUnlock() - argsForCall := fake.deleteBucketOwnershipControlsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsRequestReturns(result1 *request.Request, result2 *s3.DeleteBucketOwnershipControlsOutput) { - fake.deleteBucketOwnershipControlsRequestMutex.Lock() - defer fake.deleteBucketOwnershipControlsRequestMutex.Unlock() - fake.DeleteBucketOwnershipControlsRequestStub = nil - fake.deleteBucketOwnershipControlsRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteBucketOwnershipControlsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteBucketOwnershipControlsOutput) { - fake.deleteBucketOwnershipControlsRequestMutex.Lock() - defer fake.deleteBucketOwnershipControlsRequestMutex.Unlock() - fake.DeleteBucketOwnershipControlsRequestStub = nil - if fake.deleteBucketOwnershipControlsRequestReturnsOnCall == nil { - fake.deleteBucketOwnershipControlsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketOwnershipControlsOutput - }) - } - fake.deleteBucketOwnershipControlsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteBucketOwnershipControlsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsWithContext(arg1 context.Context, arg2 *s3.DeleteBucketOwnershipControlsInput, arg3 ...request.Option) (*s3.DeleteBucketOwnershipControlsOutput, error) { - fake.deleteBucketOwnershipControlsWithContextMutex.Lock() - ret, specificReturn := fake.deleteBucketOwnershipControlsWithContextReturnsOnCall[len(fake.deleteBucketOwnershipControlsWithContextArgsForCall)] - fake.deleteBucketOwnershipControlsWithContextArgsForCall = append(fake.deleteBucketOwnershipControlsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteBucketOwnershipControlsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteBucketOwnershipControlsWithContextStub - fakeReturns := fake.deleteBucketOwnershipControlsWithContextReturns - fake.recordInvocation("DeleteBucketOwnershipControlsWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteBucketOwnershipControlsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsWithContextCallCount() int { - fake.deleteBucketOwnershipControlsWithContextMutex.RLock() - defer fake.deleteBucketOwnershipControlsWithContextMutex.RUnlock() - return len(fake.deleteBucketOwnershipControlsWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsWithContextCalls(stub func(context.Context, *s3.DeleteBucketOwnershipControlsInput, ...request.Option) (*s3.DeleteBucketOwnershipControlsOutput, error)) { - fake.deleteBucketOwnershipControlsWithContextMutex.Lock() - defer fake.deleteBucketOwnershipControlsWithContextMutex.Unlock() - fake.DeleteBucketOwnershipControlsWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsWithContextArgsForCall(i int) (context.Context, *s3.DeleteBucketOwnershipControlsInput, []request.Option) { - fake.deleteBucketOwnershipControlsWithContextMutex.RLock() - defer fake.deleteBucketOwnershipControlsWithContextMutex.RUnlock() - argsForCall := fake.deleteBucketOwnershipControlsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsWithContextReturns(result1 *s3.DeleteBucketOwnershipControlsOutput, result2 error) { - fake.deleteBucketOwnershipControlsWithContextMutex.Lock() - defer fake.deleteBucketOwnershipControlsWithContextMutex.Unlock() - fake.DeleteBucketOwnershipControlsWithContextStub = nil - fake.deleteBucketOwnershipControlsWithContextReturns = struct { - result1 *s3.DeleteBucketOwnershipControlsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketOwnershipControlsWithContextReturnsOnCall(i int, result1 *s3.DeleteBucketOwnershipControlsOutput, result2 error) { - fake.deleteBucketOwnershipControlsWithContextMutex.Lock() - defer fake.deleteBucketOwnershipControlsWithContextMutex.Unlock() - fake.DeleteBucketOwnershipControlsWithContextStub = nil - if fake.deleteBucketOwnershipControlsWithContextReturnsOnCall == nil { - fake.deleteBucketOwnershipControlsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketOwnershipControlsOutput - result2 error - }) - } - fake.deleteBucketOwnershipControlsWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketOwnershipControlsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketPolicy(arg1 *s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error) { - fake.deleteBucketPolicyMutex.Lock() - ret, specificReturn := fake.deleteBucketPolicyReturnsOnCall[len(fake.deleteBucketPolicyArgsForCall)] - fake.deleteBucketPolicyArgsForCall = append(fake.deleteBucketPolicyArgsForCall, struct { - arg1 *s3.DeleteBucketPolicyInput - }{arg1}) - stub := fake.DeleteBucketPolicyStub - fakeReturns := fake.deleteBucketPolicyReturns - fake.recordInvocation("DeleteBucketPolicy", []interface{}{arg1}) - fake.deleteBucketPolicyMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketPolicyCallCount() int { - fake.deleteBucketPolicyMutex.RLock() - defer fake.deleteBucketPolicyMutex.RUnlock() - return len(fake.deleteBucketPolicyArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketPolicyCalls(stub func(*s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error)) { - fake.deleteBucketPolicyMutex.Lock() - defer fake.deleteBucketPolicyMutex.Unlock() - fake.DeleteBucketPolicyStub = stub -} - -func (fake *FakeS3Client) DeleteBucketPolicyArgsForCall(i int) *s3.DeleteBucketPolicyInput { - fake.deleteBucketPolicyMutex.RLock() - defer fake.deleteBucketPolicyMutex.RUnlock() - argsForCall := fake.deleteBucketPolicyArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketPolicyReturns(result1 *s3.DeleteBucketPolicyOutput, result2 error) { - fake.deleteBucketPolicyMutex.Lock() - defer fake.deleteBucketPolicyMutex.Unlock() - fake.DeleteBucketPolicyStub = nil - fake.deleteBucketPolicyReturns = struct { - result1 *s3.DeleteBucketPolicyOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketPolicyReturnsOnCall(i int, result1 *s3.DeleteBucketPolicyOutput, result2 error) { - fake.deleteBucketPolicyMutex.Lock() - defer fake.deleteBucketPolicyMutex.Unlock() - fake.DeleteBucketPolicyStub = nil - if fake.deleteBucketPolicyReturnsOnCall == nil { - fake.deleteBucketPolicyReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketPolicyOutput - result2 error - }) - } - fake.deleteBucketPolicyReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketPolicyOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketPolicyRequest(arg1 *s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput) { - fake.deleteBucketPolicyRequestMutex.Lock() - ret, specificReturn := fake.deleteBucketPolicyRequestReturnsOnCall[len(fake.deleteBucketPolicyRequestArgsForCall)] - fake.deleteBucketPolicyRequestArgsForCall = append(fake.deleteBucketPolicyRequestArgsForCall, struct { - arg1 *s3.DeleteBucketPolicyInput - }{arg1}) - stub := fake.DeleteBucketPolicyRequestStub - fakeReturns := fake.deleteBucketPolicyRequestReturns - fake.recordInvocation("DeleteBucketPolicyRequest", []interface{}{arg1}) - fake.deleteBucketPolicyRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketPolicyRequestCallCount() int { - fake.deleteBucketPolicyRequestMutex.RLock() - defer fake.deleteBucketPolicyRequestMutex.RUnlock() - return len(fake.deleteBucketPolicyRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketPolicyRequestCalls(stub func(*s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput)) { - fake.deleteBucketPolicyRequestMutex.Lock() - defer fake.deleteBucketPolicyRequestMutex.Unlock() - fake.DeleteBucketPolicyRequestStub = stub -} - -func (fake *FakeS3Client) DeleteBucketPolicyRequestArgsForCall(i int) *s3.DeleteBucketPolicyInput { - fake.deleteBucketPolicyRequestMutex.RLock() - defer fake.deleteBucketPolicyRequestMutex.RUnlock() - argsForCall := fake.deleteBucketPolicyRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketPolicyRequestReturns(result1 *request.Request, result2 *s3.DeleteBucketPolicyOutput) { - fake.deleteBucketPolicyRequestMutex.Lock() - defer fake.deleteBucketPolicyRequestMutex.Unlock() - fake.DeleteBucketPolicyRequestStub = nil - fake.deleteBucketPolicyRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteBucketPolicyOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketPolicyRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteBucketPolicyOutput) { - fake.deleteBucketPolicyRequestMutex.Lock() - defer fake.deleteBucketPolicyRequestMutex.Unlock() - fake.DeleteBucketPolicyRequestStub = nil - if fake.deleteBucketPolicyRequestReturnsOnCall == nil { - fake.deleteBucketPolicyRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketPolicyOutput - }) - } - fake.deleteBucketPolicyRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteBucketPolicyOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketPolicyWithContext(arg1 context.Context, arg2 *s3.DeleteBucketPolicyInput, arg3 ...request.Option) (*s3.DeleteBucketPolicyOutput, error) { - fake.deleteBucketPolicyWithContextMutex.Lock() - ret, specificReturn := fake.deleteBucketPolicyWithContextReturnsOnCall[len(fake.deleteBucketPolicyWithContextArgsForCall)] - fake.deleteBucketPolicyWithContextArgsForCall = append(fake.deleteBucketPolicyWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteBucketPolicyInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteBucketPolicyWithContextStub - fakeReturns := fake.deleteBucketPolicyWithContextReturns - fake.recordInvocation("DeleteBucketPolicyWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteBucketPolicyWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketPolicyWithContextCallCount() int { - fake.deleteBucketPolicyWithContextMutex.RLock() - defer fake.deleteBucketPolicyWithContextMutex.RUnlock() - return len(fake.deleteBucketPolicyWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketPolicyWithContextCalls(stub func(context.Context, *s3.DeleteBucketPolicyInput, ...request.Option) (*s3.DeleteBucketPolicyOutput, error)) { - fake.deleteBucketPolicyWithContextMutex.Lock() - defer fake.deleteBucketPolicyWithContextMutex.Unlock() - fake.DeleteBucketPolicyWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteBucketPolicyWithContextArgsForCall(i int) (context.Context, *s3.DeleteBucketPolicyInput, []request.Option) { - fake.deleteBucketPolicyWithContextMutex.RLock() - defer fake.deleteBucketPolicyWithContextMutex.RUnlock() - argsForCall := fake.deleteBucketPolicyWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteBucketPolicyWithContextReturns(result1 *s3.DeleteBucketPolicyOutput, result2 error) { - fake.deleteBucketPolicyWithContextMutex.Lock() - defer fake.deleteBucketPolicyWithContextMutex.Unlock() - fake.DeleteBucketPolicyWithContextStub = nil - fake.deleteBucketPolicyWithContextReturns = struct { - result1 *s3.DeleteBucketPolicyOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketPolicyWithContextReturnsOnCall(i int, result1 *s3.DeleteBucketPolicyOutput, result2 error) { - fake.deleteBucketPolicyWithContextMutex.Lock() - defer fake.deleteBucketPolicyWithContextMutex.Unlock() - fake.DeleteBucketPolicyWithContextStub = nil - if fake.deleteBucketPolicyWithContextReturnsOnCall == nil { - fake.deleteBucketPolicyWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketPolicyOutput - result2 error - }) - } - fake.deleteBucketPolicyWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketPolicyOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketReplication(arg1 *s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error) { - fake.deleteBucketReplicationMutex.Lock() - ret, specificReturn := fake.deleteBucketReplicationReturnsOnCall[len(fake.deleteBucketReplicationArgsForCall)] - fake.deleteBucketReplicationArgsForCall = append(fake.deleteBucketReplicationArgsForCall, struct { - arg1 *s3.DeleteBucketReplicationInput - }{arg1}) - stub := fake.DeleteBucketReplicationStub - fakeReturns := fake.deleteBucketReplicationReturns - fake.recordInvocation("DeleteBucketReplication", []interface{}{arg1}) - fake.deleteBucketReplicationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketReplicationCallCount() int { - fake.deleteBucketReplicationMutex.RLock() - defer fake.deleteBucketReplicationMutex.RUnlock() - return len(fake.deleteBucketReplicationArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketReplicationCalls(stub func(*s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error)) { - fake.deleteBucketReplicationMutex.Lock() - defer fake.deleteBucketReplicationMutex.Unlock() - fake.DeleteBucketReplicationStub = stub -} - -func (fake *FakeS3Client) DeleteBucketReplicationArgsForCall(i int) *s3.DeleteBucketReplicationInput { - fake.deleteBucketReplicationMutex.RLock() - defer fake.deleteBucketReplicationMutex.RUnlock() - argsForCall := fake.deleteBucketReplicationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketReplicationReturns(result1 *s3.DeleteBucketReplicationOutput, result2 error) { - fake.deleteBucketReplicationMutex.Lock() - defer fake.deleteBucketReplicationMutex.Unlock() - fake.DeleteBucketReplicationStub = nil - fake.deleteBucketReplicationReturns = struct { - result1 *s3.DeleteBucketReplicationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketReplicationReturnsOnCall(i int, result1 *s3.DeleteBucketReplicationOutput, result2 error) { - fake.deleteBucketReplicationMutex.Lock() - defer fake.deleteBucketReplicationMutex.Unlock() - fake.DeleteBucketReplicationStub = nil - if fake.deleteBucketReplicationReturnsOnCall == nil { - fake.deleteBucketReplicationReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketReplicationOutput - result2 error - }) - } - fake.deleteBucketReplicationReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketReplicationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketReplicationRequest(arg1 *s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput) { - fake.deleteBucketReplicationRequestMutex.Lock() - ret, specificReturn := fake.deleteBucketReplicationRequestReturnsOnCall[len(fake.deleteBucketReplicationRequestArgsForCall)] - fake.deleteBucketReplicationRequestArgsForCall = append(fake.deleteBucketReplicationRequestArgsForCall, struct { - arg1 *s3.DeleteBucketReplicationInput - }{arg1}) - stub := fake.DeleteBucketReplicationRequestStub - fakeReturns := fake.deleteBucketReplicationRequestReturns - fake.recordInvocation("DeleteBucketReplicationRequest", []interface{}{arg1}) - fake.deleteBucketReplicationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketReplicationRequestCallCount() int { - fake.deleteBucketReplicationRequestMutex.RLock() - defer fake.deleteBucketReplicationRequestMutex.RUnlock() - return len(fake.deleteBucketReplicationRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketReplicationRequestCalls(stub func(*s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput)) { - fake.deleteBucketReplicationRequestMutex.Lock() - defer fake.deleteBucketReplicationRequestMutex.Unlock() - fake.DeleteBucketReplicationRequestStub = stub -} - -func (fake *FakeS3Client) DeleteBucketReplicationRequestArgsForCall(i int) *s3.DeleteBucketReplicationInput { - fake.deleteBucketReplicationRequestMutex.RLock() - defer fake.deleteBucketReplicationRequestMutex.RUnlock() - argsForCall := fake.deleteBucketReplicationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketReplicationRequestReturns(result1 *request.Request, result2 *s3.DeleteBucketReplicationOutput) { - fake.deleteBucketReplicationRequestMutex.Lock() - defer fake.deleteBucketReplicationRequestMutex.Unlock() - fake.DeleteBucketReplicationRequestStub = nil - fake.deleteBucketReplicationRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteBucketReplicationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketReplicationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteBucketReplicationOutput) { - fake.deleteBucketReplicationRequestMutex.Lock() - defer fake.deleteBucketReplicationRequestMutex.Unlock() - fake.DeleteBucketReplicationRequestStub = nil - if fake.deleteBucketReplicationRequestReturnsOnCall == nil { - fake.deleteBucketReplicationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketReplicationOutput - }) - } - fake.deleteBucketReplicationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteBucketReplicationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketReplicationWithContext(arg1 context.Context, arg2 *s3.DeleteBucketReplicationInput, arg3 ...request.Option) (*s3.DeleteBucketReplicationOutput, error) { - fake.deleteBucketReplicationWithContextMutex.Lock() - ret, specificReturn := fake.deleteBucketReplicationWithContextReturnsOnCall[len(fake.deleteBucketReplicationWithContextArgsForCall)] - fake.deleteBucketReplicationWithContextArgsForCall = append(fake.deleteBucketReplicationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteBucketReplicationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteBucketReplicationWithContextStub - fakeReturns := fake.deleteBucketReplicationWithContextReturns - fake.recordInvocation("DeleteBucketReplicationWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteBucketReplicationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketReplicationWithContextCallCount() int { - fake.deleteBucketReplicationWithContextMutex.RLock() - defer fake.deleteBucketReplicationWithContextMutex.RUnlock() - return len(fake.deleteBucketReplicationWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketReplicationWithContextCalls(stub func(context.Context, *s3.DeleteBucketReplicationInput, ...request.Option) (*s3.DeleteBucketReplicationOutput, error)) { - fake.deleteBucketReplicationWithContextMutex.Lock() - defer fake.deleteBucketReplicationWithContextMutex.Unlock() - fake.DeleteBucketReplicationWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteBucketReplicationWithContextArgsForCall(i int) (context.Context, *s3.DeleteBucketReplicationInput, []request.Option) { - fake.deleteBucketReplicationWithContextMutex.RLock() - defer fake.deleteBucketReplicationWithContextMutex.RUnlock() - argsForCall := fake.deleteBucketReplicationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteBucketReplicationWithContextReturns(result1 *s3.DeleteBucketReplicationOutput, result2 error) { - fake.deleteBucketReplicationWithContextMutex.Lock() - defer fake.deleteBucketReplicationWithContextMutex.Unlock() - fake.DeleteBucketReplicationWithContextStub = nil - fake.deleteBucketReplicationWithContextReturns = struct { - result1 *s3.DeleteBucketReplicationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketReplicationWithContextReturnsOnCall(i int, result1 *s3.DeleteBucketReplicationOutput, result2 error) { - fake.deleteBucketReplicationWithContextMutex.Lock() - defer fake.deleteBucketReplicationWithContextMutex.Unlock() - fake.DeleteBucketReplicationWithContextStub = nil - if fake.deleteBucketReplicationWithContextReturnsOnCall == nil { - fake.deleteBucketReplicationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketReplicationOutput - result2 error - }) - } - fake.deleteBucketReplicationWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketReplicationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketRequest(arg1 *s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput) { - fake.deleteBucketRequestMutex.Lock() - ret, specificReturn := fake.deleteBucketRequestReturnsOnCall[len(fake.deleteBucketRequestArgsForCall)] - fake.deleteBucketRequestArgsForCall = append(fake.deleteBucketRequestArgsForCall, struct { - arg1 *s3.DeleteBucketInput - }{arg1}) - stub := fake.DeleteBucketRequestStub - fakeReturns := fake.deleteBucketRequestReturns - fake.recordInvocation("DeleteBucketRequest", []interface{}{arg1}) - fake.deleteBucketRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketRequestCallCount() int { - fake.deleteBucketRequestMutex.RLock() - defer fake.deleteBucketRequestMutex.RUnlock() - return len(fake.deleteBucketRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketRequestCalls(stub func(*s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput)) { - fake.deleteBucketRequestMutex.Lock() - defer fake.deleteBucketRequestMutex.Unlock() - fake.DeleteBucketRequestStub = stub -} - -func (fake *FakeS3Client) DeleteBucketRequestArgsForCall(i int) *s3.DeleteBucketInput { - fake.deleteBucketRequestMutex.RLock() - defer fake.deleteBucketRequestMutex.RUnlock() - argsForCall := fake.deleteBucketRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketRequestReturns(result1 *request.Request, result2 *s3.DeleteBucketOutput) { - fake.deleteBucketRequestMutex.Lock() - defer fake.deleteBucketRequestMutex.Unlock() - fake.DeleteBucketRequestStub = nil - fake.deleteBucketRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteBucketOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteBucketOutput) { - fake.deleteBucketRequestMutex.Lock() - defer fake.deleteBucketRequestMutex.Unlock() - fake.DeleteBucketRequestStub = nil - if fake.deleteBucketRequestReturnsOnCall == nil { - fake.deleteBucketRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketOutput - }) - } - fake.deleteBucketRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteBucketOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketTagging(arg1 *s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error) { - fake.deleteBucketTaggingMutex.Lock() - ret, specificReturn := fake.deleteBucketTaggingReturnsOnCall[len(fake.deleteBucketTaggingArgsForCall)] - fake.deleteBucketTaggingArgsForCall = append(fake.deleteBucketTaggingArgsForCall, struct { - arg1 *s3.DeleteBucketTaggingInput - }{arg1}) - stub := fake.DeleteBucketTaggingStub - fakeReturns := fake.deleteBucketTaggingReturns - fake.recordInvocation("DeleteBucketTagging", []interface{}{arg1}) - fake.deleteBucketTaggingMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketTaggingCallCount() int { - fake.deleteBucketTaggingMutex.RLock() - defer fake.deleteBucketTaggingMutex.RUnlock() - return len(fake.deleteBucketTaggingArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketTaggingCalls(stub func(*s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error)) { - fake.deleteBucketTaggingMutex.Lock() - defer fake.deleteBucketTaggingMutex.Unlock() - fake.DeleteBucketTaggingStub = stub -} - -func (fake *FakeS3Client) DeleteBucketTaggingArgsForCall(i int) *s3.DeleteBucketTaggingInput { - fake.deleteBucketTaggingMutex.RLock() - defer fake.deleteBucketTaggingMutex.RUnlock() - argsForCall := fake.deleteBucketTaggingArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketTaggingReturns(result1 *s3.DeleteBucketTaggingOutput, result2 error) { - fake.deleteBucketTaggingMutex.Lock() - defer fake.deleteBucketTaggingMutex.Unlock() - fake.DeleteBucketTaggingStub = nil - fake.deleteBucketTaggingReturns = struct { - result1 *s3.DeleteBucketTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketTaggingReturnsOnCall(i int, result1 *s3.DeleteBucketTaggingOutput, result2 error) { - fake.deleteBucketTaggingMutex.Lock() - defer fake.deleteBucketTaggingMutex.Unlock() - fake.DeleteBucketTaggingStub = nil - if fake.deleteBucketTaggingReturnsOnCall == nil { - fake.deleteBucketTaggingReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketTaggingOutput - result2 error - }) - } - fake.deleteBucketTaggingReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketTaggingRequest(arg1 *s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput) { - fake.deleteBucketTaggingRequestMutex.Lock() - ret, specificReturn := fake.deleteBucketTaggingRequestReturnsOnCall[len(fake.deleteBucketTaggingRequestArgsForCall)] - fake.deleteBucketTaggingRequestArgsForCall = append(fake.deleteBucketTaggingRequestArgsForCall, struct { - arg1 *s3.DeleteBucketTaggingInput - }{arg1}) - stub := fake.DeleteBucketTaggingRequestStub - fakeReturns := fake.deleteBucketTaggingRequestReturns - fake.recordInvocation("DeleteBucketTaggingRequest", []interface{}{arg1}) - fake.deleteBucketTaggingRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketTaggingRequestCallCount() int { - fake.deleteBucketTaggingRequestMutex.RLock() - defer fake.deleteBucketTaggingRequestMutex.RUnlock() - return len(fake.deleteBucketTaggingRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketTaggingRequestCalls(stub func(*s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput)) { - fake.deleteBucketTaggingRequestMutex.Lock() - defer fake.deleteBucketTaggingRequestMutex.Unlock() - fake.DeleteBucketTaggingRequestStub = stub -} - -func (fake *FakeS3Client) DeleteBucketTaggingRequestArgsForCall(i int) *s3.DeleteBucketTaggingInput { - fake.deleteBucketTaggingRequestMutex.RLock() - defer fake.deleteBucketTaggingRequestMutex.RUnlock() - argsForCall := fake.deleteBucketTaggingRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketTaggingRequestReturns(result1 *request.Request, result2 *s3.DeleteBucketTaggingOutput) { - fake.deleteBucketTaggingRequestMutex.Lock() - defer fake.deleteBucketTaggingRequestMutex.Unlock() - fake.DeleteBucketTaggingRequestStub = nil - fake.deleteBucketTaggingRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteBucketTaggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketTaggingRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteBucketTaggingOutput) { - fake.deleteBucketTaggingRequestMutex.Lock() - defer fake.deleteBucketTaggingRequestMutex.Unlock() - fake.DeleteBucketTaggingRequestStub = nil - if fake.deleteBucketTaggingRequestReturnsOnCall == nil { - fake.deleteBucketTaggingRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketTaggingOutput - }) - } - fake.deleteBucketTaggingRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteBucketTaggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketTaggingWithContext(arg1 context.Context, arg2 *s3.DeleteBucketTaggingInput, arg3 ...request.Option) (*s3.DeleteBucketTaggingOutput, error) { - fake.deleteBucketTaggingWithContextMutex.Lock() - ret, specificReturn := fake.deleteBucketTaggingWithContextReturnsOnCall[len(fake.deleteBucketTaggingWithContextArgsForCall)] - fake.deleteBucketTaggingWithContextArgsForCall = append(fake.deleteBucketTaggingWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteBucketTaggingInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteBucketTaggingWithContextStub - fakeReturns := fake.deleteBucketTaggingWithContextReturns - fake.recordInvocation("DeleteBucketTaggingWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteBucketTaggingWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketTaggingWithContextCallCount() int { - fake.deleteBucketTaggingWithContextMutex.RLock() - defer fake.deleteBucketTaggingWithContextMutex.RUnlock() - return len(fake.deleteBucketTaggingWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketTaggingWithContextCalls(stub func(context.Context, *s3.DeleteBucketTaggingInput, ...request.Option) (*s3.DeleteBucketTaggingOutput, error)) { - fake.deleteBucketTaggingWithContextMutex.Lock() - defer fake.deleteBucketTaggingWithContextMutex.Unlock() - fake.DeleteBucketTaggingWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteBucketTaggingWithContextArgsForCall(i int) (context.Context, *s3.DeleteBucketTaggingInput, []request.Option) { - fake.deleteBucketTaggingWithContextMutex.RLock() - defer fake.deleteBucketTaggingWithContextMutex.RUnlock() - argsForCall := fake.deleteBucketTaggingWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteBucketTaggingWithContextReturns(result1 *s3.DeleteBucketTaggingOutput, result2 error) { - fake.deleteBucketTaggingWithContextMutex.Lock() - defer fake.deleteBucketTaggingWithContextMutex.Unlock() - fake.DeleteBucketTaggingWithContextStub = nil - fake.deleteBucketTaggingWithContextReturns = struct { - result1 *s3.DeleteBucketTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketTaggingWithContextReturnsOnCall(i int, result1 *s3.DeleteBucketTaggingOutput, result2 error) { - fake.deleteBucketTaggingWithContextMutex.Lock() - defer fake.deleteBucketTaggingWithContextMutex.Unlock() - fake.DeleteBucketTaggingWithContextStub = nil - if fake.deleteBucketTaggingWithContextReturnsOnCall == nil { - fake.deleteBucketTaggingWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketTaggingOutput - result2 error - }) - } - fake.deleteBucketTaggingWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketWebsite(arg1 *s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error) { - fake.deleteBucketWebsiteMutex.Lock() - ret, specificReturn := fake.deleteBucketWebsiteReturnsOnCall[len(fake.deleteBucketWebsiteArgsForCall)] - fake.deleteBucketWebsiteArgsForCall = append(fake.deleteBucketWebsiteArgsForCall, struct { - arg1 *s3.DeleteBucketWebsiteInput - }{arg1}) - stub := fake.DeleteBucketWebsiteStub - fakeReturns := fake.deleteBucketWebsiteReturns - fake.recordInvocation("DeleteBucketWebsite", []interface{}{arg1}) - fake.deleteBucketWebsiteMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketWebsiteCallCount() int { - fake.deleteBucketWebsiteMutex.RLock() - defer fake.deleteBucketWebsiteMutex.RUnlock() - return len(fake.deleteBucketWebsiteArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketWebsiteCalls(stub func(*s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error)) { - fake.deleteBucketWebsiteMutex.Lock() - defer fake.deleteBucketWebsiteMutex.Unlock() - fake.DeleteBucketWebsiteStub = stub -} - -func (fake *FakeS3Client) DeleteBucketWebsiteArgsForCall(i int) *s3.DeleteBucketWebsiteInput { - fake.deleteBucketWebsiteMutex.RLock() - defer fake.deleteBucketWebsiteMutex.RUnlock() - argsForCall := fake.deleteBucketWebsiteArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketWebsiteReturns(result1 *s3.DeleteBucketWebsiteOutput, result2 error) { - fake.deleteBucketWebsiteMutex.Lock() - defer fake.deleteBucketWebsiteMutex.Unlock() - fake.DeleteBucketWebsiteStub = nil - fake.deleteBucketWebsiteReturns = struct { - result1 *s3.DeleteBucketWebsiteOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketWebsiteReturnsOnCall(i int, result1 *s3.DeleteBucketWebsiteOutput, result2 error) { - fake.deleteBucketWebsiteMutex.Lock() - defer fake.deleteBucketWebsiteMutex.Unlock() - fake.DeleteBucketWebsiteStub = nil - if fake.deleteBucketWebsiteReturnsOnCall == nil { - fake.deleteBucketWebsiteReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketWebsiteOutput - result2 error - }) - } - fake.deleteBucketWebsiteReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketWebsiteOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketWebsiteRequest(arg1 *s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput) { - fake.deleteBucketWebsiteRequestMutex.Lock() - ret, specificReturn := fake.deleteBucketWebsiteRequestReturnsOnCall[len(fake.deleteBucketWebsiteRequestArgsForCall)] - fake.deleteBucketWebsiteRequestArgsForCall = append(fake.deleteBucketWebsiteRequestArgsForCall, struct { - arg1 *s3.DeleteBucketWebsiteInput - }{arg1}) - stub := fake.DeleteBucketWebsiteRequestStub - fakeReturns := fake.deleteBucketWebsiteRequestReturns - fake.recordInvocation("DeleteBucketWebsiteRequest", []interface{}{arg1}) - fake.deleteBucketWebsiteRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketWebsiteRequestCallCount() int { - fake.deleteBucketWebsiteRequestMutex.RLock() - defer fake.deleteBucketWebsiteRequestMutex.RUnlock() - return len(fake.deleteBucketWebsiteRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketWebsiteRequestCalls(stub func(*s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput)) { - fake.deleteBucketWebsiteRequestMutex.Lock() - defer fake.deleteBucketWebsiteRequestMutex.Unlock() - fake.DeleteBucketWebsiteRequestStub = stub -} - -func (fake *FakeS3Client) DeleteBucketWebsiteRequestArgsForCall(i int) *s3.DeleteBucketWebsiteInput { - fake.deleteBucketWebsiteRequestMutex.RLock() - defer fake.deleteBucketWebsiteRequestMutex.RUnlock() - argsForCall := fake.deleteBucketWebsiteRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteBucketWebsiteRequestReturns(result1 *request.Request, result2 *s3.DeleteBucketWebsiteOutput) { - fake.deleteBucketWebsiteRequestMutex.Lock() - defer fake.deleteBucketWebsiteRequestMutex.Unlock() - fake.DeleteBucketWebsiteRequestStub = nil - fake.deleteBucketWebsiteRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteBucketWebsiteOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketWebsiteRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteBucketWebsiteOutput) { - fake.deleteBucketWebsiteRequestMutex.Lock() - defer fake.deleteBucketWebsiteRequestMutex.Unlock() - fake.DeleteBucketWebsiteRequestStub = nil - if fake.deleteBucketWebsiteRequestReturnsOnCall == nil { - fake.deleteBucketWebsiteRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteBucketWebsiteOutput - }) - } - fake.deleteBucketWebsiteRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteBucketWebsiteOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketWebsiteWithContext(arg1 context.Context, arg2 *s3.DeleteBucketWebsiteInput, arg3 ...request.Option) (*s3.DeleteBucketWebsiteOutput, error) { - fake.deleteBucketWebsiteWithContextMutex.Lock() - ret, specificReturn := fake.deleteBucketWebsiteWithContextReturnsOnCall[len(fake.deleteBucketWebsiteWithContextArgsForCall)] - fake.deleteBucketWebsiteWithContextArgsForCall = append(fake.deleteBucketWebsiteWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteBucketWebsiteInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteBucketWebsiteWithContextStub - fakeReturns := fake.deleteBucketWebsiteWithContextReturns - fake.recordInvocation("DeleteBucketWebsiteWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteBucketWebsiteWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketWebsiteWithContextCallCount() int { - fake.deleteBucketWebsiteWithContextMutex.RLock() - defer fake.deleteBucketWebsiteWithContextMutex.RUnlock() - return len(fake.deleteBucketWebsiteWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketWebsiteWithContextCalls(stub func(context.Context, *s3.DeleteBucketWebsiteInput, ...request.Option) (*s3.DeleteBucketWebsiteOutput, error)) { - fake.deleteBucketWebsiteWithContextMutex.Lock() - defer fake.deleteBucketWebsiteWithContextMutex.Unlock() - fake.DeleteBucketWebsiteWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteBucketWebsiteWithContextArgsForCall(i int) (context.Context, *s3.DeleteBucketWebsiteInput, []request.Option) { - fake.deleteBucketWebsiteWithContextMutex.RLock() - defer fake.deleteBucketWebsiteWithContextMutex.RUnlock() - argsForCall := fake.deleteBucketWebsiteWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteBucketWebsiteWithContextReturns(result1 *s3.DeleteBucketWebsiteOutput, result2 error) { - fake.deleteBucketWebsiteWithContextMutex.Lock() - defer fake.deleteBucketWebsiteWithContextMutex.Unlock() - fake.DeleteBucketWebsiteWithContextStub = nil - fake.deleteBucketWebsiteWithContextReturns = struct { - result1 *s3.DeleteBucketWebsiteOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketWebsiteWithContextReturnsOnCall(i int, result1 *s3.DeleteBucketWebsiteOutput, result2 error) { - fake.deleteBucketWebsiteWithContextMutex.Lock() - defer fake.deleteBucketWebsiteWithContextMutex.Unlock() - fake.DeleteBucketWebsiteWithContextStub = nil - if fake.deleteBucketWebsiteWithContextReturnsOnCall == nil { - fake.deleteBucketWebsiteWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketWebsiteOutput - result2 error - }) - } - fake.deleteBucketWebsiteWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketWebsiteOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketWithContext(arg1 context.Context, arg2 *s3.DeleteBucketInput, arg3 ...request.Option) (*s3.DeleteBucketOutput, error) { - fake.deleteBucketWithContextMutex.Lock() - ret, specificReturn := fake.deleteBucketWithContextReturnsOnCall[len(fake.deleteBucketWithContextArgsForCall)] - fake.deleteBucketWithContextArgsForCall = append(fake.deleteBucketWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteBucketInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteBucketWithContextStub - fakeReturns := fake.deleteBucketWithContextReturns - fake.recordInvocation("DeleteBucketWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteBucketWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteBucketWithContextCallCount() int { - fake.deleteBucketWithContextMutex.RLock() - defer fake.deleteBucketWithContextMutex.RUnlock() - return len(fake.deleteBucketWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteBucketWithContextCalls(stub func(context.Context, *s3.DeleteBucketInput, ...request.Option) (*s3.DeleteBucketOutput, error)) { - fake.deleteBucketWithContextMutex.Lock() - defer fake.deleteBucketWithContextMutex.Unlock() - fake.DeleteBucketWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteBucketWithContextArgsForCall(i int) (context.Context, *s3.DeleteBucketInput, []request.Option) { - fake.deleteBucketWithContextMutex.RLock() - defer fake.deleteBucketWithContextMutex.RUnlock() - argsForCall := fake.deleteBucketWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteBucketWithContextReturns(result1 *s3.DeleteBucketOutput, result2 error) { - fake.deleteBucketWithContextMutex.Lock() - defer fake.deleteBucketWithContextMutex.Unlock() - fake.DeleteBucketWithContextStub = nil - fake.deleteBucketWithContextReturns = struct { - result1 *s3.DeleteBucketOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteBucketWithContextReturnsOnCall(i int, result1 *s3.DeleteBucketOutput, result2 error) { - fake.deleteBucketWithContextMutex.Lock() - defer fake.deleteBucketWithContextMutex.Unlock() - fake.DeleteBucketWithContextStub = nil - if fake.deleteBucketWithContextReturnsOnCall == nil { - fake.deleteBucketWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteBucketOutput - result2 error - }) - } - fake.deleteBucketWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteBucketOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObject(arg1 *s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error) { - fake.deleteObjectMutex.Lock() - ret, specificReturn := fake.deleteObjectReturnsOnCall[len(fake.deleteObjectArgsForCall)] - fake.deleteObjectArgsForCall = append(fake.deleteObjectArgsForCall, struct { - arg1 *s3.DeleteObjectInput - }{arg1}) - stub := fake.DeleteObjectStub - fakeReturns := fake.deleteObjectReturns - fake.recordInvocation("DeleteObject", []interface{}{arg1}) - fake.deleteObjectMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteObjectCallCount() int { - fake.deleteObjectMutex.RLock() - defer fake.deleteObjectMutex.RUnlock() - return len(fake.deleteObjectArgsForCall) -} - -func (fake *FakeS3Client) DeleteObjectCalls(stub func(*s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error)) { - fake.deleteObjectMutex.Lock() - defer fake.deleteObjectMutex.Unlock() - fake.DeleteObjectStub = stub -} - -func (fake *FakeS3Client) DeleteObjectArgsForCall(i int) *s3.DeleteObjectInput { - fake.deleteObjectMutex.RLock() - defer fake.deleteObjectMutex.RUnlock() - argsForCall := fake.deleteObjectArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteObjectReturns(result1 *s3.DeleteObjectOutput, result2 error) { - fake.deleteObjectMutex.Lock() - defer fake.deleteObjectMutex.Unlock() - fake.DeleteObjectStub = nil - fake.deleteObjectReturns = struct { - result1 *s3.DeleteObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectReturnsOnCall(i int, result1 *s3.DeleteObjectOutput, result2 error) { - fake.deleteObjectMutex.Lock() - defer fake.deleteObjectMutex.Unlock() - fake.DeleteObjectStub = nil - if fake.deleteObjectReturnsOnCall == nil { - fake.deleteObjectReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteObjectOutput - result2 error - }) - } - fake.deleteObjectReturnsOnCall[i] = struct { - result1 *s3.DeleteObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectRequest(arg1 *s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput) { - fake.deleteObjectRequestMutex.Lock() - ret, specificReturn := fake.deleteObjectRequestReturnsOnCall[len(fake.deleteObjectRequestArgsForCall)] - fake.deleteObjectRequestArgsForCall = append(fake.deleteObjectRequestArgsForCall, struct { - arg1 *s3.DeleteObjectInput - }{arg1}) - stub := fake.DeleteObjectRequestStub - fakeReturns := fake.deleteObjectRequestReturns - fake.recordInvocation("DeleteObjectRequest", []interface{}{arg1}) - fake.deleteObjectRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteObjectRequestCallCount() int { - fake.deleteObjectRequestMutex.RLock() - defer fake.deleteObjectRequestMutex.RUnlock() - return len(fake.deleteObjectRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteObjectRequestCalls(stub func(*s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput)) { - fake.deleteObjectRequestMutex.Lock() - defer fake.deleteObjectRequestMutex.Unlock() - fake.DeleteObjectRequestStub = stub -} - -func (fake *FakeS3Client) DeleteObjectRequestArgsForCall(i int) *s3.DeleteObjectInput { - fake.deleteObjectRequestMutex.RLock() - defer fake.deleteObjectRequestMutex.RUnlock() - argsForCall := fake.deleteObjectRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteObjectRequestReturns(result1 *request.Request, result2 *s3.DeleteObjectOutput) { - fake.deleteObjectRequestMutex.Lock() - defer fake.deleteObjectRequestMutex.Unlock() - fake.DeleteObjectRequestStub = nil - fake.deleteObjectRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteObjectOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteObjectOutput) { - fake.deleteObjectRequestMutex.Lock() - defer fake.deleteObjectRequestMutex.Unlock() - fake.DeleteObjectRequestStub = nil - if fake.deleteObjectRequestReturnsOnCall == nil { - fake.deleteObjectRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteObjectOutput - }) - } - fake.deleteObjectRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteObjectOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectTagging(arg1 *s3.DeleteObjectTaggingInput) (*s3.DeleteObjectTaggingOutput, error) { - fake.deleteObjectTaggingMutex.Lock() - ret, specificReturn := fake.deleteObjectTaggingReturnsOnCall[len(fake.deleteObjectTaggingArgsForCall)] - fake.deleteObjectTaggingArgsForCall = append(fake.deleteObjectTaggingArgsForCall, struct { - arg1 *s3.DeleteObjectTaggingInput - }{arg1}) - stub := fake.DeleteObjectTaggingStub - fakeReturns := fake.deleteObjectTaggingReturns - fake.recordInvocation("DeleteObjectTagging", []interface{}{arg1}) - fake.deleteObjectTaggingMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteObjectTaggingCallCount() int { - fake.deleteObjectTaggingMutex.RLock() - defer fake.deleteObjectTaggingMutex.RUnlock() - return len(fake.deleteObjectTaggingArgsForCall) -} - -func (fake *FakeS3Client) DeleteObjectTaggingCalls(stub func(*s3.DeleteObjectTaggingInput) (*s3.DeleteObjectTaggingOutput, error)) { - fake.deleteObjectTaggingMutex.Lock() - defer fake.deleteObjectTaggingMutex.Unlock() - fake.DeleteObjectTaggingStub = stub -} - -func (fake *FakeS3Client) DeleteObjectTaggingArgsForCall(i int) *s3.DeleteObjectTaggingInput { - fake.deleteObjectTaggingMutex.RLock() - defer fake.deleteObjectTaggingMutex.RUnlock() - argsForCall := fake.deleteObjectTaggingArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteObjectTaggingReturns(result1 *s3.DeleteObjectTaggingOutput, result2 error) { - fake.deleteObjectTaggingMutex.Lock() - defer fake.deleteObjectTaggingMutex.Unlock() - fake.DeleteObjectTaggingStub = nil - fake.deleteObjectTaggingReturns = struct { - result1 *s3.DeleteObjectTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectTaggingReturnsOnCall(i int, result1 *s3.DeleteObjectTaggingOutput, result2 error) { - fake.deleteObjectTaggingMutex.Lock() - defer fake.deleteObjectTaggingMutex.Unlock() - fake.DeleteObjectTaggingStub = nil - if fake.deleteObjectTaggingReturnsOnCall == nil { - fake.deleteObjectTaggingReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteObjectTaggingOutput - result2 error - }) - } - fake.deleteObjectTaggingReturnsOnCall[i] = struct { - result1 *s3.DeleteObjectTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectTaggingRequest(arg1 *s3.DeleteObjectTaggingInput) (*request.Request, *s3.DeleteObjectTaggingOutput) { - fake.deleteObjectTaggingRequestMutex.Lock() - ret, specificReturn := fake.deleteObjectTaggingRequestReturnsOnCall[len(fake.deleteObjectTaggingRequestArgsForCall)] - fake.deleteObjectTaggingRequestArgsForCall = append(fake.deleteObjectTaggingRequestArgsForCall, struct { - arg1 *s3.DeleteObjectTaggingInput - }{arg1}) - stub := fake.DeleteObjectTaggingRequestStub - fakeReturns := fake.deleteObjectTaggingRequestReturns - fake.recordInvocation("DeleteObjectTaggingRequest", []interface{}{arg1}) - fake.deleteObjectTaggingRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteObjectTaggingRequestCallCount() int { - fake.deleteObjectTaggingRequestMutex.RLock() - defer fake.deleteObjectTaggingRequestMutex.RUnlock() - return len(fake.deleteObjectTaggingRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteObjectTaggingRequestCalls(stub func(*s3.DeleteObjectTaggingInput) (*request.Request, *s3.DeleteObjectTaggingOutput)) { - fake.deleteObjectTaggingRequestMutex.Lock() - defer fake.deleteObjectTaggingRequestMutex.Unlock() - fake.DeleteObjectTaggingRequestStub = stub -} - -func (fake *FakeS3Client) DeleteObjectTaggingRequestArgsForCall(i int) *s3.DeleteObjectTaggingInput { - fake.deleteObjectTaggingRequestMutex.RLock() - defer fake.deleteObjectTaggingRequestMutex.RUnlock() - argsForCall := fake.deleteObjectTaggingRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteObjectTaggingRequestReturns(result1 *request.Request, result2 *s3.DeleteObjectTaggingOutput) { - fake.deleteObjectTaggingRequestMutex.Lock() - defer fake.deleteObjectTaggingRequestMutex.Unlock() - fake.DeleteObjectTaggingRequestStub = nil - fake.deleteObjectTaggingRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteObjectTaggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectTaggingRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteObjectTaggingOutput) { - fake.deleteObjectTaggingRequestMutex.Lock() - defer fake.deleteObjectTaggingRequestMutex.Unlock() - fake.DeleteObjectTaggingRequestStub = nil - if fake.deleteObjectTaggingRequestReturnsOnCall == nil { - fake.deleteObjectTaggingRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteObjectTaggingOutput - }) - } - fake.deleteObjectTaggingRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteObjectTaggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectTaggingWithContext(arg1 context.Context, arg2 *s3.DeleteObjectTaggingInput, arg3 ...request.Option) (*s3.DeleteObjectTaggingOutput, error) { - fake.deleteObjectTaggingWithContextMutex.Lock() - ret, specificReturn := fake.deleteObjectTaggingWithContextReturnsOnCall[len(fake.deleteObjectTaggingWithContextArgsForCall)] - fake.deleteObjectTaggingWithContextArgsForCall = append(fake.deleteObjectTaggingWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteObjectTaggingInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteObjectTaggingWithContextStub - fakeReturns := fake.deleteObjectTaggingWithContextReturns - fake.recordInvocation("DeleteObjectTaggingWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteObjectTaggingWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteObjectTaggingWithContextCallCount() int { - fake.deleteObjectTaggingWithContextMutex.RLock() - defer fake.deleteObjectTaggingWithContextMutex.RUnlock() - return len(fake.deleteObjectTaggingWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteObjectTaggingWithContextCalls(stub func(context.Context, *s3.DeleteObjectTaggingInput, ...request.Option) (*s3.DeleteObjectTaggingOutput, error)) { - fake.deleteObjectTaggingWithContextMutex.Lock() - defer fake.deleteObjectTaggingWithContextMutex.Unlock() - fake.DeleteObjectTaggingWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteObjectTaggingWithContextArgsForCall(i int) (context.Context, *s3.DeleteObjectTaggingInput, []request.Option) { - fake.deleteObjectTaggingWithContextMutex.RLock() - defer fake.deleteObjectTaggingWithContextMutex.RUnlock() - argsForCall := fake.deleteObjectTaggingWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteObjectTaggingWithContextReturns(result1 *s3.DeleteObjectTaggingOutput, result2 error) { - fake.deleteObjectTaggingWithContextMutex.Lock() - defer fake.deleteObjectTaggingWithContextMutex.Unlock() - fake.DeleteObjectTaggingWithContextStub = nil - fake.deleteObjectTaggingWithContextReturns = struct { - result1 *s3.DeleteObjectTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectTaggingWithContextReturnsOnCall(i int, result1 *s3.DeleteObjectTaggingOutput, result2 error) { - fake.deleteObjectTaggingWithContextMutex.Lock() - defer fake.deleteObjectTaggingWithContextMutex.Unlock() - fake.DeleteObjectTaggingWithContextStub = nil - if fake.deleteObjectTaggingWithContextReturnsOnCall == nil { - fake.deleteObjectTaggingWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteObjectTaggingOutput - result2 error - }) - } - fake.deleteObjectTaggingWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteObjectTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectWithContext(arg1 context.Context, arg2 *s3.DeleteObjectInput, arg3 ...request.Option) (*s3.DeleteObjectOutput, error) { - fake.deleteObjectWithContextMutex.Lock() - ret, specificReturn := fake.deleteObjectWithContextReturnsOnCall[len(fake.deleteObjectWithContextArgsForCall)] - fake.deleteObjectWithContextArgsForCall = append(fake.deleteObjectWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteObjectInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteObjectWithContextStub - fakeReturns := fake.deleteObjectWithContextReturns - fake.recordInvocation("DeleteObjectWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteObjectWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteObjectWithContextCallCount() int { - fake.deleteObjectWithContextMutex.RLock() - defer fake.deleteObjectWithContextMutex.RUnlock() - return len(fake.deleteObjectWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteObjectWithContextCalls(stub func(context.Context, *s3.DeleteObjectInput, ...request.Option) (*s3.DeleteObjectOutput, error)) { - fake.deleteObjectWithContextMutex.Lock() - defer fake.deleteObjectWithContextMutex.Unlock() - fake.DeleteObjectWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteObjectWithContextArgsForCall(i int) (context.Context, *s3.DeleteObjectInput, []request.Option) { - fake.deleteObjectWithContextMutex.RLock() - defer fake.deleteObjectWithContextMutex.RUnlock() - argsForCall := fake.deleteObjectWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteObjectWithContextReturns(result1 *s3.DeleteObjectOutput, result2 error) { - fake.deleteObjectWithContextMutex.Lock() - defer fake.deleteObjectWithContextMutex.Unlock() - fake.DeleteObjectWithContextStub = nil - fake.deleteObjectWithContextReturns = struct { - result1 *s3.DeleteObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectWithContextReturnsOnCall(i int, result1 *s3.DeleteObjectOutput, result2 error) { - fake.deleteObjectWithContextMutex.Lock() - defer fake.deleteObjectWithContextMutex.Unlock() - fake.DeleteObjectWithContextStub = nil - if fake.deleteObjectWithContextReturnsOnCall == nil { - fake.deleteObjectWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteObjectOutput - result2 error - }) - } - fake.deleteObjectWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjects(arg1 *s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error) { - fake.deleteObjectsMutex.Lock() - ret, specificReturn := fake.deleteObjectsReturnsOnCall[len(fake.deleteObjectsArgsForCall)] - fake.deleteObjectsArgsForCall = append(fake.deleteObjectsArgsForCall, struct { - arg1 *s3.DeleteObjectsInput - }{arg1}) - stub := fake.DeleteObjectsStub - fakeReturns := fake.deleteObjectsReturns - fake.recordInvocation("DeleteObjects", []interface{}{arg1}) - fake.deleteObjectsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteObjectsCallCount() int { - fake.deleteObjectsMutex.RLock() - defer fake.deleteObjectsMutex.RUnlock() - return len(fake.deleteObjectsArgsForCall) -} - -func (fake *FakeS3Client) DeleteObjectsCalls(stub func(*s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error)) { - fake.deleteObjectsMutex.Lock() - defer fake.deleteObjectsMutex.Unlock() - fake.DeleteObjectsStub = stub -} - -func (fake *FakeS3Client) DeleteObjectsArgsForCall(i int) *s3.DeleteObjectsInput { - fake.deleteObjectsMutex.RLock() - defer fake.deleteObjectsMutex.RUnlock() - argsForCall := fake.deleteObjectsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteObjectsReturns(result1 *s3.DeleteObjectsOutput, result2 error) { - fake.deleteObjectsMutex.Lock() - defer fake.deleteObjectsMutex.Unlock() - fake.DeleteObjectsStub = nil - fake.deleteObjectsReturns = struct { - result1 *s3.DeleteObjectsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectsReturnsOnCall(i int, result1 *s3.DeleteObjectsOutput, result2 error) { - fake.deleteObjectsMutex.Lock() - defer fake.deleteObjectsMutex.Unlock() - fake.DeleteObjectsStub = nil - if fake.deleteObjectsReturnsOnCall == nil { - fake.deleteObjectsReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteObjectsOutput - result2 error - }) - } - fake.deleteObjectsReturnsOnCall[i] = struct { - result1 *s3.DeleteObjectsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectsRequest(arg1 *s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput) { - fake.deleteObjectsRequestMutex.Lock() - ret, specificReturn := fake.deleteObjectsRequestReturnsOnCall[len(fake.deleteObjectsRequestArgsForCall)] - fake.deleteObjectsRequestArgsForCall = append(fake.deleteObjectsRequestArgsForCall, struct { - arg1 *s3.DeleteObjectsInput - }{arg1}) - stub := fake.DeleteObjectsRequestStub - fakeReturns := fake.deleteObjectsRequestReturns - fake.recordInvocation("DeleteObjectsRequest", []interface{}{arg1}) - fake.deleteObjectsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteObjectsRequestCallCount() int { - fake.deleteObjectsRequestMutex.RLock() - defer fake.deleteObjectsRequestMutex.RUnlock() - return len(fake.deleteObjectsRequestArgsForCall) -} - -func (fake *FakeS3Client) DeleteObjectsRequestCalls(stub func(*s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput)) { - fake.deleteObjectsRequestMutex.Lock() - defer fake.deleteObjectsRequestMutex.Unlock() - fake.DeleteObjectsRequestStub = stub -} - -func (fake *FakeS3Client) DeleteObjectsRequestArgsForCall(i int) *s3.DeleteObjectsInput { - fake.deleteObjectsRequestMutex.RLock() - defer fake.deleteObjectsRequestMutex.RUnlock() - argsForCall := fake.deleteObjectsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeleteObjectsRequestReturns(result1 *request.Request, result2 *s3.DeleteObjectsOutput) { - fake.deleteObjectsRequestMutex.Lock() - defer fake.deleteObjectsRequestMutex.Unlock() - fake.DeleteObjectsRequestStub = nil - fake.deleteObjectsRequestReturns = struct { - result1 *request.Request - result2 *s3.DeleteObjectsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeleteObjectsOutput) { - fake.deleteObjectsRequestMutex.Lock() - defer fake.deleteObjectsRequestMutex.Unlock() - fake.DeleteObjectsRequestStub = nil - if fake.deleteObjectsRequestReturnsOnCall == nil { - fake.deleteObjectsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeleteObjectsOutput - }) - } - fake.deleteObjectsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeleteObjectsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectsWithContext(arg1 context.Context, arg2 *s3.DeleteObjectsInput, arg3 ...request.Option) (*s3.DeleteObjectsOutput, error) { - fake.deleteObjectsWithContextMutex.Lock() - ret, specificReturn := fake.deleteObjectsWithContextReturnsOnCall[len(fake.deleteObjectsWithContextArgsForCall)] - fake.deleteObjectsWithContextArgsForCall = append(fake.deleteObjectsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeleteObjectsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeleteObjectsWithContextStub - fakeReturns := fake.deleteObjectsWithContextReturns - fake.recordInvocation("DeleteObjectsWithContext", []interface{}{arg1, arg2, arg3}) - fake.deleteObjectsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeleteObjectsWithContextCallCount() int { - fake.deleteObjectsWithContextMutex.RLock() - defer fake.deleteObjectsWithContextMutex.RUnlock() - return len(fake.deleteObjectsWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeleteObjectsWithContextCalls(stub func(context.Context, *s3.DeleteObjectsInput, ...request.Option) (*s3.DeleteObjectsOutput, error)) { - fake.deleteObjectsWithContextMutex.Lock() - defer fake.deleteObjectsWithContextMutex.Unlock() - fake.DeleteObjectsWithContextStub = stub -} - -func (fake *FakeS3Client) DeleteObjectsWithContextArgsForCall(i int) (context.Context, *s3.DeleteObjectsInput, []request.Option) { - fake.deleteObjectsWithContextMutex.RLock() - defer fake.deleteObjectsWithContextMutex.RUnlock() - argsForCall := fake.deleteObjectsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeleteObjectsWithContextReturns(result1 *s3.DeleteObjectsOutput, result2 error) { - fake.deleteObjectsWithContextMutex.Lock() - defer fake.deleteObjectsWithContextMutex.Unlock() - fake.DeleteObjectsWithContextStub = nil - fake.deleteObjectsWithContextReturns = struct { - result1 *s3.DeleteObjectsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeleteObjectsWithContextReturnsOnCall(i int, result1 *s3.DeleteObjectsOutput, result2 error) { - fake.deleteObjectsWithContextMutex.Lock() - defer fake.deleteObjectsWithContextMutex.Unlock() - fake.DeleteObjectsWithContextStub = nil - if fake.deleteObjectsWithContextReturnsOnCall == nil { - fake.deleteObjectsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeleteObjectsOutput - result2 error - }) - } - fake.deleteObjectsWithContextReturnsOnCall[i] = struct { - result1 *s3.DeleteObjectsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeletePublicAccessBlock(arg1 *s3.DeletePublicAccessBlockInput) (*s3.DeletePublicAccessBlockOutput, error) { - fake.deletePublicAccessBlockMutex.Lock() - ret, specificReturn := fake.deletePublicAccessBlockReturnsOnCall[len(fake.deletePublicAccessBlockArgsForCall)] - fake.deletePublicAccessBlockArgsForCall = append(fake.deletePublicAccessBlockArgsForCall, struct { - arg1 *s3.DeletePublicAccessBlockInput - }{arg1}) - stub := fake.DeletePublicAccessBlockStub - fakeReturns := fake.deletePublicAccessBlockReturns - fake.recordInvocation("DeletePublicAccessBlock", []interface{}{arg1}) - fake.deletePublicAccessBlockMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeletePublicAccessBlockCallCount() int { - fake.deletePublicAccessBlockMutex.RLock() - defer fake.deletePublicAccessBlockMutex.RUnlock() - return len(fake.deletePublicAccessBlockArgsForCall) -} - -func (fake *FakeS3Client) DeletePublicAccessBlockCalls(stub func(*s3.DeletePublicAccessBlockInput) (*s3.DeletePublicAccessBlockOutput, error)) { - fake.deletePublicAccessBlockMutex.Lock() - defer fake.deletePublicAccessBlockMutex.Unlock() - fake.DeletePublicAccessBlockStub = stub -} - -func (fake *FakeS3Client) DeletePublicAccessBlockArgsForCall(i int) *s3.DeletePublicAccessBlockInput { - fake.deletePublicAccessBlockMutex.RLock() - defer fake.deletePublicAccessBlockMutex.RUnlock() - argsForCall := fake.deletePublicAccessBlockArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeletePublicAccessBlockReturns(result1 *s3.DeletePublicAccessBlockOutput, result2 error) { - fake.deletePublicAccessBlockMutex.Lock() - defer fake.deletePublicAccessBlockMutex.Unlock() - fake.DeletePublicAccessBlockStub = nil - fake.deletePublicAccessBlockReturns = struct { - result1 *s3.DeletePublicAccessBlockOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeletePublicAccessBlockReturnsOnCall(i int, result1 *s3.DeletePublicAccessBlockOutput, result2 error) { - fake.deletePublicAccessBlockMutex.Lock() - defer fake.deletePublicAccessBlockMutex.Unlock() - fake.DeletePublicAccessBlockStub = nil - if fake.deletePublicAccessBlockReturnsOnCall == nil { - fake.deletePublicAccessBlockReturnsOnCall = make(map[int]struct { - result1 *s3.DeletePublicAccessBlockOutput - result2 error - }) - } - fake.deletePublicAccessBlockReturnsOnCall[i] = struct { - result1 *s3.DeletePublicAccessBlockOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeletePublicAccessBlockRequest(arg1 *s3.DeletePublicAccessBlockInput) (*request.Request, *s3.DeletePublicAccessBlockOutput) { - fake.deletePublicAccessBlockRequestMutex.Lock() - ret, specificReturn := fake.deletePublicAccessBlockRequestReturnsOnCall[len(fake.deletePublicAccessBlockRequestArgsForCall)] - fake.deletePublicAccessBlockRequestArgsForCall = append(fake.deletePublicAccessBlockRequestArgsForCall, struct { - arg1 *s3.DeletePublicAccessBlockInput - }{arg1}) - stub := fake.DeletePublicAccessBlockRequestStub - fakeReturns := fake.deletePublicAccessBlockRequestReturns - fake.recordInvocation("DeletePublicAccessBlockRequest", []interface{}{arg1}) - fake.deletePublicAccessBlockRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeletePublicAccessBlockRequestCallCount() int { - fake.deletePublicAccessBlockRequestMutex.RLock() - defer fake.deletePublicAccessBlockRequestMutex.RUnlock() - return len(fake.deletePublicAccessBlockRequestArgsForCall) -} - -func (fake *FakeS3Client) DeletePublicAccessBlockRequestCalls(stub func(*s3.DeletePublicAccessBlockInput) (*request.Request, *s3.DeletePublicAccessBlockOutput)) { - fake.deletePublicAccessBlockRequestMutex.Lock() - defer fake.deletePublicAccessBlockRequestMutex.Unlock() - fake.DeletePublicAccessBlockRequestStub = stub -} - -func (fake *FakeS3Client) DeletePublicAccessBlockRequestArgsForCall(i int) *s3.DeletePublicAccessBlockInput { - fake.deletePublicAccessBlockRequestMutex.RLock() - defer fake.deletePublicAccessBlockRequestMutex.RUnlock() - argsForCall := fake.deletePublicAccessBlockRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) DeletePublicAccessBlockRequestReturns(result1 *request.Request, result2 *s3.DeletePublicAccessBlockOutput) { - fake.deletePublicAccessBlockRequestMutex.Lock() - defer fake.deletePublicAccessBlockRequestMutex.Unlock() - fake.DeletePublicAccessBlockRequestStub = nil - fake.deletePublicAccessBlockRequestReturns = struct { - result1 *request.Request - result2 *s3.DeletePublicAccessBlockOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeletePublicAccessBlockRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.DeletePublicAccessBlockOutput) { - fake.deletePublicAccessBlockRequestMutex.Lock() - defer fake.deletePublicAccessBlockRequestMutex.Unlock() - fake.DeletePublicAccessBlockRequestStub = nil - if fake.deletePublicAccessBlockRequestReturnsOnCall == nil { - fake.deletePublicAccessBlockRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.DeletePublicAccessBlockOutput - }) - } - fake.deletePublicAccessBlockRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.DeletePublicAccessBlockOutput - }{result1, result2} -} - -func (fake *FakeS3Client) DeletePublicAccessBlockWithContext(arg1 context.Context, arg2 *s3.DeletePublicAccessBlockInput, arg3 ...request.Option) (*s3.DeletePublicAccessBlockOutput, error) { - fake.deletePublicAccessBlockWithContextMutex.Lock() - ret, specificReturn := fake.deletePublicAccessBlockWithContextReturnsOnCall[len(fake.deletePublicAccessBlockWithContextArgsForCall)] - fake.deletePublicAccessBlockWithContextArgsForCall = append(fake.deletePublicAccessBlockWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.DeletePublicAccessBlockInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.DeletePublicAccessBlockWithContextStub - fakeReturns := fake.deletePublicAccessBlockWithContextReturns - fake.recordInvocation("DeletePublicAccessBlockWithContext", []interface{}{arg1, arg2, arg3}) - fake.deletePublicAccessBlockWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) DeletePublicAccessBlockWithContextCallCount() int { - fake.deletePublicAccessBlockWithContextMutex.RLock() - defer fake.deletePublicAccessBlockWithContextMutex.RUnlock() - return len(fake.deletePublicAccessBlockWithContextArgsForCall) -} - -func (fake *FakeS3Client) DeletePublicAccessBlockWithContextCalls(stub func(context.Context, *s3.DeletePublicAccessBlockInput, ...request.Option) (*s3.DeletePublicAccessBlockOutput, error)) { - fake.deletePublicAccessBlockWithContextMutex.Lock() - defer fake.deletePublicAccessBlockWithContextMutex.Unlock() - fake.DeletePublicAccessBlockWithContextStub = stub -} - -func (fake *FakeS3Client) DeletePublicAccessBlockWithContextArgsForCall(i int) (context.Context, *s3.DeletePublicAccessBlockInput, []request.Option) { - fake.deletePublicAccessBlockWithContextMutex.RLock() - defer fake.deletePublicAccessBlockWithContextMutex.RUnlock() - argsForCall := fake.deletePublicAccessBlockWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) DeletePublicAccessBlockWithContextReturns(result1 *s3.DeletePublicAccessBlockOutput, result2 error) { - fake.deletePublicAccessBlockWithContextMutex.Lock() - defer fake.deletePublicAccessBlockWithContextMutex.Unlock() - fake.DeletePublicAccessBlockWithContextStub = nil - fake.deletePublicAccessBlockWithContextReturns = struct { - result1 *s3.DeletePublicAccessBlockOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) DeletePublicAccessBlockWithContextReturnsOnCall(i int, result1 *s3.DeletePublicAccessBlockOutput, result2 error) { - fake.deletePublicAccessBlockWithContextMutex.Lock() - defer fake.deletePublicAccessBlockWithContextMutex.Unlock() - fake.DeletePublicAccessBlockWithContextStub = nil - if fake.deletePublicAccessBlockWithContextReturnsOnCall == nil { - fake.deletePublicAccessBlockWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.DeletePublicAccessBlockOutput - result2 error - }) - } - fake.deletePublicAccessBlockWithContextReturnsOnCall[i] = struct { - result1 *s3.DeletePublicAccessBlockOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAccelerateConfiguration(arg1 *s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error) { - fake.getBucketAccelerateConfigurationMutex.Lock() - ret, specificReturn := fake.getBucketAccelerateConfigurationReturnsOnCall[len(fake.getBucketAccelerateConfigurationArgsForCall)] - fake.getBucketAccelerateConfigurationArgsForCall = append(fake.getBucketAccelerateConfigurationArgsForCall, struct { - arg1 *s3.GetBucketAccelerateConfigurationInput - }{arg1}) - stub := fake.GetBucketAccelerateConfigurationStub - fakeReturns := fake.getBucketAccelerateConfigurationReturns - fake.recordInvocation("GetBucketAccelerateConfiguration", []interface{}{arg1}) - fake.getBucketAccelerateConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationCallCount() int { - fake.getBucketAccelerateConfigurationMutex.RLock() - defer fake.getBucketAccelerateConfigurationMutex.RUnlock() - return len(fake.getBucketAccelerateConfigurationArgsForCall) -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationCalls(stub func(*s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error)) { - fake.getBucketAccelerateConfigurationMutex.Lock() - defer fake.getBucketAccelerateConfigurationMutex.Unlock() - fake.GetBucketAccelerateConfigurationStub = stub -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationArgsForCall(i int) *s3.GetBucketAccelerateConfigurationInput { - fake.getBucketAccelerateConfigurationMutex.RLock() - defer fake.getBucketAccelerateConfigurationMutex.RUnlock() - argsForCall := fake.getBucketAccelerateConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationReturns(result1 *s3.GetBucketAccelerateConfigurationOutput, result2 error) { - fake.getBucketAccelerateConfigurationMutex.Lock() - defer fake.getBucketAccelerateConfigurationMutex.Unlock() - fake.GetBucketAccelerateConfigurationStub = nil - fake.getBucketAccelerateConfigurationReturns = struct { - result1 *s3.GetBucketAccelerateConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationReturnsOnCall(i int, result1 *s3.GetBucketAccelerateConfigurationOutput, result2 error) { - fake.getBucketAccelerateConfigurationMutex.Lock() - defer fake.getBucketAccelerateConfigurationMutex.Unlock() - fake.GetBucketAccelerateConfigurationStub = nil - if fake.getBucketAccelerateConfigurationReturnsOnCall == nil { - fake.getBucketAccelerateConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketAccelerateConfigurationOutput - result2 error - }) - } - fake.getBucketAccelerateConfigurationReturnsOnCall[i] = struct { - result1 *s3.GetBucketAccelerateConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationRequest(arg1 *s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput) { - fake.getBucketAccelerateConfigurationRequestMutex.Lock() - ret, specificReturn := fake.getBucketAccelerateConfigurationRequestReturnsOnCall[len(fake.getBucketAccelerateConfigurationRequestArgsForCall)] - fake.getBucketAccelerateConfigurationRequestArgsForCall = append(fake.getBucketAccelerateConfigurationRequestArgsForCall, struct { - arg1 *s3.GetBucketAccelerateConfigurationInput - }{arg1}) - stub := fake.GetBucketAccelerateConfigurationRequestStub - fakeReturns := fake.getBucketAccelerateConfigurationRequestReturns - fake.recordInvocation("GetBucketAccelerateConfigurationRequest", []interface{}{arg1}) - fake.getBucketAccelerateConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationRequestCallCount() int { - fake.getBucketAccelerateConfigurationRequestMutex.RLock() - defer fake.getBucketAccelerateConfigurationRequestMutex.RUnlock() - return len(fake.getBucketAccelerateConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationRequestCalls(stub func(*s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput)) { - fake.getBucketAccelerateConfigurationRequestMutex.Lock() - defer fake.getBucketAccelerateConfigurationRequestMutex.Unlock() - fake.GetBucketAccelerateConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationRequestArgsForCall(i int) *s3.GetBucketAccelerateConfigurationInput { - fake.getBucketAccelerateConfigurationRequestMutex.RLock() - defer fake.getBucketAccelerateConfigurationRequestMutex.RUnlock() - argsForCall := fake.getBucketAccelerateConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationRequestReturns(result1 *request.Request, result2 *s3.GetBucketAccelerateConfigurationOutput) { - fake.getBucketAccelerateConfigurationRequestMutex.Lock() - defer fake.getBucketAccelerateConfigurationRequestMutex.Unlock() - fake.GetBucketAccelerateConfigurationRequestStub = nil - fake.getBucketAccelerateConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketAccelerateConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketAccelerateConfigurationOutput) { - fake.getBucketAccelerateConfigurationRequestMutex.Lock() - defer fake.getBucketAccelerateConfigurationRequestMutex.Unlock() - fake.GetBucketAccelerateConfigurationRequestStub = nil - if fake.getBucketAccelerateConfigurationRequestReturnsOnCall == nil { - fake.getBucketAccelerateConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketAccelerateConfigurationOutput - }) - } - fake.getBucketAccelerateConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketAccelerateConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationWithContext(arg1 context.Context, arg2 *s3.GetBucketAccelerateConfigurationInput, arg3 ...request.Option) (*s3.GetBucketAccelerateConfigurationOutput, error) { - fake.getBucketAccelerateConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.getBucketAccelerateConfigurationWithContextReturnsOnCall[len(fake.getBucketAccelerateConfigurationWithContextArgsForCall)] - fake.getBucketAccelerateConfigurationWithContextArgsForCall = append(fake.getBucketAccelerateConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketAccelerateConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketAccelerateConfigurationWithContextStub - fakeReturns := fake.getBucketAccelerateConfigurationWithContextReturns - fake.recordInvocation("GetBucketAccelerateConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketAccelerateConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationWithContextCallCount() int { - fake.getBucketAccelerateConfigurationWithContextMutex.RLock() - defer fake.getBucketAccelerateConfigurationWithContextMutex.RUnlock() - return len(fake.getBucketAccelerateConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationWithContextCalls(stub func(context.Context, *s3.GetBucketAccelerateConfigurationInput, ...request.Option) (*s3.GetBucketAccelerateConfigurationOutput, error)) { - fake.getBucketAccelerateConfigurationWithContextMutex.Lock() - defer fake.getBucketAccelerateConfigurationWithContextMutex.Unlock() - fake.GetBucketAccelerateConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationWithContextArgsForCall(i int) (context.Context, *s3.GetBucketAccelerateConfigurationInput, []request.Option) { - fake.getBucketAccelerateConfigurationWithContextMutex.RLock() - defer fake.getBucketAccelerateConfigurationWithContextMutex.RUnlock() - argsForCall := fake.getBucketAccelerateConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationWithContextReturns(result1 *s3.GetBucketAccelerateConfigurationOutput, result2 error) { - fake.getBucketAccelerateConfigurationWithContextMutex.Lock() - defer fake.getBucketAccelerateConfigurationWithContextMutex.Unlock() - fake.GetBucketAccelerateConfigurationWithContextStub = nil - fake.getBucketAccelerateConfigurationWithContextReturns = struct { - result1 *s3.GetBucketAccelerateConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAccelerateConfigurationWithContextReturnsOnCall(i int, result1 *s3.GetBucketAccelerateConfigurationOutput, result2 error) { - fake.getBucketAccelerateConfigurationWithContextMutex.Lock() - defer fake.getBucketAccelerateConfigurationWithContextMutex.Unlock() - fake.GetBucketAccelerateConfigurationWithContextStub = nil - if fake.getBucketAccelerateConfigurationWithContextReturnsOnCall == nil { - fake.getBucketAccelerateConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketAccelerateConfigurationOutput - result2 error - }) - } - fake.getBucketAccelerateConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketAccelerateConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAcl(arg1 *s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error) { - fake.getBucketAclMutex.Lock() - ret, specificReturn := fake.getBucketAclReturnsOnCall[len(fake.getBucketAclArgsForCall)] - fake.getBucketAclArgsForCall = append(fake.getBucketAclArgsForCall, struct { - arg1 *s3.GetBucketAclInput - }{arg1}) - stub := fake.GetBucketAclStub - fakeReturns := fake.getBucketAclReturns - fake.recordInvocation("GetBucketAcl", []interface{}{arg1}) - fake.getBucketAclMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketAclCallCount() int { - fake.getBucketAclMutex.RLock() - defer fake.getBucketAclMutex.RUnlock() - return len(fake.getBucketAclArgsForCall) -} - -func (fake *FakeS3Client) GetBucketAclCalls(stub func(*s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error)) { - fake.getBucketAclMutex.Lock() - defer fake.getBucketAclMutex.Unlock() - fake.GetBucketAclStub = stub -} - -func (fake *FakeS3Client) GetBucketAclArgsForCall(i int) *s3.GetBucketAclInput { - fake.getBucketAclMutex.RLock() - defer fake.getBucketAclMutex.RUnlock() - argsForCall := fake.getBucketAclArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketAclReturns(result1 *s3.GetBucketAclOutput, result2 error) { - fake.getBucketAclMutex.Lock() - defer fake.getBucketAclMutex.Unlock() - fake.GetBucketAclStub = nil - fake.getBucketAclReturns = struct { - result1 *s3.GetBucketAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAclReturnsOnCall(i int, result1 *s3.GetBucketAclOutput, result2 error) { - fake.getBucketAclMutex.Lock() - defer fake.getBucketAclMutex.Unlock() - fake.GetBucketAclStub = nil - if fake.getBucketAclReturnsOnCall == nil { - fake.getBucketAclReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketAclOutput - result2 error - }) - } - fake.getBucketAclReturnsOnCall[i] = struct { - result1 *s3.GetBucketAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAclRequest(arg1 *s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput) { - fake.getBucketAclRequestMutex.Lock() - ret, specificReturn := fake.getBucketAclRequestReturnsOnCall[len(fake.getBucketAclRequestArgsForCall)] - fake.getBucketAclRequestArgsForCall = append(fake.getBucketAclRequestArgsForCall, struct { - arg1 *s3.GetBucketAclInput - }{arg1}) - stub := fake.GetBucketAclRequestStub - fakeReturns := fake.getBucketAclRequestReturns - fake.recordInvocation("GetBucketAclRequest", []interface{}{arg1}) - fake.getBucketAclRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketAclRequestCallCount() int { - fake.getBucketAclRequestMutex.RLock() - defer fake.getBucketAclRequestMutex.RUnlock() - return len(fake.getBucketAclRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketAclRequestCalls(stub func(*s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput)) { - fake.getBucketAclRequestMutex.Lock() - defer fake.getBucketAclRequestMutex.Unlock() - fake.GetBucketAclRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketAclRequestArgsForCall(i int) *s3.GetBucketAclInput { - fake.getBucketAclRequestMutex.RLock() - defer fake.getBucketAclRequestMutex.RUnlock() - argsForCall := fake.getBucketAclRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketAclRequestReturns(result1 *request.Request, result2 *s3.GetBucketAclOutput) { - fake.getBucketAclRequestMutex.Lock() - defer fake.getBucketAclRequestMutex.Unlock() - fake.GetBucketAclRequestStub = nil - fake.getBucketAclRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketAclOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAclRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketAclOutput) { - fake.getBucketAclRequestMutex.Lock() - defer fake.getBucketAclRequestMutex.Unlock() - fake.GetBucketAclRequestStub = nil - if fake.getBucketAclRequestReturnsOnCall == nil { - fake.getBucketAclRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketAclOutput - }) - } - fake.getBucketAclRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketAclOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAclWithContext(arg1 context.Context, arg2 *s3.GetBucketAclInput, arg3 ...request.Option) (*s3.GetBucketAclOutput, error) { - fake.getBucketAclWithContextMutex.Lock() - ret, specificReturn := fake.getBucketAclWithContextReturnsOnCall[len(fake.getBucketAclWithContextArgsForCall)] - fake.getBucketAclWithContextArgsForCall = append(fake.getBucketAclWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketAclInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketAclWithContextStub - fakeReturns := fake.getBucketAclWithContextReturns - fake.recordInvocation("GetBucketAclWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketAclWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketAclWithContextCallCount() int { - fake.getBucketAclWithContextMutex.RLock() - defer fake.getBucketAclWithContextMutex.RUnlock() - return len(fake.getBucketAclWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketAclWithContextCalls(stub func(context.Context, *s3.GetBucketAclInput, ...request.Option) (*s3.GetBucketAclOutput, error)) { - fake.getBucketAclWithContextMutex.Lock() - defer fake.getBucketAclWithContextMutex.Unlock() - fake.GetBucketAclWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketAclWithContextArgsForCall(i int) (context.Context, *s3.GetBucketAclInput, []request.Option) { - fake.getBucketAclWithContextMutex.RLock() - defer fake.getBucketAclWithContextMutex.RUnlock() - argsForCall := fake.getBucketAclWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketAclWithContextReturns(result1 *s3.GetBucketAclOutput, result2 error) { - fake.getBucketAclWithContextMutex.Lock() - defer fake.getBucketAclWithContextMutex.Unlock() - fake.GetBucketAclWithContextStub = nil - fake.getBucketAclWithContextReturns = struct { - result1 *s3.GetBucketAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAclWithContextReturnsOnCall(i int, result1 *s3.GetBucketAclOutput, result2 error) { - fake.getBucketAclWithContextMutex.Lock() - defer fake.getBucketAclWithContextMutex.Unlock() - fake.GetBucketAclWithContextStub = nil - if fake.getBucketAclWithContextReturnsOnCall == nil { - fake.getBucketAclWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketAclOutput - result2 error - }) - } - fake.getBucketAclWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfiguration(arg1 *s3.GetBucketAnalyticsConfigurationInput) (*s3.GetBucketAnalyticsConfigurationOutput, error) { - fake.getBucketAnalyticsConfigurationMutex.Lock() - ret, specificReturn := fake.getBucketAnalyticsConfigurationReturnsOnCall[len(fake.getBucketAnalyticsConfigurationArgsForCall)] - fake.getBucketAnalyticsConfigurationArgsForCall = append(fake.getBucketAnalyticsConfigurationArgsForCall, struct { - arg1 *s3.GetBucketAnalyticsConfigurationInput - }{arg1}) - stub := fake.GetBucketAnalyticsConfigurationStub - fakeReturns := fake.getBucketAnalyticsConfigurationReturns - fake.recordInvocation("GetBucketAnalyticsConfiguration", []interface{}{arg1}) - fake.getBucketAnalyticsConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationCallCount() int { - fake.getBucketAnalyticsConfigurationMutex.RLock() - defer fake.getBucketAnalyticsConfigurationMutex.RUnlock() - return len(fake.getBucketAnalyticsConfigurationArgsForCall) -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationCalls(stub func(*s3.GetBucketAnalyticsConfigurationInput) (*s3.GetBucketAnalyticsConfigurationOutput, error)) { - fake.getBucketAnalyticsConfigurationMutex.Lock() - defer fake.getBucketAnalyticsConfigurationMutex.Unlock() - fake.GetBucketAnalyticsConfigurationStub = stub -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationArgsForCall(i int) *s3.GetBucketAnalyticsConfigurationInput { - fake.getBucketAnalyticsConfigurationMutex.RLock() - defer fake.getBucketAnalyticsConfigurationMutex.RUnlock() - argsForCall := fake.getBucketAnalyticsConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationReturns(result1 *s3.GetBucketAnalyticsConfigurationOutput, result2 error) { - fake.getBucketAnalyticsConfigurationMutex.Lock() - defer fake.getBucketAnalyticsConfigurationMutex.Unlock() - fake.GetBucketAnalyticsConfigurationStub = nil - fake.getBucketAnalyticsConfigurationReturns = struct { - result1 *s3.GetBucketAnalyticsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationReturnsOnCall(i int, result1 *s3.GetBucketAnalyticsConfigurationOutput, result2 error) { - fake.getBucketAnalyticsConfigurationMutex.Lock() - defer fake.getBucketAnalyticsConfigurationMutex.Unlock() - fake.GetBucketAnalyticsConfigurationStub = nil - if fake.getBucketAnalyticsConfigurationReturnsOnCall == nil { - fake.getBucketAnalyticsConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketAnalyticsConfigurationOutput - result2 error - }) - } - fake.getBucketAnalyticsConfigurationReturnsOnCall[i] = struct { - result1 *s3.GetBucketAnalyticsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationRequest(arg1 *s3.GetBucketAnalyticsConfigurationInput) (*request.Request, *s3.GetBucketAnalyticsConfigurationOutput) { - fake.getBucketAnalyticsConfigurationRequestMutex.Lock() - ret, specificReturn := fake.getBucketAnalyticsConfigurationRequestReturnsOnCall[len(fake.getBucketAnalyticsConfigurationRequestArgsForCall)] - fake.getBucketAnalyticsConfigurationRequestArgsForCall = append(fake.getBucketAnalyticsConfigurationRequestArgsForCall, struct { - arg1 *s3.GetBucketAnalyticsConfigurationInput - }{arg1}) - stub := fake.GetBucketAnalyticsConfigurationRequestStub - fakeReturns := fake.getBucketAnalyticsConfigurationRequestReturns - fake.recordInvocation("GetBucketAnalyticsConfigurationRequest", []interface{}{arg1}) - fake.getBucketAnalyticsConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationRequestCallCount() int { - fake.getBucketAnalyticsConfigurationRequestMutex.RLock() - defer fake.getBucketAnalyticsConfigurationRequestMutex.RUnlock() - return len(fake.getBucketAnalyticsConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationRequestCalls(stub func(*s3.GetBucketAnalyticsConfigurationInput) (*request.Request, *s3.GetBucketAnalyticsConfigurationOutput)) { - fake.getBucketAnalyticsConfigurationRequestMutex.Lock() - defer fake.getBucketAnalyticsConfigurationRequestMutex.Unlock() - fake.GetBucketAnalyticsConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationRequestArgsForCall(i int) *s3.GetBucketAnalyticsConfigurationInput { - fake.getBucketAnalyticsConfigurationRequestMutex.RLock() - defer fake.getBucketAnalyticsConfigurationRequestMutex.RUnlock() - argsForCall := fake.getBucketAnalyticsConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationRequestReturns(result1 *request.Request, result2 *s3.GetBucketAnalyticsConfigurationOutput) { - fake.getBucketAnalyticsConfigurationRequestMutex.Lock() - defer fake.getBucketAnalyticsConfigurationRequestMutex.Unlock() - fake.GetBucketAnalyticsConfigurationRequestStub = nil - fake.getBucketAnalyticsConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketAnalyticsConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketAnalyticsConfigurationOutput) { - fake.getBucketAnalyticsConfigurationRequestMutex.Lock() - defer fake.getBucketAnalyticsConfigurationRequestMutex.Unlock() - fake.GetBucketAnalyticsConfigurationRequestStub = nil - if fake.getBucketAnalyticsConfigurationRequestReturnsOnCall == nil { - fake.getBucketAnalyticsConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketAnalyticsConfigurationOutput - }) - } - fake.getBucketAnalyticsConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketAnalyticsConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationWithContext(arg1 context.Context, arg2 *s3.GetBucketAnalyticsConfigurationInput, arg3 ...request.Option) (*s3.GetBucketAnalyticsConfigurationOutput, error) { - fake.getBucketAnalyticsConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.getBucketAnalyticsConfigurationWithContextReturnsOnCall[len(fake.getBucketAnalyticsConfigurationWithContextArgsForCall)] - fake.getBucketAnalyticsConfigurationWithContextArgsForCall = append(fake.getBucketAnalyticsConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketAnalyticsConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketAnalyticsConfigurationWithContextStub - fakeReturns := fake.getBucketAnalyticsConfigurationWithContextReturns - fake.recordInvocation("GetBucketAnalyticsConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketAnalyticsConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationWithContextCallCount() int { - fake.getBucketAnalyticsConfigurationWithContextMutex.RLock() - defer fake.getBucketAnalyticsConfigurationWithContextMutex.RUnlock() - return len(fake.getBucketAnalyticsConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationWithContextCalls(stub func(context.Context, *s3.GetBucketAnalyticsConfigurationInput, ...request.Option) (*s3.GetBucketAnalyticsConfigurationOutput, error)) { - fake.getBucketAnalyticsConfigurationWithContextMutex.Lock() - defer fake.getBucketAnalyticsConfigurationWithContextMutex.Unlock() - fake.GetBucketAnalyticsConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationWithContextArgsForCall(i int) (context.Context, *s3.GetBucketAnalyticsConfigurationInput, []request.Option) { - fake.getBucketAnalyticsConfigurationWithContextMutex.RLock() - defer fake.getBucketAnalyticsConfigurationWithContextMutex.RUnlock() - argsForCall := fake.getBucketAnalyticsConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationWithContextReturns(result1 *s3.GetBucketAnalyticsConfigurationOutput, result2 error) { - fake.getBucketAnalyticsConfigurationWithContextMutex.Lock() - defer fake.getBucketAnalyticsConfigurationWithContextMutex.Unlock() - fake.GetBucketAnalyticsConfigurationWithContextStub = nil - fake.getBucketAnalyticsConfigurationWithContextReturns = struct { - result1 *s3.GetBucketAnalyticsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketAnalyticsConfigurationWithContextReturnsOnCall(i int, result1 *s3.GetBucketAnalyticsConfigurationOutput, result2 error) { - fake.getBucketAnalyticsConfigurationWithContextMutex.Lock() - defer fake.getBucketAnalyticsConfigurationWithContextMutex.Unlock() - fake.GetBucketAnalyticsConfigurationWithContextStub = nil - if fake.getBucketAnalyticsConfigurationWithContextReturnsOnCall == nil { - fake.getBucketAnalyticsConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketAnalyticsConfigurationOutput - result2 error - }) - } - fake.getBucketAnalyticsConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketAnalyticsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketCors(arg1 *s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error) { - fake.getBucketCorsMutex.Lock() - ret, specificReturn := fake.getBucketCorsReturnsOnCall[len(fake.getBucketCorsArgsForCall)] - fake.getBucketCorsArgsForCall = append(fake.getBucketCorsArgsForCall, struct { - arg1 *s3.GetBucketCorsInput - }{arg1}) - stub := fake.GetBucketCorsStub - fakeReturns := fake.getBucketCorsReturns - fake.recordInvocation("GetBucketCors", []interface{}{arg1}) - fake.getBucketCorsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketCorsCallCount() int { - fake.getBucketCorsMutex.RLock() - defer fake.getBucketCorsMutex.RUnlock() - return len(fake.getBucketCorsArgsForCall) -} - -func (fake *FakeS3Client) GetBucketCorsCalls(stub func(*s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error)) { - fake.getBucketCorsMutex.Lock() - defer fake.getBucketCorsMutex.Unlock() - fake.GetBucketCorsStub = stub -} - -func (fake *FakeS3Client) GetBucketCorsArgsForCall(i int) *s3.GetBucketCorsInput { - fake.getBucketCorsMutex.RLock() - defer fake.getBucketCorsMutex.RUnlock() - argsForCall := fake.getBucketCorsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketCorsReturns(result1 *s3.GetBucketCorsOutput, result2 error) { - fake.getBucketCorsMutex.Lock() - defer fake.getBucketCorsMutex.Unlock() - fake.GetBucketCorsStub = nil - fake.getBucketCorsReturns = struct { - result1 *s3.GetBucketCorsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketCorsReturnsOnCall(i int, result1 *s3.GetBucketCorsOutput, result2 error) { - fake.getBucketCorsMutex.Lock() - defer fake.getBucketCorsMutex.Unlock() - fake.GetBucketCorsStub = nil - if fake.getBucketCorsReturnsOnCall == nil { - fake.getBucketCorsReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketCorsOutput - result2 error - }) - } - fake.getBucketCorsReturnsOnCall[i] = struct { - result1 *s3.GetBucketCorsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketCorsRequest(arg1 *s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput) { - fake.getBucketCorsRequestMutex.Lock() - ret, specificReturn := fake.getBucketCorsRequestReturnsOnCall[len(fake.getBucketCorsRequestArgsForCall)] - fake.getBucketCorsRequestArgsForCall = append(fake.getBucketCorsRequestArgsForCall, struct { - arg1 *s3.GetBucketCorsInput - }{arg1}) - stub := fake.GetBucketCorsRequestStub - fakeReturns := fake.getBucketCorsRequestReturns - fake.recordInvocation("GetBucketCorsRequest", []interface{}{arg1}) - fake.getBucketCorsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketCorsRequestCallCount() int { - fake.getBucketCorsRequestMutex.RLock() - defer fake.getBucketCorsRequestMutex.RUnlock() - return len(fake.getBucketCorsRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketCorsRequestCalls(stub func(*s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput)) { - fake.getBucketCorsRequestMutex.Lock() - defer fake.getBucketCorsRequestMutex.Unlock() - fake.GetBucketCorsRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketCorsRequestArgsForCall(i int) *s3.GetBucketCorsInput { - fake.getBucketCorsRequestMutex.RLock() - defer fake.getBucketCorsRequestMutex.RUnlock() - argsForCall := fake.getBucketCorsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketCorsRequestReturns(result1 *request.Request, result2 *s3.GetBucketCorsOutput) { - fake.getBucketCorsRequestMutex.Lock() - defer fake.getBucketCorsRequestMutex.Unlock() - fake.GetBucketCorsRequestStub = nil - fake.getBucketCorsRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketCorsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketCorsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketCorsOutput) { - fake.getBucketCorsRequestMutex.Lock() - defer fake.getBucketCorsRequestMutex.Unlock() - fake.GetBucketCorsRequestStub = nil - if fake.getBucketCorsRequestReturnsOnCall == nil { - fake.getBucketCorsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketCorsOutput - }) - } - fake.getBucketCorsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketCorsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketCorsWithContext(arg1 context.Context, arg2 *s3.GetBucketCorsInput, arg3 ...request.Option) (*s3.GetBucketCorsOutput, error) { - fake.getBucketCorsWithContextMutex.Lock() - ret, specificReturn := fake.getBucketCorsWithContextReturnsOnCall[len(fake.getBucketCorsWithContextArgsForCall)] - fake.getBucketCorsWithContextArgsForCall = append(fake.getBucketCorsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketCorsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketCorsWithContextStub - fakeReturns := fake.getBucketCorsWithContextReturns - fake.recordInvocation("GetBucketCorsWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketCorsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketCorsWithContextCallCount() int { - fake.getBucketCorsWithContextMutex.RLock() - defer fake.getBucketCorsWithContextMutex.RUnlock() - return len(fake.getBucketCorsWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketCorsWithContextCalls(stub func(context.Context, *s3.GetBucketCorsInput, ...request.Option) (*s3.GetBucketCorsOutput, error)) { - fake.getBucketCorsWithContextMutex.Lock() - defer fake.getBucketCorsWithContextMutex.Unlock() - fake.GetBucketCorsWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketCorsWithContextArgsForCall(i int) (context.Context, *s3.GetBucketCorsInput, []request.Option) { - fake.getBucketCorsWithContextMutex.RLock() - defer fake.getBucketCorsWithContextMutex.RUnlock() - argsForCall := fake.getBucketCorsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketCorsWithContextReturns(result1 *s3.GetBucketCorsOutput, result2 error) { - fake.getBucketCorsWithContextMutex.Lock() - defer fake.getBucketCorsWithContextMutex.Unlock() - fake.GetBucketCorsWithContextStub = nil - fake.getBucketCorsWithContextReturns = struct { - result1 *s3.GetBucketCorsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketCorsWithContextReturnsOnCall(i int, result1 *s3.GetBucketCorsOutput, result2 error) { - fake.getBucketCorsWithContextMutex.Lock() - defer fake.getBucketCorsWithContextMutex.Unlock() - fake.GetBucketCorsWithContextStub = nil - if fake.getBucketCorsWithContextReturnsOnCall == nil { - fake.getBucketCorsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketCorsOutput - result2 error - }) - } - fake.getBucketCorsWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketCorsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketEncryption(arg1 *s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error) { - fake.getBucketEncryptionMutex.Lock() - ret, specificReturn := fake.getBucketEncryptionReturnsOnCall[len(fake.getBucketEncryptionArgsForCall)] - fake.getBucketEncryptionArgsForCall = append(fake.getBucketEncryptionArgsForCall, struct { - arg1 *s3.GetBucketEncryptionInput - }{arg1}) - stub := fake.GetBucketEncryptionStub - fakeReturns := fake.getBucketEncryptionReturns - fake.recordInvocation("GetBucketEncryption", []interface{}{arg1}) - fake.getBucketEncryptionMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketEncryptionCallCount() int { - fake.getBucketEncryptionMutex.RLock() - defer fake.getBucketEncryptionMutex.RUnlock() - return len(fake.getBucketEncryptionArgsForCall) -} - -func (fake *FakeS3Client) GetBucketEncryptionCalls(stub func(*s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error)) { - fake.getBucketEncryptionMutex.Lock() - defer fake.getBucketEncryptionMutex.Unlock() - fake.GetBucketEncryptionStub = stub -} - -func (fake *FakeS3Client) GetBucketEncryptionArgsForCall(i int) *s3.GetBucketEncryptionInput { - fake.getBucketEncryptionMutex.RLock() - defer fake.getBucketEncryptionMutex.RUnlock() - argsForCall := fake.getBucketEncryptionArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketEncryptionReturns(result1 *s3.GetBucketEncryptionOutput, result2 error) { - fake.getBucketEncryptionMutex.Lock() - defer fake.getBucketEncryptionMutex.Unlock() - fake.GetBucketEncryptionStub = nil - fake.getBucketEncryptionReturns = struct { - result1 *s3.GetBucketEncryptionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketEncryptionReturnsOnCall(i int, result1 *s3.GetBucketEncryptionOutput, result2 error) { - fake.getBucketEncryptionMutex.Lock() - defer fake.getBucketEncryptionMutex.Unlock() - fake.GetBucketEncryptionStub = nil - if fake.getBucketEncryptionReturnsOnCall == nil { - fake.getBucketEncryptionReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketEncryptionOutput - result2 error - }) - } - fake.getBucketEncryptionReturnsOnCall[i] = struct { - result1 *s3.GetBucketEncryptionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketEncryptionRequest(arg1 *s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput) { - fake.getBucketEncryptionRequestMutex.Lock() - ret, specificReturn := fake.getBucketEncryptionRequestReturnsOnCall[len(fake.getBucketEncryptionRequestArgsForCall)] - fake.getBucketEncryptionRequestArgsForCall = append(fake.getBucketEncryptionRequestArgsForCall, struct { - arg1 *s3.GetBucketEncryptionInput - }{arg1}) - stub := fake.GetBucketEncryptionRequestStub - fakeReturns := fake.getBucketEncryptionRequestReturns - fake.recordInvocation("GetBucketEncryptionRequest", []interface{}{arg1}) - fake.getBucketEncryptionRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketEncryptionRequestCallCount() int { - fake.getBucketEncryptionRequestMutex.RLock() - defer fake.getBucketEncryptionRequestMutex.RUnlock() - return len(fake.getBucketEncryptionRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketEncryptionRequestCalls(stub func(*s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput)) { - fake.getBucketEncryptionRequestMutex.Lock() - defer fake.getBucketEncryptionRequestMutex.Unlock() - fake.GetBucketEncryptionRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketEncryptionRequestArgsForCall(i int) *s3.GetBucketEncryptionInput { - fake.getBucketEncryptionRequestMutex.RLock() - defer fake.getBucketEncryptionRequestMutex.RUnlock() - argsForCall := fake.getBucketEncryptionRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketEncryptionRequestReturns(result1 *request.Request, result2 *s3.GetBucketEncryptionOutput) { - fake.getBucketEncryptionRequestMutex.Lock() - defer fake.getBucketEncryptionRequestMutex.Unlock() - fake.GetBucketEncryptionRequestStub = nil - fake.getBucketEncryptionRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketEncryptionOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketEncryptionRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketEncryptionOutput) { - fake.getBucketEncryptionRequestMutex.Lock() - defer fake.getBucketEncryptionRequestMutex.Unlock() - fake.GetBucketEncryptionRequestStub = nil - if fake.getBucketEncryptionRequestReturnsOnCall == nil { - fake.getBucketEncryptionRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketEncryptionOutput - }) - } - fake.getBucketEncryptionRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketEncryptionOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketEncryptionWithContext(arg1 context.Context, arg2 *s3.GetBucketEncryptionInput, arg3 ...request.Option) (*s3.GetBucketEncryptionOutput, error) { - fake.getBucketEncryptionWithContextMutex.Lock() - ret, specificReturn := fake.getBucketEncryptionWithContextReturnsOnCall[len(fake.getBucketEncryptionWithContextArgsForCall)] - fake.getBucketEncryptionWithContextArgsForCall = append(fake.getBucketEncryptionWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketEncryptionInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketEncryptionWithContextStub - fakeReturns := fake.getBucketEncryptionWithContextReturns - fake.recordInvocation("GetBucketEncryptionWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketEncryptionWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketEncryptionWithContextCallCount() int { - fake.getBucketEncryptionWithContextMutex.RLock() - defer fake.getBucketEncryptionWithContextMutex.RUnlock() - return len(fake.getBucketEncryptionWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketEncryptionWithContextCalls(stub func(context.Context, *s3.GetBucketEncryptionInput, ...request.Option) (*s3.GetBucketEncryptionOutput, error)) { - fake.getBucketEncryptionWithContextMutex.Lock() - defer fake.getBucketEncryptionWithContextMutex.Unlock() - fake.GetBucketEncryptionWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketEncryptionWithContextArgsForCall(i int) (context.Context, *s3.GetBucketEncryptionInput, []request.Option) { - fake.getBucketEncryptionWithContextMutex.RLock() - defer fake.getBucketEncryptionWithContextMutex.RUnlock() - argsForCall := fake.getBucketEncryptionWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketEncryptionWithContextReturns(result1 *s3.GetBucketEncryptionOutput, result2 error) { - fake.getBucketEncryptionWithContextMutex.Lock() - defer fake.getBucketEncryptionWithContextMutex.Unlock() - fake.GetBucketEncryptionWithContextStub = nil - fake.getBucketEncryptionWithContextReturns = struct { - result1 *s3.GetBucketEncryptionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketEncryptionWithContextReturnsOnCall(i int, result1 *s3.GetBucketEncryptionOutput, result2 error) { - fake.getBucketEncryptionWithContextMutex.Lock() - defer fake.getBucketEncryptionWithContextMutex.Unlock() - fake.GetBucketEncryptionWithContextStub = nil - if fake.getBucketEncryptionWithContextReturnsOnCall == nil { - fake.getBucketEncryptionWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketEncryptionOutput - result2 error - }) - } - fake.getBucketEncryptionWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketEncryptionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfiguration(arg1 *s3.GetBucketIntelligentTieringConfigurationInput) (*s3.GetBucketIntelligentTieringConfigurationOutput, error) { - fake.getBucketIntelligentTieringConfigurationMutex.Lock() - ret, specificReturn := fake.getBucketIntelligentTieringConfigurationReturnsOnCall[len(fake.getBucketIntelligentTieringConfigurationArgsForCall)] - fake.getBucketIntelligentTieringConfigurationArgsForCall = append(fake.getBucketIntelligentTieringConfigurationArgsForCall, struct { - arg1 *s3.GetBucketIntelligentTieringConfigurationInput - }{arg1}) - stub := fake.GetBucketIntelligentTieringConfigurationStub - fakeReturns := fake.getBucketIntelligentTieringConfigurationReturns - fake.recordInvocation("GetBucketIntelligentTieringConfiguration", []interface{}{arg1}) - fake.getBucketIntelligentTieringConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationCallCount() int { - fake.getBucketIntelligentTieringConfigurationMutex.RLock() - defer fake.getBucketIntelligentTieringConfigurationMutex.RUnlock() - return len(fake.getBucketIntelligentTieringConfigurationArgsForCall) -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationCalls(stub func(*s3.GetBucketIntelligentTieringConfigurationInput) (*s3.GetBucketIntelligentTieringConfigurationOutput, error)) { - fake.getBucketIntelligentTieringConfigurationMutex.Lock() - defer fake.getBucketIntelligentTieringConfigurationMutex.Unlock() - fake.GetBucketIntelligentTieringConfigurationStub = stub -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationArgsForCall(i int) *s3.GetBucketIntelligentTieringConfigurationInput { - fake.getBucketIntelligentTieringConfigurationMutex.RLock() - defer fake.getBucketIntelligentTieringConfigurationMutex.RUnlock() - argsForCall := fake.getBucketIntelligentTieringConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationReturns(result1 *s3.GetBucketIntelligentTieringConfigurationOutput, result2 error) { - fake.getBucketIntelligentTieringConfigurationMutex.Lock() - defer fake.getBucketIntelligentTieringConfigurationMutex.Unlock() - fake.GetBucketIntelligentTieringConfigurationStub = nil - fake.getBucketIntelligentTieringConfigurationReturns = struct { - result1 *s3.GetBucketIntelligentTieringConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationReturnsOnCall(i int, result1 *s3.GetBucketIntelligentTieringConfigurationOutput, result2 error) { - fake.getBucketIntelligentTieringConfigurationMutex.Lock() - defer fake.getBucketIntelligentTieringConfigurationMutex.Unlock() - fake.GetBucketIntelligentTieringConfigurationStub = nil - if fake.getBucketIntelligentTieringConfigurationReturnsOnCall == nil { - fake.getBucketIntelligentTieringConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketIntelligentTieringConfigurationOutput - result2 error - }) - } - fake.getBucketIntelligentTieringConfigurationReturnsOnCall[i] = struct { - result1 *s3.GetBucketIntelligentTieringConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationRequest(arg1 *s3.GetBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.GetBucketIntelligentTieringConfigurationOutput) { - fake.getBucketIntelligentTieringConfigurationRequestMutex.Lock() - ret, specificReturn := fake.getBucketIntelligentTieringConfigurationRequestReturnsOnCall[len(fake.getBucketIntelligentTieringConfigurationRequestArgsForCall)] - fake.getBucketIntelligentTieringConfigurationRequestArgsForCall = append(fake.getBucketIntelligentTieringConfigurationRequestArgsForCall, struct { - arg1 *s3.GetBucketIntelligentTieringConfigurationInput - }{arg1}) - stub := fake.GetBucketIntelligentTieringConfigurationRequestStub - fakeReturns := fake.getBucketIntelligentTieringConfigurationRequestReturns - fake.recordInvocation("GetBucketIntelligentTieringConfigurationRequest", []interface{}{arg1}) - fake.getBucketIntelligentTieringConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationRequestCallCount() int { - fake.getBucketIntelligentTieringConfigurationRequestMutex.RLock() - defer fake.getBucketIntelligentTieringConfigurationRequestMutex.RUnlock() - return len(fake.getBucketIntelligentTieringConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationRequestCalls(stub func(*s3.GetBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.GetBucketIntelligentTieringConfigurationOutput)) { - fake.getBucketIntelligentTieringConfigurationRequestMutex.Lock() - defer fake.getBucketIntelligentTieringConfigurationRequestMutex.Unlock() - fake.GetBucketIntelligentTieringConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationRequestArgsForCall(i int) *s3.GetBucketIntelligentTieringConfigurationInput { - fake.getBucketIntelligentTieringConfigurationRequestMutex.RLock() - defer fake.getBucketIntelligentTieringConfigurationRequestMutex.RUnlock() - argsForCall := fake.getBucketIntelligentTieringConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationRequestReturns(result1 *request.Request, result2 *s3.GetBucketIntelligentTieringConfigurationOutput) { - fake.getBucketIntelligentTieringConfigurationRequestMutex.Lock() - defer fake.getBucketIntelligentTieringConfigurationRequestMutex.Unlock() - fake.GetBucketIntelligentTieringConfigurationRequestStub = nil - fake.getBucketIntelligentTieringConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketIntelligentTieringConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketIntelligentTieringConfigurationOutput) { - fake.getBucketIntelligentTieringConfigurationRequestMutex.Lock() - defer fake.getBucketIntelligentTieringConfigurationRequestMutex.Unlock() - fake.GetBucketIntelligentTieringConfigurationRequestStub = nil - if fake.getBucketIntelligentTieringConfigurationRequestReturnsOnCall == nil { - fake.getBucketIntelligentTieringConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketIntelligentTieringConfigurationOutput - }) - } - fake.getBucketIntelligentTieringConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketIntelligentTieringConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationWithContext(arg1 context.Context, arg2 *s3.GetBucketIntelligentTieringConfigurationInput, arg3 ...request.Option) (*s3.GetBucketIntelligentTieringConfigurationOutput, error) { - fake.getBucketIntelligentTieringConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.getBucketIntelligentTieringConfigurationWithContextReturnsOnCall[len(fake.getBucketIntelligentTieringConfigurationWithContextArgsForCall)] - fake.getBucketIntelligentTieringConfigurationWithContextArgsForCall = append(fake.getBucketIntelligentTieringConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketIntelligentTieringConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketIntelligentTieringConfigurationWithContextStub - fakeReturns := fake.getBucketIntelligentTieringConfigurationWithContextReturns - fake.recordInvocation("GetBucketIntelligentTieringConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketIntelligentTieringConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationWithContextCallCount() int { - fake.getBucketIntelligentTieringConfigurationWithContextMutex.RLock() - defer fake.getBucketIntelligentTieringConfigurationWithContextMutex.RUnlock() - return len(fake.getBucketIntelligentTieringConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationWithContextCalls(stub func(context.Context, *s3.GetBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.GetBucketIntelligentTieringConfigurationOutput, error)) { - fake.getBucketIntelligentTieringConfigurationWithContextMutex.Lock() - defer fake.getBucketIntelligentTieringConfigurationWithContextMutex.Unlock() - fake.GetBucketIntelligentTieringConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationWithContextArgsForCall(i int) (context.Context, *s3.GetBucketIntelligentTieringConfigurationInput, []request.Option) { - fake.getBucketIntelligentTieringConfigurationWithContextMutex.RLock() - defer fake.getBucketIntelligentTieringConfigurationWithContextMutex.RUnlock() - argsForCall := fake.getBucketIntelligentTieringConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationWithContextReturns(result1 *s3.GetBucketIntelligentTieringConfigurationOutput, result2 error) { - fake.getBucketIntelligentTieringConfigurationWithContextMutex.Lock() - defer fake.getBucketIntelligentTieringConfigurationWithContextMutex.Unlock() - fake.GetBucketIntelligentTieringConfigurationWithContextStub = nil - fake.getBucketIntelligentTieringConfigurationWithContextReturns = struct { - result1 *s3.GetBucketIntelligentTieringConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketIntelligentTieringConfigurationWithContextReturnsOnCall(i int, result1 *s3.GetBucketIntelligentTieringConfigurationOutput, result2 error) { - fake.getBucketIntelligentTieringConfigurationWithContextMutex.Lock() - defer fake.getBucketIntelligentTieringConfigurationWithContextMutex.Unlock() - fake.GetBucketIntelligentTieringConfigurationWithContextStub = nil - if fake.getBucketIntelligentTieringConfigurationWithContextReturnsOnCall == nil { - fake.getBucketIntelligentTieringConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketIntelligentTieringConfigurationOutput - result2 error - }) - } - fake.getBucketIntelligentTieringConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketIntelligentTieringConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketInventoryConfiguration(arg1 *s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error) { - fake.getBucketInventoryConfigurationMutex.Lock() - ret, specificReturn := fake.getBucketInventoryConfigurationReturnsOnCall[len(fake.getBucketInventoryConfigurationArgsForCall)] - fake.getBucketInventoryConfigurationArgsForCall = append(fake.getBucketInventoryConfigurationArgsForCall, struct { - arg1 *s3.GetBucketInventoryConfigurationInput - }{arg1}) - stub := fake.GetBucketInventoryConfigurationStub - fakeReturns := fake.getBucketInventoryConfigurationReturns - fake.recordInvocation("GetBucketInventoryConfiguration", []interface{}{arg1}) - fake.getBucketInventoryConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationCallCount() int { - fake.getBucketInventoryConfigurationMutex.RLock() - defer fake.getBucketInventoryConfigurationMutex.RUnlock() - return len(fake.getBucketInventoryConfigurationArgsForCall) -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationCalls(stub func(*s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error)) { - fake.getBucketInventoryConfigurationMutex.Lock() - defer fake.getBucketInventoryConfigurationMutex.Unlock() - fake.GetBucketInventoryConfigurationStub = stub -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationArgsForCall(i int) *s3.GetBucketInventoryConfigurationInput { - fake.getBucketInventoryConfigurationMutex.RLock() - defer fake.getBucketInventoryConfigurationMutex.RUnlock() - argsForCall := fake.getBucketInventoryConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationReturns(result1 *s3.GetBucketInventoryConfigurationOutput, result2 error) { - fake.getBucketInventoryConfigurationMutex.Lock() - defer fake.getBucketInventoryConfigurationMutex.Unlock() - fake.GetBucketInventoryConfigurationStub = nil - fake.getBucketInventoryConfigurationReturns = struct { - result1 *s3.GetBucketInventoryConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationReturnsOnCall(i int, result1 *s3.GetBucketInventoryConfigurationOutput, result2 error) { - fake.getBucketInventoryConfigurationMutex.Lock() - defer fake.getBucketInventoryConfigurationMutex.Unlock() - fake.GetBucketInventoryConfigurationStub = nil - if fake.getBucketInventoryConfigurationReturnsOnCall == nil { - fake.getBucketInventoryConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketInventoryConfigurationOutput - result2 error - }) - } - fake.getBucketInventoryConfigurationReturnsOnCall[i] = struct { - result1 *s3.GetBucketInventoryConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationRequest(arg1 *s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput) { - fake.getBucketInventoryConfigurationRequestMutex.Lock() - ret, specificReturn := fake.getBucketInventoryConfigurationRequestReturnsOnCall[len(fake.getBucketInventoryConfigurationRequestArgsForCall)] - fake.getBucketInventoryConfigurationRequestArgsForCall = append(fake.getBucketInventoryConfigurationRequestArgsForCall, struct { - arg1 *s3.GetBucketInventoryConfigurationInput - }{arg1}) - stub := fake.GetBucketInventoryConfigurationRequestStub - fakeReturns := fake.getBucketInventoryConfigurationRequestReturns - fake.recordInvocation("GetBucketInventoryConfigurationRequest", []interface{}{arg1}) - fake.getBucketInventoryConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationRequestCallCount() int { - fake.getBucketInventoryConfigurationRequestMutex.RLock() - defer fake.getBucketInventoryConfigurationRequestMutex.RUnlock() - return len(fake.getBucketInventoryConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationRequestCalls(stub func(*s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput)) { - fake.getBucketInventoryConfigurationRequestMutex.Lock() - defer fake.getBucketInventoryConfigurationRequestMutex.Unlock() - fake.GetBucketInventoryConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationRequestArgsForCall(i int) *s3.GetBucketInventoryConfigurationInput { - fake.getBucketInventoryConfigurationRequestMutex.RLock() - defer fake.getBucketInventoryConfigurationRequestMutex.RUnlock() - argsForCall := fake.getBucketInventoryConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationRequestReturns(result1 *request.Request, result2 *s3.GetBucketInventoryConfigurationOutput) { - fake.getBucketInventoryConfigurationRequestMutex.Lock() - defer fake.getBucketInventoryConfigurationRequestMutex.Unlock() - fake.GetBucketInventoryConfigurationRequestStub = nil - fake.getBucketInventoryConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketInventoryConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketInventoryConfigurationOutput) { - fake.getBucketInventoryConfigurationRequestMutex.Lock() - defer fake.getBucketInventoryConfigurationRequestMutex.Unlock() - fake.GetBucketInventoryConfigurationRequestStub = nil - if fake.getBucketInventoryConfigurationRequestReturnsOnCall == nil { - fake.getBucketInventoryConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketInventoryConfigurationOutput - }) - } - fake.getBucketInventoryConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketInventoryConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationWithContext(arg1 context.Context, arg2 *s3.GetBucketInventoryConfigurationInput, arg3 ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error) { - fake.getBucketInventoryConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.getBucketInventoryConfigurationWithContextReturnsOnCall[len(fake.getBucketInventoryConfigurationWithContextArgsForCall)] - fake.getBucketInventoryConfigurationWithContextArgsForCall = append(fake.getBucketInventoryConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketInventoryConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketInventoryConfigurationWithContextStub - fakeReturns := fake.getBucketInventoryConfigurationWithContextReturns - fake.recordInvocation("GetBucketInventoryConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketInventoryConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationWithContextCallCount() int { - fake.getBucketInventoryConfigurationWithContextMutex.RLock() - defer fake.getBucketInventoryConfigurationWithContextMutex.RUnlock() - return len(fake.getBucketInventoryConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationWithContextCalls(stub func(context.Context, *s3.GetBucketInventoryConfigurationInput, ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error)) { - fake.getBucketInventoryConfigurationWithContextMutex.Lock() - defer fake.getBucketInventoryConfigurationWithContextMutex.Unlock() - fake.GetBucketInventoryConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationWithContextArgsForCall(i int) (context.Context, *s3.GetBucketInventoryConfigurationInput, []request.Option) { - fake.getBucketInventoryConfigurationWithContextMutex.RLock() - defer fake.getBucketInventoryConfigurationWithContextMutex.RUnlock() - argsForCall := fake.getBucketInventoryConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationWithContextReturns(result1 *s3.GetBucketInventoryConfigurationOutput, result2 error) { - fake.getBucketInventoryConfigurationWithContextMutex.Lock() - defer fake.getBucketInventoryConfigurationWithContextMutex.Unlock() - fake.GetBucketInventoryConfigurationWithContextStub = nil - fake.getBucketInventoryConfigurationWithContextReturns = struct { - result1 *s3.GetBucketInventoryConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketInventoryConfigurationWithContextReturnsOnCall(i int, result1 *s3.GetBucketInventoryConfigurationOutput, result2 error) { - fake.getBucketInventoryConfigurationWithContextMutex.Lock() - defer fake.getBucketInventoryConfigurationWithContextMutex.Unlock() - fake.GetBucketInventoryConfigurationWithContextStub = nil - if fake.getBucketInventoryConfigurationWithContextReturnsOnCall == nil { - fake.getBucketInventoryConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketInventoryConfigurationOutput - result2 error - }) - } - fake.getBucketInventoryConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketInventoryConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLifecycle(arg1 *s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error) { - fake.getBucketLifecycleMutex.Lock() - ret, specificReturn := fake.getBucketLifecycleReturnsOnCall[len(fake.getBucketLifecycleArgsForCall)] - fake.getBucketLifecycleArgsForCall = append(fake.getBucketLifecycleArgsForCall, struct { - arg1 *s3.GetBucketLifecycleInput - }{arg1}) - stub := fake.GetBucketLifecycleStub - fakeReturns := fake.getBucketLifecycleReturns - fake.recordInvocation("GetBucketLifecycle", []interface{}{arg1}) - fake.getBucketLifecycleMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketLifecycleCallCount() int { - fake.getBucketLifecycleMutex.RLock() - defer fake.getBucketLifecycleMutex.RUnlock() - return len(fake.getBucketLifecycleArgsForCall) -} - -func (fake *FakeS3Client) GetBucketLifecycleCalls(stub func(*s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error)) { - fake.getBucketLifecycleMutex.Lock() - defer fake.getBucketLifecycleMutex.Unlock() - fake.GetBucketLifecycleStub = stub -} - -func (fake *FakeS3Client) GetBucketLifecycleArgsForCall(i int) *s3.GetBucketLifecycleInput { - fake.getBucketLifecycleMutex.RLock() - defer fake.getBucketLifecycleMutex.RUnlock() - argsForCall := fake.getBucketLifecycleArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketLifecycleReturns(result1 *s3.GetBucketLifecycleOutput, result2 error) { - fake.getBucketLifecycleMutex.Lock() - defer fake.getBucketLifecycleMutex.Unlock() - fake.GetBucketLifecycleStub = nil - fake.getBucketLifecycleReturns = struct { - result1 *s3.GetBucketLifecycleOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLifecycleReturnsOnCall(i int, result1 *s3.GetBucketLifecycleOutput, result2 error) { - fake.getBucketLifecycleMutex.Lock() - defer fake.getBucketLifecycleMutex.Unlock() - fake.GetBucketLifecycleStub = nil - if fake.getBucketLifecycleReturnsOnCall == nil { - fake.getBucketLifecycleReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketLifecycleOutput - result2 error - }) - } - fake.getBucketLifecycleReturnsOnCall[i] = struct { - result1 *s3.GetBucketLifecycleOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLifecycleConfiguration(arg1 *s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error) { - fake.getBucketLifecycleConfigurationMutex.Lock() - ret, specificReturn := fake.getBucketLifecycleConfigurationReturnsOnCall[len(fake.getBucketLifecycleConfigurationArgsForCall)] - fake.getBucketLifecycleConfigurationArgsForCall = append(fake.getBucketLifecycleConfigurationArgsForCall, struct { - arg1 *s3.GetBucketLifecycleConfigurationInput - }{arg1}) - stub := fake.GetBucketLifecycleConfigurationStub - fakeReturns := fake.getBucketLifecycleConfigurationReturns - fake.recordInvocation("GetBucketLifecycleConfiguration", []interface{}{arg1}) - fake.getBucketLifecycleConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationCallCount() int { - fake.getBucketLifecycleConfigurationMutex.RLock() - defer fake.getBucketLifecycleConfigurationMutex.RUnlock() - return len(fake.getBucketLifecycleConfigurationArgsForCall) -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationCalls(stub func(*s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error)) { - fake.getBucketLifecycleConfigurationMutex.Lock() - defer fake.getBucketLifecycleConfigurationMutex.Unlock() - fake.GetBucketLifecycleConfigurationStub = stub -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationArgsForCall(i int) *s3.GetBucketLifecycleConfigurationInput { - fake.getBucketLifecycleConfigurationMutex.RLock() - defer fake.getBucketLifecycleConfigurationMutex.RUnlock() - argsForCall := fake.getBucketLifecycleConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationReturns(result1 *s3.GetBucketLifecycleConfigurationOutput, result2 error) { - fake.getBucketLifecycleConfigurationMutex.Lock() - defer fake.getBucketLifecycleConfigurationMutex.Unlock() - fake.GetBucketLifecycleConfigurationStub = nil - fake.getBucketLifecycleConfigurationReturns = struct { - result1 *s3.GetBucketLifecycleConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationReturnsOnCall(i int, result1 *s3.GetBucketLifecycleConfigurationOutput, result2 error) { - fake.getBucketLifecycleConfigurationMutex.Lock() - defer fake.getBucketLifecycleConfigurationMutex.Unlock() - fake.GetBucketLifecycleConfigurationStub = nil - if fake.getBucketLifecycleConfigurationReturnsOnCall == nil { - fake.getBucketLifecycleConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketLifecycleConfigurationOutput - result2 error - }) - } - fake.getBucketLifecycleConfigurationReturnsOnCall[i] = struct { - result1 *s3.GetBucketLifecycleConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationRequest(arg1 *s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput) { - fake.getBucketLifecycleConfigurationRequestMutex.Lock() - ret, specificReturn := fake.getBucketLifecycleConfigurationRequestReturnsOnCall[len(fake.getBucketLifecycleConfigurationRequestArgsForCall)] - fake.getBucketLifecycleConfigurationRequestArgsForCall = append(fake.getBucketLifecycleConfigurationRequestArgsForCall, struct { - arg1 *s3.GetBucketLifecycleConfigurationInput - }{arg1}) - stub := fake.GetBucketLifecycleConfigurationRequestStub - fakeReturns := fake.getBucketLifecycleConfigurationRequestReturns - fake.recordInvocation("GetBucketLifecycleConfigurationRequest", []interface{}{arg1}) - fake.getBucketLifecycleConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationRequestCallCount() int { - fake.getBucketLifecycleConfigurationRequestMutex.RLock() - defer fake.getBucketLifecycleConfigurationRequestMutex.RUnlock() - return len(fake.getBucketLifecycleConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationRequestCalls(stub func(*s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput)) { - fake.getBucketLifecycleConfigurationRequestMutex.Lock() - defer fake.getBucketLifecycleConfigurationRequestMutex.Unlock() - fake.GetBucketLifecycleConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationRequestArgsForCall(i int) *s3.GetBucketLifecycleConfigurationInput { - fake.getBucketLifecycleConfigurationRequestMutex.RLock() - defer fake.getBucketLifecycleConfigurationRequestMutex.RUnlock() - argsForCall := fake.getBucketLifecycleConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationRequestReturns(result1 *request.Request, result2 *s3.GetBucketLifecycleConfigurationOutput) { - fake.getBucketLifecycleConfigurationRequestMutex.Lock() - defer fake.getBucketLifecycleConfigurationRequestMutex.Unlock() - fake.GetBucketLifecycleConfigurationRequestStub = nil - fake.getBucketLifecycleConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketLifecycleConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketLifecycleConfigurationOutput) { - fake.getBucketLifecycleConfigurationRequestMutex.Lock() - defer fake.getBucketLifecycleConfigurationRequestMutex.Unlock() - fake.GetBucketLifecycleConfigurationRequestStub = nil - if fake.getBucketLifecycleConfigurationRequestReturnsOnCall == nil { - fake.getBucketLifecycleConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketLifecycleConfigurationOutput - }) - } - fake.getBucketLifecycleConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketLifecycleConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationWithContext(arg1 context.Context, arg2 *s3.GetBucketLifecycleConfigurationInput, arg3 ...request.Option) (*s3.GetBucketLifecycleConfigurationOutput, error) { - fake.getBucketLifecycleConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.getBucketLifecycleConfigurationWithContextReturnsOnCall[len(fake.getBucketLifecycleConfigurationWithContextArgsForCall)] - fake.getBucketLifecycleConfigurationWithContextArgsForCall = append(fake.getBucketLifecycleConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketLifecycleConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketLifecycleConfigurationWithContextStub - fakeReturns := fake.getBucketLifecycleConfigurationWithContextReturns - fake.recordInvocation("GetBucketLifecycleConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketLifecycleConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationWithContextCallCount() int { - fake.getBucketLifecycleConfigurationWithContextMutex.RLock() - defer fake.getBucketLifecycleConfigurationWithContextMutex.RUnlock() - return len(fake.getBucketLifecycleConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationWithContextCalls(stub func(context.Context, *s3.GetBucketLifecycleConfigurationInput, ...request.Option) (*s3.GetBucketLifecycleConfigurationOutput, error)) { - fake.getBucketLifecycleConfigurationWithContextMutex.Lock() - defer fake.getBucketLifecycleConfigurationWithContextMutex.Unlock() - fake.GetBucketLifecycleConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationWithContextArgsForCall(i int) (context.Context, *s3.GetBucketLifecycleConfigurationInput, []request.Option) { - fake.getBucketLifecycleConfigurationWithContextMutex.RLock() - defer fake.getBucketLifecycleConfigurationWithContextMutex.RUnlock() - argsForCall := fake.getBucketLifecycleConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationWithContextReturns(result1 *s3.GetBucketLifecycleConfigurationOutput, result2 error) { - fake.getBucketLifecycleConfigurationWithContextMutex.Lock() - defer fake.getBucketLifecycleConfigurationWithContextMutex.Unlock() - fake.GetBucketLifecycleConfigurationWithContextStub = nil - fake.getBucketLifecycleConfigurationWithContextReturns = struct { - result1 *s3.GetBucketLifecycleConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLifecycleConfigurationWithContextReturnsOnCall(i int, result1 *s3.GetBucketLifecycleConfigurationOutput, result2 error) { - fake.getBucketLifecycleConfigurationWithContextMutex.Lock() - defer fake.getBucketLifecycleConfigurationWithContextMutex.Unlock() - fake.GetBucketLifecycleConfigurationWithContextStub = nil - if fake.getBucketLifecycleConfigurationWithContextReturnsOnCall == nil { - fake.getBucketLifecycleConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketLifecycleConfigurationOutput - result2 error - }) - } - fake.getBucketLifecycleConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketLifecycleConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLifecycleRequest(arg1 *s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput) { - fake.getBucketLifecycleRequestMutex.Lock() - ret, specificReturn := fake.getBucketLifecycleRequestReturnsOnCall[len(fake.getBucketLifecycleRequestArgsForCall)] - fake.getBucketLifecycleRequestArgsForCall = append(fake.getBucketLifecycleRequestArgsForCall, struct { - arg1 *s3.GetBucketLifecycleInput - }{arg1}) - stub := fake.GetBucketLifecycleRequestStub - fakeReturns := fake.getBucketLifecycleRequestReturns - fake.recordInvocation("GetBucketLifecycleRequest", []interface{}{arg1}) - fake.getBucketLifecycleRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketLifecycleRequestCallCount() int { - fake.getBucketLifecycleRequestMutex.RLock() - defer fake.getBucketLifecycleRequestMutex.RUnlock() - return len(fake.getBucketLifecycleRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketLifecycleRequestCalls(stub func(*s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput)) { - fake.getBucketLifecycleRequestMutex.Lock() - defer fake.getBucketLifecycleRequestMutex.Unlock() - fake.GetBucketLifecycleRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketLifecycleRequestArgsForCall(i int) *s3.GetBucketLifecycleInput { - fake.getBucketLifecycleRequestMutex.RLock() - defer fake.getBucketLifecycleRequestMutex.RUnlock() - argsForCall := fake.getBucketLifecycleRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketLifecycleRequestReturns(result1 *request.Request, result2 *s3.GetBucketLifecycleOutput) { - fake.getBucketLifecycleRequestMutex.Lock() - defer fake.getBucketLifecycleRequestMutex.Unlock() - fake.GetBucketLifecycleRequestStub = nil - fake.getBucketLifecycleRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketLifecycleOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLifecycleRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketLifecycleOutput) { - fake.getBucketLifecycleRequestMutex.Lock() - defer fake.getBucketLifecycleRequestMutex.Unlock() - fake.GetBucketLifecycleRequestStub = nil - if fake.getBucketLifecycleRequestReturnsOnCall == nil { - fake.getBucketLifecycleRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketLifecycleOutput - }) - } - fake.getBucketLifecycleRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketLifecycleOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLifecycleWithContext(arg1 context.Context, arg2 *s3.GetBucketLifecycleInput, arg3 ...request.Option) (*s3.GetBucketLifecycleOutput, error) { - fake.getBucketLifecycleWithContextMutex.Lock() - ret, specificReturn := fake.getBucketLifecycleWithContextReturnsOnCall[len(fake.getBucketLifecycleWithContextArgsForCall)] - fake.getBucketLifecycleWithContextArgsForCall = append(fake.getBucketLifecycleWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketLifecycleInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketLifecycleWithContextStub - fakeReturns := fake.getBucketLifecycleWithContextReturns - fake.recordInvocation("GetBucketLifecycleWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketLifecycleWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketLifecycleWithContextCallCount() int { - fake.getBucketLifecycleWithContextMutex.RLock() - defer fake.getBucketLifecycleWithContextMutex.RUnlock() - return len(fake.getBucketLifecycleWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketLifecycleWithContextCalls(stub func(context.Context, *s3.GetBucketLifecycleInput, ...request.Option) (*s3.GetBucketLifecycleOutput, error)) { - fake.getBucketLifecycleWithContextMutex.Lock() - defer fake.getBucketLifecycleWithContextMutex.Unlock() - fake.GetBucketLifecycleWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketLifecycleWithContextArgsForCall(i int) (context.Context, *s3.GetBucketLifecycleInput, []request.Option) { - fake.getBucketLifecycleWithContextMutex.RLock() - defer fake.getBucketLifecycleWithContextMutex.RUnlock() - argsForCall := fake.getBucketLifecycleWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketLifecycleWithContextReturns(result1 *s3.GetBucketLifecycleOutput, result2 error) { - fake.getBucketLifecycleWithContextMutex.Lock() - defer fake.getBucketLifecycleWithContextMutex.Unlock() - fake.GetBucketLifecycleWithContextStub = nil - fake.getBucketLifecycleWithContextReturns = struct { - result1 *s3.GetBucketLifecycleOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLifecycleWithContextReturnsOnCall(i int, result1 *s3.GetBucketLifecycleOutput, result2 error) { - fake.getBucketLifecycleWithContextMutex.Lock() - defer fake.getBucketLifecycleWithContextMutex.Unlock() - fake.GetBucketLifecycleWithContextStub = nil - if fake.getBucketLifecycleWithContextReturnsOnCall == nil { - fake.getBucketLifecycleWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketLifecycleOutput - result2 error - }) - } - fake.getBucketLifecycleWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketLifecycleOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLocation(arg1 *s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error) { - fake.getBucketLocationMutex.Lock() - ret, specificReturn := fake.getBucketLocationReturnsOnCall[len(fake.getBucketLocationArgsForCall)] - fake.getBucketLocationArgsForCall = append(fake.getBucketLocationArgsForCall, struct { - arg1 *s3.GetBucketLocationInput - }{arg1}) - stub := fake.GetBucketLocationStub - fakeReturns := fake.getBucketLocationReturns - fake.recordInvocation("GetBucketLocation", []interface{}{arg1}) - fake.getBucketLocationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketLocationCallCount() int { - fake.getBucketLocationMutex.RLock() - defer fake.getBucketLocationMutex.RUnlock() - return len(fake.getBucketLocationArgsForCall) -} - -func (fake *FakeS3Client) GetBucketLocationCalls(stub func(*s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error)) { - fake.getBucketLocationMutex.Lock() - defer fake.getBucketLocationMutex.Unlock() - fake.GetBucketLocationStub = stub -} - -func (fake *FakeS3Client) GetBucketLocationArgsForCall(i int) *s3.GetBucketLocationInput { - fake.getBucketLocationMutex.RLock() - defer fake.getBucketLocationMutex.RUnlock() - argsForCall := fake.getBucketLocationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketLocationReturns(result1 *s3.GetBucketLocationOutput, result2 error) { - fake.getBucketLocationMutex.Lock() - defer fake.getBucketLocationMutex.Unlock() - fake.GetBucketLocationStub = nil - fake.getBucketLocationReturns = struct { - result1 *s3.GetBucketLocationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLocationReturnsOnCall(i int, result1 *s3.GetBucketLocationOutput, result2 error) { - fake.getBucketLocationMutex.Lock() - defer fake.getBucketLocationMutex.Unlock() - fake.GetBucketLocationStub = nil - if fake.getBucketLocationReturnsOnCall == nil { - fake.getBucketLocationReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketLocationOutput - result2 error - }) - } - fake.getBucketLocationReturnsOnCall[i] = struct { - result1 *s3.GetBucketLocationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLocationRequest(arg1 *s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput) { - fake.getBucketLocationRequestMutex.Lock() - ret, specificReturn := fake.getBucketLocationRequestReturnsOnCall[len(fake.getBucketLocationRequestArgsForCall)] - fake.getBucketLocationRequestArgsForCall = append(fake.getBucketLocationRequestArgsForCall, struct { - arg1 *s3.GetBucketLocationInput - }{arg1}) - stub := fake.GetBucketLocationRequestStub - fakeReturns := fake.getBucketLocationRequestReturns - fake.recordInvocation("GetBucketLocationRequest", []interface{}{arg1}) - fake.getBucketLocationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketLocationRequestCallCount() int { - fake.getBucketLocationRequestMutex.RLock() - defer fake.getBucketLocationRequestMutex.RUnlock() - return len(fake.getBucketLocationRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketLocationRequestCalls(stub func(*s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput)) { - fake.getBucketLocationRequestMutex.Lock() - defer fake.getBucketLocationRequestMutex.Unlock() - fake.GetBucketLocationRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketLocationRequestArgsForCall(i int) *s3.GetBucketLocationInput { - fake.getBucketLocationRequestMutex.RLock() - defer fake.getBucketLocationRequestMutex.RUnlock() - argsForCall := fake.getBucketLocationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketLocationRequestReturns(result1 *request.Request, result2 *s3.GetBucketLocationOutput) { - fake.getBucketLocationRequestMutex.Lock() - defer fake.getBucketLocationRequestMutex.Unlock() - fake.GetBucketLocationRequestStub = nil - fake.getBucketLocationRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketLocationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLocationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketLocationOutput) { - fake.getBucketLocationRequestMutex.Lock() - defer fake.getBucketLocationRequestMutex.Unlock() - fake.GetBucketLocationRequestStub = nil - if fake.getBucketLocationRequestReturnsOnCall == nil { - fake.getBucketLocationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketLocationOutput - }) - } - fake.getBucketLocationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketLocationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLocationWithContext(arg1 context.Context, arg2 *s3.GetBucketLocationInput, arg3 ...request.Option) (*s3.GetBucketLocationOutput, error) { - fake.getBucketLocationWithContextMutex.Lock() - ret, specificReturn := fake.getBucketLocationWithContextReturnsOnCall[len(fake.getBucketLocationWithContextArgsForCall)] - fake.getBucketLocationWithContextArgsForCall = append(fake.getBucketLocationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketLocationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketLocationWithContextStub - fakeReturns := fake.getBucketLocationWithContextReturns - fake.recordInvocation("GetBucketLocationWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketLocationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketLocationWithContextCallCount() int { - fake.getBucketLocationWithContextMutex.RLock() - defer fake.getBucketLocationWithContextMutex.RUnlock() - return len(fake.getBucketLocationWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketLocationWithContextCalls(stub func(context.Context, *s3.GetBucketLocationInput, ...request.Option) (*s3.GetBucketLocationOutput, error)) { - fake.getBucketLocationWithContextMutex.Lock() - defer fake.getBucketLocationWithContextMutex.Unlock() - fake.GetBucketLocationWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketLocationWithContextArgsForCall(i int) (context.Context, *s3.GetBucketLocationInput, []request.Option) { - fake.getBucketLocationWithContextMutex.RLock() - defer fake.getBucketLocationWithContextMutex.RUnlock() - argsForCall := fake.getBucketLocationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketLocationWithContextReturns(result1 *s3.GetBucketLocationOutput, result2 error) { - fake.getBucketLocationWithContextMutex.Lock() - defer fake.getBucketLocationWithContextMutex.Unlock() - fake.GetBucketLocationWithContextStub = nil - fake.getBucketLocationWithContextReturns = struct { - result1 *s3.GetBucketLocationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLocationWithContextReturnsOnCall(i int, result1 *s3.GetBucketLocationOutput, result2 error) { - fake.getBucketLocationWithContextMutex.Lock() - defer fake.getBucketLocationWithContextMutex.Unlock() - fake.GetBucketLocationWithContextStub = nil - if fake.getBucketLocationWithContextReturnsOnCall == nil { - fake.getBucketLocationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketLocationOutput - result2 error - }) - } - fake.getBucketLocationWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketLocationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLogging(arg1 *s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error) { - fake.getBucketLoggingMutex.Lock() - ret, specificReturn := fake.getBucketLoggingReturnsOnCall[len(fake.getBucketLoggingArgsForCall)] - fake.getBucketLoggingArgsForCall = append(fake.getBucketLoggingArgsForCall, struct { - arg1 *s3.GetBucketLoggingInput - }{arg1}) - stub := fake.GetBucketLoggingStub - fakeReturns := fake.getBucketLoggingReturns - fake.recordInvocation("GetBucketLogging", []interface{}{arg1}) - fake.getBucketLoggingMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketLoggingCallCount() int { - fake.getBucketLoggingMutex.RLock() - defer fake.getBucketLoggingMutex.RUnlock() - return len(fake.getBucketLoggingArgsForCall) -} - -func (fake *FakeS3Client) GetBucketLoggingCalls(stub func(*s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error)) { - fake.getBucketLoggingMutex.Lock() - defer fake.getBucketLoggingMutex.Unlock() - fake.GetBucketLoggingStub = stub -} - -func (fake *FakeS3Client) GetBucketLoggingArgsForCall(i int) *s3.GetBucketLoggingInput { - fake.getBucketLoggingMutex.RLock() - defer fake.getBucketLoggingMutex.RUnlock() - argsForCall := fake.getBucketLoggingArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketLoggingReturns(result1 *s3.GetBucketLoggingOutput, result2 error) { - fake.getBucketLoggingMutex.Lock() - defer fake.getBucketLoggingMutex.Unlock() - fake.GetBucketLoggingStub = nil - fake.getBucketLoggingReturns = struct { - result1 *s3.GetBucketLoggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLoggingReturnsOnCall(i int, result1 *s3.GetBucketLoggingOutput, result2 error) { - fake.getBucketLoggingMutex.Lock() - defer fake.getBucketLoggingMutex.Unlock() - fake.GetBucketLoggingStub = nil - if fake.getBucketLoggingReturnsOnCall == nil { - fake.getBucketLoggingReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketLoggingOutput - result2 error - }) - } - fake.getBucketLoggingReturnsOnCall[i] = struct { - result1 *s3.GetBucketLoggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLoggingRequest(arg1 *s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput) { - fake.getBucketLoggingRequestMutex.Lock() - ret, specificReturn := fake.getBucketLoggingRequestReturnsOnCall[len(fake.getBucketLoggingRequestArgsForCall)] - fake.getBucketLoggingRequestArgsForCall = append(fake.getBucketLoggingRequestArgsForCall, struct { - arg1 *s3.GetBucketLoggingInput - }{arg1}) - stub := fake.GetBucketLoggingRequestStub - fakeReturns := fake.getBucketLoggingRequestReturns - fake.recordInvocation("GetBucketLoggingRequest", []interface{}{arg1}) - fake.getBucketLoggingRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketLoggingRequestCallCount() int { - fake.getBucketLoggingRequestMutex.RLock() - defer fake.getBucketLoggingRequestMutex.RUnlock() - return len(fake.getBucketLoggingRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketLoggingRequestCalls(stub func(*s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput)) { - fake.getBucketLoggingRequestMutex.Lock() - defer fake.getBucketLoggingRequestMutex.Unlock() - fake.GetBucketLoggingRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketLoggingRequestArgsForCall(i int) *s3.GetBucketLoggingInput { - fake.getBucketLoggingRequestMutex.RLock() - defer fake.getBucketLoggingRequestMutex.RUnlock() - argsForCall := fake.getBucketLoggingRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketLoggingRequestReturns(result1 *request.Request, result2 *s3.GetBucketLoggingOutput) { - fake.getBucketLoggingRequestMutex.Lock() - defer fake.getBucketLoggingRequestMutex.Unlock() - fake.GetBucketLoggingRequestStub = nil - fake.getBucketLoggingRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketLoggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLoggingRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketLoggingOutput) { - fake.getBucketLoggingRequestMutex.Lock() - defer fake.getBucketLoggingRequestMutex.Unlock() - fake.GetBucketLoggingRequestStub = nil - if fake.getBucketLoggingRequestReturnsOnCall == nil { - fake.getBucketLoggingRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketLoggingOutput - }) - } - fake.getBucketLoggingRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketLoggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLoggingWithContext(arg1 context.Context, arg2 *s3.GetBucketLoggingInput, arg3 ...request.Option) (*s3.GetBucketLoggingOutput, error) { - fake.getBucketLoggingWithContextMutex.Lock() - ret, specificReturn := fake.getBucketLoggingWithContextReturnsOnCall[len(fake.getBucketLoggingWithContextArgsForCall)] - fake.getBucketLoggingWithContextArgsForCall = append(fake.getBucketLoggingWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketLoggingInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketLoggingWithContextStub - fakeReturns := fake.getBucketLoggingWithContextReturns - fake.recordInvocation("GetBucketLoggingWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketLoggingWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketLoggingWithContextCallCount() int { - fake.getBucketLoggingWithContextMutex.RLock() - defer fake.getBucketLoggingWithContextMutex.RUnlock() - return len(fake.getBucketLoggingWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketLoggingWithContextCalls(stub func(context.Context, *s3.GetBucketLoggingInput, ...request.Option) (*s3.GetBucketLoggingOutput, error)) { - fake.getBucketLoggingWithContextMutex.Lock() - defer fake.getBucketLoggingWithContextMutex.Unlock() - fake.GetBucketLoggingWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketLoggingWithContextArgsForCall(i int) (context.Context, *s3.GetBucketLoggingInput, []request.Option) { - fake.getBucketLoggingWithContextMutex.RLock() - defer fake.getBucketLoggingWithContextMutex.RUnlock() - argsForCall := fake.getBucketLoggingWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketLoggingWithContextReturns(result1 *s3.GetBucketLoggingOutput, result2 error) { - fake.getBucketLoggingWithContextMutex.Lock() - defer fake.getBucketLoggingWithContextMutex.Unlock() - fake.GetBucketLoggingWithContextStub = nil - fake.getBucketLoggingWithContextReturns = struct { - result1 *s3.GetBucketLoggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketLoggingWithContextReturnsOnCall(i int, result1 *s3.GetBucketLoggingOutput, result2 error) { - fake.getBucketLoggingWithContextMutex.Lock() - defer fake.getBucketLoggingWithContextMutex.Unlock() - fake.GetBucketLoggingWithContextStub = nil - if fake.getBucketLoggingWithContextReturnsOnCall == nil { - fake.getBucketLoggingWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketLoggingOutput - result2 error - }) - } - fake.getBucketLoggingWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketLoggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketMetricsConfiguration(arg1 *s3.GetBucketMetricsConfigurationInput) (*s3.GetBucketMetricsConfigurationOutput, error) { - fake.getBucketMetricsConfigurationMutex.Lock() - ret, specificReturn := fake.getBucketMetricsConfigurationReturnsOnCall[len(fake.getBucketMetricsConfigurationArgsForCall)] - fake.getBucketMetricsConfigurationArgsForCall = append(fake.getBucketMetricsConfigurationArgsForCall, struct { - arg1 *s3.GetBucketMetricsConfigurationInput - }{arg1}) - stub := fake.GetBucketMetricsConfigurationStub - fakeReturns := fake.getBucketMetricsConfigurationReturns - fake.recordInvocation("GetBucketMetricsConfiguration", []interface{}{arg1}) - fake.getBucketMetricsConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationCallCount() int { - fake.getBucketMetricsConfigurationMutex.RLock() - defer fake.getBucketMetricsConfigurationMutex.RUnlock() - return len(fake.getBucketMetricsConfigurationArgsForCall) -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationCalls(stub func(*s3.GetBucketMetricsConfigurationInput) (*s3.GetBucketMetricsConfigurationOutput, error)) { - fake.getBucketMetricsConfigurationMutex.Lock() - defer fake.getBucketMetricsConfigurationMutex.Unlock() - fake.GetBucketMetricsConfigurationStub = stub -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationArgsForCall(i int) *s3.GetBucketMetricsConfigurationInput { - fake.getBucketMetricsConfigurationMutex.RLock() - defer fake.getBucketMetricsConfigurationMutex.RUnlock() - argsForCall := fake.getBucketMetricsConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationReturns(result1 *s3.GetBucketMetricsConfigurationOutput, result2 error) { - fake.getBucketMetricsConfigurationMutex.Lock() - defer fake.getBucketMetricsConfigurationMutex.Unlock() - fake.GetBucketMetricsConfigurationStub = nil - fake.getBucketMetricsConfigurationReturns = struct { - result1 *s3.GetBucketMetricsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationReturnsOnCall(i int, result1 *s3.GetBucketMetricsConfigurationOutput, result2 error) { - fake.getBucketMetricsConfigurationMutex.Lock() - defer fake.getBucketMetricsConfigurationMutex.Unlock() - fake.GetBucketMetricsConfigurationStub = nil - if fake.getBucketMetricsConfigurationReturnsOnCall == nil { - fake.getBucketMetricsConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketMetricsConfigurationOutput - result2 error - }) - } - fake.getBucketMetricsConfigurationReturnsOnCall[i] = struct { - result1 *s3.GetBucketMetricsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationRequest(arg1 *s3.GetBucketMetricsConfigurationInput) (*request.Request, *s3.GetBucketMetricsConfigurationOutput) { - fake.getBucketMetricsConfigurationRequestMutex.Lock() - ret, specificReturn := fake.getBucketMetricsConfigurationRequestReturnsOnCall[len(fake.getBucketMetricsConfigurationRequestArgsForCall)] - fake.getBucketMetricsConfigurationRequestArgsForCall = append(fake.getBucketMetricsConfigurationRequestArgsForCall, struct { - arg1 *s3.GetBucketMetricsConfigurationInput - }{arg1}) - stub := fake.GetBucketMetricsConfigurationRequestStub - fakeReturns := fake.getBucketMetricsConfigurationRequestReturns - fake.recordInvocation("GetBucketMetricsConfigurationRequest", []interface{}{arg1}) - fake.getBucketMetricsConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationRequestCallCount() int { - fake.getBucketMetricsConfigurationRequestMutex.RLock() - defer fake.getBucketMetricsConfigurationRequestMutex.RUnlock() - return len(fake.getBucketMetricsConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationRequestCalls(stub func(*s3.GetBucketMetricsConfigurationInput) (*request.Request, *s3.GetBucketMetricsConfigurationOutput)) { - fake.getBucketMetricsConfigurationRequestMutex.Lock() - defer fake.getBucketMetricsConfigurationRequestMutex.Unlock() - fake.GetBucketMetricsConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationRequestArgsForCall(i int) *s3.GetBucketMetricsConfigurationInput { - fake.getBucketMetricsConfigurationRequestMutex.RLock() - defer fake.getBucketMetricsConfigurationRequestMutex.RUnlock() - argsForCall := fake.getBucketMetricsConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationRequestReturns(result1 *request.Request, result2 *s3.GetBucketMetricsConfigurationOutput) { - fake.getBucketMetricsConfigurationRequestMutex.Lock() - defer fake.getBucketMetricsConfigurationRequestMutex.Unlock() - fake.GetBucketMetricsConfigurationRequestStub = nil - fake.getBucketMetricsConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketMetricsConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketMetricsConfigurationOutput) { - fake.getBucketMetricsConfigurationRequestMutex.Lock() - defer fake.getBucketMetricsConfigurationRequestMutex.Unlock() - fake.GetBucketMetricsConfigurationRequestStub = nil - if fake.getBucketMetricsConfigurationRequestReturnsOnCall == nil { - fake.getBucketMetricsConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketMetricsConfigurationOutput - }) - } - fake.getBucketMetricsConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketMetricsConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationWithContext(arg1 context.Context, arg2 *s3.GetBucketMetricsConfigurationInput, arg3 ...request.Option) (*s3.GetBucketMetricsConfigurationOutput, error) { - fake.getBucketMetricsConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.getBucketMetricsConfigurationWithContextReturnsOnCall[len(fake.getBucketMetricsConfigurationWithContextArgsForCall)] - fake.getBucketMetricsConfigurationWithContextArgsForCall = append(fake.getBucketMetricsConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketMetricsConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketMetricsConfigurationWithContextStub - fakeReturns := fake.getBucketMetricsConfigurationWithContextReturns - fake.recordInvocation("GetBucketMetricsConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketMetricsConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationWithContextCallCount() int { - fake.getBucketMetricsConfigurationWithContextMutex.RLock() - defer fake.getBucketMetricsConfigurationWithContextMutex.RUnlock() - return len(fake.getBucketMetricsConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationWithContextCalls(stub func(context.Context, *s3.GetBucketMetricsConfigurationInput, ...request.Option) (*s3.GetBucketMetricsConfigurationOutput, error)) { - fake.getBucketMetricsConfigurationWithContextMutex.Lock() - defer fake.getBucketMetricsConfigurationWithContextMutex.Unlock() - fake.GetBucketMetricsConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationWithContextArgsForCall(i int) (context.Context, *s3.GetBucketMetricsConfigurationInput, []request.Option) { - fake.getBucketMetricsConfigurationWithContextMutex.RLock() - defer fake.getBucketMetricsConfigurationWithContextMutex.RUnlock() - argsForCall := fake.getBucketMetricsConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationWithContextReturns(result1 *s3.GetBucketMetricsConfigurationOutput, result2 error) { - fake.getBucketMetricsConfigurationWithContextMutex.Lock() - defer fake.getBucketMetricsConfigurationWithContextMutex.Unlock() - fake.GetBucketMetricsConfigurationWithContextStub = nil - fake.getBucketMetricsConfigurationWithContextReturns = struct { - result1 *s3.GetBucketMetricsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketMetricsConfigurationWithContextReturnsOnCall(i int, result1 *s3.GetBucketMetricsConfigurationOutput, result2 error) { - fake.getBucketMetricsConfigurationWithContextMutex.Lock() - defer fake.getBucketMetricsConfigurationWithContextMutex.Unlock() - fake.GetBucketMetricsConfigurationWithContextStub = nil - if fake.getBucketMetricsConfigurationWithContextReturnsOnCall == nil { - fake.getBucketMetricsConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketMetricsConfigurationOutput - result2 error - }) - } - fake.getBucketMetricsConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketMetricsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketNotification(arg1 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error) { - fake.getBucketNotificationMutex.Lock() - ret, specificReturn := fake.getBucketNotificationReturnsOnCall[len(fake.getBucketNotificationArgsForCall)] - fake.getBucketNotificationArgsForCall = append(fake.getBucketNotificationArgsForCall, struct { - arg1 *s3.GetBucketNotificationConfigurationRequest - }{arg1}) - stub := fake.GetBucketNotificationStub - fakeReturns := fake.getBucketNotificationReturns - fake.recordInvocation("GetBucketNotification", []interface{}{arg1}) - fake.getBucketNotificationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketNotificationCallCount() int { - fake.getBucketNotificationMutex.RLock() - defer fake.getBucketNotificationMutex.RUnlock() - return len(fake.getBucketNotificationArgsForCall) -} - -func (fake *FakeS3Client) GetBucketNotificationCalls(stub func(*s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error)) { - fake.getBucketNotificationMutex.Lock() - defer fake.getBucketNotificationMutex.Unlock() - fake.GetBucketNotificationStub = stub -} - -func (fake *FakeS3Client) GetBucketNotificationArgsForCall(i int) *s3.GetBucketNotificationConfigurationRequest { - fake.getBucketNotificationMutex.RLock() - defer fake.getBucketNotificationMutex.RUnlock() - argsForCall := fake.getBucketNotificationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketNotificationReturns(result1 *s3.NotificationConfigurationDeprecated, result2 error) { - fake.getBucketNotificationMutex.Lock() - defer fake.getBucketNotificationMutex.Unlock() - fake.GetBucketNotificationStub = nil - fake.getBucketNotificationReturns = struct { - result1 *s3.NotificationConfigurationDeprecated - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketNotificationReturnsOnCall(i int, result1 *s3.NotificationConfigurationDeprecated, result2 error) { - fake.getBucketNotificationMutex.Lock() - defer fake.getBucketNotificationMutex.Unlock() - fake.GetBucketNotificationStub = nil - if fake.getBucketNotificationReturnsOnCall == nil { - fake.getBucketNotificationReturnsOnCall = make(map[int]struct { - result1 *s3.NotificationConfigurationDeprecated - result2 error - }) - } - fake.getBucketNotificationReturnsOnCall[i] = struct { - result1 *s3.NotificationConfigurationDeprecated - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketNotificationConfiguration(arg1 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error) { - fake.getBucketNotificationConfigurationMutex.Lock() - ret, specificReturn := fake.getBucketNotificationConfigurationReturnsOnCall[len(fake.getBucketNotificationConfigurationArgsForCall)] - fake.getBucketNotificationConfigurationArgsForCall = append(fake.getBucketNotificationConfigurationArgsForCall, struct { - arg1 *s3.GetBucketNotificationConfigurationRequest - }{arg1}) - stub := fake.GetBucketNotificationConfigurationStub - fakeReturns := fake.getBucketNotificationConfigurationReturns - fake.recordInvocation("GetBucketNotificationConfiguration", []interface{}{arg1}) - fake.getBucketNotificationConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationCallCount() int { - fake.getBucketNotificationConfigurationMutex.RLock() - defer fake.getBucketNotificationConfigurationMutex.RUnlock() - return len(fake.getBucketNotificationConfigurationArgsForCall) -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationCalls(stub func(*s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error)) { - fake.getBucketNotificationConfigurationMutex.Lock() - defer fake.getBucketNotificationConfigurationMutex.Unlock() - fake.GetBucketNotificationConfigurationStub = stub -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationArgsForCall(i int) *s3.GetBucketNotificationConfigurationRequest { - fake.getBucketNotificationConfigurationMutex.RLock() - defer fake.getBucketNotificationConfigurationMutex.RUnlock() - argsForCall := fake.getBucketNotificationConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationReturns(result1 *s3.NotificationConfiguration, result2 error) { - fake.getBucketNotificationConfigurationMutex.Lock() - defer fake.getBucketNotificationConfigurationMutex.Unlock() - fake.GetBucketNotificationConfigurationStub = nil - fake.getBucketNotificationConfigurationReturns = struct { - result1 *s3.NotificationConfiguration - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationReturnsOnCall(i int, result1 *s3.NotificationConfiguration, result2 error) { - fake.getBucketNotificationConfigurationMutex.Lock() - defer fake.getBucketNotificationConfigurationMutex.Unlock() - fake.GetBucketNotificationConfigurationStub = nil - if fake.getBucketNotificationConfigurationReturnsOnCall == nil { - fake.getBucketNotificationConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.NotificationConfiguration - result2 error - }) - } - fake.getBucketNotificationConfigurationReturnsOnCall[i] = struct { - result1 *s3.NotificationConfiguration - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationRequest(arg1 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration) { - fake.getBucketNotificationConfigurationRequestMutex.Lock() - ret, specificReturn := fake.getBucketNotificationConfigurationRequestReturnsOnCall[len(fake.getBucketNotificationConfigurationRequestArgsForCall)] - fake.getBucketNotificationConfigurationRequestArgsForCall = append(fake.getBucketNotificationConfigurationRequestArgsForCall, struct { - arg1 *s3.GetBucketNotificationConfigurationRequest - }{arg1}) - stub := fake.GetBucketNotificationConfigurationRequestStub - fakeReturns := fake.getBucketNotificationConfigurationRequestReturns - fake.recordInvocation("GetBucketNotificationConfigurationRequest", []interface{}{arg1}) - fake.getBucketNotificationConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationRequestCallCount() int { - fake.getBucketNotificationConfigurationRequestMutex.RLock() - defer fake.getBucketNotificationConfigurationRequestMutex.RUnlock() - return len(fake.getBucketNotificationConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationRequestCalls(stub func(*s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration)) { - fake.getBucketNotificationConfigurationRequestMutex.Lock() - defer fake.getBucketNotificationConfigurationRequestMutex.Unlock() - fake.GetBucketNotificationConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationRequestArgsForCall(i int) *s3.GetBucketNotificationConfigurationRequest { - fake.getBucketNotificationConfigurationRequestMutex.RLock() - defer fake.getBucketNotificationConfigurationRequestMutex.RUnlock() - argsForCall := fake.getBucketNotificationConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationRequestReturns(result1 *request.Request, result2 *s3.NotificationConfiguration) { - fake.getBucketNotificationConfigurationRequestMutex.Lock() - defer fake.getBucketNotificationConfigurationRequestMutex.Unlock() - fake.GetBucketNotificationConfigurationRequestStub = nil - fake.getBucketNotificationConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.NotificationConfiguration - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.NotificationConfiguration) { - fake.getBucketNotificationConfigurationRequestMutex.Lock() - defer fake.getBucketNotificationConfigurationRequestMutex.Unlock() - fake.GetBucketNotificationConfigurationRequestStub = nil - if fake.getBucketNotificationConfigurationRequestReturnsOnCall == nil { - fake.getBucketNotificationConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.NotificationConfiguration - }) - } - fake.getBucketNotificationConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.NotificationConfiguration - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationWithContext(arg1 context.Context, arg2 *s3.GetBucketNotificationConfigurationRequest, arg3 ...request.Option) (*s3.NotificationConfiguration, error) { - fake.getBucketNotificationConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.getBucketNotificationConfigurationWithContextReturnsOnCall[len(fake.getBucketNotificationConfigurationWithContextArgsForCall)] - fake.getBucketNotificationConfigurationWithContextArgsForCall = append(fake.getBucketNotificationConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketNotificationConfigurationRequest - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketNotificationConfigurationWithContextStub - fakeReturns := fake.getBucketNotificationConfigurationWithContextReturns - fake.recordInvocation("GetBucketNotificationConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketNotificationConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationWithContextCallCount() int { - fake.getBucketNotificationConfigurationWithContextMutex.RLock() - defer fake.getBucketNotificationConfigurationWithContextMutex.RUnlock() - return len(fake.getBucketNotificationConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationWithContextCalls(stub func(context.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) (*s3.NotificationConfiguration, error)) { - fake.getBucketNotificationConfigurationWithContextMutex.Lock() - defer fake.getBucketNotificationConfigurationWithContextMutex.Unlock() - fake.GetBucketNotificationConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationWithContextArgsForCall(i int) (context.Context, *s3.GetBucketNotificationConfigurationRequest, []request.Option) { - fake.getBucketNotificationConfigurationWithContextMutex.RLock() - defer fake.getBucketNotificationConfigurationWithContextMutex.RUnlock() - argsForCall := fake.getBucketNotificationConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationWithContextReturns(result1 *s3.NotificationConfiguration, result2 error) { - fake.getBucketNotificationConfigurationWithContextMutex.Lock() - defer fake.getBucketNotificationConfigurationWithContextMutex.Unlock() - fake.GetBucketNotificationConfigurationWithContextStub = nil - fake.getBucketNotificationConfigurationWithContextReturns = struct { - result1 *s3.NotificationConfiguration - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketNotificationConfigurationWithContextReturnsOnCall(i int, result1 *s3.NotificationConfiguration, result2 error) { - fake.getBucketNotificationConfigurationWithContextMutex.Lock() - defer fake.getBucketNotificationConfigurationWithContextMutex.Unlock() - fake.GetBucketNotificationConfigurationWithContextStub = nil - if fake.getBucketNotificationConfigurationWithContextReturnsOnCall == nil { - fake.getBucketNotificationConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.NotificationConfiguration - result2 error - }) - } - fake.getBucketNotificationConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.NotificationConfiguration - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketNotificationRequest(arg1 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated) { - fake.getBucketNotificationRequestMutex.Lock() - ret, specificReturn := fake.getBucketNotificationRequestReturnsOnCall[len(fake.getBucketNotificationRequestArgsForCall)] - fake.getBucketNotificationRequestArgsForCall = append(fake.getBucketNotificationRequestArgsForCall, struct { - arg1 *s3.GetBucketNotificationConfigurationRequest - }{arg1}) - stub := fake.GetBucketNotificationRequestStub - fakeReturns := fake.getBucketNotificationRequestReturns - fake.recordInvocation("GetBucketNotificationRequest", []interface{}{arg1}) - fake.getBucketNotificationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketNotificationRequestCallCount() int { - fake.getBucketNotificationRequestMutex.RLock() - defer fake.getBucketNotificationRequestMutex.RUnlock() - return len(fake.getBucketNotificationRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketNotificationRequestCalls(stub func(*s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated)) { - fake.getBucketNotificationRequestMutex.Lock() - defer fake.getBucketNotificationRequestMutex.Unlock() - fake.GetBucketNotificationRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketNotificationRequestArgsForCall(i int) *s3.GetBucketNotificationConfigurationRequest { - fake.getBucketNotificationRequestMutex.RLock() - defer fake.getBucketNotificationRequestMutex.RUnlock() - argsForCall := fake.getBucketNotificationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketNotificationRequestReturns(result1 *request.Request, result2 *s3.NotificationConfigurationDeprecated) { - fake.getBucketNotificationRequestMutex.Lock() - defer fake.getBucketNotificationRequestMutex.Unlock() - fake.GetBucketNotificationRequestStub = nil - fake.getBucketNotificationRequestReturns = struct { - result1 *request.Request - result2 *s3.NotificationConfigurationDeprecated - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketNotificationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.NotificationConfigurationDeprecated) { - fake.getBucketNotificationRequestMutex.Lock() - defer fake.getBucketNotificationRequestMutex.Unlock() - fake.GetBucketNotificationRequestStub = nil - if fake.getBucketNotificationRequestReturnsOnCall == nil { - fake.getBucketNotificationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.NotificationConfigurationDeprecated - }) - } - fake.getBucketNotificationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.NotificationConfigurationDeprecated - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketNotificationWithContext(arg1 context.Context, arg2 *s3.GetBucketNotificationConfigurationRequest, arg3 ...request.Option) (*s3.NotificationConfigurationDeprecated, error) { - fake.getBucketNotificationWithContextMutex.Lock() - ret, specificReturn := fake.getBucketNotificationWithContextReturnsOnCall[len(fake.getBucketNotificationWithContextArgsForCall)] - fake.getBucketNotificationWithContextArgsForCall = append(fake.getBucketNotificationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketNotificationConfigurationRequest - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketNotificationWithContextStub - fakeReturns := fake.getBucketNotificationWithContextReturns - fake.recordInvocation("GetBucketNotificationWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketNotificationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketNotificationWithContextCallCount() int { - fake.getBucketNotificationWithContextMutex.RLock() - defer fake.getBucketNotificationWithContextMutex.RUnlock() - return len(fake.getBucketNotificationWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketNotificationWithContextCalls(stub func(context.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) (*s3.NotificationConfigurationDeprecated, error)) { - fake.getBucketNotificationWithContextMutex.Lock() - defer fake.getBucketNotificationWithContextMutex.Unlock() - fake.GetBucketNotificationWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketNotificationWithContextArgsForCall(i int) (context.Context, *s3.GetBucketNotificationConfigurationRequest, []request.Option) { - fake.getBucketNotificationWithContextMutex.RLock() - defer fake.getBucketNotificationWithContextMutex.RUnlock() - argsForCall := fake.getBucketNotificationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketNotificationWithContextReturns(result1 *s3.NotificationConfigurationDeprecated, result2 error) { - fake.getBucketNotificationWithContextMutex.Lock() - defer fake.getBucketNotificationWithContextMutex.Unlock() - fake.GetBucketNotificationWithContextStub = nil - fake.getBucketNotificationWithContextReturns = struct { - result1 *s3.NotificationConfigurationDeprecated - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketNotificationWithContextReturnsOnCall(i int, result1 *s3.NotificationConfigurationDeprecated, result2 error) { - fake.getBucketNotificationWithContextMutex.Lock() - defer fake.getBucketNotificationWithContextMutex.Unlock() - fake.GetBucketNotificationWithContextStub = nil - if fake.getBucketNotificationWithContextReturnsOnCall == nil { - fake.getBucketNotificationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.NotificationConfigurationDeprecated - result2 error - }) - } - fake.getBucketNotificationWithContextReturnsOnCall[i] = struct { - result1 *s3.NotificationConfigurationDeprecated - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketOwnershipControls(arg1 *s3.GetBucketOwnershipControlsInput) (*s3.GetBucketOwnershipControlsOutput, error) { - fake.getBucketOwnershipControlsMutex.Lock() - ret, specificReturn := fake.getBucketOwnershipControlsReturnsOnCall[len(fake.getBucketOwnershipControlsArgsForCall)] - fake.getBucketOwnershipControlsArgsForCall = append(fake.getBucketOwnershipControlsArgsForCall, struct { - arg1 *s3.GetBucketOwnershipControlsInput - }{arg1}) - stub := fake.GetBucketOwnershipControlsStub - fakeReturns := fake.getBucketOwnershipControlsReturns - fake.recordInvocation("GetBucketOwnershipControls", []interface{}{arg1}) - fake.getBucketOwnershipControlsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsCallCount() int { - fake.getBucketOwnershipControlsMutex.RLock() - defer fake.getBucketOwnershipControlsMutex.RUnlock() - return len(fake.getBucketOwnershipControlsArgsForCall) -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsCalls(stub func(*s3.GetBucketOwnershipControlsInput) (*s3.GetBucketOwnershipControlsOutput, error)) { - fake.getBucketOwnershipControlsMutex.Lock() - defer fake.getBucketOwnershipControlsMutex.Unlock() - fake.GetBucketOwnershipControlsStub = stub -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsArgsForCall(i int) *s3.GetBucketOwnershipControlsInput { - fake.getBucketOwnershipControlsMutex.RLock() - defer fake.getBucketOwnershipControlsMutex.RUnlock() - argsForCall := fake.getBucketOwnershipControlsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsReturns(result1 *s3.GetBucketOwnershipControlsOutput, result2 error) { - fake.getBucketOwnershipControlsMutex.Lock() - defer fake.getBucketOwnershipControlsMutex.Unlock() - fake.GetBucketOwnershipControlsStub = nil - fake.getBucketOwnershipControlsReturns = struct { - result1 *s3.GetBucketOwnershipControlsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsReturnsOnCall(i int, result1 *s3.GetBucketOwnershipControlsOutput, result2 error) { - fake.getBucketOwnershipControlsMutex.Lock() - defer fake.getBucketOwnershipControlsMutex.Unlock() - fake.GetBucketOwnershipControlsStub = nil - if fake.getBucketOwnershipControlsReturnsOnCall == nil { - fake.getBucketOwnershipControlsReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketOwnershipControlsOutput - result2 error - }) - } - fake.getBucketOwnershipControlsReturnsOnCall[i] = struct { - result1 *s3.GetBucketOwnershipControlsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsRequest(arg1 *s3.GetBucketOwnershipControlsInput) (*request.Request, *s3.GetBucketOwnershipControlsOutput) { - fake.getBucketOwnershipControlsRequestMutex.Lock() - ret, specificReturn := fake.getBucketOwnershipControlsRequestReturnsOnCall[len(fake.getBucketOwnershipControlsRequestArgsForCall)] - fake.getBucketOwnershipControlsRequestArgsForCall = append(fake.getBucketOwnershipControlsRequestArgsForCall, struct { - arg1 *s3.GetBucketOwnershipControlsInput - }{arg1}) - stub := fake.GetBucketOwnershipControlsRequestStub - fakeReturns := fake.getBucketOwnershipControlsRequestReturns - fake.recordInvocation("GetBucketOwnershipControlsRequest", []interface{}{arg1}) - fake.getBucketOwnershipControlsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsRequestCallCount() int { - fake.getBucketOwnershipControlsRequestMutex.RLock() - defer fake.getBucketOwnershipControlsRequestMutex.RUnlock() - return len(fake.getBucketOwnershipControlsRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsRequestCalls(stub func(*s3.GetBucketOwnershipControlsInput) (*request.Request, *s3.GetBucketOwnershipControlsOutput)) { - fake.getBucketOwnershipControlsRequestMutex.Lock() - defer fake.getBucketOwnershipControlsRequestMutex.Unlock() - fake.GetBucketOwnershipControlsRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsRequestArgsForCall(i int) *s3.GetBucketOwnershipControlsInput { - fake.getBucketOwnershipControlsRequestMutex.RLock() - defer fake.getBucketOwnershipControlsRequestMutex.RUnlock() - argsForCall := fake.getBucketOwnershipControlsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsRequestReturns(result1 *request.Request, result2 *s3.GetBucketOwnershipControlsOutput) { - fake.getBucketOwnershipControlsRequestMutex.Lock() - defer fake.getBucketOwnershipControlsRequestMutex.Unlock() - fake.GetBucketOwnershipControlsRequestStub = nil - fake.getBucketOwnershipControlsRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketOwnershipControlsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketOwnershipControlsOutput) { - fake.getBucketOwnershipControlsRequestMutex.Lock() - defer fake.getBucketOwnershipControlsRequestMutex.Unlock() - fake.GetBucketOwnershipControlsRequestStub = nil - if fake.getBucketOwnershipControlsRequestReturnsOnCall == nil { - fake.getBucketOwnershipControlsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketOwnershipControlsOutput - }) - } - fake.getBucketOwnershipControlsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketOwnershipControlsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsWithContext(arg1 context.Context, arg2 *s3.GetBucketOwnershipControlsInput, arg3 ...request.Option) (*s3.GetBucketOwnershipControlsOutput, error) { - fake.getBucketOwnershipControlsWithContextMutex.Lock() - ret, specificReturn := fake.getBucketOwnershipControlsWithContextReturnsOnCall[len(fake.getBucketOwnershipControlsWithContextArgsForCall)] - fake.getBucketOwnershipControlsWithContextArgsForCall = append(fake.getBucketOwnershipControlsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketOwnershipControlsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketOwnershipControlsWithContextStub - fakeReturns := fake.getBucketOwnershipControlsWithContextReturns - fake.recordInvocation("GetBucketOwnershipControlsWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketOwnershipControlsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsWithContextCallCount() int { - fake.getBucketOwnershipControlsWithContextMutex.RLock() - defer fake.getBucketOwnershipControlsWithContextMutex.RUnlock() - return len(fake.getBucketOwnershipControlsWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsWithContextCalls(stub func(context.Context, *s3.GetBucketOwnershipControlsInput, ...request.Option) (*s3.GetBucketOwnershipControlsOutput, error)) { - fake.getBucketOwnershipControlsWithContextMutex.Lock() - defer fake.getBucketOwnershipControlsWithContextMutex.Unlock() - fake.GetBucketOwnershipControlsWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsWithContextArgsForCall(i int) (context.Context, *s3.GetBucketOwnershipControlsInput, []request.Option) { - fake.getBucketOwnershipControlsWithContextMutex.RLock() - defer fake.getBucketOwnershipControlsWithContextMutex.RUnlock() - argsForCall := fake.getBucketOwnershipControlsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsWithContextReturns(result1 *s3.GetBucketOwnershipControlsOutput, result2 error) { - fake.getBucketOwnershipControlsWithContextMutex.Lock() - defer fake.getBucketOwnershipControlsWithContextMutex.Unlock() - fake.GetBucketOwnershipControlsWithContextStub = nil - fake.getBucketOwnershipControlsWithContextReturns = struct { - result1 *s3.GetBucketOwnershipControlsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketOwnershipControlsWithContextReturnsOnCall(i int, result1 *s3.GetBucketOwnershipControlsOutput, result2 error) { - fake.getBucketOwnershipControlsWithContextMutex.Lock() - defer fake.getBucketOwnershipControlsWithContextMutex.Unlock() - fake.GetBucketOwnershipControlsWithContextStub = nil - if fake.getBucketOwnershipControlsWithContextReturnsOnCall == nil { - fake.getBucketOwnershipControlsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketOwnershipControlsOutput - result2 error - }) - } - fake.getBucketOwnershipControlsWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketOwnershipControlsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketPolicy(arg1 *s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error) { - fake.getBucketPolicyMutex.Lock() - ret, specificReturn := fake.getBucketPolicyReturnsOnCall[len(fake.getBucketPolicyArgsForCall)] - fake.getBucketPolicyArgsForCall = append(fake.getBucketPolicyArgsForCall, struct { - arg1 *s3.GetBucketPolicyInput - }{arg1}) - stub := fake.GetBucketPolicyStub - fakeReturns := fake.getBucketPolicyReturns - fake.recordInvocation("GetBucketPolicy", []interface{}{arg1}) - fake.getBucketPolicyMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketPolicyCallCount() int { - fake.getBucketPolicyMutex.RLock() - defer fake.getBucketPolicyMutex.RUnlock() - return len(fake.getBucketPolicyArgsForCall) -} - -func (fake *FakeS3Client) GetBucketPolicyCalls(stub func(*s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error)) { - fake.getBucketPolicyMutex.Lock() - defer fake.getBucketPolicyMutex.Unlock() - fake.GetBucketPolicyStub = stub -} - -func (fake *FakeS3Client) GetBucketPolicyArgsForCall(i int) *s3.GetBucketPolicyInput { - fake.getBucketPolicyMutex.RLock() - defer fake.getBucketPolicyMutex.RUnlock() - argsForCall := fake.getBucketPolicyArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketPolicyReturns(result1 *s3.GetBucketPolicyOutput, result2 error) { - fake.getBucketPolicyMutex.Lock() - defer fake.getBucketPolicyMutex.Unlock() - fake.GetBucketPolicyStub = nil - fake.getBucketPolicyReturns = struct { - result1 *s3.GetBucketPolicyOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketPolicyReturnsOnCall(i int, result1 *s3.GetBucketPolicyOutput, result2 error) { - fake.getBucketPolicyMutex.Lock() - defer fake.getBucketPolicyMutex.Unlock() - fake.GetBucketPolicyStub = nil - if fake.getBucketPolicyReturnsOnCall == nil { - fake.getBucketPolicyReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketPolicyOutput - result2 error - }) - } - fake.getBucketPolicyReturnsOnCall[i] = struct { - result1 *s3.GetBucketPolicyOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketPolicyRequest(arg1 *s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput) { - fake.getBucketPolicyRequestMutex.Lock() - ret, specificReturn := fake.getBucketPolicyRequestReturnsOnCall[len(fake.getBucketPolicyRequestArgsForCall)] - fake.getBucketPolicyRequestArgsForCall = append(fake.getBucketPolicyRequestArgsForCall, struct { - arg1 *s3.GetBucketPolicyInput - }{arg1}) - stub := fake.GetBucketPolicyRequestStub - fakeReturns := fake.getBucketPolicyRequestReturns - fake.recordInvocation("GetBucketPolicyRequest", []interface{}{arg1}) - fake.getBucketPolicyRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketPolicyRequestCallCount() int { - fake.getBucketPolicyRequestMutex.RLock() - defer fake.getBucketPolicyRequestMutex.RUnlock() - return len(fake.getBucketPolicyRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketPolicyRequestCalls(stub func(*s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput)) { - fake.getBucketPolicyRequestMutex.Lock() - defer fake.getBucketPolicyRequestMutex.Unlock() - fake.GetBucketPolicyRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketPolicyRequestArgsForCall(i int) *s3.GetBucketPolicyInput { - fake.getBucketPolicyRequestMutex.RLock() - defer fake.getBucketPolicyRequestMutex.RUnlock() - argsForCall := fake.getBucketPolicyRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketPolicyRequestReturns(result1 *request.Request, result2 *s3.GetBucketPolicyOutput) { - fake.getBucketPolicyRequestMutex.Lock() - defer fake.getBucketPolicyRequestMutex.Unlock() - fake.GetBucketPolicyRequestStub = nil - fake.getBucketPolicyRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketPolicyOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketPolicyRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketPolicyOutput) { - fake.getBucketPolicyRequestMutex.Lock() - defer fake.getBucketPolicyRequestMutex.Unlock() - fake.GetBucketPolicyRequestStub = nil - if fake.getBucketPolicyRequestReturnsOnCall == nil { - fake.getBucketPolicyRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketPolicyOutput - }) - } - fake.getBucketPolicyRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketPolicyOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketPolicyStatus(arg1 *s3.GetBucketPolicyStatusInput) (*s3.GetBucketPolicyStatusOutput, error) { - fake.getBucketPolicyStatusMutex.Lock() - ret, specificReturn := fake.getBucketPolicyStatusReturnsOnCall[len(fake.getBucketPolicyStatusArgsForCall)] - fake.getBucketPolicyStatusArgsForCall = append(fake.getBucketPolicyStatusArgsForCall, struct { - arg1 *s3.GetBucketPolicyStatusInput - }{arg1}) - stub := fake.GetBucketPolicyStatusStub - fakeReturns := fake.getBucketPolicyStatusReturns - fake.recordInvocation("GetBucketPolicyStatus", []interface{}{arg1}) - fake.getBucketPolicyStatusMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketPolicyStatusCallCount() int { - fake.getBucketPolicyStatusMutex.RLock() - defer fake.getBucketPolicyStatusMutex.RUnlock() - return len(fake.getBucketPolicyStatusArgsForCall) -} - -func (fake *FakeS3Client) GetBucketPolicyStatusCalls(stub func(*s3.GetBucketPolicyStatusInput) (*s3.GetBucketPolicyStatusOutput, error)) { - fake.getBucketPolicyStatusMutex.Lock() - defer fake.getBucketPolicyStatusMutex.Unlock() - fake.GetBucketPolicyStatusStub = stub -} - -func (fake *FakeS3Client) GetBucketPolicyStatusArgsForCall(i int) *s3.GetBucketPolicyStatusInput { - fake.getBucketPolicyStatusMutex.RLock() - defer fake.getBucketPolicyStatusMutex.RUnlock() - argsForCall := fake.getBucketPolicyStatusArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketPolicyStatusReturns(result1 *s3.GetBucketPolicyStatusOutput, result2 error) { - fake.getBucketPolicyStatusMutex.Lock() - defer fake.getBucketPolicyStatusMutex.Unlock() - fake.GetBucketPolicyStatusStub = nil - fake.getBucketPolicyStatusReturns = struct { - result1 *s3.GetBucketPolicyStatusOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketPolicyStatusReturnsOnCall(i int, result1 *s3.GetBucketPolicyStatusOutput, result2 error) { - fake.getBucketPolicyStatusMutex.Lock() - defer fake.getBucketPolicyStatusMutex.Unlock() - fake.GetBucketPolicyStatusStub = nil - if fake.getBucketPolicyStatusReturnsOnCall == nil { - fake.getBucketPolicyStatusReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketPolicyStatusOutput - result2 error - }) - } - fake.getBucketPolicyStatusReturnsOnCall[i] = struct { - result1 *s3.GetBucketPolicyStatusOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketPolicyStatusRequest(arg1 *s3.GetBucketPolicyStatusInput) (*request.Request, *s3.GetBucketPolicyStatusOutput) { - fake.getBucketPolicyStatusRequestMutex.Lock() - ret, specificReturn := fake.getBucketPolicyStatusRequestReturnsOnCall[len(fake.getBucketPolicyStatusRequestArgsForCall)] - fake.getBucketPolicyStatusRequestArgsForCall = append(fake.getBucketPolicyStatusRequestArgsForCall, struct { - arg1 *s3.GetBucketPolicyStatusInput - }{arg1}) - stub := fake.GetBucketPolicyStatusRequestStub - fakeReturns := fake.getBucketPolicyStatusRequestReturns - fake.recordInvocation("GetBucketPolicyStatusRequest", []interface{}{arg1}) - fake.getBucketPolicyStatusRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketPolicyStatusRequestCallCount() int { - fake.getBucketPolicyStatusRequestMutex.RLock() - defer fake.getBucketPolicyStatusRequestMutex.RUnlock() - return len(fake.getBucketPolicyStatusRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketPolicyStatusRequestCalls(stub func(*s3.GetBucketPolicyStatusInput) (*request.Request, *s3.GetBucketPolicyStatusOutput)) { - fake.getBucketPolicyStatusRequestMutex.Lock() - defer fake.getBucketPolicyStatusRequestMutex.Unlock() - fake.GetBucketPolicyStatusRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketPolicyStatusRequestArgsForCall(i int) *s3.GetBucketPolicyStatusInput { - fake.getBucketPolicyStatusRequestMutex.RLock() - defer fake.getBucketPolicyStatusRequestMutex.RUnlock() - argsForCall := fake.getBucketPolicyStatusRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketPolicyStatusRequestReturns(result1 *request.Request, result2 *s3.GetBucketPolicyStatusOutput) { - fake.getBucketPolicyStatusRequestMutex.Lock() - defer fake.getBucketPolicyStatusRequestMutex.Unlock() - fake.GetBucketPolicyStatusRequestStub = nil - fake.getBucketPolicyStatusRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketPolicyStatusOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketPolicyStatusRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketPolicyStatusOutput) { - fake.getBucketPolicyStatusRequestMutex.Lock() - defer fake.getBucketPolicyStatusRequestMutex.Unlock() - fake.GetBucketPolicyStatusRequestStub = nil - if fake.getBucketPolicyStatusRequestReturnsOnCall == nil { - fake.getBucketPolicyStatusRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketPolicyStatusOutput - }) - } - fake.getBucketPolicyStatusRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketPolicyStatusOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketPolicyStatusWithContext(arg1 context.Context, arg2 *s3.GetBucketPolicyStatusInput, arg3 ...request.Option) (*s3.GetBucketPolicyStatusOutput, error) { - fake.getBucketPolicyStatusWithContextMutex.Lock() - ret, specificReturn := fake.getBucketPolicyStatusWithContextReturnsOnCall[len(fake.getBucketPolicyStatusWithContextArgsForCall)] - fake.getBucketPolicyStatusWithContextArgsForCall = append(fake.getBucketPolicyStatusWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketPolicyStatusInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketPolicyStatusWithContextStub - fakeReturns := fake.getBucketPolicyStatusWithContextReturns - fake.recordInvocation("GetBucketPolicyStatusWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketPolicyStatusWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketPolicyStatusWithContextCallCount() int { - fake.getBucketPolicyStatusWithContextMutex.RLock() - defer fake.getBucketPolicyStatusWithContextMutex.RUnlock() - return len(fake.getBucketPolicyStatusWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketPolicyStatusWithContextCalls(stub func(context.Context, *s3.GetBucketPolicyStatusInput, ...request.Option) (*s3.GetBucketPolicyStatusOutput, error)) { - fake.getBucketPolicyStatusWithContextMutex.Lock() - defer fake.getBucketPolicyStatusWithContextMutex.Unlock() - fake.GetBucketPolicyStatusWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketPolicyStatusWithContextArgsForCall(i int) (context.Context, *s3.GetBucketPolicyStatusInput, []request.Option) { - fake.getBucketPolicyStatusWithContextMutex.RLock() - defer fake.getBucketPolicyStatusWithContextMutex.RUnlock() - argsForCall := fake.getBucketPolicyStatusWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketPolicyStatusWithContextReturns(result1 *s3.GetBucketPolicyStatusOutput, result2 error) { - fake.getBucketPolicyStatusWithContextMutex.Lock() - defer fake.getBucketPolicyStatusWithContextMutex.Unlock() - fake.GetBucketPolicyStatusWithContextStub = nil - fake.getBucketPolicyStatusWithContextReturns = struct { - result1 *s3.GetBucketPolicyStatusOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketPolicyStatusWithContextReturnsOnCall(i int, result1 *s3.GetBucketPolicyStatusOutput, result2 error) { - fake.getBucketPolicyStatusWithContextMutex.Lock() - defer fake.getBucketPolicyStatusWithContextMutex.Unlock() - fake.GetBucketPolicyStatusWithContextStub = nil - if fake.getBucketPolicyStatusWithContextReturnsOnCall == nil { - fake.getBucketPolicyStatusWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketPolicyStatusOutput - result2 error - }) - } - fake.getBucketPolicyStatusWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketPolicyStatusOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketPolicyWithContext(arg1 context.Context, arg2 *s3.GetBucketPolicyInput, arg3 ...request.Option) (*s3.GetBucketPolicyOutput, error) { - fake.getBucketPolicyWithContextMutex.Lock() - ret, specificReturn := fake.getBucketPolicyWithContextReturnsOnCall[len(fake.getBucketPolicyWithContextArgsForCall)] - fake.getBucketPolicyWithContextArgsForCall = append(fake.getBucketPolicyWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketPolicyInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketPolicyWithContextStub - fakeReturns := fake.getBucketPolicyWithContextReturns - fake.recordInvocation("GetBucketPolicyWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketPolicyWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketPolicyWithContextCallCount() int { - fake.getBucketPolicyWithContextMutex.RLock() - defer fake.getBucketPolicyWithContextMutex.RUnlock() - return len(fake.getBucketPolicyWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketPolicyWithContextCalls(stub func(context.Context, *s3.GetBucketPolicyInput, ...request.Option) (*s3.GetBucketPolicyOutput, error)) { - fake.getBucketPolicyWithContextMutex.Lock() - defer fake.getBucketPolicyWithContextMutex.Unlock() - fake.GetBucketPolicyWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketPolicyWithContextArgsForCall(i int) (context.Context, *s3.GetBucketPolicyInput, []request.Option) { - fake.getBucketPolicyWithContextMutex.RLock() - defer fake.getBucketPolicyWithContextMutex.RUnlock() - argsForCall := fake.getBucketPolicyWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketPolicyWithContextReturns(result1 *s3.GetBucketPolicyOutput, result2 error) { - fake.getBucketPolicyWithContextMutex.Lock() - defer fake.getBucketPolicyWithContextMutex.Unlock() - fake.GetBucketPolicyWithContextStub = nil - fake.getBucketPolicyWithContextReturns = struct { - result1 *s3.GetBucketPolicyOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketPolicyWithContextReturnsOnCall(i int, result1 *s3.GetBucketPolicyOutput, result2 error) { - fake.getBucketPolicyWithContextMutex.Lock() - defer fake.getBucketPolicyWithContextMutex.Unlock() - fake.GetBucketPolicyWithContextStub = nil - if fake.getBucketPolicyWithContextReturnsOnCall == nil { - fake.getBucketPolicyWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketPolicyOutput - result2 error - }) - } - fake.getBucketPolicyWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketPolicyOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketReplication(arg1 *s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error) { - fake.getBucketReplicationMutex.Lock() - ret, specificReturn := fake.getBucketReplicationReturnsOnCall[len(fake.getBucketReplicationArgsForCall)] - fake.getBucketReplicationArgsForCall = append(fake.getBucketReplicationArgsForCall, struct { - arg1 *s3.GetBucketReplicationInput - }{arg1}) - stub := fake.GetBucketReplicationStub - fakeReturns := fake.getBucketReplicationReturns - fake.recordInvocation("GetBucketReplication", []interface{}{arg1}) - fake.getBucketReplicationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketReplicationCallCount() int { - fake.getBucketReplicationMutex.RLock() - defer fake.getBucketReplicationMutex.RUnlock() - return len(fake.getBucketReplicationArgsForCall) -} - -func (fake *FakeS3Client) GetBucketReplicationCalls(stub func(*s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error)) { - fake.getBucketReplicationMutex.Lock() - defer fake.getBucketReplicationMutex.Unlock() - fake.GetBucketReplicationStub = stub -} - -func (fake *FakeS3Client) GetBucketReplicationArgsForCall(i int) *s3.GetBucketReplicationInput { - fake.getBucketReplicationMutex.RLock() - defer fake.getBucketReplicationMutex.RUnlock() - argsForCall := fake.getBucketReplicationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketReplicationReturns(result1 *s3.GetBucketReplicationOutput, result2 error) { - fake.getBucketReplicationMutex.Lock() - defer fake.getBucketReplicationMutex.Unlock() - fake.GetBucketReplicationStub = nil - fake.getBucketReplicationReturns = struct { - result1 *s3.GetBucketReplicationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketReplicationReturnsOnCall(i int, result1 *s3.GetBucketReplicationOutput, result2 error) { - fake.getBucketReplicationMutex.Lock() - defer fake.getBucketReplicationMutex.Unlock() - fake.GetBucketReplicationStub = nil - if fake.getBucketReplicationReturnsOnCall == nil { - fake.getBucketReplicationReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketReplicationOutput - result2 error - }) - } - fake.getBucketReplicationReturnsOnCall[i] = struct { - result1 *s3.GetBucketReplicationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketReplicationRequest(arg1 *s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput) { - fake.getBucketReplicationRequestMutex.Lock() - ret, specificReturn := fake.getBucketReplicationRequestReturnsOnCall[len(fake.getBucketReplicationRequestArgsForCall)] - fake.getBucketReplicationRequestArgsForCall = append(fake.getBucketReplicationRequestArgsForCall, struct { - arg1 *s3.GetBucketReplicationInput - }{arg1}) - stub := fake.GetBucketReplicationRequestStub - fakeReturns := fake.getBucketReplicationRequestReturns - fake.recordInvocation("GetBucketReplicationRequest", []interface{}{arg1}) - fake.getBucketReplicationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketReplicationRequestCallCount() int { - fake.getBucketReplicationRequestMutex.RLock() - defer fake.getBucketReplicationRequestMutex.RUnlock() - return len(fake.getBucketReplicationRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketReplicationRequestCalls(stub func(*s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput)) { - fake.getBucketReplicationRequestMutex.Lock() - defer fake.getBucketReplicationRequestMutex.Unlock() - fake.GetBucketReplicationRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketReplicationRequestArgsForCall(i int) *s3.GetBucketReplicationInput { - fake.getBucketReplicationRequestMutex.RLock() - defer fake.getBucketReplicationRequestMutex.RUnlock() - argsForCall := fake.getBucketReplicationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketReplicationRequestReturns(result1 *request.Request, result2 *s3.GetBucketReplicationOutput) { - fake.getBucketReplicationRequestMutex.Lock() - defer fake.getBucketReplicationRequestMutex.Unlock() - fake.GetBucketReplicationRequestStub = nil - fake.getBucketReplicationRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketReplicationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketReplicationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketReplicationOutput) { - fake.getBucketReplicationRequestMutex.Lock() - defer fake.getBucketReplicationRequestMutex.Unlock() - fake.GetBucketReplicationRequestStub = nil - if fake.getBucketReplicationRequestReturnsOnCall == nil { - fake.getBucketReplicationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketReplicationOutput - }) - } - fake.getBucketReplicationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketReplicationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketReplicationWithContext(arg1 context.Context, arg2 *s3.GetBucketReplicationInput, arg3 ...request.Option) (*s3.GetBucketReplicationOutput, error) { - fake.getBucketReplicationWithContextMutex.Lock() - ret, specificReturn := fake.getBucketReplicationWithContextReturnsOnCall[len(fake.getBucketReplicationWithContextArgsForCall)] - fake.getBucketReplicationWithContextArgsForCall = append(fake.getBucketReplicationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketReplicationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketReplicationWithContextStub - fakeReturns := fake.getBucketReplicationWithContextReturns - fake.recordInvocation("GetBucketReplicationWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketReplicationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketReplicationWithContextCallCount() int { - fake.getBucketReplicationWithContextMutex.RLock() - defer fake.getBucketReplicationWithContextMutex.RUnlock() - return len(fake.getBucketReplicationWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketReplicationWithContextCalls(stub func(context.Context, *s3.GetBucketReplicationInput, ...request.Option) (*s3.GetBucketReplicationOutput, error)) { - fake.getBucketReplicationWithContextMutex.Lock() - defer fake.getBucketReplicationWithContextMutex.Unlock() - fake.GetBucketReplicationWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketReplicationWithContextArgsForCall(i int) (context.Context, *s3.GetBucketReplicationInput, []request.Option) { - fake.getBucketReplicationWithContextMutex.RLock() - defer fake.getBucketReplicationWithContextMutex.RUnlock() - argsForCall := fake.getBucketReplicationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketReplicationWithContextReturns(result1 *s3.GetBucketReplicationOutput, result2 error) { - fake.getBucketReplicationWithContextMutex.Lock() - defer fake.getBucketReplicationWithContextMutex.Unlock() - fake.GetBucketReplicationWithContextStub = nil - fake.getBucketReplicationWithContextReturns = struct { - result1 *s3.GetBucketReplicationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketReplicationWithContextReturnsOnCall(i int, result1 *s3.GetBucketReplicationOutput, result2 error) { - fake.getBucketReplicationWithContextMutex.Lock() - defer fake.getBucketReplicationWithContextMutex.Unlock() - fake.GetBucketReplicationWithContextStub = nil - if fake.getBucketReplicationWithContextReturnsOnCall == nil { - fake.getBucketReplicationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketReplicationOutput - result2 error - }) - } - fake.getBucketReplicationWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketReplicationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketRequestPayment(arg1 *s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error) { - fake.getBucketRequestPaymentMutex.Lock() - ret, specificReturn := fake.getBucketRequestPaymentReturnsOnCall[len(fake.getBucketRequestPaymentArgsForCall)] - fake.getBucketRequestPaymentArgsForCall = append(fake.getBucketRequestPaymentArgsForCall, struct { - arg1 *s3.GetBucketRequestPaymentInput - }{arg1}) - stub := fake.GetBucketRequestPaymentStub - fakeReturns := fake.getBucketRequestPaymentReturns - fake.recordInvocation("GetBucketRequestPayment", []interface{}{arg1}) - fake.getBucketRequestPaymentMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketRequestPaymentCallCount() int { - fake.getBucketRequestPaymentMutex.RLock() - defer fake.getBucketRequestPaymentMutex.RUnlock() - return len(fake.getBucketRequestPaymentArgsForCall) -} - -func (fake *FakeS3Client) GetBucketRequestPaymentCalls(stub func(*s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error)) { - fake.getBucketRequestPaymentMutex.Lock() - defer fake.getBucketRequestPaymentMutex.Unlock() - fake.GetBucketRequestPaymentStub = stub -} - -func (fake *FakeS3Client) GetBucketRequestPaymentArgsForCall(i int) *s3.GetBucketRequestPaymentInput { - fake.getBucketRequestPaymentMutex.RLock() - defer fake.getBucketRequestPaymentMutex.RUnlock() - argsForCall := fake.getBucketRequestPaymentArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketRequestPaymentReturns(result1 *s3.GetBucketRequestPaymentOutput, result2 error) { - fake.getBucketRequestPaymentMutex.Lock() - defer fake.getBucketRequestPaymentMutex.Unlock() - fake.GetBucketRequestPaymentStub = nil - fake.getBucketRequestPaymentReturns = struct { - result1 *s3.GetBucketRequestPaymentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketRequestPaymentReturnsOnCall(i int, result1 *s3.GetBucketRequestPaymentOutput, result2 error) { - fake.getBucketRequestPaymentMutex.Lock() - defer fake.getBucketRequestPaymentMutex.Unlock() - fake.GetBucketRequestPaymentStub = nil - if fake.getBucketRequestPaymentReturnsOnCall == nil { - fake.getBucketRequestPaymentReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketRequestPaymentOutput - result2 error - }) - } - fake.getBucketRequestPaymentReturnsOnCall[i] = struct { - result1 *s3.GetBucketRequestPaymentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketRequestPaymentRequest(arg1 *s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput) { - fake.getBucketRequestPaymentRequestMutex.Lock() - ret, specificReturn := fake.getBucketRequestPaymentRequestReturnsOnCall[len(fake.getBucketRequestPaymentRequestArgsForCall)] - fake.getBucketRequestPaymentRequestArgsForCall = append(fake.getBucketRequestPaymentRequestArgsForCall, struct { - arg1 *s3.GetBucketRequestPaymentInput - }{arg1}) - stub := fake.GetBucketRequestPaymentRequestStub - fakeReturns := fake.getBucketRequestPaymentRequestReturns - fake.recordInvocation("GetBucketRequestPaymentRequest", []interface{}{arg1}) - fake.getBucketRequestPaymentRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketRequestPaymentRequestCallCount() int { - fake.getBucketRequestPaymentRequestMutex.RLock() - defer fake.getBucketRequestPaymentRequestMutex.RUnlock() - return len(fake.getBucketRequestPaymentRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketRequestPaymentRequestCalls(stub func(*s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput)) { - fake.getBucketRequestPaymentRequestMutex.Lock() - defer fake.getBucketRequestPaymentRequestMutex.Unlock() - fake.GetBucketRequestPaymentRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketRequestPaymentRequestArgsForCall(i int) *s3.GetBucketRequestPaymentInput { - fake.getBucketRequestPaymentRequestMutex.RLock() - defer fake.getBucketRequestPaymentRequestMutex.RUnlock() - argsForCall := fake.getBucketRequestPaymentRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketRequestPaymentRequestReturns(result1 *request.Request, result2 *s3.GetBucketRequestPaymentOutput) { - fake.getBucketRequestPaymentRequestMutex.Lock() - defer fake.getBucketRequestPaymentRequestMutex.Unlock() - fake.GetBucketRequestPaymentRequestStub = nil - fake.getBucketRequestPaymentRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketRequestPaymentOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketRequestPaymentRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketRequestPaymentOutput) { - fake.getBucketRequestPaymentRequestMutex.Lock() - defer fake.getBucketRequestPaymentRequestMutex.Unlock() - fake.GetBucketRequestPaymentRequestStub = nil - if fake.getBucketRequestPaymentRequestReturnsOnCall == nil { - fake.getBucketRequestPaymentRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketRequestPaymentOutput - }) - } - fake.getBucketRequestPaymentRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketRequestPaymentOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketRequestPaymentWithContext(arg1 context.Context, arg2 *s3.GetBucketRequestPaymentInput, arg3 ...request.Option) (*s3.GetBucketRequestPaymentOutput, error) { - fake.getBucketRequestPaymentWithContextMutex.Lock() - ret, specificReturn := fake.getBucketRequestPaymentWithContextReturnsOnCall[len(fake.getBucketRequestPaymentWithContextArgsForCall)] - fake.getBucketRequestPaymentWithContextArgsForCall = append(fake.getBucketRequestPaymentWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketRequestPaymentInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketRequestPaymentWithContextStub - fakeReturns := fake.getBucketRequestPaymentWithContextReturns - fake.recordInvocation("GetBucketRequestPaymentWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketRequestPaymentWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketRequestPaymentWithContextCallCount() int { - fake.getBucketRequestPaymentWithContextMutex.RLock() - defer fake.getBucketRequestPaymentWithContextMutex.RUnlock() - return len(fake.getBucketRequestPaymentWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketRequestPaymentWithContextCalls(stub func(context.Context, *s3.GetBucketRequestPaymentInput, ...request.Option) (*s3.GetBucketRequestPaymentOutput, error)) { - fake.getBucketRequestPaymentWithContextMutex.Lock() - defer fake.getBucketRequestPaymentWithContextMutex.Unlock() - fake.GetBucketRequestPaymentWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketRequestPaymentWithContextArgsForCall(i int) (context.Context, *s3.GetBucketRequestPaymentInput, []request.Option) { - fake.getBucketRequestPaymentWithContextMutex.RLock() - defer fake.getBucketRequestPaymentWithContextMutex.RUnlock() - argsForCall := fake.getBucketRequestPaymentWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketRequestPaymentWithContextReturns(result1 *s3.GetBucketRequestPaymentOutput, result2 error) { - fake.getBucketRequestPaymentWithContextMutex.Lock() - defer fake.getBucketRequestPaymentWithContextMutex.Unlock() - fake.GetBucketRequestPaymentWithContextStub = nil - fake.getBucketRequestPaymentWithContextReturns = struct { - result1 *s3.GetBucketRequestPaymentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketRequestPaymentWithContextReturnsOnCall(i int, result1 *s3.GetBucketRequestPaymentOutput, result2 error) { - fake.getBucketRequestPaymentWithContextMutex.Lock() - defer fake.getBucketRequestPaymentWithContextMutex.Unlock() - fake.GetBucketRequestPaymentWithContextStub = nil - if fake.getBucketRequestPaymentWithContextReturnsOnCall == nil { - fake.getBucketRequestPaymentWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketRequestPaymentOutput - result2 error - }) - } - fake.getBucketRequestPaymentWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketRequestPaymentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketTagging(arg1 *s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error) { - fake.getBucketTaggingMutex.Lock() - ret, specificReturn := fake.getBucketTaggingReturnsOnCall[len(fake.getBucketTaggingArgsForCall)] - fake.getBucketTaggingArgsForCall = append(fake.getBucketTaggingArgsForCall, struct { - arg1 *s3.GetBucketTaggingInput - }{arg1}) - stub := fake.GetBucketTaggingStub - fakeReturns := fake.getBucketTaggingReturns - fake.recordInvocation("GetBucketTagging", []interface{}{arg1}) - fake.getBucketTaggingMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketTaggingCallCount() int { - fake.getBucketTaggingMutex.RLock() - defer fake.getBucketTaggingMutex.RUnlock() - return len(fake.getBucketTaggingArgsForCall) -} - -func (fake *FakeS3Client) GetBucketTaggingCalls(stub func(*s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error)) { - fake.getBucketTaggingMutex.Lock() - defer fake.getBucketTaggingMutex.Unlock() - fake.GetBucketTaggingStub = stub -} - -func (fake *FakeS3Client) GetBucketTaggingArgsForCall(i int) *s3.GetBucketTaggingInput { - fake.getBucketTaggingMutex.RLock() - defer fake.getBucketTaggingMutex.RUnlock() - argsForCall := fake.getBucketTaggingArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketTaggingReturns(result1 *s3.GetBucketTaggingOutput, result2 error) { - fake.getBucketTaggingMutex.Lock() - defer fake.getBucketTaggingMutex.Unlock() - fake.GetBucketTaggingStub = nil - fake.getBucketTaggingReturns = struct { - result1 *s3.GetBucketTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketTaggingReturnsOnCall(i int, result1 *s3.GetBucketTaggingOutput, result2 error) { - fake.getBucketTaggingMutex.Lock() - defer fake.getBucketTaggingMutex.Unlock() - fake.GetBucketTaggingStub = nil - if fake.getBucketTaggingReturnsOnCall == nil { - fake.getBucketTaggingReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketTaggingOutput - result2 error - }) - } - fake.getBucketTaggingReturnsOnCall[i] = struct { - result1 *s3.GetBucketTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketTaggingRequest(arg1 *s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput) { - fake.getBucketTaggingRequestMutex.Lock() - ret, specificReturn := fake.getBucketTaggingRequestReturnsOnCall[len(fake.getBucketTaggingRequestArgsForCall)] - fake.getBucketTaggingRequestArgsForCall = append(fake.getBucketTaggingRequestArgsForCall, struct { - arg1 *s3.GetBucketTaggingInput - }{arg1}) - stub := fake.GetBucketTaggingRequestStub - fakeReturns := fake.getBucketTaggingRequestReturns - fake.recordInvocation("GetBucketTaggingRequest", []interface{}{arg1}) - fake.getBucketTaggingRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketTaggingRequestCallCount() int { - fake.getBucketTaggingRequestMutex.RLock() - defer fake.getBucketTaggingRequestMutex.RUnlock() - return len(fake.getBucketTaggingRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketTaggingRequestCalls(stub func(*s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput)) { - fake.getBucketTaggingRequestMutex.Lock() - defer fake.getBucketTaggingRequestMutex.Unlock() - fake.GetBucketTaggingRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketTaggingRequestArgsForCall(i int) *s3.GetBucketTaggingInput { - fake.getBucketTaggingRequestMutex.RLock() - defer fake.getBucketTaggingRequestMutex.RUnlock() - argsForCall := fake.getBucketTaggingRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketTaggingRequestReturns(result1 *request.Request, result2 *s3.GetBucketTaggingOutput) { - fake.getBucketTaggingRequestMutex.Lock() - defer fake.getBucketTaggingRequestMutex.Unlock() - fake.GetBucketTaggingRequestStub = nil - fake.getBucketTaggingRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketTaggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketTaggingRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketTaggingOutput) { - fake.getBucketTaggingRequestMutex.Lock() - defer fake.getBucketTaggingRequestMutex.Unlock() - fake.GetBucketTaggingRequestStub = nil - if fake.getBucketTaggingRequestReturnsOnCall == nil { - fake.getBucketTaggingRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketTaggingOutput - }) - } - fake.getBucketTaggingRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketTaggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketTaggingWithContext(arg1 context.Context, arg2 *s3.GetBucketTaggingInput, arg3 ...request.Option) (*s3.GetBucketTaggingOutput, error) { - fake.getBucketTaggingWithContextMutex.Lock() - ret, specificReturn := fake.getBucketTaggingWithContextReturnsOnCall[len(fake.getBucketTaggingWithContextArgsForCall)] - fake.getBucketTaggingWithContextArgsForCall = append(fake.getBucketTaggingWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketTaggingInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketTaggingWithContextStub - fakeReturns := fake.getBucketTaggingWithContextReturns - fake.recordInvocation("GetBucketTaggingWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketTaggingWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketTaggingWithContextCallCount() int { - fake.getBucketTaggingWithContextMutex.RLock() - defer fake.getBucketTaggingWithContextMutex.RUnlock() - return len(fake.getBucketTaggingWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketTaggingWithContextCalls(stub func(context.Context, *s3.GetBucketTaggingInput, ...request.Option) (*s3.GetBucketTaggingOutput, error)) { - fake.getBucketTaggingWithContextMutex.Lock() - defer fake.getBucketTaggingWithContextMutex.Unlock() - fake.GetBucketTaggingWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketTaggingWithContextArgsForCall(i int) (context.Context, *s3.GetBucketTaggingInput, []request.Option) { - fake.getBucketTaggingWithContextMutex.RLock() - defer fake.getBucketTaggingWithContextMutex.RUnlock() - argsForCall := fake.getBucketTaggingWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketTaggingWithContextReturns(result1 *s3.GetBucketTaggingOutput, result2 error) { - fake.getBucketTaggingWithContextMutex.Lock() - defer fake.getBucketTaggingWithContextMutex.Unlock() - fake.GetBucketTaggingWithContextStub = nil - fake.getBucketTaggingWithContextReturns = struct { - result1 *s3.GetBucketTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketTaggingWithContextReturnsOnCall(i int, result1 *s3.GetBucketTaggingOutput, result2 error) { - fake.getBucketTaggingWithContextMutex.Lock() - defer fake.getBucketTaggingWithContextMutex.Unlock() - fake.GetBucketTaggingWithContextStub = nil - if fake.getBucketTaggingWithContextReturnsOnCall == nil { - fake.getBucketTaggingWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketTaggingOutput - result2 error - }) - } - fake.getBucketTaggingWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketVersioning(arg1 *s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error) { - fake.getBucketVersioningMutex.Lock() - ret, specificReturn := fake.getBucketVersioningReturnsOnCall[len(fake.getBucketVersioningArgsForCall)] - fake.getBucketVersioningArgsForCall = append(fake.getBucketVersioningArgsForCall, struct { - arg1 *s3.GetBucketVersioningInput - }{arg1}) - stub := fake.GetBucketVersioningStub - fakeReturns := fake.getBucketVersioningReturns - fake.recordInvocation("GetBucketVersioning", []interface{}{arg1}) - fake.getBucketVersioningMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketVersioningCallCount() int { - fake.getBucketVersioningMutex.RLock() - defer fake.getBucketVersioningMutex.RUnlock() - return len(fake.getBucketVersioningArgsForCall) -} - -func (fake *FakeS3Client) GetBucketVersioningCalls(stub func(*s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error)) { - fake.getBucketVersioningMutex.Lock() - defer fake.getBucketVersioningMutex.Unlock() - fake.GetBucketVersioningStub = stub -} - -func (fake *FakeS3Client) GetBucketVersioningArgsForCall(i int) *s3.GetBucketVersioningInput { - fake.getBucketVersioningMutex.RLock() - defer fake.getBucketVersioningMutex.RUnlock() - argsForCall := fake.getBucketVersioningArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketVersioningReturns(result1 *s3.GetBucketVersioningOutput, result2 error) { - fake.getBucketVersioningMutex.Lock() - defer fake.getBucketVersioningMutex.Unlock() - fake.GetBucketVersioningStub = nil - fake.getBucketVersioningReturns = struct { - result1 *s3.GetBucketVersioningOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketVersioningReturnsOnCall(i int, result1 *s3.GetBucketVersioningOutput, result2 error) { - fake.getBucketVersioningMutex.Lock() - defer fake.getBucketVersioningMutex.Unlock() - fake.GetBucketVersioningStub = nil - if fake.getBucketVersioningReturnsOnCall == nil { - fake.getBucketVersioningReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketVersioningOutput - result2 error - }) - } - fake.getBucketVersioningReturnsOnCall[i] = struct { - result1 *s3.GetBucketVersioningOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketVersioningRequest(arg1 *s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput) { - fake.getBucketVersioningRequestMutex.Lock() - ret, specificReturn := fake.getBucketVersioningRequestReturnsOnCall[len(fake.getBucketVersioningRequestArgsForCall)] - fake.getBucketVersioningRequestArgsForCall = append(fake.getBucketVersioningRequestArgsForCall, struct { - arg1 *s3.GetBucketVersioningInput - }{arg1}) - stub := fake.GetBucketVersioningRequestStub - fakeReturns := fake.getBucketVersioningRequestReturns - fake.recordInvocation("GetBucketVersioningRequest", []interface{}{arg1}) - fake.getBucketVersioningRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketVersioningRequestCallCount() int { - fake.getBucketVersioningRequestMutex.RLock() - defer fake.getBucketVersioningRequestMutex.RUnlock() - return len(fake.getBucketVersioningRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketVersioningRequestCalls(stub func(*s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput)) { - fake.getBucketVersioningRequestMutex.Lock() - defer fake.getBucketVersioningRequestMutex.Unlock() - fake.GetBucketVersioningRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketVersioningRequestArgsForCall(i int) *s3.GetBucketVersioningInput { - fake.getBucketVersioningRequestMutex.RLock() - defer fake.getBucketVersioningRequestMutex.RUnlock() - argsForCall := fake.getBucketVersioningRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketVersioningRequestReturns(result1 *request.Request, result2 *s3.GetBucketVersioningOutput) { - fake.getBucketVersioningRequestMutex.Lock() - defer fake.getBucketVersioningRequestMutex.Unlock() - fake.GetBucketVersioningRequestStub = nil - fake.getBucketVersioningRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketVersioningOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketVersioningRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketVersioningOutput) { - fake.getBucketVersioningRequestMutex.Lock() - defer fake.getBucketVersioningRequestMutex.Unlock() - fake.GetBucketVersioningRequestStub = nil - if fake.getBucketVersioningRequestReturnsOnCall == nil { - fake.getBucketVersioningRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketVersioningOutput - }) - } - fake.getBucketVersioningRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketVersioningOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketVersioningWithContext(arg1 context.Context, arg2 *s3.GetBucketVersioningInput, arg3 ...request.Option) (*s3.GetBucketVersioningOutput, error) { - fake.getBucketVersioningWithContextMutex.Lock() - ret, specificReturn := fake.getBucketVersioningWithContextReturnsOnCall[len(fake.getBucketVersioningWithContextArgsForCall)] - fake.getBucketVersioningWithContextArgsForCall = append(fake.getBucketVersioningWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketVersioningInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketVersioningWithContextStub - fakeReturns := fake.getBucketVersioningWithContextReturns - fake.recordInvocation("GetBucketVersioningWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketVersioningWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketVersioningWithContextCallCount() int { - fake.getBucketVersioningWithContextMutex.RLock() - defer fake.getBucketVersioningWithContextMutex.RUnlock() - return len(fake.getBucketVersioningWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketVersioningWithContextCalls(stub func(context.Context, *s3.GetBucketVersioningInput, ...request.Option) (*s3.GetBucketVersioningOutput, error)) { - fake.getBucketVersioningWithContextMutex.Lock() - defer fake.getBucketVersioningWithContextMutex.Unlock() - fake.GetBucketVersioningWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketVersioningWithContextArgsForCall(i int) (context.Context, *s3.GetBucketVersioningInput, []request.Option) { - fake.getBucketVersioningWithContextMutex.RLock() - defer fake.getBucketVersioningWithContextMutex.RUnlock() - argsForCall := fake.getBucketVersioningWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketVersioningWithContextReturns(result1 *s3.GetBucketVersioningOutput, result2 error) { - fake.getBucketVersioningWithContextMutex.Lock() - defer fake.getBucketVersioningWithContextMutex.Unlock() - fake.GetBucketVersioningWithContextStub = nil - fake.getBucketVersioningWithContextReturns = struct { - result1 *s3.GetBucketVersioningOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketVersioningWithContextReturnsOnCall(i int, result1 *s3.GetBucketVersioningOutput, result2 error) { - fake.getBucketVersioningWithContextMutex.Lock() - defer fake.getBucketVersioningWithContextMutex.Unlock() - fake.GetBucketVersioningWithContextStub = nil - if fake.getBucketVersioningWithContextReturnsOnCall == nil { - fake.getBucketVersioningWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketVersioningOutput - result2 error - }) - } - fake.getBucketVersioningWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketVersioningOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketWebsite(arg1 *s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error) { - fake.getBucketWebsiteMutex.Lock() - ret, specificReturn := fake.getBucketWebsiteReturnsOnCall[len(fake.getBucketWebsiteArgsForCall)] - fake.getBucketWebsiteArgsForCall = append(fake.getBucketWebsiteArgsForCall, struct { - arg1 *s3.GetBucketWebsiteInput - }{arg1}) - stub := fake.GetBucketWebsiteStub - fakeReturns := fake.getBucketWebsiteReturns - fake.recordInvocation("GetBucketWebsite", []interface{}{arg1}) - fake.getBucketWebsiteMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketWebsiteCallCount() int { - fake.getBucketWebsiteMutex.RLock() - defer fake.getBucketWebsiteMutex.RUnlock() - return len(fake.getBucketWebsiteArgsForCall) -} - -func (fake *FakeS3Client) GetBucketWebsiteCalls(stub func(*s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error)) { - fake.getBucketWebsiteMutex.Lock() - defer fake.getBucketWebsiteMutex.Unlock() - fake.GetBucketWebsiteStub = stub -} - -func (fake *FakeS3Client) GetBucketWebsiteArgsForCall(i int) *s3.GetBucketWebsiteInput { - fake.getBucketWebsiteMutex.RLock() - defer fake.getBucketWebsiteMutex.RUnlock() - argsForCall := fake.getBucketWebsiteArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketWebsiteReturns(result1 *s3.GetBucketWebsiteOutput, result2 error) { - fake.getBucketWebsiteMutex.Lock() - defer fake.getBucketWebsiteMutex.Unlock() - fake.GetBucketWebsiteStub = nil - fake.getBucketWebsiteReturns = struct { - result1 *s3.GetBucketWebsiteOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketWebsiteReturnsOnCall(i int, result1 *s3.GetBucketWebsiteOutput, result2 error) { - fake.getBucketWebsiteMutex.Lock() - defer fake.getBucketWebsiteMutex.Unlock() - fake.GetBucketWebsiteStub = nil - if fake.getBucketWebsiteReturnsOnCall == nil { - fake.getBucketWebsiteReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketWebsiteOutput - result2 error - }) - } - fake.getBucketWebsiteReturnsOnCall[i] = struct { - result1 *s3.GetBucketWebsiteOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketWebsiteRequest(arg1 *s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput) { - fake.getBucketWebsiteRequestMutex.Lock() - ret, specificReturn := fake.getBucketWebsiteRequestReturnsOnCall[len(fake.getBucketWebsiteRequestArgsForCall)] - fake.getBucketWebsiteRequestArgsForCall = append(fake.getBucketWebsiteRequestArgsForCall, struct { - arg1 *s3.GetBucketWebsiteInput - }{arg1}) - stub := fake.GetBucketWebsiteRequestStub - fakeReturns := fake.getBucketWebsiteRequestReturns - fake.recordInvocation("GetBucketWebsiteRequest", []interface{}{arg1}) - fake.getBucketWebsiteRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketWebsiteRequestCallCount() int { - fake.getBucketWebsiteRequestMutex.RLock() - defer fake.getBucketWebsiteRequestMutex.RUnlock() - return len(fake.getBucketWebsiteRequestArgsForCall) -} - -func (fake *FakeS3Client) GetBucketWebsiteRequestCalls(stub func(*s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput)) { - fake.getBucketWebsiteRequestMutex.Lock() - defer fake.getBucketWebsiteRequestMutex.Unlock() - fake.GetBucketWebsiteRequestStub = stub -} - -func (fake *FakeS3Client) GetBucketWebsiteRequestArgsForCall(i int) *s3.GetBucketWebsiteInput { - fake.getBucketWebsiteRequestMutex.RLock() - defer fake.getBucketWebsiteRequestMutex.RUnlock() - argsForCall := fake.getBucketWebsiteRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetBucketWebsiteRequestReturns(result1 *request.Request, result2 *s3.GetBucketWebsiteOutput) { - fake.getBucketWebsiteRequestMutex.Lock() - defer fake.getBucketWebsiteRequestMutex.Unlock() - fake.GetBucketWebsiteRequestStub = nil - fake.getBucketWebsiteRequestReturns = struct { - result1 *request.Request - result2 *s3.GetBucketWebsiteOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketWebsiteRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetBucketWebsiteOutput) { - fake.getBucketWebsiteRequestMutex.Lock() - defer fake.getBucketWebsiteRequestMutex.Unlock() - fake.GetBucketWebsiteRequestStub = nil - if fake.getBucketWebsiteRequestReturnsOnCall == nil { - fake.getBucketWebsiteRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetBucketWebsiteOutput - }) - } - fake.getBucketWebsiteRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetBucketWebsiteOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketWebsiteWithContext(arg1 context.Context, arg2 *s3.GetBucketWebsiteInput, arg3 ...request.Option) (*s3.GetBucketWebsiteOutput, error) { - fake.getBucketWebsiteWithContextMutex.Lock() - ret, specificReturn := fake.getBucketWebsiteWithContextReturnsOnCall[len(fake.getBucketWebsiteWithContextArgsForCall)] - fake.getBucketWebsiteWithContextArgsForCall = append(fake.getBucketWebsiteWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetBucketWebsiteInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetBucketWebsiteWithContextStub - fakeReturns := fake.getBucketWebsiteWithContextReturns - fake.recordInvocation("GetBucketWebsiteWithContext", []interface{}{arg1, arg2, arg3}) - fake.getBucketWebsiteWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetBucketWebsiteWithContextCallCount() int { - fake.getBucketWebsiteWithContextMutex.RLock() - defer fake.getBucketWebsiteWithContextMutex.RUnlock() - return len(fake.getBucketWebsiteWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetBucketWebsiteWithContextCalls(stub func(context.Context, *s3.GetBucketWebsiteInput, ...request.Option) (*s3.GetBucketWebsiteOutput, error)) { - fake.getBucketWebsiteWithContextMutex.Lock() - defer fake.getBucketWebsiteWithContextMutex.Unlock() - fake.GetBucketWebsiteWithContextStub = stub -} - -func (fake *FakeS3Client) GetBucketWebsiteWithContextArgsForCall(i int) (context.Context, *s3.GetBucketWebsiteInput, []request.Option) { - fake.getBucketWebsiteWithContextMutex.RLock() - defer fake.getBucketWebsiteWithContextMutex.RUnlock() - argsForCall := fake.getBucketWebsiteWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetBucketWebsiteWithContextReturns(result1 *s3.GetBucketWebsiteOutput, result2 error) { - fake.getBucketWebsiteWithContextMutex.Lock() - defer fake.getBucketWebsiteWithContextMutex.Unlock() - fake.GetBucketWebsiteWithContextStub = nil - fake.getBucketWebsiteWithContextReturns = struct { - result1 *s3.GetBucketWebsiteOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetBucketWebsiteWithContextReturnsOnCall(i int, result1 *s3.GetBucketWebsiteOutput, result2 error) { - fake.getBucketWebsiteWithContextMutex.Lock() - defer fake.getBucketWebsiteWithContextMutex.Unlock() - fake.GetBucketWebsiteWithContextStub = nil - if fake.getBucketWebsiteWithContextReturnsOnCall == nil { - fake.getBucketWebsiteWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetBucketWebsiteOutput - result2 error - }) - } - fake.getBucketWebsiteWithContextReturnsOnCall[i] = struct { - result1 *s3.GetBucketWebsiteOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObject(arg1 *s3.GetObjectInput) (*s3.GetObjectOutput, error) { - fake.getObjectMutex.Lock() - ret, specificReturn := fake.getObjectReturnsOnCall[len(fake.getObjectArgsForCall)] - fake.getObjectArgsForCall = append(fake.getObjectArgsForCall, struct { - arg1 *s3.GetObjectInput - }{arg1}) - stub := fake.GetObjectStub - fakeReturns := fake.getObjectReturns - fake.recordInvocation("GetObject", []interface{}{arg1}) - fake.getObjectMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectCallCount() int { - fake.getObjectMutex.RLock() - defer fake.getObjectMutex.RUnlock() - return len(fake.getObjectArgsForCall) -} - -func (fake *FakeS3Client) GetObjectCalls(stub func(*s3.GetObjectInput) (*s3.GetObjectOutput, error)) { - fake.getObjectMutex.Lock() - defer fake.getObjectMutex.Unlock() - fake.GetObjectStub = stub -} - -func (fake *FakeS3Client) GetObjectArgsForCall(i int) *s3.GetObjectInput { - fake.getObjectMutex.RLock() - defer fake.getObjectMutex.RUnlock() - argsForCall := fake.getObjectArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetObjectReturns(result1 *s3.GetObjectOutput, result2 error) { - fake.getObjectMutex.Lock() - defer fake.getObjectMutex.Unlock() - fake.GetObjectStub = nil - fake.getObjectReturns = struct { - result1 *s3.GetObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectReturnsOnCall(i int, result1 *s3.GetObjectOutput, result2 error) { - fake.getObjectMutex.Lock() - defer fake.getObjectMutex.Unlock() - fake.GetObjectStub = nil - if fake.getObjectReturnsOnCall == nil { - fake.getObjectReturnsOnCall = make(map[int]struct { - result1 *s3.GetObjectOutput - result2 error - }) - } - fake.getObjectReturnsOnCall[i] = struct { - result1 *s3.GetObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectAcl(arg1 *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) { - fake.getObjectAclMutex.Lock() - ret, specificReturn := fake.getObjectAclReturnsOnCall[len(fake.getObjectAclArgsForCall)] - fake.getObjectAclArgsForCall = append(fake.getObjectAclArgsForCall, struct { - arg1 *s3.GetObjectAclInput - }{arg1}) - stub := fake.GetObjectAclStub - fakeReturns := fake.getObjectAclReturns - fake.recordInvocation("GetObjectAcl", []interface{}{arg1}) - fake.getObjectAclMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectAclCallCount() int { - fake.getObjectAclMutex.RLock() - defer fake.getObjectAclMutex.RUnlock() - return len(fake.getObjectAclArgsForCall) -} - -func (fake *FakeS3Client) GetObjectAclCalls(stub func(*s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error)) { - fake.getObjectAclMutex.Lock() - defer fake.getObjectAclMutex.Unlock() - fake.GetObjectAclStub = stub -} - -func (fake *FakeS3Client) GetObjectAclArgsForCall(i int) *s3.GetObjectAclInput { - fake.getObjectAclMutex.RLock() - defer fake.getObjectAclMutex.RUnlock() - argsForCall := fake.getObjectAclArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetObjectAclReturns(result1 *s3.GetObjectAclOutput, result2 error) { - fake.getObjectAclMutex.Lock() - defer fake.getObjectAclMutex.Unlock() - fake.GetObjectAclStub = nil - fake.getObjectAclReturns = struct { - result1 *s3.GetObjectAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectAclReturnsOnCall(i int, result1 *s3.GetObjectAclOutput, result2 error) { - fake.getObjectAclMutex.Lock() - defer fake.getObjectAclMutex.Unlock() - fake.GetObjectAclStub = nil - if fake.getObjectAclReturnsOnCall == nil { - fake.getObjectAclReturnsOnCall = make(map[int]struct { - result1 *s3.GetObjectAclOutput - result2 error - }) - } - fake.getObjectAclReturnsOnCall[i] = struct { - result1 *s3.GetObjectAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectAclRequest(arg1 *s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput) { - fake.getObjectAclRequestMutex.Lock() - ret, specificReturn := fake.getObjectAclRequestReturnsOnCall[len(fake.getObjectAclRequestArgsForCall)] - fake.getObjectAclRequestArgsForCall = append(fake.getObjectAclRequestArgsForCall, struct { - arg1 *s3.GetObjectAclInput - }{arg1}) - stub := fake.GetObjectAclRequestStub - fakeReturns := fake.getObjectAclRequestReturns - fake.recordInvocation("GetObjectAclRequest", []interface{}{arg1}) - fake.getObjectAclRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectAclRequestCallCount() int { - fake.getObjectAclRequestMutex.RLock() - defer fake.getObjectAclRequestMutex.RUnlock() - return len(fake.getObjectAclRequestArgsForCall) -} - -func (fake *FakeS3Client) GetObjectAclRequestCalls(stub func(*s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput)) { - fake.getObjectAclRequestMutex.Lock() - defer fake.getObjectAclRequestMutex.Unlock() - fake.GetObjectAclRequestStub = stub -} - -func (fake *FakeS3Client) GetObjectAclRequestArgsForCall(i int) *s3.GetObjectAclInput { - fake.getObjectAclRequestMutex.RLock() - defer fake.getObjectAclRequestMutex.RUnlock() - argsForCall := fake.getObjectAclRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetObjectAclRequestReturns(result1 *request.Request, result2 *s3.GetObjectAclOutput) { - fake.getObjectAclRequestMutex.Lock() - defer fake.getObjectAclRequestMutex.Unlock() - fake.GetObjectAclRequestStub = nil - fake.getObjectAclRequestReturns = struct { - result1 *request.Request - result2 *s3.GetObjectAclOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectAclRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetObjectAclOutput) { - fake.getObjectAclRequestMutex.Lock() - defer fake.getObjectAclRequestMutex.Unlock() - fake.GetObjectAclRequestStub = nil - if fake.getObjectAclRequestReturnsOnCall == nil { - fake.getObjectAclRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetObjectAclOutput - }) - } - fake.getObjectAclRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetObjectAclOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectAclWithContext(arg1 context.Context, arg2 *s3.GetObjectAclInput, arg3 ...request.Option) (*s3.GetObjectAclOutput, error) { - fake.getObjectAclWithContextMutex.Lock() - ret, specificReturn := fake.getObjectAclWithContextReturnsOnCall[len(fake.getObjectAclWithContextArgsForCall)] - fake.getObjectAclWithContextArgsForCall = append(fake.getObjectAclWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetObjectAclInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetObjectAclWithContextStub - fakeReturns := fake.getObjectAclWithContextReturns - fake.recordInvocation("GetObjectAclWithContext", []interface{}{arg1, arg2, arg3}) - fake.getObjectAclWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectAclWithContextCallCount() int { - fake.getObjectAclWithContextMutex.RLock() - defer fake.getObjectAclWithContextMutex.RUnlock() - return len(fake.getObjectAclWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetObjectAclWithContextCalls(stub func(context.Context, *s3.GetObjectAclInput, ...request.Option) (*s3.GetObjectAclOutput, error)) { - fake.getObjectAclWithContextMutex.Lock() - defer fake.getObjectAclWithContextMutex.Unlock() - fake.GetObjectAclWithContextStub = stub -} - -func (fake *FakeS3Client) GetObjectAclWithContextArgsForCall(i int) (context.Context, *s3.GetObjectAclInput, []request.Option) { - fake.getObjectAclWithContextMutex.RLock() - defer fake.getObjectAclWithContextMutex.RUnlock() - argsForCall := fake.getObjectAclWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetObjectAclWithContextReturns(result1 *s3.GetObjectAclOutput, result2 error) { - fake.getObjectAclWithContextMutex.Lock() - defer fake.getObjectAclWithContextMutex.Unlock() - fake.GetObjectAclWithContextStub = nil - fake.getObjectAclWithContextReturns = struct { - result1 *s3.GetObjectAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectAclWithContextReturnsOnCall(i int, result1 *s3.GetObjectAclOutput, result2 error) { - fake.getObjectAclWithContextMutex.Lock() - defer fake.getObjectAclWithContextMutex.Unlock() - fake.GetObjectAclWithContextStub = nil - if fake.getObjectAclWithContextReturnsOnCall == nil { - fake.getObjectAclWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetObjectAclOutput - result2 error - }) - } - fake.getObjectAclWithContextReturnsOnCall[i] = struct { - result1 *s3.GetObjectAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectLegalHold(arg1 *s3.GetObjectLegalHoldInput) (*s3.GetObjectLegalHoldOutput, error) { - fake.getObjectLegalHoldMutex.Lock() - ret, specificReturn := fake.getObjectLegalHoldReturnsOnCall[len(fake.getObjectLegalHoldArgsForCall)] - fake.getObjectLegalHoldArgsForCall = append(fake.getObjectLegalHoldArgsForCall, struct { - arg1 *s3.GetObjectLegalHoldInput - }{arg1}) - stub := fake.GetObjectLegalHoldStub - fakeReturns := fake.getObjectLegalHoldReturns - fake.recordInvocation("GetObjectLegalHold", []interface{}{arg1}) - fake.getObjectLegalHoldMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectLegalHoldCallCount() int { - fake.getObjectLegalHoldMutex.RLock() - defer fake.getObjectLegalHoldMutex.RUnlock() - return len(fake.getObjectLegalHoldArgsForCall) -} - -func (fake *FakeS3Client) GetObjectLegalHoldCalls(stub func(*s3.GetObjectLegalHoldInput) (*s3.GetObjectLegalHoldOutput, error)) { - fake.getObjectLegalHoldMutex.Lock() - defer fake.getObjectLegalHoldMutex.Unlock() - fake.GetObjectLegalHoldStub = stub -} - -func (fake *FakeS3Client) GetObjectLegalHoldArgsForCall(i int) *s3.GetObjectLegalHoldInput { - fake.getObjectLegalHoldMutex.RLock() - defer fake.getObjectLegalHoldMutex.RUnlock() - argsForCall := fake.getObjectLegalHoldArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetObjectLegalHoldReturns(result1 *s3.GetObjectLegalHoldOutput, result2 error) { - fake.getObjectLegalHoldMutex.Lock() - defer fake.getObjectLegalHoldMutex.Unlock() - fake.GetObjectLegalHoldStub = nil - fake.getObjectLegalHoldReturns = struct { - result1 *s3.GetObjectLegalHoldOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectLegalHoldReturnsOnCall(i int, result1 *s3.GetObjectLegalHoldOutput, result2 error) { - fake.getObjectLegalHoldMutex.Lock() - defer fake.getObjectLegalHoldMutex.Unlock() - fake.GetObjectLegalHoldStub = nil - if fake.getObjectLegalHoldReturnsOnCall == nil { - fake.getObjectLegalHoldReturnsOnCall = make(map[int]struct { - result1 *s3.GetObjectLegalHoldOutput - result2 error - }) - } - fake.getObjectLegalHoldReturnsOnCall[i] = struct { - result1 *s3.GetObjectLegalHoldOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectLegalHoldRequest(arg1 *s3.GetObjectLegalHoldInput) (*request.Request, *s3.GetObjectLegalHoldOutput) { - fake.getObjectLegalHoldRequestMutex.Lock() - ret, specificReturn := fake.getObjectLegalHoldRequestReturnsOnCall[len(fake.getObjectLegalHoldRequestArgsForCall)] - fake.getObjectLegalHoldRequestArgsForCall = append(fake.getObjectLegalHoldRequestArgsForCall, struct { - arg1 *s3.GetObjectLegalHoldInput - }{arg1}) - stub := fake.GetObjectLegalHoldRequestStub - fakeReturns := fake.getObjectLegalHoldRequestReturns - fake.recordInvocation("GetObjectLegalHoldRequest", []interface{}{arg1}) - fake.getObjectLegalHoldRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectLegalHoldRequestCallCount() int { - fake.getObjectLegalHoldRequestMutex.RLock() - defer fake.getObjectLegalHoldRequestMutex.RUnlock() - return len(fake.getObjectLegalHoldRequestArgsForCall) -} - -func (fake *FakeS3Client) GetObjectLegalHoldRequestCalls(stub func(*s3.GetObjectLegalHoldInput) (*request.Request, *s3.GetObjectLegalHoldOutput)) { - fake.getObjectLegalHoldRequestMutex.Lock() - defer fake.getObjectLegalHoldRequestMutex.Unlock() - fake.GetObjectLegalHoldRequestStub = stub -} - -func (fake *FakeS3Client) GetObjectLegalHoldRequestArgsForCall(i int) *s3.GetObjectLegalHoldInput { - fake.getObjectLegalHoldRequestMutex.RLock() - defer fake.getObjectLegalHoldRequestMutex.RUnlock() - argsForCall := fake.getObjectLegalHoldRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetObjectLegalHoldRequestReturns(result1 *request.Request, result2 *s3.GetObjectLegalHoldOutput) { - fake.getObjectLegalHoldRequestMutex.Lock() - defer fake.getObjectLegalHoldRequestMutex.Unlock() - fake.GetObjectLegalHoldRequestStub = nil - fake.getObjectLegalHoldRequestReturns = struct { - result1 *request.Request - result2 *s3.GetObjectLegalHoldOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectLegalHoldRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetObjectLegalHoldOutput) { - fake.getObjectLegalHoldRequestMutex.Lock() - defer fake.getObjectLegalHoldRequestMutex.Unlock() - fake.GetObjectLegalHoldRequestStub = nil - if fake.getObjectLegalHoldRequestReturnsOnCall == nil { - fake.getObjectLegalHoldRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetObjectLegalHoldOutput - }) - } - fake.getObjectLegalHoldRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetObjectLegalHoldOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectLegalHoldWithContext(arg1 context.Context, arg2 *s3.GetObjectLegalHoldInput, arg3 ...request.Option) (*s3.GetObjectLegalHoldOutput, error) { - fake.getObjectLegalHoldWithContextMutex.Lock() - ret, specificReturn := fake.getObjectLegalHoldWithContextReturnsOnCall[len(fake.getObjectLegalHoldWithContextArgsForCall)] - fake.getObjectLegalHoldWithContextArgsForCall = append(fake.getObjectLegalHoldWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetObjectLegalHoldInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetObjectLegalHoldWithContextStub - fakeReturns := fake.getObjectLegalHoldWithContextReturns - fake.recordInvocation("GetObjectLegalHoldWithContext", []interface{}{arg1, arg2, arg3}) - fake.getObjectLegalHoldWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectLegalHoldWithContextCallCount() int { - fake.getObjectLegalHoldWithContextMutex.RLock() - defer fake.getObjectLegalHoldWithContextMutex.RUnlock() - return len(fake.getObjectLegalHoldWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetObjectLegalHoldWithContextCalls(stub func(context.Context, *s3.GetObjectLegalHoldInput, ...request.Option) (*s3.GetObjectLegalHoldOutput, error)) { - fake.getObjectLegalHoldWithContextMutex.Lock() - defer fake.getObjectLegalHoldWithContextMutex.Unlock() - fake.GetObjectLegalHoldWithContextStub = stub -} - -func (fake *FakeS3Client) GetObjectLegalHoldWithContextArgsForCall(i int) (context.Context, *s3.GetObjectLegalHoldInput, []request.Option) { - fake.getObjectLegalHoldWithContextMutex.RLock() - defer fake.getObjectLegalHoldWithContextMutex.RUnlock() - argsForCall := fake.getObjectLegalHoldWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetObjectLegalHoldWithContextReturns(result1 *s3.GetObjectLegalHoldOutput, result2 error) { - fake.getObjectLegalHoldWithContextMutex.Lock() - defer fake.getObjectLegalHoldWithContextMutex.Unlock() - fake.GetObjectLegalHoldWithContextStub = nil - fake.getObjectLegalHoldWithContextReturns = struct { - result1 *s3.GetObjectLegalHoldOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectLegalHoldWithContextReturnsOnCall(i int, result1 *s3.GetObjectLegalHoldOutput, result2 error) { - fake.getObjectLegalHoldWithContextMutex.Lock() - defer fake.getObjectLegalHoldWithContextMutex.Unlock() - fake.GetObjectLegalHoldWithContextStub = nil - if fake.getObjectLegalHoldWithContextReturnsOnCall == nil { - fake.getObjectLegalHoldWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetObjectLegalHoldOutput - result2 error - }) - } - fake.getObjectLegalHoldWithContextReturnsOnCall[i] = struct { - result1 *s3.GetObjectLegalHoldOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectLockConfiguration(arg1 *s3.GetObjectLockConfigurationInput) (*s3.GetObjectLockConfigurationOutput, error) { - fake.getObjectLockConfigurationMutex.Lock() - ret, specificReturn := fake.getObjectLockConfigurationReturnsOnCall[len(fake.getObjectLockConfigurationArgsForCall)] - fake.getObjectLockConfigurationArgsForCall = append(fake.getObjectLockConfigurationArgsForCall, struct { - arg1 *s3.GetObjectLockConfigurationInput - }{arg1}) - stub := fake.GetObjectLockConfigurationStub - fakeReturns := fake.getObjectLockConfigurationReturns - fake.recordInvocation("GetObjectLockConfiguration", []interface{}{arg1}) - fake.getObjectLockConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectLockConfigurationCallCount() int { - fake.getObjectLockConfigurationMutex.RLock() - defer fake.getObjectLockConfigurationMutex.RUnlock() - return len(fake.getObjectLockConfigurationArgsForCall) -} - -func (fake *FakeS3Client) GetObjectLockConfigurationCalls(stub func(*s3.GetObjectLockConfigurationInput) (*s3.GetObjectLockConfigurationOutput, error)) { - fake.getObjectLockConfigurationMutex.Lock() - defer fake.getObjectLockConfigurationMutex.Unlock() - fake.GetObjectLockConfigurationStub = stub -} - -func (fake *FakeS3Client) GetObjectLockConfigurationArgsForCall(i int) *s3.GetObjectLockConfigurationInput { - fake.getObjectLockConfigurationMutex.RLock() - defer fake.getObjectLockConfigurationMutex.RUnlock() - argsForCall := fake.getObjectLockConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetObjectLockConfigurationReturns(result1 *s3.GetObjectLockConfigurationOutput, result2 error) { - fake.getObjectLockConfigurationMutex.Lock() - defer fake.getObjectLockConfigurationMutex.Unlock() - fake.GetObjectLockConfigurationStub = nil - fake.getObjectLockConfigurationReturns = struct { - result1 *s3.GetObjectLockConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectLockConfigurationReturnsOnCall(i int, result1 *s3.GetObjectLockConfigurationOutput, result2 error) { - fake.getObjectLockConfigurationMutex.Lock() - defer fake.getObjectLockConfigurationMutex.Unlock() - fake.GetObjectLockConfigurationStub = nil - if fake.getObjectLockConfigurationReturnsOnCall == nil { - fake.getObjectLockConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.GetObjectLockConfigurationOutput - result2 error - }) - } - fake.getObjectLockConfigurationReturnsOnCall[i] = struct { - result1 *s3.GetObjectLockConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectLockConfigurationRequest(arg1 *s3.GetObjectLockConfigurationInput) (*request.Request, *s3.GetObjectLockConfigurationOutput) { - fake.getObjectLockConfigurationRequestMutex.Lock() - ret, specificReturn := fake.getObjectLockConfigurationRequestReturnsOnCall[len(fake.getObjectLockConfigurationRequestArgsForCall)] - fake.getObjectLockConfigurationRequestArgsForCall = append(fake.getObjectLockConfigurationRequestArgsForCall, struct { - arg1 *s3.GetObjectLockConfigurationInput - }{arg1}) - stub := fake.GetObjectLockConfigurationRequestStub - fakeReturns := fake.getObjectLockConfigurationRequestReturns - fake.recordInvocation("GetObjectLockConfigurationRequest", []interface{}{arg1}) - fake.getObjectLockConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectLockConfigurationRequestCallCount() int { - fake.getObjectLockConfigurationRequestMutex.RLock() - defer fake.getObjectLockConfigurationRequestMutex.RUnlock() - return len(fake.getObjectLockConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) GetObjectLockConfigurationRequestCalls(stub func(*s3.GetObjectLockConfigurationInput) (*request.Request, *s3.GetObjectLockConfigurationOutput)) { - fake.getObjectLockConfigurationRequestMutex.Lock() - defer fake.getObjectLockConfigurationRequestMutex.Unlock() - fake.GetObjectLockConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) GetObjectLockConfigurationRequestArgsForCall(i int) *s3.GetObjectLockConfigurationInput { - fake.getObjectLockConfigurationRequestMutex.RLock() - defer fake.getObjectLockConfigurationRequestMutex.RUnlock() - argsForCall := fake.getObjectLockConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetObjectLockConfigurationRequestReturns(result1 *request.Request, result2 *s3.GetObjectLockConfigurationOutput) { - fake.getObjectLockConfigurationRequestMutex.Lock() - defer fake.getObjectLockConfigurationRequestMutex.Unlock() - fake.GetObjectLockConfigurationRequestStub = nil - fake.getObjectLockConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.GetObjectLockConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectLockConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetObjectLockConfigurationOutput) { - fake.getObjectLockConfigurationRequestMutex.Lock() - defer fake.getObjectLockConfigurationRequestMutex.Unlock() - fake.GetObjectLockConfigurationRequestStub = nil - if fake.getObjectLockConfigurationRequestReturnsOnCall == nil { - fake.getObjectLockConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetObjectLockConfigurationOutput - }) - } - fake.getObjectLockConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetObjectLockConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectLockConfigurationWithContext(arg1 context.Context, arg2 *s3.GetObjectLockConfigurationInput, arg3 ...request.Option) (*s3.GetObjectLockConfigurationOutput, error) { - fake.getObjectLockConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.getObjectLockConfigurationWithContextReturnsOnCall[len(fake.getObjectLockConfigurationWithContextArgsForCall)] - fake.getObjectLockConfigurationWithContextArgsForCall = append(fake.getObjectLockConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetObjectLockConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetObjectLockConfigurationWithContextStub - fakeReturns := fake.getObjectLockConfigurationWithContextReturns - fake.recordInvocation("GetObjectLockConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.getObjectLockConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectLockConfigurationWithContextCallCount() int { - fake.getObjectLockConfigurationWithContextMutex.RLock() - defer fake.getObjectLockConfigurationWithContextMutex.RUnlock() - return len(fake.getObjectLockConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetObjectLockConfigurationWithContextCalls(stub func(context.Context, *s3.GetObjectLockConfigurationInput, ...request.Option) (*s3.GetObjectLockConfigurationOutput, error)) { - fake.getObjectLockConfigurationWithContextMutex.Lock() - defer fake.getObjectLockConfigurationWithContextMutex.Unlock() - fake.GetObjectLockConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) GetObjectLockConfigurationWithContextArgsForCall(i int) (context.Context, *s3.GetObjectLockConfigurationInput, []request.Option) { - fake.getObjectLockConfigurationWithContextMutex.RLock() - defer fake.getObjectLockConfigurationWithContextMutex.RUnlock() - argsForCall := fake.getObjectLockConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetObjectLockConfigurationWithContextReturns(result1 *s3.GetObjectLockConfigurationOutput, result2 error) { - fake.getObjectLockConfigurationWithContextMutex.Lock() - defer fake.getObjectLockConfigurationWithContextMutex.Unlock() - fake.GetObjectLockConfigurationWithContextStub = nil - fake.getObjectLockConfigurationWithContextReturns = struct { - result1 *s3.GetObjectLockConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectLockConfigurationWithContextReturnsOnCall(i int, result1 *s3.GetObjectLockConfigurationOutput, result2 error) { - fake.getObjectLockConfigurationWithContextMutex.Lock() - defer fake.getObjectLockConfigurationWithContextMutex.Unlock() - fake.GetObjectLockConfigurationWithContextStub = nil - if fake.getObjectLockConfigurationWithContextReturnsOnCall == nil { - fake.getObjectLockConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetObjectLockConfigurationOutput - result2 error - }) - } - fake.getObjectLockConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.GetObjectLockConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectRequest(arg1 *s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput) { - fake.getObjectRequestMutex.Lock() - ret, specificReturn := fake.getObjectRequestReturnsOnCall[len(fake.getObjectRequestArgsForCall)] - fake.getObjectRequestArgsForCall = append(fake.getObjectRequestArgsForCall, struct { - arg1 *s3.GetObjectInput - }{arg1}) - stub := fake.GetObjectRequestStub - fakeReturns := fake.getObjectRequestReturns - fake.recordInvocation("GetObjectRequest", []interface{}{arg1}) - fake.getObjectRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectRequestCallCount() int { - fake.getObjectRequestMutex.RLock() - defer fake.getObjectRequestMutex.RUnlock() - return len(fake.getObjectRequestArgsForCall) -} - -func (fake *FakeS3Client) GetObjectRequestCalls(stub func(*s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput)) { - fake.getObjectRequestMutex.Lock() - defer fake.getObjectRequestMutex.Unlock() - fake.GetObjectRequestStub = stub -} - -func (fake *FakeS3Client) GetObjectRequestArgsForCall(i int) *s3.GetObjectInput { - fake.getObjectRequestMutex.RLock() - defer fake.getObjectRequestMutex.RUnlock() - argsForCall := fake.getObjectRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetObjectRequestReturns(result1 *request.Request, result2 *s3.GetObjectOutput) { - fake.getObjectRequestMutex.Lock() - defer fake.getObjectRequestMutex.Unlock() - fake.GetObjectRequestStub = nil - fake.getObjectRequestReturns = struct { - result1 *request.Request - result2 *s3.GetObjectOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetObjectOutput) { - fake.getObjectRequestMutex.Lock() - defer fake.getObjectRequestMutex.Unlock() - fake.GetObjectRequestStub = nil - if fake.getObjectRequestReturnsOnCall == nil { - fake.getObjectRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetObjectOutput - }) - } - fake.getObjectRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetObjectOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectRetention(arg1 *s3.GetObjectRetentionInput) (*s3.GetObjectRetentionOutput, error) { - fake.getObjectRetentionMutex.Lock() - ret, specificReturn := fake.getObjectRetentionReturnsOnCall[len(fake.getObjectRetentionArgsForCall)] - fake.getObjectRetentionArgsForCall = append(fake.getObjectRetentionArgsForCall, struct { - arg1 *s3.GetObjectRetentionInput - }{arg1}) - stub := fake.GetObjectRetentionStub - fakeReturns := fake.getObjectRetentionReturns - fake.recordInvocation("GetObjectRetention", []interface{}{arg1}) - fake.getObjectRetentionMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectRetentionCallCount() int { - fake.getObjectRetentionMutex.RLock() - defer fake.getObjectRetentionMutex.RUnlock() - return len(fake.getObjectRetentionArgsForCall) -} - -func (fake *FakeS3Client) GetObjectRetentionCalls(stub func(*s3.GetObjectRetentionInput) (*s3.GetObjectRetentionOutput, error)) { - fake.getObjectRetentionMutex.Lock() - defer fake.getObjectRetentionMutex.Unlock() - fake.GetObjectRetentionStub = stub -} - -func (fake *FakeS3Client) GetObjectRetentionArgsForCall(i int) *s3.GetObjectRetentionInput { - fake.getObjectRetentionMutex.RLock() - defer fake.getObjectRetentionMutex.RUnlock() - argsForCall := fake.getObjectRetentionArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetObjectRetentionReturns(result1 *s3.GetObjectRetentionOutput, result2 error) { - fake.getObjectRetentionMutex.Lock() - defer fake.getObjectRetentionMutex.Unlock() - fake.GetObjectRetentionStub = nil - fake.getObjectRetentionReturns = struct { - result1 *s3.GetObjectRetentionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectRetentionReturnsOnCall(i int, result1 *s3.GetObjectRetentionOutput, result2 error) { - fake.getObjectRetentionMutex.Lock() - defer fake.getObjectRetentionMutex.Unlock() - fake.GetObjectRetentionStub = nil - if fake.getObjectRetentionReturnsOnCall == nil { - fake.getObjectRetentionReturnsOnCall = make(map[int]struct { - result1 *s3.GetObjectRetentionOutput - result2 error - }) - } - fake.getObjectRetentionReturnsOnCall[i] = struct { - result1 *s3.GetObjectRetentionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectRetentionRequest(arg1 *s3.GetObjectRetentionInput) (*request.Request, *s3.GetObjectRetentionOutput) { - fake.getObjectRetentionRequestMutex.Lock() - ret, specificReturn := fake.getObjectRetentionRequestReturnsOnCall[len(fake.getObjectRetentionRequestArgsForCall)] - fake.getObjectRetentionRequestArgsForCall = append(fake.getObjectRetentionRequestArgsForCall, struct { - arg1 *s3.GetObjectRetentionInput - }{arg1}) - stub := fake.GetObjectRetentionRequestStub - fakeReturns := fake.getObjectRetentionRequestReturns - fake.recordInvocation("GetObjectRetentionRequest", []interface{}{arg1}) - fake.getObjectRetentionRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectRetentionRequestCallCount() int { - fake.getObjectRetentionRequestMutex.RLock() - defer fake.getObjectRetentionRequestMutex.RUnlock() - return len(fake.getObjectRetentionRequestArgsForCall) -} - -func (fake *FakeS3Client) GetObjectRetentionRequestCalls(stub func(*s3.GetObjectRetentionInput) (*request.Request, *s3.GetObjectRetentionOutput)) { - fake.getObjectRetentionRequestMutex.Lock() - defer fake.getObjectRetentionRequestMutex.Unlock() - fake.GetObjectRetentionRequestStub = stub -} - -func (fake *FakeS3Client) GetObjectRetentionRequestArgsForCall(i int) *s3.GetObjectRetentionInput { - fake.getObjectRetentionRequestMutex.RLock() - defer fake.getObjectRetentionRequestMutex.RUnlock() - argsForCall := fake.getObjectRetentionRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetObjectRetentionRequestReturns(result1 *request.Request, result2 *s3.GetObjectRetentionOutput) { - fake.getObjectRetentionRequestMutex.Lock() - defer fake.getObjectRetentionRequestMutex.Unlock() - fake.GetObjectRetentionRequestStub = nil - fake.getObjectRetentionRequestReturns = struct { - result1 *request.Request - result2 *s3.GetObjectRetentionOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectRetentionRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetObjectRetentionOutput) { - fake.getObjectRetentionRequestMutex.Lock() - defer fake.getObjectRetentionRequestMutex.Unlock() - fake.GetObjectRetentionRequestStub = nil - if fake.getObjectRetentionRequestReturnsOnCall == nil { - fake.getObjectRetentionRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetObjectRetentionOutput - }) - } - fake.getObjectRetentionRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetObjectRetentionOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectRetentionWithContext(arg1 context.Context, arg2 *s3.GetObjectRetentionInput, arg3 ...request.Option) (*s3.GetObjectRetentionOutput, error) { - fake.getObjectRetentionWithContextMutex.Lock() - ret, specificReturn := fake.getObjectRetentionWithContextReturnsOnCall[len(fake.getObjectRetentionWithContextArgsForCall)] - fake.getObjectRetentionWithContextArgsForCall = append(fake.getObjectRetentionWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetObjectRetentionInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetObjectRetentionWithContextStub - fakeReturns := fake.getObjectRetentionWithContextReturns - fake.recordInvocation("GetObjectRetentionWithContext", []interface{}{arg1, arg2, arg3}) - fake.getObjectRetentionWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectRetentionWithContextCallCount() int { - fake.getObjectRetentionWithContextMutex.RLock() - defer fake.getObjectRetentionWithContextMutex.RUnlock() - return len(fake.getObjectRetentionWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetObjectRetentionWithContextCalls(stub func(context.Context, *s3.GetObjectRetentionInput, ...request.Option) (*s3.GetObjectRetentionOutput, error)) { - fake.getObjectRetentionWithContextMutex.Lock() - defer fake.getObjectRetentionWithContextMutex.Unlock() - fake.GetObjectRetentionWithContextStub = stub -} - -func (fake *FakeS3Client) GetObjectRetentionWithContextArgsForCall(i int) (context.Context, *s3.GetObjectRetentionInput, []request.Option) { - fake.getObjectRetentionWithContextMutex.RLock() - defer fake.getObjectRetentionWithContextMutex.RUnlock() - argsForCall := fake.getObjectRetentionWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetObjectRetentionWithContextReturns(result1 *s3.GetObjectRetentionOutput, result2 error) { - fake.getObjectRetentionWithContextMutex.Lock() - defer fake.getObjectRetentionWithContextMutex.Unlock() - fake.GetObjectRetentionWithContextStub = nil - fake.getObjectRetentionWithContextReturns = struct { - result1 *s3.GetObjectRetentionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectRetentionWithContextReturnsOnCall(i int, result1 *s3.GetObjectRetentionOutput, result2 error) { - fake.getObjectRetentionWithContextMutex.Lock() - defer fake.getObjectRetentionWithContextMutex.Unlock() - fake.GetObjectRetentionWithContextStub = nil - if fake.getObjectRetentionWithContextReturnsOnCall == nil { - fake.getObjectRetentionWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetObjectRetentionOutput - result2 error - }) - } - fake.getObjectRetentionWithContextReturnsOnCall[i] = struct { - result1 *s3.GetObjectRetentionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectTagging(arg1 *s3.GetObjectTaggingInput) (*s3.GetObjectTaggingOutput, error) { - fake.getObjectTaggingMutex.Lock() - ret, specificReturn := fake.getObjectTaggingReturnsOnCall[len(fake.getObjectTaggingArgsForCall)] - fake.getObjectTaggingArgsForCall = append(fake.getObjectTaggingArgsForCall, struct { - arg1 *s3.GetObjectTaggingInput - }{arg1}) - stub := fake.GetObjectTaggingStub - fakeReturns := fake.getObjectTaggingReturns - fake.recordInvocation("GetObjectTagging", []interface{}{arg1}) - fake.getObjectTaggingMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectTaggingCallCount() int { - fake.getObjectTaggingMutex.RLock() - defer fake.getObjectTaggingMutex.RUnlock() - return len(fake.getObjectTaggingArgsForCall) -} - -func (fake *FakeS3Client) GetObjectTaggingCalls(stub func(*s3.GetObjectTaggingInput) (*s3.GetObjectTaggingOutput, error)) { - fake.getObjectTaggingMutex.Lock() - defer fake.getObjectTaggingMutex.Unlock() - fake.GetObjectTaggingStub = stub -} - -func (fake *FakeS3Client) GetObjectTaggingArgsForCall(i int) *s3.GetObjectTaggingInput { - fake.getObjectTaggingMutex.RLock() - defer fake.getObjectTaggingMutex.RUnlock() - argsForCall := fake.getObjectTaggingArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetObjectTaggingReturns(result1 *s3.GetObjectTaggingOutput, result2 error) { - fake.getObjectTaggingMutex.Lock() - defer fake.getObjectTaggingMutex.Unlock() - fake.GetObjectTaggingStub = nil - fake.getObjectTaggingReturns = struct { - result1 *s3.GetObjectTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectTaggingReturnsOnCall(i int, result1 *s3.GetObjectTaggingOutput, result2 error) { - fake.getObjectTaggingMutex.Lock() - defer fake.getObjectTaggingMutex.Unlock() - fake.GetObjectTaggingStub = nil - if fake.getObjectTaggingReturnsOnCall == nil { - fake.getObjectTaggingReturnsOnCall = make(map[int]struct { - result1 *s3.GetObjectTaggingOutput - result2 error - }) - } - fake.getObjectTaggingReturnsOnCall[i] = struct { - result1 *s3.GetObjectTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectTaggingRequest(arg1 *s3.GetObjectTaggingInput) (*request.Request, *s3.GetObjectTaggingOutput) { - fake.getObjectTaggingRequestMutex.Lock() - ret, specificReturn := fake.getObjectTaggingRequestReturnsOnCall[len(fake.getObjectTaggingRequestArgsForCall)] - fake.getObjectTaggingRequestArgsForCall = append(fake.getObjectTaggingRequestArgsForCall, struct { - arg1 *s3.GetObjectTaggingInput - }{arg1}) - stub := fake.GetObjectTaggingRequestStub - fakeReturns := fake.getObjectTaggingRequestReturns - fake.recordInvocation("GetObjectTaggingRequest", []interface{}{arg1}) - fake.getObjectTaggingRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectTaggingRequestCallCount() int { - fake.getObjectTaggingRequestMutex.RLock() - defer fake.getObjectTaggingRequestMutex.RUnlock() - return len(fake.getObjectTaggingRequestArgsForCall) -} - -func (fake *FakeS3Client) GetObjectTaggingRequestCalls(stub func(*s3.GetObjectTaggingInput) (*request.Request, *s3.GetObjectTaggingOutput)) { - fake.getObjectTaggingRequestMutex.Lock() - defer fake.getObjectTaggingRequestMutex.Unlock() - fake.GetObjectTaggingRequestStub = stub -} - -func (fake *FakeS3Client) GetObjectTaggingRequestArgsForCall(i int) *s3.GetObjectTaggingInput { - fake.getObjectTaggingRequestMutex.RLock() - defer fake.getObjectTaggingRequestMutex.RUnlock() - argsForCall := fake.getObjectTaggingRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetObjectTaggingRequestReturns(result1 *request.Request, result2 *s3.GetObjectTaggingOutput) { - fake.getObjectTaggingRequestMutex.Lock() - defer fake.getObjectTaggingRequestMutex.Unlock() - fake.GetObjectTaggingRequestStub = nil - fake.getObjectTaggingRequestReturns = struct { - result1 *request.Request - result2 *s3.GetObjectTaggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectTaggingRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetObjectTaggingOutput) { - fake.getObjectTaggingRequestMutex.Lock() - defer fake.getObjectTaggingRequestMutex.Unlock() - fake.GetObjectTaggingRequestStub = nil - if fake.getObjectTaggingRequestReturnsOnCall == nil { - fake.getObjectTaggingRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetObjectTaggingOutput - }) - } - fake.getObjectTaggingRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetObjectTaggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectTaggingWithContext(arg1 context.Context, arg2 *s3.GetObjectTaggingInput, arg3 ...request.Option) (*s3.GetObjectTaggingOutput, error) { - fake.getObjectTaggingWithContextMutex.Lock() - ret, specificReturn := fake.getObjectTaggingWithContextReturnsOnCall[len(fake.getObjectTaggingWithContextArgsForCall)] - fake.getObjectTaggingWithContextArgsForCall = append(fake.getObjectTaggingWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetObjectTaggingInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetObjectTaggingWithContextStub - fakeReturns := fake.getObjectTaggingWithContextReturns - fake.recordInvocation("GetObjectTaggingWithContext", []interface{}{arg1, arg2, arg3}) - fake.getObjectTaggingWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectTaggingWithContextCallCount() int { - fake.getObjectTaggingWithContextMutex.RLock() - defer fake.getObjectTaggingWithContextMutex.RUnlock() - return len(fake.getObjectTaggingWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetObjectTaggingWithContextCalls(stub func(context.Context, *s3.GetObjectTaggingInput, ...request.Option) (*s3.GetObjectTaggingOutput, error)) { - fake.getObjectTaggingWithContextMutex.Lock() - defer fake.getObjectTaggingWithContextMutex.Unlock() - fake.GetObjectTaggingWithContextStub = stub -} - -func (fake *FakeS3Client) GetObjectTaggingWithContextArgsForCall(i int) (context.Context, *s3.GetObjectTaggingInput, []request.Option) { - fake.getObjectTaggingWithContextMutex.RLock() - defer fake.getObjectTaggingWithContextMutex.RUnlock() - argsForCall := fake.getObjectTaggingWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetObjectTaggingWithContextReturns(result1 *s3.GetObjectTaggingOutput, result2 error) { - fake.getObjectTaggingWithContextMutex.Lock() - defer fake.getObjectTaggingWithContextMutex.Unlock() - fake.GetObjectTaggingWithContextStub = nil - fake.getObjectTaggingWithContextReturns = struct { - result1 *s3.GetObjectTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectTaggingWithContextReturnsOnCall(i int, result1 *s3.GetObjectTaggingOutput, result2 error) { - fake.getObjectTaggingWithContextMutex.Lock() - defer fake.getObjectTaggingWithContextMutex.Unlock() - fake.GetObjectTaggingWithContextStub = nil - if fake.getObjectTaggingWithContextReturnsOnCall == nil { - fake.getObjectTaggingWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetObjectTaggingOutput - result2 error - }) - } - fake.getObjectTaggingWithContextReturnsOnCall[i] = struct { - result1 *s3.GetObjectTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectTorrent(arg1 *s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error) { - fake.getObjectTorrentMutex.Lock() - ret, specificReturn := fake.getObjectTorrentReturnsOnCall[len(fake.getObjectTorrentArgsForCall)] - fake.getObjectTorrentArgsForCall = append(fake.getObjectTorrentArgsForCall, struct { - arg1 *s3.GetObjectTorrentInput - }{arg1}) - stub := fake.GetObjectTorrentStub - fakeReturns := fake.getObjectTorrentReturns - fake.recordInvocation("GetObjectTorrent", []interface{}{arg1}) - fake.getObjectTorrentMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectTorrentCallCount() int { - fake.getObjectTorrentMutex.RLock() - defer fake.getObjectTorrentMutex.RUnlock() - return len(fake.getObjectTorrentArgsForCall) -} - -func (fake *FakeS3Client) GetObjectTorrentCalls(stub func(*s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error)) { - fake.getObjectTorrentMutex.Lock() - defer fake.getObjectTorrentMutex.Unlock() - fake.GetObjectTorrentStub = stub -} - -func (fake *FakeS3Client) GetObjectTorrentArgsForCall(i int) *s3.GetObjectTorrentInput { - fake.getObjectTorrentMutex.RLock() - defer fake.getObjectTorrentMutex.RUnlock() - argsForCall := fake.getObjectTorrentArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetObjectTorrentReturns(result1 *s3.GetObjectTorrentOutput, result2 error) { - fake.getObjectTorrentMutex.Lock() - defer fake.getObjectTorrentMutex.Unlock() - fake.GetObjectTorrentStub = nil - fake.getObjectTorrentReturns = struct { - result1 *s3.GetObjectTorrentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectTorrentReturnsOnCall(i int, result1 *s3.GetObjectTorrentOutput, result2 error) { - fake.getObjectTorrentMutex.Lock() - defer fake.getObjectTorrentMutex.Unlock() - fake.GetObjectTorrentStub = nil - if fake.getObjectTorrentReturnsOnCall == nil { - fake.getObjectTorrentReturnsOnCall = make(map[int]struct { - result1 *s3.GetObjectTorrentOutput - result2 error - }) - } - fake.getObjectTorrentReturnsOnCall[i] = struct { - result1 *s3.GetObjectTorrentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectTorrentRequest(arg1 *s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput) { - fake.getObjectTorrentRequestMutex.Lock() - ret, specificReturn := fake.getObjectTorrentRequestReturnsOnCall[len(fake.getObjectTorrentRequestArgsForCall)] - fake.getObjectTorrentRequestArgsForCall = append(fake.getObjectTorrentRequestArgsForCall, struct { - arg1 *s3.GetObjectTorrentInput - }{arg1}) - stub := fake.GetObjectTorrentRequestStub - fakeReturns := fake.getObjectTorrentRequestReturns - fake.recordInvocation("GetObjectTorrentRequest", []interface{}{arg1}) - fake.getObjectTorrentRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectTorrentRequestCallCount() int { - fake.getObjectTorrentRequestMutex.RLock() - defer fake.getObjectTorrentRequestMutex.RUnlock() - return len(fake.getObjectTorrentRequestArgsForCall) -} - -func (fake *FakeS3Client) GetObjectTorrentRequestCalls(stub func(*s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput)) { - fake.getObjectTorrentRequestMutex.Lock() - defer fake.getObjectTorrentRequestMutex.Unlock() - fake.GetObjectTorrentRequestStub = stub -} - -func (fake *FakeS3Client) GetObjectTorrentRequestArgsForCall(i int) *s3.GetObjectTorrentInput { - fake.getObjectTorrentRequestMutex.RLock() - defer fake.getObjectTorrentRequestMutex.RUnlock() - argsForCall := fake.getObjectTorrentRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetObjectTorrentRequestReturns(result1 *request.Request, result2 *s3.GetObjectTorrentOutput) { - fake.getObjectTorrentRequestMutex.Lock() - defer fake.getObjectTorrentRequestMutex.Unlock() - fake.GetObjectTorrentRequestStub = nil - fake.getObjectTorrentRequestReturns = struct { - result1 *request.Request - result2 *s3.GetObjectTorrentOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectTorrentRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetObjectTorrentOutput) { - fake.getObjectTorrentRequestMutex.Lock() - defer fake.getObjectTorrentRequestMutex.Unlock() - fake.GetObjectTorrentRequestStub = nil - if fake.getObjectTorrentRequestReturnsOnCall == nil { - fake.getObjectTorrentRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetObjectTorrentOutput - }) - } - fake.getObjectTorrentRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetObjectTorrentOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectTorrentWithContext(arg1 context.Context, arg2 *s3.GetObjectTorrentInput, arg3 ...request.Option) (*s3.GetObjectTorrentOutput, error) { - fake.getObjectTorrentWithContextMutex.Lock() - ret, specificReturn := fake.getObjectTorrentWithContextReturnsOnCall[len(fake.getObjectTorrentWithContextArgsForCall)] - fake.getObjectTorrentWithContextArgsForCall = append(fake.getObjectTorrentWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetObjectTorrentInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetObjectTorrentWithContextStub - fakeReturns := fake.getObjectTorrentWithContextReturns - fake.recordInvocation("GetObjectTorrentWithContext", []interface{}{arg1, arg2, arg3}) - fake.getObjectTorrentWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectTorrentWithContextCallCount() int { - fake.getObjectTorrentWithContextMutex.RLock() - defer fake.getObjectTorrentWithContextMutex.RUnlock() - return len(fake.getObjectTorrentWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetObjectTorrentWithContextCalls(stub func(context.Context, *s3.GetObjectTorrentInput, ...request.Option) (*s3.GetObjectTorrentOutput, error)) { - fake.getObjectTorrentWithContextMutex.Lock() - defer fake.getObjectTorrentWithContextMutex.Unlock() - fake.GetObjectTorrentWithContextStub = stub -} - -func (fake *FakeS3Client) GetObjectTorrentWithContextArgsForCall(i int) (context.Context, *s3.GetObjectTorrentInput, []request.Option) { - fake.getObjectTorrentWithContextMutex.RLock() - defer fake.getObjectTorrentWithContextMutex.RUnlock() - argsForCall := fake.getObjectTorrentWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetObjectTorrentWithContextReturns(result1 *s3.GetObjectTorrentOutput, result2 error) { - fake.getObjectTorrentWithContextMutex.Lock() - defer fake.getObjectTorrentWithContextMutex.Unlock() - fake.GetObjectTorrentWithContextStub = nil - fake.getObjectTorrentWithContextReturns = struct { - result1 *s3.GetObjectTorrentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectTorrentWithContextReturnsOnCall(i int, result1 *s3.GetObjectTorrentOutput, result2 error) { - fake.getObjectTorrentWithContextMutex.Lock() - defer fake.getObjectTorrentWithContextMutex.Unlock() - fake.GetObjectTorrentWithContextStub = nil - if fake.getObjectTorrentWithContextReturnsOnCall == nil { - fake.getObjectTorrentWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetObjectTorrentOutput - result2 error - }) - } - fake.getObjectTorrentWithContextReturnsOnCall[i] = struct { - result1 *s3.GetObjectTorrentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectWithContext(arg1 context.Context, arg2 *s3.GetObjectInput, arg3 ...request.Option) (*s3.GetObjectOutput, error) { - fake.getObjectWithContextMutex.Lock() - ret, specificReturn := fake.getObjectWithContextReturnsOnCall[len(fake.getObjectWithContextArgsForCall)] - fake.getObjectWithContextArgsForCall = append(fake.getObjectWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetObjectInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetObjectWithContextStub - fakeReturns := fake.getObjectWithContextReturns - fake.recordInvocation("GetObjectWithContext", []interface{}{arg1, arg2, arg3}) - fake.getObjectWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetObjectWithContextCallCount() int { - fake.getObjectWithContextMutex.RLock() - defer fake.getObjectWithContextMutex.RUnlock() - return len(fake.getObjectWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetObjectWithContextCalls(stub func(context.Context, *s3.GetObjectInput, ...request.Option) (*s3.GetObjectOutput, error)) { - fake.getObjectWithContextMutex.Lock() - defer fake.getObjectWithContextMutex.Unlock() - fake.GetObjectWithContextStub = stub -} - -func (fake *FakeS3Client) GetObjectWithContextArgsForCall(i int) (context.Context, *s3.GetObjectInput, []request.Option) { - fake.getObjectWithContextMutex.RLock() - defer fake.getObjectWithContextMutex.RUnlock() - argsForCall := fake.getObjectWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetObjectWithContextReturns(result1 *s3.GetObjectOutput, result2 error) { - fake.getObjectWithContextMutex.Lock() - defer fake.getObjectWithContextMutex.Unlock() - fake.GetObjectWithContextStub = nil - fake.getObjectWithContextReturns = struct { - result1 *s3.GetObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetObjectWithContextReturnsOnCall(i int, result1 *s3.GetObjectOutput, result2 error) { - fake.getObjectWithContextMutex.Lock() - defer fake.getObjectWithContextMutex.Unlock() - fake.GetObjectWithContextStub = nil - if fake.getObjectWithContextReturnsOnCall == nil { - fake.getObjectWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetObjectOutput - result2 error - }) - } - fake.getObjectWithContextReturnsOnCall[i] = struct { - result1 *s3.GetObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetPublicAccessBlock(arg1 *s3.GetPublicAccessBlockInput) (*s3.GetPublicAccessBlockOutput, error) { - fake.getPublicAccessBlockMutex.Lock() - ret, specificReturn := fake.getPublicAccessBlockReturnsOnCall[len(fake.getPublicAccessBlockArgsForCall)] - fake.getPublicAccessBlockArgsForCall = append(fake.getPublicAccessBlockArgsForCall, struct { - arg1 *s3.GetPublicAccessBlockInput - }{arg1}) - stub := fake.GetPublicAccessBlockStub - fakeReturns := fake.getPublicAccessBlockReturns - fake.recordInvocation("GetPublicAccessBlock", []interface{}{arg1}) - fake.getPublicAccessBlockMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetPublicAccessBlockCallCount() int { - fake.getPublicAccessBlockMutex.RLock() - defer fake.getPublicAccessBlockMutex.RUnlock() - return len(fake.getPublicAccessBlockArgsForCall) -} - -func (fake *FakeS3Client) GetPublicAccessBlockCalls(stub func(*s3.GetPublicAccessBlockInput) (*s3.GetPublicAccessBlockOutput, error)) { - fake.getPublicAccessBlockMutex.Lock() - defer fake.getPublicAccessBlockMutex.Unlock() - fake.GetPublicAccessBlockStub = stub -} - -func (fake *FakeS3Client) GetPublicAccessBlockArgsForCall(i int) *s3.GetPublicAccessBlockInput { - fake.getPublicAccessBlockMutex.RLock() - defer fake.getPublicAccessBlockMutex.RUnlock() - argsForCall := fake.getPublicAccessBlockArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetPublicAccessBlockReturns(result1 *s3.GetPublicAccessBlockOutput, result2 error) { - fake.getPublicAccessBlockMutex.Lock() - defer fake.getPublicAccessBlockMutex.Unlock() - fake.GetPublicAccessBlockStub = nil - fake.getPublicAccessBlockReturns = struct { - result1 *s3.GetPublicAccessBlockOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetPublicAccessBlockReturnsOnCall(i int, result1 *s3.GetPublicAccessBlockOutput, result2 error) { - fake.getPublicAccessBlockMutex.Lock() - defer fake.getPublicAccessBlockMutex.Unlock() - fake.GetPublicAccessBlockStub = nil - if fake.getPublicAccessBlockReturnsOnCall == nil { - fake.getPublicAccessBlockReturnsOnCall = make(map[int]struct { - result1 *s3.GetPublicAccessBlockOutput - result2 error - }) - } - fake.getPublicAccessBlockReturnsOnCall[i] = struct { - result1 *s3.GetPublicAccessBlockOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetPublicAccessBlockRequest(arg1 *s3.GetPublicAccessBlockInput) (*request.Request, *s3.GetPublicAccessBlockOutput) { - fake.getPublicAccessBlockRequestMutex.Lock() - ret, specificReturn := fake.getPublicAccessBlockRequestReturnsOnCall[len(fake.getPublicAccessBlockRequestArgsForCall)] - fake.getPublicAccessBlockRequestArgsForCall = append(fake.getPublicAccessBlockRequestArgsForCall, struct { - arg1 *s3.GetPublicAccessBlockInput - }{arg1}) - stub := fake.GetPublicAccessBlockRequestStub - fakeReturns := fake.getPublicAccessBlockRequestReturns - fake.recordInvocation("GetPublicAccessBlockRequest", []interface{}{arg1}) - fake.getPublicAccessBlockRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetPublicAccessBlockRequestCallCount() int { - fake.getPublicAccessBlockRequestMutex.RLock() - defer fake.getPublicAccessBlockRequestMutex.RUnlock() - return len(fake.getPublicAccessBlockRequestArgsForCall) -} - -func (fake *FakeS3Client) GetPublicAccessBlockRequestCalls(stub func(*s3.GetPublicAccessBlockInput) (*request.Request, *s3.GetPublicAccessBlockOutput)) { - fake.getPublicAccessBlockRequestMutex.Lock() - defer fake.getPublicAccessBlockRequestMutex.Unlock() - fake.GetPublicAccessBlockRequestStub = stub -} - -func (fake *FakeS3Client) GetPublicAccessBlockRequestArgsForCall(i int) *s3.GetPublicAccessBlockInput { - fake.getPublicAccessBlockRequestMutex.RLock() - defer fake.getPublicAccessBlockRequestMutex.RUnlock() - argsForCall := fake.getPublicAccessBlockRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) GetPublicAccessBlockRequestReturns(result1 *request.Request, result2 *s3.GetPublicAccessBlockOutput) { - fake.getPublicAccessBlockRequestMutex.Lock() - defer fake.getPublicAccessBlockRequestMutex.Unlock() - fake.GetPublicAccessBlockRequestStub = nil - fake.getPublicAccessBlockRequestReturns = struct { - result1 *request.Request - result2 *s3.GetPublicAccessBlockOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetPublicAccessBlockRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.GetPublicAccessBlockOutput) { - fake.getPublicAccessBlockRequestMutex.Lock() - defer fake.getPublicAccessBlockRequestMutex.Unlock() - fake.GetPublicAccessBlockRequestStub = nil - if fake.getPublicAccessBlockRequestReturnsOnCall == nil { - fake.getPublicAccessBlockRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.GetPublicAccessBlockOutput - }) - } - fake.getPublicAccessBlockRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.GetPublicAccessBlockOutput - }{result1, result2} -} - -func (fake *FakeS3Client) GetPublicAccessBlockWithContext(arg1 context.Context, arg2 *s3.GetPublicAccessBlockInput, arg3 ...request.Option) (*s3.GetPublicAccessBlockOutput, error) { - fake.getPublicAccessBlockWithContextMutex.Lock() - ret, specificReturn := fake.getPublicAccessBlockWithContextReturnsOnCall[len(fake.getPublicAccessBlockWithContextArgsForCall)] - fake.getPublicAccessBlockWithContextArgsForCall = append(fake.getPublicAccessBlockWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.GetPublicAccessBlockInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.GetPublicAccessBlockWithContextStub - fakeReturns := fake.getPublicAccessBlockWithContextReturns - fake.recordInvocation("GetPublicAccessBlockWithContext", []interface{}{arg1, arg2, arg3}) - fake.getPublicAccessBlockWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) GetPublicAccessBlockWithContextCallCount() int { - fake.getPublicAccessBlockWithContextMutex.RLock() - defer fake.getPublicAccessBlockWithContextMutex.RUnlock() - return len(fake.getPublicAccessBlockWithContextArgsForCall) -} - -func (fake *FakeS3Client) GetPublicAccessBlockWithContextCalls(stub func(context.Context, *s3.GetPublicAccessBlockInput, ...request.Option) (*s3.GetPublicAccessBlockOutput, error)) { - fake.getPublicAccessBlockWithContextMutex.Lock() - defer fake.getPublicAccessBlockWithContextMutex.Unlock() - fake.GetPublicAccessBlockWithContextStub = stub -} - -func (fake *FakeS3Client) GetPublicAccessBlockWithContextArgsForCall(i int) (context.Context, *s3.GetPublicAccessBlockInput, []request.Option) { - fake.getPublicAccessBlockWithContextMutex.RLock() - defer fake.getPublicAccessBlockWithContextMutex.RUnlock() - argsForCall := fake.getPublicAccessBlockWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) GetPublicAccessBlockWithContextReturns(result1 *s3.GetPublicAccessBlockOutput, result2 error) { - fake.getPublicAccessBlockWithContextMutex.Lock() - defer fake.getPublicAccessBlockWithContextMutex.Unlock() - fake.GetPublicAccessBlockWithContextStub = nil - fake.getPublicAccessBlockWithContextReturns = struct { - result1 *s3.GetPublicAccessBlockOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) GetPublicAccessBlockWithContextReturnsOnCall(i int, result1 *s3.GetPublicAccessBlockOutput, result2 error) { - fake.getPublicAccessBlockWithContextMutex.Lock() - defer fake.getPublicAccessBlockWithContextMutex.Unlock() - fake.GetPublicAccessBlockWithContextStub = nil - if fake.getPublicAccessBlockWithContextReturnsOnCall == nil { - fake.getPublicAccessBlockWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.GetPublicAccessBlockOutput - result2 error - }) - } - fake.getPublicAccessBlockWithContextReturnsOnCall[i] = struct { - result1 *s3.GetPublicAccessBlockOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) HeadBucket(arg1 *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) { - fake.headBucketMutex.Lock() - ret, specificReturn := fake.headBucketReturnsOnCall[len(fake.headBucketArgsForCall)] - fake.headBucketArgsForCall = append(fake.headBucketArgsForCall, struct { - arg1 *s3.HeadBucketInput - }{arg1}) - stub := fake.HeadBucketStub - fakeReturns := fake.headBucketReturns - fake.recordInvocation("HeadBucket", []interface{}{arg1}) - fake.headBucketMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) HeadBucketCallCount() int { - fake.headBucketMutex.RLock() - defer fake.headBucketMutex.RUnlock() - return len(fake.headBucketArgsForCall) -} - -func (fake *FakeS3Client) HeadBucketCalls(stub func(*s3.HeadBucketInput) (*s3.HeadBucketOutput, error)) { - fake.headBucketMutex.Lock() - defer fake.headBucketMutex.Unlock() - fake.HeadBucketStub = stub -} - -func (fake *FakeS3Client) HeadBucketArgsForCall(i int) *s3.HeadBucketInput { - fake.headBucketMutex.RLock() - defer fake.headBucketMutex.RUnlock() - argsForCall := fake.headBucketArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) HeadBucketReturns(result1 *s3.HeadBucketOutput, result2 error) { - fake.headBucketMutex.Lock() - defer fake.headBucketMutex.Unlock() - fake.HeadBucketStub = nil - fake.headBucketReturns = struct { - result1 *s3.HeadBucketOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) HeadBucketReturnsOnCall(i int, result1 *s3.HeadBucketOutput, result2 error) { - fake.headBucketMutex.Lock() - defer fake.headBucketMutex.Unlock() - fake.HeadBucketStub = nil - if fake.headBucketReturnsOnCall == nil { - fake.headBucketReturnsOnCall = make(map[int]struct { - result1 *s3.HeadBucketOutput - result2 error - }) - } - fake.headBucketReturnsOnCall[i] = struct { - result1 *s3.HeadBucketOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) HeadBucketRequest(arg1 *s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput) { - fake.headBucketRequestMutex.Lock() - ret, specificReturn := fake.headBucketRequestReturnsOnCall[len(fake.headBucketRequestArgsForCall)] - fake.headBucketRequestArgsForCall = append(fake.headBucketRequestArgsForCall, struct { - arg1 *s3.HeadBucketInput - }{arg1}) - stub := fake.HeadBucketRequestStub - fakeReturns := fake.headBucketRequestReturns - fake.recordInvocation("HeadBucketRequest", []interface{}{arg1}) - fake.headBucketRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) HeadBucketRequestCallCount() int { - fake.headBucketRequestMutex.RLock() - defer fake.headBucketRequestMutex.RUnlock() - return len(fake.headBucketRequestArgsForCall) -} - -func (fake *FakeS3Client) HeadBucketRequestCalls(stub func(*s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput)) { - fake.headBucketRequestMutex.Lock() - defer fake.headBucketRequestMutex.Unlock() - fake.HeadBucketRequestStub = stub -} - -func (fake *FakeS3Client) HeadBucketRequestArgsForCall(i int) *s3.HeadBucketInput { - fake.headBucketRequestMutex.RLock() - defer fake.headBucketRequestMutex.RUnlock() - argsForCall := fake.headBucketRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) HeadBucketRequestReturns(result1 *request.Request, result2 *s3.HeadBucketOutput) { - fake.headBucketRequestMutex.Lock() - defer fake.headBucketRequestMutex.Unlock() - fake.HeadBucketRequestStub = nil - fake.headBucketRequestReturns = struct { - result1 *request.Request - result2 *s3.HeadBucketOutput - }{result1, result2} -} - -func (fake *FakeS3Client) HeadBucketRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.HeadBucketOutput) { - fake.headBucketRequestMutex.Lock() - defer fake.headBucketRequestMutex.Unlock() - fake.HeadBucketRequestStub = nil - if fake.headBucketRequestReturnsOnCall == nil { - fake.headBucketRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.HeadBucketOutput - }) - } - fake.headBucketRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.HeadBucketOutput - }{result1, result2} -} - -func (fake *FakeS3Client) HeadBucketWithContext(arg1 context.Context, arg2 *s3.HeadBucketInput, arg3 ...request.Option) (*s3.HeadBucketOutput, error) { - fake.headBucketWithContextMutex.Lock() - ret, specificReturn := fake.headBucketWithContextReturnsOnCall[len(fake.headBucketWithContextArgsForCall)] - fake.headBucketWithContextArgsForCall = append(fake.headBucketWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.HeadBucketInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.HeadBucketWithContextStub - fakeReturns := fake.headBucketWithContextReturns - fake.recordInvocation("HeadBucketWithContext", []interface{}{arg1, arg2, arg3}) - fake.headBucketWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) HeadBucketWithContextCallCount() int { - fake.headBucketWithContextMutex.RLock() - defer fake.headBucketWithContextMutex.RUnlock() - return len(fake.headBucketWithContextArgsForCall) -} - -func (fake *FakeS3Client) HeadBucketWithContextCalls(stub func(context.Context, *s3.HeadBucketInput, ...request.Option) (*s3.HeadBucketOutput, error)) { - fake.headBucketWithContextMutex.Lock() - defer fake.headBucketWithContextMutex.Unlock() - fake.HeadBucketWithContextStub = stub -} - -func (fake *FakeS3Client) HeadBucketWithContextArgsForCall(i int) (context.Context, *s3.HeadBucketInput, []request.Option) { - fake.headBucketWithContextMutex.RLock() - defer fake.headBucketWithContextMutex.RUnlock() - argsForCall := fake.headBucketWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) HeadBucketWithContextReturns(result1 *s3.HeadBucketOutput, result2 error) { - fake.headBucketWithContextMutex.Lock() - defer fake.headBucketWithContextMutex.Unlock() - fake.HeadBucketWithContextStub = nil - fake.headBucketWithContextReturns = struct { - result1 *s3.HeadBucketOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) HeadBucketWithContextReturnsOnCall(i int, result1 *s3.HeadBucketOutput, result2 error) { - fake.headBucketWithContextMutex.Lock() - defer fake.headBucketWithContextMutex.Unlock() - fake.HeadBucketWithContextStub = nil - if fake.headBucketWithContextReturnsOnCall == nil { - fake.headBucketWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.HeadBucketOutput - result2 error - }) - } - fake.headBucketWithContextReturnsOnCall[i] = struct { - result1 *s3.HeadBucketOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) HeadObject(arg1 *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) { - fake.headObjectMutex.Lock() - ret, specificReturn := fake.headObjectReturnsOnCall[len(fake.headObjectArgsForCall)] - fake.headObjectArgsForCall = append(fake.headObjectArgsForCall, struct { - arg1 *s3.HeadObjectInput - }{arg1}) - stub := fake.HeadObjectStub - fakeReturns := fake.headObjectReturns - fake.recordInvocation("HeadObject", []interface{}{arg1}) - fake.headObjectMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) HeadObjectCallCount() int { - fake.headObjectMutex.RLock() - defer fake.headObjectMutex.RUnlock() - return len(fake.headObjectArgsForCall) -} - -func (fake *FakeS3Client) HeadObjectCalls(stub func(*s3.HeadObjectInput) (*s3.HeadObjectOutput, error)) { - fake.headObjectMutex.Lock() - defer fake.headObjectMutex.Unlock() - fake.HeadObjectStub = stub -} - -func (fake *FakeS3Client) HeadObjectArgsForCall(i int) *s3.HeadObjectInput { - fake.headObjectMutex.RLock() - defer fake.headObjectMutex.RUnlock() - argsForCall := fake.headObjectArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) HeadObjectReturns(result1 *s3.HeadObjectOutput, result2 error) { - fake.headObjectMutex.Lock() - defer fake.headObjectMutex.Unlock() - fake.HeadObjectStub = nil - fake.headObjectReturns = struct { - result1 *s3.HeadObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) HeadObjectReturnsOnCall(i int, result1 *s3.HeadObjectOutput, result2 error) { - fake.headObjectMutex.Lock() - defer fake.headObjectMutex.Unlock() - fake.HeadObjectStub = nil - if fake.headObjectReturnsOnCall == nil { - fake.headObjectReturnsOnCall = make(map[int]struct { - result1 *s3.HeadObjectOutput - result2 error - }) - } - fake.headObjectReturnsOnCall[i] = struct { - result1 *s3.HeadObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) HeadObjectRequest(arg1 *s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput) { - fake.headObjectRequestMutex.Lock() - ret, specificReturn := fake.headObjectRequestReturnsOnCall[len(fake.headObjectRequestArgsForCall)] - fake.headObjectRequestArgsForCall = append(fake.headObjectRequestArgsForCall, struct { - arg1 *s3.HeadObjectInput - }{arg1}) - stub := fake.HeadObjectRequestStub - fakeReturns := fake.headObjectRequestReturns - fake.recordInvocation("HeadObjectRequest", []interface{}{arg1}) - fake.headObjectRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) HeadObjectRequestCallCount() int { - fake.headObjectRequestMutex.RLock() - defer fake.headObjectRequestMutex.RUnlock() - return len(fake.headObjectRequestArgsForCall) -} - -func (fake *FakeS3Client) HeadObjectRequestCalls(stub func(*s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput)) { - fake.headObjectRequestMutex.Lock() - defer fake.headObjectRequestMutex.Unlock() - fake.HeadObjectRequestStub = stub -} - -func (fake *FakeS3Client) HeadObjectRequestArgsForCall(i int) *s3.HeadObjectInput { - fake.headObjectRequestMutex.RLock() - defer fake.headObjectRequestMutex.RUnlock() - argsForCall := fake.headObjectRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) HeadObjectRequestReturns(result1 *request.Request, result2 *s3.HeadObjectOutput) { - fake.headObjectRequestMutex.Lock() - defer fake.headObjectRequestMutex.Unlock() - fake.HeadObjectRequestStub = nil - fake.headObjectRequestReturns = struct { - result1 *request.Request - result2 *s3.HeadObjectOutput - }{result1, result2} -} - -func (fake *FakeS3Client) HeadObjectRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.HeadObjectOutput) { - fake.headObjectRequestMutex.Lock() - defer fake.headObjectRequestMutex.Unlock() - fake.HeadObjectRequestStub = nil - if fake.headObjectRequestReturnsOnCall == nil { - fake.headObjectRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.HeadObjectOutput - }) - } - fake.headObjectRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.HeadObjectOutput - }{result1, result2} -} - -func (fake *FakeS3Client) HeadObjectWithContext(arg1 context.Context, arg2 *s3.HeadObjectInput, arg3 ...request.Option) (*s3.HeadObjectOutput, error) { - fake.headObjectWithContextMutex.Lock() - ret, specificReturn := fake.headObjectWithContextReturnsOnCall[len(fake.headObjectWithContextArgsForCall)] - fake.headObjectWithContextArgsForCall = append(fake.headObjectWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.HeadObjectInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.HeadObjectWithContextStub - fakeReturns := fake.headObjectWithContextReturns - fake.recordInvocation("HeadObjectWithContext", []interface{}{arg1, arg2, arg3}) - fake.headObjectWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) HeadObjectWithContextCallCount() int { - fake.headObjectWithContextMutex.RLock() - defer fake.headObjectWithContextMutex.RUnlock() - return len(fake.headObjectWithContextArgsForCall) -} - -func (fake *FakeS3Client) HeadObjectWithContextCalls(stub func(context.Context, *s3.HeadObjectInput, ...request.Option) (*s3.HeadObjectOutput, error)) { - fake.headObjectWithContextMutex.Lock() - defer fake.headObjectWithContextMutex.Unlock() - fake.HeadObjectWithContextStub = stub -} - -func (fake *FakeS3Client) HeadObjectWithContextArgsForCall(i int) (context.Context, *s3.HeadObjectInput, []request.Option) { - fake.headObjectWithContextMutex.RLock() - defer fake.headObjectWithContextMutex.RUnlock() - argsForCall := fake.headObjectWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) HeadObjectWithContextReturns(result1 *s3.HeadObjectOutput, result2 error) { - fake.headObjectWithContextMutex.Lock() - defer fake.headObjectWithContextMutex.Unlock() - fake.HeadObjectWithContextStub = nil - fake.headObjectWithContextReturns = struct { - result1 *s3.HeadObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) HeadObjectWithContextReturnsOnCall(i int, result1 *s3.HeadObjectOutput, result2 error) { - fake.headObjectWithContextMutex.Lock() - defer fake.headObjectWithContextMutex.Unlock() - fake.HeadObjectWithContextStub = nil - if fake.headObjectWithContextReturnsOnCall == nil { - fake.headObjectWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.HeadObjectOutput - result2 error - }) - } - fake.headObjectWithContextReturnsOnCall[i] = struct { - result1 *s3.HeadObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurations(arg1 *s3.ListBucketAnalyticsConfigurationsInput) (*s3.ListBucketAnalyticsConfigurationsOutput, error) { - fake.listBucketAnalyticsConfigurationsMutex.Lock() - ret, specificReturn := fake.listBucketAnalyticsConfigurationsReturnsOnCall[len(fake.listBucketAnalyticsConfigurationsArgsForCall)] - fake.listBucketAnalyticsConfigurationsArgsForCall = append(fake.listBucketAnalyticsConfigurationsArgsForCall, struct { - arg1 *s3.ListBucketAnalyticsConfigurationsInput - }{arg1}) - stub := fake.ListBucketAnalyticsConfigurationsStub - fakeReturns := fake.listBucketAnalyticsConfigurationsReturns - fake.recordInvocation("ListBucketAnalyticsConfigurations", []interface{}{arg1}) - fake.listBucketAnalyticsConfigurationsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsCallCount() int { - fake.listBucketAnalyticsConfigurationsMutex.RLock() - defer fake.listBucketAnalyticsConfigurationsMutex.RUnlock() - return len(fake.listBucketAnalyticsConfigurationsArgsForCall) -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsCalls(stub func(*s3.ListBucketAnalyticsConfigurationsInput) (*s3.ListBucketAnalyticsConfigurationsOutput, error)) { - fake.listBucketAnalyticsConfigurationsMutex.Lock() - defer fake.listBucketAnalyticsConfigurationsMutex.Unlock() - fake.ListBucketAnalyticsConfigurationsStub = stub -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsArgsForCall(i int) *s3.ListBucketAnalyticsConfigurationsInput { - fake.listBucketAnalyticsConfigurationsMutex.RLock() - defer fake.listBucketAnalyticsConfigurationsMutex.RUnlock() - argsForCall := fake.listBucketAnalyticsConfigurationsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsReturns(result1 *s3.ListBucketAnalyticsConfigurationsOutput, result2 error) { - fake.listBucketAnalyticsConfigurationsMutex.Lock() - defer fake.listBucketAnalyticsConfigurationsMutex.Unlock() - fake.ListBucketAnalyticsConfigurationsStub = nil - fake.listBucketAnalyticsConfigurationsReturns = struct { - result1 *s3.ListBucketAnalyticsConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsReturnsOnCall(i int, result1 *s3.ListBucketAnalyticsConfigurationsOutput, result2 error) { - fake.listBucketAnalyticsConfigurationsMutex.Lock() - defer fake.listBucketAnalyticsConfigurationsMutex.Unlock() - fake.ListBucketAnalyticsConfigurationsStub = nil - if fake.listBucketAnalyticsConfigurationsReturnsOnCall == nil { - fake.listBucketAnalyticsConfigurationsReturnsOnCall = make(map[int]struct { - result1 *s3.ListBucketAnalyticsConfigurationsOutput - result2 error - }) - } - fake.listBucketAnalyticsConfigurationsReturnsOnCall[i] = struct { - result1 *s3.ListBucketAnalyticsConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsRequest(arg1 *s3.ListBucketAnalyticsConfigurationsInput) (*request.Request, *s3.ListBucketAnalyticsConfigurationsOutput) { - fake.listBucketAnalyticsConfigurationsRequestMutex.Lock() - ret, specificReturn := fake.listBucketAnalyticsConfigurationsRequestReturnsOnCall[len(fake.listBucketAnalyticsConfigurationsRequestArgsForCall)] - fake.listBucketAnalyticsConfigurationsRequestArgsForCall = append(fake.listBucketAnalyticsConfigurationsRequestArgsForCall, struct { - arg1 *s3.ListBucketAnalyticsConfigurationsInput - }{arg1}) - stub := fake.ListBucketAnalyticsConfigurationsRequestStub - fakeReturns := fake.listBucketAnalyticsConfigurationsRequestReturns - fake.recordInvocation("ListBucketAnalyticsConfigurationsRequest", []interface{}{arg1}) - fake.listBucketAnalyticsConfigurationsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsRequestCallCount() int { - fake.listBucketAnalyticsConfigurationsRequestMutex.RLock() - defer fake.listBucketAnalyticsConfigurationsRequestMutex.RUnlock() - return len(fake.listBucketAnalyticsConfigurationsRequestArgsForCall) -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsRequestCalls(stub func(*s3.ListBucketAnalyticsConfigurationsInput) (*request.Request, *s3.ListBucketAnalyticsConfigurationsOutput)) { - fake.listBucketAnalyticsConfigurationsRequestMutex.Lock() - defer fake.listBucketAnalyticsConfigurationsRequestMutex.Unlock() - fake.ListBucketAnalyticsConfigurationsRequestStub = stub -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsRequestArgsForCall(i int) *s3.ListBucketAnalyticsConfigurationsInput { - fake.listBucketAnalyticsConfigurationsRequestMutex.RLock() - defer fake.listBucketAnalyticsConfigurationsRequestMutex.RUnlock() - argsForCall := fake.listBucketAnalyticsConfigurationsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsRequestReturns(result1 *request.Request, result2 *s3.ListBucketAnalyticsConfigurationsOutput) { - fake.listBucketAnalyticsConfigurationsRequestMutex.Lock() - defer fake.listBucketAnalyticsConfigurationsRequestMutex.Unlock() - fake.ListBucketAnalyticsConfigurationsRequestStub = nil - fake.listBucketAnalyticsConfigurationsRequestReturns = struct { - result1 *request.Request - result2 *s3.ListBucketAnalyticsConfigurationsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.ListBucketAnalyticsConfigurationsOutput) { - fake.listBucketAnalyticsConfigurationsRequestMutex.Lock() - defer fake.listBucketAnalyticsConfigurationsRequestMutex.Unlock() - fake.ListBucketAnalyticsConfigurationsRequestStub = nil - if fake.listBucketAnalyticsConfigurationsRequestReturnsOnCall == nil { - fake.listBucketAnalyticsConfigurationsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.ListBucketAnalyticsConfigurationsOutput - }) - } - fake.listBucketAnalyticsConfigurationsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.ListBucketAnalyticsConfigurationsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsWithContext(arg1 context.Context, arg2 *s3.ListBucketAnalyticsConfigurationsInput, arg3 ...request.Option) (*s3.ListBucketAnalyticsConfigurationsOutput, error) { - fake.listBucketAnalyticsConfigurationsWithContextMutex.Lock() - ret, specificReturn := fake.listBucketAnalyticsConfigurationsWithContextReturnsOnCall[len(fake.listBucketAnalyticsConfigurationsWithContextArgsForCall)] - fake.listBucketAnalyticsConfigurationsWithContextArgsForCall = append(fake.listBucketAnalyticsConfigurationsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListBucketAnalyticsConfigurationsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.ListBucketAnalyticsConfigurationsWithContextStub - fakeReturns := fake.listBucketAnalyticsConfigurationsWithContextReturns - fake.recordInvocation("ListBucketAnalyticsConfigurationsWithContext", []interface{}{arg1, arg2, arg3}) - fake.listBucketAnalyticsConfigurationsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsWithContextCallCount() int { - fake.listBucketAnalyticsConfigurationsWithContextMutex.RLock() - defer fake.listBucketAnalyticsConfigurationsWithContextMutex.RUnlock() - return len(fake.listBucketAnalyticsConfigurationsWithContextArgsForCall) -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsWithContextCalls(stub func(context.Context, *s3.ListBucketAnalyticsConfigurationsInput, ...request.Option) (*s3.ListBucketAnalyticsConfigurationsOutput, error)) { - fake.listBucketAnalyticsConfigurationsWithContextMutex.Lock() - defer fake.listBucketAnalyticsConfigurationsWithContextMutex.Unlock() - fake.ListBucketAnalyticsConfigurationsWithContextStub = stub -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsWithContextArgsForCall(i int) (context.Context, *s3.ListBucketAnalyticsConfigurationsInput, []request.Option) { - fake.listBucketAnalyticsConfigurationsWithContextMutex.RLock() - defer fake.listBucketAnalyticsConfigurationsWithContextMutex.RUnlock() - argsForCall := fake.listBucketAnalyticsConfigurationsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsWithContextReturns(result1 *s3.ListBucketAnalyticsConfigurationsOutput, result2 error) { - fake.listBucketAnalyticsConfigurationsWithContextMutex.Lock() - defer fake.listBucketAnalyticsConfigurationsWithContextMutex.Unlock() - fake.ListBucketAnalyticsConfigurationsWithContextStub = nil - fake.listBucketAnalyticsConfigurationsWithContextReturns = struct { - result1 *s3.ListBucketAnalyticsConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketAnalyticsConfigurationsWithContextReturnsOnCall(i int, result1 *s3.ListBucketAnalyticsConfigurationsOutput, result2 error) { - fake.listBucketAnalyticsConfigurationsWithContextMutex.Lock() - defer fake.listBucketAnalyticsConfigurationsWithContextMutex.Unlock() - fake.ListBucketAnalyticsConfigurationsWithContextStub = nil - if fake.listBucketAnalyticsConfigurationsWithContextReturnsOnCall == nil { - fake.listBucketAnalyticsConfigurationsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.ListBucketAnalyticsConfigurationsOutput - result2 error - }) - } - fake.listBucketAnalyticsConfigurationsWithContextReturnsOnCall[i] = struct { - result1 *s3.ListBucketAnalyticsConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurations(arg1 *s3.ListBucketIntelligentTieringConfigurationsInput) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error) { - fake.listBucketIntelligentTieringConfigurationsMutex.Lock() - ret, specificReturn := fake.listBucketIntelligentTieringConfigurationsReturnsOnCall[len(fake.listBucketIntelligentTieringConfigurationsArgsForCall)] - fake.listBucketIntelligentTieringConfigurationsArgsForCall = append(fake.listBucketIntelligentTieringConfigurationsArgsForCall, struct { - arg1 *s3.ListBucketIntelligentTieringConfigurationsInput - }{arg1}) - stub := fake.ListBucketIntelligentTieringConfigurationsStub - fakeReturns := fake.listBucketIntelligentTieringConfigurationsReturns - fake.recordInvocation("ListBucketIntelligentTieringConfigurations", []interface{}{arg1}) - fake.listBucketIntelligentTieringConfigurationsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsCallCount() int { - fake.listBucketIntelligentTieringConfigurationsMutex.RLock() - defer fake.listBucketIntelligentTieringConfigurationsMutex.RUnlock() - return len(fake.listBucketIntelligentTieringConfigurationsArgsForCall) -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsCalls(stub func(*s3.ListBucketIntelligentTieringConfigurationsInput) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error)) { - fake.listBucketIntelligentTieringConfigurationsMutex.Lock() - defer fake.listBucketIntelligentTieringConfigurationsMutex.Unlock() - fake.ListBucketIntelligentTieringConfigurationsStub = stub -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsArgsForCall(i int) *s3.ListBucketIntelligentTieringConfigurationsInput { - fake.listBucketIntelligentTieringConfigurationsMutex.RLock() - defer fake.listBucketIntelligentTieringConfigurationsMutex.RUnlock() - argsForCall := fake.listBucketIntelligentTieringConfigurationsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsReturns(result1 *s3.ListBucketIntelligentTieringConfigurationsOutput, result2 error) { - fake.listBucketIntelligentTieringConfigurationsMutex.Lock() - defer fake.listBucketIntelligentTieringConfigurationsMutex.Unlock() - fake.ListBucketIntelligentTieringConfigurationsStub = nil - fake.listBucketIntelligentTieringConfigurationsReturns = struct { - result1 *s3.ListBucketIntelligentTieringConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsReturnsOnCall(i int, result1 *s3.ListBucketIntelligentTieringConfigurationsOutput, result2 error) { - fake.listBucketIntelligentTieringConfigurationsMutex.Lock() - defer fake.listBucketIntelligentTieringConfigurationsMutex.Unlock() - fake.ListBucketIntelligentTieringConfigurationsStub = nil - if fake.listBucketIntelligentTieringConfigurationsReturnsOnCall == nil { - fake.listBucketIntelligentTieringConfigurationsReturnsOnCall = make(map[int]struct { - result1 *s3.ListBucketIntelligentTieringConfigurationsOutput - result2 error - }) - } - fake.listBucketIntelligentTieringConfigurationsReturnsOnCall[i] = struct { - result1 *s3.ListBucketIntelligentTieringConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsRequest(arg1 *s3.ListBucketIntelligentTieringConfigurationsInput) (*request.Request, *s3.ListBucketIntelligentTieringConfigurationsOutput) { - fake.listBucketIntelligentTieringConfigurationsRequestMutex.Lock() - ret, specificReturn := fake.listBucketIntelligentTieringConfigurationsRequestReturnsOnCall[len(fake.listBucketIntelligentTieringConfigurationsRequestArgsForCall)] - fake.listBucketIntelligentTieringConfigurationsRequestArgsForCall = append(fake.listBucketIntelligentTieringConfigurationsRequestArgsForCall, struct { - arg1 *s3.ListBucketIntelligentTieringConfigurationsInput - }{arg1}) - stub := fake.ListBucketIntelligentTieringConfigurationsRequestStub - fakeReturns := fake.listBucketIntelligentTieringConfigurationsRequestReturns - fake.recordInvocation("ListBucketIntelligentTieringConfigurationsRequest", []interface{}{arg1}) - fake.listBucketIntelligentTieringConfigurationsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsRequestCallCount() int { - fake.listBucketIntelligentTieringConfigurationsRequestMutex.RLock() - defer fake.listBucketIntelligentTieringConfigurationsRequestMutex.RUnlock() - return len(fake.listBucketIntelligentTieringConfigurationsRequestArgsForCall) -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsRequestCalls(stub func(*s3.ListBucketIntelligentTieringConfigurationsInput) (*request.Request, *s3.ListBucketIntelligentTieringConfigurationsOutput)) { - fake.listBucketIntelligentTieringConfigurationsRequestMutex.Lock() - defer fake.listBucketIntelligentTieringConfigurationsRequestMutex.Unlock() - fake.ListBucketIntelligentTieringConfigurationsRequestStub = stub -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsRequestArgsForCall(i int) *s3.ListBucketIntelligentTieringConfigurationsInput { - fake.listBucketIntelligentTieringConfigurationsRequestMutex.RLock() - defer fake.listBucketIntelligentTieringConfigurationsRequestMutex.RUnlock() - argsForCall := fake.listBucketIntelligentTieringConfigurationsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsRequestReturns(result1 *request.Request, result2 *s3.ListBucketIntelligentTieringConfigurationsOutput) { - fake.listBucketIntelligentTieringConfigurationsRequestMutex.Lock() - defer fake.listBucketIntelligentTieringConfigurationsRequestMutex.Unlock() - fake.ListBucketIntelligentTieringConfigurationsRequestStub = nil - fake.listBucketIntelligentTieringConfigurationsRequestReturns = struct { - result1 *request.Request - result2 *s3.ListBucketIntelligentTieringConfigurationsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.ListBucketIntelligentTieringConfigurationsOutput) { - fake.listBucketIntelligentTieringConfigurationsRequestMutex.Lock() - defer fake.listBucketIntelligentTieringConfigurationsRequestMutex.Unlock() - fake.ListBucketIntelligentTieringConfigurationsRequestStub = nil - if fake.listBucketIntelligentTieringConfigurationsRequestReturnsOnCall == nil { - fake.listBucketIntelligentTieringConfigurationsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.ListBucketIntelligentTieringConfigurationsOutput - }) - } - fake.listBucketIntelligentTieringConfigurationsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.ListBucketIntelligentTieringConfigurationsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsWithContext(arg1 context.Context, arg2 *s3.ListBucketIntelligentTieringConfigurationsInput, arg3 ...request.Option) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error) { - fake.listBucketIntelligentTieringConfigurationsWithContextMutex.Lock() - ret, specificReturn := fake.listBucketIntelligentTieringConfigurationsWithContextReturnsOnCall[len(fake.listBucketIntelligentTieringConfigurationsWithContextArgsForCall)] - fake.listBucketIntelligentTieringConfigurationsWithContextArgsForCall = append(fake.listBucketIntelligentTieringConfigurationsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListBucketIntelligentTieringConfigurationsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.ListBucketIntelligentTieringConfigurationsWithContextStub - fakeReturns := fake.listBucketIntelligentTieringConfigurationsWithContextReturns - fake.recordInvocation("ListBucketIntelligentTieringConfigurationsWithContext", []interface{}{arg1, arg2, arg3}) - fake.listBucketIntelligentTieringConfigurationsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsWithContextCallCount() int { - fake.listBucketIntelligentTieringConfigurationsWithContextMutex.RLock() - defer fake.listBucketIntelligentTieringConfigurationsWithContextMutex.RUnlock() - return len(fake.listBucketIntelligentTieringConfigurationsWithContextArgsForCall) -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsWithContextCalls(stub func(context.Context, *s3.ListBucketIntelligentTieringConfigurationsInput, ...request.Option) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error)) { - fake.listBucketIntelligentTieringConfigurationsWithContextMutex.Lock() - defer fake.listBucketIntelligentTieringConfigurationsWithContextMutex.Unlock() - fake.ListBucketIntelligentTieringConfigurationsWithContextStub = stub -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsWithContextArgsForCall(i int) (context.Context, *s3.ListBucketIntelligentTieringConfigurationsInput, []request.Option) { - fake.listBucketIntelligentTieringConfigurationsWithContextMutex.RLock() - defer fake.listBucketIntelligentTieringConfigurationsWithContextMutex.RUnlock() - argsForCall := fake.listBucketIntelligentTieringConfigurationsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsWithContextReturns(result1 *s3.ListBucketIntelligentTieringConfigurationsOutput, result2 error) { - fake.listBucketIntelligentTieringConfigurationsWithContextMutex.Lock() - defer fake.listBucketIntelligentTieringConfigurationsWithContextMutex.Unlock() - fake.ListBucketIntelligentTieringConfigurationsWithContextStub = nil - fake.listBucketIntelligentTieringConfigurationsWithContextReturns = struct { - result1 *s3.ListBucketIntelligentTieringConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketIntelligentTieringConfigurationsWithContextReturnsOnCall(i int, result1 *s3.ListBucketIntelligentTieringConfigurationsOutput, result2 error) { - fake.listBucketIntelligentTieringConfigurationsWithContextMutex.Lock() - defer fake.listBucketIntelligentTieringConfigurationsWithContextMutex.Unlock() - fake.ListBucketIntelligentTieringConfigurationsWithContextStub = nil - if fake.listBucketIntelligentTieringConfigurationsWithContextReturnsOnCall == nil { - fake.listBucketIntelligentTieringConfigurationsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.ListBucketIntelligentTieringConfigurationsOutput - result2 error - }) - } - fake.listBucketIntelligentTieringConfigurationsWithContextReturnsOnCall[i] = struct { - result1 *s3.ListBucketIntelligentTieringConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurations(arg1 *s3.ListBucketInventoryConfigurationsInput) (*s3.ListBucketInventoryConfigurationsOutput, error) { - fake.listBucketInventoryConfigurationsMutex.Lock() - ret, specificReturn := fake.listBucketInventoryConfigurationsReturnsOnCall[len(fake.listBucketInventoryConfigurationsArgsForCall)] - fake.listBucketInventoryConfigurationsArgsForCall = append(fake.listBucketInventoryConfigurationsArgsForCall, struct { - arg1 *s3.ListBucketInventoryConfigurationsInput - }{arg1}) - stub := fake.ListBucketInventoryConfigurationsStub - fakeReturns := fake.listBucketInventoryConfigurationsReturns - fake.recordInvocation("ListBucketInventoryConfigurations", []interface{}{arg1}) - fake.listBucketInventoryConfigurationsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsCallCount() int { - fake.listBucketInventoryConfigurationsMutex.RLock() - defer fake.listBucketInventoryConfigurationsMutex.RUnlock() - return len(fake.listBucketInventoryConfigurationsArgsForCall) -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsCalls(stub func(*s3.ListBucketInventoryConfigurationsInput) (*s3.ListBucketInventoryConfigurationsOutput, error)) { - fake.listBucketInventoryConfigurationsMutex.Lock() - defer fake.listBucketInventoryConfigurationsMutex.Unlock() - fake.ListBucketInventoryConfigurationsStub = stub -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsArgsForCall(i int) *s3.ListBucketInventoryConfigurationsInput { - fake.listBucketInventoryConfigurationsMutex.RLock() - defer fake.listBucketInventoryConfigurationsMutex.RUnlock() - argsForCall := fake.listBucketInventoryConfigurationsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsReturns(result1 *s3.ListBucketInventoryConfigurationsOutput, result2 error) { - fake.listBucketInventoryConfigurationsMutex.Lock() - defer fake.listBucketInventoryConfigurationsMutex.Unlock() - fake.ListBucketInventoryConfigurationsStub = nil - fake.listBucketInventoryConfigurationsReturns = struct { - result1 *s3.ListBucketInventoryConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsReturnsOnCall(i int, result1 *s3.ListBucketInventoryConfigurationsOutput, result2 error) { - fake.listBucketInventoryConfigurationsMutex.Lock() - defer fake.listBucketInventoryConfigurationsMutex.Unlock() - fake.ListBucketInventoryConfigurationsStub = nil - if fake.listBucketInventoryConfigurationsReturnsOnCall == nil { - fake.listBucketInventoryConfigurationsReturnsOnCall = make(map[int]struct { - result1 *s3.ListBucketInventoryConfigurationsOutput - result2 error - }) - } - fake.listBucketInventoryConfigurationsReturnsOnCall[i] = struct { - result1 *s3.ListBucketInventoryConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsRequest(arg1 *s3.ListBucketInventoryConfigurationsInput) (*request.Request, *s3.ListBucketInventoryConfigurationsOutput) { - fake.listBucketInventoryConfigurationsRequestMutex.Lock() - ret, specificReturn := fake.listBucketInventoryConfigurationsRequestReturnsOnCall[len(fake.listBucketInventoryConfigurationsRequestArgsForCall)] - fake.listBucketInventoryConfigurationsRequestArgsForCall = append(fake.listBucketInventoryConfigurationsRequestArgsForCall, struct { - arg1 *s3.ListBucketInventoryConfigurationsInput - }{arg1}) - stub := fake.ListBucketInventoryConfigurationsRequestStub - fakeReturns := fake.listBucketInventoryConfigurationsRequestReturns - fake.recordInvocation("ListBucketInventoryConfigurationsRequest", []interface{}{arg1}) - fake.listBucketInventoryConfigurationsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsRequestCallCount() int { - fake.listBucketInventoryConfigurationsRequestMutex.RLock() - defer fake.listBucketInventoryConfigurationsRequestMutex.RUnlock() - return len(fake.listBucketInventoryConfigurationsRequestArgsForCall) -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsRequestCalls(stub func(*s3.ListBucketInventoryConfigurationsInput) (*request.Request, *s3.ListBucketInventoryConfigurationsOutput)) { - fake.listBucketInventoryConfigurationsRequestMutex.Lock() - defer fake.listBucketInventoryConfigurationsRequestMutex.Unlock() - fake.ListBucketInventoryConfigurationsRequestStub = stub -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsRequestArgsForCall(i int) *s3.ListBucketInventoryConfigurationsInput { - fake.listBucketInventoryConfigurationsRequestMutex.RLock() - defer fake.listBucketInventoryConfigurationsRequestMutex.RUnlock() - argsForCall := fake.listBucketInventoryConfigurationsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsRequestReturns(result1 *request.Request, result2 *s3.ListBucketInventoryConfigurationsOutput) { - fake.listBucketInventoryConfigurationsRequestMutex.Lock() - defer fake.listBucketInventoryConfigurationsRequestMutex.Unlock() - fake.ListBucketInventoryConfigurationsRequestStub = nil - fake.listBucketInventoryConfigurationsRequestReturns = struct { - result1 *request.Request - result2 *s3.ListBucketInventoryConfigurationsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.ListBucketInventoryConfigurationsOutput) { - fake.listBucketInventoryConfigurationsRequestMutex.Lock() - defer fake.listBucketInventoryConfigurationsRequestMutex.Unlock() - fake.ListBucketInventoryConfigurationsRequestStub = nil - if fake.listBucketInventoryConfigurationsRequestReturnsOnCall == nil { - fake.listBucketInventoryConfigurationsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.ListBucketInventoryConfigurationsOutput - }) - } - fake.listBucketInventoryConfigurationsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.ListBucketInventoryConfigurationsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsWithContext(arg1 context.Context, arg2 *s3.ListBucketInventoryConfigurationsInput, arg3 ...request.Option) (*s3.ListBucketInventoryConfigurationsOutput, error) { - fake.listBucketInventoryConfigurationsWithContextMutex.Lock() - ret, specificReturn := fake.listBucketInventoryConfigurationsWithContextReturnsOnCall[len(fake.listBucketInventoryConfigurationsWithContextArgsForCall)] - fake.listBucketInventoryConfigurationsWithContextArgsForCall = append(fake.listBucketInventoryConfigurationsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListBucketInventoryConfigurationsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.ListBucketInventoryConfigurationsWithContextStub - fakeReturns := fake.listBucketInventoryConfigurationsWithContextReturns - fake.recordInvocation("ListBucketInventoryConfigurationsWithContext", []interface{}{arg1, arg2, arg3}) - fake.listBucketInventoryConfigurationsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsWithContextCallCount() int { - fake.listBucketInventoryConfigurationsWithContextMutex.RLock() - defer fake.listBucketInventoryConfigurationsWithContextMutex.RUnlock() - return len(fake.listBucketInventoryConfigurationsWithContextArgsForCall) -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsWithContextCalls(stub func(context.Context, *s3.ListBucketInventoryConfigurationsInput, ...request.Option) (*s3.ListBucketInventoryConfigurationsOutput, error)) { - fake.listBucketInventoryConfigurationsWithContextMutex.Lock() - defer fake.listBucketInventoryConfigurationsWithContextMutex.Unlock() - fake.ListBucketInventoryConfigurationsWithContextStub = stub -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsWithContextArgsForCall(i int) (context.Context, *s3.ListBucketInventoryConfigurationsInput, []request.Option) { - fake.listBucketInventoryConfigurationsWithContextMutex.RLock() - defer fake.listBucketInventoryConfigurationsWithContextMutex.RUnlock() - argsForCall := fake.listBucketInventoryConfigurationsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsWithContextReturns(result1 *s3.ListBucketInventoryConfigurationsOutput, result2 error) { - fake.listBucketInventoryConfigurationsWithContextMutex.Lock() - defer fake.listBucketInventoryConfigurationsWithContextMutex.Unlock() - fake.ListBucketInventoryConfigurationsWithContextStub = nil - fake.listBucketInventoryConfigurationsWithContextReturns = struct { - result1 *s3.ListBucketInventoryConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketInventoryConfigurationsWithContextReturnsOnCall(i int, result1 *s3.ListBucketInventoryConfigurationsOutput, result2 error) { - fake.listBucketInventoryConfigurationsWithContextMutex.Lock() - defer fake.listBucketInventoryConfigurationsWithContextMutex.Unlock() - fake.ListBucketInventoryConfigurationsWithContextStub = nil - if fake.listBucketInventoryConfigurationsWithContextReturnsOnCall == nil { - fake.listBucketInventoryConfigurationsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.ListBucketInventoryConfigurationsOutput - result2 error - }) - } - fake.listBucketInventoryConfigurationsWithContextReturnsOnCall[i] = struct { - result1 *s3.ListBucketInventoryConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurations(arg1 *s3.ListBucketMetricsConfigurationsInput) (*s3.ListBucketMetricsConfigurationsOutput, error) { - fake.listBucketMetricsConfigurationsMutex.Lock() - ret, specificReturn := fake.listBucketMetricsConfigurationsReturnsOnCall[len(fake.listBucketMetricsConfigurationsArgsForCall)] - fake.listBucketMetricsConfigurationsArgsForCall = append(fake.listBucketMetricsConfigurationsArgsForCall, struct { - arg1 *s3.ListBucketMetricsConfigurationsInput - }{arg1}) - stub := fake.ListBucketMetricsConfigurationsStub - fakeReturns := fake.listBucketMetricsConfigurationsReturns - fake.recordInvocation("ListBucketMetricsConfigurations", []interface{}{arg1}) - fake.listBucketMetricsConfigurationsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsCallCount() int { - fake.listBucketMetricsConfigurationsMutex.RLock() - defer fake.listBucketMetricsConfigurationsMutex.RUnlock() - return len(fake.listBucketMetricsConfigurationsArgsForCall) -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsCalls(stub func(*s3.ListBucketMetricsConfigurationsInput) (*s3.ListBucketMetricsConfigurationsOutput, error)) { - fake.listBucketMetricsConfigurationsMutex.Lock() - defer fake.listBucketMetricsConfigurationsMutex.Unlock() - fake.ListBucketMetricsConfigurationsStub = stub -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsArgsForCall(i int) *s3.ListBucketMetricsConfigurationsInput { - fake.listBucketMetricsConfigurationsMutex.RLock() - defer fake.listBucketMetricsConfigurationsMutex.RUnlock() - argsForCall := fake.listBucketMetricsConfigurationsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsReturns(result1 *s3.ListBucketMetricsConfigurationsOutput, result2 error) { - fake.listBucketMetricsConfigurationsMutex.Lock() - defer fake.listBucketMetricsConfigurationsMutex.Unlock() - fake.ListBucketMetricsConfigurationsStub = nil - fake.listBucketMetricsConfigurationsReturns = struct { - result1 *s3.ListBucketMetricsConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsReturnsOnCall(i int, result1 *s3.ListBucketMetricsConfigurationsOutput, result2 error) { - fake.listBucketMetricsConfigurationsMutex.Lock() - defer fake.listBucketMetricsConfigurationsMutex.Unlock() - fake.ListBucketMetricsConfigurationsStub = nil - if fake.listBucketMetricsConfigurationsReturnsOnCall == nil { - fake.listBucketMetricsConfigurationsReturnsOnCall = make(map[int]struct { - result1 *s3.ListBucketMetricsConfigurationsOutput - result2 error - }) - } - fake.listBucketMetricsConfigurationsReturnsOnCall[i] = struct { - result1 *s3.ListBucketMetricsConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsRequest(arg1 *s3.ListBucketMetricsConfigurationsInput) (*request.Request, *s3.ListBucketMetricsConfigurationsOutput) { - fake.listBucketMetricsConfigurationsRequestMutex.Lock() - ret, specificReturn := fake.listBucketMetricsConfigurationsRequestReturnsOnCall[len(fake.listBucketMetricsConfigurationsRequestArgsForCall)] - fake.listBucketMetricsConfigurationsRequestArgsForCall = append(fake.listBucketMetricsConfigurationsRequestArgsForCall, struct { - arg1 *s3.ListBucketMetricsConfigurationsInput - }{arg1}) - stub := fake.ListBucketMetricsConfigurationsRequestStub - fakeReturns := fake.listBucketMetricsConfigurationsRequestReturns - fake.recordInvocation("ListBucketMetricsConfigurationsRequest", []interface{}{arg1}) - fake.listBucketMetricsConfigurationsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsRequestCallCount() int { - fake.listBucketMetricsConfigurationsRequestMutex.RLock() - defer fake.listBucketMetricsConfigurationsRequestMutex.RUnlock() - return len(fake.listBucketMetricsConfigurationsRequestArgsForCall) -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsRequestCalls(stub func(*s3.ListBucketMetricsConfigurationsInput) (*request.Request, *s3.ListBucketMetricsConfigurationsOutput)) { - fake.listBucketMetricsConfigurationsRequestMutex.Lock() - defer fake.listBucketMetricsConfigurationsRequestMutex.Unlock() - fake.ListBucketMetricsConfigurationsRequestStub = stub -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsRequestArgsForCall(i int) *s3.ListBucketMetricsConfigurationsInput { - fake.listBucketMetricsConfigurationsRequestMutex.RLock() - defer fake.listBucketMetricsConfigurationsRequestMutex.RUnlock() - argsForCall := fake.listBucketMetricsConfigurationsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsRequestReturns(result1 *request.Request, result2 *s3.ListBucketMetricsConfigurationsOutput) { - fake.listBucketMetricsConfigurationsRequestMutex.Lock() - defer fake.listBucketMetricsConfigurationsRequestMutex.Unlock() - fake.ListBucketMetricsConfigurationsRequestStub = nil - fake.listBucketMetricsConfigurationsRequestReturns = struct { - result1 *request.Request - result2 *s3.ListBucketMetricsConfigurationsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.ListBucketMetricsConfigurationsOutput) { - fake.listBucketMetricsConfigurationsRequestMutex.Lock() - defer fake.listBucketMetricsConfigurationsRequestMutex.Unlock() - fake.ListBucketMetricsConfigurationsRequestStub = nil - if fake.listBucketMetricsConfigurationsRequestReturnsOnCall == nil { - fake.listBucketMetricsConfigurationsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.ListBucketMetricsConfigurationsOutput - }) - } - fake.listBucketMetricsConfigurationsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.ListBucketMetricsConfigurationsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsWithContext(arg1 context.Context, arg2 *s3.ListBucketMetricsConfigurationsInput, arg3 ...request.Option) (*s3.ListBucketMetricsConfigurationsOutput, error) { - fake.listBucketMetricsConfigurationsWithContextMutex.Lock() - ret, specificReturn := fake.listBucketMetricsConfigurationsWithContextReturnsOnCall[len(fake.listBucketMetricsConfigurationsWithContextArgsForCall)] - fake.listBucketMetricsConfigurationsWithContextArgsForCall = append(fake.listBucketMetricsConfigurationsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListBucketMetricsConfigurationsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.ListBucketMetricsConfigurationsWithContextStub - fakeReturns := fake.listBucketMetricsConfigurationsWithContextReturns - fake.recordInvocation("ListBucketMetricsConfigurationsWithContext", []interface{}{arg1, arg2, arg3}) - fake.listBucketMetricsConfigurationsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsWithContextCallCount() int { - fake.listBucketMetricsConfigurationsWithContextMutex.RLock() - defer fake.listBucketMetricsConfigurationsWithContextMutex.RUnlock() - return len(fake.listBucketMetricsConfigurationsWithContextArgsForCall) -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsWithContextCalls(stub func(context.Context, *s3.ListBucketMetricsConfigurationsInput, ...request.Option) (*s3.ListBucketMetricsConfigurationsOutput, error)) { - fake.listBucketMetricsConfigurationsWithContextMutex.Lock() - defer fake.listBucketMetricsConfigurationsWithContextMutex.Unlock() - fake.ListBucketMetricsConfigurationsWithContextStub = stub -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsWithContextArgsForCall(i int) (context.Context, *s3.ListBucketMetricsConfigurationsInput, []request.Option) { - fake.listBucketMetricsConfigurationsWithContextMutex.RLock() - defer fake.listBucketMetricsConfigurationsWithContextMutex.RUnlock() - argsForCall := fake.listBucketMetricsConfigurationsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsWithContextReturns(result1 *s3.ListBucketMetricsConfigurationsOutput, result2 error) { - fake.listBucketMetricsConfigurationsWithContextMutex.Lock() - defer fake.listBucketMetricsConfigurationsWithContextMutex.Unlock() - fake.ListBucketMetricsConfigurationsWithContextStub = nil - fake.listBucketMetricsConfigurationsWithContextReturns = struct { - result1 *s3.ListBucketMetricsConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketMetricsConfigurationsWithContextReturnsOnCall(i int, result1 *s3.ListBucketMetricsConfigurationsOutput, result2 error) { - fake.listBucketMetricsConfigurationsWithContextMutex.Lock() - defer fake.listBucketMetricsConfigurationsWithContextMutex.Unlock() - fake.ListBucketMetricsConfigurationsWithContextStub = nil - if fake.listBucketMetricsConfigurationsWithContextReturnsOnCall == nil { - fake.listBucketMetricsConfigurationsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.ListBucketMetricsConfigurationsOutput - result2 error - }) - } - fake.listBucketMetricsConfigurationsWithContextReturnsOnCall[i] = struct { - result1 *s3.ListBucketMetricsConfigurationsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBuckets(arg1 *s3.ListBucketsInput) (*s3.ListBucketsOutput, error) { - fake.listBucketsMutex.Lock() - ret, specificReturn := fake.listBucketsReturnsOnCall[len(fake.listBucketsArgsForCall)] - fake.listBucketsArgsForCall = append(fake.listBucketsArgsForCall, struct { - arg1 *s3.ListBucketsInput - }{arg1}) - stub := fake.ListBucketsStub - fakeReturns := fake.listBucketsReturns - fake.recordInvocation("ListBuckets", []interface{}{arg1}) - fake.listBucketsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketsCallCount() int { - fake.listBucketsMutex.RLock() - defer fake.listBucketsMutex.RUnlock() - return len(fake.listBucketsArgsForCall) -} - -func (fake *FakeS3Client) ListBucketsCalls(stub func(*s3.ListBucketsInput) (*s3.ListBucketsOutput, error)) { - fake.listBucketsMutex.Lock() - defer fake.listBucketsMutex.Unlock() - fake.ListBucketsStub = stub -} - -func (fake *FakeS3Client) ListBucketsArgsForCall(i int) *s3.ListBucketsInput { - fake.listBucketsMutex.RLock() - defer fake.listBucketsMutex.RUnlock() - argsForCall := fake.listBucketsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListBucketsReturns(result1 *s3.ListBucketsOutput, result2 error) { - fake.listBucketsMutex.Lock() - defer fake.listBucketsMutex.Unlock() - fake.ListBucketsStub = nil - fake.listBucketsReturns = struct { - result1 *s3.ListBucketsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketsReturnsOnCall(i int, result1 *s3.ListBucketsOutput, result2 error) { - fake.listBucketsMutex.Lock() - defer fake.listBucketsMutex.Unlock() - fake.ListBucketsStub = nil - if fake.listBucketsReturnsOnCall == nil { - fake.listBucketsReturnsOnCall = make(map[int]struct { - result1 *s3.ListBucketsOutput - result2 error - }) - } - fake.listBucketsReturnsOnCall[i] = struct { - result1 *s3.ListBucketsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketsRequest(arg1 *s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput) { - fake.listBucketsRequestMutex.Lock() - ret, specificReturn := fake.listBucketsRequestReturnsOnCall[len(fake.listBucketsRequestArgsForCall)] - fake.listBucketsRequestArgsForCall = append(fake.listBucketsRequestArgsForCall, struct { - arg1 *s3.ListBucketsInput - }{arg1}) - stub := fake.ListBucketsRequestStub - fakeReturns := fake.listBucketsRequestReturns - fake.recordInvocation("ListBucketsRequest", []interface{}{arg1}) - fake.listBucketsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketsRequestCallCount() int { - fake.listBucketsRequestMutex.RLock() - defer fake.listBucketsRequestMutex.RUnlock() - return len(fake.listBucketsRequestArgsForCall) -} - -func (fake *FakeS3Client) ListBucketsRequestCalls(stub func(*s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput)) { - fake.listBucketsRequestMutex.Lock() - defer fake.listBucketsRequestMutex.Unlock() - fake.ListBucketsRequestStub = stub -} - -func (fake *FakeS3Client) ListBucketsRequestArgsForCall(i int) *s3.ListBucketsInput { - fake.listBucketsRequestMutex.RLock() - defer fake.listBucketsRequestMutex.RUnlock() - argsForCall := fake.listBucketsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListBucketsRequestReturns(result1 *request.Request, result2 *s3.ListBucketsOutput) { - fake.listBucketsRequestMutex.Lock() - defer fake.listBucketsRequestMutex.Unlock() - fake.ListBucketsRequestStub = nil - fake.listBucketsRequestReturns = struct { - result1 *request.Request - result2 *s3.ListBucketsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.ListBucketsOutput) { - fake.listBucketsRequestMutex.Lock() - defer fake.listBucketsRequestMutex.Unlock() - fake.ListBucketsRequestStub = nil - if fake.listBucketsRequestReturnsOnCall == nil { - fake.listBucketsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.ListBucketsOutput - }) - } - fake.listBucketsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.ListBucketsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketsWithContext(arg1 context.Context, arg2 *s3.ListBucketsInput, arg3 ...request.Option) (*s3.ListBucketsOutput, error) { - fake.listBucketsWithContextMutex.Lock() - ret, specificReturn := fake.listBucketsWithContextReturnsOnCall[len(fake.listBucketsWithContextArgsForCall)] - fake.listBucketsWithContextArgsForCall = append(fake.listBucketsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListBucketsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.ListBucketsWithContextStub - fakeReturns := fake.listBucketsWithContextReturns - fake.recordInvocation("ListBucketsWithContext", []interface{}{arg1, arg2, arg3}) - fake.listBucketsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListBucketsWithContextCallCount() int { - fake.listBucketsWithContextMutex.RLock() - defer fake.listBucketsWithContextMutex.RUnlock() - return len(fake.listBucketsWithContextArgsForCall) -} - -func (fake *FakeS3Client) ListBucketsWithContextCalls(stub func(context.Context, *s3.ListBucketsInput, ...request.Option) (*s3.ListBucketsOutput, error)) { - fake.listBucketsWithContextMutex.Lock() - defer fake.listBucketsWithContextMutex.Unlock() - fake.ListBucketsWithContextStub = stub -} - -func (fake *FakeS3Client) ListBucketsWithContextArgsForCall(i int) (context.Context, *s3.ListBucketsInput, []request.Option) { - fake.listBucketsWithContextMutex.RLock() - defer fake.listBucketsWithContextMutex.RUnlock() - argsForCall := fake.listBucketsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) ListBucketsWithContextReturns(result1 *s3.ListBucketsOutput, result2 error) { - fake.listBucketsWithContextMutex.Lock() - defer fake.listBucketsWithContextMutex.Unlock() - fake.ListBucketsWithContextStub = nil - fake.listBucketsWithContextReturns = struct { - result1 *s3.ListBucketsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListBucketsWithContextReturnsOnCall(i int, result1 *s3.ListBucketsOutput, result2 error) { - fake.listBucketsWithContextMutex.Lock() - defer fake.listBucketsWithContextMutex.Unlock() - fake.ListBucketsWithContextStub = nil - if fake.listBucketsWithContextReturnsOnCall == nil { - fake.listBucketsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.ListBucketsOutput - result2 error - }) - } - fake.listBucketsWithContextReturnsOnCall[i] = struct { - result1 *s3.ListBucketsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListMultipartUploads(arg1 *s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error) { - fake.listMultipartUploadsMutex.Lock() - ret, specificReturn := fake.listMultipartUploadsReturnsOnCall[len(fake.listMultipartUploadsArgsForCall)] - fake.listMultipartUploadsArgsForCall = append(fake.listMultipartUploadsArgsForCall, struct { - arg1 *s3.ListMultipartUploadsInput - }{arg1}) - stub := fake.ListMultipartUploadsStub - fakeReturns := fake.listMultipartUploadsReturns - fake.recordInvocation("ListMultipartUploads", []interface{}{arg1}) - fake.listMultipartUploadsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListMultipartUploadsCallCount() int { - fake.listMultipartUploadsMutex.RLock() - defer fake.listMultipartUploadsMutex.RUnlock() - return len(fake.listMultipartUploadsArgsForCall) -} - -func (fake *FakeS3Client) ListMultipartUploadsCalls(stub func(*s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error)) { - fake.listMultipartUploadsMutex.Lock() - defer fake.listMultipartUploadsMutex.Unlock() - fake.ListMultipartUploadsStub = stub -} - -func (fake *FakeS3Client) ListMultipartUploadsArgsForCall(i int) *s3.ListMultipartUploadsInput { - fake.listMultipartUploadsMutex.RLock() - defer fake.listMultipartUploadsMutex.RUnlock() - argsForCall := fake.listMultipartUploadsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListMultipartUploadsReturns(result1 *s3.ListMultipartUploadsOutput, result2 error) { - fake.listMultipartUploadsMutex.Lock() - defer fake.listMultipartUploadsMutex.Unlock() - fake.ListMultipartUploadsStub = nil - fake.listMultipartUploadsReturns = struct { - result1 *s3.ListMultipartUploadsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListMultipartUploadsReturnsOnCall(i int, result1 *s3.ListMultipartUploadsOutput, result2 error) { - fake.listMultipartUploadsMutex.Lock() - defer fake.listMultipartUploadsMutex.Unlock() - fake.ListMultipartUploadsStub = nil - if fake.listMultipartUploadsReturnsOnCall == nil { - fake.listMultipartUploadsReturnsOnCall = make(map[int]struct { - result1 *s3.ListMultipartUploadsOutput - result2 error - }) - } - fake.listMultipartUploadsReturnsOnCall[i] = struct { - result1 *s3.ListMultipartUploadsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListMultipartUploadsPages(arg1 *s3.ListMultipartUploadsInput, arg2 func(*s3.ListMultipartUploadsOutput, bool) bool) error { - fake.listMultipartUploadsPagesMutex.Lock() - ret, specificReturn := fake.listMultipartUploadsPagesReturnsOnCall[len(fake.listMultipartUploadsPagesArgsForCall)] - fake.listMultipartUploadsPagesArgsForCall = append(fake.listMultipartUploadsPagesArgsForCall, struct { - arg1 *s3.ListMultipartUploadsInput - arg2 func(*s3.ListMultipartUploadsOutput, bool) bool - }{arg1, arg2}) - stub := fake.ListMultipartUploadsPagesStub - fakeReturns := fake.listMultipartUploadsPagesReturns - fake.recordInvocation("ListMultipartUploadsPages", []interface{}{arg1, arg2}) - fake.listMultipartUploadsPagesMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) ListMultipartUploadsPagesCallCount() int { - fake.listMultipartUploadsPagesMutex.RLock() - defer fake.listMultipartUploadsPagesMutex.RUnlock() - return len(fake.listMultipartUploadsPagesArgsForCall) -} - -func (fake *FakeS3Client) ListMultipartUploadsPagesCalls(stub func(*s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool) error) { - fake.listMultipartUploadsPagesMutex.Lock() - defer fake.listMultipartUploadsPagesMutex.Unlock() - fake.ListMultipartUploadsPagesStub = stub -} - -func (fake *FakeS3Client) ListMultipartUploadsPagesArgsForCall(i int) (*s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool) { - fake.listMultipartUploadsPagesMutex.RLock() - defer fake.listMultipartUploadsPagesMutex.RUnlock() - argsForCall := fake.listMultipartUploadsPagesArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeS3Client) ListMultipartUploadsPagesReturns(result1 error) { - fake.listMultipartUploadsPagesMutex.Lock() - defer fake.listMultipartUploadsPagesMutex.Unlock() - fake.ListMultipartUploadsPagesStub = nil - fake.listMultipartUploadsPagesReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListMultipartUploadsPagesReturnsOnCall(i int, result1 error) { - fake.listMultipartUploadsPagesMutex.Lock() - defer fake.listMultipartUploadsPagesMutex.Unlock() - fake.ListMultipartUploadsPagesStub = nil - if fake.listMultipartUploadsPagesReturnsOnCall == nil { - fake.listMultipartUploadsPagesReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.listMultipartUploadsPagesReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListMultipartUploadsPagesWithContext(arg1 context.Context, arg2 *s3.ListMultipartUploadsInput, arg3 func(*s3.ListMultipartUploadsOutput, bool) bool, arg4 ...request.Option) error { - fake.listMultipartUploadsPagesWithContextMutex.Lock() - ret, specificReturn := fake.listMultipartUploadsPagesWithContextReturnsOnCall[len(fake.listMultipartUploadsPagesWithContextArgsForCall)] - fake.listMultipartUploadsPagesWithContextArgsForCall = append(fake.listMultipartUploadsPagesWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListMultipartUploadsInput - arg3 func(*s3.ListMultipartUploadsOutput, bool) bool - arg4 []request.Option - }{arg1, arg2, arg3, arg4}) - stub := fake.ListMultipartUploadsPagesWithContextStub - fakeReturns := fake.listMultipartUploadsPagesWithContextReturns - fake.recordInvocation("ListMultipartUploadsPagesWithContext", []interface{}{arg1, arg2, arg3, arg4}) - fake.listMultipartUploadsPagesWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3, arg4...) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) ListMultipartUploadsPagesWithContextCallCount() int { - fake.listMultipartUploadsPagesWithContextMutex.RLock() - defer fake.listMultipartUploadsPagesWithContextMutex.RUnlock() - return len(fake.listMultipartUploadsPagesWithContextArgsForCall) -} - -func (fake *FakeS3Client) ListMultipartUploadsPagesWithContextCalls(stub func(context.Context, *s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool, ...request.Option) error) { - fake.listMultipartUploadsPagesWithContextMutex.Lock() - defer fake.listMultipartUploadsPagesWithContextMutex.Unlock() - fake.ListMultipartUploadsPagesWithContextStub = stub -} - -func (fake *FakeS3Client) ListMultipartUploadsPagesWithContextArgsForCall(i int) (context.Context, *s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool, []request.Option) { - fake.listMultipartUploadsPagesWithContextMutex.RLock() - defer fake.listMultipartUploadsPagesWithContextMutex.RUnlock() - argsForCall := fake.listMultipartUploadsPagesWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 -} - -func (fake *FakeS3Client) ListMultipartUploadsPagesWithContextReturns(result1 error) { - fake.listMultipartUploadsPagesWithContextMutex.Lock() - defer fake.listMultipartUploadsPagesWithContextMutex.Unlock() - fake.ListMultipartUploadsPagesWithContextStub = nil - fake.listMultipartUploadsPagesWithContextReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListMultipartUploadsPagesWithContextReturnsOnCall(i int, result1 error) { - fake.listMultipartUploadsPagesWithContextMutex.Lock() - defer fake.listMultipartUploadsPagesWithContextMutex.Unlock() - fake.ListMultipartUploadsPagesWithContextStub = nil - if fake.listMultipartUploadsPagesWithContextReturnsOnCall == nil { - fake.listMultipartUploadsPagesWithContextReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.listMultipartUploadsPagesWithContextReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListMultipartUploadsRequest(arg1 *s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput) { - fake.listMultipartUploadsRequestMutex.Lock() - ret, specificReturn := fake.listMultipartUploadsRequestReturnsOnCall[len(fake.listMultipartUploadsRequestArgsForCall)] - fake.listMultipartUploadsRequestArgsForCall = append(fake.listMultipartUploadsRequestArgsForCall, struct { - arg1 *s3.ListMultipartUploadsInput - }{arg1}) - stub := fake.ListMultipartUploadsRequestStub - fakeReturns := fake.listMultipartUploadsRequestReturns - fake.recordInvocation("ListMultipartUploadsRequest", []interface{}{arg1}) - fake.listMultipartUploadsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListMultipartUploadsRequestCallCount() int { - fake.listMultipartUploadsRequestMutex.RLock() - defer fake.listMultipartUploadsRequestMutex.RUnlock() - return len(fake.listMultipartUploadsRequestArgsForCall) -} - -func (fake *FakeS3Client) ListMultipartUploadsRequestCalls(stub func(*s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput)) { - fake.listMultipartUploadsRequestMutex.Lock() - defer fake.listMultipartUploadsRequestMutex.Unlock() - fake.ListMultipartUploadsRequestStub = stub -} - -func (fake *FakeS3Client) ListMultipartUploadsRequestArgsForCall(i int) *s3.ListMultipartUploadsInput { - fake.listMultipartUploadsRequestMutex.RLock() - defer fake.listMultipartUploadsRequestMutex.RUnlock() - argsForCall := fake.listMultipartUploadsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListMultipartUploadsRequestReturns(result1 *request.Request, result2 *s3.ListMultipartUploadsOutput) { - fake.listMultipartUploadsRequestMutex.Lock() - defer fake.listMultipartUploadsRequestMutex.Unlock() - fake.ListMultipartUploadsRequestStub = nil - fake.listMultipartUploadsRequestReturns = struct { - result1 *request.Request - result2 *s3.ListMultipartUploadsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListMultipartUploadsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.ListMultipartUploadsOutput) { - fake.listMultipartUploadsRequestMutex.Lock() - defer fake.listMultipartUploadsRequestMutex.Unlock() - fake.ListMultipartUploadsRequestStub = nil - if fake.listMultipartUploadsRequestReturnsOnCall == nil { - fake.listMultipartUploadsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.ListMultipartUploadsOutput - }) - } - fake.listMultipartUploadsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.ListMultipartUploadsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListMultipartUploadsWithContext(arg1 context.Context, arg2 *s3.ListMultipartUploadsInput, arg3 ...request.Option) (*s3.ListMultipartUploadsOutput, error) { - fake.listMultipartUploadsWithContextMutex.Lock() - ret, specificReturn := fake.listMultipartUploadsWithContextReturnsOnCall[len(fake.listMultipartUploadsWithContextArgsForCall)] - fake.listMultipartUploadsWithContextArgsForCall = append(fake.listMultipartUploadsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListMultipartUploadsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.ListMultipartUploadsWithContextStub - fakeReturns := fake.listMultipartUploadsWithContextReturns - fake.recordInvocation("ListMultipartUploadsWithContext", []interface{}{arg1, arg2, arg3}) - fake.listMultipartUploadsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListMultipartUploadsWithContextCallCount() int { - fake.listMultipartUploadsWithContextMutex.RLock() - defer fake.listMultipartUploadsWithContextMutex.RUnlock() - return len(fake.listMultipartUploadsWithContextArgsForCall) -} - -func (fake *FakeS3Client) ListMultipartUploadsWithContextCalls(stub func(context.Context, *s3.ListMultipartUploadsInput, ...request.Option) (*s3.ListMultipartUploadsOutput, error)) { - fake.listMultipartUploadsWithContextMutex.Lock() - defer fake.listMultipartUploadsWithContextMutex.Unlock() - fake.ListMultipartUploadsWithContextStub = stub -} - -func (fake *FakeS3Client) ListMultipartUploadsWithContextArgsForCall(i int) (context.Context, *s3.ListMultipartUploadsInput, []request.Option) { - fake.listMultipartUploadsWithContextMutex.RLock() - defer fake.listMultipartUploadsWithContextMutex.RUnlock() - argsForCall := fake.listMultipartUploadsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) ListMultipartUploadsWithContextReturns(result1 *s3.ListMultipartUploadsOutput, result2 error) { - fake.listMultipartUploadsWithContextMutex.Lock() - defer fake.listMultipartUploadsWithContextMutex.Unlock() - fake.ListMultipartUploadsWithContextStub = nil - fake.listMultipartUploadsWithContextReturns = struct { - result1 *s3.ListMultipartUploadsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListMultipartUploadsWithContextReturnsOnCall(i int, result1 *s3.ListMultipartUploadsOutput, result2 error) { - fake.listMultipartUploadsWithContextMutex.Lock() - defer fake.listMultipartUploadsWithContextMutex.Unlock() - fake.ListMultipartUploadsWithContextStub = nil - if fake.listMultipartUploadsWithContextReturnsOnCall == nil { - fake.listMultipartUploadsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.ListMultipartUploadsOutput - result2 error - }) - } - fake.listMultipartUploadsWithContextReturnsOnCall[i] = struct { - result1 *s3.ListMultipartUploadsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectVersions(arg1 *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error) { - fake.listObjectVersionsMutex.Lock() - ret, specificReturn := fake.listObjectVersionsReturnsOnCall[len(fake.listObjectVersionsArgsForCall)] - fake.listObjectVersionsArgsForCall = append(fake.listObjectVersionsArgsForCall, struct { - arg1 *s3.ListObjectVersionsInput - }{arg1}) - stub := fake.ListObjectVersionsStub - fakeReturns := fake.listObjectVersionsReturns - fake.recordInvocation("ListObjectVersions", []interface{}{arg1}) - fake.listObjectVersionsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListObjectVersionsCallCount() int { - fake.listObjectVersionsMutex.RLock() - defer fake.listObjectVersionsMutex.RUnlock() - return len(fake.listObjectVersionsArgsForCall) -} - -func (fake *FakeS3Client) ListObjectVersionsCalls(stub func(*s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error)) { - fake.listObjectVersionsMutex.Lock() - defer fake.listObjectVersionsMutex.Unlock() - fake.ListObjectVersionsStub = stub -} - -func (fake *FakeS3Client) ListObjectVersionsArgsForCall(i int) *s3.ListObjectVersionsInput { - fake.listObjectVersionsMutex.RLock() - defer fake.listObjectVersionsMutex.RUnlock() - argsForCall := fake.listObjectVersionsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListObjectVersionsReturns(result1 *s3.ListObjectVersionsOutput, result2 error) { - fake.listObjectVersionsMutex.Lock() - defer fake.listObjectVersionsMutex.Unlock() - fake.ListObjectVersionsStub = nil - fake.listObjectVersionsReturns = struct { - result1 *s3.ListObjectVersionsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectVersionsReturnsOnCall(i int, result1 *s3.ListObjectVersionsOutput, result2 error) { - fake.listObjectVersionsMutex.Lock() - defer fake.listObjectVersionsMutex.Unlock() - fake.ListObjectVersionsStub = nil - if fake.listObjectVersionsReturnsOnCall == nil { - fake.listObjectVersionsReturnsOnCall = make(map[int]struct { - result1 *s3.ListObjectVersionsOutput - result2 error - }) - } - fake.listObjectVersionsReturnsOnCall[i] = struct { - result1 *s3.ListObjectVersionsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectVersionsPages(arg1 *s3.ListObjectVersionsInput, arg2 func(*s3.ListObjectVersionsOutput, bool) bool) error { - fake.listObjectVersionsPagesMutex.Lock() - ret, specificReturn := fake.listObjectVersionsPagesReturnsOnCall[len(fake.listObjectVersionsPagesArgsForCall)] - fake.listObjectVersionsPagesArgsForCall = append(fake.listObjectVersionsPagesArgsForCall, struct { - arg1 *s3.ListObjectVersionsInput - arg2 func(*s3.ListObjectVersionsOutput, bool) bool - }{arg1, arg2}) - stub := fake.ListObjectVersionsPagesStub - fakeReturns := fake.listObjectVersionsPagesReturns - fake.recordInvocation("ListObjectVersionsPages", []interface{}{arg1, arg2}) - fake.listObjectVersionsPagesMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) ListObjectVersionsPagesCallCount() int { - fake.listObjectVersionsPagesMutex.RLock() - defer fake.listObjectVersionsPagesMutex.RUnlock() - return len(fake.listObjectVersionsPagesArgsForCall) -} - -func (fake *FakeS3Client) ListObjectVersionsPagesCalls(stub func(*s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool) error) { - fake.listObjectVersionsPagesMutex.Lock() - defer fake.listObjectVersionsPagesMutex.Unlock() - fake.ListObjectVersionsPagesStub = stub -} - -func (fake *FakeS3Client) ListObjectVersionsPagesArgsForCall(i int) (*s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool) { - fake.listObjectVersionsPagesMutex.RLock() - defer fake.listObjectVersionsPagesMutex.RUnlock() - argsForCall := fake.listObjectVersionsPagesArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeS3Client) ListObjectVersionsPagesReturns(result1 error) { - fake.listObjectVersionsPagesMutex.Lock() - defer fake.listObjectVersionsPagesMutex.Unlock() - fake.ListObjectVersionsPagesStub = nil - fake.listObjectVersionsPagesReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListObjectVersionsPagesReturnsOnCall(i int, result1 error) { - fake.listObjectVersionsPagesMutex.Lock() - defer fake.listObjectVersionsPagesMutex.Unlock() - fake.ListObjectVersionsPagesStub = nil - if fake.listObjectVersionsPagesReturnsOnCall == nil { - fake.listObjectVersionsPagesReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.listObjectVersionsPagesReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListObjectVersionsPagesWithContext(arg1 context.Context, arg2 *s3.ListObjectVersionsInput, arg3 func(*s3.ListObjectVersionsOutput, bool) bool, arg4 ...request.Option) error { - fake.listObjectVersionsPagesWithContextMutex.Lock() - ret, specificReturn := fake.listObjectVersionsPagesWithContextReturnsOnCall[len(fake.listObjectVersionsPagesWithContextArgsForCall)] - fake.listObjectVersionsPagesWithContextArgsForCall = append(fake.listObjectVersionsPagesWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListObjectVersionsInput - arg3 func(*s3.ListObjectVersionsOutput, bool) bool - arg4 []request.Option - }{arg1, arg2, arg3, arg4}) - stub := fake.ListObjectVersionsPagesWithContextStub - fakeReturns := fake.listObjectVersionsPagesWithContextReturns - fake.recordInvocation("ListObjectVersionsPagesWithContext", []interface{}{arg1, arg2, arg3, arg4}) - fake.listObjectVersionsPagesWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3, arg4...) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) ListObjectVersionsPagesWithContextCallCount() int { - fake.listObjectVersionsPagesWithContextMutex.RLock() - defer fake.listObjectVersionsPagesWithContextMutex.RUnlock() - return len(fake.listObjectVersionsPagesWithContextArgsForCall) -} - -func (fake *FakeS3Client) ListObjectVersionsPagesWithContextCalls(stub func(context.Context, *s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool, ...request.Option) error) { - fake.listObjectVersionsPagesWithContextMutex.Lock() - defer fake.listObjectVersionsPagesWithContextMutex.Unlock() - fake.ListObjectVersionsPagesWithContextStub = stub -} - -func (fake *FakeS3Client) ListObjectVersionsPagesWithContextArgsForCall(i int) (context.Context, *s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool, []request.Option) { - fake.listObjectVersionsPagesWithContextMutex.RLock() - defer fake.listObjectVersionsPagesWithContextMutex.RUnlock() - argsForCall := fake.listObjectVersionsPagesWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 -} - -func (fake *FakeS3Client) ListObjectVersionsPagesWithContextReturns(result1 error) { - fake.listObjectVersionsPagesWithContextMutex.Lock() - defer fake.listObjectVersionsPagesWithContextMutex.Unlock() - fake.ListObjectVersionsPagesWithContextStub = nil - fake.listObjectVersionsPagesWithContextReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListObjectVersionsPagesWithContextReturnsOnCall(i int, result1 error) { - fake.listObjectVersionsPagesWithContextMutex.Lock() - defer fake.listObjectVersionsPagesWithContextMutex.Unlock() - fake.ListObjectVersionsPagesWithContextStub = nil - if fake.listObjectVersionsPagesWithContextReturnsOnCall == nil { - fake.listObjectVersionsPagesWithContextReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.listObjectVersionsPagesWithContextReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListObjectVersionsRequest(arg1 *s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput) { - fake.listObjectVersionsRequestMutex.Lock() - ret, specificReturn := fake.listObjectVersionsRequestReturnsOnCall[len(fake.listObjectVersionsRequestArgsForCall)] - fake.listObjectVersionsRequestArgsForCall = append(fake.listObjectVersionsRequestArgsForCall, struct { - arg1 *s3.ListObjectVersionsInput - }{arg1}) - stub := fake.ListObjectVersionsRequestStub - fakeReturns := fake.listObjectVersionsRequestReturns - fake.recordInvocation("ListObjectVersionsRequest", []interface{}{arg1}) - fake.listObjectVersionsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListObjectVersionsRequestCallCount() int { - fake.listObjectVersionsRequestMutex.RLock() - defer fake.listObjectVersionsRequestMutex.RUnlock() - return len(fake.listObjectVersionsRequestArgsForCall) -} - -func (fake *FakeS3Client) ListObjectVersionsRequestCalls(stub func(*s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput)) { - fake.listObjectVersionsRequestMutex.Lock() - defer fake.listObjectVersionsRequestMutex.Unlock() - fake.ListObjectVersionsRequestStub = stub -} - -func (fake *FakeS3Client) ListObjectVersionsRequestArgsForCall(i int) *s3.ListObjectVersionsInput { - fake.listObjectVersionsRequestMutex.RLock() - defer fake.listObjectVersionsRequestMutex.RUnlock() - argsForCall := fake.listObjectVersionsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListObjectVersionsRequestReturns(result1 *request.Request, result2 *s3.ListObjectVersionsOutput) { - fake.listObjectVersionsRequestMutex.Lock() - defer fake.listObjectVersionsRequestMutex.Unlock() - fake.ListObjectVersionsRequestStub = nil - fake.listObjectVersionsRequestReturns = struct { - result1 *request.Request - result2 *s3.ListObjectVersionsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectVersionsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.ListObjectVersionsOutput) { - fake.listObjectVersionsRequestMutex.Lock() - defer fake.listObjectVersionsRequestMutex.Unlock() - fake.ListObjectVersionsRequestStub = nil - if fake.listObjectVersionsRequestReturnsOnCall == nil { - fake.listObjectVersionsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.ListObjectVersionsOutput - }) - } - fake.listObjectVersionsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.ListObjectVersionsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectVersionsWithContext(arg1 context.Context, arg2 *s3.ListObjectVersionsInput, arg3 ...request.Option) (*s3.ListObjectVersionsOutput, error) { - fake.listObjectVersionsWithContextMutex.Lock() - ret, specificReturn := fake.listObjectVersionsWithContextReturnsOnCall[len(fake.listObjectVersionsWithContextArgsForCall)] - fake.listObjectVersionsWithContextArgsForCall = append(fake.listObjectVersionsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListObjectVersionsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.ListObjectVersionsWithContextStub - fakeReturns := fake.listObjectVersionsWithContextReturns - fake.recordInvocation("ListObjectVersionsWithContext", []interface{}{arg1, arg2, arg3}) - fake.listObjectVersionsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListObjectVersionsWithContextCallCount() int { - fake.listObjectVersionsWithContextMutex.RLock() - defer fake.listObjectVersionsWithContextMutex.RUnlock() - return len(fake.listObjectVersionsWithContextArgsForCall) -} - -func (fake *FakeS3Client) ListObjectVersionsWithContextCalls(stub func(context.Context, *s3.ListObjectVersionsInput, ...request.Option) (*s3.ListObjectVersionsOutput, error)) { - fake.listObjectVersionsWithContextMutex.Lock() - defer fake.listObjectVersionsWithContextMutex.Unlock() - fake.ListObjectVersionsWithContextStub = stub -} - -func (fake *FakeS3Client) ListObjectVersionsWithContextArgsForCall(i int) (context.Context, *s3.ListObjectVersionsInput, []request.Option) { - fake.listObjectVersionsWithContextMutex.RLock() - defer fake.listObjectVersionsWithContextMutex.RUnlock() - argsForCall := fake.listObjectVersionsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) ListObjectVersionsWithContextReturns(result1 *s3.ListObjectVersionsOutput, result2 error) { - fake.listObjectVersionsWithContextMutex.Lock() - defer fake.listObjectVersionsWithContextMutex.Unlock() - fake.ListObjectVersionsWithContextStub = nil - fake.listObjectVersionsWithContextReturns = struct { - result1 *s3.ListObjectVersionsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectVersionsWithContextReturnsOnCall(i int, result1 *s3.ListObjectVersionsOutput, result2 error) { - fake.listObjectVersionsWithContextMutex.Lock() - defer fake.listObjectVersionsWithContextMutex.Unlock() - fake.ListObjectVersionsWithContextStub = nil - if fake.listObjectVersionsWithContextReturnsOnCall == nil { - fake.listObjectVersionsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.ListObjectVersionsOutput - result2 error - }) - } - fake.listObjectVersionsWithContextReturnsOnCall[i] = struct { - result1 *s3.ListObjectVersionsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjects(arg1 *s3.ListObjectsInput) (*s3.ListObjectsOutput, error) { - fake.listObjectsMutex.Lock() - ret, specificReturn := fake.listObjectsReturnsOnCall[len(fake.listObjectsArgsForCall)] - fake.listObjectsArgsForCall = append(fake.listObjectsArgsForCall, struct { - arg1 *s3.ListObjectsInput - }{arg1}) - stub := fake.ListObjectsStub - fakeReturns := fake.listObjectsReturns - fake.recordInvocation("ListObjects", []interface{}{arg1}) - fake.listObjectsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListObjectsCallCount() int { - fake.listObjectsMutex.RLock() - defer fake.listObjectsMutex.RUnlock() - return len(fake.listObjectsArgsForCall) -} - -func (fake *FakeS3Client) ListObjectsCalls(stub func(*s3.ListObjectsInput) (*s3.ListObjectsOutput, error)) { - fake.listObjectsMutex.Lock() - defer fake.listObjectsMutex.Unlock() - fake.ListObjectsStub = stub -} - -func (fake *FakeS3Client) ListObjectsArgsForCall(i int) *s3.ListObjectsInput { - fake.listObjectsMutex.RLock() - defer fake.listObjectsMutex.RUnlock() - argsForCall := fake.listObjectsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListObjectsReturns(result1 *s3.ListObjectsOutput, result2 error) { - fake.listObjectsMutex.Lock() - defer fake.listObjectsMutex.Unlock() - fake.ListObjectsStub = nil - fake.listObjectsReturns = struct { - result1 *s3.ListObjectsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectsReturnsOnCall(i int, result1 *s3.ListObjectsOutput, result2 error) { - fake.listObjectsMutex.Lock() - defer fake.listObjectsMutex.Unlock() - fake.ListObjectsStub = nil - if fake.listObjectsReturnsOnCall == nil { - fake.listObjectsReturnsOnCall = make(map[int]struct { - result1 *s3.ListObjectsOutput - result2 error - }) - } - fake.listObjectsReturnsOnCall[i] = struct { - result1 *s3.ListObjectsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectsPages(arg1 *s3.ListObjectsInput, arg2 func(*s3.ListObjectsOutput, bool) bool) error { - fake.listObjectsPagesMutex.Lock() - ret, specificReturn := fake.listObjectsPagesReturnsOnCall[len(fake.listObjectsPagesArgsForCall)] - fake.listObjectsPagesArgsForCall = append(fake.listObjectsPagesArgsForCall, struct { - arg1 *s3.ListObjectsInput - arg2 func(*s3.ListObjectsOutput, bool) bool - }{arg1, arg2}) - stub := fake.ListObjectsPagesStub - fakeReturns := fake.listObjectsPagesReturns - fake.recordInvocation("ListObjectsPages", []interface{}{arg1, arg2}) - fake.listObjectsPagesMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) ListObjectsPagesCallCount() int { - fake.listObjectsPagesMutex.RLock() - defer fake.listObjectsPagesMutex.RUnlock() - return len(fake.listObjectsPagesArgsForCall) -} - -func (fake *FakeS3Client) ListObjectsPagesCalls(stub func(*s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool) error) { - fake.listObjectsPagesMutex.Lock() - defer fake.listObjectsPagesMutex.Unlock() - fake.ListObjectsPagesStub = stub -} - -func (fake *FakeS3Client) ListObjectsPagesArgsForCall(i int) (*s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool) { - fake.listObjectsPagesMutex.RLock() - defer fake.listObjectsPagesMutex.RUnlock() - argsForCall := fake.listObjectsPagesArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeS3Client) ListObjectsPagesReturns(result1 error) { - fake.listObjectsPagesMutex.Lock() - defer fake.listObjectsPagesMutex.Unlock() - fake.ListObjectsPagesStub = nil - fake.listObjectsPagesReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListObjectsPagesReturnsOnCall(i int, result1 error) { - fake.listObjectsPagesMutex.Lock() - defer fake.listObjectsPagesMutex.Unlock() - fake.ListObjectsPagesStub = nil - if fake.listObjectsPagesReturnsOnCall == nil { - fake.listObjectsPagesReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.listObjectsPagesReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListObjectsPagesWithContext(arg1 context.Context, arg2 *s3.ListObjectsInput, arg3 func(*s3.ListObjectsOutput, bool) bool, arg4 ...request.Option) error { - fake.listObjectsPagesWithContextMutex.Lock() - ret, specificReturn := fake.listObjectsPagesWithContextReturnsOnCall[len(fake.listObjectsPagesWithContextArgsForCall)] - fake.listObjectsPagesWithContextArgsForCall = append(fake.listObjectsPagesWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListObjectsInput - arg3 func(*s3.ListObjectsOutput, bool) bool - arg4 []request.Option - }{arg1, arg2, arg3, arg4}) - stub := fake.ListObjectsPagesWithContextStub - fakeReturns := fake.listObjectsPagesWithContextReturns - fake.recordInvocation("ListObjectsPagesWithContext", []interface{}{arg1, arg2, arg3, arg4}) - fake.listObjectsPagesWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3, arg4...) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) ListObjectsPagesWithContextCallCount() int { - fake.listObjectsPagesWithContextMutex.RLock() - defer fake.listObjectsPagesWithContextMutex.RUnlock() - return len(fake.listObjectsPagesWithContextArgsForCall) -} - -func (fake *FakeS3Client) ListObjectsPagesWithContextCalls(stub func(context.Context, *s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool, ...request.Option) error) { - fake.listObjectsPagesWithContextMutex.Lock() - defer fake.listObjectsPagesWithContextMutex.Unlock() - fake.ListObjectsPagesWithContextStub = stub -} - -func (fake *FakeS3Client) ListObjectsPagesWithContextArgsForCall(i int) (context.Context, *s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool, []request.Option) { - fake.listObjectsPagesWithContextMutex.RLock() - defer fake.listObjectsPagesWithContextMutex.RUnlock() - argsForCall := fake.listObjectsPagesWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 -} - -func (fake *FakeS3Client) ListObjectsPagesWithContextReturns(result1 error) { - fake.listObjectsPagesWithContextMutex.Lock() - defer fake.listObjectsPagesWithContextMutex.Unlock() - fake.ListObjectsPagesWithContextStub = nil - fake.listObjectsPagesWithContextReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListObjectsPagesWithContextReturnsOnCall(i int, result1 error) { - fake.listObjectsPagesWithContextMutex.Lock() - defer fake.listObjectsPagesWithContextMutex.Unlock() - fake.ListObjectsPagesWithContextStub = nil - if fake.listObjectsPagesWithContextReturnsOnCall == nil { - fake.listObjectsPagesWithContextReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.listObjectsPagesWithContextReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListObjectsRequest(arg1 *s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput) { - fake.listObjectsRequestMutex.Lock() - ret, specificReturn := fake.listObjectsRequestReturnsOnCall[len(fake.listObjectsRequestArgsForCall)] - fake.listObjectsRequestArgsForCall = append(fake.listObjectsRequestArgsForCall, struct { - arg1 *s3.ListObjectsInput - }{arg1}) - stub := fake.ListObjectsRequestStub - fakeReturns := fake.listObjectsRequestReturns - fake.recordInvocation("ListObjectsRequest", []interface{}{arg1}) - fake.listObjectsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListObjectsRequestCallCount() int { - fake.listObjectsRequestMutex.RLock() - defer fake.listObjectsRequestMutex.RUnlock() - return len(fake.listObjectsRequestArgsForCall) -} - -func (fake *FakeS3Client) ListObjectsRequestCalls(stub func(*s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput)) { - fake.listObjectsRequestMutex.Lock() - defer fake.listObjectsRequestMutex.Unlock() - fake.ListObjectsRequestStub = stub -} - -func (fake *FakeS3Client) ListObjectsRequestArgsForCall(i int) *s3.ListObjectsInput { - fake.listObjectsRequestMutex.RLock() - defer fake.listObjectsRequestMutex.RUnlock() - argsForCall := fake.listObjectsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListObjectsRequestReturns(result1 *request.Request, result2 *s3.ListObjectsOutput) { - fake.listObjectsRequestMutex.Lock() - defer fake.listObjectsRequestMutex.Unlock() - fake.ListObjectsRequestStub = nil - fake.listObjectsRequestReturns = struct { - result1 *request.Request - result2 *s3.ListObjectsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.ListObjectsOutput) { - fake.listObjectsRequestMutex.Lock() - defer fake.listObjectsRequestMutex.Unlock() - fake.ListObjectsRequestStub = nil - if fake.listObjectsRequestReturnsOnCall == nil { - fake.listObjectsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.ListObjectsOutput - }) - } - fake.listObjectsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.ListObjectsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectsV2(arg1 *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error) { - fake.listObjectsV2Mutex.Lock() - ret, specificReturn := fake.listObjectsV2ReturnsOnCall[len(fake.listObjectsV2ArgsForCall)] - fake.listObjectsV2ArgsForCall = append(fake.listObjectsV2ArgsForCall, struct { - arg1 *s3.ListObjectsV2Input - }{arg1}) - stub := fake.ListObjectsV2Stub - fakeReturns := fake.listObjectsV2Returns - fake.recordInvocation("ListObjectsV2", []interface{}{arg1}) - fake.listObjectsV2Mutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListObjectsV2CallCount() int { - fake.listObjectsV2Mutex.RLock() - defer fake.listObjectsV2Mutex.RUnlock() - return len(fake.listObjectsV2ArgsForCall) -} - -func (fake *FakeS3Client) ListObjectsV2Calls(stub func(*s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error)) { - fake.listObjectsV2Mutex.Lock() - defer fake.listObjectsV2Mutex.Unlock() - fake.ListObjectsV2Stub = stub -} - -func (fake *FakeS3Client) ListObjectsV2ArgsForCall(i int) *s3.ListObjectsV2Input { - fake.listObjectsV2Mutex.RLock() - defer fake.listObjectsV2Mutex.RUnlock() - argsForCall := fake.listObjectsV2ArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListObjectsV2Returns(result1 *s3.ListObjectsV2Output, result2 error) { - fake.listObjectsV2Mutex.Lock() - defer fake.listObjectsV2Mutex.Unlock() - fake.ListObjectsV2Stub = nil - fake.listObjectsV2Returns = struct { - result1 *s3.ListObjectsV2Output - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectsV2ReturnsOnCall(i int, result1 *s3.ListObjectsV2Output, result2 error) { - fake.listObjectsV2Mutex.Lock() - defer fake.listObjectsV2Mutex.Unlock() - fake.ListObjectsV2Stub = nil - if fake.listObjectsV2ReturnsOnCall == nil { - fake.listObjectsV2ReturnsOnCall = make(map[int]struct { - result1 *s3.ListObjectsV2Output - result2 error - }) - } - fake.listObjectsV2ReturnsOnCall[i] = struct { - result1 *s3.ListObjectsV2Output - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectsV2Pages(arg1 *s3.ListObjectsV2Input, arg2 func(*s3.ListObjectsV2Output, bool) bool) error { - fake.listObjectsV2PagesMutex.Lock() - ret, specificReturn := fake.listObjectsV2PagesReturnsOnCall[len(fake.listObjectsV2PagesArgsForCall)] - fake.listObjectsV2PagesArgsForCall = append(fake.listObjectsV2PagesArgsForCall, struct { - arg1 *s3.ListObjectsV2Input - arg2 func(*s3.ListObjectsV2Output, bool) bool - }{arg1, arg2}) - stub := fake.ListObjectsV2PagesStub - fakeReturns := fake.listObjectsV2PagesReturns - fake.recordInvocation("ListObjectsV2Pages", []interface{}{arg1, arg2}) - fake.listObjectsV2PagesMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) ListObjectsV2PagesCallCount() int { - fake.listObjectsV2PagesMutex.RLock() - defer fake.listObjectsV2PagesMutex.RUnlock() - return len(fake.listObjectsV2PagesArgsForCall) -} - -func (fake *FakeS3Client) ListObjectsV2PagesCalls(stub func(*s3.ListObjectsV2Input, func(*s3.ListObjectsV2Output, bool) bool) error) { - fake.listObjectsV2PagesMutex.Lock() - defer fake.listObjectsV2PagesMutex.Unlock() - fake.ListObjectsV2PagesStub = stub -} - -func (fake *FakeS3Client) ListObjectsV2PagesArgsForCall(i int) (*s3.ListObjectsV2Input, func(*s3.ListObjectsV2Output, bool) bool) { - fake.listObjectsV2PagesMutex.RLock() - defer fake.listObjectsV2PagesMutex.RUnlock() - argsForCall := fake.listObjectsV2PagesArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeS3Client) ListObjectsV2PagesReturns(result1 error) { - fake.listObjectsV2PagesMutex.Lock() - defer fake.listObjectsV2PagesMutex.Unlock() - fake.ListObjectsV2PagesStub = nil - fake.listObjectsV2PagesReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListObjectsV2PagesReturnsOnCall(i int, result1 error) { - fake.listObjectsV2PagesMutex.Lock() - defer fake.listObjectsV2PagesMutex.Unlock() - fake.ListObjectsV2PagesStub = nil - if fake.listObjectsV2PagesReturnsOnCall == nil { - fake.listObjectsV2PagesReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.listObjectsV2PagesReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListObjectsV2PagesWithContext(arg1 context.Context, arg2 *s3.ListObjectsV2Input, arg3 func(*s3.ListObjectsV2Output, bool) bool, arg4 ...request.Option) error { - fake.listObjectsV2PagesWithContextMutex.Lock() - ret, specificReturn := fake.listObjectsV2PagesWithContextReturnsOnCall[len(fake.listObjectsV2PagesWithContextArgsForCall)] - fake.listObjectsV2PagesWithContextArgsForCall = append(fake.listObjectsV2PagesWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListObjectsV2Input - arg3 func(*s3.ListObjectsV2Output, bool) bool - arg4 []request.Option - }{arg1, arg2, arg3, arg4}) - stub := fake.ListObjectsV2PagesWithContextStub - fakeReturns := fake.listObjectsV2PagesWithContextReturns - fake.recordInvocation("ListObjectsV2PagesWithContext", []interface{}{arg1, arg2, arg3, arg4}) - fake.listObjectsV2PagesWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3, arg4...) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) ListObjectsV2PagesWithContextCallCount() int { - fake.listObjectsV2PagesWithContextMutex.RLock() - defer fake.listObjectsV2PagesWithContextMutex.RUnlock() - return len(fake.listObjectsV2PagesWithContextArgsForCall) -} - -func (fake *FakeS3Client) ListObjectsV2PagesWithContextCalls(stub func(context.Context, *s3.ListObjectsV2Input, func(*s3.ListObjectsV2Output, bool) bool, ...request.Option) error) { - fake.listObjectsV2PagesWithContextMutex.Lock() - defer fake.listObjectsV2PagesWithContextMutex.Unlock() - fake.ListObjectsV2PagesWithContextStub = stub -} - -func (fake *FakeS3Client) ListObjectsV2PagesWithContextArgsForCall(i int) (context.Context, *s3.ListObjectsV2Input, func(*s3.ListObjectsV2Output, bool) bool, []request.Option) { - fake.listObjectsV2PagesWithContextMutex.RLock() - defer fake.listObjectsV2PagesWithContextMutex.RUnlock() - argsForCall := fake.listObjectsV2PagesWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 -} - -func (fake *FakeS3Client) ListObjectsV2PagesWithContextReturns(result1 error) { - fake.listObjectsV2PagesWithContextMutex.Lock() - defer fake.listObjectsV2PagesWithContextMutex.Unlock() - fake.ListObjectsV2PagesWithContextStub = nil - fake.listObjectsV2PagesWithContextReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListObjectsV2PagesWithContextReturnsOnCall(i int, result1 error) { - fake.listObjectsV2PagesWithContextMutex.Lock() - defer fake.listObjectsV2PagesWithContextMutex.Unlock() - fake.ListObjectsV2PagesWithContextStub = nil - if fake.listObjectsV2PagesWithContextReturnsOnCall == nil { - fake.listObjectsV2PagesWithContextReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.listObjectsV2PagesWithContextReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListObjectsV2Request(arg1 *s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output) { - fake.listObjectsV2RequestMutex.Lock() - ret, specificReturn := fake.listObjectsV2RequestReturnsOnCall[len(fake.listObjectsV2RequestArgsForCall)] - fake.listObjectsV2RequestArgsForCall = append(fake.listObjectsV2RequestArgsForCall, struct { - arg1 *s3.ListObjectsV2Input - }{arg1}) - stub := fake.ListObjectsV2RequestStub - fakeReturns := fake.listObjectsV2RequestReturns - fake.recordInvocation("ListObjectsV2Request", []interface{}{arg1}) - fake.listObjectsV2RequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListObjectsV2RequestCallCount() int { - fake.listObjectsV2RequestMutex.RLock() - defer fake.listObjectsV2RequestMutex.RUnlock() - return len(fake.listObjectsV2RequestArgsForCall) -} - -func (fake *FakeS3Client) ListObjectsV2RequestCalls(stub func(*s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output)) { - fake.listObjectsV2RequestMutex.Lock() - defer fake.listObjectsV2RequestMutex.Unlock() - fake.ListObjectsV2RequestStub = stub -} - -func (fake *FakeS3Client) ListObjectsV2RequestArgsForCall(i int) *s3.ListObjectsV2Input { - fake.listObjectsV2RequestMutex.RLock() - defer fake.listObjectsV2RequestMutex.RUnlock() - argsForCall := fake.listObjectsV2RequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListObjectsV2RequestReturns(result1 *request.Request, result2 *s3.ListObjectsV2Output) { - fake.listObjectsV2RequestMutex.Lock() - defer fake.listObjectsV2RequestMutex.Unlock() - fake.ListObjectsV2RequestStub = nil - fake.listObjectsV2RequestReturns = struct { - result1 *request.Request - result2 *s3.ListObjectsV2Output - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectsV2RequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.ListObjectsV2Output) { - fake.listObjectsV2RequestMutex.Lock() - defer fake.listObjectsV2RequestMutex.Unlock() - fake.ListObjectsV2RequestStub = nil - if fake.listObjectsV2RequestReturnsOnCall == nil { - fake.listObjectsV2RequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.ListObjectsV2Output - }) - } - fake.listObjectsV2RequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.ListObjectsV2Output - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectsV2WithContext(arg1 context.Context, arg2 *s3.ListObjectsV2Input, arg3 ...request.Option) (*s3.ListObjectsV2Output, error) { - fake.listObjectsV2WithContextMutex.Lock() - ret, specificReturn := fake.listObjectsV2WithContextReturnsOnCall[len(fake.listObjectsV2WithContextArgsForCall)] - fake.listObjectsV2WithContextArgsForCall = append(fake.listObjectsV2WithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListObjectsV2Input - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.ListObjectsV2WithContextStub - fakeReturns := fake.listObjectsV2WithContextReturns - fake.recordInvocation("ListObjectsV2WithContext", []interface{}{arg1, arg2, arg3}) - fake.listObjectsV2WithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListObjectsV2WithContextCallCount() int { - fake.listObjectsV2WithContextMutex.RLock() - defer fake.listObjectsV2WithContextMutex.RUnlock() - return len(fake.listObjectsV2WithContextArgsForCall) -} - -func (fake *FakeS3Client) ListObjectsV2WithContextCalls(stub func(context.Context, *s3.ListObjectsV2Input, ...request.Option) (*s3.ListObjectsV2Output, error)) { - fake.listObjectsV2WithContextMutex.Lock() - defer fake.listObjectsV2WithContextMutex.Unlock() - fake.ListObjectsV2WithContextStub = stub -} - -func (fake *FakeS3Client) ListObjectsV2WithContextArgsForCall(i int) (context.Context, *s3.ListObjectsV2Input, []request.Option) { - fake.listObjectsV2WithContextMutex.RLock() - defer fake.listObjectsV2WithContextMutex.RUnlock() - argsForCall := fake.listObjectsV2WithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) ListObjectsV2WithContextReturns(result1 *s3.ListObjectsV2Output, result2 error) { - fake.listObjectsV2WithContextMutex.Lock() - defer fake.listObjectsV2WithContextMutex.Unlock() - fake.ListObjectsV2WithContextStub = nil - fake.listObjectsV2WithContextReturns = struct { - result1 *s3.ListObjectsV2Output - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectsV2WithContextReturnsOnCall(i int, result1 *s3.ListObjectsV2Output, result2 error) { - fake.listObjectsV2WithContextMutex.Lock() - defer fake.listObjectsV2WithContextMutex.Unlock() - fake.ListObjectsV2WithContextStub = nil - if fake.listObjectsV2WithContextReturnsOnCall == nil { - fake.listObjectsV2WithContextReturnsOnCall = make(map[int]struct { - result1 *s3.ListObjectsV2Output - result2 error - }) - } - fake.listObjectsV2WithContextReturnsOnCall[i] = struct { - result1 *s3.ListObjectsV2Output - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectsWithContext(arg1 context.Context, arg2 *s3.ListObjectsInput, arg3 ...request.Option) (*s3.ListObjectsOutput, error) { - fake.listObjectsWithContextMutex.Lock() - ret, specificReturn := fake.listObjectsWithContextReturnsOnCall[len(fake.listObjectsWithContextArgsForCall)] - fake.listObjectsWithContextArgsForCall = append(fake.listObjectsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListObjectsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.ListObjectsWithContextStub - fakeReturns := fake.listObjectsWithContextReturns - fake.recordInvocation("ListObjectsWithContext", []interface{}{arg1, arg2, arg3}) - fake.listObjectsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListObjectsWithContextCallCount() int { - fake.listObjectsWithContextMutex.RLock() - defer fake.listObjectsWithContextMutex.RUnlock() - return len(fake.listObjectsWithContextArgsForCall) -} - -func (fake *FakeS3Client) ListObjectsWithContextCalls(stub func(context.Context, *s3.ListObjectsInput, ...request.Option) (*s3.ListObjectsOutput, error)) { - fake.listObjectsWithContextMutex.Lock() - defer fake.listObjectsWithContextMutex.Unlock() - fake.ListObjectsWithContextStub = stub -} - -func (fake *FakeS3Client) ListObjectsWithContextArgsForCall(i int) (context.Context, *s3.ListObjectsInput, []request.Option) { - fake.listObjectsWithContextMutex.RLock() - defer fake.listObjectsWithContextMutex.RUnlock() - argsForCall := fake.listObjectsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) ListObjectsWithContextReturns(result1 *s3.ListObjectsOutput, result2 error) { - fake.listObjectsWithContextMutex.Lock() - defer fake.listObjectsWithContextMutex.Unlock() - fake.ListObjectsWithContextStub = nil - fake.listObjectsWithContextReturns = struct { - result1 *s3.ListObjectsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListObjectsWithContextReturnsOnCall(i int, result1 *s3.ListObjectsOutput, result2 error) { - fake.listObjectsWithContextMutex.Lock() - defer fake.listObjectsWithContextMutex.Unlock() - fake.ListObjectsWithContextStub = nil - if fake.listObjectsWithContextReturnsOnCall == nil { - fake.listObjectsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.ListObjectsOutput - result2 error - }) - } - fake.listObjectsWithContextReturnsOnCall[i] = struct { - result1 *s3.ListObjectsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListParts(arg1 *s3.ListPartsInput) (*s3.ListPartsOutput, error) { - fake.listPartsMutex.Lock() - ret, specificReturn := fake.listPartsReturnsOnCall[len(fake.listPartsArgsForCall)] - fake.listPartsArgsForCall = append(fake.listPartsArgsForCall, struct { - arg1 *s3.ListPartsInput - }{arg1}) - stub := fake.ListPartsStub - fakeReturns := fake.listPartsReturns - fake.recordInvocation("ListParts", []interface{}{arg1}) - fake.listPartsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListPartsCallCount() int { - fake.listPartsMutex.RLock() - defer fake.listPartsMutex.RUnlock() - return len(fake.listPartsArgsForCall) -} - -func (fake *FakeS3Client) ListPartsCalls(stub func(*s3.ListPartsInput) (*s3.ListPartsOutput, error)) { - fake.listPartsMutex.Lock() - defer fake.listPartsMutex.Unlock() - fake.ListPartsStub = stub -} - -func (fake *FakeS3Client) ListPartsArgsForCall(i int) *s3.ListPartsInput { - fake.listPartsMutex.RLock() - defer fake.listPartsMutex.RUnlock() - argsForCall := fake.listPartsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListPartsReturns(result1 *s3.ListPartsOutput, result2 error) { - fake.listPartsMutex.Lock() - defer fake.listPartsMutex.Unlock() - fake.ListPartsStub = nil - fake.listPartsReturns = struct { - result1 *s3.ListPartsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListPartsReturnsOnCall(i int, result1 *s3.ListPartsOutput, result2 error) { - fake.listPartsMutex.Lock() - defer fake.listPartsMutex.Unlock() - fake.ListPartsStub = nil - if fake.listPartsReturnsOnCall == nil { - fake.listPartsReturnsOnCall = make(map[int]struct { - result1 *s3.ListPartsOutput - result2 error - }) - } - fake.listPartsReturnsOnCall[i] = struct { - result1 *s3.ListPartsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListPartsPages(arg1 *s3.ListPartsInput, arg2 func(*s3.ListPartsOutput, bool) bool) error { - fake.listPartsPagesMutex.Lock() - ret, specificReturn := fake.listPartsPagesReturnsOnCall[len(fake.listPartsPagesArgsForCall)] - fake.listPartsPagesArgsForCall = append(fake.listPartsPagesArgsForCall, struct { - arg1 *s3.ListPartsInput - arg2 func(*s3.ListPartsOutput, bool) bool - }{arg1, arg2}) - stub := fake.ListPartsPagesStub - fakeReturns := fake.listPartsPagesReturns - fake.recordInvocation("ListPartsPages", []interface{}{arg1, arg2}) - fake.listPartsPagesMutex.Unlock() - if stub != nil { - return stub(arg1, arg2) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) ListPartsPagesCallCount() int { - fake.listPartsPagesMutex.RLock() - defer fake.listPartsPagesMutex.RUnlock() - return len(fake.listPartsPagesArgsForCall) -} - -func (fake *FakeS3Client) ListPartsPagesCalls(stub func(*s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool) error) { - fake.listPartsPagesMutex.Lock() - defer fake.listPartsPagesMutex.Unlock() - fake.ListPartsPagesStub = stub -} - -func (fake *FakeS3Client) ListPartsPagesArgsForCall(i int) (*s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool) { - fake.listPartsPagesMutex.RLock() - defer fake.listPartsPagesMutex.RUnlock() - argsForCall := fake.listPartsPagesArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2 -} - -func (fake *FakeS3Client) ListPartsPagesReturns(result1 error) { - fake.listPartsPagesMutex.Lock() - defer fake.listPartsPagesMutex.Unlock() - fake.ListPartsPagesStub = nil - fake.listPartsPagesReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListPartsPagesReturnsOnCall(i int, result1 error) { - fake.listPartsPagesMutex.Lock() - defer fake.listPartsPagesMutex.Unlock() - fake.ListPartsPagesStub = nil - if fake.listPartsPagesReturnsOnCall == nil { - fake.listPartsPagesReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.listPartsPagesReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListPartsPagesWithContext(arg1 context.Context, arg2 *s3.ListPartsInput, arg3 func(*s3.ListPartsOutput, bool) bool, arg4 ...request.Option) error { - fake.listPartsPagesWithContextMutex.Lock() - ret, specificReturn := fake.listPartsPagesWithContextReturnsOnCall[len(fake.listPartsPagesWithContextArgsForCall)] - fake.listPartsPagesWithContextArgsForCall = append(fake.listPartsPagesWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListPartsInput - arg3 func(*s3.ListPartsOutput, bool) bool - arg4 []request.Option - }{arg1, arg2, arg3, arg4}) - stub := fake.ListPartsPagesWithContextStub - fakeReturns := fake.listPartsPagesWithContextReturns - fake.recordInvocation("ListPartsPagesWithContext", []interface{}{arg1, arg2, arg3, arg4}) - fake.listPartsPagesWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3, arg4...) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) ListPartsPagesWithContextCallCount() int { - fake.listPartsPagesWithContextMutex.RLock() - defer fake.listPartsPagesWithContextMutex.RUnlock() - return len(fake.listPartsPagesWithContextArgsForCall) -} - -func (fake *FakeS3Client) ListPartsPagesWithContextCalls(stub func(context.Context, *s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool, ...request.Option) error) { - fake.listPartsPagesWithContextMutex.Lock() - defer fake.listPartsPagesWithContextMutex.Unlock() - fake.ListPartsPagesWithContextStub = stub -} - -func (fake *FakeS3Client) ListPartsPagesWithContextArgsForCall(i int) (context.Context, *s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool, []request.Option) { - fake.listPartsPagesWithContextMutex.RLock() - defer fake.listPartsPagesWithContextMutex.RUnlock() - argsForCall := fake.listPartsPagesWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 -} - -func (fake *FakeS3Client) ListPartsPagesWithContextReturns(result1 error) { - fake.listPartsPagesWithContextMutex.Lock() - defer fake.listPartsPagesWithContextMutex.Unlock() - fake.ListPartsPagesWithContextStub = nil - fake.listPartsPagesWithContextReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListPartsPagesWithContextReturnsOnCall(i int, result1 error) { - fake.listPartsPagesWithContextMutex.Lock() - defer fake.listPartsPagesWithContextMutex.Unlock() - fake.ListPartsPagesWithContextStub = nil - if fake.listPartsPagesWithContextReturnsOnCall == nil { - fake.listPartsPagesWithContextReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.listPartsPagesWithContextReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) ListPartsRequest(arg1 *s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput) { - fake.listPartsRequestMutex.Lock() - ret, specificReturn := fake.listPartsRequestReturnsOnCall[len(fake.listPartsRequestArgsForCall)] - fake.listPartsRequestArgsForCall = append(fake.listPartsRequestArgsForCall, struct { - arg1 *s3.ListPartsInput - }{arg1}) - stub := fake.ListPartsRequestStub - fakeReturns := fake.listPartsRequestReturns - fake.recordInvocation("ListPartsRequest", []interface{}{arg1}) - fake.listPartsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListPartsRequestCallCount() int { - fake.listPartsRequestMutex.RLock() - defer fake.listPartsRequestMutex.RUnlock() - return len(fake.listPartsRequestArgsForCall) -} - -func (fake *FakeS3Client) ListPartsRequestCalls(stub func(*s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput)) { - fake.listPartsRequestMutex.Lock() - defer fake.listPartsRequestMutex.Unlock() - fake.ListPartsRequestStub = stub -} - -func (fake *FakeS3Client) ListPartsRequestArgsForCall(i int) *s3.ListPartsInput { - fake.listPartsRequestMutex.RLock() - defer fake.listPartsRequestMutex.RUnlock() - argsForCall := fake.listPartsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) ListPartsRequestReturns(result1 *request.Request, result2 *s3.ListPartsOutput) { - fake.listPartsRequestMutex.Lock() - defer fake.listPartsRequestMutex.Unlock() - fake.ListPartsRequestStub = nil - fake.listPartsRequestReturns = struct { - result1 *request.Request - result2 *s3.ListPartsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListPartsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.ListPartsOutput) { - fake.listPartsRequestMutex.Lock() - defer fake.listPartsRequestMutex.Unlock() - fake.ListPartsRequestStub = nil - if fake.listPartsRequestReturnsOnCall == nil { - fake.listPartsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.ListPartsOutput - }) - } - fake.listPartsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.ListPartsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) ListPartsWithContext(arg1 context.Context, arg2 *s3.ListPartsInput, arg3 ...request.Option) (*s3.ListPartsOutput, error) { - fake.listPartsWithContextMutex.Lock() - ret, specificReturn := fake.listPartsWithContextReturnsOnCall[len(fake.listPartsWithContextArgsForCall)] - fake.listPartsWithContextArgsForCall = append(fake.listPartsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.ListPartsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.ListPartsWithContextStub - fakeReturns := fake.listPartsWithContextReturns - fake.recordInvocation("ListPartsWithContext", []interface{}{arg1, arg2, arg3}) - fake.listPartsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) ListPartsWithContextCallCount() int { - fake.listPartsWithContextMutex.RLock() - defer fake.listPartsWithContextMutex.RUnlock() - return len(fake.listPartsWithContextArgsForCall) -} - -func (fake *FakeS3Client) ListPartsWithContextCalls(stub func(context.Context, *s3.ListPartsInput, ...request.Option) (*s3.ListPartsOutput, error)) { - fake.listPartsWithContextMutex.Lock() - defer fake.listPartsWithContextMutex.Unlock() - fake.ListPartsWithContextStub = stub -} - -func (fake *FakeS3Client) ListPartsWithContextArgsForCall(i int) (context.Context, *s3.ListPartsInput, []request.Option) { - fake.listPartsWithContextMutex.RLock() - defer fake.listPartsWithContextMutex.RUnlock() - argsForCall := fake.listPartsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) ListPartsWithContextReturns(result1 *s3.ListPartsOutput, result2 error) { - fake.listPartsWithContextMutex.Lock() - defer fake.listPartsWithContextMutex.Unlock() - fake.ListPartsWithContextStub = nil - fake.listPartsWithContextReturns = struct { - result1 *s3.ListPartsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) ListPartsWithContextReturnsOnCall(i int, result1 *s3.ListPartsOutput, result2 error) { - fake.listPartsWithContextMutex.Lock() - defer fake.listPartsWithContextMutex.Unlock() - fake.ListPartsWithContextStub = nil - if fake.listPartsWithContextReturnsOnCall == nil { - fake.listPartsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.ListPartsOutput - result2 error - }) - } - fake.listPartsWithContextReturnsOnCall[i] = struct { - result1 *s3.ListPartsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAccelerateConfiguration(arg1 *s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error) { - fake.putBucketAccelerateConfigurationMutex.Lock() - ret, specificReturn := fake.putBucketAccelerateConfigurationReturnsOnCall[len(fake.putBucketAccelerateConfigurationArgsForCall)] - fake.putBucketAccelerateConfigurationArgsForCall = append(fake.putBucketAccelerateConfigurationArgsForCall, struct { - arg1 *s3.PutBucketAccelerateConfigurationInput - }{arg1}) - stub := fake.PutBucketAccelerateConfigurationStub - fakeReturns := fake.putBucketAccelerateConfigurationReturns - fake.recordInvocation("PutBucketAccelerateConfiguration", []interface{}{arg1}) - fake.putBucketAccelerateConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationCallCount() int { - fake.putBucketAccelerateConfigurationMutex.RLock() - defer fake.putBucketAccelerateConfigurationMutex.RUnlock() - return len(fake.putBucketAccelerateConfigurationArgsForCall) -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationCalls(stub func(*s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error)) { - fake.putBucketAccelerateConfigurationMutex.Lock() - defer fake.putBucketAccelerateConfigurationMutex.Unlock() - fake.PutBucketAccelerateConfigurationStub = stub -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationArgsForCall(i int) *s3.PutBucketAccelerateConfigurationInput { - fake.putBucketAccelerateConfigurationMutex.RLock() - defer fake.putBucketAccelerateConfigurationMutex.RUnlock() - argsForCall := fake.putBucketAccelerateConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationReturns(result1 *s3.PutBucketAccelerateConfigurationOutput, result2 error) { - fake.putBucketAccelerateConfigurationMutex.Lock() - defer fake.putBucketAccelerateConfigurationMutex.Unlock() - fake.PutBucketAccelerateConfigurationStub = nil - fake.putBucketAccelerateConfigurationReturns = struct { - result1 *s3.PutBucketAccelerateConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationReturnsOnCall(i int, result1 *s3.PutBucketAccelerateConfigurationOutput, result2 error) { - fake.putBucketAccelerateConfigurationMutex.Lock() - defer fake.putBucketAccelerateConfigurationMutex.Unlock() - fake.PutBucketAccelerateConfigurationStub = nil - if fake.putBucketAccelerateConfigurationReturnsOnCall == nil { - fake.putBucketAccelerateConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketAccelerateConfigurationOutput - result2 error - }) - } - fake.putBucketAccelerateConfigurationReturnsOnCall[i] = struct { - result1 *s3.PutBucketAccelerateConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationRequest(arg1 *s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput) { - fake.putBucketAccelerateConfigurationRequestMutex.Lock() - ret, specificReturn := fake.putBucketAccelerateConfigurationRequestReturnsOnCall[len(fake.putBucketAccelerateConfigurationRequestArgsForCall)] - fake.putBucketAccelerateConfigurationRequestArgsForCall = append(fake.putBucketAccelerateConfigurationRequestArgsForCall, struct { - arg1 *s3.PutBucketAccelerateConfigurationInput - }{arg1}) - stub := fake.PutBucketAccelerateConfigurationRequestStub - fakeReturns := fake.putBucketAccelerateConfigurationRequestReturns - fake.recordInvocation("PutBucketAccelerateConfigurationRequest", []interface{}{arg1}) - fake.putBucketAccelerateConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationRequestCallCount() int { - fake.putBucketAccelerateConfigurationRequestMutex.RLock() - defer fake.putBucketAccelerateConfigurationRequestMutex.RUnlock() - return len(fake.putBucketAccelerateConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationRequestCalls(stub func(*s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput)) { - fake.putBucketAccelerateConfigurationRequestMutex.Lock() - defer fake.putBucketAccelerateConfigurationRequestMutex.Unlock() - fake.PutBucketAccelerateConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationRequestArgsForCall(i int) *s3.PutBucketAccelerateConfigurationInput { - fake.putBucketAccelerateConfigurationRequestMutex.RLock() - defer fake.putBucketAccelerateConfigurationRequestMutex.RUnlock() - argsForCall := fake.putBucketAccelerateConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationRequestReturns(result1 *request.Request, result2 *s3.PutBucketAccelerateConfigurationOutput) { - fake.putBucketAccelerateConfigurationRequestMutex.Lock() - defer fake.putBucketAccelerateConfigurationRequestMutex.Unlock() - fake.PutBucketAccelerateConfigurationRequestStub = nil - fake.putBucketAccelerateConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketAccelerateConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketAccelerateConfigurationOutput) { - fake.putBucketAccelerateConfigurationRequestMutex.Lock() - defer fake.putBucketAccelerateConfigurationRequestMutex.Unlock() - fake.PutBucketAccelerateConfigurationRequestStub = nil - if fake.putBucketAccelerateConfigurationRequestReturnsOnCall == nil { - fake.putBucketAccelerateConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketAccelerateConfigurationOutput - }) - } - fake.putBucketAccelerateConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketAccelerateConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationWithContext(arg1 context.Context, arg2 *s3.PutBucketAccelerateConfigurationInput, arg3 ...request.Option) (*s3.PutBucketAccelerateConfigurationOutput, error) { - fake.putBucketAccelerateConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.putBucketAccelerateConfigurationWithContextReturnsOnCall[len(fake.putBucketAccelerateConfigurationWithContextArgsForCall)] - fake.putBucketAccelerateConfigurationWithContextArgsForCall = append(fake.putBucketAccelerateConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketAccelerateConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketAccelerateConfigurationWithContextStub - fakeReturns := fake.putBucketAccelerateConfigurationWithContextReturns - fake.recordInvocation("PutBucketAccelerateConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketAccelerateConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationWithContextCallCount() int { - fake.putBucketAccelerateConfigurationWithContextMutex.RLock() - defer fake.putBucketAccelerateConfigurationWithContextMutex.RUnlock() - return len(fake.putBucketAccelerateConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationWithContextCalls(stub func(context.Context, *s3.PutBucketAccelerateConfigurationInput, ...request.Option) (*s3.PutBucketAccelerateConfigurationOutput, error)) { - fake.putBucketAccelerateConfigurationWithContextMutex.Lock() - defer fake.putBucketAccelerateConfigurationWithContextMutex.Unlock() - fake.PutBucketAccelerateConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationWithContextArgsForCall(i int) (context.Context, *s3.PutBucketAccelerateConfigurationInput, []request.Option) { - fake.putBucketAccelerateConfigurationWithContextMutex.RLock() - defer fake.putBucketAccelerateConfigurationWithContextMutex.RUnlock() - argsForCall := fake.putBucketAccelerateConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationWithContextReturns(result1 *s3.PutBucketAccelerateConfigurationOutput, result2 error) { - fake.putBucketAccelerateConfigurationWithContextMutex.Lock() - defer fake.putBucketAccelerateConfigurationWithContextMutex.Unlock() - fake.PutBucketAccelerateConfigurationWithContextStub = nil - fake.putBucketAccelerateConfigurationWithContextReturns = struct { - result1 *s3.PutBucketAccelerateConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAccelerateConfigurationWithContextReturnsOnCall(i int, result1 *s3.PutBucketAccelerateConfigurationOutput, result2 error) { - fake.putBucketAccelerateConfigurationWithContextMutex.Lock() - defer fake.putBucketAccelerateConfigurationWithContextMutex.Unlock() - fake.PutBucketAccelerateConfigurationWithContextStub = nil - if fake.putBucketAccelerateConfigurationWithContextReturnsOnCall == nil { - fake.putBucketAccelerateConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketAccelerateConfigurationOutput - result2 error - }) - } - fake.putBucketAccelerateConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketAccelerateConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAcl(arg1 *s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error) { - fake.putBucketAclMutex.Lock() - ret, specificReturn := fake.putBucketAclReturnsOnCall[len(fake.putBucketAclArgsForCall)] - fake.putBucketAclArgsForCall = append(fake.putBucketAclArgsForCall, struct { - arg1 *s3.PutBucketAclInput - }{arg1}) - stub := fake.PutBucketAclStub - fakeReturns := fake.putBucketAclReturns - fake.recordInvocation("PutBucketAcl", []interface{}{arg1}) - fake.putBucketAclMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketAclCallCount() int { - fake.putBucketAclMutex.RLock() - defer fake.putBucketAclMutex.RUnlock() - return len(fake.putBucketAclArgsForCall) -} - -func (fake *FakeS3Client) PutBucketAclCalls(stub func(*s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error)) { - fake.putBucketAclMutex.Lock() - defer fake.putBucketAclMutex.Unlock() - fake.PutBucketAclStub = stub -} - -func (fake *FakeS3Client) PutBucketAclArgsForCall(i int) *s3.PutBucketAclInput { - fake.putBucketAclMutex.RLock() - defer fake.putBucketAclMutex.RUnlock() - argsForCall := fake.putBucketAclArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketAclReturns(result1 *s3.PutBucketAclOutput, result2 error) { - fake.putBucketAclMutex.Lock() - defer fake.putBucketAclMutex.Unlock() - fake.PutBucketAclStub = nil - fake.putBucketAclReturns = struct { - result1 *s3.PutBucketAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAclReturnsOnCall(i int, result1 *s3.PutBucketAclOutput, result2 error) { - fake.putBucketAclMutex.Lock() - defer fake.putBucketAclMutex.Unlock() - fake.PutBucketAclStub = nil - if fake.putBucketAclReturnsOnCall == nil { - fake.putBucketAclReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketAclOutput - result2 error - }) - } - fake.putBucketAclReturnsOnCall[i] = struct { - result1 *s3.PutBucketAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAclRequest(arg1 *s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput) { - fake.putBucketAclRequestMutex.Lock() - ret, specificReturn := fake.putBucketAclRequestReturnsOnCall[len(fake.putBucketAclRequestArgsForCall)] - fake.putBucketAclRequestArgsForCall = append(fake.putBucketAclRequestArgsForCall, struct { - arg1 *s3.PutBucketAclInput - }{arg1}) - stub := fake.PutBucketAclRequestStub - fakeReturns := fake.putBucketAclRequestReturns - fake.recordInvocation("PutBucketAclRequest", []interface{}{arg1}) - fake.putBucketAclRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketAclRequestCallCount() int { - fake.putBucketAclRequestMutex.RLock() - defer fake.putBucketAclRequestMutex.RUnlock() - return len(fake.putBucketAclRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketAclRequestCalls(stub func(*s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput)) { - fake.putBucketAclRequestMutex.Lock() - defer fake.putBucketAclRequestMutex.Unlock() - fake.PutBucketAclRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketAclRequestArgsForCall(i int) *s3.PutBucketAclInput { - fake.putBucketAclRequestMutex.RLock() - defer fake.putBucketAclRequestMutex.RUnlock() - argsForCall := fake.putBucketAclRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketAclRequestReturns(result1 *request.Request, result2 *s3.PutBucketAclOutput) { - fake.putBucketAclRequestMutex.Lock() - defer fake.putBucketAclRequestMutex.Unlock() - fake.PutBucketAclRequestStub = nil - fake.putBucketAclRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketAclOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAclRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketAclOutput) { - fake.putBucketAclRequestMutex.Lock() - defer fake.putBucketAclRequestMutex.Unlock() - fake.PutBucketAclRequestStub = nil - if fake.putBucketAclRequestReturnsOnCall == nil { - fake.putBucketAclRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketAclOutput - }) - } - fake.putBucketAclRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketAclOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAclWithContext(arg1 context.Context, arg2 *s3.PutBucketAclInput, arg3 ...request.Option) (*s3.PutBucketAclOutput, error) { - fake.putBucketAclWithContextMutex.Lock() - ret, specificReturn := fake.putBucketAclWithContextReturnsOnCall[len(fake.putBucketAclWithContextArgsForCall)] - fake.putBucketAclWithContextArgsForCall = append(fake.putBucketAclWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketAclInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketAclWithContextStub - fakeReturns := fake.putBucketAclWithContextReturns - fake.recordInvocation("PutBucketAclWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketAclWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketAclWithContextCallCount() int { - fake.putBucketAclWithContextMutex.RLock() - defer fake.putBucketAclWithContextMutex.RUnlock() - return len(fake.putBucketAclWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketAclWithContextCalls(stub func(context.Context, *s3.PutBucketAclInput, ...request.Option) (*s3.PutBucketAclOutput, error)) { - fake.putBucketAclWithContextMutex.Lock() - defer fake.putBucketAclWithContextMutex.Unlock() - fake.PutBucketAclWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketAclWithContextArgsForCall(i int) (context.Context, *s3.PutBucketAclInput, []request.Option) { - fake.putBucketAclWithContextMutex.RLock() - defer fake.putBucketAclWithContextMutex.RUnlock() - argsForCall := fake.putBucketAclWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketAclWithContextReturns(result1 *s3.PutBucketAclOutput, result2 error) { - fake.putBucketAclWithContextMutex.Lock() - defer fake.putBucketAclWithContextMutex.Unlock() - fake.PutBucketAclWithContextStub = nil - fake.putBucketAclWithContextReturns = struct { - result1 *s3.PutBucketAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAclWithContextReturnsOnCall(i int, result1 *s3.PutBucketAclOutput, result2 error) { - fake.putBucketAclWithContextMutex.Lock() - defer fake.putBucketAclWithContextMutex.Unlock() - fake.PutBucketAclWithContextStub = nil - if fake.putBucketAclWithContextReturnsOnCall == nil { - fake.putBucketAclWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketAclOutput - result2 error - }) - } - fake.putBucketAclWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfiguration(arg1 *s3.PutBucketAnalyticsConfigurationInput) (*s3.PutBucketAnalyticsConfigurationOutput, error) { - fake.putBucketAnalyticsConfigurationMutex.Lock() - ret, specificReturn := fake.putBucketAnalyticsConfigurationReturnsOnCall[len(fake.putBucketAnalyticsConfigurationArgsForCall)] - fake.putBucketAnalyticsConfigurationArgsForCall = append(fake.putBucketAnalyticsConfigurationArgsForCall, struct { - arg1 *s3.PutBucketAnalyticsConfigurationInput - }{arg1}) - stub := fake.PutBucketAnalyticsConfigurationStub - fakeReturns := fake.putBucketAnalyticsConfigurationReturns - fake.recordInvocation("PutBucketAnalyticsConfiguration", []interface{}{arg1}) - fake.putBucketAnalyticsConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationCallCount() int { - fake.putBucketAnalyticsConfigurationMutex.RLock() - defer fake.putBucketAnalyticsConfigurationMutex.RUnlock() - return len(fake.putBucketAnalyticsConfigurationArgsForCall) -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationCalls(stub func(*s3.PutBucketAnalyticsConfigurationInput) (*s3.PutBucketAnalyticsConfigurationOutput, error)) { - fake.putBucketAnalyticsConfigurationMutex.Lock() - defer fake.putBucketAnalyticsConfigurationMutex.Unlock() - fake.PutBucketAnalyticsConfigurationStub = stub -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationArgsForCall(i int) *s3.PutBucketAnalyticsConfigurationInput { - fake.putBucketAnalyticsConfigurationMutex.RLock() - defer fake.putBucketAnalyticsConfigurationMutex.RUnlock() - argsForCall := fake.putBucketAnalyticsConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationReturns(result1 *s3.PutBucketAnalyticsConfigurationOutput, result2 error) { - fake.putBucketAnalyticsConfigurationMutex.Lock() - defer fake.putBucketAnalyticsConfigurationMutex.Unlock() - fake.PutBucketAnalyticsConfigurationStub = nil - fake.putBucketAnalyticsConfigurationReturns = struct { - result1 *s3.PutBucketAnalyticsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationReturnsOnCall(i int, result1 *s3.PutBucketAnalyticsConfigurationOutput, result2 error) { - fake.putBucketAnalyticsConfigurationMutex.Lock() - defer fake.putBucketAnalyticsConfigurationMutex.Unlock() - fake.PutBucketAnalyticsConfigurationStub = nil - if fake.putBucketAnalyticsConfigurationReturnsOnCall == nil { - fake.putBucketAnalyticsConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketAnalyticsConfigurationOutput - result2 error - }) - } - fake.putBucketAnalyticsConfigurationReturnsOnCall[i] = struct { - result1 *s3.PutBucketAnalyticsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationRequest(arg1 *s3.PutBucketAnalyticsConfigurationInput) (*request.Request, *s3.PutBucketAnalyticsConfigurationOutput) { - fake.putBucketAnalyticsConfigurationRequestMutex.Lock() - ret, specificReturn := fake.putBucketAnalyticsConfigurationRequestReturnsOnCall[len(fake.putBucketAnalyticsConfigurationRequestArgsForCall)] - fake.putBucketAnalyticsConfigurationRequestArgsForCall = append(fake.putBucketAnalyticsConfigurationRequestArgsForCall, struct { - arg1 *s3.PutBucketAnalyticsConfigurationInput - }{arg1}) - stub := fake.PutBucketAnalyticsConfigurationRequestStub - fakeReturns := fake.putBucketAnalyticsConfigurationRequestReturns - fake.recordInvocation("PutBucketAnalyticsConfigurationRequest", []interface{}{arg1}) - fake.putBucketAnalyticsConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationRequestCallCount() int { - fake.putBucketAnalyticsConfigurationRequestMutex.RLock() - defer fake.putBucketAnalyticsConfigurationRequestMutex.RUnlock() - return len(fake.putBucketAnalyticsConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationRequestCalls(stub func(*s3.PutBucketAnalyticsConfigurationInput) (*request.Request, *s3.PutBucketAnalyticsConfigurationOutput)) { - fake.putBucketAnalyticsConfigurationRequestMutex.Lock() - defer fake.putBucketAnalyticsConfigurationRequestMutex.Unlock() - fake.PutBucketAnalyticsConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationRequestArgsForCall(i int) *s3.PutBucketAnalyticsConfigurationInput { - fake.putBucketAnalyticsConfigurationRequestMutex.RLock() - defer fake.putBucketAnalyticsConfigurationRequestMutex.RUnlock() - argsForCall := fake.putBucketAnalyticsConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationRequestReturns(result1 *request.Request, result2 *s3.PutBucketAnalyticsConfigurationOutput) { - fake.putBucketAnalyticsConfigurationRequestMutex.Lock() - defer fake.putBucketAnalyticsConfigurationRequestMutex.Unlock() - fake.PutBucketAnalyticsConfigurationRequestStub = nil - fake.putBucketAnalyticsConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketAnalyticsConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketAnalyticsConfigurationOutput) { - fake.putBucketAnalyticsConfigurationRequestMutex.Lock() - defer fake.putBucketAnalyticsConfigurationRequestMutex.Unlock() - fake.PutBucketAnalyticsConfigurationRequestStub = nil - if fake.putBucketAnalyticsConfigurationRequestReturnsOnCall == nil { - fake.putBucketAnalyticsConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketAnalyticsConfigurationOutput - }) - } - fake.putBucketAnalyticsConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketAnalyticsConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationWithContext(arg1 context.Context, arg2 *s3.PutBucketAnalyticsConfigurationInput, arg3 ...request.Option) (*s3.PutBucketAnalyticsConfigurationOutput, error) { - fake.putBucketAnalyticsConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.putBucketAnalyticsConfigurationWithContextReturnsOnCall[len(fake.putBucketAnalyticsConfigurationWithContextArgsForCall)] - fake.putBucketAnalyticsConfigurationWithContextArgsForCall = append(fake.putBucketAnalyticsConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketAnalyticsConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketAnalyticsConfigurationWithContextStub - fakeReturns := fake.putBucketAnalyticsConfigurationWithContextReturns - fake.recordInvocation("PutBucketAnalyticsConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketAnalyticsConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationWithContextCallCount() int { - fake.putBucketAnalyticsConfigurationWithContextMutex.RLock() - defer fake.putBucketAnalyticsConfigurationWithContextMutex.RUnlock() - return len(fake.putBucketAnalyticsConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationWithContextCalls(stub func(context.Context, *s3.PutBucketAnalyticsConfigurationInput, ...request.Option) (*s3.PutBucketAnalyticsConfigurationOutput, error)) { - fake.putBucketAnalyticsConfigurationWithContextMutex.Lock() - defer fake.putBucketAnalyticsConfigurationWithContextMutex.Unlock() - fake.PutBucketAnalyticsConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationWithContextArgsForCall(i int) (context.Context, *s3.PutBucketAnalyticsConfigurationInput, []request.Option) { - fake.putBucketAnalyticsConfigurationWithContextMutex.RLock() - defer fake.putBucketAnalyticsConfigurationWithContextMutex.RUnlock() - argsForCall := fake.putBucketAnalyticsConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationWithContextReturns(result1 *s3.PutBucketAnalyticsConfigurationOutput, result2 error) { - fake.putBucketAnalyticsConfigurationWithContextMutex.Lock() - defer fake.putBucketAnalyticsConfigurationWithContextMutex.Unlock() - fake.PutBucketAnalyticsConfigurationWithContextStub = nil - fake.putBucketAnalyticsConfigurationWithContextReturns = struct { - result1 *s3.PutBucketAnalyticsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketAnalyticsConfigurationWithContextReturnsOnCall(i int, result1 *s3.PutBucketAnalyticsConfigurationOutput, result2 error) { - fake.putBucketAnalyticsConfigurationWithContextMutex.Lock() - defer fake.putBucketAnalyticsConfigurationWithContextMutex.Unlock() - fake.PutBucketAnalyticsConfigurationWithContextStub = nil - if fake.putBucketAnalyticsConfigurationWithContextReturnsOnCall == nil { - fake.putBucketAnalyticsConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketAnalyticsConfigurationOutput - result2 error - }) - } - fake.putBucketAnalyticsConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketAnalyticsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketCors(arg1 *s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error) { - fake.putBucketCorsMutex.Lock() - ret, specificReturn := fake.putBucketCorsReturnsOnCall[len(fake.putBucketCorsArgsForCall)] - fake.putBucketCorsArgsForCall = append(fake.putBucketCorsArgsForCall, struct { - arg1 *s3.PutBucketCorsInput - }{arg1}) - stub := fake.PutBucketCorsStub - fakeReturns := fake.putBucketCorsReturns - fake.recordInvocation("PutBucketCors", []interface{}{arg1}) - fake.putBucketCorsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketCorsCallCount() int { - fake.putBucketCorsMutex.RLock() - defer fake.putBucketCorsMutex.RUnlock() - return len(fake.putBucketCorsArgsForCall) -} - -func (fake *FakeS3Client) PutBucketCorsCalls(stub func(*s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error)) { - fake.putBucketCorsMutex.Lock() - defer fake.putBucketCorsMutex.Unlock() - fake.PutBucketCorsStub = stub -} - -func (fake *FakeS3Client) PutBucketCorsArgsForCall(i int) *s3.PutBucketCorsInput { - fake.putBucketCorsMutex.RLock() - defer fake.putBucketCorsMutex.RUnlock() - argsForCall := fake.putBucketCorsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketCorsReturns(result1 *s3.PutBucketCorsOutput, result2 error) { - fake.putBucketCorsMutex.Lock() - defer fake.putBucketCorsMutex.Unlock() - fake.PutBucketCorsStub = nil - fake.putBucketCorsReturns = struct { - result1 *s3.PutBucketCorsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketCorsReturnsOnCall(i int, result1 *s3.PutBucketCorsOutput, result2 error) { - fake.putBucketCorsMutex.Lock() - defer fake.putBucketCorsMutex.Unlock() - fake.PutBucketCorsStub = nil - if fake.putBucketCorsReturnsOnCall == nil { - fake.putBucketCorsReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketCorsOutput - result2 error - }) - } - fake.putBucketCorsReturnsOnCall[i] = struct { - result1 *s3.PutBucketCorsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketCorsRequest(arg1 *s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput) { - fake.putBucketCorsRequestMutex.Lock() - ret, specificReturn := fake.putBucketCorsRequestReturnsOnCall[len(fake.putBucketCorsRequestArgsForCall)] - fake.putBucketCorsRequestArgsForCall = append(fake.putBucketCorsRequestArgsForCall, struct { - arg1 *s3.PutBucketCorsInput - }{arg1}) - stub := fake.PutBucketCorsRequestStub - fakeReturns := fake.putBucketCorsRequestReturns - fake.recordInvocation("PutBucketCorsRequest", []interface{}{arg1}) - fake.putBucketCorsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketCorsRequestCallCount() int { - fake.putBucketCorsRequestMutex.RLock() - defer fake.putBucketCorsRequestMutex.RUnlock() - return len(fake.putBucketCorsRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketCorsRequestCalls(stub func(*s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput)) { - fake.putBucketCorsRequestMutex.Lock() - defer fake.putBucketCorsRequestMutex.Unlock() - fake.PutBucketCorsRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketCorsRequestArgsForCall(i int) *s3.PutBucketCorsInput { - fake.putBucketCorsRequestMutex.RLock() - defer fake.putBucketCorsRequestMutex.RUnlock() - argsForCall := fake.putBucketCorsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketCorsRequestReturns(result1 *request.Request, result2 *s3.PutBucketCorsOutput) { - fake.putBucketCorsRequestMutex.Lock() - defer fake.putBucketCorsRequestMutex.Unlock() - fake.PutBucketCorsRequestStub = nil - fake.putBucketCorsRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketCorsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketCorsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketCorsOutput) { - fake.putBucketCorsRequestMutex.Lock() - defer fake.putBucketCorsRequestMutex.Unlock() - fake.PutBucketCorsRequestStub = nil - if fake.putBucketCorsRequestReturnsOnCall == nil { - fake.putBucketCorsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketCorsOutput - }) - } - fake.putBucketCorsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketCorsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketCorsWithContext(arg1 context.Context, arg2 *s3.PutBucketCorsInput, arg3 ...request.Option) (*s3.PutBucketCorsOutput, error) { - fake.putBucketCorsWithContextMutex.Lock() - ret, specificReturn := fake.putBucketCorsWithContextReturnsOnCall[len(fake.putBucketCorsWithContextArgsForCall)] - fake.putBucketCorsWithContextArgsForCall = append(fake.putBucketCorsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketCorsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketCorsWithContextStub - fakeReturns := fake.putBucketCorsWithContextReturns - fake.recordInvocation("PutBucketCorsWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketCorsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketCorsWithContextCallCount() int { - fake.putBucketCorsWithContextMutex.RLock() - defer fake.putBucketCorsWithContextMutex.RUnlock() - return len(fake.putBucketCorsWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketCorsWithContextCalls(stub func(context.Context, *s3.PutBucketCorsInput, ...request.Option) (*s3.PutBucketCorsOutput, error)) { - fake.putBucketCorsWithContextMutex.Lock() - defer fake.putBucketCorsWithContextMutex.Unlock() - fake.PutBucketCorsWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketCorsWithContextArgsForCall(i int) (context.Context, *s3.PutBucketCorsInput, []request.Option) { - fake.putBucketCorsWithContextMutex.RLock() - defer fake.putBucketCorsWithContextMutex.RUnlock() - argsForCall := fake.putBucketCorsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketCorsWithContextReturns(result1 *s3.PutBucketCorsOutput, result2 error) { - fake.putBucketCorsWithContextMutex.Lock() - defer fake.putBucketCorsWithContextMutex.Unlock() - fake.PutBucketCorsWithContextStub = nil - fake.putBucketCorsWithContextReturns = struct { - result1 *s3.PutBucketCorsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketCorsWithContextReturnsOnCall(i int, result1 *s3.PutBucketCorsOutput, result2 error) { - fake.putBucketCorsWithContextMutex.Lock() - defer fake.putBucketCorsWithContextMutex.Unlock() - fake.PutBucketCorsWithContextStub = nil - if fake.putBucketCorsWithContextReturnsOnCall == nil { - fake.putBucketCorsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketCorsOutput - result2 error - }) - } - fake.putBucketCorsWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketCorsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketEncryption(arg1 *s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error) { - fake.putBucketEncryptionMutex.Lock() - ret, specificReturn := fake.putBucketEncryptionReturnsOnCall[len(fake.putBucketEncryptionArgsForCall)] - fake.putBucketEncryptionArgsForCall = append(fake.putBucketEncryptionArgsForCall, struct { - arg1 *s3.PutBucketEncryptionInput - }{arg1}) - stub := fake.PutBucketEncryptionStub - fakeReturns := fake.putBucketEncryptionReturns - fake.recordInvocation("PutBucketEncryption", []interface{}{arg1}) - fake.putBucketEncryptionMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketEncryptionCallCount() int { - fake.putBucketEncryptionMutex.RLock() - defer fake.putBucketEncryptionMutex.RUnlock() - return len(fake.putBucketEncryptionArgsForCall) -} - -func (fake *FakeS3Client) PutBucketEncryptionCalls(stub func(*s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error)) { - fake.putBucketEncryptionMutex.Lock() - defer fake.putBucketEncryptionMutex.Unlock() - fake.PutBucketEncryptionStub = stub -} - -func (fake *FakeS3Client) PutBucketEncryptionArgsForCall(i int) *s3.PutBucketEncryptionInput { - fake.putBucketEncryptionMutex.RLock() - defer fake.putBucketEncryptionMutex.RUnlock() - argsForCall := fake.putBucketEncryptionArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketEncryptionReturns(result1 *s3.PutBucketEncryptionOutput, result2 error) { - fake.putBucketEncryptionMutex.Lock() - defer fake.putBucketEncryptionMutex.Unlock() - fake.PutBucketEncryptionStub = nil - fake.putBucketEncryptionReturns = struct { - result1 *s3.PutBucketEncryptionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketEncryptionReturnsOnCall(i int, result1 *s3.PutBucketEncryptionOutput, result2 error) { - fake.putBucketEncryptionMutex.Lock() - defer fake.putBucketEncryptionMutex.Unlock() - fake.PutBucketEncryptionStub = nil - if fake.putBucketEncryptionReturnsOnCall == nil { - fake.putBucketEncryptionReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketEncryptionOutput - result2 error - }) - } - fake.putBucketEncryptionReturnsOnCall[i] = struct { - result1 *s3.PutBucketEncryptionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketEncryptionRequest(arg1 *s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput) { - fake.putBucketEncryptionRequestMutex.Lock() - ret, specificReturn := fake.putBucketEncryptionRequestReturnsOnCall[len(fake.putBucketEncryptionRequestArgsForCall)] - fake.putBucketEncryptionRequestArgsForCall = append(fake.putBucketEncryptionRequestArgsForCall, struct { - arg1 *s3.PutBucketEncryptionInput - }{arg1}) - stub := fake.PutBucketEncryptionRequestStub - fakeReturns := fake.putBucketEncryptionRequestReturns - fake.recordInvocation("PutBucketEncryptionRequest", []interface{}{arg1}) - fake.putBucketEncryptionRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketEncryptionRequestCallCount() int { - fake.putBucketEncryptionRequestMutex.RLock() - defer fake.putBucketEncryptionRequestMutex.RUnlock() - return len(fake.putBucketEncryptionRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketEncryptionRequestCalls(stub func(*s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput)) { - fake.putBucketEncryptionRequestMutex.Lock() - defer fake.putBucketEncryptionRequestMutex.Unlock() - fake.PutBucketEncryptionRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketEncryptionRequestArgsForCall(i int) *s3.PutBucketEncryptionInput { - fake.putBucketEncryptionRequestMutex.RLock() - defer fake.putBucketEncryptionRequestMutex.RUnlock() - argsForCall := fake.putBucketEncryptionRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketEncryptionRequestReturns(result1 *request.Request, result2 *s3.PutBucketEncryptionOutput) { - fake.putBucketEncryptionRequestMutex.Lock() - defer fake.putBucketEncryptionRequestMutex.Unlock() - fake.PutBucketEncryptionRequestStub = nil - fake.putBucketEncryptionRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketEncryptionOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketEncryptionRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketEncryptionOutput) { - fake.putBucketEncryptionRequestMutex.Lock() - defer fake.putBucketEncryptionRequestMutex.Unlock() - fake.PutBucketEncryptionRequestStub = nil - if fake.putBucketEncryptionRequestReturnsOnCall == nil { - fake.putBucketEncryptionRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketEncryptionOutput - }) - } - fake.putBucketEncryptionRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketEncryptionOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketEncryptionWithContext(arg1 context.Context, arg2 *s3.PutBucketEncryptionInput, arg3 ...request.Option) (*s3.PutBucketEncryptionOutput, error) { - fake.putBucketEncryptionWithContextMutex.Lock() - ret, specificReturn := fake.putBucketEncryptionWithContextReturnsOnCall[len(fake.putBucketEncryptionWithContextArgsForCall)] - fake.putBucketEncryptionWithContextArgsForCall = append(fake.putBucketEncryptionWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketEncryptionInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketEncryptionWithContextStub - fakeReturns := fake.putBucketEncryptionWithContextReturns - fake.recordInvocation("PutBucketEncryptionWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketEncryptionWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketEncryptionWithContextCallCount() int { - fake.putBucketEncryptionWithContextMutex.RLock() - defer fake.putBucketEncryptionWithContextMutex.RUnlock() - return len(fake.putBucketEncryptionWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketEncryptionWithContextCalls(stub func(context.Context, *s3.PutBucketEncryptionInput, ...request.Option) (*s3.PutBucketEncryptionOutput, error)) { - fake.putBucketEncryptionWithContextMutex.Lock() - defer fake.putBucketEncryptionWithContextMutex.Unlock() - fake.PutBucketEncryptionWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketEncryptionWithContextArgsForCall(i int) (context.Context, *s3.PutBucketEncryptionInput, []request.Option) { - fake.putBucketEncryptionWithContextMutex.RLock() - defer fake.putBucketEncryptionWithContextMutex.RUnlock() - argsForCall := fake.putBucketEncryptionWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketEncryptionWithContextReturns(result1 *s3.PutBucketEncryptionOutput, result2 error) { - fake.putBucketEncryptionWithContextMutex.Lock() - defer fake.putBucketEncryptionWithContextMutex.Unlock() - fake.PutBucketEncryptionWithContextStub = nil - fake.putBucketEncryptionWithContextReturns = struct { - result1 *s3.PutBucketEncryptionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketEncryptionWithContextReturnsOnCall(i int, result1 *s3.PutBucketEncryptionOutput, result2 error) { - fake.putBucketEncryptionWithContextMutex.Lock() - defer fake.putBucketEncryptionWithContextMutex.Unlock() - fake.PutBucketEncryptionWithContextStub = nil - if fake.putBucketEncryptionWithContextReturnsOnCall == nil { - fake.putBucketEncryptionWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketEncryptionOutput - result2 error - }) - } - fake.putBucketEncryptionWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketEncryptionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfiguration(arg1 *s3.PutBucketIntelligentTieringConfigurationInput) (*s3.PutBucketIntelligentTieringConfigurationOutput, error) { - fake.putBucketIntelligentTieringConfigurationMutex.Lock() - ret, specificReturn := fake.putBucketIntelligentTieringConfigurationReturnsOnCall[len(fake.putBucketIntelligentTieringConfigurationArgsForCall)] - fake.putBucketIntelligentTieringConfigurationArgsForCall = append(fake.putBucketIntelligentTieringConfigurationArgsForCall, struct { - arg1 *s3.PutBucketIntelligentTieringConfigurationInput - }{arg1}) - stub := fake.PutBucketIntelligentTieringConfigurationStub - fakeReturns := fake.putBucketIntelligentTieringConfigurationReturns - fake.recordInvocation("PutBucketIntelligentTieringConfiguration", []interface{}{arg1}) - fake.putBucketIntelligentTieringConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationCallCount() int { - fake.putBucketIntelligentTieringConfigurationMutex.RLock() - defer fake.putBucketIntelligentTieringConfigurationMutex.RUnlock() - return len(fake.putBucketIntelligentTieringConfigurationArgsForCall) -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationCalls(stub func(*s3.PutBucketIntelligentTieringConfigurationInput) (*s3.PutBucketIntelligentTieringConfigurationOutput, error)) { - fake.putBucketIntelligentTieringConfigurationMutex.Lock() - defer fake.putBucketIntelligentTieringConfigurationMutex.Unlock() - fake.PutBucketIntelligentTieringConfigurationStub = stub -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationArgsForCall(i int) *s3.PutBucketIntelligentTieringConfigurationInput { - fake.putBucketIntelligentTieringConfigurationMutex.RLock() - defer fake.putBucketIntelligentTieringConfigurationMutex.RUnlock() - argsForCall := fake.putBucketIntelligentTieringConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationReturns(result1 *s3.PutBucketIntelligentTieringConfigurationOutput, result2 error) { - fake.putBucketIntelligentTieringConfigurationMutex.Lock() - defer fake.putBucketIntelligentTieringConfigurationMutex.Unlock() - fake.PutBucketIntelligentTieringConfigurationStub = nil - fake.putBucketIntelligentTieringConfigurationReturns = struct { - result1 *s3.PutBucketIntelligentTieringConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationReturnsOnCall(i int, result1 *s3.PutBucketIntelligentTieringConfigurationOutput, result2 error) { - fake.putBucketIntelligentTieringConfigurationMutex.Lock() - defer fake.putBucketIntelligentTieringConfigurationMutex.Unlock() - fake.PutBucketIntelligentTieringConfigurationStub = nil - if fake.putBucketIntelligentTieringConfigurationReturnsOnCall == nil { - fake.putBucketIntelligentTieringConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketIntelligentTieringConfigurationOutput - result2 error - }) - } - fake.putBucketIntelligentTieringConfigurationReturnsOnCall[i] = struct { - result1 *s3.PutBucketIntelligentTieringConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationRequest(arg1 *s3.PutBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.PutBucketIntelligentTieringConfigurationOutput) { - fake.putBucketIntelligentTieringConfigurationRequestMutex.Lock() - ret, specificReturn := fake.putBucketIntelligentTieringConfigurationRequestReturnsOnCall[len(fake.putBucketIntelligentTieringConfigurationRequestArgsForCall)] - fake.putBucketIntelligentTieringConfigurationRequestArgsForCall = append(fake.putBucketIntelligentTieringConfigurationRequestArgsForCall, struct { - arg1 *s3.PutBucketIntelligentTieringConfigurationInput - }{arg1}) - stub := fake.PutBucketIntelligentTieringConfigurationRequestStub - fakeReturns := fake.putBucketIntelligentTieringConfigurationRequestReturns - fake.recordInvocation("PutBucketIntelligentTieringConfigurationRequest", []interface{}{arg1}) - fake.putBucketIntelligentTieringConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationRequestCallCount() int { - fake.putBucketIntelligentTieringConfigurationRequestMutex.RLock() - defer fake.putBucketIntelligentTieringConfigurationRequestMutex.RUnlock() - return len(fake.putBucketIntelligentTieringConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationRequestCalls(stub func(*s3.PutBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.PutBucketIntelligentTieringConfigurationOutput)) { - fake.putBucketIntelligentTieringConfigurationRequestMutex.Lock() - defer fake.putBucketIntelligentTieringConfigurationRequestMutex.Unlock() - fake.PutBucketIntelligentTieringConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationRequestArgsForCall(i int) *s3.PutBucketIntelligentTieringConfigurationInput { - fake.putBucketIntelligentTieringConfigurationRequestMutex.RLock() - defer fake.putBucketIntelligentTieringConfigurationRequestMutex.RUnlock() - argsForCall := fake.putBucketIntelligentTieringConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationRequestReturns(result1 *request.Request, result2 *s3.PutBucketIntelligentTieringConfigurationOutput) { - fake.putBucketIntelligentTieringConfigurationRequestMutex.Lock() - defer fake.putBucketIntelligentTieringConfigurationRequestMutex.Unlock() - fake.PutBucketIntelligentTieringConfigurationRequestStub = nil - fake.putBucketIntelligentTieringConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketIntelligentTieringConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketIntelligentTieringConfigurationOutput) { - fake.putBucketIntelligentTieringConfigurationRequestMutex.Lock() - defer fake.putBucketIntelligentTieringConfigurationRequestMutex.Unlock() - fake.PutBucketIntelligentTieringConfigurationRequestStub = nil - if fake.putBucketIntelligentTieringConfigurationRequestReturnsOnCall == nil { - fake.putBucketIntelligentTieringConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketIntelligentTieringConfigurationOutput - }) - } - fake.putBucketIntelligentTieringConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketIntelligentTieringConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationWithContext(arg1 context.Context, arg2 *s3.PutBucketIntelligentTieringConfigurationInput, arg3 ...request.Option) (*s3.PutBucketIntelligentTieringConfigurationOutput, error) { - fake.putBucketIntelligentTieringConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.putBucketIntelligentTieringConfigurationWithContextReturnsOnCall[len(fake.putBucketIntelligentTieringConfigurationWithContextArgsForCall)] - fake.putBucketIntelligentTieringConfigurationWithContextArgsForCall = append(fake.putBucketIntelligentTieringConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketIntelligentTieringConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketIntelligentTieringConfigurationWithContextStub - fakeReturns := fake.putBucketIntelligentTieringConfigurationWithContextReturns - fake.recordInvocation("PutBucketIntelligentTieringConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketIntelligentTieringConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationWithContextCallCount() int { - fake.putBucketIntelligentTieringConfigurationWithContextMutex.RLock() - defer fake.putBucketIntelligentTieringConfigurationWithContextMutex.RUnlock() - return len(fake.putBucketIntelligentTieringConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationWithContextCalls(stub func(context.Context, *s3.PutBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.PutBucketIntelligentTieringConfigurationOutput, error)) { - fake.putBucketIntelligentTieringConfigurationWithContextMutex.Lock() - defer fake.putBucketIntelligentTieringConfigurationWithContextMutex.Unlock() - fake.PutBucketIntelligentTieringConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationWithContextArgsForCall(i int) (context.Context, *s3.PutBucketIntelligentTieringConfigurationInput, []request.Option) { - fake.putBucketIntelligentTieringConfigurationWithContextMutex.RLock() - defer fake.putBucketIntelligentTieringConfigurationWithContextMutex.RUnlock() - argsForCall := fake.putBucketIntelligentTieringConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationWithContextReturns(result1 *s3.PutBucketIntelligentTieringConfigurationOutput, result2 error) { - fake.putBucketIntelligentTieringConfigurationWithContextMutex.Lock() - defer fake.putBucketIntelligentTieringConfigurationWithContextMutex.Unlock() - fake.PutBucketIntelligentTieringConfigurationWithContextStub = nil - fake.putBucketIntelligentTieringConfigurationWithContextReturns = struct { - result1 *s3.PutBucketIntelligentTieringConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketIntelligentTieringConfigurationWithContextReturnsOnCall(i int, result1 *s3.PutBucketIntelligentTieringConfigurationOutput, result2 error) { - fake.putBucketIntelligentTieringConfigurationWithContextMutex.Lock() - defer fake.putBucketIntelligentTieringConfigurationWithContextMutex.Unlock() - fake.PutBucketIntelligentTieringConfigurationWithContextStub = nil - if fake.putBucketIntelligentTieringConfigurationWithContextReturnsOnCall == nil { - fake.putBucketIntelligentTieringConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketIntelligentTieringConfigurationOutput - result2 error - }) - } - fake.putBucketIntelligentTieringConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketIntelligentTieringConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketInventoryConfiguration(arg1 *s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error) { - fake.putBucketInventoryConfigurationMutex.Lock() - ret, specificReturn := fake.putBucketInventoryConfigurationReturnsOnCall[len(fake.putBucketInventoryConfigurationArgsForCall)] - fake.putBucketInventoryConfigurationArgsForCall = append(fake.putBucketInventoryConfigurationArgsForCall, struct { - arg1 *s3.PutBucketInventoryConfigurationInput - }{arg1}) - stub := fake.PutBucketInventoryConfigurationStub - fakeReturns := fake.putBucketInventoryConfigurationReturns - fake.recordInvocation("PutBucketInventoryConfiguration", []interface{}{arg1}) - fake.putBucketInventoryConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationCallCount() int { - fake.putBucketInventoryConfigurationMutex.RLock() - defer fake.putBucketInventoryConfigurationMutex.RUnlock() - return len(fake.putBucketInventoryConfigurationArgsForCall) -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationCalls(stub func(*s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error)) { - fake.putBucketInventoryConfigurationMutex.Lock() - defer fake.putBucketInventoryConfigurationMutex.Unlock() - fake.PutBucketInventoryConfigurationStub = stub -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationArgsForCall(i int) *s3.PutBucketInventoryConfigurationInput { - fake.putBucketInventoryConfigurationMutex.RLock() - defer fake.putBucketInventoryConfigurationMutex.RUnlock() - argsForCall := fake.putBucketInventoryConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationReturns(result1 *s3.PutBucketInventoryConfigurationOutput, result2 error) { - fake.putBucketInventoryConfigurationMutex.Lock() - defer fake.putBucketInventoryConfigurationMutex.Unlock() - fake.PutBucketInventoryConfigurationStub = nil - fake.putBucketInventoryConfigurationReturns = struct { - result1 *s3.PutBucketInventoryConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationReturnsOnCall(i int, result1 *s3.PutBucketInventoryConfigurationOutput, result2 error) { - fake.putBucketInventoryConfigurationMutex.Lock() - defer fake.putBucketInventoryConfigurationMutex.Unlock() - fake.PutBucketInventoryConfigurationStub = nil - if fake.putBucketInventoryConfigurationReturnsOnCall == nil { - fake.putBucketInventoryConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketInventoryConfigurationOutput - result2 error - }) - } - fake.putBucketInventoryConfigurationReturnsOnCall[i] = struct { - result1 *s3.PutBucketInventoryConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationRequest(arg1 *s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput) { - fake.putBucketInventoryConfigurationRequestMutex.Lock() - ret, specificReturn := fake.putBucketInventoryConfigurationRequestReturnsOnCall[len(fake.putBucketInventoryConfigurationRequestArgsForCall)] - fake.putBucketInventoryConfigurationRequestArgsForCall = append(fake.putBucketInventoryConfigurationRequestArgsForCall, struct { - arg1 *s3.PutBucketInventoryConfigurationInput - }{arg1}) - stub := fake.PutBucketInventoryConfigurationRequestStub - fakeReturns := fake.putBucketInventoryConfigurationRequestReturns - fake.recordInvocation("PutBucketInventoryConfigurationRequest", []interface{}{arg1}) - fake.putBucketInventoryConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationRequestCallCount() int { - fake.putBucketInventoryConfigurationRequestMutex.RLock() - defer fake.putBucketInventoryConfigurationRequestMutex.RUnlock() - return len(fake.putBucketInventoryConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationRequestCalls(stub func(*s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput)) { - fake.putBucketInventoryConfigurationRequestMutex.Lock() - defer fake.putBucketInventoryConfigurationRequestMutex.Unlock() - fake.PutBucketInventoryConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationRequestArgsForCall(i int) *s3.PutBucketInventoryConfigurationInput { - fake.putBucketInventoryConfigurationRequestMutex.RLock() - defer fake.putBucketInventoryConfigurationRequestMutex.RUnlock() - argsForCall := fake.putBucketInventoryConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationRequestReturns(result1 *request.Request, result2 *s3.PutBucketInventoryConfigurationOutput) { - fake.putBucketInventoryConfigurationRequestMutex.Lock() - defer fake.putBucketInventoryConfigurationRequestMutex.Unlock() - fake.PutBucketInventoryConfigurationRequestStub = nil - fake.putBucketInventoryConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketInventoryConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketInventoryConfigurationOutput) { - fake.putBucketInventoryConfigurationRequestMutex.Lock() - defer fake.putBucketInventoryConfigurationRequestMutex.Unlock() - fake.PutBucketInventoryConfigurationRequestStub = nil - if fake.putBucketInventoryConfigurationRequestReturnsOnCall == nil { - fake.putBucketInventoryConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketInventoryConfigurationOutput - }) - } - fake.putBucketInventoryConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketInventoryConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationWithContext(arg1 context.Context, arg2 *s3.PutBucketInventoryConfigurationInput, arg3 ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error) { - fake.putBucketInventoryConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.putBucketInventoryConfigurationWithContextReturnsOnCall[len(fake.putBucketInventoryConfigurationWithContextArgsForCall)] - fake.putBucketInventoryConfigurationWithContextArgsForCall = append(fake.putBucketInventoryConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketInventoryConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketInventoryConfigurationWithContextStub - fakeReturns := fake.putBucketInventoryConfigurationWithContextReturns - fake.recordInvocation("PutBucketInventoryConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketInventoryConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationWithContextCallCount() int { - fake.putBucketInventoryConfigurationWithContextMutex.RLock() - defer fake.putBucketInventoryConfigurationWithContextMutex.RUnlock() - return len(fake.putBucketInventoryConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationWithContextCalls(stub func(context.Context, *s3.PutBucketInventoryConfigurationInput, ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error)) { - fake.putBucketInventoryConfigurationWithContextMutex.Lock() - defer fake.putBucketInventoryConfigurationWithContextMutex.Unlock() - fake.PutBucketInventoryConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationWithContextArgsForCall(i int) (context.Context, *s3.PutBucketInventoryConfigurationInput, []request.Option) { - fake.putBucketInventoryConfigurationWithContextMutex.RLock() - defer fake.putBucketInventoryConfigurationWithContextMutex.RUnlock() - argsForCall := fake.putBucketInventoryConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationWithContextReturns(result1 *s3.PutBucketInventoryConfigurationOutput, result2 error) { - fake.putBucketInventoryConfigurationWithContextMutex.Lock() - defer fake.putBucketInventoryConfigurationWithContextMutex.Unlock() - fake.PutBucketInventoryConfigurationWithContextStub = nil - fake.putBucketInventoryConfigurationWithContextReturns = struct { - result1 *s3.PutBucketInventoryConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketInventoryConfigurationWithContextReturnsOnCall(i int, result1 *s3.PutBucketInventoryConfigurationOutput, result2 error) { - fake.putBucketInventoryConfigurationWithContextMutex.Lock() - defer fake.putBucketInventoryConfigurationWithContextMutex.Unlock() - fake.PutBucketInventoryConfigurationWithContextStub = nil - if fake.putBucketInventoryConfigurationWithContextReturnsOnCall == nil { - fake.putBucketInventoryConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketInventoryConfigurationOutput - result2 error - }) - } - fake.putBucketInventoryConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketInventoryConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLifecycle(arg1 *s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error) { - fake.putBucketLifecycleMutex.Lock() - ret, specificReturn := fake.putBucketLifecycleReturnsOnCall[len(fake.putBucketLifecycleArgsForCall)] - fake.putBucketLifecycleArgsForCall = append(fake.putBucketLifecycleArgsForCall, struct { - arg1 *s3.PutBucketLifecycleInput - }{arg1}) - stub := fake.PutBucketLifecycleStub - fakeReturns := fake.putBucketLifecycleReturns - fake.recordInvocation("PutBucketLifecycle", []interface{}{arg1}) - fake.putBucketLifecycleMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketLifecycleCallCount() int { - fake.putBucketLifecycleMutex.RLock() - defer fake.putBucketLifecycleMutex.RUnlock() - return len(fake.putBucketLifecycleArgsForCall) -} - -func (fake *FakeS3Client) PutBucketLifecycleCalls(stub func(*s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error)) { - fake.putBucketLifecycleMutex.Lock() - defer fake.putBucketLifecycleMutex.Unlock() - fake.PutBucketLifecycleStub = stub -} - -func (fake *FakeS3Client) PutBucketLifecycleArgsForCall(i int) *s3.PutBucketLifecycleInput { - fake.putBucketLifecycleMutex.RLock() - defer fake.putBucketLifecycleMutex.RUnlock() - argsForCall := fake.putBucketLifecycleArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketLifecycleReturns(result1 *s3.PutBucketLifecycleOutput, result2 error) { - fake.putBucketLifecycleMutex.Lock() - defer fake.putBucketLifecycleMutex.Unlock() - fake.PutBucketLifecycleStub = nil - fake.putBucketLifecycleReturns = struct { - result1 *s3.PutBucketLifecycleOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLifecycleReturnsOnCall(i int, result1 *s3.PutBucketLifecycleOutput, result2 error) { - fake.putBucketLifecycleMutex.Lock() - defer fake.putBucketLifecycleMutex.Unlock() - fake.PutBucketLifecycleStub = nil - if fake.putBucketLifecycleReturnsOnCall == nil { - fake.putBucketLifecycleReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketLifecycleOutput - result2 error - }) - } - fake.putBucketLifecycleReturnsOnCall[i] = struct { - result1 *s3.PutBucketLifecycleOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLifecycleConfiguration(arg1 *s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error) { - fake.putBucketLifecycleConfigurationMutex.Lock() - ret, specificReturn := fake.putBucketLifecycleConfigurationReturnsOnCall[len(fake.putBucketLifecycleConfigurationArgsForCall)] - fake.putBucketLifecycleConfigurationArgsForCall = append(fake.putBucketLifecycleConfigurationArgsForCall, struct { - arg1 *s3.PutBucketLifecycleConfigurationInput - }{arg1}) - stub := fake.PutBucketLifecycleConfigurationStub - fakeReturns := fake.putBucketLifecycleConfigurationReturns - fake.recordInvocation("PutBucketLifecycleConfiguration", []interface{}{arg1}) - fake.putBucketLifecycleConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationCallCount() int { - fake.putBucketLifecycleConfigurationMutex.RLock() - defer fake.putBucketLifecycleConfigurationMutex.RUnlock() - return len(fake.putBucketLifecycleConfigurationArgsForCall) -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationCalls(stub func(*s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error)) { - fake.putBucketLifecycleConfigurationMutex.Lock() - defer fake.putBucketLifecycleConfigurationMutex.Unlock() - fake.PutBucketLifecycleConfigurationStub = stub -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationArgsForCall(i int) *s3.PutBucketLifecycleConfigurationInput { - fake.putBucketLifecycleConfigurationMutex.RLock() - defer fake.putBucketLifecycleConfigurationMutex.RUnlock() - argsForCall := fake.putBucketLifecycleConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationReturns(result1 *s3.PutBucketLifecycleConfigurationOutput, result2 error) { - fake.putBucketLifecycleConfigurationMutex.Lock() - defer fake.putBucketLifecycleConfigurationMutex.Unlock() - fake.PutBucketLifecycleConfigurationStub = nil - fake.putBucketLifecycleConfigurationReturns = struct { - result1 *s3.PutBucketLifecycleConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationReturnsOnCall(i int, result1 *s3.PutBucketLifecycleConfigurationOutput, result2 error) { - fake.putBucketLifecycleConfigurationMutex.Lock() - defer fake.putBucketLifecycleConfigurationMutex.Unlock() - fake.PutBucketLifecycleConfigurationStub = nil - if fake.putBucketLifecycleConfigurationReturnsOnCall == nil { - fake.putBucketLifecycleConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketLifecycleConfigurationOutput - result2 error - }) - } - fake.putBucketLifecycleConfigurationReturnsOnCall[i] = struct { - result1 *s3.PutBucketLifecycleConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationRequest(arg1 *s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput) { - fake.putBucketLifecycleConfigurationRequestMutex.Lock() - ret, specificReturn := fake.putBucketLifecycleConfigurationRequestReturnsOnCall[len(fake.putBucketLifecycleConfigurationRequestArgsForCall)] - fake.putBucketLifecycleConfigurationRequestArgsForCall = append(fake.putBucketLifecycleConfigurationRequestArgsForCall, struct { - arg1 *s3.PutBucketLifecycleConfigurationInput - }{arg1}) - stub := fake.PutBucketLifecycleConfigurationRequestStub - fakeReturns := fake.putBucketLifecycleConfigurationRequestReturns - fake.recordInvocation("PutBucketLifecycleConfigurationRequest", []interface{}{arg1}) - fake.putBucketLifecycleConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationRequestCallCount() int { - fake.putBucketLifecycleConfigurationRequestMutex.RLock() - defer fake.putBucketLifecycleConfigurationRequestMutex.RUnlock() - return len(fake.putBucketLifecycleConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationRequestCalls(stub func(*s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput)) { - fake.putBucketLifecycleConfigurationRequestMutex.Lock() - defer fake.putBucketLifecycleConfigurationRequestMutex.Unlock() - fake.PutBucketLifecycleConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationRequestArgsForCall(i int) *s3.PutBucketLifecycleConfigurationInput { - fake.putBucketLifecycleConfigurationRequestMutex.RLock() - defer fake.putBucketLifecycleConfigurationRequestMutex.RUnlock() - argsForCall := fake.putBucketLifecycleConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationRequestReturns(result1 *request.Request, result2 *s3.PutBucketLifecycleConfigurationOutput) { - fake.putBucketLifecycleConfigurationRequestMutex.Lock() - defer fake.putBucketLifecycleConfigurationRequestMutex.Unlock() - fake.PutBucketLifecycleConfigurationRequestStub = nil - fake.putBucketLifecycleConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketLifecycleConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketLifecycleConfigurationOutput) { - fake.putBucketLifecycleConfigurationRequestMutex.Lock() - defer fake.putBucketLifecycleConfigurationRequestMutex.Unlock() - fake.PutBucketLifecycleConfigurationRequestStub = nil - if fake.putBucketLifecycleConfigurationRequestReturnsOnCall == nil { - fake.putBucketLifecycleConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketLifecycleConfigurationOutput - }) - } - fake.putBucketLifecycleConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketLifecycleConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationWithContext(arg1 context.Context, arg2 *s3.PutBucketLifecycleConfigurationInput, arg3 ...request.Option) (*s3.PutBucketLifecycleConfigurationOutput, error) { - fake.putBucketLifecycleConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.putBucketLifecycleConfigurationWithContextReturnsOnCall[len(fake.putBucketLifecycleConfigurationWithContextArgsForCall)] - fake.putBucketLifecycleConfigurationWithContextArgsForCall = append(fake.putBucketLifecycleConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketLifecycleConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketLifecycleConfigurationWithContextStub - fakeReturns := fake.putBucketLifecycleConfigurationWithContextReturns - fake.recordInvocation("PutBucketLifecycleConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketLifecycleConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationWithContextCallCount() int { - fake.putBucketLifecycleConfigurationWithContextMutex.RLock() - defer fake.putBucketLifecycleConfigurationWithContextMutex.RUnlock() - return len(fake.putBucketLifecycleConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationWithContextCalls(stub func(context.Context, *s3.PutBucketLifecycleConfigurationInput, ...request.Option) (*s3.PutBucketLifecycleConfigurationOutput, error)) { - fake.putBucketLifecycleConfigurationWithContextMutex.Lock() - defer fake.putBucketLifecycleConfigurationWithContextMutex.Unlock() - fake.PutBucketLifecycleConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationWithContextArgsForCall(i int) (context.Context, *s3.PutBucketLifecycleConfigurationInput, []request.Option) { - fake.putBucketLifecycleConfigurationWithContextMutex.RLock() - defer fake.putBucketLifecycleConfigurationWithContextMutex.RUnlock() - argsForCall := fake.putBucketLifecycleConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationWithContextReturns(result1 *s3.PutBucketLifecycleConfigurationOutput, result2 error) { - fake.putBucketLifecycleConfigurationWithContextMutex.Lock() - defer fake.putBucketLifecycleConfigurationWithContextMutex.Unlock() - fake.PutBucketLifecycleConfigurationWithContextStub = nil - fake.putBucketLifecycleConfigurationWithContextReturns = struct { - result1 *s3.PutBucketLifecycleConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLifecycleConfigurationWithContextReturnsOnCall(i int, result1 *s3.PutBucketLifecycleConfigurationOutput, result2 error) { - fake.putBucketLifecycleConfigurationWithContextMutex.Lock() - defer fake.putBucketLifecycleConfigurationWithContextMutex.Unlock() - fake.PutBucketLifecycleConfigurationWithContextStub = nil - if fake.putBucketLifecycleConfigurationWithContextReturnsOnCall == nil { - fake.putBucketLifecycleConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketLifecycleConfigurationOutput - result2 error - }) - } - fake.putBucketLifecycleConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketLifecycleConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLifecycleRequest(arg1 *s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput) { - fake.putBucketLifecycleRequestMutex.Lock() - ret, specificReturn := fake.putBucketLifecycleRequestReturnsOnCall[len(fake.putBucketLifecycleRequestArgsForCall)] - fake.putBucketLifecycleRequestArgsForCall = append(fake.putBucketLifecycleRequestArgsForCall, struct { - arg1 *s3.PutBucketLifecycleInput - }{arg1}) - stub := fake.PutBucketLifecycleRequestStub - fakeReturns := fake.putBucketLifecycleRequestReturns - fake.recordInvocation("PutBucketLifecycleRequest", []interface{}{arg1}) - fake.putBucketLifecycleRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketLifecycleRequestCallCount() int { - fake.putBucketLifecycleRequestMutex.RLock() - defer fake.putBucketLifecycleRequestMutex.RUnlock() - return len(fake.putBucketLifecycleRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketLifecycleRequestCalls(stub func(*s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput)) { - fake.putBucketLifecycleRequestMutex.Lock() - defer fake.putBucketLifecycleRequestMutex.Unlock() - fake.PutBucketLifecycleRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketLifecycleRequestArgsForCall(i int) *s3.PutBucketLifecycleInput { - fake.putBucketLifecycleRequestMutex.RLock() - defer fake.putBucketLifecycleRequestMutex.RUnlock() - argsForCall := fake.putBucketLifecycleRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketLifecycleRequestReturns(result1 *request.Request, result2 *s3.PutBucketLifecycleOutput) { - fake.putBucketLifecycleRequestMutex.Lock() - defer fake.putBucketLifecycleRequestMutex.Unlock() - fake.PutBucketLifecycleRequestStub = nil - fake.putBucketLifecycleRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketLifecycleOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLifecycleRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketLifecycleOutput) { - fake.putBucketLifecycleRequestMutex.Lock() - defer fake.putBucketLifecycleRequestMutex.Unlock() - fake.PutBucketLifecycleRequestStub = nil - if fake.putBucketLifecycleRequestReturnsOnCall == nil { - fake.putBucketLifecycleRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketLifecycleOutput - }) - } - fake.putBucketLifecycleRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketLifecycleOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLifecycleWithContext(arg1 context.Context, arg2 *s3.PutBucketLifecycleInput, arg3 ...request.Option) (*s3.PutBucketLifecycleOutput, error) { - fake.putBucketLifecycleWithContextMutex.Lock() - ret, specificReturn := fake.putBucketLifecycleWithContextReturnsOnCall[len(fake.putBucketLifecycleWithContextArgsForCall)] - fake.putBucketLifecycleWithContextArgsForCall = append(fake.putBucketLifecycleWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketLifecycleInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketLifecycleWithContextStub - fakeReturns := fake.putBucketLifecycleWithContextReturns - fake.recordInvocation("PutBucketLifecycleWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketLifecycleWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketLifecycleWithContextCallCount() int { - fake.putBucketLifecycleWithContextMutex.RLock() - defer fake.putBucketLifecycleWithContextMutex.RUnlock() - return len(fake.putBucketLifecycleWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketLifecycleWithContextCalls(stub func(context.Context, *s3.PutBucketLifecycleInput, ...request.Option) (*s3.PutBucketLifecycleOutput, error)) { - fake.putBucketLifecycleWithContextMutex.Lock() - defer fake.putBucketLifecycleWithContextMutex.Unlock() - fake.PutBucketLifecycleWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketLifecycleWithContextArgsForCall(i int) (context.Context, *s3.PutBucketLifecycleInput, []request.Option) { - fake.putBucketLifecycleWithContextMutex.RLock() - defer fake.putBucketLifecycleWithContextMutex.RUnlock() - argsForCall := fake.putBucketLifecycleWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketLifecycleWithContextReturns(result1 *s3.PutBucketLifecycleOutput, result2 error) { - fake.putBucketLifecycleWithContextMutex.Lock() - defer fake.putBucketLifecycleWithContextMutex.Unlock() - fake.PutBucketLifecycleWithContextStub = nil - fake.putBucketLifecycleWithContextReturns = struct { - result1 *s3.PutBucketLifecycleOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLifecycleWithContextReturnsOnCall(i int, result1 *s3.PutBucketLifecycleOutput, result2 error) { - fake.putBucketLifecycleWithContextMutex.Lock() - defer fake.putBucketLifecycleWithContextMutex.Unlock() - fake.PutBucketLifecycleWithContextStub = nil - if fake.putBucketLifecycleWithContextReturnsOnCall == nil { - fake.putBucketLifecycleWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketLifecycleOutput - result2 error - }) - } - fake.putBucketLifecycleWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketLifecycleOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLogging(arg1 *s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error) { - fake.putBucketLoggingMutex.Lock() - ret, specificReturn := fake.putBucketLoggingReturnsOnCall[len(fake.putBucketLoggingArgsForCall)] - fake.putBucketLoggingArgsForCall = append(fake.putBucketLoggingArgsForCall, struct { - arg1 *s3.PutBucketLoggingInput - }{arg1}) - stub := fake.PutBucketLoggingStub - fakeReturns := fake.putBucketLoggingReturns - fake.recordInvocation("PutBucketLogging", []interface{}{arg1}) - fake.putBucketLoggingMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketLoggingCallCount() int { - fake.putBucketLoggingMutex.RLock() - defer fake.putBucketLoggingMutex.RUnlock() - return len(fake.putBucketLoggingArgsForCall) -} - -func (fake *FakeS3Client) PutBucketLoggingCalls(stub func(*s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error)) { - fake.putBucketLoggingMutex.Lock() - defer fake.putBucketLoggingMutex.Unlock() - fake.PutBucketLoggingStub = stub -} - -func (fake *FakeS3Client) PutBucketLoggingArgsForCall(i int) *s3.PutBucketLoggingInput { - fake.putBucketLoggingMutex.RLock() - defer fake.putBucketLoggingMutex.RUnlock() - argsForCall := fake.putBucketLoggingArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketLoggingReturns(result1 *s3.PutBucketLoggingOutput, result2 error) { - fake.putBucketLoggingMutex.Lock() - defer fake.putBucketLoggingMutex.Unlock() - fake.PutBucketLoggingStub = nil - fake.putBucketLoggingReturns = struct { - result1 *s3.PutBucketLoggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLoggingReturnsOnCall(i int, result1 *s3.PutBucketLoggingOutput, result2 error) { - fake.putBucketLoggingMutex.Lock() - defer fake.putBucketLoggingMutex.Unlock() - fake.PutBucketLoggingStub = nil - if fake.putBucketLoggingReturnsOnCall == nil { - fake.putBucketLoggingReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketLoggingOutput - result2 error - }) - } - fake.putBucketLoggingReturnsOnCall[i] = struct { - result1 *s3.PutBucketLoggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLoggingRequest(arg1 *s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput) { - fake.putBucketLoggingRequestMutex.Lock() - ret, specificReturn := fake.putBucketLoggingRequestReturnsOnCall[len(fake.putBucketLoggingRequestArgsForCall)] - fake.putBucketLoggingRequestArgsForCall = append(fake.putBucketLoggingRequestArgsForCall, struct { - arg1 *s3.PutBucketLoggingInput - }{arg1}) - stub := fake.PutBucketLoggingRequestStub - fakeReturns := fake.putBucketLoggingRequestReturns - fake.recordInvocation("PutBucketLoggingRequest", []interface{}{arg1}) - fake.putBucketLoggingRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketLoggingRequestCallCount() int { - fake.putBucketLoggingRequestMutex.RLock() - defer fake.putBucketLoggingRequestMutex.RUnlock() - return len(fake.putBucketLoggingRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketLoggingRequestCalls(stub func(*s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput)) { - fake.putBucketLoggingRequestMutex.Lock() - defer fake.putBucketLoggingRequestMutex.Unlock() - fake.PutBucketLoggingRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketLoggingRequestArgsForCall(i int) *s3.PutBucketLoggingInput { - fake.putBucketLoggingRequestMutex.RLock() - defer fake.putBucketLoggingRequestMutex.RUnlock() - argsForCall := fake.putBucketLoggingRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketLoggingRequestReturns(result1 *request.Request, result2 *s3.PutBucketLoggingOutput) { - fake.putBucketLoggingRequestMutex.Lock() - defer fake.putBucketLoggingRequestMutex.Unlock() - fake.PutBucketLoggingRequestStub = nil - fake.putBucketLoggingRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketLoggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLoggingRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketLoggingOutput) { - fake.putBucketLoggingRequestMutex.Lock() - defer fake.putBucketLoggingRequestMutex.Unlock() - fake.PutBucketLoggingRequestStub = nil - if fake.putBucketLoggingRequestReturnsOnCall == nil { - fake.putBucketLoggingRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketLoggingOutput - }) - } - fake.putBucketLoggingRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketLoggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLoggingWithContext(arg1 context.Context, arg2 *s3.PutBucketLoggingInput, arg3 ...request.Option) (*s3.PutBucketLoggingOutput, error) { - fake.putBucketLoggingWithContextMutex.Lock() - ret, specificReturn := fake.putBucketLoggingWithContextReturnsOnCall[len(fake.putBucketLoggingWithContextArgsForCall)] - fake.putBucketLoggingWithContextArgsForCall = append(fake.putBucketLoggingWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketLoggingInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketLoggingWithContextStub - fakeReturns := fake.putBucketLoggingWithContextReturns - fake.recordInvocation("PutBucketLoggingWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketLoggingWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketLoggingWithContextCallCount() int { - fake.putBucketLoggingWithContextMutex.RLock() - defer fake.putBucketLoggingWithContextMutex.RUnlock() - return len(fake.putBucketLoggingWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketLoggingWithContextCalls(stub func(context.Context, *s3.PutBucketLoggingInput, ...request.Option) (*s3.PutBucketLoggingOutput, error)) { - fake.putBucketLoggingWithContextMutex.Lock() - defer fake.putBucketLoggingWithContextMutex.Unlock() - fake.PutBucketLoggingWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketLoggingWithContextArgsForCall(i int) (context.Context, *s3.PutBucketLoggingInput, []request.Option) { - fake.putBucketLoggingWithContextMutex.RLock() - defer fake.putBucketLoggingWithContextMutex.RUnlock() - argsForCall := fake.putBucketLoggingWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketLoggingWithContextReturns(result1 *s3.PutBucketLoggingOutput, result2 error) { - fake.putBucketLoggingWithContextMutex.Lock() - defer fake.putBucketLoggingWithContextMutex.Unlock() - fake.PutBucketLoggingWithContextStub = nil - fake.putBucketLoggingWithContextReturns = struct { - result1 *s3.PutBucketLoggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketLoggingWithContextReturnsOnCall(i int, result1 *s3.PutBucketLoggingOutput, result2 error) { - fake.putBucketLoggingWithContextMutex.Lock() - defer fake.putBucketLoggingWithContextMutex.Unlock() - fake.PutBucketLoggingWithContextStub = nil - if fake.putBucketLoggingWithContextReturnsOnCall == nil { - fake.putBucketLoggingWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketLoggingOutput - result2 error - }) - } - fake.putBucketLoggingWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketLoggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketMetricsConfiguration(arg1 *s3.PutBucketMetricsConfigurationInput) (*s3.PutBucketMetricsConfigurationOutput, error) { - fake.putBucketMetricsConfigurationMutex.Lock() - ret, specificReturn := fake.putBucketMetricsConfigurationReturnsOnCall[len(fake.putBucketMetricsConfigurationArgsForCall)] - fake.putBucketMetricsConfigurationArgsForCall = append(fake.putBucketMetricsConfigurationArgsForCall, struct { - arg1 *s3.PutBucketMetricsConfigurationInput - }{arg1}) - stub := fake.PutBucketMetricsConfigurationStub - fakeReturns := fake.putBucketMetricsConfigurationReturns - fake.recordInvocation("PutBucketMetricsConfiguration", []interface{}{arg1}) - fake.putBucketMetricsConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationCallCount() int { - fake.putBucketMetricsConfigurationMutex.RLock() - defer fake.putBucketMetricsConfigurationMutex.RUnlock() - return len(fake.putBucketMetricsConfigurationArgsForCall) -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationCalls(stub func(*s3.PutBucketMetricsConfigurationInput) (*s3.PutBucketMetricsConfigurationOutput, error)) { - fake.putBucketMetricsConfigurationMutex.Lock() - defer fake.putBucketMetricsConfigurationMutex.Unlock() - fake.PutBucketMetricsConfigurationStub = stub -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationArgsForCall(i int) *s3.PutBucketMetricsConfigurationInput { - fake.putBucketMetricsConfigurationMutex.RLock() - defer fake.putBucketMetricsConfigurationMutex.RUnlock() - argsForCall := fake.putBucketMetricsConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationReturns(result1 *s3.PutBucketMetricsConfigurationOutput, result2 error) { - fake.putBucketMetricsConfigurationMutex.Lock() - defer fake.putBucketMetricsConfigurationMutex.Unlock() - fake.PutBucketMetricsConfigurationStub = nil - fake.putBucketMetricsConfigurationReturns = struct { - result1 *s3.PutBucketMetricsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationReturnsOnCall(i int, result1 *s3.PutBucketMetricsConfigurationOutput, result2 error) { - fake.putBucketMetricsConfigurationMutex.Lock() - defer fake.putBucketMetricsConfigurationMutex.Unlock() - fake.PutBucketMetricsConfigurationStub = nil - if fake.putBucketMetricsConfigurationReturnsOnCall == nil { - fake.putBucketMetricsConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketMetricsConfigurationOutput - result2 error - }) - } - fake.putBucketMetricsConfigurationReturnsOnCall[i] = struct { - result1 *s3.PutBucketMetricsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationRequest(arg1 *s3.PutBucketMetricsConfigurationInput) (*request.Request, *s3.PutBucketMetricsConfigurationOutput) { - fake.putBucketMetricsConfigurationRequestMutex.Lock() - ret, specificReturn := fake.putBucketMetricsConfigurationRequestReturnsOnCall[len(fake.putBucketMetricsConfigurationRequestArgsForCall)] - fake.putBucketMetricsConfigurationRequestArgsForCall = append(fake.putBucketMetricsConfigurationRequestArgsForCall, struct { - arg1 *s3.PutBucketMetricsConfigurationInput - }{arg1}) - stub := fake.PutBucketMetricsConfigurationRequestStub - fakeReturns := fake.putBucketMetricsConfigurationRequestReturns - fake.recordInvocation("PutBucketMetricsConfigurationRequest", []interface{}{arg1}) - fake.putBucketMetricsConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationRequestCallCount() int { - fake.putBucketMetricsConfigurationRequestMutex.RLock() - defer fake.putBucketMetricsConfigurationRequestMutex.RUnlock() - return len(fake.putBucketMetricsConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationRequestCalls(stub func(*s3.PutBucketMetricsConfigurationInput) (*request.Request, *s3.PutBucketMetricsConfigurationOutput)) { - fake.putBucketMetricsConfigurationRequestMutex.Lock() - defer fake.putBucketMetricsConfigurationRequestMutex.Unlock() - fake.PutBucketMetricsConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationRequestArgsForCall(i int) *s3.PutBucketMetricsConfigurationInput { - fake.putBucketMetricsConfigurationRequestMutex.RLock() - defer fake.putBucketMetricsConfigurationRequestMutex.RUnlock() - argsForCall := fake.putBucketMetricsConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationRequestReturns(result1 *request.Request, result2 *s3.PutBucketMetricsConfigurationOutput) { - fake.putBucketMetricsConfigurationRequestMutex.Lock() - defer fake.putBucketMetricsConfigurationRequestMutex.Unlock() - fake.PutBucketMetricsConfigurationRequestStub = nil - fake.putBucketMetricsConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketMetricsConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketMetricsConfigurationOutput) { - fake.putBucketMetricsConfigurationRequestMutex.Lock() - defer fake.putBucketMetricsConfigurationRequestMutex.Unlock() - fake.PutBucketMetricsConfigurationRequestStub = nil - if fake.putBucketMetricsConfigurationRequestReturnsOnCall == nil { - fake.putBucketMetricsConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketMetricsConfigurationOutput - }) - } - fake.putBucketMetricsConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketMetricsConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationWithContext(arg1 context.Context, arg2 *s3.PutBucketMetricsConfigurationInput, arg3 ...request.Option) (*s3.PutBucketMetricsConfigurationOutput, error) { - fake.putBucketMetricsConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.putBucketMetricsConfigurationWithContextReturnsOnCall[len(fake.putBucketMetricsConfigurationWithContextArgsForCall)] - fake.putBucketMetricsConfigurationWithContextArgsForCall = append(fake.putBucketMetricsConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketMetricsConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketMetricsConfigurationWithContextStub - fakeReturns := fake.putBucketMetricsConfigurationWithContextReturns - fake.recordInvocation("PutBucketMetricsConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketMetricsConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationWithContextCallCount() int { - fake.putBucketMetricsConfigurationWithContextMutex.RLock() - defer fake.putBucketMetricsConfigurationWithContextMutex.RUnlock() - return len(fake.putBucketMetricsConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationWithContextCalls(stub func(context.Context, *s3.PutBucketMetricsConfigurationInput, ...request.Option) (*s3.PutBucketMetricsConfigurationOutput, error)) { - fake.putBucketMetricsConfigurationWithContextMutex.Lock() - defer fake.putBucketMetricsConfigurationWithContextMutex.Unlock() - fake.PutBucketMetricsConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationWithContextArgsForCall(i int) (context.Context, *s3.PutBucketMetricsConfigurationInput, []request.Option) { - fake.putBucketMetricsConfigurationWithContextMutex.RLock() - defer fake.putBucketMetricsConfigurationWithContextMutex.RUnlock() - argsForCall := fake.putBucketMetricsConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationWithContextReturns(result1 *s3.PutBucketMetricsConfigurationOutput, result2 error) { - fake.putBucketMetricsConfigurationWithContextMutex.Lock() - defer fake.putBucketMetricsConfigurationWithContextMutex.Unlock() - fake.PutBucketMetricsConfigurationWithContextStub = nil - fake.putBucketMetricsConfigurationWithContextReturns = struct { - result1 *s3.PutBucketMetricsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketMetricsConfigurationWithContextReturnsOnCall(i int, result1 *s3.PutBucketMetricsConfigurationOutput, result2 error) { - fake.putBucketMetricsConfigurationWithContextMutex.Lock() - defer fake.putBucketMetricsConfigurationWithContextMutex.Unlock() - fake.PutBucketMetricsConfigurationWithContextStub = nil - if fake.putBucketMetricsConfigurationWithContextReturnsOnCall == nil { - fake.putBucketMetricsConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketMetricsConfigurationOutput - result2 error - }) - } - fake.putBucketMetricsConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketMetricsConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketNotification(arg1 *s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error) { - fake.putBucketNotificationMutex.Lock() - ret, specificReturn := fake.putBucketNotificationReturnsOnCall[len(fake.putBucketNotificationArgsForCall)] - fake.putBucketNotificationArgsForCall = append(fake.putBucketNotificationArgsForCall, struct { - arg1 *s3.PutBucketNotificationInput - }{arg1}) - stub := fake.PutBucketNotificationStub - fakeReturns := fake.putBucketNotificationReturns - fake.recordInvocation("PutBucketNotification", []interface{}{arg1}) - fake.putBucketNotificationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketNotificationCallCount() int { - fake.putBucketNotificationMutex.RLock() - defer fake.putBucketNotificationMutex.RUnlock() - return len(fake.putBucketNotificationArgsForCall) -} - -func (fake *FakeS3Client) PutBucketNotificationCalls(stub func(*s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error)) { - fake.putBucketNotificationMutex.Lock() - defer fake.putBucketNotificationMutex.Unlock() - fake.PutBucketNotificationStub = stub -} - -func (fake *FakeS3Client) PutBucketNotificationArgsForCall(i int) *s3.PutBucketNotificationInput { - fake.putBucketNotificationMutex.RLock() - defer fake.putBucketNotificationMutex.RUnlock() - argsForCall := fake.putBucketNotificationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketNotificationReturns(result1 *s3.PutBucketNotificationOutput, result2 error) { - fake.putBucketNotificationMutex.Lock() - defer fake.putBucketNotificationMutex.Unlock() - fake.PutBucketNotificationStub = nil - fake.putBucketNotificationReturns = struct { - result1 *s3.PutBucketNotificationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketNotificationReturnsOnCall(i int, result1 *s3.PutBucketNotificationOutput, result2 error) { - fake.putBucketNotificationMutex.Lock() - defer fake.putBucketNotificationMutex.Unlock() - fake.PutBucketNotificationStub = nil - if fake.putBucketNotificationReturnsOnCall == nil { - fake.putBucketNotificationReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketNotificationOutput - result2 error - }) - } - fake.putBucketNotificationReturnsOnCall[i] = struct { - result1 *s3.PutBucketNotificationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketNotificationConfiguration(arg1 *s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error) { - fake.putBucketNotificationConfigurationMutex.Lock() - ret, specificReturn := fake.putBucketNotificationConfigurationReturnsOnCall[len(fake.putBucketNotificationConfigurationArgsForCall)] - fake.putBucketNotificationConfigurationArgsForCall = append(fake.putBucketNotificationConfigurationArgsForCall, struct { - arg1 *s3.PutBucketNotificationConfigurationInput - }{arg1}) - stub := fake.PutBucketNotificationConfigurationStub - fakeReturns := fake.putBucketNotificationConfigurationReturns - fake.recordInvocation("PutBucketNotificationConfiguration", []interface{}{arg1}) - fake.putBucketNotificationConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationCallCount() int { - fake.putBucketNotificationConfigurationMutex.RLock() - defer fake.putBucketNotificationConfigurationMutex.RUnlock() - return len(fake.putBucketNotificationConfigurationArgsForCall) -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationCalls(stub func(*s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error)) { - fake.putBucketNotificationConfigurationMutex.Lock() - defer fake.putBucketNotificationConfigurationMutex.Unlock() - fake.PutBucketNotificationConfigurationStub = stub -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationArgsForCall(i int) *s3.PutBucketNotificationConfigurationInput { - fake.putBucketNotificationConfigurationMutex.RLock() - defer fake.putBucketNotificationConfigurationMutex.RUnlock() - argsForCall := fake.putBucketNotificationConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationReturns(result1 *s3.PutBucketNotificationConfigurationOutput, result2 error) { - fake.putBucketNotificationConfigurationMutex.Lock() - defer fake.putBucketNotificationConfigurationMutex.Unlock() - fake.PutBucketNotificationConfigurationStub = nil - fake.putBucketNotificationConfigurationReturns = struct { - result1 *s3.PutBucketNotificationConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationReturnsOnCall(i int, result1 *s3.PutBucketNotificationConfigurationOutput, result2 error) { - fake.putBucketNotificationConfigurationMutex.Lock() - defer fake.putBucketNotificationConfigurationMutex.Unlock() - fake.PutBucketNotificationConfigurationStub = nil - if fake.putBucketNotificationConfigurationReturnsOnCall == nil { - fake.putBucketNotificationConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketNotificationConfigurationOutput - result2 error - }) - } - fake.putBucketNotificationConfigurationReturnsOnCall[i] = struct { - result1 *s3.PutBucketNotificationConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationRequest(arg1 *s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput) { - fake.putBucketNotificationConfigurationRequestMutex.Lock() - ret, specificReturn := fake.putBucketNotificationConfigurationRequestReturnsOnCall[len(fake.putBucketNotificationConfigurationRequestArgsForCall)] - fake.putBucketNotificationConfigurationRequestArgsForCall = append(fake.putBucketNotificationConfigurationRequestArgsForCall, struct { - arg1 *s3.PutBucketNotificationConfigurationInput - }{arg1}) - stub := fake.PutBucketNotificationConfigurationRequestStub - fakeReturns := fake.putBucketNotificationConfigurationRequestReturns - fake.recordInvocation("PutBucketNotificationConfigurationRequest", []interface{}{arg1}) - fake.putBucketNotificationConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationRequestCallCount() int { - fake.putBucketNotificationConfigurationRequestMutex.RLock() - defer fake.putBucketNotificationConfigurationRequestMutex.RUnlock() - return len(fake.putBucketNotificationConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationRequestCalls(stub func(*s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput)) { - fake.putBucketNotificationConfigurationRequestMutex.Lock() - defer fake.putBucketNotificationConfigurationRequestMutex.Unlock() - fake.PutBucketNotificationConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationRequestArgsForCall(i int) *s3.PutBucketNotificationConfigurationInput { - fake.putBucketNotificationConfigurationRequestMutex.RLock() - defer fake.putBucketNotificationConfigurationRequestMutex.RUnlock() - argsForCall := fake.putBucketNotificationConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationRequestReturns(result1 *request.Request, result2 *s3.PutBucketNotificationConfigurationOutput) { - fake.putBucketNotificationConfigurationRequestMutex.Lock() - defer fake.putBucketNotificationConfigurationRequestMutex.Unlock() - fake.PutBucketNotificationConfigurationRequestStub = nil - fake.putBucketNotificationConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketNotificationConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketNotificationConfigurationOutput) { - fake.putBucketNotificationConfigurationRequestMutex.Lock() - defer fake.putBucketNotificationConfigurationRequestMutex.Unlock() - fake.PutBucketNotificationConfigurationRequestStub = nil - if fake.putBucketNotificationConfigurationRequestReturnsOnCall == nil { - fake.putBucketNotificationConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketNotificationConfigurationOutput - }) - } - fake.putBucketNotificationConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketNotificationConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationWithContext(arg1 context.Context, arg2 *s3.PutBucketNotificationConfigurationInput, arg3 ...request.Option) (*s3.PutBucketNotificationConfigurationOutput, error) { - fake.putBucketNotificationConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.putBucketNotificationConfigurationWithContextReturnsOnCall[len(fake.putBucketNotificationConfigurationWithContextArgsForCall)] - fake.putBucketNotificationConfigurationWithContextArgsForCall = append(fake.putBucketNotificationConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketNotificationConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketNotificationConfigurationWithContextStub - fakeReturns := fake.putBucketNotificationConfigurationWithContextReturns - fake.recordInvocation("PutBucketNotificationConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketNotificationConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationWithContextCallCount() int { - fake.putBucketNotificationConfigurationWithContextMutex.RLock() - defer fake.putBucketNotificationConfigurationWithContextMutex.RUnlock() - return len(fake.putBucketNotificationConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationWithContextCalls(stub func(context.Context, *s3.PutBucketNotificationConfigurationInput, ...request.Option) (*s3.PutBucketNotificationConfigurationOutput, error)) { - fake.putBucketNotificationConfigurationWithContextMutex.Lock() - defer fake.putBucketNotificationConfigurationWithContextMutex.Unlock() - fake.PutBucketNotificationConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationWithContextArgsForCall(i int) (context.Context, *s3.PutBucketNotificationConfigurationInput, []request.Option) { - fake.putBucketNotificationConfigurationWithContextMutex.RLock() - defer fake.putBucketNotificationConfigurationWithContextMutex.RUnlock() - argsForCall := fake.putBucketNotificationConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationWithContextReturns(result1 *s3.PutBucketNotificationConfigurationOutput, result2 error) { - fake.putBucketNotificationConfigurationWithContextMutex.Lock() - defer fake.putBucketNotificationConfigurationWithContextMutex.Unlock() - fake.PutBucketNotificationConfigurationWithContextStub = nil - fake.putBucketNotificationConfigurationWithContextReturns = struct { - result1 *s3.PutBucketNotificationConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketNotificationConfigurationWithContextReturnsOnCall(i int, result1 *s3.PutBucketNotificationConfigurationOutput, result2 error) { - fake.putBucketNotificationConfigurationWithContextMutex.Lock() - defer fake.putBucketNotificationConfigurationWithContextMutex.Unlock() - fake.PutBucketNotificationConfigurationWithContextStub = nil - if fake.putBucketNotificationConfigurationWithContextReturnsOnCall == nil { - fake.putBucketNotificationConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketNotificationConfigurationOutput - result2 error - }) - } - fake.putBucketNotificationConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketNotificationConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketNotificationRequest(arg1 *s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput) { - fake.putBucketNotificationRequestMutex.Lock() - ret, specificReturn := fake.putBucketNotificationRequestReturnsOnCall[len(fake.putBucketNotificationRequestArgsForCall)] - fake.putBucketNotificationRequestArgsForCall = append(fake.putBucketNotificationRequestArgsForCall, struct { - arg1 *s3.PutBucketNotificationInput - }{arg1}) - stub := fake.PutBucketNotificationRequestStub - fakeReturns := fake.putBucketNotificationRequestReturns - fake.recordInvocation("PutBucketNotificationRequest", []interface{}{arg1}) - fake.putBucketNotificationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketNotificationRequestCallCount() int { - fake.putBucketNotificationRequestMutex.RLock() - defer fake.putBucketNotificationRequestMutex.RUnlock() - return len(fake.putBucketNotificationRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketNotificationRequestCalls(stub func(*s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput)) { - fake.putBucketNotificationRequestMutex.Lock() - defer fake.putBucketNotificationRequestMutex.Unlock() - fake.PutBucketNotificationRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketNotificationRequestArgsForCall(i int) *s3.PutBucketNotificationInput { - fake.putBucketNotificationRequestMutex.RLock() - defer fake.putBucketNotificationRequestMutex.RUnlock() - argsForCall := fake.putBucketNotificationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketNotificationRequestReturns(result1 *request.Request, result2 *s3.PutBucketNotificationOutput) { - fake.putBucketNotificationRequestMutex.Lock() - defer fake.putBucketNotificationRequestMutex.Unlock() - fake.PutBucketNotificationRequestStub = nil - fake.putBucketNotificationRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketNotificationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketNotificationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketNotificationOutput) { - fake.putBucketNotificationRequestMutex.Lock() - defer fake.putBucketNotificationRequestMutex.Unlock() - fake.PutBucketNotificationRequestStub = nil - if fake.putBucketNotificationRequestReturnsOnCall == nil { - fake.putBucketNotificationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketNotificationOutput - }) - } - fake.putBucketNotificationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketNotificationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketNotificationWithContext(arg1 context.Context, arg2 *s3.PutBucketNotificationInput, arg3 ...request.Option) (*s3.PutBucketNotificationOutput, error) { - fake.putBucketNotificationWithContextMutex.Lock() - ret, specificReturn := fake.putBucketNotificationWithContextReturnsOnCall[len(fake.putBucketNotificationWithContextArgsForCall)] - fake.putBucketNotificationWithContextArgsForCall = append(fake.putBucketNotificationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketNotificationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketNotificationWithContextStub - fakeReturns := fake.putBucketNotificationWithContextReturns - fake.recordInvocation("PutBucketNotificationWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketNotificationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketNotificationWithContextCallCount() int { - fake.putBucketNotificationWithContextMutex.RLock() - defer fake.putBucketNotificationWithContextMutex.RUnlock() - return len(fake.putBucketNotificationWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketNotificationWithContextCalls(stub func(context.Context, *s3.PutBucketNotificationInput, ...request.Option) (*s3.PutBucketNotificationOutput, error)) { - fake.putBucketNotificationWithContextMutex.Lock() - defer fake.putBucketNotificationWithContextMutex.Unlock() - fake.PutBucketNotificationWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketNotificationWithContextArgsForCall(i int) (context.Context, *s3.PutBucketNotificationInput, []request.Option) { - fake.putBucketNotificationWithContextMutex.RLock() - defer fake.putBucketNotificationWithContextMutex.RUnlock() - argsForCall := fake.putBucketNotificationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketNotificationWithContextReturns(result1 *s3.PutBucketNotificationOutput, result2 error) { - fake.putBucketNotificationWithContextMutex.Lock() - defer fake.putBucketNotificationWithContextMutex.Unlock() - fake.PutBucketNotificationWithContextStub = nil - fake.putBucketNotificationWithContextReturns = struct { - result1 *s3.PutBucketNotificationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketNotificationWithContextReturnsOnCall(i int, result1 *s3.PutBucketNotificationOutput, result2 error) { - fake.putBucketNotificationWithContextMutex.Lock() - defer fake.putBucketNotificationWithContextMutex.Unlock() - fake.PutBucketNotificationWithContextStub = nil - if fake.putBucketNotificationWithContextReturnsOnCall == nil { - fake.putBucketNotificationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketNotificationOutput - result2 error - }) - } - fake.putBucketNotificationWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketNotificationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketOwnershipControls(arg1 *s3.PutBucketOwnershipControlsInput) (*s3.PutBucketOwnershipControlsOutput, error) { - fake.putBucketOwnershipControlsMutex.Lock() - ret, specificReturn := fake.putBucketOwnershipControlsReturnsOnCall[len(fake.putBucketOwnershipControlsArgsForCall)] - fake.putBucketOwnershipControlsArgsForCall = append(fake.putBucketOwnershipControlsArgsForCall, struct { - arg1 *s3.PutBucketOwnershipControlsInput - }{arg1}) - stub := fake.PutBucketOwnershipControlsStub - fakeReturns := fake.putBucketOwnershipControlsReturns - fake.recordInvocation("PutBucketOwnershipControls", []interface{}{arg1}) - fake.putBucketOwnershipControlsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsCallCount() int { - fake.putBucketOwnershipControlsMutex.RLock() - defer fake.putBucketOwnershipControlsMutex.RUnlock() - return len(fake.putBucketOwnershipControlsArgsForCall) -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsCalls(stub func(*s3.PutBucketOwnershipControlsInput) (*s3.PutBucketOwnershipControlsOutput, error)) { - fake.putBucketOwnershipControlsMutex.Lock() - defer fake.putBucketOwnershipControlsMutex.Unlock() - fake.PutBucketOwnershipControlsStub = stub -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsArgsForCall(i int) *s3.PutBucketOwnershipControlsInput { - fake.putBucketOwnershipControlsMutex.RLock() - defer fake.putBucketOwnershipControlsMutex.RUnlock() - argsForCall := fake.putBucketOwnershipControlsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsReturns(result1 *s3.PutBucketOwnershipControlsOutput, result2 error) { - fake.putBucketOwnershipControlsMutex.Lock() - defer fake.putBucketOwnershipControlsMutex.Unlock() - fake.PutBucketOwnershipControlsStub = nil - fake.putBucketOwnershipControlsReturns = struct { - result1 *s3.PutBucketOwnershipControlsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsReturnsOnCall(i int, result1 *s3.PutBucketOwnershipControlsOutput, result2 error) { - fake.putBucketOwnershipControlsMutex.Lock() - defer fake.putBucketOwnershipControlsMutex.Unlock() - fake.PutBucketOwnershipControlsStub = nil - if fake.putBucketOwnershipControlsReturnsOnCall == nil { - fake.putBucketOwnershipControlsReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketOwnershipControlsOutput - result2 error - }) - } - fake.putBucketOwnershipControlsReturnsOnCall[i] = struct { - result1 *s3.PutBucketOwnershipControlsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsRequest(arg1 *s3.PutBucketOwnershipControlsInput) (*request.Request, *s3.PutBucketOwnershipControlsOutput) { - fake.putBucketOwnershipControlsRequestMutex.Lock() - ret, specificReturn := fake.putBucketOwnershipControlsRequestReturnsOnCall[len(fake.putBucketOwnershipControlsRequestArgsForCall)] - fake.putBucketOwnershipControlsRequestArgsForCall = append(fake.putBucketOwnershipControlsRequestArgsForCall, struct { - arg1 *s3.PutBucketOwnershipControlsInput - }{arg1}) - stub := fake.PutBucketOwnershipControlsRequestStub - fakeReturns := fake.putBucketOwnershipControlsRequestReturns - fake.recordInvocation("PutBucketOwnershipControlsRequest", []interface{}{arg1}) - fake.putBucketOwnershipControlsRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsRequestCallCount() int { - fake.putBucketOwnershipControlsRequestMutex.RLock() - defer fake.putBucketOwnershipControlsRequestMutex.RUnlock() - return len(fake.putBucketOwnershipControlsRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsRequestCalls(stub func(*s3.PutBucketOwnershipControlsInput) (*request.Request, *s3.PutBucketOwnershipControlsOutput)) { - fake.putBucketOwnershipControlsRequestMutex.Lock() - defer fake.putBucketOwnershipControlsRequestMutex.Unlock() - fake.PutBucketOwnershipControlsRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsRequestArgsForCall(i int) *s3.PutBucketOwnershipControlsInput { - fake.putBucketOwnershipControlsRequestMutex.RLock() - defer fake.putBucketOwnershipControlsRequestMutex.RUnlock() - argsForCall := fake.putBucketOwnershipControlsRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsRequestReturns(result1 *request.Request, result2 *s3.PutBucketOwnershipControlsOutput) { - fake.putBucketOwnershipControlsRequestMutex.Lock() - defer fake.putBucketOwnershipControlsRequestMutex.Unlock() - fake.PutBucketOwnershipControlsRequestStub = nil - fake.putBucketOwnershipControlsRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketOwnershipControlsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketOwnershipControlsOutput) { - fake.putBucketOwnershipControlsRequestMutex.Lock() - defer fake.putBucketOwnershipControlsRequestMutex.Unlock() - fake.PutBucketOwnershipControlsRequestStub = nil - if fake.putBucketOwnershipControlsRequestReturnsOnCall == nil { - fake.putBucketOwnershipControlsRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketOwnershipControlsOutput - }) - } - fake.putBucketOwnershipControlsRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketOwnershipControlsOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsWithContext(arg1 context.Context, arg2 *s3.PutBucketOwnershipControlsInput, arg3 ...request.Option) (*s3.PutBucketOwnershipControlsOutput, error) { - fake.putBucketOwnershipControlsWithContextMutex.Lock() - ret, specificReturn := fake.putBucketOwnershipControlsWithContextReturnsOnCall[len(fake.putBucketOwnershipControlsWithContextArgsForCall)] - fake.putBucketOwnershipControlsWithContextArgsForCall = append(fake.putBucketOwnershipControlsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketOwnershipControlsInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketOwnershipControlsWithContextStub - fakeReturns := fake.putBucketOwnershipControlsWithContextReturns - fake.recordInvocation("PutBucketOwnershipControlsWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketOwnershipControlsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsWithContextCallCount() int { - fake.putBucketOwnershipControlsWithContextMutex.RLock() - defer fake.putBucketOwnershipControlsWithContextMutex.RUnlock() - return len(fake.putBucketOwnershipControlsWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsWithContextCalls(stub func(context.Context, *s3.PutBucketOwnershipControlsInput, ...request.Option) (*s3.PutBucketOwnershipControlsOutput, error)) { - fake.putBucketOwnershipControlsWithContextMutex.Lock() - defer fake.putBucketOwnershipControlsWithContextMutex.Unlock() - fake.PutBucketOwnershipControlsWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsWithContextArgsForCall(i int) (context.Context, *s3.PutBucketOwnershipControlsInput, []request.Option) { - fake.putBucketOwnershipControlsWithContextMutex.RLock() - defer fake.putBucketOwnershipControlsWithContextMutex.RUnlock() - argsForCall := fake.putBucketOwnershipControlsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsWithContextReturns(result1 *s3.PutBucketOwnershipControlsOutput, result2 error) { - fake.putBucketOwnershipControlsWithContextMutex.Lock() - defer fake.putBucketOwnershipControlsWithContextMutex.Unlock() - fake.PutBucketOwnershipControlsWithContextStub = nil - fake.putBucketOwnershipControlsWithContextReturns = struct { - result1 *s3.PutBucketOwnershipControlsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketOwnershipControlsWithContextReturnsOnCall(i int, result1 *s3.PutBucketOwnershipControlsOutput, result2 error) { - fake.putBucketOwnershipControlsWithContextMutex.Lock() - defer fake.putBucketOwnershipControlsWithContextMutex.Unlock() - fake.PutBucketOwnershipControlsWithContextStub = nil - if fake.putBucketOwnershipControlsWithContextReturnsOnCall == nil { - fake.putBucketOwnershipControlsWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketOwnershipControlsOutput - result2 error - }) - } - fake.putBucketOwnershipControlsWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketOwnershipControlsOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketPolicy(arg1 *s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error) { - fake.putBucketPolicyMutex.Lock() - ret, specificReturn := fake.putBucketPolicyReturnsOnCall[len(fake.putBucketPolicyArgsForCall)] - fake.putBucketPolicyArgsForCall = append(fake.putBucketPolicyArgsForCall, struct { - arg1 *s3.PutBucketPolicyInput - }{arg1}) - stub := fake.PutBucketPolicyStub - fakeReturns := fake.putBucketPolicyReturns - fake.recordInvocation("PutBucketPolicy", []interface{}{arg1}) - fake.putBucketPolicyMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketPolicyCallCount() int { - fake.putBucketPolicyMutex.RLock() - defer fake.putBucketPolicyMutex.RUnlock() - return len(fake.putBucketPolicyArgsForCall) -} - -func (fake *FakeS3Client) PutBucketPolicyCalls(stub func(*s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error)) { - fake.putBucketPolicyMutex.Lock() - defer fake.putBucketPolicyMutex.Unlock() - fake.PutBucketPolicyStub = stub -} - -func (fake *FakeS3Client) PutBucketPolicyArgsForCall(i int) *s3.PutBucketPolicyInput { - fake.putBucketPolicyMutex.RLock() - defer fake.putBucketPolicyMutex.RUnlock() - argsForCall := fake.putBucketPolicyArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketPolicyReturns(result1 *s3.PutBucketPolicyOutput, result2 error) { - fake.putBucketPolicyMutex.Lock() - defer fake.putBucketPolicyMutex.Unlock() - fake.PutBucketPolicyStub = nil - fake.putBucketPolicyReturns = struct { - result1 *s3.PutBucketPolicyOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketPolicyReturnsOnCall(i int, result1 *s3.PutBucketPolicyOutput, result2 error) { - fake.putBucketPolicyMutex.Lock() - defer fake.putBucketPolicyMutex.Unlock() - fake.PutBucketPolicyStub = nil - if fake.putBucketPolicyReturnsOnCall == nil { - fake.putBucketPolicyReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketPolicyOutput - result2 error - }) - } - fake.putBucketPolicyReturnsOnCall[i] = struct { - result1 *s3.PutBucketPolicyOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketPolicyRequest(arg1 *s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput) { - fake.putBucketPolicyRequestMutex.Lock() - ret, specificReturn := fake.putBucketPolicyRequestReturnsOnCall[len(fake.putBucketPolicyRequestArgsForCall)] - fake.putBucketPolicyRequestArgsForCall = append(fake.putBucketPolicyRequestArgsForCall, struct { - arg1 *s3.PutBucketPolicyInput - }{arg1}) - stub := fake.PutBucketPolicyRequestStub - fakeReturns := fake.putBucketPolicyRequestReturns - fake.recordInvocation("PutBucketPolicyRequest", []interface{}{arg1}) - fake.putBucketPolicyRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketPolicyRequestCallCount() int { - fake.putBucketPolicyRequestMutex.RLock() - defer fake.putBucketPolicyRequestMutex.RUnlock() - return len(fake.putBucketPolicyRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketPolicyRequestCalls(stub func(*s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput)) { - fake.putBucketPolicyRequestMutex.Lock() - defer fake.putBucketPolicyRequestMutex.Unlock() - fake.PutBucketPolicyRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketPolicyRequestArgsForCall(i int) *s3.PutBucketPolicyInput { - fake.putBucketPolicyRequestMutex.RLock() - defer fake.putBucketPolicyRequestMutex.RUnlock() - argsForCall := fake.putBucketPolicyRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketPolicyRequestReturns(result1 *request.Request, result2 *s3.PutBucketPolicyOutput) { - fake.putBucketPolicyRequestMutex.Lock() - defer fake.putBucketPolicyRequestMutex.Unlock() - fake.PutBucketPolicyRequestStub = nil - fake.putBucketPolicyRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketPolicyOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketPolicyRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketPolicyOutput) { - fake.putBucketPolicyRequestMutex.Lock() - defer fake.putBucketPolicyRequestMutex.Unlock() - fake.PutBucketPolicyRequestStub = nil - if fake.putBucketPolicyRequestReturnsOnCall == nil { - fake.putBucketPolicyRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketPolicyOutput - }) - } - fake.putBucketPolicyRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketPolicyOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketPolicyWithContext(arg1 context.Context, arg2 *s3.PutBucketPolicyInput, arg3 ...request.Option) (*s3.PutBucketPolicyOutput, error) { - fake.putBucketPolicyWithContextMutex.Lock() - ret, specificReturn := fake.putBucketPolicyWithContextReturnsOnCall[len(fake.putBucketPolicyWithContextArgsForCall)] - fake.putBucketPolicyWithContextArgsForCall = append(fake.putBucketPolicyWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketPolicyInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketPolicyWithContextStub - fakeReturns := fake.putBucketPolicyWithContextReturns - fake.recordInvocation("PutBucketPolicyWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketPolicyWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketPolicyWithContextCallCount() int { - fake.putBucketPolicyWithContextMutex.RLock() - defer fake.putBucketPolicyWithContextMutex.RUnlock() - return len(fake.putBucketPolicyWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketPolicyWithContextCalls(stub func(context.Context, *s3.PutBucketPolicyInput, ...request.Option) (*s3.PutBucketPolicyOutput, error)) { - fake.putBucketPolicyWithContextMutex.Lock() - defer fake.putBucketPolicyWithContextMutex.Unlock() - fake.PutBucketPolicyWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketPolicyWithContextArgsForCall(i int) (context.Context, *s3.PutBucketPolicyInput, []request.Option) { - fake.putBucketPolicyWithContextMutex.RLock() - defer fake.putBucketPolicyWithContextMutex.RUnlock() - argsForCall := fake.putBucketPolicyWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketPolicyWithContextReturns(result1 *s3.PutBucketPolicyOutput, result2 error) { - fake.putBucketPolicyWithContextMutex.Lock() - defer fake.putBucketPolicyWithContextMutex.Unlock() - fake.PutBucketPolicyWithContextStub = nil - fake.putBucketPolicyWithContextReturns = struct { - result1 *s3.PutBucketPolicyOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketPolicyWithContextReturnsOnCall(i int, result1 *s3.PutBucketPolicyOutput, result2 error) { - fake.putBucketPolicyWithContextMutex.Lock() - defer fake.putBucketPolicyWithContextMutex.Unlock() - fake.PutBucketPolicyWithContextStub = nil - if fake.putBucketPolicyWithContextReturnsOnCall == nil { - fake.putBucketPolicyWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketPolicyOutput - result2 error - }) - } - fake.putBucketPolicyWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketPolicyOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketReplication(arg1 *s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error) { - fake.putBucketReplicationMutex.Lock() - ret, specificReturn := fake.putBucketReplicationReturnsOnCall[len(fake.putBucketReplicationArgsForCall)] - fake.putBucketReplicationArgsForCall = append(fake.putBucketReplicationArgsForCall, struct { - arg1 *s3.PutBucketReplicationInput - }{arg1}) - stub := fake.PutBucketReplicationStub - fakeReturns := fake.putBucketReplicationReturns - fake.recordInvocation("PutBucketReplication", []interface{}{arg1}) - fake.putBucketReplicationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketReplicationCallCount() int { - fake.putBucketReplicationMutex.RLock() - defer fake.putBucketReplicationMutex.RUnlock() - return len(fake.putBucketReplicationArgsForCall) -} - -func (fake *FakeS3Client) PutBucketReplicationCalls(stub func(*s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error)) { - fake.putBucketReplicationMutex.Lock() - defer fake.putBucketReplicationMutex.Unlock() - fake.PutBucketReplicationStub = stub -} - -func (fake *FakeS3Client) PutBucketReplicationArgsForCall(i int) *s3.PutBucketReplicationInput { - fake.putBucketReplicationMutex.RLock() - defer fake.putBucketReplicationMutex.RUnlock() - argsForCall := fake.putBucketReplicationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketReplicationReturns(result1 *s3.PutBucketReplicationOutput, result2 error) { - fake.putBucketReplicationMutex.Lock() - defer fake.putBucketReplicationMutex.Unlock() - fake.PutBucketReplicationStub = nil - fake.putBucketReplicationReturns = struct { - result1 *s3.PutBucketReplicationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketReplicationReturnsOnCall(i int, result1 *s3.PutBucketReplicationOutput, result2 error) { - fake.putBucketReplicationMutex.Lock() - defer fake.putBucketReplicationMutex.Unlock() - fake.PutBucketReplicationStub = nil - if fake.putBucketReplicationReturnsOnCall == nil { - fake.putBucketReplicationReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketReplicationOutput - result2 error - }) - } - fake.putBucketReplicationReturnsOnCall[i] = struct { - result1 *s3.PutBucketReplicationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketReplicationRequest(arg1 *s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput) { - fake.putBucketReplicationRequestMutex.Lock() - ret, specificReturn := fake.putBucketReplicationRequestReturnsOnCall[len(fake.putBucketReplicationRequestArgsForCall)] - fake.putBucketReplicationRequestArgsForCall = append(fake.putBucketReplicationRequestArgsForCall, struct { - arg1 *s3.PutBucketReplicationInput - }{arg1}) - stub := fake.PutBucketReplicationRequestStub - fakeReturns := fake.putBucketReplicationRequestReturns - fake.recordInvocation("PutBucketReplicationRequest", []interface{}{arg1}) - fake.putBucketReplicationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketReplicationRequestCallCount() int { - fake.putBucketReplicationRequestMutex.RLock() - defer fake.putBucketReplicationRequestMutex.RUnlock() - return len(fake.putBucketReplicationRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketReplicationRequestCalls(stub func(*s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput)) { - fake.putBucketReplicationRequestMutex.Lock() - defer fake.putBucketReplicationRequestMutex.Unlock() - fake.PutBucketReplicationRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketReplicationRequestArgsForCall(i int) *s3.PutBucketReplicationInput { - fake.putBucketReplicationRequestMutex.RLock() - defer fake.putBucketReplicationRequestMutex.RUnlock() - argsForCall := fake.putBucketReplicationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketReplicationRequestReturns(result1 *request.Request, result2 *s3.PutBucketReplicationOutput) { - fake.putBucketReplicationRequestMutex.Lock() - defer fake.putBucketReplicationRequestMutex.Unlock() - fake.PutBucketReplicationRequestStub = nil - fake.putBucketReplicationRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketReplicationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketReplicationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketReplicationOutput) { - fake.putBucketReplicationRequestMutex.Lock() - defer fake.putBucketReplicationRequestMutex.Unlock() - fake.PutBucketReplicationRequestStub = nil - if fake.putBucketReplicationRequestReturnsOnCall == nil { - fake.putBucketReplicationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketReplicationOutput - }) - } - fake.putBucketReplicationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketReplicationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketReplicationWithContext(arg1 context.Context, arg2 *s3.PutBucketReplicationInput, arg3 ...request.Option) (*s3.PutBucketReplicationOutput, error) { - fake.putBucketReplicationWithContextMutex.Lock() - ret, specificReturn := fake.putBucketReplicationWithContextReturnsOnCall[len(fake.putBucketReplicationWithContextArgsForCall)] - fake.putBucketReplicationWithContextArgsForCall = append(fake.putBucketReplicationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketReplicationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketReplicationWithContextStub - fakeReturns := fake.putBucketReplicationWithContextReturns - fake.recordInvocation("PutBucketReplicationWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketReplicationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketReplicationWithContextCallCount() int { - fake.putBucketReplicationWithContextMutex.RLock() - defer fake.putBucketReplicationWithContextMutex.RUnlock() - return len(fake.putBucketReplicationWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketReplicationWithContextCalls(stub func(context.Context, *s3.PutBucketReplicationInput, ...request.Option) (*s3.PutBucketReplicationOutput, error)) { - fake.putBucketReplicationWithContextMutex.Lock() - defer fake.putBucketReplicationWithContextMutex.Unlock() - fake.PutBucketReplicationWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketReplicationWithContextArgsForCall(i int) (context.Context, *s3.PutBucketReplicationInput, []request.Option) { - fake.putBucketReplicationWithContextMutex.RLock() - defer fake.putBucketReplicationWithContextMutex.RUnlock() - argsForCall := fake.putBucketReplicationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketReplicationWithContextReturns(result1 *s3.PutBucketReplicationOutput, result2 error) { - fake.putBucketReplicationWithContextMutex.Lock() - defer fake.putBucketReplicationWithContextMutex.Unlock() - fake.PutBucketReplicationWithContextStub = nil - fake.putBucketReplicationWithContextReturns = struct { - result1 *s3.PutBucketReplicationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketReplicationWithContextReturnsOnCall(i int, result1 *s3.PutBucketReplicationOutput, result2 error) { - fake.putBucketReplicationWithContextMutex.Lock() - defer fake.putBucketReplicationWithContextMutex.Unlock() - fake.PutBucketReplicationWithContextStub = nil - if fake.putBucketReplicationWithContextReturnsOnCall == nil { - fake.putBucketReplicationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketReplicationOutput - result2 error - }) - } - fake.putBucketReplicationWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketReplicationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketRequestPayment(arg1 *s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error) { - fake.putBucketRequestPaymentMutex.Lock() - ret, specificReturn := fake.putBucketRequestPaymentReturnsOnCall[len(fake.putBucketRequestPaymentArgsForCall)] - fake.putBucketRequestPaymentArgsForCall = append(fake.putBucketRequestPaymentArgsForCall, struct { - arg1 *s3.PutBucketRequestPaymentInput - }{arg1}) - stub := fake.PutBucketRequestPaymentStub - fakeReturns := fake.putBucketRequestPaymentReturns - fake.recordInvocation("PutBucketRequestPayment", []interface{}{arg1}) - fake.putBucketRequestPaymentMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketRequestPaymentCallCount() int { - fake.putBucketRequestPaymentMutex.RLock() - defer fake.putBucketRequestPaymentMutex.RUnlock() - return len(fake.putBucketRequestPaymentArgsForCall) -} - -func (fake *FakeS3Client) PutBucketRequestPaymentCalls(stub func(*s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error)) { - fake.putBucketRequestPaymentMutex.Lock() - defer fake.putBucketRequestPaymentMutex.Unlock() - fake.PutBucketRequestPaymentStub = stub -} - -func (fake *FakeS3Client) PutBucketRequestPaymentArgsForCall(i int) *s3.PutBucketRequestPaymentInput { - fake.putBucketRequestPaymentMutex.RLock() - defer fake.putBucketRequestPaymentMutex.RUnlock() - argsForCall := fake.putBucketRequestPaymentArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketRequestPaymentReturns(result1 *s3.PutBucketRequestPaymentOutput, result2 error) { - fake.putBucketRequestPaymentMutex.Lock() - defer fake.putBucketRequestPaymentMutex.Unlock() - fake.PutBucketRequestPaymentStub = nil - fake.putBucketRequestPaymentReturns = struct { - result1 *s3.PutBucketRequestPaymentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketRequestPaymentReturnsOnCall(i int, result1 *s3.PutBucketRequestPaymentOutput, result2 error) { - fake.putBucketRequestPaymentMutex.Lock() - defer fake.putBucketRequestPaymentMutex.Unlock() - fake.PutBucketRequestPaymentStub = nil - if fake.putBucketRequestPaymentReturnsOnCall == nil { - fake.putBucketRequestPaymentReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketRequestPaymentOutput - result2 error - }) - } - fake.putBucketRequestPaymentReturnsOnCall[i] = struct { - result1 *s3.PutBucketRequestPaymentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketRequestPaymentRequest(arg1 *s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput) { - fake.putBucketRequestPaymentRequestMutex.Lock() - ret, specificReturn := fake.putBucketRequestPaymentRequestReturnsOnCall[len(fake.putBucketRequestPaymentRequestArgsForCall)] - fake.putBucketRequestPaymentRequestArgsForCall = append(fake.putBucketRequestPaymentRequestArgsForCall, struct { - arg1 *s3.PutBucketRequestPaymentInput - }{arg1}) - stub := fake.PutBucketRequestPaymentRequestStub - fakeReturns := fake.putBucketRequestPaymentRequestReturns - fake.recordInvocation("PutBucketRequestPaymentRequest", []interface{}{arg1}) - fake.putBucketRequestPaymentRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketRequestPaymentRequestCallCount() int { - fake.putBucketRequestPaymentRequestMutex.RLock() - defer fake.putBucketRequestPaymentRequestMutex.RUnlock() - return len(fake.putBucketRequestPaymentRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketRequestPaymentRequestCalls(stub func(*s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput)) { - fake.putBucketRequestPaymentRequestMutex.Lock() - defer fake.putBucketRequestPaymentRequestMutex.Unlock() - fake.PutBucketRequestPaymentRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketRequestPaymentRequestArgsForCall(i int) *s3.PutBucketRequestPaymentInput { - fake.putBucketRequestPaymentRequestMutex.RLock() - defer fake.putBucketRequestPaymentRequestMutex.RUnlock() - argsForCall := fake.putBucketRequestPaymentRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketRequestPaymentRequestReturns(result1 *request.Request, result2 *s3.PutBucketRequestPaymentOutput) { - fake.putBucketRequestPaymentRequestMutex.Lock() - defer fake.putBucketRequestPaymentRequestMutex.Unlock() - fake.PutBucketRequestPaymentRequestStub = nil - fake.putBucketRequestPaymentRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketRequestPaymentOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketRequestPaymentRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketRequestPaymentOutput) { - fake.putBucketRequestPaymentRequestMutex.Lock() - defer fake.putBucketRequestPaymentRequestMutex.Unlock() - fake.PutBucketRequestPaymentRequestStub = nil - if fake.putBucketRequestPaymentRequestReturnsOnCall == nil { - fake.putBucketRequestPaymentRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketRequestPaymentOutput - }) - } - fake.putBucketRequestPaymentRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketRequestPaymentOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketRequestPaymentWithContext(arg1 context.Context, arg2 *s3.PutBucketRequestPaymentInput, arg3 ...request.Option) (*s3.PutBucketRequestPaymentOutput, error) { - fake.putBucketRequestPaymentWithContextMutex.Lock() - ret, specificReturn := fake.putBucketRequestPaymentWithContextReturnsOnCall[len(fake.putBucketRequestPaymentWithContextArgsForCall)] - fake.putBucketRequestPaymentWithContextArgsForCall = append(fake.putBucketRequestPaymentWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketRequestPaymentInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketRequestPaymentWithContextStub - fakeReturns := fake.putBucketRequestPaymentWithContextReturns - fake.recordInvocation("PutBucketRequestPaymentWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketRequestPaymentWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketRequestPaymentWithContextCallCount() int { - fake.putBucketRequestPaymentWithContextMutex.RLock() - defer fake.putBucketRequestPaymentWithContextMutex.RUnlock() - return len(fake.putBucketRequestPaymentWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketRequestPaymentWithContextCalls(stub func(context.Context, *s3.PutBucketRequestPaymentInput, ...request.Option) (*s3.PutBucketRequestPaymentOutput, error)) { - fake.putBucketRequestPaymentWithContextMutex.Lock() - defer fake.putBucketRequestPaymentWithContextMutex.Unlock() - fake.PutBucketRequestPaymentWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketRequestPaymentWithContextArgsForCall(i int) (context.Context, *s3.PutBucketRequestPaymentInput, []request.Option) { - fake.putBucketRequestPaymentWithContextMutex.RLock() - defer fake.putBucketRequestPaymentWithContextMutex.RUnlock() - argsForCall := fake.putBucketRequestPaymentWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketRequestPaymentWithContextReturns(result1 *s3.PutBucketRequestPaymentOutput, result2 error) { - fake.putBucketRequestPaymentWithContextMutex.Lock() - defer fake.putBucketRequestPaymentWithContextMutex.Unlock() - fake.PutBucketRequestPaymentWithContextStub = nil - fake.putBucketRequestPaymentWithContextReturns = struct { - result1 *s3.PutBucketRequestPaymentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketRequestPaymentWithContextReturnsOnCall(i int, result1 *s3.PutBucketRequestPaymentOutput, result2 error) { - fake.putBucketRequestPaymentWithContextMutex.Lock() - defer fake.putBucketRequestPaymentWithContextMutex.Unlock() - fake.PutBucketRequestPaymentWithContextStub = nil - if fake.putBucketRequestPaymentWithContextReturnsOnCall == nil { - fake.putBucketRequestPaymentWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketRequestPaymentOutput - result2 error - }) - } - fake.putBucketRequestPaymentWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketRequestPaymentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketTagging(arg1 *s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error) { - fake.putBucketTaggingMutex.Lock() - ret, specificReturn := fake.putBucketTaggingReturnsOnCall[len(fake.putBucketTaggingArgsForCall)] - fake.putBucketTaggingArgsForCall = append(fake.putBucketTaggingArgsForCall, struct { - arg1 *s3.PutBucketTaggingInput - }{arg1}) - stub := fake.PutBucketTaggingStub - fakeReturns := fake.putBucketTaggingReturns - fake.recordInvocation("PutBucketTagging", []interface{}{arg1}) - fake.putBucketTaggingMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketTaggingCallCount() int { - fake.putBucketTaggingMutex.RLock() - defer fake.putBucketTaggingMutex.RUnlock() - return len(fake.putBucketTaggingArgsForCall) -} - -func (fake *FakeS3Client) PutBucketTaggingCalls(stub func(*s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error)) { - fake.putBucketTaggingMutex.Lock() - defer fake.putBucketTaggingMutex.Unlock() - fake.PutBucketTaggingStub = stub -} - -func (fake *FakeS3Client) PutBucketTaggingArgsForCall(i int) *s3.PutBucketTaggingInput { - fake.putBucketTaggingMutex.RLock() - defer fake.putBucketTaggingMutex.RUnlock() - argsForCall := fake.putBucketTaggingArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketTaggingReturns(result1 *s3.PutBucketTaggingOutput, result2 error) { - fake.putBucketTaggingMutex.Lock() - defer fake.putBucketTaggingMutex.Unlock() - fake.PutBucketTaggingStub = nil - fake.putBucketTaggingReturns = struct { - result1 *s3.PutBucketTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketTaggingReturnsOnCall(i int, result1 *s3.PutBucketTaggingOutput, result2 error) { - fake.putBucketTaggingMutex.Lock() - defer fake.putBucketTaggingMutex.Unlock() - fake.PutBucketTaggingStub = nil - if fake.putBucketTaggingReturnsOnCall == nil { - fake.putBucketTaggingReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketTaggingOutput - result2 error - }) - } - fake.putBucketTaggingReturnsOnCall[i] = struct { - result1 *s3.PutBucketTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketTaggingRequest(arg1 *s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput) { - fake.putBucketTaggingRequestMutex.Lock() - ret, specificReturn := fake.putBucketTaggingRequestReturnsOnCall[len(fake.putBucketTaggingRequestArgsForCall)] - fake.putBucketTaggingRequestArgsForCall = append(fake.putBucketTaggingRequestArgsForCall, struct { - arg1 *s3.PutBucketTaggingInput - }{arg1}) - stub := fake.PutBucketTaggingRequestStub - fakeReturns := fake.putBucketTaggingRequestReturns - fake.recordInvocation("PutBucketTaggingRequest", []interface{}{arg1}) - fake.putBucketTaggingRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketTaggingRequestCallCount() int { - fake.putBucketTaggingRequestMutex.RLock() - defer fake.putBucketTaggingRequestMutex.RUnlock() - return len(fake.putBucketTaggingRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketTaggingRequestCalls(stub func(*s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput)) { - fake.putBucketTaggingRequestMutex.Lock() - defer fake.putBucketTaggingRequestMutex.Unlock() - fake.PutBucketTaggingRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketTaggingRequestArgsForCall(i int) *s3.PutBucketTaggingInput { - fake.putBucketTaggingRequestMutex.RLock() - defer fake.putBucketTaggingRequestMutex.RUnlock() - argsForCall := fake.putBucketTaggingRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketTaggingRequestReturns(result1 *request.Request, result2 *s3.PutBucketTaggingOutput) { - fake.putBucketTaggingRequestMutex.Lock() - defer fake.putBucketTaggingRequestMutex.Unlock() - fake.PutBucketTaggingRequestStub = nil - fake.putBucketTaggingRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketTaggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketTaggingRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketTaggingOutput) { - fake.putBucketTaggingRequestMutex.Lock() - defer fake.putBucketTaggingRequestMutex.Unlock() - fake.PutBucketTaggingRequestStub = nil - if fake.putBucketTaggingRequestReturnsOnCall == nil { - fake.putBucketTaggingRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketTaggingOutput - }) - } - fake.putBucketTaggingRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketTaggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketTaggingWithContext(arg1 context.Context, arg2 *s3.PutBucketTaggingInput, arg3 ...request.Option) (*s3.PutBucketTaggingOutput, error) { - fake.putBucketTaggingWithContextMutex.Lock() - ret, specificReturn := fake.putBucketTaggingWithContextReturnsOnCall[len(fake.putBucketTaggingWithContextArgsForCall)] - fake.putBucketTaggingWithContextArgsForCall = append(fake.putBucketTaggingWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketTaggingInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketTaggingWithContextStub - fakeReturns := fake.putBucketTaggingWithContextReturns - fake.recordInvocation("PutBucketTaggingWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketTaggingWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketTaggingWithContextCallCount() int { - fake.putBucketTaggingWithContextMutex.RLock() - defer fake.putBucketTaggingWithContextMutex.RUnlock() - return len(fake.putBucketTaggingWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketTaggingWithContextCalls(stub func(context.Context, *s3.PutBucketTaggingInput, ...request.Option) (*s3.PutBucketTaggingOutput, error)) { - fake.putBucketTaggingWithContextMutex.Lock() - defer fake.putBucketTaggingWithContextMutex.Unlock() - fake.PutBucketTaggingWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketTaggingWithContextArgsForCall(i int) (context.Context, *s3.PutBucketTaggingInput, []request.Option) { - fake.putBucketTaggingWithContextMutex.RLock() - defer fake.putBucketTaggingWithContextMutex.RUnlock() - argsForCall := fake.putBucketTaggingWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketTaggingWithContextReturns(result1 *s3.PutBucketTaggingOutput, result2 error) { - fake.putBucketTaggingWithContextMutex.Lock() - defer fake.putBucketTaggingWithContextMutex.Unlock() - fake.PutBucketTaggingWithContextStub = nil - fake.putBucketTaggingWithContextReturns = struct { - result1 *s3.PutBucketTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketTaggingWithContextReturnsOnCall(i int, result1 *s3.PutBucketTaggingOutput, result2 error) { - fake.putBucketTaggingWithContextMutex.Lock() - defer fake.putBucketTaggingWithContextMutex.Unlock() - fake.PutBucketTaggingWithContextStub = nil - if fake.putBucketTaggingWithContextReturnsOnCall == nil { - fake.putBucketTaggingWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketTaggingOutput - result2 error - }) - } - fake.putBucketTaggingWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketVersioning(arg1 *s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error) { - fake.putBucketVersioningMutex.Lock() - ret, specificReturn := fake.putBucketVersioningReturnsOnCall[len(fake.putBucketVersioningArgsForCall)] - fake.putBucketVersioningArgsForCall = append(fake.putBucketVersioningArgsForCall, struct { - arg1 *s3.PutBucketVersioningInput - }{arg1}) - stub := fake.PutBucketVersioningStub - fakeReturns := fake.putBucketVersioningReturns - fake.recordInvocation("PutBucketVersioning", []interface{}{arg1}) - fake.putBucketVersioningMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketVersioningCallCount() int { - fake.putBucketVersioningMutex.RLock() - defer fake.putBucketVersioningMutex.RUnlock() - return len(fake.putBucketVersioningArgsForCall) -} - -func (fake *FakeS3Client) PutBucketVersioningCalls(stub func(*s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error)) { - fake.putBucketVersioningMutex.Lock() - defer fake.putBucketVersioningMutex.Unlock() - fake.PutBucketVersioningStub = stub -} - -func (fake *FakeS3Client) PutBucketVersioningArgsForCall(i int) *s3.PutBucketVersioningInput { - fake.putBucketVersioningMutex.RLock() - defer fake.putBucketVersioningMutex.RUnlock() - argsForCall := fake.putBucketVersioningArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketVersioningReturns(result1 *s3.PutBucketVersioningOutput, result2 error) { - fake.putBucketVersioningMutex.Lock() - defer fake.putBucketVersioningMutex.Unlock() - fake.PutBucketVersioningStub = nil - fake.putBucketVersioningReturns = struct { - result1 *s3.PutBucketVersioningOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketVersioningReturnsOnCall(i int, result1 *s3.PutBucketVersioningOutput, result2 error) { - fake.putBucketVersioningMutex.Lock() - defer fake.putBucketVersioningMutex.Unlock() - fake.PutBucketVersioningStub = nil - if fake.putBucketVersioningReturnsOnCall == nil { - fake.putBucketVersioningReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketVersioningOutput - result2 error - }) - } - fake.putBucketVersioningReturnsOnCall[i] = struct { - result1 *s3.PutBucketVersioningOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketVersioningRequest(arg1 *s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput) { - fake.putBucketVersioningRequestMutex.Lock() - ret, specificReturn := fake.putBucketVersioningRequestReturnsOnCall[len(fake.putBucketVersioningRequestArgsForCall)] - fake.putBucketVersioningRequestArgsForCall = append(fake.putBucketVersioningRequestArgsForCall, struct { - arg1 *s3.PutBucketVersioningInput - }{arg1}) - stub := fake.PutBucketVersioningRequestStub - fakeReturns := fake.putBucketVersioningRequestReturns - fake.recordInvocation("PutBucketVersioningRequest", []interface{}{arg1}) - fake.putBucketVersioningRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketVersioningRequestCallCount() int { - fake.putBucketVersioningRequestMutex.RLock() - defer fake.putBucketVersioningRequestMutex.RUnlock() - return len(fake.putBucketVersioningRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketVersioningRequestCalls(stub func(*s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput)) { - fake.putBucketVersioningRequestMutex.Lock() - defer fake.putBucketVersioningRequestMutex.Unlock() - fake.PutBucketVersioningRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketVersioningRequestArgsForCall(i int) *s3.PutBucketVersioningInput { - fake.putBucketVersioningRequestMutex.RLock() - defer fake.putBucketVersioningRequestMutex.RUnlock() - argsForCall := fake.putBucketVersioningRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketVersioningRequestReturns(result1 *request.Request, result2 *s3.PutBucketVersioningOutput) { - fake.putBucketVersioningRequestMutex.Lock() - defer fake.putBucketVersioningRequestMutex.Unlock() - fake.PutBucketVersioningRequestStub = nil - fake.putBucketVersioningRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketVersioningOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketVersioningRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketVersioningOutput) { - fake.putBucketVersioningRequestMutex.Lock() - defer fake.putBucketVersioningRequestMutex.Unlock() - fake.PutBucketVersioningRequestStub = nil - if fake.putBucketVersioningRequestReturnsOnCall == nil { - fake.putBucketVersioningRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketVersioningOutput - }) - } - fake.putBucketVersioningRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketVersioningOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketVersioningWithContext(arg1 context.Context, arg2 *s3.PutBucketVersioningInput, arg3 ...request.Option) (*s3.PutBucketVersioningOutput, error) { - fake.putBucketVersioningWithContextMutex.Lock() - ret, specificReturn := fake.putBucketVersioningWithContextReturnsOnCall[len(fake.putBucketVersioningWithContextArgsForCall)] - fake.putBucketVersioningWithContextArgsForCall = append(fake.putBucketVersioningWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketVersioningInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketVersioningWithContextStub - fakeReturns := fake.putBucketVersioningWithContextReturns - fake.recordInvocation("PutBucketVersioningWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketVersioningWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketVersioningWithContextCallCount() int { - fake.putBucketVersioningWithContextMutex.RLock() - defer fake.putBucketVersioningWithContextMutex.RUnlock() - return len(fake.putBucketVersioningWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketVersioningWithContextCalls(stub func(context.Context, *s3.PutBucketVersioningInput, ...request.Option) (*s3.PutBucketVersioningOutput, error)) { - fake.putBucketVersioningWithContextMutex.Lock() - defer fake.putBucketVersioningWithContextMutex.Unlock() - fake.PutBucketVersioningWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketVersioningWithContextArgsForCall(i int) (context.Context, *s3.PutBucketVersioningInput, []request.Option) { - fake.putBucketVersioningWithContextMutex.RLock() - defer fake.putBucketVersioningWithContextMutex.RUnlock() - argsForCall := fake.putBucketVersioningWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketVersioningWithContextReturns(result1 *s3.PutBucketVersioningOutput, result2 error) { - fake.putBucketVersioningWithContextMutex.Lock() - defer fake.putBucketVersioningWithContextMutex.Unlock() - fake.PutBucketVersioningWithContextStub = nil - fake.putBucketVersioningWithContextReturns = struct { - result1 *s3.PutBucketVersioningOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketVersioningWithContextReturnsOnCall(i int, result1 *s3.PutBucketVersioningOutput, result2 error) { - fake.putBucketVersioningWithContextMutex.Lock() - defer fake.putBucketVersioningWithContextMutex.Unlock() - fake.PutBucketVersioningWithContextStub = nil - if fake.putBucketVersioningWithContextReturnsOnCall == nil { - fake.putBucketVersioningWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketVersioningOutput - result2 error - }) - } - fake.putBucketVersioningWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketVersioningOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketWebsite(arg1 *s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error) { - fake.putBucketWebsiteMutex.Lock() - ret, specificReturn := fake.putBucketWebsiteReturnsOnCall[len(fake.putBucketWebsiteArgsForCall)] - fake.putBucketWebsiteArgsForCall = append(fake.putBucketWebsiteArgsForCall, struct { - arg1 *s3.PutBucketWebsiteInput - }{arg1}) - stub := fake.PutBucketWebsiteStub - fakeReturns := fake.putBucketWebsiteReturns - fake.recordInvocation("PutBucketWebsite", []interface{}{arg1}) - fake.putBucketWebsiteMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketWebsiteCallCount() int { - fake.putBucketWebsiteMutex.RLock() - defer fake.putBucketWebsiteMutex.RUnlock() - return len(fake.putBucketWebsiteArgsForCall) -} - -func (fake *FakeS3Client) PutBucketWebsiteCalls(stub func(*s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error)) { - fake.putBucketWebsiteMutex.Lock() - defer fake.putBucketWebsiteMutex.Unlock() - fake.PutBucketWebsiteStub = stub -} - -func (fake *FakeS3Client) PutBucketWebsiteArgsForCall(i int) *s3.PutBucketWebsiteInput { - fake.putBucketWebsiteMutex.RLock() - defer fake.putBucketWebsiteMutex.RUnlock() - argsForCall := fake.putBucketWebsiteArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketWebsiteReturns(result1 *s3.PutBucketWebsiteOutput, result2 error) { - fake.putBucketWebsiteMutex.Lock() - defer fake.putBucketWebsiteMutex.Unlock() - fake.PutBucketWebsiteStub = nil - fake.putBucketWebsiteReturns = struct { - result1 *s3.PutBucketWebsiteOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketWebsiteReturnsOnCall(i int, result1 *s3.PutBucketWebsiteOutput, result2 error) { - fake.putBucketWebsiteMutex.Lock() - defer fake.putBucketWebsiteMutex.Unlock() - fake.PutBucketWebsiteStub = nil - if fake.putBucketWebsiteReturnsOnCall == nil { - fake.putBucketWebsiteReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketWebsiteOutput - result2 error - }) - } - fake.putBucketWebsiteReturnsOnCall[i] = struct { - result1 *s3.PutBucketWebsiteOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketWebsiteRequest(arg1 *s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput) { - fake.putBucketWebsiteRequestMutex.Lock() - ret, specificReturn := fake.putBucketWebsiteRequestReturnsOnCall[len(fake.putBucketWebsiteRequestArgsForCall)] - fake.putBucketWebsiteRequestArgsForCall = append(fake.putBucketWebsiteRequestArgsForCall, struct { - arg1 *s3.PutBucketWebsiteInput - }{arg1}) - stub := fake.PutBucketWebsiteRequestStub - fakeReturns := fake.putBucketWebsiteRequestReturns - fake.recordInvocation("PutBucketWebsiteRequest", []interface{}{arg1}) - fake.putBucketWebsiteRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketWebsiteRequestCallCount() int { - fake.putBucketWebsiteRequestMutex.RLock() - defer fake.putBucketWebsiteRequestMutex.RUnlock() - return len(fake.putBucketWebsiteRequestArgsForCall) -} - -func (fake *FakeS3Client) PutBucketWebsiteRequestCalls(stub func(*s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput)) { - fake.putBucketWebsiteRequestMutex.Lock() - defer fake.putBucketWebsiteRequestMutex.Unlock() - fake.PutBucketWebsiteRequestStub = stub -} - -func (fake *FakeS3Client) PutBucketWebsiteRequestArgsForCall(i int) *s3.PutBucketWebsiteInput { - fake.putBucketWebsiteRequestMutex.RLock() - defer fake.putBucketWebsiteRequestMutex.RUnlock() - argsForCall := fake.putBucketWebsiteRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutBucketWebsiteRequestReturns(result1 *request.Request, result2 *s3.PutBucketWebsiteOutput) { - fake.putBucketWebsiteRequestMutex.Lock() - defer fake.putBucketWebsiteRequestMutex.Unlock() - fake.PutBucketWebsiteRequestStub = nil - fake.putBucketWebsiteRequestReturns = struct { - result1 *request.Request - result2 *s3.PutBucketWebsiteOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketWebsiteRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutBucketWebsiteOutput) { - fake.putBucketWebsiteRequestMutex.Lock() - defer fake.putBucketWebsiteRequestMutex.Unlock() - fake.PutBucketWebsiteRequestStub = nil - if fake.putBucketWebsiteRequestReturnsOnCall == nil { - fake.putBucketWebsiteRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutBucketWebsiteOutput - }) - } - fake.putBucketWebsiteRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutBucketWebsiteOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketWebsiteWithContext(arg1 context.Context, arg2 *s3.PutBucketWebsiteInput, arg3 ...request.Option) (*s3.PutBucketWebsiteOutput, error) { - fake.putBucketWebsiteWithContextMutex.Lock() - ret, specificReturn := fake.putBucketWebsiteWithContextReturnsOnCall[len(fake.putBucketWebsiteWithContextArgsForCall)] - fake.putBucketWebsiteWithContextArgsForCall = append(fake.putBucketWebsiteWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutBucketWebsiteInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutBucketWebsiteWithContextStub - fakeReturns := fake.putBucketWebsiteWithContextReturns - fake.recordInvocation("PutBucketWebsiteWithContext", []interface{}{arg1, arg2, arg3}) - fake.putBucketWebsiteWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutBucketWebsiteWithContextCallCount() int { - fake.putBucketWebsiteWithContextMutex.RLock() - defer fake.putBucketWebsiteWithContextMutex.RUnlock() - return len(fake.putBucketWebsiteWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutBucketWebsiteWithContextCalls(stub func(context.Context, *s3.PutBucketWebsiteInput, ...request.Option) (*s3.PutBucketWebsiteOutput, error)) { - fake.putBucketWebsiteWithContextMutex.Lock() - defer fake.putBucketWebsiteWithContextMutex.Unlock() - fake.PutBucketWebsiteWithContextStub = stub -} - -func (fake *FakeS3Client) PutBucketWebsiteWithContextArgsForCall(i int) (context.Context, *s3.PutBucketWebsiteInput, []request.Option) { - fake.putBucketWebsiteWithContextMutex.RLock() - defer fake.putBucketWebsiteWithContextMutex.RUnlock() - argsForCall := fake.putBucketWebsiteWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutBucketWebsiteWithContextReturns(result1 *s3.PutBucketWebsiteOutput, result2 error) { - fake.putBucketWebsiteWithContextMutex.Lock() - defer fake.putBucketWebsiteWithContextMutex.Unlock() - fake.PutBucketWebsiteWithContextStub = nil - fake.putBucketWebsiteWithContextReturns = struct { - result1 *s3.PutBucketWebsiteOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutBucketWebsiteWithContextReturnsOnCall(i int, result1 *s3.PutBucketWebsiteOutput, result2 error) { - fake.putBucketWebsiteWithContextMutex.Lock() - defer fake.putBucketWebsiteWithContextMutex.Unlock() - fake.PutBucketWebsiteWithContextStub = nil - if fake.putBucketWebsiteWithContextReturnsOnCall == nil { - fake.putBucketWebsiteWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutBucketWebsiteOutput - result2 error - }) - } - fake.putBucketWebsiteWithContextReturnsOnCall[i] = struct { - result1 *s3.PutBucketWebsiteOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObject(arg1 *s3.PutObjectInput) (*s3.PutObjectOutput, error) { - fake.putObjectMutex.Lock() - ret, specificReturn := fake.putObjectReturnsOnCall[len(fake.putObjectArgsForCall)] - fake.putObjectArgsForCall = append(fake.putObjectArgsForCall, struct { - arg1 *s3.PutObjectInput - }{arg1}) - stub := fake.PutObjectStub - fakeReturns := fake.putObjectReturns - fake.recordInvocation("PutObject", []interface{}{arg1}) - fake.putObjectMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectCallCount() int { - fake.putObjectMutex.RLock() - defer fake.putObjectMutex.RUnlock() - return len(fake.putObjectArgsForCall) -} - -func (fake *FakeS3Client) PutObjectCalls(stub func(*s3.PutObjectInput) (*s3.PutObjectOutput, error)) { - fake.putObjectMutex.Lock() - defer fake.putObjectMutex.Unlock() - fake.PutObjectStub = stub -} - -func (fake *FakeS3Client) PutObjectArgsForCall(i int) *s3.PutObjectInput { - fake.putObjectMutex.RLock() - defer fake.putObjectMutex.RUnlock() - argsForCall := fake.putObjectArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutObjectReturns(result1 *s3.PutObjectOutput, result2 error) { - fake.putObjectMutex.Lock() - defer fake.putObjectMutex.Unlock() - fake.PutObjectStub = nil - fake.putObjectReturns = struct { - result1 *s3.PutObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectReturnsOnCall(i int, result1 *s3.PutObjectOutput, result2 error) { - fake.putObjectMutex.Lock() - defer fake.putObjectMutex.Unlock() - fake.PutObjectStub = nil - if fake.putObjectReturnsOnCall == nil { - fake.putObjectReturnsOnCall = make(map[int]struct { - result1 *s3.PutObjectOutput - result2 error - }) - } - fake.putObjectReturnsOnCall[i] = struct { - result1 *s3.PutObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectAcl(arg1 *s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error) { - fake.putObjectAclMutex.Lock() - ret, specificReturn := fake.putObjectAclReturnsOnCall[len(fake.putObjectAclArgsForCall)] - fake.putObjectAclArgsForCall = append(fake.putObjectAclArgsForCall, struct { - arg1 *s3.PutObjectAclInput - }{arg1}) - stub := fake.PutObjectAclStub - fakeReturns := fake.putObjectAclReturns - fake.recordInvocation("PutObjectAcl", []interface{}{arg1}) - fake.putObjectAclMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectAclCallCount() int { - fake.putObjectAclMutex.RLock() - defer fake.putObjectAclMutex.RUnlock() - return len(fake.putObjectAclArgsForCall) -} - -func (fake *FakeS3Client) PutObjectAclCalls(stub func(*s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error)) { - fake.putObjectAclMutex.Lock() - defer fake.putObjectAclMutex.Unlock() - fake.PutObjectAclStub = stub -} - -func (fake *FakeS3Client) PutObjectAclArgsForCall(i int) *s3.PutObjectAclInput { - fake.putObjectAclMutex.RLock() - defer fake.putObjectAclMutex.RUnlock() - argsForCall := fake.putObjectAclArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutObjectAclReturns(result1 *s3.PutObjectAclOutput, result2 error) { - fake.putObjectAclMutex.Lock() - defer fake.putObjectAclMutex.Unlock() - fake.PutObjectAclStub = nil - fake.putObjectAclReturns = struct { - result1 *s3.PutObjectAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectAclReturnsOnCall(i int, result1 *s3.PutObjectAclOutput, result2 error) { - fake.putObjectAclMutex.Lock() - defer fake.putObjectAclMutex.Unlock() - fake.PutObjectAclStub = nil - if fake.putObjectAclReturnsOnCall == nil { - fake.putObjectAclReturnsOnCall = make(map[int]struct { - result1 *s3.PutObjectAclOutput - result2 error - }) - } - fake.putObjectAclReturnsOnCall[i] = struct { - result1 *s3.PutObjectAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectAclRequest(arg1 *s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput) { - fake.putObjectAclRequestMutex.Lock() - ret, specificReturn := fake.putObjectAclRequestReturnsOnCall[len(fake.putObjectAclRequestArgsForCall)] - fake.putObjectAclRequestArgsForCall = append(fake.putObjectAclRequestArgsForCall, struct { - arg1 *s3.PutObjectAclInput - }{arg1}) - stub := fake.PutObjectAclRequestStub - fakeReturns := fake.putObjectAclRequestReturns - fake.recordInvocation("PutObjectAclRequest", []interface{}{arg1}) - fake.putObjectAclRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectAclRequestCallCount() int { - fake.putObjectAclRequestMutex.RLock() - defer fake.putObjectAclRequestMutex.RUnlock() - return len(fake.putObjectAclRequestArgsForCall) -} - -func (fake *FakeS3Client) PutObjectAclRequestCalls(stub func(*s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput)) { - fake.putObjectAclRequestMutex.Lock() - defer fake.putObjectAclRequestMutex.Unlock() - fake.PutObjectAclRequestStub = stub -} - -func (fake *FakeS3Client) PutObjectAclRequestArgsForCall(i int) *s3.PutObjectAclInput { - fake.putObjectAclRequestMutex.RLock() - defer fake.putObjectAclRequestMutex.RUnlock() - argsForCall := fake.putObjectAclRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutObjectAclRequestReturns(result1 *request.Request, result2 *s3.PutObjectAclOutput) { - fake.putObjectAclRequestMutex.Lock() - defer fake.putObjectAclRequestMutex.Unlock() - fake.PutObjectAclRequestStub = nil - fake.putObjectAclRequestReturns = struct { - result1 *request.Request - result2 *s3.PutObjectAclOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectAclRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutObjectAclOutput) { - fake.putObjectAclRequestMutex.Lock() - defer fake.putObjectAclRequestMutex.Unlock() - fake.PutObjectAclRequestStub = nil - if fake.putObjectAclRequestReturnsOnCall == nil { - fake.putObjectAclRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutObjectAclOutput - }) - } - fake.putObjectAclRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutObjectAclOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectAclWithContext(arg1 context.Context, arg2 *s3.PutObjectAclInput, arg3 ...request.Option) (*s3.PutObjectAclOutput, error) { - fake.putObjectAclWithContextMutex.Lock() - ret, specificReturn := fake.putObjectAclWithContextReturnsOnCall[len(fake.putObjectAclWithContextArgsForCall)] - fake.putObjectAclWithContextArgsForCall = append(fake.putObjectAclWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutObjectAclInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutObjectAclWithContextStub - fakeReturns := fake.putObjectAclWithContextReturns - fake.recordInvocation("PutObjectAclWithContext", []interface{}{arg1, arg2, arg3}) - fake.putObjectAclWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectAclWithContextCallCount() int { - fake.putObjectAclWithContextMutex.RLock() - defer fake.putObjectAclWithContextMutex.RUnlock() - return len(fake.putObjectAclWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutObjectAclWithContextCalls(stub func(context.Context, *s3.PutObjectAclInput, ...request.Option) (*s3.PutObjectAclOutput, error)) { - fake.putObjectAclWithContextMutex.Lock() - defer fake.putObjectAclWithContextMutex.Unlock() - fake.PutObjectAclWithContextStub = stub -} - -func (fake *FakeS3Client) PutObjectAclWithContextArgsForCall(i int) (context.Context, *s3.PutObjectAclInput, []request.Option) { - fake.putObjectAclWithContextMutex.RLock() - defer fake.putObjectAclWithContextMutex.RUnlock() - argsForCall := fake.putObjectAclWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutObjectAclWithContextReturns(result1 *s3.PutObjectAclOutput, result2 error) { - fake.putObjectAclWithContextMutex.Lock() - defer fake.putObjectAclWithContextMutex.Unlock() - fake.PutObjectAclWithContextStub = nil - fake.putObjectAclWithContextReturns = struct { - result1 *s3.PutObjectAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectAclWithContextReturnsOnCall(i int, result1 *s3.PutObjectAclOutput, result2 error) { - fake.putObjectAclWithContextMutex.Lock() - defer fake.putObjectAclWithContextMutex.Unlock() - fake.PutObjectAclWithContextStub = nil - if fake.putObjectAclWithContextReturnsOnCall == nil { - fake.putObjectAclWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutObjectAclOutput - result2 error - }) - } - fake.putObjectAclWithContextReturnsOnCall[i] = struct { - result1 *s3.PutObjectAclOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectLegalHold(arg1 *s3.PutObjectLegalHoldInput) (*s3.PutObjectLegalHoldOutput, error) { - fake.putObjectLegalHoldMutex.Lock() - ret, specificReturn := fake.putObjectLegalHoldReturnsOnCall[len(fake.putObjectLegalHoldArgsForCall)] - fake.putObjectLegalHoldArgsForCall = append(fake.putObjectLegalHoldArgsForCall, struct { - arg1 *s3.PutObjectLegalHoldInput - }{arg1}) - stub := fake.PutObjectLegalHoldStub - fakeReturns := fake.putObjectLegalHoldReturns - fake.recordInvocation("PutObjectLegalHold", []interface{}{arg1}) - fake.putObjectLegalHoldMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectLegalHoldCallCount() int { - fake.putObjectLegalHoldMutex.RLock() - defer fake.putObjectLegalHoldMutex.RUnlock() - return len(fake.putObjectLegalHoldArgsForCall) -} - -func (fake *FakeS3Client) PutObjectLegalHoldCalls(stub func(*s3.PutObjectLegalHoldInput) (*s3.PutObjectLegalHoldOutput, error)) { - fake.putObjectLegalHoldMutex.Lock() - defer fake.putObjectLegalHoldMutex.Unlock() - fake.PutObjectLegalHoldStub = stub -} - -func (fake *FakeS3Client) PutObjectLegalHoldArgsForCall(i int) *s3.PutObjectLegalHoldInput { - fake.putObjectLegalHoldMutex.RLock() - defer fake.putObjectLegalHoldMutex.RUnlock() - argsForCall := fake.putObjectLegalHoldArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutObjectLegalHoldReturns(result1 *s3.PutObjectLegalHoldOutput, result2 error) { - fake.putObjectLegalHoldMutex.Lock() - defer fake.putObjectLegalHoldMutex.Unlock() - fake.PutObjectLegalHoldStub = nil - fake.putObjectLegalHoldReturns = struct { - result1 *s3.PutObjectLegalHoldOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectLegalHoldReturnsOnCall(i int, result1 *s3.PutObjectLegalHoldOutput, result2 error) { - fake.putObjectLegalHoldMutex.Lock() - defer fake.putObjectLegalHoldMutex.Unlock() - fake.PutObjectLegalHoldStub = nil - if fake.putObjectLegalHoldReturnsOnCall == nil { - fake.putObjectLegalHoldReturnsOnCall = make(map[int]struct { - result1 *s3.PutObjectLegalHoldOutput - result2 error - }) - } - fake.putObjectLegalHoldReturnsOnCall[i] = struct { - result1 *s3.PutObjectLegalHoldOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectLegalHoldRequest(arg1 *s3.PutObjectLegalHoldInput) (*request.Request, *s3.PutObjectLegalHoldOutput) { - fake.putObjectLegalHoldRequestMutex.Lock() - ret, specificReturn := fake.putObjectLegalHoldRequestReturnsOnCall[len(fake.putObjectLegalHoldRequestArgsForCall)] - fake.putObjectLegalHoldRequestArgsForCall = append(fake.putObjectLegalHoldRequestArgsForCall, struct { - arg1 *s3.PutObjectLegalHoldInput - }{arg1}) - stub := fake.PutObjectLegalHoldRequestStub - fakeReturns := fake.putObjectLegalHoldRequestReturns - fake.recordInvocation("PutObjectLegalHoldRequest", []interface{}{arg1}) - fake.putObjectLegalHoldRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectLegalHoldRequestCallCount() int { - fake.putObjectLegalHoldRequestMutex.RLock() - defer fake.putObjectLegalHoldRequestMutex.RUnlock() - return len(fake.putObjectLegalHoldRequestArgsForCall) -} - -func (fake *FakeS3Client) PutObjectLegalHoldRequestCalls(stub func(*s3.PutObjectLegalHoldInput) (*request.Request, *s3.PutObjectLegalHoldOutput)) { - fake.putObjectLegalHoldRequestMutex.Lock() - defer fake.putObjectLegalHoldRequestMutex.Unlock() - fake.PutObjectLegalHoldRequestStub = stub -} - -func (fake *FakeS3Client) PutObjectLegalHoldRequestArgsForCall(i int) *s3.PutObjectLegalHoldInput { - fake.putObjectLegalHoldRequestMutex.RLock() - defer fake.putObjectLegalHoldRequestMutex.RUnlock() - argsForCall := fake.putObjectLegalHoldRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutObjectLegalHoldRequestReturns(result1 *request.Request, result2 *s3.PutObjectLegalHoldOutput) { - fake.putObjectLegalHoldRequestMutex.Lock() - defer fake.putObjectLegalHoldRequestMutex.Unlock() - fake.PutObjectLegalHoldRequestStub = nil - fake.putObjectLegalHoldRequestReturns = struct { - result1 *request.Request - result2 *s3.PutObjectLegalHoldOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectLegalHoldRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutObjectLegalHoldOutput) { - fake.putObjectLegalHoldRequestMutex.Lock() - defer fake.putObjectLegalHoldRequestMutex.Unlock() - fake.PutObjectLegalHoldRequestStub = nil - if fake.putObjectLegalHoldRequestReturnsOnCall == nil { - fake.putObjectLegalHoldRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutObjectLegalHoldOutput - }) - } - fake.putObjectLegalHoldRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutObjectLegalHoldOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectLegalHoldWithContext(arg1 context.Context, arg2 *s3.PutObjectLegalHoldInput, arg3 ...request.Option) (*s3.PutObjectLegalHoldOutput, error) { - fake.putObjectLegalHoldWithContextMutex.Lock() - ret, specificReturn := fake.putObjectLegalHoldWithContextReturnsOnCall[len(fake.putObjectLegalHoldWithContextArgsForCall)] - fake.putObjectLegalHoldWithContextArgsForCall = append(fake.putObjectLegalHoldWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutObjectLegalHoldInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutObjectLegalHoldWithContextStub - fakeReturns := fake.putObjectLegalHoldWithContextReturns - fake.recordInvocation("PutObjectLegalHoldWithContext", []interface{}{arg1, arg2, arg3}) - fake.putObjectLegalHoldWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectLegalHoldWithContextCallCount() int { - fake.putObjectLegalHoldWithContextMutex.RLock() - defer fake.putObjectLegalHoldWithContextMutex.RUnlock() - return len(fake.putObjectLegalHoldWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutObjectLegalHoldWithContextCalls(stub func(context.Context, *s3.PutObjectLegalHoldInput, ...request.Option) (*s3.PutObjectLegalHoldOutput, error)) { - fake.putObjectLegalHoldWithContextMutex.Lock() - defer fake.putObjectLegalHoldWithContextMutex.Unlock() - fake.PutObjectLegalHoldWithContextStub = stub -} - -func (fake *FakeS3Client) PutObjectLegalHoldWithContextArgsForCall(i int) (context.Context, *s3.PutObjectLegalHoldInput, []request.Option) { - fake.putObjectLegalHoldWithContextMutex.RLock() - defer fake.putObjectLegalHoldWithContextMutex.RUnlock() - argsForCall := fake.putObjectLegalHoldWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutObjectLegalHoldWithContextReturns(result1 *s3.PutObjectLegalHoldOutput, result2 error) { - fake.putObjectLegalHoldWithContextMutex.Lock() - defer fake.putObjectLegalHoldWithContextMutex.Unlock() - fake.PutObjectLegalHoldWithContextStub = nil - fake.putObjectLegalHoldWithContextReturns = struct { - result1 *s3.PutObjectLegalHoldOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectLegalHoldWithContextReturnsOnCall(i int, result1 *s3.PutObjectLegalHoldOutput, result2 error) { - fake.putObjectLegalHoldWithContextMutex.Lock() - defer fake.putObjectLegalHoldWithContextMutex.Unlock() - fake.PutObjectLegalHoldWithContextStub = nil - if fake.putObjectLegalHoldWithContextReturnsOnCall == nil { - fake.putObjectLegalHoldWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutObjectLegalHoldOutput - result2 error - }) - } - fake.putObjectLegalHoldWithContextReturnsOnCall[i] = struct { - result1 *s3.PutObjectLegalHoldOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectLockConfiguration(arg1 *s3.PutObjectLockConfigurationInput) (*s3.PutObjectLockConfigurationOutput, error) { - fake.putObjectLockConfigurationMutex.Lock() - ret, specificReturn := fake.putObjectLockConfigurationReturnsOnCall[len(fake.putObjectLockConfigurationArgsForCall)] - fake.putObjectLockConfigurationArgsForCall = append(fake.putObjectLockConfigurationArgsForCall, struct { - arg1 *s3.PutObjectLockConfigurationInput - }{arg1}) - stub := fake.PutObjectLockConfigurationStub - fakeReturns := fake.putObjectLockConfigurationReturns - fake.recordInvocation("PutObjectLockConfiguration", []interface{}{arg1}) - fake.putObjectLockConfigurationMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectLockConfigurationCallCount() int { - fake.putObjectLockConfigurationMutex.RLock() - defer fake.putObjectLockConfigurationMutex.RUnlock() - return len(fake.putObjectLockConfigurationArgsForCall) -} - -func (fake *FakeS3Client) PutObjectLockConfigurationCalls(stub func(*s3.PutObjectLockConfigurationInput) (*s3.PutObjectLockConfigurationOutput, error)) { - fake.putObjectLockConfigurationMutex.Lock() - defer fake.putObjectLockConfigurationMutex.Unlock() - fake.PutObjectLockConfigurationStub = stub -} - -func (fake *FakeS3Client) PutObjectLockConfigurationArgsForCall(i int) *s3.PutObjectLockConfigurationInput { - fake.putObjectLockConfigurationMutex.RLock() - defer fake.putObjectLockConfigurationMutex.RUnlock() - argsForCall := fake.putObjectLockConfigurationArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutObjectLockConfigurationReturns(result1 *s3.PutObjectLockConfigurationOutput, result2 error) { - fake.putObjectLockConfigurationMutex.Lock() - defer fake.putObjectLockConfigurationMutex.Unlock() - fake.PutObjectLockConfigurationStub = nil - fake.putObjectLockConfigurationReturns = struct { - result1 *s3.PutObjectLockConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectLockConfigurationReturnsOnCall(i int, result1 *s3.PutObjectLockConfigurationOutput, result2 error) { - fake.putObjectLockConfigurationMutex.Lock() - defer fake.putObjectLockConfigurationMutex.Unlock() - fake.PutObjectLockConfigurationStub = nil - if fake.putObjectLockConfigurationReturnsOnCall == nil { - fake.putObjectLockConfigurationReturnsOnCall = make(map[int]struct { - result1 *s3.PutObjectLockConfigurationOutput - result2 error - }) - } - fake.putObjectLockConfigurationReturnsOnCall[i] = struct { - result1 *s3.PutObjectLockConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectLockConfigurationRequest(arg1 *s3.PutObjectLockConfigurationInput) (*request.Request, *s3.PutObjectLockConfigurationOutput) { - fake.putObjectLockConfigurationRequestMutex.Lock() - ret, specificReturn := fake.putObjectLockConfigurationRequestReturnsOnCall[len(fake.putObjectLockConfigurationRequestArgsForCall)] - fake.putObjectLockConfigurationRequestArgsForCall = append(fake.putObjectLockConfigurationRequestArgsForCall, struct { - arg1 *s3.PutObjectLockConfigurationInput - }{arg1}) - stub := fake.PutObjectLockConfigurationRequestStub - fakeReturns := fake.putObjectLockConfigurationRequestReturns - fake.recordInvocation("PutObjectLockConfigurationRequest", []interface{}{arg1}) - fake.putObjectLockConfigurationRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectLockConfigurationRequestCallCount() int { - fake.putObjectLockConfigurationRequestMutex.RLock() - defer fake.putObjectLockConfigurationRequestMutex.RUnlock() - return len(fake.putObjectLockConfigurationRequestArgsForCall) -} - -func (fake *FakeS3Client) PutObjectLockConfigurationRequestCalls(stub func(*s3.PutObjectLockConfigurationInput) (*request.Request, *s3.PutObjectLockConfigurationOutput)) { - fake.putObjectLockConfigurationRequestMutex.Lock() - defer fake.putObjectLockConfigurationRequestMutex.Unlock() - fake.PutObjectLockConfigurationRequestStub = stub -} - -func (fake *FakeS3Client) PutObjectLockConfigurationRequestArgsForCall(i int) *s3.PutObjectLockConfigurationInput { - fake.putObjectLockConfigurationRequestMutex.RLock() - defer fake.putObjectLockConfigurationRequestMutex.RUnlock() - argsForCall := fake.putObjectLockConfigurationRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutObjectLockConfigurationRequestReturns(result1 *request.Request, result2 *s3.PutObjectLockConfigurationOutput) { - fake.putObjectLockConfigurationRequestMutex.Lock() - defer fake.putObjectLockConfigurationRequestMutex.Unlock() - fake.PutObjectLockConfigurationRequestStub = nil - fake.putObjectLockConfigurationRequestReturns = struct { - result1 *request.Request - result2 *s3.PutObjectLockConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectLockConfigurationRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutObjectLockConfigurationOutput) { - fake.putObjectLockConfigurationRequestMutex.Lock() - defer fake.putObjectLockConfigurationRequestMutex.Unlock() - fake.PutObjectLockConfigurationRequestStub = nil - if fake.putObjectLockConfigurationRequestReturnsOnCall == nil { - fake.putObjectLockConfigurationRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutObjectLockConfigurationOutput - }) - } - fake.putObjectLockConfigurationRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutObjectLockConfigurationOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectLockConfigurationWithContext(arg1 context.Context, arg2 *s3.PutObjectLockConfigurationInput, arg3 ...request.Option) (*s3.PutObjectLockConfigurationOutput, error) { - fake.putObjectLockConfigurationWithContextMutex.Lock() - ret, specificReturn := fake.putObjectLockConfigurationWithContextReturnsOnCall[len(fake.putObjectLockConfigurationWithContextArgsForCall)] - fake.putObjectLockConfigurationWithContextArgsForCall = append(fake.putObjectLockConfigurationWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutObjectLockConfigurationInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutObjectLockConfigurationWithContextStub - fakeReturns := fake.putObjectLockConfigurationWithContextReturns - fake.recordInvocation("PutObjectLockConfigurationWithContext", []interface{}{arg1, arg2, arg3}) - fake.putObjectLockConfigurationWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectLockConfigurationWithContextCallCount() int { - fake.putObjectLockConfigurationWithContextMutex.RLock() - defer fake.putObjectLockConfigurationWithContextMutex.RUnlock() - return len(fake.putObjectLockConfigurationWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutObjectLockConfigurationWithContextCalls(stub func(context.Context, *s3.PutObjectLockConfigurationInput, ...request.Option) (*s3.PutObjectLockConfigurationOutput, error)) { - fake.putObjectLockConfigurationWithContextMutex.Lock() - defer fake.putObjectLockConfigurationWithContextMutex.Unlock() - fake.PutObjectLockConfigurationWithContextStub = stub -} - -func (fake *FakeS3Client) PutObjectLockConfigurationWithContextArgsForCall(i int) (context.Context, *s3.PutObjectLockConfigurationInput, []request.Option) { - fake.putObjectLockConfigurationWithContextMutex.RLock() - defer fake.putObjectLockConfigurationWithContextMutex.RUnlock() - argsForCall := fake.putObjectLockConfigurationWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutObjectLockConfigurationWithContextReturns(result1 *s3.PutObjectLockConfigurationOutput, result2 error) { - fake.putObjectLockConfigurationWithContextMutex.Lock() - defer fake.putObjectLockConfigurationWithContextMutex.Unlock() - fake.PutObjectLockConfigurationWithContextStub = nil - fake.putObjectLockConfigurationWithContextReturns = struct { - result1 *s3.PutObjectLockConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectLockConfigurationWithContextReturnsOnCall(i int, result1 *s3.PutObjectLockConfigurationOutput, result2 error) { - fake.putObjectLockConfigurationWithContextMutex.Lock() - defer fake.putObjectLockConfigurationWithContextMutex.Unlock() - fake.PutObjectLockConfigurationWithContextStub = nil - if fake.putObjectLockConfigurationWithContextReturnsOnCall == nil { - fake.putObjectLockConfigurationWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutObjectLockConfigurationOutput - result2 error - }) - } - fake.putObjectLockConfigurationWithContextReturnsOnCall[i] = struct { - result1 *s3.PutObjectLockConfigurationOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectRequest(arg1 *s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput) { - fake.putObjectRequestMutex.Lock() - ret, specificReturn := fake.putObjectRequestReturnsOnCall[len(fake.putObjectRequestArgsForCall)] - fake.putObjectRequestArgsForCall = append(fake.putObjectRequestArgsForCall, struct { - arg1 *s3.PutObjectInput - }{arg1}) - stub := fake.PutObjectRequestStub - fakeReturns := fake.putObjectRequestReturns - fake.recordInvocation("PutObjectRequest", []interface{}{arg1}) - fake.putObjectRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectRequestCallCount() int { - fake.putObjectRequestMutex.RLock() - defer fake.putObjectRequestMutex.RUnlock() - return len(fake.putObjectRequestArgsForCall) -} - -func (fake *FakeS3Client) PutObjectRequestCalls(stub func(*s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput)) { - fake.putObjectRequestMutex.Lock() - defer fake.putObjectRequestMutex.Unlock() - fake.PutObjectRequestStub = stub -} - -func (fake *FakeS3Client) PutObjectRequestArgsForCall(i int) *s3.PutObjectInput { - fake.putObjectRequestMutex.RLock() - defer fake.putObjectRequestMutex.RUnlock() - argsForCall := fake.putObjectRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutObjectRequestReturns(result1 *request.Request, result2 *s3.PutObjectOutput) { - fake.putObjectRequestMutex.Lock() - defer fake.putObjectRequestMutex.Unlock() - fake.PutObjectRequestStub = nil - fake.putObjectRequestReturns = struct { - result1 *request.Request - result2 *s3.PutObjectOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutObjectOutput) { - fake.putObjectRequestMutex.Lock() - defer fake.putObjectRequestMutex.Unlock() - fake.PutObjectRequestStub = nil - if fake.putObjectRequestReturnsOnCall == nil { - fake.putObjectRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutObjectOutput - }) - } - fake.putObjectRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutObjectOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectRetention(arg1 *s3.PutObjectRetentionInput) (*s3.PutObjectRetentionOutput, error) { - fake.putObjectRetentionMutex.Lock() - ret, specificReturn := fake.putObjectRetentionReturnsOnCall[len(fake.putObjectRetentionArgsForCall)] - fake.putObjectRetentionArgsForCall = append(fake.putObjectRetentionArgsForCall, struct { - arg1 *s3.PutObjectRetentionInput - }{arg1}) - stub := fake.PutObjectRetentionStub - fakeReturns := fake.putObjectRetentionReturns - fake.recordInvocation("PutObjectRetention", []interface{}{arg1}) - fake.putObjectRetentionMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectRetentionCallCount() int { - fake.putObjectRetentionMutex.RLock() - defer fake.putObjectRetentionMutex.RUnlock() - return len(fake.putObjectRetentionArgsForCall) -} - -func (fake *FakeS3Client) PutObjectRetentionCalls(stub func(*s3.PutObjectRetentionInput) (*s3.PutObjectRetentionOutput, error)) { - fake.putObjectRetentionMutex.Lock() - defer fake.putObjectRetentionMutex.Unlock() - fake.PutObjectRetentionStub = stub -} - -func (fake *FakeS3Client) PutObjectRetentionArgsForCall(i int) *s3.PutObjectRetentionInput { - fake.putObjectRetentionMutex.RLock() - defer fake.putObjectRetentionMutex.RUnlock() - argsForCall := fake.putObjectRetentionArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutObjectRetentionReturns(result1 *s3.PutObjectRetentionOutput, result2 error) { - fake.putObjectRetentionMutex.Lock() - defer fake.putObjectRetentionMutex.Unlock() - fake.PutObjectRetentionStub = nil - fake.putObjectRetentionReturns = struct { - result1 *s3.PutObjectRetentionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectRetentionReturnsOnCall(i int, result1 *s3.PutObjectRetentionOutput, result2 error) { - fake.putObjectRetentionMutex.Lock() - defer fake.putObjectRetentionMutex.Unlock() - fake.PutObjectRetentionStub = nil - if fake.putObjectRetentionReturnsOnCall == nil { - fake.putObjectRetentionReturnsOnCall = make(map[int]struct { - result1 *s3.PutObjectRetentionOutput - result2 error - }) - } - fake.putObjectRetentionReturnsOnCall[i] = struct { - result1 *s3.PutObjectRetentionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectRetentionRequest(arg1 *s3.PutObjectRetentionInput) (*request.Request, *s3.PutObjectRetentionOutput) { - fake.putObjectRetentionRequestMutex.Lock() - ret, specificReturn := fake.putObjectRetentionRequestReturnsOnCall[len(fake.putObjectRetentionRequestArgsForCall)] - fake.putObjectRetentionRequestArgsForCall = append(fake.putObjectRetentionRequestArgsForCall, struct { - arg1 *s3.PutObjectRetentionInput - }{arg1}) - stub := fake.PutObjectRetentionRequestStub - fakeReturns := fake.putObjectRetentionRequestReturns - fake.recordInvocation("PutObjectRetentionRequest", []interface{}{arg1}) - fake.putObjectRetentionRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectRetentionRequestCallCount() int { - fake.putObjectRetentionRequestMutex.RLock() - defer fake.putObjectRetentionRequestMutex.RUnlock() - return len(fake.putObjectRetentionRequestArgsForCall) -} - -func (fake *FakeS3Client) PutObjectRetentionRequestCalls(stub func(*s3.PutObjectRetentionInput) (*request.Request, *s3.PutObjectRetentionOutput)) { - fake.putObjectRetentionRequestMutex.Lock() - defer fake.putObjectRetentionRequestMutex.Unlock() - fake.PutObjectRetentionRequestStub = stub -} - -func (fake *FakeS3Client) PutObjectRetentionRequestArgsForCall(i int) *s3.PutObjectRetentionInput { - fake.putObjectRetentionRequestMutex.RLock() - defer fake.putObjectRetentionRequestMutex.RUnlock() - argsForCall := fake.putObjectRetentionRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutObjectRetentionRequestReturns(result1 *request.Request, result2 *s3.PutObjectRetentionOutput) { - fake.putObjectRetentionRequestMutex.Lock() - defer fake.putObjectRetentionRequestMutex.Unlock() - fake.PutObjectRetentionRequestStub = nil - fake.putObjectRetentionRequestReturns = struct { - result1 *request.Request - result2 *s3.PutObjectRetentionOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectRetentionRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutObjectRetentionOutput) { - fake.putObjectRetentionRequestMutex.Lock() - defer fake.putObjectRetentionRequestMutex.Unlock() - fake.PutObjectRetentionRequestStub = nil - if fake.putObjectRetentionRequestReturnsOnCall == nil { - fake.putObjectRetentionRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutObjectRetentionOutput - }) - } - fake.putObjectRetentionRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutObjectRetentionOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectRetentionWithContext(arg1 context.Context, arg2 *s3.PutObjectRetentionInput, arg3 ...request.Option) (*s3.PutObjectRetentionOutput, error) { - fake.putObjectRetentionWithContextMutex.Lock() - ret, specificReturn := fake.putObjectRetentionWithContextReturnsOnCall[len(fake.putObjectRetentionWithContextArgsForCall)] - fake.putObjectRetentionWithContextArgsForCall = append(fake.putObjectRetentionWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutObjectRetentionInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutObjectRetentionWithContextStub - fakeReturns := fake.putObjectRetentionWithContextReturns - fake.recordInvocation("PutObjectRetentionWithContext", []interface{}{arg1, arg2, arg3}) - fake.putObjectRetentionWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectRetentionWithContextCallCount() int { - fake.putObjectRetentionWithContextMutex.RLock() - defer fake.putObjectRetentionWithContextMutex.RUnlock() - return len(fake.putObjectRetentionWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutObjectRetentionWithContextCalls(stub func(context.Context, *s3.PutObjectRetentionInput, ...request.Option) (*s3.PutObjectRetentionOutput, error)) { - fake.putObjectRetentionWithContextMutex.Lock() - defer fake.putObjectRetentionWithContextMutex.Unlock() - fake.PutObjectRetentionWithContextStub = stub -} - -func (fake *FakeS3Client) PutObjectRetentionWithContextArgsForCall(i int) (context.Context, *s3.PutObjectRetentionInput, []request.Option) { - fake.putObjectRetentionWithContextMutex.RLock() - defer fake.putObjectRetentionWithContextMutex.RUnlock() - argsForCall := fake.putObjectRetentionWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutObjectRetentionWithContextReturns(result1 *s3.PutObjectRetentionOutput, result2 error) { - fake.putObjectRetentionWithContextMutex.Lock() - defer fake.putObjectRetentionWithContextMutex.Unlock() - fake.PutObjectRetentionWithContextStub = nil - fake.putObjectRetentionWithContextReturns = struct { - result1 *s3.PutObjectRetentionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectRetentionWithContextReturnsOnCall(i int, result1 *s3.PutObjectRetentionOutput, result2 error) { - fake.putObjectRetentionWithContextMutex.Lock() - defer fake.putObjectRetentionWithContextMutex.Unlock() - fake.PutObjectRetentionWithContextStub = nil - if fake.putObjectRetentionWithContextReturnsOnCall == nil { - fake.putObjectRetentionWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutObjectRetentionOutput - result2 error - }) - } - fake.putObjectRetentionWithContextReturnsOnCall[i] = struct { - result1 *s3.PutObjectRetentionOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectTagging(arg1 *s3.PutObjectTaggingInput) (*s3.PutObjectTaggingOutput, error) { - fake.putObjectTaggingMutex.Lock() - ret, specificReturn := fake.putObjectTaggingReturnsOnCall[len(fake.putObjectTaggingArgsForCall)] - fake.putObjectTaggingArgsForCall = append(fake.putObjectTaggingArgsForCall, struct { - arg1 *s3.PutObjectTaggingInput - }{arg1}) - stub := fake.PutObjectTaggingStub - fakeReturns := fake.putObjectTaggingReturns - fake.recordInvocation("PutObjectTagging", []interface{}{arg1}) - fake.putObjectTaggingMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectTaggingCallCount() int { - fake.putObjectTaggingMutex.RLock() - defer fake.putObjectTaggingMutex.RUnlock() - return len(fake.putObjectTaggingArgsForCall) -} - -func (fake *FakeS3Client) PutObjectTaggingCalls(stub func(*s3.PutObjectTaggingInput) (*s3.PutObjectTaggingOutput, error)) { - fake.putObjectTaggingMutex.Lock() - defer fake.putObjectTaggingMutex.Unlock() - fake.PutObjectTaggingStub = stub -} - -func (fake *FakeS3Client) PutObjectTaggingArgsForCall(i int) *s3.PutObjectTaggingInput { - fake.putObjectTaggingMutex.RLock() - defer fake.putObjectTaggingMutex.RUnlock() - argsForCall := fake.putObjectTaggingArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutObjectTaggingReturns(result1 *s3.PutObjectTaggingOutput, result2 error) { - fake.putObjectTaggingMutex.Lock() - defer fake.putObjectTaggingMutex.Unlock() - fake.PutObjectTaggingStub = nil - fake.putObjectTaggingReturns = struct { - result1 *s3.PutObjectTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectTaggingReturnsOnCall(i int, result1 *s3.PutObjectTaggingOutput, result2 error) { - fake.putObjectTaggingMutex.Lock() - defer fake.putObjectTaggingMutex.Unlock() - fake.PutObjectTaggingStub = nil - if fake.putObjectTaggingReturnsOnCall == nil { - fake.putObjectTaggingReturnsOnCall = make(map[int]struct { - result1 *s3.PutObjectTaggingOutput - result2 error - }) - } - fake.putObjectTaggingReturnsOnCall[i] = struct { - result1 *s3.PutObjectTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectTaggingRequest(arg1 *s3.PutObjectTaggingInput) (*request.Request, *s3.PutObjectTaggingOutput) { - fake.putObjectTaggingRequestMutex.Lock() - ret, specificReturn := fake.putObjectTaggingRequestReturnsOnCall[len(fake.putObjectTaggingRequestArgsForCall)] - fake.putObjectTaggingRequestArgsForCall = append(fake.putObjectTaggingRequestArgsForCall, struct { - arg1 *s3.PutObjectTaggingInput - }{arg1}) - stub := fake.PutObjectTaggingRequestStub - fakeReturns := fake.putObjectTaggingRequestReturns - fake.recordInvocation("PutObjectTaggingRequest", []interface{}{arg1}) - fake.putObjectTaggingRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectTaggingRequestCallCount() int { - fake.putObjectTaggingRequestMutex.RLock() - defer fake.putObjectTaggingRequestMutex.RUnlock() - return len(fake.putObjectTaggingRequestArgsForCall) -} - -func (fake *FakeS3Client) PutObjectTaggingRequestCalls(stub func(*s3.PutObjectTaggingInput) (*request.Request, *s3.PutObjectTaggingOutput)) { - fake.putObjectTaggingRequestMutex.Lock() - defer fake.putObjectTaggingRequestMutex.Unlock() - fake.PutObjectTaggingRequestStub = stub -} - -func (fake *FakeS3Client) PutObjectTaggingRequestArgsForCall(i int) *s3.PutObjectTaggingInput { - fake.putObjectTaggingRequestMutex.RLock() - defer fake.putObjectTaggingRequestMutex.RUnlock() - argsForCall := fake.putObjectTaggingRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutObjectTaggingRequestReturns(result1 *request.Request, result2 *s3.PutObjectTaggingOutput) { - fake.putObjectTaggingRequestMutex.Lock() - defer fake.putObjectTaggingRequestMutex.Unlock() - fake.PutObjectTaggingRequestStub = nil - fake.putObjectTaggingRequestReturns = struct { - result1 *request.Request - result2 *s3.PutObjectTaggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectTaggingRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutObjectTaggingOutput) { - fake.putObjectTaggingRequestMutex.Lock() - defer fake.putObjectTaggingRequestMutex.Unlock() - fake.PutObjectTaggingRequestStub = nil - if fake.putObjectTaggingRequestReturnsOnCall == nil { - fake.putObjectTaggingRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutObjectTaggingOutput - }) - } - fake.putObjectTaggingRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutObjectTaggingOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectTaggingWithContext(arg1 context.Context, arg2 *s3.PutObjectTaggingInput, arg3 ...request.Option) (*s3.PutObjectTaggingOutput, error) { - fake.putObjectTaggingWithContextMutex.Lock() - ret, specificReturn := fake.putObjectTaggingWithContextReturnsOnCall[len(fake.putObjectTaggingWithContextArgsForCall)] - fake.putObjectTaggingWithContextArgsForCall = append(fake.putObjectTaggingWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutObjectTaggingInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutObjectTaggingWithContextStub - fakeReturns := fake.putObjectTaggingWithContextReturns - fake.recordInvocation("PutObjectTaggingWithContext", []interface{}{arg1, arg2, arg3}) - fake.putObjectTaggingWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectTaggingWithContextCallCount() int { - fake.putObjectTaggingWithContextMutex.RLock() - defer fake.putObjectTaggingWithContextMutex.RUnlock() - return len(fake.putObjectTaggingWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutObjectTaggingWithContextCalls(stub func(context.Context, *s3.PutObjectTaggingInput, ...request.Option) (*s3.PutObjectTaggingOutput, error)) { - fake.putObjectTaggingWithContextMutex.Lock() - defer fake.putObjectTaggingWithContextMutex.Unlock() - fake.PutObjectTaggingWithContextStub = stub -} - -func (fake *FakeS3Client) PutObjectTaggingWithContextArgsForCall(i int) (context.Context, *s3.PutObjectTaggingInput, []request.Option) { - fake.putObjectTaggingWithContextMutex.RLock() - defer fake.putObjectTaggingWithContextMutex.RUnlock() - argsForCall := fake.putObjectTaggingWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutObjectTaggingWithContextReturns(result1 *s3.PutObjectTaggingOutput, result2 error) { - fake.putObjectTaggingWithContextMutex.Lock() - defer fake.putObjectTaggingWithContextMutex.Unlock() - fake.PutObjectTaggingWithContextStub = nil - fake.putObjectTaggingWithContextReturns = struct { - result1 *s3.PutObjectTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectTaggingWithContextReturnsOnCall(i int, result1 *s3.PutObjectTaggingOutput, result2 error) { - fake.putObjectTaggingWithContextMutex.Lock() - defer fake.putObjectTaggingWithContextMutex.Unlock() - fake.PutObjectTaggingWithContextStub = nil - if fake.putObjectTaggingWithContextReturnsOnCall == nil { - fake.putObjectTaggingWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutObjectTaggingOutput - result2 error - }) - } - fake.putObjectTaggingWithContextReturnsOnCall[i] = struct { - result1 *s3.PutObjectTaggingOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectWithContext(arg1 context.Context, arg2 *s3.PutObjectInput, arg3 ...request.Option) (*s3.PutObjectOutput, error) { - fake.putObjectWithContextMutex.Lock() - ret, specificReturn := fake.putObjectWithContextReturnsOnCall[len(fake.putObjectWithContextArgsForCall)] - fake.putObjectWithContextArgsForCall = append(fake.putObjectWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutObjectInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutObjectWithContextStub - fakeReturns := fake.putObjectWithContextReturns - fake.recordInvocation("PutObjectWithContext", []interface{}{arg1, arg2, arg3}) - fake.putObjectWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutObjectWithContextCallCount() int { - fake.putObjectWithContextMutex.RLock() - defer fake.putObjectWithContextMutex.RUnlock() - return len(fake.putObjectWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutObjectWithContextCalls(stub func(context.Context, *s3.PutObjectInput, ...request.Option) (*s3.PutObjectOutput, error)) { - fake.putObjectWithContextMutex.Lock() - defer fake.putObjectWithContextMutex.Unlock() - fake.PutObjectWithContextStub = stub -} - -func (fake *FakeS3Client) PutObjectWithContextArgsForCall(i int) (context.Context, *s3.PutObjectInput, []request.Option) { - fake.putObjectWithContextMutex.RLock() - defer fake.putObjectWithContextMutex.RUnlock() - argsForCall := fake.putObjectWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutObjectWithContextReturns(result1 *s3.PutObjectOutput, result2 error) { - fake.putObjectWithContextMutex.Lock() - defer fake.putObjectWithContextMutex.Unlock() - fake.PutObjectWithContextStub = nil - fake.putObjectWithContextReturns = struct { - result1 *s3.PutObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutObjectWithContextReturnsOnCall(i int, result1 *s3.PutObjectOutput, result2 error) { - fake.putObjectWithContextMutex.Lock() - defer fake.putObjectWithContextMutex.Unlock() - fake.PutObjectWithContextStub = nil - if fake.putObjectWithContextReturnsOnCall == nil { - fake.putObjectWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutObjectOutput - result2 error - }) - } - fake.putObjectWithContextReturnsOnCall[i] = struct { - result1 *s3.PutObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutPublicAccessBlock(arg1 *s3.PutPublicAccessBlockInput) (*s3.PutPublicAccessBlockOutput, error) { - fake.putPublicAccessBlockMutex.Lock() - ret, specificReturn := fake.putPublicAccessBlockReturnsOnCall[len(fake.putPublicAccessBlockArgsForCall)] - fake.putPublicAccessBlockArgsForCall = append(fake.putPublicAccessBlockArgsForCall, struct { - arg1 *s3.PutPublicAccessBlockInput - }{arg1}) - stub := fake.PutPublicAccessBlockStub - fakeReturns := fake.putPublicAccessBlockReturns - fake.recordInvocation("PutPublicAccessBlock", []interface{}{arg1}) - fake.putPublicAccessBlockMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutPublicAccessBlockCallCount() int { - fake.putPublicAccessBlockMutex.RLock() - defer fake.putPublicAccessBlockMutex.RUnlock() - return len(fake.putPublicAccessBlockArgsForCall) -} - -func (fake *FakeS3Client) PutPublicAccessBlockCalls(stub func(*s3.PutPublicAccessBlockInput) (*s3.PutPublicAccessBlockOutput, error)) { - fake.putPublicAccessBlockMutex.Lock() - defer fake.putPublicAccessBlockMutex.Unlock() - fake.PutPublicAccessBlockStub = stub -} - -func (fake *FakeS3Client) PutPublicAccessBlockArgsForCall(i int) *s3.PutPublicAccessBlockInput { - fake.putPublicAccessBlockMutex.RLock() - defer fake.putPublicAccessBlockMutex.RUnlock() - argsForCall := fake.putPublicAccessBlockArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutPublicAccessBlockReturns(result1 *s3.PutPublicAccessBlockOutput, result2 error) { - fake.putPublicAccessBlockMutex.Lock() - defer fake.putPublicAccessBlockMutex.Unlock() - fake.PutPublicAccessBlockStub = nil - fake.putPublicAccessBlockReturns = struct { - result1 *s3.PutPublicAccessBlockOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutPublicAccessBlockReturnsOnCall(i int, result1 *s3.PutPublicAccessBlockOutput, result2 error) { - fake.putPublicAccessBlockMutex.Lock() - defer fake.putPublicAccessBlockMutex.Unlock() - fake.PutPublicAccessBlockStub = nil - if fake.putPublicAccessBlockReturnsOnCall == nil { - fake.putPublicAccessBlockReturnsOnCall = make(map[int]struct { - result1 *s3.PutPublicAccessBlockOutput - result2 error - }) - } - fake.putPublicAccessBlockReturnsOnCall[i] = struct { - result1 *s3.PutPublicAccessBlockOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutPublicAccessBlockRequest(arg1 *s3.PutPublicAccessBlockInput) (*request.Request, *s3.PutPublicAccessBlockOutput) { - fake.putPublicAccessBlockRequestMutex.Lock() - ret, specificReturn := fake.putPublicAccessBlockRequestReturnsOnCall[len(fake.putPublicAccessBlockRequestArgsForCall)] - fake.putPublicAccessBlockRequestArgsForCall = append(fake.putPublicAccessBlockRequestArgsForCall, struct { - arg1 *s3.PutPublicAccessBlockInput - }{arg1}) - stub := fake.PutPublicAccessBlockRequestStub - fakeReturns := fake.putPublicAccessBlockRequestReturns - fake.recordInvocation("PutPublicAccessBlockRequest", []interface{}{arg1}) - fake.putPublicAccessBlockRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutPublicAccessBlockRequestCallCount() int { - fake.putPublicAccessBlockRequestMutex.RLock() - defer fake.putPublicAccessBlockRequestMutex.RUnlock() - return len(fake.putPublicAccessBlockRequestArgsForCall) -} - -func (fake *FakeS3Client) PutPublicAccessBlockRequestCalls(stub func(*s3.PutPublicAccessBlockInput) (*request.Request, *s3.PutPublicAccessBlockOutput)) { - fake.putPublicAccessBlockRequestMutex.Lock() - defer fake.putPublicAccessBlockRequestMutex.Unlock() - fake.PutPublicAccessBlockRequestStub = stub -} - -func (fake *FakeS3Client) PutPublicAccessBlockRequestArgsForCall(i int) *s3.PutPublicAccessBlockInput { - fake.putPublicAccessBlockRequestMutex.RLock() - defer fake.putPublicAccessBlockRequestMutex.RUnlock() - argsForCall := fake.putPublicAccessBlockRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) PutPublicAccessBlockRequestReturns(result1 *request.Request, result2 *s3.PutPublicAccessBlockOutput) { - fake.putPublicAccessBlockRequestMutex.Lock() - defer fake.putPublicAccessBlockRequestMutex.Unlock() - fake.PutPublicAccessBlockRequestStub = nil - fake.putPublicAccessBlockRequestReturns = struct { - result1 *request.Request - result2 *s3.PutPublicAccessBlockOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutPublicAccessBlockRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.PutPublicAccessBlockOutput) { - fake.putPublicAccessBlockRequestMutex.Lock() - defer fake.putPublicAccessBlockRequestMutex.Unlock() - fake.PutPublicAccessBlockRequestStub = nil - if fake.putPublicAccessBlockRequestReturnsOnCall == nil { - fake.putPublicAccessBlockRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.PutPublicAccessBlockOutput - }) - } - fake.putPublicAccessBlockRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.PutPublicAccessBlockOutput - }{result1, result2} -} - -func (fake *FakeS3Client) PutPublicAccessBlockWithContext(arg1 context.Context, arg2 *s3.PutPublicAccessBlockInput, arg3 ...request.Option) (*s3.PutPublicAccessBlockOutput, error) { - fake.putPublicAccessBlockWithContextMutex.Lock() - ret, specificReturn := fake.putPublicAccessBlockWithContextReturnsOnCall[len(fake.putPublicAccessBlockWithContextArgsForCall)] - fake.putPublicAccessBlockWithContextArgsForCall = append(fake.putPublicAccessBlockWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.PutPublicAccessBlockInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.PutPublicAccessBlockWithContextStub - fakeReturns := fake.putPublicAccessBlockWithContextReturns - fake.recordInvocation("PutPublicAccessBlockWithContext", []interface{}{arg1, arg2, arg3}) - fake.putPublicAccessBlockWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) PutPublicAccessBlockWithContextCallCount() int { - fake.putPublicAccessBlockWithContextMutex.RLock() - defer fake.putPublicAccessBlockWithContextMutex.RUnlock() - return len(fake.putPublicAccessBlockWithContextArgsForCall) -} - -func (fake *FakeS3Client) PutPublicAccessBlockWithContextCalls(stub func(context.Context, *s3.PutPublicAccessBlockInput, ...request.Option) (*s3.PutPublicAccessBlockOutput, error)) { - fake.putPublicAccessBlockWithContextMutex.Lock() - defer fake.putPublicAccessBlockWithContextMutex.Unlock() - fake.PutPublicAccessBlockWithContextStub = stub -} - -func (fake *FakeS3Client) PutPublicAccessBlockWithContextArgsForCall(i int) (context.Context, *s3.PutPublicAccessBlockInput, []request.Option) { - fake.putPublicAccessBlockWithContextMutex.RLock() - defer fake.putPublicAccessBlockWithContextMutex.RUnlock() - argsForCall := fake.putPublicAccessBlockWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) PutPublicAccessBlockWithContextReturns(result1 *s3.PutPublicAccessBlockOutput, result2 error) { - fake.putPublicAccessBlockWithContextMutex.Lock() - defer fake.putPublicAccessBlockWithContextMutex.Unlock() - fake.PutPublicAccessBlockWithContextStub = nil - fake.putPublicAccessBlockWithContextReturns = struct { - result1 *s3.PutPublicAccessBlockOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) PutPublicAccessBlockWithContextReturnsOnCall(i int, result1 *s3.PutPublicAccessBlockOutput, result2 error) { - fake.putPublicAccessBlockWithContextMutex.Lock() - defer fake.putPublicAccessBlockWithContextMutex.Unlock() - fake.PutPublicAccessBlockWithContextStub = nil - if fake.putPublicAccessBlockWithContextReturnsOnCall == nil { - fake.putPublicAccessBlockWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.PutPublicAccessBlockOutput - result2 error - }) - } - fake.putPublicAccessBlockWithContextReturnsOnCall[i] = struct { - result1 *s3.PutPublicAccessBlockOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) RestoreObject(arg1 *s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error) { - fake.restoreObjectMutex.Lock() - ret, specificReturn := fake.restoreObjectReturnsOnCall[len(fake.restoreObjectArgsForCall)] - fake.restoreObjectArgsForCall = append(fake.restoreObjectArgsForCall, struct { - arg1 *s3.RestoreObjectInput - }{arg1}) - stub := fake.RestoreObjectStub - fakeReturns := fake.restoreObjectReturns - fake.recordInvocation("RestoreObject", []interface{}{arg1}) - fake.restoreObjectMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) RestoreObjectCallCount() int { - fake.restoreObjectMutex.RLock() - defer fake.restoreObjectMutex.RUnlock() - return len(fake.restoreObjectArgsForCall) -} - -func (fake *FakeS3Client) RestoreObjectCalls(stub func(*s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error)) { - fake.restoreObjectMutex.Lock() - defer fake.restoreObjectMutex.Unlock() - fake.RestoreObjectStub = stub -} - -func (fake *FakeS3Client) RestoreObjectArgsForCall(i int) *s3.RestoreObjectInput { - fake.restoreObjectMutex.RLock() - defer fake.restoreObjectMutex.RUnlock() - argsForCall := fake.restoreObjectArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) RestoreObjectReturns(result1 *s3.RestoreObjectOutput, result2 error) { - fake.restoreObjectMutex.Lock() - defer fake.restoreObjectMutex.Unlock() - fake.RestoreObjectStub = nil - fake.restoreObjectReturns = struct { - result1 *s3.RestoreObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) RestoreObjectReturnsOnCall(i int, result1 *s3.RestoreObjectOutput, result2 error) { - fake.restoreObjectMutex.Lock() - defer fake.restoreObjectMutex.Unlock() - fake.RestoreObjectStub = nil - if fake.restoreObjectReturnsOnCall == nil { - fake.restoreObjectReturnsOnCall = make(map[int]struct { - result1 *s3.RestoreObjectOutput - result2 error - }) - } - fake.restoreObjectReturnsOnCall[i] = struct { - result1 *s3.RestoreObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) RestoreObjectRequest(arg1 *s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput) { - fake.restoreObjectRequestMutex.Lock() - ret, specificReturn := fake.restoreObjectRequestReturnsOnCall[len(fake.restoreObjectRequestArgsForCall)] - fake.restoreObjectRequestArgsForCall = append(fake.restoreObjectRequestArgsForCall, struct { - arg1 *s3.RestoreObjectInput - }{arg1}) - stub := fake.RestoreObjectRequestStub - fakeReturns := fake.restoreObjectRequestReturns - fake.recordInvocation("RestoreObjectRequest", []interface{}{arg1}) - fake.restoreObjectRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) RestoreObjectRequestCallCount() int { - fake.restoreObjectRequestMutex.RLock() - defer fake.restoreObjectRequestMutex.RUnlock() - return len(fake.restoreObjectRequestArgsForCall) -} - -func (fake *FakeS3Client) RestoreObjectRequestCalls(stub func(*s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput)) { - fake.restoreObjectRequestMutex.Lock() - defer fake.restoreObjectRequestMutex.Unlock() - fake.RestoreObjectRequestStub = stub -} - -func (fake *FakeS3Client) RestoreObjectRequestArgsForCall(i int) *s3.RestoreObjectInput { - fake.restoreObjectRequestMutex.RLock() - defer fake.restoreObjectRequestMutex.RUnlock() - argsForCall := fake.restoreObjectRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) RestoreObjectRequestReturns(result1 *request.Request, result2 *s3.RestoreObjectOutput) { - fake.restoreObjectRequestMutex.Lock() - defer fake.restoreObjectRequestMutex.Unlock() - fake.RestoreObjectRequestStub = nil - fake.restoreObjectRequestReturns = struct { - result1 *request.Request - result2 *s3.RestoreObjectOutput - }{result1, result2} -} - -func (fake *FakeS3Client) RestoreObjectRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.RestoreObjectOutput) { - fake.restoreObjectRequestMutex.Lock() - defer fake.restoreObjectRequestMutex.Unlock() - fake.RestoreObjectRequestStub = nil - if fake.restoreObjectRequestReturnsOnCall == nil { - fake.restoreObjectRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.RestoreObjectOutput - }) - } - fake.restoreObjectRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.RestoreObjectOutput - }{result1, result2} -} - -func (fake *FakeS3Client) RestoreObjectWithContext(arg1 context.Context, arg2 *s3.RestoreObjectInput, arg3 ...request.Option) (*s3.RestoreObjectOutput, error) { - fake.restoreObjectWithContextMutex.Lock() - ret, specificReturn := fake.restoreObjectWithContextReturnsOnCall[len(fake.restoreObjectWithContextArgsForCall)] - fake.restoreObjectWithContextArgsForCall = append(fake.restoreObjectWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.RestoreObjectInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.RestoreObjectWithContextStub - fakeReturns := fake.restoreObjectWithContextReturns - fake.recordInvocation("RestoreObjectWithContext", []interface{}{arg1, arg2, arg3}) - fake.restoreObjectWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) RestoreObjectWithContextCallCount() int { - fake.restoreObjectWithContextMutex.RLock() - defer fake.restoreObjectWithContextMutex.RUnlock() - return len(fake.restoreObjectWithContextArgsForCall) -} - -func (fake *FakeS3Client) RestoreObjectWithContextCalls(stub func(context.Context, *s3.RestoreObjectInput, ...request.Option) (*s3.RestoreObjectOutput, error)) { - fake.restoreObjectWithContextMutex.Lock() - defer fake.restoreObjectWithContextMutex.Unlock() - fake.RestoreObjectWithContextStub = stub -} - -func (fake *FakeS3Client) RestoreObjectWithContextArgsForCall(i int) (context.Context, *s3.RestoreObjectInput, []request.Option) { - fake.restoreObjectWithContextMutex.RLock() - defer fake.restoreObjectWithContextMutex.RUnlock() - argsForCall := fake.restoreObjectWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) RestoreObjectWithContextReturns(result1 *s3.RestoreObjectOutput, result2 error) { - fake.restoreObjectWithContextMutex.Lock() - defer fake.restoreObjectWithContextMutex.Unlock() - fake.RestoreObjectWithContextStub = nil - fake.restoreObjectWithContextReturns = struct { - result1 *s3.RestoreObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) RestoreObjectWithContextReturnsOnCall(i int, result1 *s3.RestoreObjectOutput, result2 error) { - fake.restoreObjectWithContextMutex.Lock() - defer fake.restoreObjectWithContextMutex.Unlock() - fake.RestoreObjectWithContextStub = nil - if fake.restoreObjectWithContextReturnsOnCall == nil { - fake.restoreObjectWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.RestoreObjectOutput - result2 error - }) - } - fake.restoreObjectWithContextReturnsOnCall[i] = struct { - result1 *s3.RestoreObjectOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) SelectObjectContent(arg1 *s3.SelectObjectContentInput) (*s3.SelectObjectContentOutput, error) { - fake.selectObjectContentMutex.Lock() - ret, specificReturn := fake.selectObjectContentReturnsOnCall[len(fake.selectObjectContentArgsForCall)] - fake.selectObjectContentArgsForCall = append(fake.selectObjectContentArgsForCall, struct { - arg1 *s3.SelectObjectContentInput - }{arg1}) - stub := fake.SelectObjectContentStub - fakeReturns := fake.selectObjectContentReturns - fake.recordInvocation("SelectObjectContent", []interface{}{arg1}) - fake.selectObjectContentMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) SelectObjectContentCallCount() int { - fake.selectObjectContentMutex.RLock() - defer fake.selectObjectContentMutex.RUnlock() - return len(fake.selectObjectContentArgsForCall) -} - -func (fake *FakeS3Client) SelectObjectContentCalls(stub func(*s3.SelectObjectContentInput) (*s3.SelectObjectContentOutput, error)) { - fake.selectObjectContentMutex.Lock() - defer fake.selectObjectContentMutex.Unlock() - fake.SelectObjectContentStub = stub -} - -func (fake *FakeS3Client) SelectObjectContentArgsForCall(i int) *s3.SelectObjectContentInput { - fake.selectObjectContentMutex.RLock() - defer fake.selectObjectContentMutex.RUnlock() - argsForCall := fake.selectObjectContentArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) SelectObjectContentReturns(result1 *s3.SelectObjectContentOutput, result2 error) { - fake.selectObjectContentMutex.Lock() - defer fake.selectObjectContentMutex.Unlock() - fake.SelectObjectContentStub = nil - fake.selectObjectContentReturns = struct { - result1 *s3.SelectObjectContentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) SelectObjectContentReturnsOnCall(i int, result1 *s3.SelectObjectContentOutput, result2 error) { - fake.selectObjectContentMutex.Lock() - defer fake.selectObjectContentMutex.Unlock() - fake.SelectObjectContentStub = nil - if fake.selectObjectContentReturnsOnCall == nil { - fake.selectObjectContentReturnsOnCall = make(map[int]struct { - result1 *s3.SelectObjectContentOutput - result2 error - }) - } - fake.selectObjectContentReturnsOnCall[i] = struct { - result1 *s3.SelectObjectContentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) SelectObjectContentRequest(arg1 *s3.SelectObjectContentInput) (*request.Request, *s3.SelectObjectContentOutput) { - fake.selectObjectContentRequestMutex.Lock() - ret, specificReturn := fake.selectObjectContentRequestReturnsOnCall[len(fake.selectObjectContentRequestArgsForCall)] - fake.selectObjectContentRequestArgsForCall = append(fake.selectObjectContentRequestArgsForCall, struct { - arg1 *s3.SelectObjectContentInput - }{arg1}) - stub := fake.SelectObjectContentRequestStub - fakeReturns := fake.selectObjectContentRequestReturns - fake.recordInvocation("SelectObjectContentRequest", []interface{}{arg1}) - fake.selectObjectContentRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) SelectObjectContentRequestCallCount() int { - fake.selectObjectContentRequestMutex.RLock() - defer fake.selectObjectContentRequestMutex.RUnlock() - return len(fake.selectObjectContentRequestArgsForCall) -} - -func (fake *FakeS3Client) SelectObjectContentRequestCalls(stub func(*s3.SelectObjectContentInput) (*request.Request, *s3.SelectObjectContentOutput)) { - fake.selectObjectContentRequestMutex.Lock() - defer fake.selectObjectContentRequestMutex.Unlock() - fake.SelectObjectContentRequestStub = stub -} - -func (fake *FakeS3Client) SelectObjectContentRequestArgsForCall(i int) *s3.SelectObjectContentInput { - fake.selectObjectContentRequestMutex.RLock() - defer fake.selectObjectContentRequestMutex.RUnlock() - argsForCall := fake.selectObjectContentRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) SelectObjectContentRequestReturns(result1 *request.Request, result2 *s3.SelectObjectContentOutput) { - fake.selectObjectContentRequestMutex.Lock() - defer fake.selectObjectContentRequestMutex.Unlock() - fake.SelectObjectContentRequestStub = nil - fake.selectObjectContentRequestReturns = struct { - result1 *request.Request - result2 *s3.SelectObjectContentOutput - }{result1, result2} -} - -func (fake *FakeS3Client) SelectObjectContentRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.SelectObjectContentOutput) { - fake.selectObjectContentRequestMutex.Lock() - defer fake.selectObjectContentRequestMutex.Unlock() - fake.SelectObjectContentRequestStub = nil - if fake.selectObjectContentRequestReturnsOnCall == nil { - fake.selectObjectContentRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.SelectObjectContentOutput - }) - } - fake.selectObjectContentRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.SelectObjectContentOutput - }{result1, result2} -} - -func (fake *FakeS3Client) SelectObjectContentWithContext(arg1 context.Context, arg2 *s3.SelectObjectContentInput, arg3 ...request.Option) (*s3.SelectObjectContentOutput, error) { - fake.selectObjectContentWithContextMutex.Lock() - ret, specificReturn := fake.selectObjectContentWithContextReturnsOnCall[len(fake.selectObjectContentWithContextArgsForCall)] - fake.selectObjectContentWithContextArgsForCall = append(fake.selectObjectContentWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.SelectObjectContentInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.SelectObjectContentWithContextStub - fakeReturns := fake.selectObjectContentWithContextReturns - fake.recordInvocation("SelectObjectContentWithContext", []interface{}{arg1, arg2, arg3}) - fake.selectObjectContentWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) SelectObjectContentWithContextCallCount() int { - fake.selectObjectContentWithContextMutex.RLock() - defer fake.selectObjectContentWithContextMutex.RUnlock() - return len(fake.selectObjectContentWithContextArgsForCall) -} - -func (fake *FakeS3Client) SelectObjectContentWithContextCalls(stub func(context.Context, *s3.SelectObjectContentInput, ...request.Option) (*s3.SelectObjectContentOutput, error)) { - fake.selectObjectContentWithContextMutex.Lock() - defer fake.selectObjectContentWithContextMutex.Unlock() - fake.SelectObjectContentWithContextStub = stub -} - -func (fake *FakeS3Client) SelectObjectContentWithContextArgsForCall(i int) (context.Context, *s3.SelectObjectContentInput, []request.Option) { - fake.selectObjectContentWithContextMutex.RLock() - defer fake.selectObjectContentWithContextMutex.RUnlock() - argsForCall := fake.selectObjectContentWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) SelectObjectContentWithContextReturns(result1 *s3.SelectObjectContentOutput, result2 error) { - fake.selectObjectContentWithContextMutex.Lock() - defer fake.selectObjectContentWithContextMutex.Unlock() - fake.SelectObjectContentWithContextStub = nil - fake.selectObjectContentWithContextReturns = struct { - result1 *s3.SelectObjectContentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) SelectObjectContentWithContextReturnsOnCall(i int, result1 *s3.SelectObjectContentOutput, result2 error) { - fake.selectObjectContentWithContextMutex.Lock() - defer fake.selectObjectContentWithContextMutex.Unlock() - fake.SelectObjectContentWithContextStub = nil - if fake.selectObjectContentWithContextReturnsOnCall == nil { - fake.selectObjectContentWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.SelectObjectContentOutput - result2 error - }) - } - fake.selectObjectContentWithContextReturnsOnCall[i] = struct { - result1 *s3.SelectObjectContentOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) UploadPart(arg1 *s3.UploadPartInput) (*s3.UploadPartOutput, error) { - fake.uploadPartMutex.Lock() - ret, specificReturn := fake.uploadPartReturnsOnCall[len(fake.uploadPartArgsForCall)] - fake.uploadPartArgsForCall = append(fake.uploadPartArgsForCall, struct { - arg1 *s3.UploadPartInput - }{arg1}) - stub := fake.UploadPartStub - fakeReturns := fake.uploadPartReturns - fake.recordInvocation("UploadPart", []interface{}{arg1}) - fake.uploadPartMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) UploadPartCallCount() int { - fake.uploadPartMutex.RLock() - defer fake.uploadPartMutex.RUnlock() - return len(fake.uploadPartArgsForCall) -} - -func (fake *FakeS3Client) UploadPartCalls(stub func(*s3.UploadPartInput) (*s3.UploadPartOutput, error)) { - fake.uploadPartMutex.Lock() - defer fake.uploadPartMutex.Unlock() - fake.UploadPartStub = stub -} - -func (fake *FakeS3Client) UploadPartArgsForCall(i int) *s3.UploadPartInput { - fake.uploadPartMutex.RLock() - defer fake.uploadPartMutex.RUnlock() - argsForCall := fake.uploadPartArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) UploadPartReturns(result1 *s3.UploadPartOutput, result2 error) { - fake.uploadPartMutex.Lock() - defer fake.uploadPartMutex.Unlock() - fake.UploadPartStub = nil - fake.uploadPartReturns = struct { - result1 *s3.UploadPartOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) UploadPartReturnsOnCall(i int, result1 *s3.UploadPartOutput, result2 error) { - fake.uploadPartMutex.Lock() - defer fake.uploadPartMutex.Unlock() - fake.UploadPartStub = nil - if fake.uploadPartReturnsOnCall == nil { - fake.uploadPartReturnsOnCall = make(map[int]struct { - result1 *s3.UploadPartOutput - result2 error - }) - } - fake.uploadPartReturnsOnCall[i] = struct { - result1 *s3.UploadPartOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) UploadPartCopy(arg1 *s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error) { - fake.uploadPartCopyMutex.Lock() - ret, specificReturn := fake.uploadPartCopyReturnsOnCall[len(fake.uploadPartCopyArgsForCall)] - fake.uploadPartCopyArgsForCall = append(fake.uploadPartCopyArgsForCall, struct { - arg1 *s3.UploadPartCopyInput - }{arg1}) - stub := fake.UploadPartCopyStub - fakeReturns := fake.uploadPartCopyReturns - fake.recordInvocation("UploadPartCopy", []interface{}{arg1}) - fake.uploadPartCopyMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) UploadPartCopyCallCount() int { - fake.uploadPartCopyMutex.RLock() - defer fake.uploadPartCopyMutex.RUnlock() - return len(fake.uploadPartCopyArgsForCall) -} - -func (fake *FakeS3Client) UploadPartCopyCalls(stub func(*s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error)) { - fake.uploadPartCopyMutex.Lock() - defer fake.uploadPartCopyMutex.Unlock() - fake.UploadPartCopyStub = stub -} - -func (fake *FakeS3Client) UploadPartCopyArgsForCall(i int) *s3.UploadPartCopyInput { - fake.uploadPartCopyMutex.RLock() - defer fake.uploadPartCopyMutex.RUnlock() - argsForCall := fake.uploadPartCopyArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) UploadPartCopyReturns(result1 *s3.UploadPartCopyOutput, result2 error) { - fake.uploadPartCopyMutex.Lock() - defer fake.uploadPartCopyMutex.Unlock() - fake.UploadPartCopyStub = nil - fake.uploadPartCopyReturns = struct { - result1 *s3.UploadPartCopyOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) UploadPartCopyReturnsOnCall(i int, result1 *s3.UploadPartCopyOutput, result2 error) { - fake.uploadPartCopyMutex.Lock() - defer fake.uploadPartCopyMutex.Unlock() - fake.UploadPartCopyStub = nil - if fake.uploadPartCopyReturnsOnCall == nil { - fake.uploadPartCopyReturnsOnCall = make(map[int]struct { - result1 *s3.UploadPartCopyOutput - result2 error - }) - } - fake.uploadPartCopyReturnsOnCall[i] = struct { - result1 *s3.UploadPartCopyOutput - result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) UploadPartCopyRequest(arg1 *s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput) { - fake.uploadPartCopyRequestMutex.Lock() - ret, specificReturn := fake.uploadPartCopyRequestReturnsOnCall[len(fake.uploadPartCopyRequestArgsForCall)] - fake.uploadPartCopyRequestArgsForCall = append(fake.uploadPartCopyRequestArgsForCall, struct { - arg1 *s3.UploadPartCopyInput - }{arg1}) - stub := fake.UploadPartCopyRequestStub - fakeReturns := fake.uploadPartCopyRequestReturns - fake.recordInvocation("UploadPartCopyRequest", []interface{}{arg1}) - fake.uploadPartCopyRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) UploadPartCopyRequestCallCount() int { - fake.uploadPartCopyRequestMutex.RLock() - defer fake.uploadPartCopyRequestMutex.RUnlock() - return len(fake.uploadPartCopyRequestArgsForCall) -} - -func (fake *FakeS3Client) UploadPartCopyRequestCalls(stub func(*s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput)) { - fake.uploadPartCopyRequestMutex.Lock() - defer fake.uploadPartCopyRequestMutex.Unlock() - fake.UploadPartCopyRequestStub = stub -} - -func (fake *FakeS3Client) UploadPartCopyRequestArgsForCall(i int) *s3.UploadPartCopyInput { - fake.uploadPartCopyRequestMutex.RLock() - defer fake.uploadPartCopyRequestMutex.RUnlock() - argsForCall := fake.uploadPartCopyRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) UploadPartCopyRequestReturns(result1 *request.Request, result2 *s3.UploadPartCopyOutput) { - fake.uploadPartCopyRequestMutex.Lock() - defer fake.uploadPartCopyRequestMutex.Unlock() - fake.UploadPartCopyRequestStub = nil - fake.uploadPartCopyRequestReturns = struct { - result1 *request.Request - result2 *s3.UploadPartCopyOutput - }{result1, result2} -} - -func (fake *FakeS3Client) UploadPartCopyRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.UploadPartCopyOutput) { - fake.uploadPartCopyRequestMutex.Lock() - defer fake.uploadPartCopyRequestMutex.Unlock() - fake.UploadPartCopyRequestStub = nil - if fake.uploadPartCopyRequestReturnsOnCall == nil { - fake.uploadPartCopyRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.UploadPartCopyOutput - }) - } - fake.uploadPartCopyRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.UploadPartCopyOutput - }{result1, result2} -} - -func (fake *FakeS3Client) UploadPartCopyWithContext(arg1 context.Context, arg2 *s3.UploadPartCopyInput, arg3 ...request.Option) (*s3.UploadPartCopyOutput, error) { - fake.uploadPartCopyWithContextMutex.Lock() - ret, specificReturn := fake.uploadPartCopyWithContextReturnsOnCall[len(fake.uploadPartCopyWithContextArgsForCall)] - fake.uploadPartCopyWithContextArgsForCall = append(fake.uploadPartCopyWithContextArgsForCall, struct { + GetObjectStub func(context.Context, *s3.GetObjectInput, ...func(*s3.Options)) (*s3.GetObjectOutput, error) + getObjectMutex sync.RWMutex + getObjectArgsForCall []struct { arg1 context.Context - arg2 *s3.UploadPartCopyInput - arg3 []request.Option - }{arg1, arg2, arg3}) - stub := fake.UploadPartCopyWithContextStub - fakeReturns := fake.uploadPartCopyWithContextReturns - fake.recordInvocation("UploadPartCopyWithContext", []interface{}{arg1, arg2, arg3}) - fake.uploadPartCopyWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1, ret.result2 + arg2 *s3.GetObjectInput + arg3 []func(*s3.Options) } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) UploadPartCopyWithContextCallCount() int { - fake.uploadPartCopyWithContextMutex.RLock() - defer fake.uploadPartCopyWithContextMutex.RUnlock() - return len(fake.uploadPartCopyWithContextArgsForCall) -} - -func (fake *FakeS3Client) UploadPartCopyWithContextCalls(stub func(context.Context, *s3.UploadPartCopyInput, ...request.Option) (*s3.UploadPartCopyOutput, error)) { - fake.uploadPartCopyWithContextMutex.Lock() - defer fake.uploadPartCopyWithContextMutex.Unlock() - fake.UploadPartCopyWithContextStub = stub -} - -func (fake *FakeS3Client) UploadPartCopyWithContextArgsForCall(i int) (context.Context, *s3.UploadPartCopyInput, []request.Option) { - fake.uploadPartCopyWithContextMutex.RLock() - defer fake.uploadPartCopyWithContextMutex.RUnlock() - argsForCall := fake.uploadPartCopyWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) UploadPartCopyWithContextReturns(result1 *s3.UploadPartCopyOutput, result2 error) { - fake.uploadPartCopyWithContextMutex.Lock() - defer fake.uploadPartCopyWithContextMutex.Unlock() - fake.UploadPartCopyWithContextStub = nil - fake.uploadPartCopyWithContextReturns = struct { - result1 *s3.UploadPartCopyOutput + getObjectReturns struct { + result1 *s3.GetObjectOutput result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) UploadPartCopyWithContextReturnsOnCall(i int, result1 *s3.UploadPartCopyOutput, result2 error) { - fake.uploadPartCopyWithContextMutex.Lock() - defer fake.uploadPartCopyWithContextMutex.Unlock() - fake.UploadPartCopyWithContextStub = nil - if fake.uploadPartCopyWithContextReturnsOnCall == nil { - fake.uploadPartCopyWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.UploadPartCopyOutput - result2 error - }) } - fake.uploadPartCopyWithContextReturnsOnCall[i] = struct { - result1 *s3.UploadPartCopyOutput + getObjectReturnsOnCall map[int]struct { + result1 *s3.GetObjectOutput result2 error - }{result1, result2} -} - -func (fake *FakeS3Client) UploadPartRequest(arg1 *s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput) { - fake.uploadPartRequestMutex.Lock() - ret, specificReturn := fake.uploadPartRequestReturnsOnCall[len(fake.uploadPartRequestArgsForCall)] - fake.uploadPartRequestArgsForCall = append(fake.uploadPartRequestArgsForCall, struct { - arg1 *s3.UploadPartInput - }{arg1}) - stub := fake.UploadPartRequestStub - fakeReturns := fake.uploadPartRequestReturns - fake.recordInvocation("UploadPartRequest", []interface{}{arg1}) - fake.uploadPartRequestMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1, ret.result2 - } - return fakeReturns.result1, fakeReturns.result2 -} - -func (fake *FakeS3Client) UploadPartRequestCallCount() int { - fake.uploadPartRequestMutex.RLock() - defer fake.uploadPartRequestMutex.RUnlock() - return len(fake.uploadPartRequestArgsForCall) -} - -func (fake *FakeS3Client) UploadPartRequestCalls(stub func(*s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput)) { - fake.uploadPartRequestMutex.Lock() - defer fake.uploadPartRequestMutex.Unlock() - fake.UploadPartRequestStub = stub -} - -func (fake *FakeS3Client) UploadPartRequestArgsForCall(i int) *s3.UploadPartInput { - fake.uploadPartRequestMutex.RLock() - defer fake.uploadPartRequestMutex.RUnlock() - argsForCall := fake.uploadPartRequestArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) UploadPartRequestReturns(result1 *request.Request, result2 *s3.UploadPartOutput) { - fake.uploadPartRequestMutex.Lock() - defer fake.uploadPartRequestMutex.Unlock() - fake.UploadPartRequestStub = nil - fake.uploadPartRequestReturns = struct { - result1 *request.Request - result2 *s3.UploadPartOutput - }{result1, result2} -} - -func (fake *FakeS3Client) UploadPartRequestReturnsOnCall(i int, result1 *request.Request, result2 *s3.UploadPartOutput) { - fake.uploadPartRequestMutex.Lock() - defer fake.uploadPartRequestMutex.Unlock() - fake.UploadPartRequestStub = nil - if fake.uploadPartRequestReturnsOnCall == nil { - fake.uploadPartRequestReturnsOnCall = make(map[int]struct { - result1 *request.Request - result2 *s3.UploadPartOutput - }) } - fake.uploadPartRequestReturnsOnCall[i] = struct { - result1 *request.Request - result2 *s3.UploadPartOutput - }{result1, result2} + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex } -func (fake *FakeS3Client) UploadPartWithContext(arg1 context.Context, arg2 *s3.UploadPartInput, arg3 ...request.Option) (*s3.UploadPartOutput, error) { - fake.uploadPartWithContextMutex.Lock() - ret, specificReturn := fake.uploadPartWithContextReturnsOnCall[len(fake.uploadPartWithContextArgsForCall)] - fake.uploadPartWithContextArgsForCall = append(fake.uploadPartWithContextArgsForCall, struct { +func (fake *FakeS3Client) GetObject(arg1 context.Context, arg2 *s3.GetObjectInput, arg3 ...func(*s3.Options)) (*s3.GetObjectOutput, error) { + fake.getObjectMutex.Lock() + ret, specificReturn := fake.getObjectReturnsOnCall[len(fake.getObjectArgsForCall)] + fake.getObjectArgsForCall = append(fake.getObjectArgsForCall, struct { arg1 context.Context - arg2 *s3.UploadPartInput - arg3 []request.Option + arg2 *s3.GetObjectInput + arg3 []func(*s3.Options) }{arg1, arg2, arg3}) - stub := fake.UploadPartWithContextStub - fakeReturns := fake.uploadPartWithContextReturns - fake.recordInvocation("UploadPartWithContext", []interface{}{arg1, arg2, arg3}) - fake.uploadPartWithContextMutex.Unlock() + stub := fake.GetObjectStub + fakeReturns := fake.getObjectReturns + fake.recordInvocation("GetObject", []interface{}{arg1, arg2, arg3}) + fake.getObjectMutex.Unlock() if stub != nil { return stub(arg1, arg2, arg3...) } @@ -23151,1156 +50,56 @@ func (fake *FakeS3Client) UploadPartWithContext(arg1 context.Context, arg2 *s3.U return fakeReturns.result1, fakeReturns.result2 } -func (fake *FakeS3Client) UploadPartWithContextCallCount() int { - fake.uploadPartWithContextMutex.RLock() - defer fake.uploadPartWithContextMutex.RUnlock() - return len(fake.uploadPartWithContextArgsForCall) +func (fake *FakeS3Client) GetObjectCallCount() int { + fake.getObjectMutex.RLock() + defer fake.getObjectMutex.RUnlock() + return len(fake.getObjectArgsForCall) } -func (fake *FakeS3Client) UploadPartWithContextCalls(stub func(context.Context, *s3.UploadPartInput, ...request.Option) (*s3.UploadPartOutput, error)) { - fake.uploadPartWithContextMutex.Lock() - defer fake.uploadPartWithContextMutex.Unlock() - fake.UploadPartWithContextStub = stub +func (fake *FakeS3Client) GetObjectCalls(stub func(context.Context, *s3.GetObjectInput, ...func(*s3.Options)) (*s3.GetObjectOutput, error)) { + fake.getObjectMutex.Lock() + defer fake.getObjectMutex.Unlock() + fake.GetObjectStub = stub } -func (fake *FakeS3Client) UploadPartWithContextArgsForCall(i int) (context.Context, *s3.UploadPartInput, []request.Option) { - fake.uploadPartWithContextMutex.RLock() - defer fake.uploadPartWithContextMutex.RUnlock() - argsForCall := fake.uploadPartWithContextArgsForCall[i] +func (fake *FakeS3Client) GetObjectArgsForCall(i int) (context.Context, *s3.GetObjectInput, []func(*s3.Options)) { + fake.getObjectMutex.RLock() + defer fake.getObjectMutex.RUnlock() + argsForCall := fake.getObjectArgsForCall[i] return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 } -func (fake *FakeS3Client) UploadPartWithContextReturns(result1 *s3.UploadPartOutput, result2 error) { - fake.uploadPartWithContextMutex.Lock() - defer fake.uploadPartWithContextMutex.Unlock() - fake.UploadPartWithContextStub = nil - fake.uploadPartWithContextReturns = struct { - result1 *s3.UploadPartOutput +func (fake *FakeS3Client) GetObjectReturns(result1 *s3.GetObjectOutput, result2 error) { + fake.getObjectMutex.Lock() + defer fake.getObjectMutex.Unlock() + fake.GetObjectStub = nil + fake.getObjectReturns = struct { + result1 *s3.GetObjectOutput result2 error }{result1, result2} } -func (fake *FakeS3Client) UploadPartWithContextReturnsOnCall(i int, result1 *s3.UploadPartOutput, result2 error) { - fake.uploadPartWithContextMutex.Lock() - defer fake.uploadPartWithContextMutex.Unlock() - fake.UploadPartWithContextStub = nil - if fake.uploadPartWithContextReturnsOnCall == nil { - fake.uploadPartWithContextReturnsOnCall = make(map[int]struct { - result1 *s3.UploadPartOutput +func (fake *FakeS3Client) GetObjectReturnsOnCall(i int, result1 *s3.GetObjectOutput, result2 error) { + fake.getObjectMutex.Lock() + defer fake.getObjectMutex.Unlock() + fake.GetObjectStub = nil + if fake.getObjectReturnsOnCall == nil { + fake.getObjectReturnsOnCall = make(map[int]struct { + result1 *s3.GetObjectOutput result2 error }) } - fake.uploadPartWithContextReturnsOnCall[i] = struct { - result1 *s3.UploadPartOutput + fake.getObjectReturnsOnCall[i] = struct { + result1 *s3.GetObjectOutput result2 error }{result1, result2} } -func (fake *FakeS3Client) WaitUntilBucketExists(arg1 *s3.HeadBucketInput) error { - fake.waitUntilBucketExistsMutex.Lock() - ret, specificReturn := fake.waitUntilBucketExistsReturnsOnCall[len(fake.waitUntilBucketExistsArgsForCall)] - fake.waitUntilBucketExistsArgsForCall = append(fake.waitUntilBucketExistsArgsForCall, struct { - arg1 *s3.HeadBucketInput - }{arg1}) - stub := fake.WaitUntilBucketExistsStub - fakeReturns := fake.waitUntilBucketExistsReturns - fake.recordInvocation("WaitUntilBucketExists", []interface{}{arg1}) - fake.waitUntilBucketExistsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) WaitUntilBucketExistsCallCount() int { - fake.waitUntilBucketExistsMutex.RLock() - defer fake.waitUntilBucketExistsMutex.RUnlock() - return len(fake.waitUntilBucketExistsArgsForCall) -} - -func (fake *FakeS3Client) WaitUntilBucketExistsCalls(stub func(*s3.HeadBucketInput) error) { - fake.waitUntilBucketExistsMutex.Lock() - defer fake.waitUntilBucketExistsMutex.Unlock() - fake.WaitUntilBucketExistsStub = stub -} - -func (fake *FakeS3Client) WaitUntilBucketExistsArgsForCall(i int) *s3.HeadBucketInput { - fake.waitUntilBucketExistsMutex.RLock() - defer fake.waitUntilBucketExistsMutex.RUnlock() - argsForCall := fake.waitUntilBucketExistsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) WaitUntilBucketExistsReturns(result1 error) { - fake.waitUntilBucketExistsMutex.Lock() - defer fake.waitUntilBucketExistsMutex.Unlock() - fake.WaitUntilBucketExistsStub = nil - fake.waitUntilBucketExistsReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilBucketExistsReturnsOnCall(i int, result1 error) { - fake.waitUntilBucketExistsMutex.Lock() - defer fake.waitUntilBucketExistsMutex.Unlock() - fake.WaitUntilBucketExistsStub = nil - if fake.waitUntilBucketExistsReturnsOnCall == nil { - fake.waitUntilBucketExistsReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.waitUntilBucketExistsReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilBucketExistsWithContext(arg1 context.Context, arg2 *s3.HeadBucketInput, arg3 ...request.WaiterOption) error { - fake.waitUntilBucketExistsWithContextMutex.Lock() - ret, specificReturn := fake.waitUntilBucketExistsWithContextReturnsOnCall[len(fake.waitUntilBucketExistsWithContextArgsForCall)] - fake.waitUntilBucketExistsWithContextArgsForCall = append(fake.waitUntilBucketExistsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.HeadBucketInput - arg3 []request.WaiterOption - }{arg1, arg2, arg3}) - stub := fake.WaitUntilBucketExistsWithContextStub - fakeReturns := fake.waitUntilBucketExistsWithContextReturns - fake.recordInvocation("WaitUntilBucketExistsWithContext", []interface{}{arg1, arg2, arg3}) - fake.waitUntilBucketExistsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) WaitUntilBucketExistsWithContextCallCount() int { - fake.waitUntilBucketExistsWithContextMutex.RLock() - defer fake.waitUntilBucketExistsWithContextMutex.RUnlock() - return len(fake.waitUntilBucketExistsWithContextArgsForCall) -} - -func (fake *FakeS3Client) WaitUntilBucketExistsWithContextCalls(stub func(context.Context, *s3.HeadBucketInput, ...request.WaiterOption) error) { - fake.waitUntilBucketExistsWithContextMutex.Lock() - defer fake.waitUntilBucketExistsWithContextMutex.Unlock() - fake.WaitUntilBucketExistsWithContextStub = stub -} - -func (fake *FakeS3Client) WaitUntilBucketExistsWithContextArgsForCall(i int) (context.Context, *s3.HeadBucketInput, []request.WaiterOption) { - fake.waitUntilBucketExistsWithContextMutex.RLock() - defer fake.waitUntilBucketExistsWithContextMutex.RUnlock() - argsForCall := fake.waitUntilBucketExistsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) WaitUntilBucketExistsWithContextReturns(result1 error) { - fake.waitUntilBucketExistsWithContextMutex.Lock() - defer fake.waitUntilBucketExistsWithContextMutex.Unlock() - fake.WaitUntilBucketExistsWithContextStub = nil - fake.waitUntilBucketExistsWithContextReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilBucketExistsWithContextReturnsOnCall(i int, result1 error) { - fake.waitUntilBucketExistsWithContextMutex.Lock() - defer fake.waitUntilBucketExistsWithContextMutex.Unlock() - fake.WaitUntilBucketExistsWithContextStub = nil - if fake.waitUntilBucketExistsWithContextReturnsOnCall == nil { - fake.waitUntilBucketExistsWithContextReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.waitUntilBucketExistsWithContextReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilBucketNotExists(arg1 *s3.HeadBucketInput) error { - fake.waitUntilBucketNotExistsMutex.Lock() - ret, specificReturn := fake.waitUntilBucketNotExistsReturnsOnCall[len(fake.waitUntilBucketNotExistsArgsForCall)] - fake.waitUntilBucketNotExistsArgsForCall = append(fake.waitUntilBucketNotExistsArgsForCall, struct { - arg1 *s3.HeadBucketInput - }{arg1}) - stub := fake.WaitUntilBucketNotExistsStub - fakeReturns := fake.waitUntilBucketNotExistsReturns - fake.recordInvocation("WaitUntilBucketNotExists", []interface{}{arg1}) - fake.waitUntilBucketNotExistsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) WaitUntilBucketNotExistsCallCount() int { - fake.waitUntilBucketNotExistsMutex.RLock() - defer fake.waitUntilBucketNotExistsMutex.RUnlock() - return len(fake.waitUntilBucketNotExistsArgsForCall) -} - -func (fake *FakeS3Client) WaitUntilBucketNotExistsCalls(stub func(*s3.HeadBucketInput) error) { - fake.waitUntilBucketNotExistsMutex.Lock() - defer fake.waitUntilBucketNotExistsMutex.Unlock() - fake.WaitUntilBucketNotExistsStub = stub -} - -func (fake *FakeS3Client) WaitUntilBucketNotExistsArgsForCall(i int) *s3.HeadBucketInput { - fake.waitUntilBucketNotExistsMutex.RLock() - defer fake.waitUntilBucketNotExistsMutex.RUnlock() - argsForCall := fake.waitUntilBucketNotExistsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) WaitUntilBucketNotExistsReturns(result1 error) { - fake.waitUntilBucketNotExistsMutex.Lock() - defer fake.waitUntilBucketNotExistsMutex.Unlock() - fake.WaitUntilBucketNotExistsStub = nil - fake.waitUntilBucketNotExistsReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilBucketNotExistsReturnsOnCall(i int, result1 error) { - fake.waitUntilBucketNotExistsMutex.Lock() - defer fake.waitUntilBucketNotExistsMutex.Unlock() - fake.WaitUntilBucketNotExistsStub = nil - if fake.waitUntilBucketNotExistsReturnsOnCall == nil { - fake.waitUntilBucketNotExistsReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.waitUntilBucketNotExistsReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilBucketNotExistsWithContext(arg1 context.Context, arg2 *s3.HeadBucketInput, arg3 ...request.WaiterOption) error { - fake.waitUntilBucketNotExistsWithContextMutex.Lock() - ret, specificReturn := fake.waitUntilBucketNotExistsWithContextReturnsOnCall[len(fake.waitUntilBucketNotExistsWithContextArgsForCall)] - fake.waitUntilBucketNotExistsWithContextArgsForCall = append(fake.waitUntilBucketNotExistsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.HeadBucketInput - arg3 []request.WaiterOption - }{arg1, arg2, arg3}) - stub := fake.WaitUntilBucketNotExistsWithContextStub - fakeReturns := fake.waitUntilBucketNotExistsWithContextReturns - fake.recordInvocation("WaitUntilBucketNotExistsWithContext", []interface{}{arg1, arg2, arg3}) - fake.waitUntilBucketNotExistsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) WaitUntilBucketNotExistsWithContextCallCount() int { - fake.waitUntilBucketNotExistsWithContextMutex.RLock() - defer fake.waitUntilBucketNotExistsWithContextMutex.RUnlock() - return len(fake.waitUntilBucketNotExistsWithContextArgsForCall) -} - -func (fake *FakeS3Client) WaitUntilBucketNotExistsWithContextCalls(stub func(context.Context, *s3.HeadBucketInput, ...request.WaiterOption) error) { - fake.waitUntilBucketNotExistsWithContextMutex.Lock() - defer fake.waitUntilBucketNotExistsWithContextMutex.Unlock() - fake.WaitUntilBucketNotExistsWithContextStub = stub -} - -func (fake *FakeS3Client) WaitUntilBucketNotExistsWithContextArgsForCall(i int) (context.Context, *s3.HeadBucketInput, []request.WaiterOption) { - fake.waitUntilBucketNotExistsWithContextMutex.RLock() - defer fake.waitUntilBucketNotExistsWithContextMutex.RUnlock() - argsForCall := fake.waitUntilBucketNotExistsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) WaitUntilBucketNotExistsWithContextReturns(result1 error) { - fake.waitUntilBucketNotExistsWithContextMutex.Lock() - defer fake.waitUntilBucketNotExistsWithContextMutex.Unlock() - fake.WaitUntilBucketNotExistsWithContextStub = nil - fake.waitUntilBucketNotExistsWithContextReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilBucketNotExistsWithContextReturnsOnCall(i int, result1 error) { - fake.waitUntilBucketNotExistsWithContextMutex.Lock() - defer fake.waitUntilBucketNotExistsWithContextMutex.Unlock() - fake.WaitUntilBucketNotExistsWithContextStub = nil - if fake.waitUntilBucketNotExistsWithContextReturnsOnCall == nil { - fake.waitUntilBucketNotExistsWithContextReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.waitUntilBucketNotExistsWithContextReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilObjectExists(arg1 *s3.HeadObjectInput) error { - fake.waitUntilObjectExistsMutex.Lock() - ret, specificReturn := fake.waitUntilObjectExistsReturnsOnCall[len(fake.waitUntilObjectExistsArgsForCall)] - fake.waitUntilObjectExistsArgsForCall = append(fake.waitUntilObjectExistsArgsForCall, struct { - arg1 *s3.HeadObjectInput - }{arg1}) - stub := fake.WaitUntilObjectExistsStub - fakeReturns := fake.waitUntilObjectExistsReturns - fake.recordInvocation("WaitUntilObjectExists", []interface{}{arg1}) - fake.waitUntilObjectExistsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) WaitUntilObjectExistsCallCount() int { - fake.waitUntilObjectExistsMutex.RLock() - defer fake.waitUntilObjectExistsMutex.RUnlock() - return len(fake.waitUntilObjectExistsArgsForCall) -} - -func (fake *FakeS3Client) WaitUntilObjectExistsCalls(stub func(*s3.HeadObjectInput) error) { - fake.waitUntilObjectExistsMutex.Lock() - defer fake.waitUntilObjectExistsMutex.Unlock() - fake.WaitUntilObjectExistsStub = stub -} - -func (fake *FakeS3Client) WaitUntilObjectExistsArgsForCall(i int) *s3.HeadObjectInput { - fake.waitUntilObjectExistsMutex.RLock() - defer fake.waitUntilObjectExistsMutex.RUnlock() - argsForCall := fake.waitUntilObjectExistsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) WaitUntilObjectExistsReturns(result1 error) { - fake.waitUntilObjectExistsMutex.Lock() - defer fake.waitUntilObjectExistsMutex.Unlock() - fake.WaitUntilObjectExistsStub = nil - fake.waitUntilObjectExistsReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilObjectExistsReturnsOnCall(i int, result1 error) { - fake.waitUntilObjectExistsMutex.Lock() - defer fake.waitUntilObjectExistsMutex.Unlock() - fake.WaitUntilObjectExistsStub = nil - if fake.waitUntilObjectExistsReturnsOnCall == nil { - fake.waitUntilObjectExistsReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.waitUntilObjectExistsReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilObjectExistsWithContext(arg1 context.Context, arg2 *s3.HeadObjectInput, arg3 ...request.WaiterOption) error { - fake.waitUntilObjectExistsWithContextMutex.Lock() - ret, specificReturn := fake.waitUntilObjectExistsWithContextReturnsOnCall[len(fake.waitUntilObjectExistsWithContextArgsForCall)] - fake.waitUntilObjectExistsWithContextArgsForCall = append(fake.waitUntilObjectExistsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.HeadObjectInput - arg3 []request.WaiterOption - }{arg1, arg2, arg3}) - stub := fake.WaitUntilObjectExistsWithContextStub - fakeReturns := fake.waitUntilObjectExistsWithContextReturns - fake.recordInvocation("WaitUntilObjectExistsWithContext", []interface{}{arg1, arg2, arg3}) - fake.waitUntilObjectExistsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) WaitUntilObjectExistsWithContextCallCount() int { - fake.waitUntilObjectExistsWithContextMutex.RLock() - defer fake.waitUntilObjectExistsWithContextMutex.RUnlock() - return len(fake.waitUntilObjectExistsWithContextArgsForCall) -} - -func (fake *FakeS3Client) WaitUntilObjectExistsWithContextCalls(stub func(context.Context, *s3.HeadObjectInput, ...request.WaiterOption) error) { - fake.waitUntilObjectExistsWithContextMutex.Lock() - defer fake.waitUntilObjectExistsWithContextMutex.Unlock() - fake.WaitUntilObjectExistsWithContextStub = stub -} - -func (fake *FakeS3Client) WaitUntilObjectExistsWithContextArgsForCall(i int) (context.Context, *s3.HeadObjectInput, []request.WaiterOption) { - fake.waitUntilObjectExistsWithContextMutex.RLock() - defer fake.waitUntilObjectExistsWithContextMutex.RUnlock() - argsForCall := fake.waitUntilObjectExistsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) WaitUntilObjectExistsWithContextReturns(result1 error) { - fake.waitUntilObjectExistsWithContextMutex.Lock() - defer fake.waitUntilObjectExistsWithContextMutex.Unlock() - fake.WaitUntilObjectExistsWithContextStub = nil - fake.waitUntilObjectExistsWithContextReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilObjectExistsWithContextReturnsOnCall(i int, result1 error) { - fake.waitUntilObjectExistsWithContextMutex.Lock() - defer fake.waitUntilObjectExistsWithContextMutex.Unlock() - fake.WaitUntilObjectExistsWithContextStub = nil - if fake.waitUntilObjectExistsWithContextReturnsOnCall == nil { - fake.waitUntilObjectExistsWithContextReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.waitUntilObjectExistsWithContextReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilObjectNotExists(arg1 *s3.HeadObjectInput) error { - fake.waitUntilObjectNotExistsMutex.Lock() - ret, specificReturn := fake.waitUntilObjectNotExistsReturnsOnCall[len(fake.waitUntilObjectNotExistsArgsForCall)] - fake.waitUntilObjectNotExistsArgsForCall = append(fake.waitUntilObjectNotExistsArgsForCall, struct { - arg1 *s3.HeadObjectInput - }{arg1}) - stub := fake.WaitUntilObjectNotExistsStub - fakeReturns := fake.waitUntilObjectNotExistsReturns - fake.recordInvocation("WaitUntilObjectNotExists", []interface{}{arg1}) - fake.waitUntilObjectNotExistsMutex.Unlock() - if stub != nil { - return stub(arg1) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) WaitUntilObjectNotExistsCallCount() int { - fake.waitUntilObjectNotExistsMutex.RLock() - defer fake.waitUntilObjectNotExistsMutex.RUnlock() - return len(fake.waitUntilObjectNotExistsArgsForCall) -} - -func (fake *FakeS3Client) WaitUntilObjectNotExistsCalls(stub func(*s3.HeadObjectInput) error) { - fake.waitUntilObjectNotExistsMutex.Lock() - defer fake.waitUntilObjectNotExistsMutex.Unlock() - fake.WaitUntilObjectNotExistsStub = stub -} - -func (fake *FakeS3Client) WaitUntilObjectNotExistsArgsForCall(i int) *s3.HeadObjectInput { - fake.waitUntilObjectNotExistsMutex.RLock() - defer fake.waitUntilObjectNotExistsMutex.RUnlock() - argsForCall := fake.waitUntilObjectNotExistsArgsForCall[i] - return argsForCall.arg1 -} - -func (fake *FakeS3Client) WaitUntilObjectNotExistsReturns(result1 error) { - fake.waitUntilObjectNotExistsMutex.Lock() - defer fake.waitUntilObjectNotExistsMutex.Unlock() - fake.WaitUntilObjectNotExistsStub = nil - fake.waitUntilObjectNotExistsReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilObjectNotExistsReturnsOnCall(i int, result1 error) { - fake.waitUntilObjectNotExistsMutex.Lock() - defer fake.waitUntilObjectNotExistsMutex.Unlock() - fake.WaitUntilObjectNotExistsStub = nil - if fake.waitUntilObjectNotExistsReturnsOnCall == nil { - fake.waitUntilObjectNotExistsReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.waitUntilObjectNotExistsReturnsOnCall[i] = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilObjectNotExistsWithContext(arg1 context.Context, arg2 *s3.HeadObjectInput, arg3 ...request.WaiterOption) error { - fake.waitUntilObjectNotExistsWithContextMutex.Lock() - ret, specificReturn := fake.waitUntilObjectNotExistsWithContextReturnsOnCall[len(fake.waitUntilObjectNotExistsWithContextArgsForCall)] - fake.waitUntilObjectNotExistsWithContextArgsForCall = append(fake.waitUntilObjectNotExistsWithContextArgsForCall, struct { - arg1 context.Context - arg2 *s3.HeadObjectInput - arg3 []request.WaiterOption - }{arg1, arg2, arg3}) - stub := fake.WaitUntilObjectNotExistsWithContextStub - fakeReturns := fake.waitUntilObjectNotExistsWithContextReturns - fake.recordInvocation("WaitUntilObjectNotExistsWithContext", []interface{}{arg1, arg2, arg3}) - fake.waitUntilObjectNotExistsWithContextMutex.Unlock() - if stub != nil { - return stub(arg1, arg2, arg3...) - } - if specificReturn { - return ret.result1 - } - return fakeReturns.result1 -} - -func (fake *FakeS3Client) WaitUntilObjectNotExistsWithContextCallCount() int { - fake.waitUntilObjectNotExistsWithContextMutex.RLock() - defer fake.waitUntilObjectNotExistsWithContextMutex.RUnlock() - return len(fake.waitUntilObjectNotExistsWithContextArgsForCall) -} - -func (fake *FakeS3Client) WaitUntilObjectNotExistsWithContextCalls(stub func(context.Context, *s3.HeadObjectInput, ...request.WaiterOption) error) { - fake.waitUntilObjectNotExistsWithContextMutex.Lock() - defer fake.waitUntilObjectNotExistsWithContextMutex.Unlock() - fake.WaitUntilObjectNotExistsWithContextStub = stub -} - -func (fake *FakeS3Client) WaitUntilObjectNotExistsWithContextArgsForCall(i int) (context.Context, *s3.HeadObjectInput, []request.WaiterOption) { - fake.waitUntilObjectNotExistsWithContextMutex.RLock() - defer fake.waitUntilObjectNotExistsWithContextMutex.RUnlock() - argsForCall := fake.waitUntilObjectNotExistsWithContextArgsForCall[i] - return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 -} - -func (fake *FakeS3Client) WaitUntilObjectNotExistsWithContextReturns(result1 error) { - fake.waitUntilObjectNotExistsWithContextMutex.Lock() - defer fake.waitUntilObjectNotExistsWithContextMutex.Unlock() - fake.WaitUntilObjectNotExistsWithContextStub = nil - fake.waitUntilObjectNotExistsWithContextReturns = struct { - result1 error - }{result1} -} - -func (fake *FakeS3Client) WaitUntilObjectNotExistsWithContextReturnsOnCall(i int, result1 error) { - fake.waitUntilObjectNotExistsWithContextMutex.Lock() - defer fake.waitUntilObjectNotExistsWithContextMutex.Unlock() - fake.WaitUntilObjectNotExistsWithContextStub = nil - if fake.waitUntilObjectNotExistsWithContextReturnsOnCall == nil { - fake.waitUntilObjectNotExistsWithContextReturnsOnCall = make(map[int]struct { - result1 error - }) - } - fake.waitUntilObjectNotExistsWithContextReturnsOnCall[i] = struct { - result1 error - }{result1} -} - func (fake *FakeS3Client) Invocations() map[string][][]interface{} { fake.invocationsMutex.RLock() defer fake.invocationsMutex.RUnlock() - fake.abortMultipartUploadMutex.RLock() - defer fake.abortMultipartUploadMutex.RUnlock() - fake.abortMultipartUploadRequestMutex.RLock() - defer fake.abortMultipartUploadRequestMutex.RUnlock() - fake.abortMultipartUploadWithContextMutex.RLock() - defer fake.abortMultipartUploadWithContextMutex.RUnlock() - fake.completeMultipartUploadMutex.RLock() - defer fake.completeMultipartUploadMutex.RUnlock() - fake.completeMultipartUploadRequestMutex.RLock() - defer fake.completeMultipartUploadRequestMutex.RUnlock() - fake.completeMultipartUploadWithContextMutex.RLock() - defer fake.completeMultipartUploadWithContextMutex.RUnlock() - fake.copyObjectMutex.RLock() - defer fake.copyObjectMutex.RUnlock() - fake.copyObjectRequestMutex.RLock() - defer fake.copyObjectRequestMutex.RUnlock() - fake.copyObjectWithContextMutex.RLock() - defer fake.copyObjectWithContextMutex.RUnlock() - fake.createBucketMutex.RLock() - defer fake.createBucketMutex.RUnlock() - fake.createBucketRequestMutex.RLock() - defer fake.createBucketRequestMutex.RUnlock() - fake.createBucketWithContextMutex.RLock() - defer fake.createBucketWithContextMutex.RUnlock() - fake.createMultipartUploadMutex.RLock() - defer fake.createMultipartUploadMutex.RUnlock() - fake.createMultipartUploadRequestMutex.RLock() - defer fake.createMultipartUploadRequestMutex.RUnlock() - fake.createMultipartUploadWithContextMutex.RLock() - defer fake.createMultipartUploadWithContextMutex.RUnlock() - fake.deleteBucketMutex.RLock() - defer fake.deleteBucketMutex.RUnlock() - fake.deleteBucketAnalyticsConfigurationMutex.RLock() - defer fake.deleteBucketAnalyticsConfigurationMutex.RUnlock() - fake.deleteBucketAnalyticsConfigurationRequestMutex.RLock() - defer fake.deleteBucketAnalyticsConfigurationRequestMutex.RUnlock() - fake.deleteBucketAnalyticsConfigurationWithContextMutex.RLock() - defer fake.deleteBucketAnalyticsConfigurationWithContextMutex.RUnlock() - fake.deleteBucketCorsMutex.RLock() - defer fake.deleteBucketCorsMutex.RUnlock() - fake.deleteBucketCorsRequestMutex.RLock() - defer fake.deleteBucketCorsRequestMutex.RUnlock() - fake.deleteBucketCorsWithContextMutex.RLock() - defer fake.deleteBucketCorsWithContextMutex.RUnlock() - fake.deleteBucketEncryptionMutex.RLock() - defer fake.deleteBucketEncryptionMutex.RUnlock() - fake.deleteBucketEncryptionRequestMutex.RLock() - defer fake.deleteBucketEncryptionRequestMutex.RUnlock() - fake.deleteBucketEncryptionWithContextMutex.RLock() - defer fake.deleteBucketEncryptionWithContextMutex.RUnlock() - fake.deleteBucketIntelligentTieringConfigurationMutex.RLock() - defer fake.deleteBucketIntelligentTieringConfigurationMutex.RUnlock() - fake.deleteBucketIntelligentTieringConfigurationRequestMutex.RLock() - defer fake.deleteBucketIntelligentTieringConfigurationRequestMutex.RUnlock() - fake.deleteBucketIntelligentTieringConfigurationWithContextMutex.RLock() - defer fake.deleteBucketIntelligentTieringConfigurationWithContextMutex.RUnlock() - fake.deleteBucketInventoryConfigurationMutex.RLock() - defer fake.deleteBucketInventoryConfigurationMutex.RUnlock() - fake.deleteBucketInventoryConfigurationRequestMutex.RLock() - defer fake.deleteBucketInventoryConfigurationRequestMutex.RUnlock() - fake.deleteBucketInventoryConfigurationWithContextMutex.RLock() - defer fake.deleteBucketInventoryConfigurationWithContextMutex.RUnlock() - fake.deleteBucketLifecycleMutex.RLock() - defer fake.deleteBucketLifecycleMutex.RUnlock() - fake.deleteBucketLifecycleRequestMutex.RLock() - defer fake.deleteBucketLifecycleRequestMutex.RUnlock() - fake.deleteBucketLifecycleWithContextMutex.RLock() - defer fake.deleteBucketLifecycleWithContextMutex.RUnlock() - fake.deleteBucketMetricsConfigurationMutex.RLock() - defer fake.deleteBucketMetricsConfigurationMutex.RUnlock() - fake.deleteBucketMetricsConfigurationRequestMutex.RLock() - defer fake.deleteBucketMetricsConfigurationRequestMutex.RUnlock() - fake.deleteBucketMetricsConfigurationWithContextMutex.RLock() - defer fake.deleteBucketMetricsConfigurationWithContextMutex.RUnlock() - fake.deleteBucketOwnershipControlsMutex.RLock() - defer fake.deleteBucketOwnershipControlsMutex.RUnlock() - fake.deleteBucketOwnershipControlsRequestMutex.RLock() - defer fake.deleteBucketOwnershipControlsRequestMutex.RUnlock() - fake.deleteBucketOwnershipControlsWithContextMutex.RLock() - defer fake.deleteBucketOwnershipControlsWithContextMutex.RUnlock() - fake.deleteBucketPolicyMutex.RLock() - defer fake.deleteBucketPolicyMutex.RUnlock() - fake.deleteBucketPolicyRequestMutex.RLock() - defer fake.deleteBucketPolicyRequestMutex.RUnlock() - fake.deleteBucketPolicyWithContextMutex.RLock() - defer fake.deleteBucketPolicyWithContextMutex.RUnlock() - fake.deleteBucketReplicationMutex.RLock() - defer fake.deleteBucketReplicationMutex.RUnlock() - fake.deleteBucketReplicationRequestMutex.RLock() - defer fake.deleteBucketReplicationRequestMutex.RUnlock() - fake.deleteBucketReplicationWithContextMutex.RLock() - defer fake.deleteBucketReplicationWithContextMutex.RUnlock() - fake.deleteBucketRequestMutex.RLock() - defer fake.deleteBucketRequestMutex.RUnlock() - fake.deleteBucketTaggingMutex.RLock() - defer fake.deleteBucketTaggingMutex.RUnlock() - fake.deleteBucketTaggingRequestMutex.RLock() - defer fake.deleteBucketTaggingRequestMutex.RUnlock() - fake.deleteBucketTaggingWithContextMutex.RLock() - defer fake.deleteBucketTaggingWithContextMutex.RUnlock() - fake.deleteBucketWebsiteMutex.RLock() - defer fake.deleteBucketWebsiteMutex.RUnlock() - fake.deleteBucketWebsiteRequestMutex.RLock() - defer fake.deleteBucketWebsiteRequestMutex.RUnlock() - fake.deleteBucketWebsiteWithContextMutex.RLock() - defer fake.deleteBucketWebsiteWithContextMutex.RUnlock() - fake.deleteBucketWithContextMutex.RLock() - defer fake.deleteBucketWithContextMutex.RUnlock() - fake.deleteObjectMutex.RLock() - defer fake.deleteObjectMutex.RUnlock() - fake.deleteObjectRequestMutex.RLock() - defer fake.deleteObjectRequestMutex.RUnlock() - fake.deleteObjectTaggingMutex.RLock() - defer fake.deleteObjectTaggingMutex.RUnlock() - fake.deleteObjectTaggingRequestMutex.RLock() - defer fake.deleteObjectTaggingRequestMutex.RUnlock() - fake.deleteObjectTaggingWithContextMutex.RLock() - defer fake.deleteObjectTaggingWithContextMutex.RUnlock() - fake.deleteObjectWithContextMutex.RLock() - defer fake.deleteObjectWithContextMutex.RUnlock() - fake.deleteObjectsMutex.RLock() - defer fake.deleteObjectsMutex.RUnlock() - fake.deleteObjectsRequestMutex.RLock() - defer fake.deleteObjectsRequestMutex.RUnlock() - fake.deleteObjectsWithContextMutex.RLock() - defer fake.deleteObjectsWithContextMutex.RUnlock() - fake.deletePublicAccessBlockMutex.RLock() - defer fake.deletePublicAccessBlockMutex.RUnlock() - fake.deletePublicAccessBlockRequestMutex.RLock() - defer fake.deletePublicAccessBlockRequestMutex.RUnlock() - fake.deletePublicAccessBlockWithContextMutex.RLock() - defer fake.deletePublicAccessBlockWithContextMutex.RUnlock() - fake.getBucketAccelerateConfigurationMutex.RLock() - defer fake.getBucketAccelerateConfigurationMutex.RUnlock() - fake.getBucketAccelerateConfigurationRequestMutex.RLock() - defer fake.getBucketAccelerateConfigurationRequestMutex.RUnlock() - fake.getBucketAccelerateConfigurationWithContextMutex.RLock() - defer fake.getBucketAccelerateConfigurationWithContextMutex.RUnlock() - fake.getBucketAclMutex.RLock() - defer fake.getBucketAclMutex.RUnlock() - fake.getBucketAclRequestMutex.RLock() - defer fake.getBucketAclRequestMutex.RUnlock() - fake.getBucketAclWithContextMutex.RLock() - defer fake.getBucketAclWithContextMutex.RUnlock() - fake.getBucketAnalyticsConfigurationMutex.RLock() - defer fake.getBucketAnalyticsConfigurationMutex.RUnlock() - fake.getBucketAnalyticsConfigurationRequestMutex.RLock() - defer fake.getBucketAnalyticsConfigurationRequestMutex.RUnlock() - fake.getBucketAnalyticsConfigurationWithContextMutex.RLock() - defer fake.getBucketAnalyticsConfigurationWithContextMutex.RUnlock() - fake.getBucketCorsMutex.RLock() - defer fake.getBucketCorsMutex.RUnlock() - fake.getBucketCorsRequestMutex.RLock() - defer fake.getBucketCorsRequestMutex.RUnlock() - fake.getBucketCorsWithContextMutex.RLock() - defer fake.getBucketCorsWithContextMutex.RUnlock() - fake.getBucketEncryptionMutex.RLock() - defer fake.getBucketEncryptionMutex.RUnlock() - fake.getBucketEncryptionRequestMutex.RLock() - defer fake.getBucketEncryptionRequestMutex.RUnlock() - fake.getBucketEncryptionWithContextMutex.RLock() - defer fake.getBucketEncryptionWithContextMutex.RUnlock() - fake.getBucketIntelligentTieringConfigurationMutex.RLock() - defer fake.getBucketIntelligentTieringConfigurationMutex.RUnlock() - fake.getBucketIntelligentTieringConfigurationRequestMutex.RLock() - defer fake.getBucketIntelligentTieringConfigurationRequestMutex.RUnlock() - fake.getBucketIntelligentTieringConfigurationWithContextMutex.RLock() - defer fake.getBucketIntelligentTieringConfigurationWithContextMutex.RUnlock() - fake.getBucketInventoryConfigurationMutex.RLock() - defer fake.getBucketInventoryConfigurationMutex.RUnlock() - fake.getBucketInventoryConfigurationRequestMutex.RLock() - defer fake.getBucketInventoryConfigurationRequestMutex.RUnlock() - fake.getBucketInventoryConfigurationWithContextMutex.RLock() - defer fake.getBucketInventoryConfigurationWithContextMutex.RUnlock() - fake.getBucketLifecycleMutex.RLock() - defer fake.getBucketLifecycleMutex.RUnlock() - fake.getBucketLifecycleConfigurationMutex.RLock() - defer fake.getBucketLifecycleConfigurationMutex.RUnlock() - fake.getBucketLifecycleConfigurationRequestMutex.RLock() - defer fake.getBucketLifecycleConfigurationRequestMutex.RUnlock() - fake.getBucketLifecycleConfigurationWithContextMutex.RLock() - defer fake.getBucketLifecycleConfigurationWithContextMutex.RUnlock() - fake.getBucketLifecycleRequestMutex.RLock() - defer fake.getBucketLifecycleRequestMutex.RUnlock() - fake.getBucketLifecycleWithContextMutex.RLock() - defer fake.getBucketLifecycleWithContextMutex.RUnlock() - fake.getBucketLocationMutex.RLock() - defer fake.getBucketLocationMutex.RUnlock() - fake.getBucketLocationRequestMutex.RLock() - defer fake.getBucketLocationRequestMutex.RUnlock() - fake.getBucketLocationWithContextMutex.RLock() - defer fake.getBucketLocationWithContextMutex.RUnlock() - fake.getBucketLoggingMutex.RLock() - defer fake.getBucketLoggingMutex.RUnlock() - fake.getBucketLoggingRequestMutex.RLock() - defer fake.getBucketLoggingRequestMutex.RUnlock() - fake.getBucketLoggingWithContextMutex.RLock() - defer fake.getBucketLoggingWithContextMutex.RUnlock() - fake.getBucketMetricsConfigurationMutex.RLock() - defer fake.getBucketMetricsConfigurationMutex.RUnlock() - fake.getBucketMetricsConfigurationRequestMutex.RLock() - defer fake.getBucketMetricsConfigurationRequestMutex.RUnlock() - fake.getBucketMetricsConfigurationWithContextMutex.RLock() - defer fake.getBucketMetricsConfigurationWithContextMutex.RUnlock() - fake.getBucketNotificationMutex.RLock() - defer fake.getBucketNotificationMutex.RUnlock() - fake.getBucketNotificationConfigurationMutex.RLock() - defer fake.getBucketNotificationConfigurationMutex.RUnlock() - fake.getBucketNotificationConfigurationRequestMutex.RLock() - defer fake.getBucketNotificationConfigurationRequestMutex.RUnlock() - fake.getBucketNotificationConfigurationWithContextMutex.RLock() - defer fake.getBucketNotificationConfigurationWithContextMutex.RUnlock() - fake.getBucketNotificationRequestMutex.RLock() - defer fake.getBucketNotificationRequestMutex.RUnlock() - fake.getBucketNotificationWithContextMutex.RLock() - defer fake.getBucketNotificationWithContextMutex.RUnlock() - fake.getBucketOwnershipControlsMutex.RLock() - defer fake.getBucketOwnershipControlsMutex.RUnlock() - fake.getBucketOwnershipControlsRequestMutex.RLock() - defer fake.getBucketOwnershipControlsRequestMutex.RUnlock() - fake.getBucketOwnershipControlsWithContextMutex.RLock() - defer fake.getBucketOwnershipControlsWithContextMutex.RUnlock() - fake.getBucketPolicyMutex.RLock() - defer fake.getBucketPolicyMutex.RUnlock() - fake.getBucketPolicyRequestMutex.RLock() - defer fake.getBucketPolicyRequestMutex.RUnlock() - fake.getBucketPolicyStatusMutex.RLock() - defer fake.getBucketPolicyStatusMutex.RUnlock() - fake.getBucketPolicyStatusRequestMutex.RLock() - defer fake.getBucketPolicyStatusRequestMutex.RUnlock() - fake.getBucketPolicyStatusWithContextMutex.RLock() - defer fake.getBucketPolicyStatusWithContextMutex.RUnlock() - fake.getBucketPolicyWithContextMutex.RLock() - defer fake.getBucketPolicyWithContextMutex.RUnlock() - fake.getBucketReplicationMutex.RLock() - defer fake.getBucketReplicationMutex.RUnlock() - fake.getBucketReplicationRequestMutex.RLock() - defer fake.getBucketReplicationRequestMutex.RUnlock() - fake.getBucketReplicationWithContextMutex.RLock() - defer fake.getBucketReplicationWithContextMutex.RUnlock() - fake.getBucketRequestPaymentMutex.RLock() - defer fake.getBucketRequestPaymentMutex.RUnlock() - fake.getBucketRequestPaymentRequestMutex.RLock() - defer fake.getBucketRequestPaymentRequestMutex.RUnlock() - fake.getBucketRequestPaymentWithContextMutex.RLock() - defer fake.getBucketRequestPaymentWithContextMutex.RUnlock() - fake.getBucketTaggingMutex.RLock() - defer fake.getBucketTaggingMutex.RUnlock() - fake.getBucketTaggingRequestMutex.RLock() - defer fake.getBucketTaggingRequestMutex.RUnlock() - fake.getBucketTaggingWithContextMutex.RLock() - defer fake.getBucketTaggingWithContextMutex.RUnlock() - fake.getBucketVersioningMutex.RLock() - defer fake.getBucketVersioningMutex.RUnlock() - fake.getBucketVersioningRequestMutex.RLock() - defer fake.getBucketVersioningRequestMutex.RUnlock() - fake.getBucketVersioningWithContextMutex.RLock() - defer fake.getBucketVersioningWithContextMutex.RUnlock() - fake.getBucketWebsiteMutex.RLock() - defer fake.getBucketWebsiteMutex.RUnlock() - fake.getBucketWebsiteRequestMutex.RLock() - defer fake.getBucketWebsiteRequestMutex.RUnlock() - fake.getBucketWebsiteWithContextMutex.RLock() - defer fake.getBucketWebsiteWithContextMutex.RUnlock() fake.getObjectMutex.RLock() defer fake.getObjectMutex.RUnlock() - fake.getObjectAclMutex.RLock() - defer fake.getObjectAclMutex.RUnlock() - fake.getObjectAclRequestMutex.RLock() - defer fake.getObjectAclRequestMutex.RUnlock() - fake.getObjectAclWithContextMutex.RLock() - defer fake.getObjectAclWithContextMutex.RUnlock() - fake.getObjectLegalHoldMutex.RLock() - defer fake.getObjectLegalHoldMutex.RUnlock() - fake.getObjectLegalHoldRequestMutex.RLock() - defer fake.getObjectLegalHoldRequestMutex.RUnlock() - fake.getObjectLegalHoldWithContextMutex.RLock() - defer fake.getObjectLegalHoldWithContextMutex.RUnlock() - fake.getObjectLockConfigurationMutex.RLock() - defer fake.getObjectLockConfigurationMutex.RUnlock() - fake.getObjectLockConfigurationRequestMutex.RLock() - defer fake.getObjectLockConfigurationRequestMutex.RUnlock() - fake.getObjectLockConfigurationWithContextMutex.RLock() - defer fake.getObjectLockConfigurationWithContextMutex.RUnlock() - fake.getObjectRequestMutex.RLock() - defer fake.getObjectRequestMutex.RUnlock() - fake.getObjectRetentionMutex.RLock() - defer fake.getObjectRetentionMutex.RUnlock() - fake.getObjectRetentionRequestMutex.RLock() - defer fake.getObjectRetentionRequestMutex.RUnlock() - fake.getObjectRetentionWithContextMutex.RLock() - defer fake.getObjectRetentionWithContextMutex.RUnlock() - fake.getObjectTaggingMutex.RLock() - defer fake.getObjectTaggingMutex.RUnlock() - fake.getObjectTaggingRequestMutex.RLock() - defer fake.getObjectTaggingRequestMutex.RUnlock() - fake.getObjectTaggingWithContextMutex.RLock() - defer fake.getObjectTaggingWithContextMutex.RUnlock() - fake.getObjectTorrentMutex.RLock() - defer fake.getObjectTorrentMutex.RUnlock() - fake.getObjectTorrentRequestMutex.RLock() - defer fake.getObjectTorrentRequestMutex.RUnlock() - fake.getObjectTorrentWithContextMutex.RLock() - defer fake.getObjectTorrentWithContextMutex.RUnlock() - fake.getObjectWithContextMutex.RLock() - defer fake.getObjectWithContextMutex.RUnlock() - fake.getPublicAccessBlockMutex.RLock() - defer fake.getPublicAccessBlockMutex.RUnlock() - fake.getPublicAccessBlockRequestMutex.RLock() - defer fake.getPublicAccessBlockRequestMutex.RUnlock() - fake.getPublicAccessBlockWithContextMutex.RLock() - defer fake.getPublicAccessBlockWithContextMutex.RUnlock() - fake.headBucketMutex.RLock() - defer fake.headBucketMutex.RUnlock() - fake.headBucketRequestMutex.RLock() - defer fake.headBucketRequestMutex.RUnlock() - fake.headBucketWithContextMutex.RLock() - defer fake.headBucketWithContextMutex.RUnlock() - fake.headObjectMutex.RLock() - defer fake.headObjectMutex.RUnlock() - fake.headObjectRequestMutex.RLock() - defer fake.headObjectRequestMutex.RUnlock() - fake.headObjectWithContextMutex.RLock() - defer fake.headObjectWithContextMutex.RUnlock() - fake.listBucketAnalyticsConfigurationsMutex.RLock() - defer fake.listBucketAnalyticsConfigurationsMutex.RUnlock() - fake.listBucketAnalyticsConfigurationsRequestMutex.RLock() - defer fake.listBucketAnalyticsConfigurationsRequestMutex.RUnlock() - fake.listBucketAnalyticsConfigurationsWithContextMutex.RLock() - defer fake.listBucketAnalyticsConfigurationsWithContextMutex.RUnlock() - fake.listBucketIntelligentTieringConfigurationsMutex.RLock() - defer fake.listBucketIntelligentTieringConfigurationsMutex.RUnlock() - fake.listBucketIntelligentTieringConfigurationsRequestMutex.RLock() - defer fake.listBucketIntelligentTieringConfigurationsRequestMutex.RUnlock() - fake.listBucketIntelligentTieringConfigurationsWithContextMutex.RLock() - defer fake.listBucketIntelligentTieringConfigurationsWithContextMutex.RUnlock() - fake.listBucketInventoryConfigurationsMutex.RLock() - defer fake.listBucketInventoryConfigurationsMutex.RUnlock() - fake.listBucketInventoryConfigurationsRequestMutex.RLock() - defer fake.listBucketInventoryConfigurationsRequestMutex.RUnlock() - fake.listBucketInventoryConfigurationsWithContextMutex.RLock() - defer fake.listBucketInventoryConfigurationsWithContextMutex.RUnlock() - fake.listBucketMetricsConfigurationsMutex.RLock() - defer fake.listBucketMetricsConfigurationsMutex.RUnlock() - fake.listBucketMetricsConfigurationsRequestMutex.RLock() - defer fake.listBucketMetricsConfigurationsRequestMutex.RUnlock() - fake.listBucketMetricsConfigurationsWithContextMutex.RLock() - defer fake.listBucketMetricsConfigurationsWithContextMutex.RUnlock() - fake.listBucketsMutex.RLock() - defer fake.listBucketsMutex.RUnlock() - fake.listBucketsRequestMutex.RLock() - defer fake.listBucketsRequestMutex.RUnlock() - fake.listBucketsWithContextMutex.RLock() - defer fake.listBucketsWithContextMutex.RUnlock() - fake.listMultipartUploadsMutex.RLock() - defer fake.listMultipartUploadsMutex.RUnlock() - fake.listMultipartUploadsPagesMutex.RLock() - defer fake.listMultipartUploadsPagesMutex.RUnlock() - fake.listMultipartUploadsPagesWithContextMutex.RLock() - defer fake.listMultipartUploadsPagesWithContextMutex.RUnlock() - fake.listMultipartUploadsRequestMutex.RLock() - defer fake.listMultipartUploadsRequestMutex.RUnlock() - fake.listMultipartUploadsWithContextMutex.RLock() - defer fake.listMultipartUploadsWithContextMutex.RUnlock() - fake.listObjectVersionsMutex.RLock() - defer fake.listObjectVersionsMutex.RUnlock() - fake.listObjectVersionsPagesMutex.RLock() - defer fake.listObjectVersionsPagesMutex.RUnlock() - fake.listObjectVersionsPagesWithContextMutex.RLock() - defer fake.listObjectVersionsPagesWithContextMutex.RUnlock() - fake.listObjectVersionsRequestMutex.RLock() - defer fake.listObjectVersionsRequestMutex.RUnlock() - fake.listObjectVersionsWithContextMutex.RLock() - defer fake.listObjectVersionsWithContextMutex.RUnlock() - fake.listObjectsMutex.RLock() - defer fake.listObjectsMutex.RUnlock() - fake.listObjectsPagesMutex.RLock() - defer fake.listObjectsPagesMutex.RUnlock() - fake.listObjectsPagesWithContextMutex.RLock() - defer fake.listObjectsPagesWithContextMutex.RUnlock() - fake.listObjectsRequestMutex.RLock() - defer fake.listObjectsRequestMutex.RUnlock() - fake.listObjectsV2Mutex.RLock() - defer fake.listObjectsV2Mutex.RUnlock() - fake.listObjectsV2PagesMutex.RLock() - defer fake.listObjectsV2PagesMutex.RUnlock() - fake.listObjectsV2PagesWithContextMutex.RLock() - defer fake.listObjectsV2PagesWithContextMutex.RUnlock() - fake.listObjectsV2RequestMutex.RLock() - defer fake.listObjectsV2RequestMutex.RUnlock() - fake.listObjectsV2WithContextMutex.RLock() - defer fake.listObjectsV2WithContextMutex.RUnlock() - fake.listObjectsWithContextMutex.RLock() - defer fake.listObjectsWithContextMutex.RUnlock() - fake.listPartsMutex.RLock() - defer fake.listPartsMutex.RUnlock() - fake.listPartsPagesMutex.RLock() - defer fake.listPartsPagesMutex.RUnlock() - fake.listPartsPagesWithContextMutex.RLock() - defer fake.listPartsPagesWithContextMutex.RUnlock() - fake.listPartsRequestMutex.RLock() - defer fake.listPartsRequestMutex.RUnlock() - fake.listPartsWithContextMutex.RLock() - defer fake.listPartsWithContextMutex.RUnlock() - fake.putBucketAccelerateConfigurationMutex.RLock() - defer fake.putBucketAccelerateConfigurationMutex.RUnlock() - fake.putBucketAccelerateConfigurationRequestMutex.RLock() - defer fake.putBucketAccelerateConfigurationRequestMutex.RUnlock() - fake.putBucketAccelerateConfigurationWithContextMutex.RLock() - defer fake.putBucketAccelerateConfigurationWithContextMutex.RUnlock() - fake.putBucketAclMutex.RLock() - defer fake.putBucketAclMutex.RUnlock() - fake.putBucketAclRequestMutex.RLock() - defer fake.putBucketAclRequestMutex.RUnlock() - fake.putBucketAclWithContextMutex.RLock() - defer fake.putBucketAclWithContextMutex.RUnlock() - fake.putBucketAnalyticsConfigurationMutex.RLock() - defer fake.putBucketAnalyticsConfigurationMutex.RUnlock() - fake.putBucketAnalyticsConfigurationRequestMutex.RLock() - defer fake.putBucketAnalyticsConfigurationRequestMutex.RUnlock() - fake.putBucketAnalyticsConfigurationWithContextMutex.RLock() - defer fake.putBucketAnalyticsConfigurationWithContextMutex.RUnlock() - fake.putBucketCorsMutex.RLock() - defer fake.putBucketCorsMutex.RUnlock() - fake.putBucketCorsRequestMutex.RLock() - defer fake.putBucketCorsRequestMutex.RUnlock() - fake.putBucketCorsWithContextMutex.RLock() - defer fake.putBucketCorsWithContextMutex.RUnlock() - fake.putBucketEncryptionMutex.RLock() - defer fake.putBucketEncryptionMutex.RUnlock() - fake.putBucketEncryptionRequestMutex.RLock() - defer fake.putBucketEncryptionRequestMutex.RUnlock() - fake.putBucketEncryptionWithContextMutex.RLock() - defer fake.putBucketEncryptionWithContextMutex.RUnlock() - fake.putBucketIntelligentTieringConfigurationMutex.RLock() - defer fake.putBucketIntelligentTieringConfigurationMutex.RUnlock() - fake.putBucketIntelligentTieringConfigurationRequestMutex.RLock() - defer fake.putBucketIntelligentTieringConfigurationRequestMutex.RUnlock() - fake.putBucketIntelligentTieringConfigurationWithContextMutex.RLock() - defer fake.putBucketIntelligentTieringConfigurationWithContextMutex.RUnlock() - fake.putBucketInventoryConfigurationMutex.RLock() - defer fake.putBucketInventoryConfigurationMutex.RUnlock() - fake.putBucketInventoryConfigurationRequestMutex.RLock() - defer fake.putBucketInventoryConfigurationRequestMutex.RUnlock() - fake.putBucketInventoryConfigurationWithContextMutex.RLock() - defer fake.putBucketInventoryConfigurationWithContextMutex.RUnlock() - fake.putBucketLifecycleMutex.RLock() - defer fake.putBucketLifecycleMutex.RUnlock() - fake.putBucketLifecycleConfigurationMutex.RLock() - defer fake.putBucketLifecycleConfigurationMutex.RUnlock() - fake.putBucketLifecycleConfigurationRequestMutex.RLock() - defer fake.putBucketLifecycleConfigurationRequestMutex.RUnlock() - fake.putBucketLifecycleConfigurationWithContextMutex.RLock() - defer fake.putBucketLifecycleConfigurationWithContextMutex.RUnlock() - fake.putBucketLifecycleRequestMutex.RLock() - defer fake.putBucketLifecycleRequestMutex.RUnlock() - fake.putBucketLifecycleWithContextMutex.RLock() - defer fake.putBucketLifecycleWithContextMutex.RUnlock() - fake.putBucketLoggingMutex.RLock() - defer fake.putBucketLoggingMutex.RUnlock() - fake.putBucketLoggingRequestMutex.RLock() - defer fake.putBucketLoggingRequestMutex.RUnlock() - fake.putBucketLoggingWithContextMutex.RLock() - defer fake.putBucketLoggingWithContextMutex.RUnlock() - fake.putBucketMetricsConfigurationMutex.RLock() - defer fake.putBucketMetricsConfigurationMutex.RUnlock() - fake.putBucketMetricsConfigurationRequestMutex.RLock() - defer fake.putBucketMetricsConfigurationRequestMutex.RUnlock() - fake.putBucketMetricsConfigurationWithContextMutex.RLock() - defer fake.putBucketMetricsConfigurationWithContextMutex.RUnlock() - fake.putBucketNotificationMutex.RLock() - defer fake.putBucketNotificationMutex.RUnlock() - fake.putBucketNotificationConfigurationMutex.RLock() - defer fake.putBucketNotificationConfigurationMutex.RUnlock() - fake.putBucketNotificationConfigurationRequestMutex.RLock() - defer fake.putBucketNotificationConfigurationRequestMutex.RUnlock() - fake.putBucketNotificationConfigurationWithContextMutex.RLock() - defer fake.putBucketNotificationConfigurationWithContextMutex.RUnlock() - fake.putBucketNotificationRequestMutex.RLock() - defer fake.putBucketNotificationRequestMutex.RUnlock() - fake.putBucketNotificationWithContextMutex.RLock() - defer fake.putBucketNotificationWithContextMutex.RUnlock() - fake.putBucketOwnershipControlsMutex.RLock() - defer fake.putBucketOwnershipControlsMutex.RUnlock() - fake.putBucketOwnershipControlsRequestMutex.RLock() - defer fake.putBucketOwnershipControlsRequestMutex.RUnlock() - fake.putBucketOwnershipControlsWithContextMutex.RLock() - defer fake.putBucketOwnershipControlsWithContextMutex.RUnlock() - fake.putBucketPolicyMutex.RLock() - defer fake.putBucketPolicyMutex.RUnlock() - fake.putBucketPolicyRequestMutex.RLock() - defer fake.putBucketPolicyRequestMutex.RUnlock() - fake.putBucketPolicyWithContextMutex.RLock() - defer fake.putBucketPolicyWithContextMutex.RUnlock() - fake.putBucketReplicationMutex.RLock() - defer fake.putBucketReplicationMutex.RUnlock() - fake.putBucketReplicationRequestMutex.RLock() - defer fake.putBucketReplicationRequestMutex.RUnlock() - fake.putBucketReplicationWithContextMutex.RLock() - defer fake.putBucketReplicationWithContextMutex.RUnlock() - fake.putBucketRequestPaymentMutex.RLock() - defer fake.putBucketRequestPaymentMutex.RUnlock() - fake.putBucketRequestPaymentRequestMutex.RLock() - defer fake.putBucketRequestPaymentRequestMutex.RUnlock() - fake.putBucketRequestPaymentWithContextMutex.RLock() - defer fake.putBucketRequestPaymentWithContextMutex.RUnlock() - fake.putBucketTaggingMutex.RLock() - defer fake.putBucketTaggingMutex.RUnlock() - fake.putBucketTaggingRequestMutex.RLock() - defer fake.putBucketTaggingRequestMutex.RUnlock() - fake.putBucketTaggingWithContextMutex.RLock() - defer fake.putBucketTaggingWithContextMutex.RUnlock() - fake.putBucketVersioningMutex.RLock() - defer fake.putBucketVersioningMutex.RUnlock() - fake.putBucketVersioningRequestMutex.RLock() - defer fake.putBucketVersioningRequestMutex.RUnlock() - fake.putBucketVersioningWithContextMutex.RLock() - defer fake.putBucketVersioningWithContextMutex.RUnlock() - fake.putBucketWebsiteMutex.RLock() - defer fake.putBucketWebsiteMutex.RUnlock() - fake.putBucketWebsiteRequestMutex.RLock() - defer fake.putBucketWebsiteRequestMutex.RUnlock() - fake.putBucketWebsiteWithContextMutex.RLock() - defer fake.putBucketWebsiteWithContextMutex.RUnlock() - fake.putObjectMutex.RLock() - defer fake.putObjectMutex.RUnlock() - fake.putObjectAclMutex.RLock() - defer fake.putObjectAclMutex.RUnlock() - fake.putObjectAclRequestMutex.RLock() - defer fake.putObjectAclRequestMutex.RUnlock() - fake.putObjectAclWithContextMutex.RLock() - defer fake.putObjectAclWithContextMutex.RUnlock() - fake.putObjectLegalHoldMutex.RLock() - defer fake.putObjectLegalHoldMutex.RUnlock() - fake.putObjectLegalHoldRequestMutex.RLock() - defer fake.putObjectLegalHoldRequestMutex.RUnlock() - fake.putObjectLegalHoldWithContextMutex.RLock() - defer fake.putObjectLegalHoldWithContextMutex.RUnlock() - fake.putObjectLockConfigurationMutex.RLock() - defer fake.putObjectLockConfigurationMutex.RUnlock() - fake.putObjectLockConfigurationRequestMutex.RLock() - defer fake.putObjectLockConfigurationRequestMutex.RUnlock() - fake.putObjectLockConfigurationWithContextMutex.RLock() - defer fake.putObjectLockConfigurationWithContextMutex.RUnlock() - fake.putObjectRequestMutex.RLock() - defer fake.putObjectRequestMutex.RUnlock() - fake.putObjectRetentionMutex.RLock() - defer fake.putObjectRetentionMutex.RUnlock() - fake.putObjectRetentionRequestMutex.RLock() - defer fake.putObjectRetentionRequestMutex.RUnlock() - fake.putObjectRetentionWithContextMutex.RLock() - defer fake.putObjectRetentionWithContextMutex.RUnlock() - fake.putObjectTaggingMutex.RLock() - defer fake.putObjectTaggingMutex.RUnlock() - fake.putObjectTaggingRequestMutex.RLock() - defer fake.putObjectTaggingRequestMutex.RUnlock() - fake.putObjectTaggingWithContextMutex.RLock() - defer fake.putObjectTaggingWithContextMutex.RUnlock() - fake.putObjectWithContextMutex.RLock() - defer fake.putObjectWithContextMutex.RUnlock() - fake.putPublicAccessBlockMutex.RLock() - defer fake.putPublicAccessBlockMutex.RUnlock() - fake.putPublicAccessBlockRequestMutex.RLock() - defer fake.putPublicAccessBlockRequestMutex.RUnlock() - fake.putPublicAccessBlockWithContextMutex.RLock() - defer fake.putPublicAccessBlockWithContextMutex.RUnlock() - fake.restoreObjectMutex.RLock() - defer fake.restoreObjectMutex.RUnlock() - fake.restoreObjectRequestMutex.RLock() - defer fake.restoreObjectRequestMutex.RUnlock() - fake.restoreObjectWithContextMutex.RLock() - defer fake.restoreObjectWithContextMutex.RUnlock() - fake.selectObjectContentMutex.RLock() - defer fake.selectObjectContentMutex.RUnlock() - fake.selectObjectContentRequestMutex.RLock() - defer fake.selectObjectContentRequestMutex.RUnlock() - fake.selectObjectContentWithContextMutex.RLock() - defer fake.selectObjectContentWithContextMutex.RUnlock() - fake.uploadPartMutex.RLock() - defer fake.uploadPartMutex.RUnlock() - fake.uploadPartCopyMutex.RLock() - defer fake.uploadPartCopyMutex.RUnlock() - fake.uploadPartCopyRequestMutex.RLock() - defer fake.uploadPartCopyRequestMutex.RUnlock() - fake.uploadPartCopyWithContextMutex.RLock() - defer fake.uploadPartCopyWithContextMutex.RUnlock() - fake.uploadPartRequestMutex.RLock() - defer fake.uploadPartRequestMutex.RUnlock() - fake.uploadPartWithContextMutex.RLock() - defer fake.uploadPartWithContextMutex.RUnlock() - fake.waitUntilBucketExistsMutex.RLock() - defer fake.waitUntilBucketExistsMutex.RUnlock() - fake.waitUntilBucketExistsWithContextMutex.RLock() - defer fake.waitUntilBucketExistsWithContextMutex.RUnlock() - fake.waitUntilBucketNotExistsMutex.RLock() - defer fake.waitUntilBucketNotExistsMutex.RUnlock() - fake.waitUntilBucketNotExistsWithContextMutex.RLock() - defer fake.waitUntilBucketNotExistsWithContextMutex.RUnlock() - fake.waitUntilObjectExistsMutex.RLock() - defer fake.waitUntilObjectExistsMutex.RUnlock() - fake.waitUntilObjectExistsWithContextMutex.RLock() - defer fake.waitUntilObjectExistsWithContextMutex.RUnlock() - fake.waitUntilObjectNotExistsMutex.RLock() - defer fake.waitUntilObjectNotExistsMutex.RUnlock() - fake.waitUntilObjectNotExistsWithContextMutex.RLock() - defer fake.waitUntilObjectNotExistsWithContextMutex.RUnlock() copiedInvocations := map[string][][]interface{}{} for key, value := range fake.invocations { copiedInvocations[key] = value diff --git a/pkg/reflector/download_test.go b/pkg/reflector/download_test.go index 808e211b..7311e067 100644 --- a/pkg/reflector/download_test.go +++ b/pkg/reflector/download_test.go @@ -3,6 +3,7 @@ package reflector_test import ( "bytes" "compress/gzip" + "github.com/aws/aws-sdk-go/aws/awserr" "io" "io/ioutil" "math/rand" @@ -10,8 +11,8 @@ import ( "strings" "testing" - "github.com/aws/aws-sdk-go/aws/awserr" - "github.com/aws/aws-sdk-go/service/s3" + "github.com/aws/aws-sdk-go-v2/service/s3" + //"github.com/aws/aws-sdk-go/aws/awserr" "github.com/segmentio/ctlstore/pkg/fakes" "github.com/segmentio/ctlstore/pkg/reflector" "github.com/segmentio/errors-go" @@ -21,7 +22,7 @@ import ( // Verifies error handling behavior when downloading from s3 fails. // Specifically, the supervisor is allowed to create a new LDB if // a 404 is received from S3, and other errors from S3 are able -// to be retried. These behaviors result from the kind of error +// to be retired. These behaviors result from the kind of error // that s3Downloader.DownloadTo(writer) returns. func TestS3DownloadErrors(t *testing.T) { for _, test := range []struct { @@ -160,7 +161,7 @@ func TestS3Downloader(t *testing.T) { contentLength := int64(len(toWrite)) fake.GetObjectReturns(&s3.GetObjectOutput{ Body: ioutil.NopCloser(bytes.NewReader(toWrite)), - ContentLength: &contentLength, + ContentLength: contentLength, }, nil) sd := &reflector.S3Downloader{ @@ -171,7 +172,7 @@ func TestS3Downloader(t *testing.T) { w := new(bytes.Buffer) n, err := sd.DownloadTo(w) - arg := fake.GetObjectArgsForCall(0) + _, arg, _ := fake.GetObjectArgsForCall(0) require.Equal(t, test.bucket, *arg.Bucket) require.Equal(t, test.key, *arg.Key) From fbdf1012a13618fbc9c4ca9962535a22398ecc25 Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Thu, 3 Aug 2023 15:31:17 -0400 Subject: [PATCH 15/27] use klauspost/pgzip --- go.mod | 3 ++- go.sum | 2 ++ pkg/reflector/download.go | 2 +- pkg/reflector/download_test.go | 8 ++++---- 4 files changed, 9 insertions(+), 6 deletions(-) diff --git a/go.mod b/go.mod index efea127b..0e187349 100644 --- a/go.mod +++ b/go.mod @@ -15,7 +15,7 @@ require ( github.com/google/uuid v1.1.2 github.com/gorilla/mux v1.7.3 github.com/julienschmidt/httprouter v1.2.0 - github.com/klauspost/compress v1.16.7 + github.com/klauspost/pgzip v1.2.6 github.com/maxbrunsfeld/counterfeiter/v6 v6.4.1 github.com/pkg/errors v0.9.1 github.com/segmentio/cli v0.5.1 @@ -45,6 +45,7 @@ require ( github.com/aws/smithy-go v1.13.5 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/jmespath/go-jmespath v0.4.0 // indirect + github.com/klauspost/compress v1.16.7 // indirect github.com/mdlayher/genetlink v0.0.0-20190313224034-60417448a851 // indirect github.com/mdlayher/netlink v0.0.0-20190313131330-258ea9dff42c // indirect github.com/mdlayher/taskstats v0.0.0-20190313225729-7cbba52ee072 // indirect diff --git a/go.sum b/go.sum index fab76d02..06fe2f3e 100644 --- a/go.sum +++ b/go.sum @@ -77,6 +77,8 @@ github.com/julienschmidt/httprouter v1.2.0 h1:TDTW5Yz1mjftljbcKqRcrYhd4XeOoI98t+ github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I= github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE= +github.com/klauspost/pgzip v1.2.6 h1:8RXeL5crjEUFnR2/Sn6GJNWtSQ3Dk8pq4CL3jvdDyjU= +github.com/klauspost/pgzip v1.2.6/go.mod h1:Ch1tH69qFZu15pkjo5kYi6mth2Zzwzt50oCQKQE9RUs= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= diff --git a/pkg/reflector/download.go b/pkg/reflector/download.go index d5cdf405..d001d708 100644 --- a/pkg/reflector/download.go +++ b/pkg/reflector/download.go @@ -2,7 +2,6 @@ package reflector import ( "bytes" - "compress/gzip" "context" "fmt" "io" @@ -16,6 +15,7 @@ import ( "github.com/aws/aws-sdk-go-v2/feature/s3/manager" "github.com/aws/aws-sdk-go-v2/service/s3" "github.com/aws/aws-sdk-go/aws/awserr" + gzip "github.com/klauspost/pgzip" "github.com/segmentio/ctlstore/pkg/errs" "github.com/segmentio/errors-go" diff --git a/pkg/reflector/download_test.go b/pkg/reflector/download_test.go index 7311e067..d7f3c13a 100644 --- a/pkg/reflector/download_test.go +++ b/pkg/reflector/download_test.go @@ -2,8 +2,6 @@ package reflector_test import ( "bytes" - "compress/gzip" - "github.com/aws/aws-sdk-go/aws/awserr" "io" "io/ioutil" "math/rand" @@ -12,11 +10,13 @@ import ( "testing" "github.com/aws/aws-sdk-go-v2/service/s3" - //"github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/aws/awserr" + gzip "github.com/klauspost/pgzip" + "github.com/stretchr/testify/require" + "github.com/segmentio/ctlstore/pkg/fakes" "github.com/segmentio/ctlstore/pkg/reflector" "github.com/segmentio/errors-go" - "github.com/stretchr/testify/require" ) // Verifies error handling behavior when downloading from s3 fails. From 7a6b7476b8d247a07801da29650a3710a98f76c1 Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Thu, 3 Aug 2023 18:07:54 -0400 Subject: [PATCH 16/27] replace awserr with smithy-go --- go.mod | 12 +++++++----- go.sum | 19 ++++++++++++++----- pkg/reflector/download.go | 18 +++++++++++------- 3 files changed, 32 insertions(+), 17 deletions(-) diff --git a/go.mod b/go.mod index 0e187349..f83eaaca 100644 --- a/go.mod +++ b/go.mod @@ -5,10 +5,12 @@ go 1.20 require ( github.com/AlekSi/pointer v1.0.0 github.com/aws/aws-sdk-go v1.37.8 - github.com/aws/aws-sdk-go-v2 v1.19.0 + github.com/aws/aws-sdk-go-v2 v1.20.0 github.com/aws/aws-sdk-go-v2/config v1.18.29 github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.11.73 + github.com/aws/aws-sdk-go-v2/service/dynamodb v1.21.1 github.com/aws/aws-sdk-go-v2/service/s3 v1.37.0 + github.com/aws/smithy-go v1.14.0 github.com/fsnotify/fsnotify v1.5.1 github.com/go-sql-driver/mysql v1.4.1 github.com/google/go-cmp v0.5.8 @@ -31,18 +33,18 @@ require ( github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.4.10 // indirect github.com/aws/aws-sdk-go-v2/credentials v1.13.28 // indirect github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.13.5 // indirect - github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.35 // indirect - github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.29 // indirect + github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.37 // indirect + github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.31 // indirect github.com/aws/aws-sdk-go-v2/internal/ini v1.3.36 // indirect github.com/aws/aws-sdk-go-v2/internal/v4a v1.0.27 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.11 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.12 // indirect github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.30 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.7.31 // indirect github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.29 // indirect github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.14.4 // indirect github.com/aws/aws-sdk-go-v2/service/sso v1.12.13 // indirect github.com/aws/aws-sdk-go-v2/service/ssooidc v1.14.13 // indirect github.com/aws/aws-sdk-go-v2/service/sts v1.20.0 // indirect - github.com/aws/smithy-go v1.13.5 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/jmespath/go-jmespath v0.4.0 // indirect github.com/klauspost/compress v1.16.7 // indirect diff --git a/go.sum b/go.sum index 06fe2f3e..84aa4a83 100644 --- a/go.sum +++ b/go.sum @@ -4,8 +4,9 @@ github.com/PuerkitoBio/goquery v1.8.1/go.mod h1:Q8ICL1kNUJ2sXGoAhPGUdYDJvgQgHzJs github.com/andybalholm/cascadia v1.3.1/go.mod h1:R4bJ1UQfqADjvDa4P6HZHLh/3OxWWEqc0Sk8XGwHqvA= github.com/aws/aws-sdk-go v1.37.8 h1:9kywcbuz6vQuTf+FD+U7FshafrHzmqUCjgAEiLuIJ8U= github.com/aws/aws-sdk-go v1.37.8/go.mod h1:hcU610XS61/+aQV88ixoOzUoG7v3b31pl2zKMmprdro= -github.com/aws/aws-sdk-go-v2 v1.19.0 h1:klAT+y3pGFBU/qVf1uzwttpBbiuozJYWzNLHioyDJ+k= github.com/aws/aws-sdk-go-v2 v1.19.0/go.mod h1:uzbQtefpm44goOPmdKyAlXSNcwlRgF3ePWVW6EtJvvw= +github.com/aws/aws-sdk-go-v2 v1.20.0 h1:INUDpYLt4oiPOJl0XwZDK2OVAVf0Rzo+MGVTv9f+gy8= +github.com/aws/aws-sdk-go-v2 v1.20.0/go.mod h1:uWOr0m0jDsiWw8nnXiqZ+YG6LdvAlGYDLLf2NmHZoy4= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.4.10 h1:dK82zF6kkPeCo8J1e+tGx4JdvDIQzj7ygIoLg8WMuGs= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.4.10/go.mod h1:VeTZetY5KRJLuD/7fkQXMU6Mw7H5m/KP2J5Iy9osMno= github.com/aws/aws-sdk-go-v2/config v1.18.29 h1:yA+bSSRGhBwWuprG9I4VgxfK//NBLZ/0BGOHiV3f9oM= @@ -16,18 +17,25 @@ github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.13.5 h1:kP3Me6Fy3vdi+9uHd7YLr6e github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.13.5/go.mod h1:Gj7tm95r+QsDoN2Fhuz/3npQvcZbkEf5mL70n3Xfluc= github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.11.73 h1:ez9K7LHdBxo+g1ExpUPsWEFfHxzHhiVZriWAJAiZwKc= github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.11.73/go.mod h1:+eJGIv33Lpdk3pbgIzKisFleIOB9dfWuVuipuve5Gsw= -github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.35 h1:hMUCiE3Zi5AHrRNGf5j985u0WyqI6r2NULhUfo0N/No= github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.35/go.mod h1:ipR5PvpSPqIqL5Mi82BxLnfMkHVbmco8kUwO2xrCi0M= -github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.29 h1:yOpYx+FTBdpk/g+sBU6Cb1H0U/TLEcYYp66mYqsPpcc= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.37 h1:zr/gxAZkMcvP71ZhQOcvdm8ReLjFgIXnIn0fw5AM7mo= +github.com/aws/aws-sdk-go-v2/internal/configsources v1.1.37/go.mod h1:Pdn4j43v49Kk6+82spO3Tu5gSeQXRsxo56ePPQAvFiA= github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.29/go.mod h1:M/eUABlDbw2uVrdAn+UsI6M727qp2fxkp8K0ejcBDUY= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.31 h1:0HCMIkAkVY9KMgueD8tf4bRTUanzEYvhw7KkPXIMpO0= +github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.4.31/go.mod h1:fTJDMe8LOFYtqiFFFeHA+SVMAwqLhoq0kcInYoLa9Js= github.com/aws/aws-sdk-go-v2/internal/ini v1.3.36 h1:8r5m1BoAWkn0TDC34lUculryf7nUF25EgIMdjvGCkgo= github.com/aws/aws-sdk-go-v2/internal/ini v1.3.36/go.mod h1:Rmw2M1hMVTwiUhjwMoIBFWFJMhvJbct06sSidxInkhY= github.com/aws/aws-sdk-go-v2/internal/v4a v1.0.27 h1:cZG7psLfqpkB6H+fIrgUDWmlzM474St1LP0jcz272yI= github.com/aws/aws-sdk-go-v2/internal/v4a v1.0.27/go.mod h1:ZdjYvJpDlefgh8/hWelJhqgqJeodxu4SmbVsSdBlL7E= -github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.11 h1:y2+VQzC6Zh2ojtV2LoC0MNwHWc6qXv/j2vrQtlftkdA= +github.com/aws/aws-sdk-go-v2/service/dynamodb v1.21.1 h1:E9giR4LylJO/iu/75Sb8golqceDcM26k7RZ8ng5MQ2k= +github.com/aws/aws-sdk-go-v2/service/dynamodb v1.21.1/go.mod h1:HVZN4RDNEO/u7XvWytqUBKm9BsBjt5OKVnRTW8NMMVc= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.11/go.mod h1:iV4q2hsqtNECrfmlXyord9u4zyuFEJX9eLgLpSPzWA8= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.12 h1:uAiiHnWihGP2rVp64fHwzLDrswGjEjsPszwRYMiYQPU= +github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.12/go.mod h1:fUTHpOXqRQpXvEpDPSa3zxCc2fnpW6YnBoba+eQr+Bg= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.30 h1:Bje8Xkh2OWpjBdNfXLrnn8eZg569dUQmhgtydxAYyP0= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.30/go.mod h1:qQtIBl5OVMfmeQkz8HaVyh5DzFmmFXyvK27UgIgOr4c= +github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.7.31 h1:L6ya7BMQ12LV6rsE1jiKm9ajsrnkRAYalatWRwFawHk= +github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.7.31/go.mod h1:tp7VzPEi+bKtSCP5fSrsZrB271L6oC8CWP3g2cZLofU= github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.29 h1:IiDolu/eLmuB18DRZibj77n1hHQT7z12jnGO7Ze3pLc= github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.29/go.mod h1:fDbkK4o7fpPXWn8YAPmTieAMuB9mk/VgvW64uaUqxd4= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.14.4 h1:hx4WksB0NRQ9utR+2c3gEGzl6uKj3eM6PMQ6tN3lgXs= @@ -40,8 +48,9 @@ github.com/aws/aws-sdk-go-v2/service/ssooidc v1.14.13 h1:BFubHS/xN5bjl818QaroN6m github.com/aws/aws-sdk-go-v2/service/ssooidc v1.14.13/go.mod h1:BzqsVVFduubEmzrVtUFQQIQdFqvUItF8XUq2EnS8Wog= github.com/aws/aws-sdk-go-v2/service/sts v1.20.0 h1:jKmIOO+dFvCPuIhhM8u0Dy3dtd590n2kEDSYiGHoI98= github.com/aws/aws-sdk-go-v2/service/sts v1.20.0/go.mod h1:yVGZA1CPkmUhBdA039jXNJJG7/6t+G+EBWmFq23xqnY= -github.com/aws/smithy-go v1.13.5 h1:hgz0X/DX0dGqTYpGALqXJoRKRj5oQ7150i5FdTePzO8= github.com/aws/smithy-go v1.13.5/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA= +github.com/aws/smithy-go v1.14.0 h1:+X90sB94fizKjDmwb4vyl2cTTPXTE5E2G/1mjByb0io= +github.com/aws/smithy-go v1.14.0/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= diff --git a/pkg/reflector/download.go b/pkg/reflector/download.go index d001d708..037bf9af 100644 --- a/pkg/reflector/download.go +++ b/pkg/reflector/download.go @@ -3,9 +3,9 @@ package reflector import ( "bytes" "context" + er "errors" "fmt" "io" - "net/http" "os" "strings" "time" @@ -14,7 +14,8 @@ import ( "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/feature/s3/manager" "github.com/aws/aws-sdk-go-v2/service/s3" - "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go-v2/service/s3/types" + "github.com/aws/smithy-go" gzip "github.com/klauspost/pgzip" "github.com/segmentio/ctlstore/pkg/errs" @@ -60,11 +61,14 @@ func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { stats.Observe("snapshot_download_time", time.Now().Sub(start)) if err != nil { - switch err := err.(type) { - case awserr.RequestFailure: - if d.StartOverOnNotFound && err.StatusCode() == http.StatusNotFound { - // don't bother retrying. we'll start with a fresh ldb. - return -1, errors.WithTypes(errors.Wrap(err, "get s3 data"), errs.ErrTypePermanent) + var apiErr smithy.APIError + if er.As(err, &apiErr) { + switch apiErr.(type) { + case *types.NotFound: + if d.StartOverOnNotFound { + // don't bother retrying. we'll start with a fresh ldb. + return -1, errors.WithTypes(errors.Wrap(err, "get s3 data"), errs.ErrTypePermanent) + } } } // retry From 09f57d6be89014530129ad2b98cec6afb432d1b3 Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Thu, 3 Aug 2023 18:38:25 -0400 Subject: [PATCH 17/27] revert changes by mistake --- ldb_reader.go | 2 +- rows.go | 27 ++------------------------- 2 files changed, 3 insertions(+), 26 deletions(-) diff --git a/ldb_reader.go b/ldb_reader.go index fbdf6852..1aea253c 100644 --- a/ldb_reader.go +++ b/ldb_reader.go @@ -189,7 +189,7 @@ func (reader *LDBReader) GetRowsByKeyPrefix(ctx context.Context, familyName stri if err != nil { return nil, err } - res := &Rows{rows: rows, cols: cols, familyName: familyName, tableName: tableName, start: time.Now()} + res := &Rows{rows: rows, cols: cols} return res, nil case err == sql.ErrNoRows: return &Rows{}, nil diff --git a/rows.go b/rows.go index 7b750bb1..31c15d2f 100644 --- a/rows.go +++ b/rows.go @@ -2,31 +2,19 @@ package ctlstore import ( "database/sql" - "sync" - "sync/atomic" - "time" - "github.com/segmentio/stats/v4" - - "github.com/segmentio/ctlstore/pkg/globalstats" "github.com/segmentio/ctlstore/pkg/scanfunc" "github.com/segmentio/ctlstore/pkg/schema" ) // Rows composes an *sql.Rows and allows scanning ctlstore table rows into // structs or maps, similar to how the GetRowByKey reader method works. -// It also keeps track of number of rows read and emits as a metric on Close // // The contract around Next/Err/Close is the same was it is for // *sql.Rows. type Rows struct { - rows *sql.Rows - cols []schema.DBColumnMeta - familyName string - tableName string - count uint32 - once sync.Once - start time.Time + rows *sql.Rows + cols []schema.DBColumnMeta } // Next returns true if there's another row available. @@ -34,7 +22,6 @@ func (r *Rows) Next() bool { if r.rows == nil { return false } - atomic.AddUint32(&r.count, 1) return r.rows.Next() } @@ -54,16 +41,6 @@ func (r *Rows) Close() error { if r.rows == nil { return nil } - r.once.Do(func() { - globalstats.Observe("get_rows_by_key_prefix_row_count", atomic.LoadUint32(&r.count), - stats.T("family", r.familyName), - stats.T("table", r.tableName)) - if !r.start.IsZero() { - globalstats.Observe("get_rows_by_prefix_scan_time", time.Now().Sub(r.start), - stats.T("family", r.familyName), - stats.T("table", r.tableName)) - } - }) return r.rows.Close() } From 750638092b9941c21cdd81f8369e281f0f63352d Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Fri, 4 Aug 2023 10:02:13 -0400 Subject: [PATCH 18/27] revert replacing awserr with smithy-go --- go.mod | 12 +++++------- go.sum | 17 ++++++++--------- pkg/reflector/download.go | 18 +++++++----------- 3 files changed, 20 insertions(+), 27 deletions(-) diff --git a/go.mod b/go.mod index f83eaaca..75f96894 100644 --- a/go.mod +++ b/go.mod @@ -8,9 +8,7 @@ require ( github.com/aws/aws-sdk-go-v2 v1.20.0 github.com/aws/aws-sdk-go-v2/config v1.18.29 github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.11.73 - github.com/aws/aws-sdk-go-v2/service/dynamodb v1.21.1 github.com/aws/aws-sdk-go-v2/service/s3 v1.37.0 - github.com/aws/smithy-go v1.14.0 github.com/fsnotify/fsnotify v1.5.1 github.com/go-sql-driver/mysql v1.4.1 github.com/google/go-cmp v0.5.8 @@ -39,12 +37,12 @@ require ( github.com/aws/aws-sdk-go-v2/internal/v4a v1.0.27 // indirect github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.12 // indirect github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.30 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.7.31 // indirect - github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.29 // indirect + github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.31 // indirect github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.14.4 // indirect - github.com/aws/aws-sdk-go-v2/service/sso v1.12.13 // indirect - github.com/aws/aws-sdk-go-v2/service/ssooidc v1.14.13 // indirect - github.com/aws/aws-sdk-go-v2/service/sts v1.20.0 // indirect + github.com/aws/aws-sdk-go-v2/service/sso v1.13.1 // indirect + github.com/aws/aws-sdk-go-v2/service/ssooidc v1.15.1 // indirect + github.com/aws/aws-sdk-go-v2/service/sts v1.21.1 // indirect + github.com/aws/smithy-go v1.14.0 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/jmespath/go-jmespath v0.4.0 // indirect github.com/klauspost/compress v1.16.7 // indirect diff --git a/go.sum b/go.sum index 84aa4a83..c903cb3c 100644 --- a/go.sum +++ b/go.sum @@ -27,27 +27,27 @@ github.com/aws/aws-sdk-go-v2/internal/ini v1.3.36 h1:8r5m1BoAWkn0TDC34lUculryf7n github.com/aws/aws-sdk-go-v2/internal/ini v1.3.36/go.mod h1:Rmw2M1hMVTwiUhjwMoIBFWFJMhvJbct06sSidxInkhY= github.com/aws/aws-sdk-go-v2/internal/v4a v1.0.27 h1:cZG7psLfqpkB6H+fIrgUDWmlzM474St1LP0jcz272yI= github.com/aws/aws-sdk-go-v2/internal/v4a v1.0.27/go.mod h1:ZdjYvJpDlefgh8/hWelJhqgqJeodxu4SmbVsSdBlL7E= -github.com/aws/aws-sdk-go-v2/service/dynamodb v1.21.1 h1:E9giR4LylJO/iu/75Sb8golqceDcM26k7RZ8ng5MQ2k= -github.com/aws/aws-sdk-go-v2/service/dynamodb v1.21.1/go.mod h1:HVZN4RDNEO/u7XvWytqUBKm9BsBjt5OKVnRTW8NMMVc= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.11/go.mod h1:iV4q2hsqtNECrfmlXyord9u4zyuFEJX9eLgLpSPzWA8= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.12 h1:uAiiHnWihGP2rVp64fHwzLDrswGjEjsPszwRYMiYQPU= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.9.12/go.mod h1:fUTHpOXqRQpXvEpDPSa3zxCc2fnpW6YnBoba+eQr+Bg= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.30 h1:Bje8Xkh2OWpjBdNfXLrnn8eZg569dUQmhgtydxAYyP0= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.1.30/go.mod h1:qQtIBl5OVMfmeQkz8HaVyh5DzFmmFXyvK27UgIgOr4c= -github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.7.31 h1:L6ya7BMQ12LV6rsE1jiKm9ajsrnkRAYalatWRwFawHk= -github.com/aws/aws-sdk-go-v2/service/internal/endpoint-discovery v1.7.31/go.mod h1:tp7VzPEi+bKtSCP5fSrsZrB271L6oC8CWP3g2cZLofU= -github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.29 h1:IiDolu/eLmuB18DRZibj77n1hHQT7z12jnGO7Ze3pLc= github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.29/go.mod h1:fDbkK4o7fpPXWn8YAPmTieAMuB9mk/VgvW64uaUqxd4= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.31 h1:auGDJ0aLZahF5SPvkJ6WcUuX7iQ7kyl2MamV7Tm8QBk= +github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.9.31/go.mod h1:3+lloe3sZuBQw1aBc5MyndvodzQlyqCZ7x1QPDHaWP4= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.14.4 h1:hx4WksB0NRQ9utR+2c3gEGzl6uKj3eM6PMQ6tN3lgXs= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.14.4/go.mod h1:JniVpqvw90sVjNqanGLufrVapWySL28fhBlYgl96Q/w= github.com/aws/aws-sdk-go-v2/service/s3 v1.37.0 h1:PalLOEGZ/4XfQxpGZFTLaoJSmPoybnqJYotaIZEf/Rg= github.com/aws/aws-sdk-go-v2/service/s3 v1.37.0/go.mod h1:PwyKKVL0cNkC37QwLcrhyeCrAk+5bY8O2ou7USyAS2A= -github.com/aws/aws-sdk-go-v2/service/sso v1.12.13 h1:sWDv7cMITPcZ21QdreULwxOOAmE05JjEsT6fCDtDA9k= github.com/aws/aws-sdk-go-v2/service/sso v1.12.13/go.mod h1:DfX0sWuT46KpcqbMhJ9QWtxAIP1VozkDWf8VAkByjYY= -github.com/aws/aws-sdk-go-v2/service/ssooidc v1.14.13 h1:BFubHS/xN5bjl818QaroN6mQdjneYQ+AOx44KNXlyH4= +github.com/aws/aws-sdk-go-v2/service/sso v1.13.1 h1:DSNpSbfEgFXRV+IfEcKE5kTbqxm+MeF5WgyeRlsLnHY= +github.com/aws/aws-sdk-go-v2/service/sso v1.13.1/go.mod h1:TC9BubuFMVScIU+TLKamO6VZiYTkYoEHqlSQwAe2omw= github.com/aws/aws-sdk-go-v2/service/ssooidc v1.14.13/go.mod h1:BzqsVVFduubEmzrVtUFQQIQdFqvUItF8XUq2EnS8Wog= -github.com/aws/aws-sdk-go-v2/service/sts v1.20.0 h1:jKmIOO+dFvCPuIhhM8u0Dy3dtd590n2kEDSYiGHoI98= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.15.1 h1:hd0SKLMdOL/Sl6Z0np1PX9LeH2gqNtBe0MhTedA8MGI= +github.com/aws/aws-sdk-go-v2/service/ssooidc v1.15.1/go.mod h1:XO/VcyoQ8nKyKfFW/3DMsRQXsfh/052tHTWmg3xBXRg= github.com/aws/aws-sdk-go-v2/service/sts v1.20.0/go.mod h1:yVGZA1CPkmUhBdA039jXNJJG7/6t+G+EBWmFq23xqnY= +github.com/aws/aws-sdk-go-v2/service/sts v1.21.1 h1:pAOJj+80tC8sPVgSDHzMYD6KLWsaLQ1kZw31PTeORbs= +github.com/aws/aws-sdk-go-v2/service/sts v1.21.1/go.mod h1:G8SbvL0rFk4WOJroU8tKBczhsbhj2p/YY7qeJezJ3CI= github.com/aws/smithy-go v1.13.5/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA= github.com/aws/smithy-go v1.14.0 h1:+X90sB94fizKjDmwb4vyl2cTTPXTE5E2G/1mjByb0io= github.com/aws/smithy-go v1.14.0/go.mod h1:Tg+OJXh4MB2R/uN61Ko2f6hTZwB/ZYGOtib8J3gBHzA= @@ -206,7 +206,6 @@ golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= google.golang.org/appengine v1.6.7 h1:FZR1q0exgwxzPzp/aF+VccGrSfxfPpkBqjIIEq3ru6c= google.golang.org/appengine v1.6.7/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc= diff --git a/pkg/reflector/download.go b/pkg/reflector/download.go index 037bf9af..d001d708 100644 --- a/pkg/reflector/download.go +++ b/pkg/reflector/download.go @@ -3,9 +3,9 @@ package reflector import ( "bytes" "context" - er "errors" "fmt" "io" + "net/http" "os" "strings" "time" @@ -14,8 +14,7 @@ import ( "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/feature/s3/manager" "github.com/aws/aws-sdk-go-v2/service/s3" - "github.com/aws/aws-sdk-go-v2/service/s3/types" - "github.com/aws/smithy-go" + "github.com/aws/aws-sdk-go/aws/awserr" gzip "github.com/klauspost/pgzip" "github.com/segmentio/ctlstore/pkg/errs" @@ -61,14 +60,11 @@ func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { stats.Observe("snapshot_download_time", time.Now().Sub(start)) if err != nil { - var apiErr smithy.APIError - if er.As(err, &apiErr) { - switch apiErr.(type) { - case *types.NotFound: - if d.StartOverOnNotFound { - // don't bother retrying. we'll start with a fresh ldb. - return -1, errors.WithTypes(errors.Wrap(err, "get s3 data"), errs.ErrTypePermanent) - } + switch err := err.(type) { + case awserr.RequestFailure: + if d.StartOverOnNotFound && err.StatusCode() == http.StatusNotFound { + // don't bother retrying. we'll start with a fresh ldb. + return -1, errors.WithTypes(errors.Wrap(err, "get s3 data"), errs.ErrTypePermanent) } } // retry From 714dceaf353d22377b468469b14a2afaebcc6f09 Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Fri, 4 Aug 2023 16:34:16 -0400 Subject: [PATCH 19/27] Update pkg/reflector/download_test.go Co-authored-by: Taylor Brennan --- pkg/reflector/download_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/reflector/download_test.go b/pkg/reflector/download_test.go index d7f3c13a..e7596140 100644 --- a/pkg/reflector/download_test.go +++ b/pkg/reflector/download_test.go @@ -22,7 +22,7 @@ import ( // Verifies error handling behavior when downloading from s3 fails. // Specifically, the supervisor is allowed to create a new LDB if // a 404 is received from S3, and other errors from S3 are able -// to be retired. These behaviors result from the kind of error +// to be retried. These behaviors result from the kind of error // that s3Downloader.DownloadTo(writer) returns. func TestS3DownloadErrors(t *testing.T) { for _, test := range []struct { From 26f03e26ba8b64cb99b5a629fdbe10d243554f00 Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Wed, 9 Aug 2023 14:40:45 -0400 Subject: [PATCH 20/27] fix test --- pkg/reflector/download.go | 7 ++++++- pkg/reflector/download_test.go | 3 ++- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/pkg/reflector/download.go b/pkg/reflector/download.go index d001d708..ba04d95e 100644 --- a/pkg/reflector/download.go +++ b/pkg/reflector/download.go @@ -53,7 +53,7 @@ func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { defer os.Remove(file.Name()) start := time.Now() - numBytes, err := downloader.Download(context.TODO(), file, &s3.GetObjectInput{ + numBytes, err := downloader.Download(context.Background(), file, &s3.GetObjectInput{ Bucket: aws.String(d.Bucket), Key: aws.String(d.Key), }) @@ -76,6 +76,11 @@ func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { if err != nil { return n, errors.Wrap(err, "unzip snapshot") } + } else { + n, err = io.Copy(w, file) + if err != nil { + return n, errors.Wrap(err, "copy snapshot") + } } events.Log("LDB inflated %d -> %d bytes", numBytes, n) diff --git a/pkg/reflector/download_test.go b/pkg/reflector/download_test.go index e7596140..3c642966 100644 --- a/pkg/reflector/download_test.go +++ b/pkg/reflector/download_test.go @@ -38,7 +38,8 @@ func TestS3DownloadErrors(t *testing.T) { s3Client: func() reflector.S3Client { f := &fakes.FakeS3Client{} f.GetObjectReturns(&s3.GetObjectOutput{ - Body: ioutil.NopCloser(strings.NewReader("data")), + Body: ioutil.NopCloser(strings.NewReader("data")), + ContentLength: 4, }, nil) return f }, From 8f520fc9f9d4a71aacb0ac364a4200f0b2fb9a2e Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Wed, 9 Aug 2023 15:27:17 -0400 Subject: [PATCH 21/27] reverted unwanted changes --- .github/workflows/build-ctlstore.yml | 37 --------- Dockerfile | 2 +- pkg/cmd/ctlstore/main.go | 46 +++++++---- pkg/reflector/wal_monitor_test.go | 119 ++++++++++++++++++++++----- 4 files changed, 128 insertions(+), 76 deletions(-) delete mode 100644 .github/workflows/build-ctlstore.yml diff --git a/.github/workflows/build-ctlstore.yml b/.github/workflows/build-ctlstore.yml deleted file mode 100644 index 76b82efc..00000000 --- a/.github/workflows/build-ctlstore.yml +++ /dev/null @@ -1,37 +0,0 @@ -name: build -on: - - push -jobs: - build: - name: Executes a full build - runs-on: ubuntu-latest - services: - mysql: - image: mysql:5.6 - env: - MYSQL_ROOT_PASSWORD: ctldbpw - MYSQL_DATABASE: ctldb - MYSQL_USER: ctldb - MYSQL_PASSWORD: ctldbpw - ports: - - 3306:3306 - - steps: - - name: checkout - uses: actions/checkout@v3 - - - name: setup go 1.20 - uses: actions/setup-go@v3 - with: - go-version: '1.20' - - - name: Deps - run: | - make vendor - - - name: Test - run: | - make test - - name: build - run: | - make build \ No newline at end of file diff --git a/Dockerfile b/Dockerfile index 8b8f40b0..72e9c3d8 100644 --- a/Dockerfile +++ b/Dockerfile @@ -25,4 +25,4 @@ COPY --from=0 /go/src/github.com/segmentio/ctlstore/scripts/download.sh . COPY --from=0 /bin/chamber /bin/chamber COPY --from=0 /bin/s5cmd /bin/s5cmd COPY --from=0 /usr/local/bin/ctlstore /usr/local/bin/ -COPY --from=0 /usr/local/bin/ctlstore-cli /usr/local/bin/ \ No newline at end of file +COPY --from=0 /usr/local/bin/ctlstore-cli /usr/local/bin/ diff --git a/pkg/cmd/ctlstore/main.go b/pkg/cmd/ctlstore/main.go index 5a938aaa..8a09a0a2 100644 --- a/pkg/cmd/ctlstore/main.go +++ b/pkg/cmd/ctlstore/main.go @@ -23,6 +23,7 @@ import ( "github.com/segmentio/ctlstore/pkg/errs" executivepkg "github.com/segmentio/ctlstore/pkg/executive" heartbeatpkg "github.com/segmentio/ctlstore/pkg/heartbeat" + "github.com/segmentio/ctlstore/pkg/ldbwriter" "github.com/segmentio/ctlstore/pkg/ledger" reflectorpkg "github.com/segmentio/ctlstore/pkg/reflector" sidecarpkg "github.com/segmentio/ctlstore/pkg/sidecar" @@ -46,22 +47,25 @@ type sidecarConfig struct { } type reflectorCliConfig struct { - LDBPath string `conf:"ldb-path" help:"Path to LDB file" validate:"nonzero"` - ChangelogPath string `conf:"changelog-path" help:"Path to changelog file"` - ChangelogSize int `conf:"changelog-size" help:"Maximum size of the changelog file"` - UpstreamDriver string `conf:"upstream-driver" help:"Upstream driver name (e.g. sqlite3)" validate:"nonzero"` - UpstreamDSN string `conf:"upstream-dsn" help:"Upstream DSN (e.g. path to file if sqlite3)" validate:"nonzero"` - UpstreamLedgerTable string `conf:"upstream-ledger-table" help:"Table on the upstream to look for statement ledger"` - BootstrapURL string `conf:"bootstrap-url" help:"Bootstraps LDB from an S3 URL"` - BootstrapRegion string `conf:"bootstrap-region" help:"If specified, indicates which region in which the S3 bucket lives"` - PollInterval time.Duration `conf:"poll-interval" help:"How often to pull the upstream" validate:"nonzero"` - PollJitterCoefficient float64 `conf:"poll-jitter-coefficient" help:"Coefficient for poll jittering"` - QueryBlockSize int `conf:"query-block-size" help:"Number of ledger entries to get at once"` - Debug bool `conf:"debug" help:"Turns on debug logging"` - LedgerHealth ledgerHealthConfig `conf:"ledger-latency" help:"Configure ledger latency behavior"` - Dogstatsd dogstatsdConfig `conf:"dogstatsd" help:"dogstatsd Configuration"` - MetricsBind string `conf:"metrics-bind" help:"address to serve Prometheus metircs"` - WALPollInterval time.Duration `conf:"wal-poll-interval" help:"How often to pull the sqlite's wal size and status. 0 indicates disabled monitoring'"` + LDBPath string `conf:"ldb-path" help:"Path to LDB file" validate:"nonzero"` + ChangelogPath string `conf:"changelog-path" help:"Path to changelog file"` + ChangelogSize int `conf:"changelog-size" help:"Maximum size of the changelog file"` + UpstreamDriver string `conf:"upstream-driver" help:"Upstream driver name (e.g. sqlite3)" validate:"nonzero"` + UpstreamDSN string `conf:"upstream-dsn" help:"Upstream DSN (e.g. path to file if sqlite3)" validate:"nonzero"` + UpstreamLedgerTable string `conf:"upstream-ledger-table" help:"Table on the upstream to look for statement ledger"` + BootstrapURL string `conf:"bootstrap-url" help:"Bootstraps LDB from an S3 URL"` + BootstrapRegion string `conf:"bootstrap-region" help:"If specified, indicates which region in which the S3 bucket lives"` + PollInterval time.Duration `conf:"poll-interval" help:"How often to pull the upstream" validate:"nonzero"` + PollJitterCoefficient float64 `conf:"poll-jitter-coefficient" help:"Coefficient for poll jittering"` + QueryBlockSize int `conf:"query-block-size" help:"Number of ledger entries to get at once"` + Debug bool `conf:"debug" help:"Turns on debug logging"` + LedgerHealth ledgerHealthConfig `conf:"ledger-latency" help:"Configure ledger latency behavior"` + Dogstatsd dogstatsdConfig `conf:"dogstatsd" help:"dogstatsd Configuration"` + MetricsBind string `conf:"metrics-bind" help:"address to serve Prometheus metircs"` + WALPollInterval time.Duration `conf:"wal-poll-interval" help:"How often to pull the sqlite's wal size and status. 0 indicates disabled monitoring'"` + WALCheckpointThresholdSize int `conf:"wal-checkpoint-threshold-size" help:"Performs a checkpoint after the WAL file exceeds this size in bytes"` + WALCheckpointType ldbwriter.CheckpointType `conf:"wal-checkpoint-type" help:"what type of checkpoint to manually perform once the wal size is exceeded"` + BusyTimeoutMS int `conf:"busy-timeout-ms" help:"Set a busy timeout on the connection string for sqlite in milliseconds"` } type executiveCliConfig struct { @@ -490,6 +494,9 @@ func defaultReflectorCLIConfig(isSupervisor bool) reflectorCliConfig { }, // disabled by default WALPollInterval: 0, + // 8 MB, double what a "healthy" WAL file should be https://www.sqlite.org/compile.html#default_wal_autocheckpoint + WALCheckpointThresholdSize: 8 * 1024 * 1024, + WALCheckpointType: ldbwriter.Passive, } if isSupervisor { // the supervisor runs as an ECS task, so it cannot yet set @@ -547,7 +554,10 @@ func newReflector(cliCfg reflectorCliConfig, isSupervisor bool) (*reflectorpkg.R QueryBlockSize: cliCfg.QueryBlockSize, PollTimeout: 5 * time.Second, }, - WALPollInterval: cliCfg.WALPollInterval, - DoMonitorWAL: cliCfg.WALPollInterval > 0, + WALPollInterval: cliCfg.WALPollInterval, + DoMonitorWAL: cliCfg.WALPollInterval > 0, + WALCheckpointThresholdSize: cliCfg.WALCheckpointThresholdSize, + WALCheckpointType: cliCfg.WALCheckpointType, + BusyTimeoutMS: cliCfg.BusyTimeoutMS, }) } diff --git a/pkg/reflector/wal_monitor_test.go b/pkg/reflector/wal_monitor_test.go index fc14a590..24f7f89c 100644 --- a/pkg/reflector/wal_monitor_test.go +++ b/pkg/reflector/wal_monitor_test.go @@ -5,6 +5,7 @@ import ( "fmt" "os" "sync" + "sync/atomic" "testing" "time" @@ -12,18 +13,18 @@ import ( ) type fake struct { - size int64 - err error - wg sync.WaitGroup - statCallCount int - checkCallCount int + size int64 + err error + wg sync.WaitGroup + statCallCount atomic.Int64 + cpCallCount atomic.Int64 } func (f *fake) Stat() func(m *WALMonitor) { return func(m *WALMonitor) { m.walSizeFunc = func(p string) (int64, error) { defer f.wg.Done() - f.statCallCount++ + f.statCallCount.Add(1) v, err := m.getWALSize(p) f.size = v f.err = err @@ -43,13 +44,14 @@ func (f *fake) Ticker() func(m *WALMonitor) { func (f *fake) Checkpointer() func(m *WALMonitor) { return func(m *WALMonitor) { m.cpTesterFunc = func() (*ldbwriter.PragmaWALResult, error) { - f.checkCallCount++ + defer f.wg.Done() + f.cpCallCount.Add(1) return nil, fmt.Errorf("fail") } } } -func TestWALMonitorSize(t *testing.T) { +func TestWALMonitorTooSmall(t *testing.T) { tmpdir := t.TempDir() f, err := os.CreateTemp(tmpdir, "*.ldb-wal") if err != nil { @@ -66,10 +68,57 @@ func TestWALMonitorSize(t *testing.T) { } var fake fake - fake.wg.Add(1) + fake.wg.Add(2) mon := NewMonitor(MonitorConfig{ - PollInterval: time.Millisecond, - Path: f.Name(), + PollInterval: time.Millisecond, + Path: f.Name(), + WALCheckpointThresholdSize: int64(n + 1), + }, nil, fake.Stat(), fake.Ticker(), fake.Checkpointer()) + + ctx, cancel := context.WithCancel(context.Background()) + go mon.Start(ctx) + // wait for fake stat call + fake.wg.Wait() + cancel() + + if fake.statCallCount.Load() == 0 { + t.Errorf("Stat should have been called at least once") + } + + if fake.cpCallCount.Load() != 0 { + t.Errorf("Checkpoint should not have been called since the file wasn't large enough") + } + if fake.err != nil { + t.Errorf("unexpected error on stat: %v", fake.err) + } + + if int64(n) != fake.size { + t.Errorf("expected file size of %d, got %d", n, fake.size) + } +} + +func TestWALMonitorBigEnough(t *testing.T) { + tmpdir := t.TempDir() + f, err := os.CreateTemp(tmpdir, "*.ldb-wal") + if err != nil { + t.Fatal(err) + } + + n, err := f.WriteString("some random bytes!") + if err != nil { + t.Fatal(err) + } + + if f.Sync() != nil { + t.Fatal(err) + } + + var fake fake + fake.wg.Add(2) + mon := NewMonitor(MonitorConfig{ + PollInterval: time.Millisecond, + Path: f.Name(), + WALCheckpointThresholdSize: int64(n - 1), }, nil, fake.Stat(), fake.Ticker(), fake.Checkpointer()) ctx, cancel := context.WithCancel(context.Background()) @@ -78,11 +127,11 @@ func TestWALMonitorSize(t *testing.T) { fake.wg.Wait() cancel() - if fake.statCallCount == 0 { + if fake.statCallCount.Load() == 0 { t.Errorf("Stat should have been called at least once") } - if fake.checkCallCount == 0 { + if fake.cpCallCount.Load() == 0 { t.Errorf("Checkpoint should have been called at least once") } if fake.err != nil { @@ -103,16 +152,16 @@ func TestNoWALPath(t *testing.T) { mon.Start(context.Background()) - if fake.statCallCount != 0 { + if fake.statCallCount.Load() != 0 { t.Errorf("Stat should not have been called") } - if fake.checkCallCount != 0 { + if fake.cpCallCount.Load() != 0 { t.Errorf("Checkpoint should not have been called") } } -func TestWALMonitorStopsOnError(t *testing.T) { +func TestWALMonitorStopsOnStatError(t *testing.T) { var fake fake fake.wg.Add(5) mon := NewMonitor(MonitorConfig{ @@ -122,11 +171,41 @@ func TestWALMonitorStopsOnError(t *testing.T) { mon.Start(context.Background()) fake.wg.Wait() - if fake.statCallCount != 5 { - t.Errorf("Stat should have been called 5 times, got %d", fake.statCallCount) + if fake.statCallCount.Load() != 5 { + t.Errorf("Stat should have been called 5 times, got %d", fake.statCallCount.Load()) } - if fake.checkCallCount != 5 { - t.Errorf("Checkpoint should have have been called 5 times, got %d", fake.checkCallCount) + if fake.cpCallCount.Load() != 0 { + t.Errorf("Checkpoint should not have been called") + } +} + +func TestWALMonitorStopsOnCheckpointError(t *testing.T) { + tmpdir := t.TempDir() + f, err := os.CreateTemp(tmpdir, "*.ldb-wal") + if err != nil { + t.Fatal(err) + } + + _, err = f.WriteString("some random bytes!") + if err != nil { + t.Fatal(err) + } + + var fake fake + fake.wg.Add(10) + mon := NewMonitor(MonitorConfig{ + PollInterval: 50 * time.Microsecond, + Path: f.Name(), + }, nil, fake.Stat(), fake.Checkpointer()) + + mon.Start(context.Background()) + fake.wg.Wait() + if fake.statCallCount.Load() != 5 { + t.Errorf("Stat should have been called 5 times, got %d", fake.statCallCount.Load()) + } + + if fake.cpCallCount.Load() != 5 { + t.Errorf("Checkpoint should not have been called") } } From 467fb2ebbb1f34fde0aabf4dd6930bb318a3a161 Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Wed, 9 Aug 2023 17:11:53 -0400 Subject: [PATCH 22/27] free ourselves of all aws-sdk-go v1 --- go.mod | 2 +- pkg/reflector/download.go | 18 +++++++++++------- pkg/reflector/download_test.go | 20 +++++++++++++------- 3 files changed, 25 insertions(+), 15 deletions(-) diff --git a/go.mod b/go.mod index 75f96894..c2b6d305 100644 --- a/go.mod +++ b/go.mod @@ -9,6 +9,7 @@ require ( github.com/aws/aws-sdk-go-v2/config v1.18.29 github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.11.73 github.com/aws/aws-sdk-go-v2/service/s3 v1.37.0 + github.com/aws/smithy-go v1.14.0 github.com/fsnotify/fsnotify v1.5.1 github.com/go-sql-driver/mysql v1.4.1 github.com/google/go-cmp v0.5.8 @@ -42,7 +43,6 @@ require ( github.com/aws/aws-sdk-go-v2/service/sso v1.13.1 // indirect github.com/aws/aws-sdk-go-v2/service/ssooidc v1.15.1 // indirect github.com/aws/aws-sdk-go-v2/service/sts v1.21.1 // indirect - github.com/aws/smithy-go v1.14.0 // indirect github.com/davecgh/go-spew v1.1.1 // indirect github.com/jmespath/go-jmespath v0.4.0 // indirect github.com/klauspost/compress v1.16.7 // indirect diff --git a/pkg/reflector/download.go b/pkg/reflector/download.go index ba04d95e..8e8f6647 100644 --- a/pkg/reflector/download.go +++ b/pkg/reflector/download.go @@ -3,9 +3,9 @@ package reflector import ( "bytes" "context" + er "errors" "fmt" "io" - "net/http" "os" "strings" "time" @@ -14,7 +14,8 @@ import ( "github.com/aws/aws-sdk-go-v2/config" "github.com/aws/aws-sdk-go-v2/feature/s3/manager" "github.com/aws/aws-sdk-go-v2/service/s3" - "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go-v2/service/s3/types" + "github.com/aws/smithy-go" gzip "github.com/klauspost/pgzip" "github.com/segmentio/ctlstore/pkg/errs" @@ -60,11 +61,14 @@ func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { stats.Observe("snapshot_download_time", time.Now().Sub(start)) if err != nil { - switch err := err.(type) { - case awserr.RequestFailure: - if d.StartOverOnNotFound && err.StatusCode() == http.StatusNotFound { - // don't bother retrying. we'll start with a fresh ldb. - return -1, errors.WithTypes(errors.Wrap(err, "get s3 data"), errs.ErrTypePermanent) + var ae smithy.APIError + if er.As(err, &ae) { + switch ae.(type) { + case *types.NotFound: + if d.StartOverOnNotFound { + // don't bother retrying. we'll start with a fresh ldb. + return -1, errors.WithTypes(errors.Wrap(err, "get s3 data"), errs.ErrTypePermanent) + } } } // retry diff --git a/pkg/reflector/download_test.go b/pkg/reflector/download_test.go index 3c642966..b3381885 100644 --- a/pkg/reflector/download_test.go +++ b/pkg/reflector/download_test.go @@ -9,8 +9,10 @@ import ( "strings" "testing" + "github.com/aws/aws-sdk-go-v2/aws" "github.com/aws/aws-sdk-go-v2/service/s3" - "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go-v2/service/s3/types" + "github.com/aws/smithy-go" gzip "github.com/klauspost/pgzip" "github.com/stretchr/testify/require" @@ -62,8 +64,9 @@ func TestS3DownloadErrors(t *testing.T) { isSupervisor: true, s3Client: func() reflector.S3Client { f := &fakes.FakeS3Client{} - f.GetObjectReturns(nil, awserr.NewRequestFailure( - awserr.New("error-code", "error-message", errors.New("failure")), http.StatusNotFound, "")) + f.GetObjectReturns(nil, &types.NotFound{ + Message: aws.String("failure"), + }) return f }, err: errors.New("failure"), @@ -74,8 +77,9 @@ func TestS3DownloadErrors(t *testing.T) { name: "temporary failure on 404 if not-supervisor", s3Client: func() reflector.S3Client { f := &fakes.FakeS3Client{} - f.GetObjectReturns(nil, awserr.NewRequestFailure( - awserr.New("error-code", "error-message", errors.New("failure")), http.StatusNotFound, "")) + f.GetObjectReturns(nil, &types.NotFound{ + Message: aws.String("failure"), + }) return f }, err: errors.New("failure"), @@ -86,8 +90,10 @@ func TestS3DownloadErrors(t *testing.T) { name: "temporary failure", s3Client: func() reflector.S3Client { f := &fakes.FakeS3Client{} - f.GetObjectReturns(nil, awserr.NewRequestFailure( - awserr.New("error-code", "error-message", errors.New("failure")), http.StatusInternalServerError, "")) + f.GetObjectReturns(nil, &smithy.GenericAPIError{ + Code: string(rune(http.StatusInternalServerError)), + Message: "failure", + }) return f }, err: errors.New("failure"), From 50a2cc4ffb9978e3e7ae6cac2a2d6641acd3d44a Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Mon, 11 Sep 2023 16:12:34 -0400 Subject: [PATCH 23/27] log s3 client's downloading time --- pkg/reflector/download.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/reflector/download.go b/pkg/reflector/download.go index 8e8f6647..9d58c1ae 100644 --- a/pkg/reflector/download.go +++ b/pkg/reflector/download.go @@ -86,7 +86,7 @@ func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { return n, errors.Wrap(err, "copy snapshot") } } - + events.Log("ldb.db ready in %s seconds (s3 client)", time.Now().Sub(start)) events.Log("LDB inflated %d -> %d bytes", numBytes, n) return From 36dba8f9aaacc95476da43df22ab61a47e9ece06 Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Mon, 11 Sep 2023 18:36:48 -0400 Subject: [PATCH 24/27] Bootstrap LDB regardless of existence --- pkg/reflector/reflector.go | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/pkg/reflector/reflector.go b/pkg/reflector/reflector.go index 324c2d25..faf3e19a 100644 --- a/pkg/reflector/reflector.go +++ b/pkg/reflector/reflector.go @@ -123,7 +123,18 @@ func ReflectorFromConfig(config ReflectorConfig) (*Reflector, error) { return nil, err } } else { - events.Log("LDB File %{file}s exists, skipping bootstrap.", config.LDBPath) + //events.Log("LDB File %{file}s exists, skipping bootstrap.", config.LDBPath) + // Bootstrap LDB regardless of existence + events.Log("LDB File %{file}s doesn't exist, beginning bootstrap...", config.LDBPath) + err = bootstrapLDB(ldbBootstrapConfig{ + url: config.BootstrapURL, + path: config.LDBPath, + restartOnS3NotFound: config.IsSupervisor, // allow supervisor to restart ldb + region: config.BootstrapRegion, + }) + if err != nil { + return nil, err + } } } From 70ac14e4b25daa93dedab9382519e6ca6fae9944 Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Mon, 11 Sep 2023 21:01:05 -0400 Subject: [PATCH 25/27] remove leading slash --- pkg/reflector/download.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pkg/reflector/download.go b/pkg/reflector/download.go index 9d58c1ae..33da96cf 100644 --- a/pkg/reflector/download.go +++ b/pkg/reflector/download.go @@ -47,7 +47,7 @@ func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { } tmpdir := os.TempDir() - file, err := os.CreateTemp(tmpdir, d.Key) + file, err := os.CreateTemp(tmpdir, strings.TrimLeft(d.Key, "/")) if err != nil { return -1, errors.Wrap(err, "download snapshot into disk") } From 54251d84fe255c7cdd57ea4eac9cc5ba5b1092a3 Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Mon, 11 Sep 2023 21:38:19 -0400 Subject: [PATCH 26/27] remove leading slash --- pkg/reflector/download.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/pkg/reflector/download.go b/pkg/reflector/download.go index 33da96cf..ca2dc717 100644 --- a/pkg/reflector/download.go +++ b/pkg/reflector/download.go @@ -56,10 +56,12 @@ func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { start := time.Now() numBytes, err := downloader.Download(context.Background(), file, &s3.GetObjectInput{ Bucket: aws.String(d.Bucket), - Key: aws.String(d.Key), + Key: aws.String(strings.TrimLeft(d.Key, "/")), }) stats.Observe("snapshot_download_time", time.Now().Sub(start)) + events.Log("downloading file with key: ", d.Key) + if err != nil { var ae smithy.APIError if er.As(err, &ae) { From 0df2e025d88f31e89dc6d36e75aaf9fc6f856b5e Mon Sep 17 00:00:00 2001 From: Hongyu Zhou Date: Mon, 11 Sep 2023 22:08:15 -0400 Subject: [PATCH 27/27] more concurrency --- pkg/reflector/download.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/pkg/reflector/download.go b/pkg/reflector/download.go index ca2dc717..19916881 100644 --- a/pkg/reflector/download.go +++ b/pkg/reflector/download.go @@ -39,8 +39,8 @@ type S3Downloader struct { func (d *S3Downloader) DownloadTo(w io.Writer) (n int64, err error) { client, err := d.getS3Client() downloader := manager.NewDownloader(client, func(d *manager.Downloader) { - d.PartSize = 64 * 1024 * 1024 // 64MB per part - d.Concurrency = 5 + d.PartSize = 16 * 1024 * 1024 // 64MB per part + d.Concurrency = 11 }) if err != nil { return -1, err