diff --git a/.github/workflows/ci-checks.yml b/.github/workflows/ci-checks.yml index fad5b1401d1..9686305f5d8 100644 --- a/.github/workflows/ci-checks.yml +++ b/.github/workflows/ci-checks.yml @@ -32,7 +32,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run unit test uses: nick-fields/retry@v3 @@ -66,7 +66,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run golint run: docker compose -f docker/github_actions/docker-compose.yml run coverage-report bash -c "./scripts/github_actions/golint.sh" @@ -86,7 +86,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run integration profile for cassandra uses: nick-fields/retry@v3 @@ -116,7 +116,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run integration profile for cassandra running history queue v2 uses: nick-fields/retry@v3 @@ -147,7 +147,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run integration profile for cassandra running history queue v2 with alert uses: nick-fields/retry@v3 @@ -179,7 +179,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run integration profile for cassandra and elasticsearch v7 uses: nick-fields/retry@v3 @@ -211,7 +211,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run integration test with cassandra and pinot uses: nick-fields/retry@v3 @@ -243,7 +243,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run integration profile for cassandra and opensearch v2 uses: nick-fields/retry@v3 @@ -275,7 +275,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run ndc profile for cassandra uses: nick-fields/retry@v3 @@ -307,7 +307,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run integration profile for mysql uses: nick-fields/retry@v3 @@ -339,7 +339,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run ndc profile for mysql uses: nick-fields/retry@v3 @@ -371,7 +371,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run integration profile for postgres uses: nick-fields/retry@v3 @@ -402,7 +402,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run integration profile for sqlite uses: nick-fields/retry@v3 @@ -433,7 +433,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run ndc profile for postgres uses: nick-fields/retry@v3 @@ -464,7 +464,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run async wf integration test with kafka uses: nick-fields/retry@v3 @@ -488,7 +488,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run integration test with etcd uses: nick-fields/retry@v3 diff --git a/.github/workflows/codecov-on-master.yml b/.github/workflows/codecov-on-master.yml index 67f3e1c22c1..07dd8c8b378 100644 --- a/.github/workflows/codecov-on-master.yml +++ b/.github/workflows/codecov-on-master.yml @@ -13,7 +13,7 @@ jobs: - name: Set up Go uses: actions/setup-go@v4 with: - go-version: 1.23.4 + go-version: 1.24.7 cache: false - name: Download dependencies run: go mod download diff --git a/.github/workflows/codecov-on-pr.yml b/.github/workflows/codecov-on-pr.yml index 852d2ce03d5..476f3f08eda 100644 --- a/.github/workflows/codecov-on-pr.yml +++ b/.github/workflows/codecov-on-pr.yml @@ -13,7 +13,7 @@ jobs: - name: Set up Go uses: actions/setup-go@v4 with: - go-version: 1.23.4 + go-version: 1.24.7 cache: false - name: Download dependencies diff --git a/.github/workflows/replication-simulation.yml b/.github/workflows/replication-simulation.yml index a1e96172636..c444fcc7e45 100644 --- a/.github/workflows/replication-simulation.yml +++ b/.github/workflows/replication-simulation.yml @@ -35,7 +35,7 @@ jobs: - name: Setup Go environment uses: actions/setup-go@v5 with: - go-version: '1.23.4' + go-version: '1.24.7' - name: Run simulation uses: nick-fields/retry@v3 diff --git a/.mockery.yml b/.mockery.yml new file mode 100644 index 00000000000..8fdf931fa7e --- /dev/null +++ b/.mockery.yml @@ -0,0 +1,85 @@ +all: false +log-level: info +dir: "{{.InterfaceDirRelative}}" +structname: "Mock{{.InterfaceName}}" +# interfacefile is an absolute path, get basename and rewrite +filename: "{{.InterfaceFile | base | replaceAll \".go\" \"_mock.go\"}}" +pkgname: "{{.SrcPackageName}}" +packages: + github.com/aws/aws-sdk-go/service/s3/s3iface: + config: + dir: "common/archiver/s3store/mocks" + filename: "s3_api_mock.go" + structname: "{{.InterfaceName}}" + pkgname: "mocks" + interfaces: + S3API: + github.com/uber/cadence/common/archiver: + config: + filename: "interface_mock.go" + structname: "{{.InterfaceName}}Mock" + interfaces: + HistoryArchiver: + VisibilityArchiver: + github.com/uber/cadence/common/archiver/gcloud/connector: + config: + dir: "common/archiver/gcloud/connector/mocks" + pkgname: "mocks" + filename: "{{.InterfaceName}}.go" + structname: "{{.InterfaceName}}" + interfaces: + Client: + GcloudStorageClient: + BucketHandleWrapper: + ObjectHandleWrapper: + ObjectIteratorWrapper: + ReaderWrapper: + WriterWrapper: + github.com/uber/cadence/common/archiver/provider: + interfaces: + ArchiverProvider: + github.com/uber/cadence/common/blobstore: + interfaces: + Client: + github.com/uber/cadence/common/elasticsearch: + config: + dir: "common/elasticsearch/mocks" + pkgname: "mocks" + filename: "{{.InterfaceName}}.go" + structname: "{{.InterfaceName}}" + interfaces: + GenericClient: + github.com/uber/cadence/common/elasticsearch/bulk: + config: + dir: "common/elasticsearch/bulk/mocks" + pkgname: "mocks" + filename: "{{.InterfaceName}}.go" + structname: "{{.InterfaceName}}" + interfaces: + GenericBulkableRequest: + GenericBulkProcessor: + github.com/uber/cadence/common/metrics: + config: + dir: "common/metrics/mocks" + pkgname: "mocks" + filename: "{{.InterfaceName}}.go" + structname: "{{.InterfaceName}}" + interfaces: + Client: + Scope: + github.com/uber/cadence/common/persistence: + config: + dir: "common/mocks" + pkgname: "mocks" + filename: "{{.InterfaceName}}.go" + structname: "{{.InterfaceName}}" + interfaces: + ExecutionManager: + TaskManager: + VisibilityManager: + ShardManager: + github.com/uber/cadence/service/worker/parentclosepolicy: + config: + structname: "ClientMock" + interfaces: + Client: \ No newline at end of file diff --git a/Dockerfile b/Dockerfile index 9b68d6f8de0..3c5c4f3fd3f 100644 --- a/Dockerfile +++ b/Dockerfile @@ -4,7 +4,7 @@ ARG TARGET=server ARG GOPROXY # Build Cadence binaries -FROM golang:1.23.4-alpine3.21 AS builder +FROM golang:1.24.7-alpine3.21 AS builder ARG RELEASE_VERSION diff --git a/Makefile b/Makefile index a722efd313c..1a1bdb33e1f 100644 --- a/Makefile +++ b/Makefile @@ -62,8 +62,6 @@ $(BUILD)/proto-lint: $(BUILD)/gomod-lint: $(BUILD)/goversion-lint: $(BUILD)/fmt: $(BUILD)/codegen # formatting must occur only after all other go-file-modifications are done -# $(BUILD)/copyright -# $(BUILD)/copyright: $(BUILD)/codegen # must add copyright to generated code, sometimes needs re-formatting $(BUILD)/codegen: $(BUILD)/thrift $(BUILD)/protoc $(BUILD)/thrift: $(BUILD)/go_mod_check $(BUILD)/protoc: $(BUILD)/go_mod_check @@ -79,6 +77,10 @@ $(BUILD)/go_mod_check: null := SPACE := $(null) # COMMA := , +define NEWLINE + + +endef # set a V=1 env var for verbose output. V=0 (or unset) disables. # this is used to make two verbose flags: @@ -112,6 +114,18 @@ endif PROJECT_ROOT = github.com/uber/cadence +# go submodules only, the top-level go.mod is easy enough to type by hand +SUBMODULE_PATHS = $(shell \ + find . \ + -type f \ + -name "go.mod" \ + -not -path "./go.mod" \ + -not -path "./idls/*" \ + -exec dirname {} \; \ + | sed 's|^\./||' \ +) +SUBMODULE_FILES = $(foreach MOD,$(SUBMODULE_PATHS),$(MOD)/go.mod) + # helper for executing bins that need other bins, just `$(BIN_PATH) the_command ...` # I'd recommend not exporting this in general, to reduce the chance of accidentally using non-versioned tools. BIN_PATH := PATH="$(abspath $(BIN)):$(abspath $(STABLE_BIN)):$$PATH" @@ -186,7 +200,7 @@ $(BIN)/mockgen: internal/tools/go.mod go.work $(call go_build_tool,go.uber.org/mock/mockgen) $(BIN)/mockery: internal/tools/go.mod go.work - $(call go_build_tool,github.com/vektra/mockery/v2,mockery) + $(call go_build_tool,github.com/vektra/mockery/v3,mockery) $(BIN)/enumer: internal/tools/go.mod go.work $(call go_build_tool,github.com/dmarkham/enumer) @@ -216,10 +230,6 @@ $(BUILD)/go_mod_check: go.mod internal/tools/go.mod go.work $Q ./scripts/check-gomod-version.sh github.com/golang/mock/gomock $(if $(verbose),-v) $Q touch $@ -# copyright header checker/writer. only requires stdlib, so no other dependencies are needed. -# $(BIN)/copyright: cmd/tools/copyright/licensegen.go -# $Q go build -o $@ ./cmd/tools/copyright/licensegen.go - # https://docs.buf.build/ # changing BUF_VERSION will automatically download and use the specified version. BUF_VERSION = 0.36.0 @@ -372,12 +382,11 @@ $(BUILD)/proto-lint: $(PROTO_FILES) $(STABLE_BIN)/$(BUF_VERSION_BIN) | $(BUILD) # lints that go modules are as expected, e.g. parent does not import submodule. # tool builds that need to be in sync with the parent are partially checked through go_mod_build_tool, but should probably be checked here too -$(BUILD)/gomod-lint: go.mod internal/tools/go.mod common/archiver/gcloud/go.mod | $(BUILD) +$(BUILD)/gomod-lint: go.mod $(SUBMODULE_FILES) | $(BUILD) $Q echo "checking for direct submodule dependencies in root go.mod..." $Q ( \ MAIN_MODULE=$$(grep "^module " go.mod | awk '{print $$2}'); \ - SUBMODULES=$$(find . -type f -name "go.mod" -not -path "./go.mod" -not -path "./idls/*" -exec dirname {} \; | sed 's|^\./||'); \ - for submodule in $$SUBMODULES; do \ + for submodule in $(SUBMODULE_PATHS); do \ submodule_path="$$MAIN_MODULE/$$submodule"; \ if grep -q "$$submodule_path" go.mod; then \ echo "ERROR: Root go.mod directly depends on submodule: $$submodule_path" >&2; \ @@ -410,19 +419,6 @@ $(BUILD)/goversion-lint: go.work Dockerfile docker/github_actions/Dockerfile${DO $Q ./scripts/check-go-toolchain.sh $(GOWORK_TOOLCHAIN) $Q touch $@ -# fmt and copyright are mutually cyclic with their inputs, so if a copyright header is modified: -# - copyright -> makes changes -# - fmt sees changes -> makes changes -# - now copyright thinks it needs to run again (but does nothing) -# - which means fmt needs to run again (but does nothing) -# and now after two passes it's finally stable, because they stopped making changes. -# -# this is not fatal, we can just run 2x. -# to be fancier though, we can detect when *both* are run, and re-touch the book-keeping files to prevent the second run. -# this STRICTLY REQUIRES that `copyright` and `fmt` are mutually stable, and that copyright runs before fmt. -# if either changes, this will need to change. -MAYBE_TOUCH_COPYRIGHT= - # use FRESH_ALL_SRC so it won't miss any generated files produced earlier. $(BUILD)/fmt: $(ALL_SRC) $(BIN)/goimports $(BIN)/gci | $(BUILD) $Q echo "removing unused imports..." @@ -431,12 +427,6 @@ $(BUILD)/fmt: $(ALL_SRC) $(BIN)/goimports $(BIN)/gci | $(BUILD) $Q echo "grouping imports..." $Q $(BIN)/gci write --section standard --section 'Prefix(github.com/uber/cadence/)' --section default --section blank $(FRESH_ALL_SRC) $Q touch $@ -# $Q $(MAYBE_TOUCH_COPYRIGHT) - -# $(BUILD)/copyright: $(ALL_SRC) $(BIN)/copyright | $(BUILD) -# $(BIN)/copyright --verifyOnly -# $Q $(eval MAYBE_TOUCH_COPYRIGHT=touch $@) -# $Q touch $@ # ==================================== # developer-oriented targets @@ -453,7 +443,7 @@ $Q rm -f $(addprefix $(BUILD)/,$(1)) $Q +$(MAKE) --no-print-directory $(addprefix $(BUILD)/,$(1)) endef -.PHONY: lint fmt copyright pr +.PHONY: lint fmt pr mockery # useful to actually re-run to get output again. # reuse the intermediates for simplicity and consistency. @@ -463,10 +453,9 @@ lint: ## (Re)run the linter # intentionally not re-making, it's a bit slow and it's clear when it's unnecessary fmt: $(BUILD)/fmt ## Run `gofmt` / organize imports / etc -# not identical to the intermediate target, but does provide the same codegen (or more). -# copyright: $(BIN)/copyright | $(BUILD) ## Update copyright headers -# $(BIN)/copyright -# $Q touch $(BUILD)/copyright +mockery: $(BIN)/mockery + $Q $(BIN)/mockery + $Q $(call remake,fmt) define make_quietly $Q echo "make $1..." @@ -479,7 +468,6 @@ pr: ## Redo all codegen and basic checks, to ensure your PR will be able to run $Q $(if $(verbose),$(MAKE) go-generate,$(call make_quietly,go-generate)) $Q $(if $(verbose),$(MAKE) fmt,$(call make_quietly,fmt)) $Q $(if $(verbose),$(MAKE) lint,$(call make_quietly,lint)) -# $Q $(if $(verbose),$(MAKE) copyright,$(call make_quietly,copyright)) # ==================================== # binaries to build @@ -538,7 +526,7 @@ cadence-bench: $(BINS_DEPEND_ON) $Q ./scripts/build-with-ldflags.sh -o $@ cmd/bench/main.go -BINS += cadence-releaser +BINS += cadence-releaser cadence-releaser: $(BINS_DEPEND_ON) $Q echo "compiling cadence-releaser with OS: $(GOOS), ARCH: $(GOARCH)" $Q ./scripts/build-with-ldflags.sh -o $@ cmd/tools/releaser/releaser.go @@ -550,12 +538,12 @@ bins: $(BINS) ## Build all binaries, and any fast codegen needed (does not refre tools: $(TOOLS) go-generate: $(BIN)/mockgen $(BIN)/enumer $(BIN)/mockery $(BIN)/gowrap ## Run `go generate` to regen mocks, enums, etc - $Q echo "running go generate ./..., this takes a minute or more..." + $Q echo "running mockery..." + $Q $(BIN)/mockery --log-level error + $Q echo "running go generate ./..., this takes a few minutes..." $Q # add our bins to PATH so `go generate` can find them $Q $(BIN_PATH) go generate $(if $(verbose),-v) ./... $Q $(MAKE) --no-print-directory fmt -# $Q echo "updating copyright headers" -# $Q $(MAKE) --no-print-directory copyright release: ## Re-generate generated code and run tests $(MAKE) --no-print-directory go-generate @@ -574,15 +562,21 @@ build: ## `go build` all packages and tests (a quick compile check only, skips a $Q cd cmd/server; go test -exec /usr/bin/true ./... >/dev/null tidy: ## `go mod tidy` all packages - $Q # tidy in dependency order + $Q # tidy needs to run in dependency order: + $Q # everything depends on the main module, server depends on everything else so it should be last. + $Q # but we can just tidy everything 2x, which should be stable as our dependency tree is only 2 deep. $Q go mod tidy - $Q cd common/archiver/gcloud; go mod tidy || (echo "failed to tidy gcloud plugin, try manually copying go.mod contents into common/archiver/gcloud/go.mod and rerunning" >&2; exit 1) - $Q cd cmd/server; go mod tidy || (echo "failed to tidy main server module, try manually copying go.mod and common/archiver/gcloud/go.mod contents into cmd/server/go.mod and rerunning" >&2; exit 1) + $Q $(foreach sub,$(SUBMODULE_PATHS), \ + $Q cd $(sub); go mod tidy || $$(>&2 echo "failed to tidy $(sub) plugin, try manually copying go.mod contents into $(sub)/go.mod and rerunning by hand"; exit 1)$(NEWLINE) \ + ) + $Q $(foreach sub,$(SUBMODULE_PATHS), \ + $Q cd $(sub); go mod tidy || $$(>&2 echo "failed to tidy $(sub) plugin, try manually copying go.mod contents into $(sub)/go.mod and rerunning by hand"; exit 1)$(NEWLINE) \ + ) clean: ## Clean build products and SQLite database rm -f $(BINS) rm -Rf $(BUILD) - rm *.db + rm -f *.db $(if \ $(wildcard $(STABLE_BIN)/*), \ $(warning usually-stable build tools still exist, delete the $(STABLE_BIN) folder to rebuild them),) diff --git a/bench/load/signal/workflow.go b/bench/load/signal/workflow.go index 84eaf834927..50bf07b0300 100644 --- a/bench/load/signal/workflow.go +++ b/bench/load/signal/workflow.go @@ -400,7 +400,7 @@ main_loop: if workflow.Now(ctx).Sub(time.Unix(0, signal.Timestamp)) > time.Duration(params.MaxSignalDelayInSeconds)*time.Second { signalDelayCount++ if signalDelayCount > params.MaxSignalDelayCount { - return fmt.Errorf(fmt.Sprintf("received %v signals are longer than %v seconds.", params.MaxSignalDelayCount, params.MaxSignalDelayInSeconds)) + return fmt.Errorf("received %v signals are longer than %v seconds", params.MaxSignalDelayCount, params.MaxSignalDelayInSeconds) } } diff --git a/cmd/server/go.mod b/cmd/server/go.mod index 7a640eb6fde..f1957ce5594 100644 --- a/cmd/server/go.mod +++ b/cmd/server/go.mod @@ -1,8 +1,8 @@ module github.com/uber/cadence/cmd/server -go 1.23.0 +go 1.24 -toolchain go1.23.4 +toolchain go1.24.7 // build against the current code in the "main" (and gcloud) module, not a specific SHA. // @@ -56,10 +56,10 @@ require ( go.uber.org/thriftrw v1.29.2 // indirect go.uber.org/yarpc v1.70.3 // indirect go.uber.org/zap v1.26.0 - golang.org/x/net v0.40.0 // indirect - golang.org/x/sync v0.14.0 // indirect + golang.org/x/net v0.43.0 // indirect + golang.org/x/sync v0.16.0 // indirect golang.org/x/time v0.5.0 // indirect - golang.org/x/tools v0.22.0 // indirect + golang.org/x/tools v0.36.0 // indirect gonum.org/v1/gonum v0.7.0 // indirect google.golang.org/grpc v1.59.0 // indirect gopkg.in/validator.v2 v2.0.0-20180514200540-135c24b11c19 // indirect @@ -71,7 +71,7 @@ require ( github.com/uber/cadence/common/archiver/gcloud v0.0.0-00010101000000-000000000000 github.com/uber/cadence/service/sharddistributor/store/etcd v0.0.0-00010101000000-000000000000 go.uber.org/automaxprocs v1.6.0 - go.uber.org/mock v0.5.0 + go.uber.org/mock v0.6.0 ) require ( @@ -82,12 +82,12 @@ require ( github.com/google/gofuzz v1.0.0 // indirect github.com/mattn/go-colorable v0.1.9 // indirect github.com/mattn/go-isatty v0.0.14 // indirect - github.com/ncruces/go-sqlite3 v0.22.0 // indirect + github.com/ncruces/go-sqlite3 v0.23.3 // indirect github.com/ncruces/julianday v1.0.0 // indirect github.com/opensearch-project/opensearch-go/v4 v4.1.0 // indirect github.com/pierrec/lz4/v4 v4.1.22 // indirect github.com/robfig/cron/v3 v3.0.1 // indirect - github.com/tetratelabs/wazero v1.8.2 // indirect + github.com/tetratelabs/wazero v1.9.0 // indirect github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect go.etcd.io/etcd/api/v3 v3.5.5 // indirect go.etcd.io/etcd/client/pkg/v3 v3.5.5 // indirect @@ -160,14 +160,14 @@ require ( go.opencensus.io v0.24.0 // indirect go.uber.org/dig v1.18.0 // indirect go.uber.org/net/metrics v1.3.0 // indirect - golang.org/x/crypto v0.38.0 // indirect + golang.org/x/crypto v0.41.0 // indirect golang.org/x/exp v0.0.0-20231226003508-02704c960a9b // indirect golang.org/x/exp/typeparams v0.0.0-20220218215828-6cf2b201936e // indirect golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 // indirect - golang.org/x/mod v0.18.0 // indirect + golang.org/x/mod v0.27.0 // indirect golang.org/x/oauth2 v0.11.0 // indirect - golang.org/x/sys v0.33.0 // indirect - golang.org/x/text v0.25.0 // indirect + golang.org/x/sys v0.35.0 // indirect + golang.org/x/text v0.28.0 // indirect golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect google.golang.org/api v0.128.0 // indirect google.golang.org/appengine v1.6.7 // indirect diff --git a/cmd/server/go.sum b/cmd/server/go.sum index be04231efb4..eff91a35eea 100644 --- a/cmd/server/go.sum +++ b/cmd/server/go.sum @@ -296,8 +296,8 @@ github.com/modern-go/reflect2 v0.0.0-20180701023420-4b7aa43c6742/go.mod h1:bx2lN github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= -github.com/ncruces/go-sqlite3 v0.22.0 h1:FkGSBhd0TY6e66k1LVhyEpA+RnG/8QkQNed5pjIk4cs= -github.com/ncruces/go-sqlite3 v0.22.0/go.mod h1:ueXOZXYZS2OFQirCU3mHneDwJm5fGKHrtccYBeGEV7M= +github.com/ncruces/go-sqlite3 v0.23.3 h1:RHaQPjd5hPhhVXuS2B4z07rqhV/3SuAsBbDCk23fyMw= +github.com/ncruces/go-sqlite3 v0.23.3/go.mod h1:WvU8gwMpK1rNG3JqJ7QZGRXNVNeIAwuButtr/Ze3iso= github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M= github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g= github.com/olivere/elastic v6.2.37+incompatible h1:UfSGJem5czY+x/LqxgeCBgjDn6St+z8OnsCuxwD3L0U= @@ -396,8 +396,8 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/tetratelabs/wazero v1.8.2 h1:yIgLR/b2bN31bjxwXHD8a3d+BogigR952csSDdLYEv4= -github.com/tetratelabs/wazero v1.8.2/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs= +github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I= +github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM= github.com/tidwall/gjson v1.17.1 h1:wlYEnwqAHgzmhNUFfw7Xalt2JzQvsMx2Se4PcoFCT/U= github.com/tidwall/gjson v1.17.1/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA= @@ -478,8 +478,8 @@ go.uber.org/goleak v0.10.0/go.mod h1:VCZuO8V8mFPlL0F5J5GK1rtHV3DrFcQ1R8ryq7FK0aI go.uber.org/goleak v1.0.0/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk= go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo= -go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU= -go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM= +go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= +go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= go.uber.org/multierr v1.4.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= @@ -509,8 +509,8 @@ golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPh golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.0.0-20220314234659-1baeb1ce4c0b/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58= -golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8= -golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw= +golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4= +golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc= golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= @@ -534,8 +534,8 @@ golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0= -golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ= +golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -560,8 +560,8 @@ golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qx golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= -golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY= -golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds= +golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE= +golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -577,8 +577,8 @@ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ= -golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw= +golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -611,8 +611,8 @@ golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= -golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI= +golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= @@ -625,8 +625,8 @@ golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4= -golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA= +golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng= +golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU= golang.org/x/time v0.0.0-20170927054726-6dc17368e09b/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= @@ -659,8 +659,10 @@ golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.11-0.20220513221640-090b14e8501f/go.mod h1:SgwaegtQh8clINPpECJMqnxLv9I09HLqnW3RMqW0CA4= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA= -golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c= +golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg= +golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s= +golang.org/x/tools/go/expect v0.1.1-deprecated h1:jpBZDwmgPhXsKZC6WhL20P4b/wmnpsEAGHaNy0n/rJM= +golang.org/x/tools/go/expect v0.1.1-deprecated/go.mod h1:eihoPOH+FgIqa3FpoTwguz/bVUSGBlGQU67vpBeOrBY= 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= diff --git a/cmd/tools/copyright/licensegen.go b/cmd/tools/copyright/licensegen.go deleted file mode 100644 index b72920f5fc5..00000000000 --- a/cmd/tools/copyright/licensegen.go +++ /dev/null @@ -1,285 +0,0 @@ -// Copyright (c) 2017 Uber Technologies, Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -package main - -import ( - "bufio" - "errors" - "flag" - "fmt" - "io/ioutil" - "os" - "path/filepath" - "strings" -) - -type ( - // task that adds license header to source - // files, if they don't already exist - addLicenseHeaderTask struct { - license string // license header string to add - config *config // root directory of the project source - } - - // command line config params - config struct { - rootDir string - verifyOnly bool - temporalAddMode bool - temporalModifyMode bool - filePaths string - } -) - -// licenseFileName is the name of the license file -const licenseFileName = "LICENSE" - -// unique prefix that identifies a license header -const licenseHeaderPrefixOld = "Copyright (c)" -const licenseHeaderPrefix = "// The MIT License (MIT)" -const cadenceCopyright = "// Copyright (c) 2017-2020 Uber Technologies Inc." -const cadenceModificationHeader = "// Modifications Copyright (c) 2020 Uber Technologies Inc." -const temporalCopyright = "// Copyright (c) 2020 Temporal Technologies, Inc." -const temporalPartialCopyright = "// Portions of the Software are attributed to Copyright (c) 2020 Temporal Technologies Inc." - -const firstLinesToCheck = 10 - -var ( - // directories to be excluded - dirDenylist = []string{"vendor/"} - // default perms for the newly created files - defaultFilePerms = os.FileMode(0644) -) - -// command line utility that adds license header -// to the source files. Usage as follows: -// -// ./cmd/tools/copyright/licensegen.go -func main() { - - var cfg config - flag.StringVar(&cfg.rootDir, "rootDir", ".", "project root directory") - flag.BoolVar(&cfg.verifyOnly, "verifyOnly", false, - "don't automatically add headers, just verify all files") - flag.BoolVar(&cfg.temporalAddMode, "temporalAddMode", false, "add copyright for new file copied from temporal") - flag.BoolVar(&cfg.temporalModifyMode, "temporalModifyMode", false, "add copyright for existing file which has parts copied from temporal") - flag.StringVar(&cfg.filePaths, "filePaths", "", "comma separated list of files to run temporal license on") - flag.Parse() - - if err := verifyCfg(cfg); err != nil { - fmt.Println(err) - os.Exit(-1) - } - - task := newAddLicenseHeaderTask(&cfg) - if err := task.run(); err != nil { - fmt.Println(err) - os.Exit(-1) - } -} - -func verifyCfg(cfg config) error { - if cfg.verifyOnly { - if cfg.temporalModifyMode || cfg.temporalAddMode { - return errors.New("invalid config, can only specify one of temporalAddMode, temporalModifyMode or verifyOnly") - } - } - if cfg.temporalAddMode && cfg.temporalModifyMode { - return errors.New("invalid config, can only specify temporalAddMode or temporalModifyMode") - } - if (cfg.temporalModifyMode || cfg.temporalAddMode) && len(cfg.filePaths) == 0 { - return errors.New("invalid config, when running in temporalAddMode or temporalModifyMode must provide filePaths") - } - return nil -} - -func newAddLicenseHeaderTask(cfg *config) *addLicenseHeaderTask { - return &addLicenseHeaderTask{ - config: cfg, - } -} - -func (task *addLicenseHeaderTask) run() error { - data, err := ioutil.ReadFile(task.config.rootDir + "/" + licenseFileName) - if err != nil { - return fmt.Errorf("error reading license file, errr=%v", err.Error()) - } - task.license, err = commentOutLines(string(data)) - if err != nil { - return fmt.Errorf("copyright header failed to comment out lines, err=%v", err.Error()) - } - if task.config.temporalAddMode { - task.license = fmt.Sprintf("%v\n\n%v\n\n%v", cadenceModificationHeader, temporalCopyright, task.license) - } else if task.config.temporalModifyMode { - task.license = fmt.Sprintf("%v\n\n%v\n\n%v", cadenceCopyright, temporalPartialCopyright, task.license) - } - if task.config.temporalModifyMode || task.config.temporalAddMode { - filePaths, fileInfos, err := getFilePaths(task.config.filePaths) - if err != nil { - return err - } - for i := 0; i < len(filePaths); i++ { - if err := task.handleFile(filePaths[i], fileInfos[i], nil); err != nil { - return err - } - } - return nil - } - task.license = fmt.Sprintf("%v\n\n%v\n\n%v", licenseHeaderPrefix, cadenceCopyright, task.license) - err = filepath.Walk(task.config.rootDir, task.handleFile) - if err != nil { - return fmt.Errorf("copyright header check failed, err=%v", err.Error()) - } - return nil -} - -func (task *addLicenseHeaderTask) handleFile(path string, fileInfo os.FileInfo, err error) error { - - if err != nil { - return err - } - - if fileInfo.IsDir() { - if strings.HasPrefix(fileInfo.Name(), "_vendor-") || fileInfo.Name() == ".build" || fileInfo.Name() == ".bin" { - return filepath.SkipDir - } - return nil - } - - if !mustProcessPath(path) { - return nil - } - - if !strings.HasSuffix(fileInfo.Name(), ".go") && !strings.HasSuffix(fileInfo.Name(), ".proto") { - return nil - } - - // Used as part of the cli to write licence headers on files, does not use user supplied input so marked as nosec - // #nosec - f, err := os.Open(path) - if err != nil { - return err - } - - ok, err := hasCopyright(f) - if err != nil { - return err - } - - if err := f.Close(); err != nil { - return err - } - - if ok { - if task.config.temporalModifyMode || task.config.temporalAddMode { - return fmt.Errorf("when running in temporalModifyMode or temporalAddMode please first remove existing license header: %v", path) - } - return nil - } - - // at this point, src file is missing the header - if task.config.verifyOnly { - if !isFileAutogenerated(path) { - return fmt.Errorf("%v missing license header", path) - } - } - - // Used as part of the cli to write licence headers on files, does not use user supplied input so marked as nosec - // #nosec - data, err := ioutil.ReadFile(path) - if err != nil { - return err - } - - return ioutil.WriteFile(path, []byte(task.license+string(data)), defaultFilePerms) -} - -func hasCopyright(f *os.File) (bool, error) { - scanner := bufio.NewScanner(f) - lineSuccess := scanner.Scan() - if !lineSuccess { - return false, fmt.Errorf("fail to read first line of file %v", f.Name()) - } - i := 0 - for i < firstLinesToCheck && lineSuccess { - i++ - line := strings.TrimSpace(scanner.Text()) - if err := scanner.Err(); err != nil { - return false, err - } - if lineHasCopyright(line) { - return true, nil - } - lineSuccess = scanner.Scan() - } - return false, nil -} - -func isFileAutogenerated(path string) bool { - return strings.HasPrefix(path, ".gen") -} - -func mustProcessPath(path string) bool { - for _, d := range dirDenylist { - if strings.HasPrefix(path, d) { - return false - } - } - return true -} - -func commentOutLines(str string) (string, error) { - var lines []string - scanner := bufio.NewScanner(strings.NewReader(str)) - for scanner.Scan() { - text := scanner.Text() - if text == "" { - // do not add trailing whitespace, gofmt / goimports removes it - lines = append(lines, "//\n") - } else { - lines = append(lines, "// "+scanner.Text()+"\n") - } - } - lines = append(lines, "\n") - - if err := scanner.Err(); err != nil { - return "", err - } - return strings.Join(lines, ""), nil -} - -func lineHasCopyright(line string) bool { - return strings.Contains(line, licenseHeaderPrefixOld) || - strings.Contains(line, licenseHeaderPrefix) -} - -func getFilePaths(filePaths string) ([]string, []os.FileInfo, error) { - paths := strings.Split(filePaths, ",") - var fileInfos []os.FileInfo - for _, p := range paths { - fileInfo, err := os.Stat(p) - if err != nil { - return nil, nil, err - } - fileInfos = append(fileInfos, fileInfo) - } - return paths, fileInfos, nil -} diff --git a/common/archiver/gcloud/connector/mocks/BucketHandleWrapper.go b/common/archiver/gcloud/connector/mocks/BucketHandleWrapper.go index f97ab03760c..fdef666df32 100644 --- a/common/archiver/gcloud/connector/mocks/BucketHandleWrapper.go +++ b/common/archiver/gcloud/connector/mocks/BucketHandleWrapper.go @@ -1,92 +1,215 @@ -// Copyright (c) 2020 Uber Technologies, Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -// Code generated by mockery v1.0.0. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - context "context" + "context" - storage "cloud.google.com/go/storage" + "cloud.google.com/go/storage" mock "github.com/stretchr/testify/mock" - connector "github.com/uber/cadence/common/archiver/gcloud/connector" + "github.com/uber/cadence/common/archiver/gcloud/connector" ) +// NewBucketHandleWrapper creates a new instance of BucketHandleWrapper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewBucketHandleWrapper(t interface { + mock.TestingT + Cleanup(func()) +}) *BucketHandleWrapper { + mock := &BucketHandleWrapper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // BucketHandleWrapper is an autogenerated mock type for the BucketHandleWrapper type type BucketHandleWrapper struct { mock.Mock } -// Attrs provides a mock function with given fields: ctx -func (_m *BucketHandleWrapper) Attrs(ctx context.Context) (*storage.BucketAttrs, error) { - ret := _m.Called(ctx) +type BucketHandleWrapper_Expecter struct { + mock *mock.Mock +} + +func (_m *BucketHandleWrapper) EXPECT() *BucketHandleWrapper_Expecter { + return &BucketHandleWrapper_Expecter{mock: &_m.Mock} +} + +// Attrs provides a mock function for the type BucketHandleWrapper +func (_mock *BucketHandleWrapper) Attrs(ctx context.Context) (*storage.BucketAttrs, error) { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Attrs") + } var r0 *storage.BucketAttrs - if rf, ok := ret.Get(0).(func(context.Context) *storage.BucketAttrs); ok { - r0 = rf(ctx) + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context) (*storage.BucketAttrs, error)); ok { + return returnFunc(ctx) + } + if returnFunc, ok := ret.Get(0).(func(context.Context) *storage.BucketAttrs); ok { + r0 = returnFunc(ctx) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*storage.BucketAttrs) } } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context) error); ok { - r1 = rf(ctx) + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) } else { r1 = ret.Error(1) } - return r0, r1 } -// Object provides a mock function with given fields: name -func (_m *BucketHandleWrapper) Object(name string) connector.ObjectHandleWrapper { - ret := _m.Called(name) +// BucketHandleWrapper_Attrs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Attrs' +type BucketHandleWrapper_Attrs_Call struct { + *mock.Call +} + +// Attrs is a helper method to define mock.On call +// - ctx context.Context +func (_e *BucketHandleWrapper_Expecter) Attrs(ctx interface{}) *BucketHandleWrapper_Attrs_Call { + return &BucketHandleWrapper_Attrs_Call{Call: _e.mock.On("Attrs", ctx)} +} + +func (_c *BucketHandleWrapper_Attrs_Call) Run(run func(ctx context.Context)) *BucketHandleWrapper_Attrs_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *BucketHandleWrapper_Attrs_Call) Return(bucketAttrs *storage.BucketAttrs, err error) *BucketHandleWrapper_Attrs_Call { + _c.Call.Return(bucketAttrs, err) + return _c +} + +func (_c *BucketHandleWrapper_Attrs_Call) RunAndReturn(run func(ctx context.Context) (*storage.BucketAttrs, error)) *BucketHandleWrapper_Attrs_Call { + _c.Call.Return(run) + return _c +} + +// Object provides a mock function for the type BucketHandleWrapper +func (_mock *BucketHandleWrapper) Object(name string) connector.ObjectHandleWrapper { + ret := _mock.Called(name) + + if len(ret) == 0 { + panic("no return value specified for Object") + } var r0 connector.ObjectHandleWrapper - if rf, ok := ret.Get(0).(func(string) connector.ObjectHandleWrapper); ok { - r0 = rf(name) + if returnFunc, ok := ret.Get(0).(func(string) connector.ObjectHandleWrapper); ok { + r0 = returnFunc(name) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(connector.ObjectHandleWrapper) } } - return r0 } -// Objects provides a mock function with given fields: ctx, q -func (_m *BucketHandleWrapper) Objects(ctx context.Context, q *storage.Query) connector.ObjectIteratorWrapper { - ret := _m.Called(ctx, q) +// BucketHandleWrapper_Object_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Object' +type BucketHandleWrapper_Object_Call struct { + *mock.Call +} + +// Object is a helper method to define mock.On call +// - name string +func (_e *BucketHandleWrapper_Expecter) Object(name interface{}) *BucketHandleWrapper_Object_Call { + return &BucketHandleWrapper_Object_Call{Call: _e.mock.On("Object", name)} +} + +func (_c *BucketHandleWrapper_Object_Call) Run(run func(name string)) *BucketHandleWrapper_Object_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *BucketHandleWrapper_Object_Call) Return(objectHandleWrapper connector.ObjectHandleWrapper) *BucketHandleWrapper_Object_Call { + _c.Call.Return(objectHandleWrapper) + return _c +} + +func (_c *BucketHandleWrapper_Object_Call) RunAndReturn(run func(name string) connector.ObjectHandleWrapper) *BucketHandleWrapper_Object_Call { + _c.Call.Return(run) + return _c +} + +// Objects provides a mock function for the type BucketHandleWrapper +func (_mock *BucketHandleWrapper) Objects(ctx context.Context, q *storage.Query) connector.ObjectIteratorWrapper { + ret := _mock.Called(ctx, q) + + if len(ret) == 0 { + panic("no return value specified for Objects") + } var r0 connector.ObjectIteratorWrapper - if rf, ok := ret.Get(0).(func(context.Context, *storage.Query) connector.ObjectIteratorWrapper); ok { - r0 = rf(ctx, q) + if returnFunc, ok := ret.Get(0).(func(context.Context, *storage.Query) connector.ObjectIteratorWrapper); ok { + r0 = returnFunc(ctx, q) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(connector.ObjectIteratorWrapper) } } - return r0 } + +// BucketHandleWrapper_Objects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Objects' +type BucketHandleWrapper_Objects_Call struct { + *mock.Call +} + +// Objects is a helper method to define mock.On call +// - ctx context.Context +// - q *storage.Query +func (_e *BucketHandleWrapper_Expecter) Objects(ctx interface{}, q interface{}) *BucketHandleWrapper_Objects_Call { + return &BucketHandleWrapper_Objects_Call{Call: _e.mock.On("Objects", ctx, q)} +} + +func (_c *BucketHandleWrapper_Objects_Call) Run(run func(ctx context.Context, q *storage.Query)) *BucketHandleWrapper_Objects_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *storage.Query + if args[1] != nil { + arg1 = args[1].(*storage.Query) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *BucketHandleWrapper_Objects_Call) Return(objectIteratorWrapper connector.ObjectIteratorWrapper) *BucketHandleWrapper_Objects_Call { + _c.Call.Return(objectIteratorWrapper) + return _c +} + +func (_c *BucketHandleWrapper_Objects_Call) RunAndReturn(run func(ctx context.Context, q *storage.Query) connector.ObjectIteratorWrapper) *BucketHandleWrapper_Objects_Call { + _c.Call.Return(run) + return _c +} diff --git a/common/archiver/gcloud/connector/mocks/Client.go b/common/archiver/gcloud/connector/mocks/Client.go index c4aa991f6cb..be7fe408857 100644 --- a/common/archiver/gcloud/connector/mocks/Client.go +++ b/common/archiver/gcloud/connector/mocks/Client.go @@ -1,155 +1,434 @@ -// Copyright (c) 2020 Uber Technologies, Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -// Code generated by mockery v1.0.0. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - context "context" + "context" mock "github.com/stretchr/testify/mock" - archiver "github.com/uber/cadence/common/archiver" - connector "github.com/uber/cadence/common/archiver/gcloud/connector" + "github.com/uber/cadence/common/archiver" + "github.com/uber/cadence/common/archiver/gcloud/connector" ) +// NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewClient(t interface { + mock.TestingT + Cleanup(func()) +}) *Client { + mock := &Client{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // Client is an autogenerated mock type for the Client type type Client struct { mock.Mock } -// Exist provides a mock function with given fields: ctx, URI, fileName -func (_m *Client) Exist(ctx context.Context, URI archiver.URI, fileName string) (bool, error) { - ret := _m.Called(ctx, URI, fileName) +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + +// Exist provides a mock function for the type Client +func (_mock *Client) Exist(ctx context.Context, URI archiver.URI, fileName string) (bool, error) { + ret := _mock.Called(ctx, URI, fileName) + + if len(ret) == 0 { + panic("no return value specified for Exist") + } var r0 bool - if rf, ok := ret.Get(0).(func(context.Context, archiver.URI, string) bool); ok { - r0 = rf(ctx, URI, fileName) + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, archiver.URI, string) (bool, error)); ok { + return returnFunc(ctx, URI, fileName) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, archiver.URI, string) bool); ok { + r0 = returnFunc(ctx, URI, fileName) } else { r0 = ret.Get(0).(bool) } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, archiver.URI, string) error); ok { - r1 = rf(ctx, URI, fileName) + if returnFunc, ok := ret.Get(1).(func(context.Context, archiver.URI, string) error); ok { + r1 = returnFunc(ctx, URI, fileName) } else { r1 = ret.Error(1) } - return r0, r1 } -// Get provides a mock function with given fields: ctx, URI, file -func (_m *Client) Get(ctx context.Context, URI archiver.URI, file string) ([]byte, error) { - ret := _m.Called(ctx, URI, file) +// Client_Exist_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Exist' +type Client_Exist_Call struct { + *mock.Call +} + +// Exist is a helper method to define mock.On call +// - ctx context.Context +// - URI archiver.URI +// - fileName string +func (_e *Client_Expecter) Exist(ctx interface{}, URI interface{}, fileName interface{}) *Client_Exist_Call { + return &Client_Exist_Call{Call: _e.mock.On("Exist", ctx, URI, fileName)} +} + +func (_c *Client_Exist_Call) Run(run func(ctx context.Context, URI archiver.URI, fileName string)) *Client_Exist_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 archiver.URI + if args[1] != nil { + arg1 = args[1].(archiver.URI) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Client_Exist_Call) Return(b bool, err error) *Client_Exist_Call { + _c.Call.Return(b, err) + return _c +} + +func (_c *Client_Exist_Call) RunAndReturn(run func(ctx context.Context, URI archiver.URI, fileName string) (bool, error)) *Client_Exist_Call { + _c.Call.Return(run) + return _c +} + +// Get provides a mock function for the type Client +func (_mock *Client) Get(ctx context.Context, URI archiver.URI, file string) ([]byte, error) { + ret := _mock.Called(ctx, URI, file) + + if len(ret) == 0 { + panic("no return value specified for Get") + } var r0 []byte - if rf, ok := ret.Get(0).(func(context.Context, archiver.URI, string) []byte); ok { - r0 = rf(ctx, URI, file) + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, archiver.URI, string) ([]byte, error)); ok { + return returnFunc(ctx, URI, file) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, archiver.URI, string) []byte); ok { + r0 = returnFunc(ctx, URI, file) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]byte) } } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, archiver.URI, string) error); ok { - r1 = rf(ctx, URI, file) + if returnFunc, ok := ret.Get(1).(func(context.Context, archiver.URI, string) error); ok { + r1 = returnFunc(ctx, URI, file) } else { r1 = ret.Error(1) } - return r0, r1 } -// Query provides a mock function with given fields: ctx, URI, fileNamePrefix -func (_m *Client) Query(ctx context.Context, URI archiver.URI, fileNamePrefix string) ([]string, error) { - ret := _m.Called(ctx, URI, fileNamePrefix) +// Client_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type Client_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - ctx context.Context +// - URI archiver.URI +// - file string +func (_e *Client_Expecter) Get(ctx interface{}, URI interface{}, file interface{}) *Client_Get_Call { + return &Client_Get_Call{Call: _e.mock.On("Get", ctx, URI, file)} +} + +func (_c *Client_Get_Call) Run(run func(ctx context.Context, URI archiver.URI, file string)) *Client_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 archiver.URI + if args[1] != nil { + arg1 = args[1].(archiver.URI) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Client_Get_Call) Return(bytes []byte, err error) *Client_Get_Call { + _c.Call.Return(bytes, err) + return _c +} + +func (_c *Client_Get_Call) RunAndReturn(run func(ctx context.Context, URI archiver.URI, file string) ([]byte, error)) *Client_Get_Call { + _c.Call.Return(run) + return _c +} + +// Query provides a mock function for the type Client +func (_mock *Client) Query(ctx context.Context, URI archiver.URI, fileNamePrefix string) ([]string, error) { + ret := _mock.Called(ctx, URI, fileNamePrefix) + + if len(ret) == 0 { + panic("no return value specified for Query") + } var r0 []string - if rf, ok := ret.Get(0).(func(context.Context, archiver.URI, string) []string); ok { - r0 = rf(ctx, URI, fileNamePrefix) + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, archiver.URI, string) ([]string, error)); ok { + return returnFunc(ctx, URI, fileNamePrefix) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, archiver.URI, string) []string); ok { + r0 = returnFunc(ctx, URI, fileNamePrefix) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]string) } } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, archiver.URI, string) error); ok { - r1 = rf(ctx, URI, fileNamePrefix) + if returnFunc, ok := ret.Get(1).(func(context.Context, archiver.URI, string) error); ok { + r1 = returnFunc(ctx, URI, fileNamePrefix) } else { r1 = ret.Error(1) } - return r0, r1 } -// QueryWithFilters provides a mock function with given fields: ctx, URI, fileNamePrefix, pageSize, offset, filters -func (_m *Client) QueryWithFilters(ctx context.Context, URI archiver.URI, fileNamePrefix string, pageSize int, offset int, filters []connector.Precondition) ([]string, bool, int, error) { - ret := _m.Called(ctx, URI, fileNamePrefix, pageSize, offset, filters) +// Client_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query' +type Client_Query_Call struct { + *mock.Call +} + +// Query is a helper method to define mock.On call +// - ctx context.Context +// - URI archiver.URI +// - fileNamePrefix string +func (_e *Client_Expecter) Query(ctx interface{}, URI interface{}, fileNamePrefix interface{}) *Client_Query_Call { + return &Client_Query_Call{Call: _e.mock.On("Query", ctx, URI, fileNamePrefix)} +} + +func (_c *Client_Query_Call) Run(run func(ctx context.Context, URI archiver.URI, fileNamePrefix string)) *Client_Query_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 archiver.URI + if args[1] != nil { + arg1 = args[1].(archiver.URI) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Client_Query_Call) Return(strings []string, err error) *Client_Query_Call { + _c.Call.Return(strings, err) + return _c +} + +func (_c *Client_Query_Call) RunAndReturn(run func(ctx context.Context, URI archiver.URI, fileNamePrefix string) ([]string, error)) *Client_Query_Call { + _c.Call.Return(run) + return _c +} + +// QueryWithFilters provides a mock function for the type Client +func (_mock *Client) QueryWithFilters(ctx context.Context, URI archiver.URI, fileNamePrefix string, pageSize int, offset int, filters []connector.Precondition) ([]string, bool, int, error) { + ret := _mock.Called(ctx, URI, fileNamePrefix, pageSize, offset, filters) + + if len(ret) == 0 { + panic("no return value specified for QueryWithFilters") + } var r0 []string - if rf, ok := ret.Get(0).(func(context.Context, archiver.URI, string, int, int, []connector.Precondition) []string); ok { - r0 = rf(ctx, URI, fileNamePrefix, pageSize, offset, filters) + var r1 bool + var r2 int + var r3 error + if returnFunc, ok := ret.Get(0).(func(context.Context, archiver.URI, string, int, int, []connector.Precondition) ([]string, bool, int, error)); ok { + return returnFunc(ctx, URI, fileNamePrefix, pageSize, offset, filters) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, archiver.URI, string, int, int, []connector.Precondition) []string); ok { + r0 = returnFunc(ctx, URI, fileNamePrefix, pageSize, offset, filters) } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]string) } } - - var r1 bool - if rf, ok := ret.Get(1).(func(context.Context, archiver.URI, string, int, int, []connector.Precondition) bool); ok { - r1 = rf(ctx, URI, fileNamePrefix, pageSize, offset, filters) + if returnFunc, ok := ret.Get(1).(func(context.Context, archiver.URI, string, int, int, []connector.Precondition) bool); ok { + r1 = returnFunc(ctx, URI, fileNamePrefix, pageSize, offset, filters) } else { r1 = ret.Get(1).(bool) } - - var r2 int - if rf, ok := ret.Get(2).(func(context.Context, archiver.URI, string, int, int, []connector.Precondition) int); ok { - r2 = rf(ctx, URI, fileNamePrefix, pageSize, offset, filters) + if returnFunc, ok := ret.Get(2).(func(context.Context, archiver.URI, string, int, int, []connector.Precondition) int); ok { + r2 = returnFunc(ctx, URI, fileNamePrefix, pageSize, offset, filters) } else { r2 = ret.Get(2).(int) } - - var r3 error - if rf, ok := ret.Get(3).(func(context.Context, archiver.URI, string, int, int, []connector.Precondition) error); ok { - r3 = rf(ctx, URI, fileNamePrefix, pageSize, offset, filters) + if returnFunc, ok := ret.Get(3).(func(context.Context, archiver.URI, string, int, int, []connector.Precondition) error); ok { + r3 = returnFunc(ctx, URI, fileNamePrefix, pageSize, offset, filters) } else { r3 = ret.Error(3) } - return r0, r1, r2, r3 } -// Upload provides a mock function with given fields: ctx, URI, fileName, file -func (_m *Client) Upload(ctx context.Context, URI archiver.URI, fileName string, file []byte) error { - ret := _m.Called(ctx, URI, fileName, file) +// Client_QueryWithFilters_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'QueryWithFilters' +type Client_QueryWithFilters_Call struct { + *mock.Call +} + +// QueryWithFilters is a helper method to define mock.On call +// - ctx context.Context +// - URI archiver.URI +// - fileNamePrefix string +// - pageSize int +// - offset int +// - filters []connector.Precondition +func (_e *Client_Expecter) QueryWithFilters(ctx interface{}, URI interface{}, fileNamePrefix interface{}, pageSize interface{}, offset interface{}, filters interface{}) *Client_QueryWithFilters_Call { + return &Client_QueryWithFilters_Call{Call: _e.mock.On("QueryWithFilters", ctx, URI, fileNamePrefix, pageSize, offset, filters)} +} + +func (_c *Client_QueryWithFilters_Call) Run(run func(ctx context.Context, URI archiver.URI, fileNamePrefix string, pageSize int, offset int, filters []connector.Precondition)) *Client_QueryWithFilters_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 archiver.URI + if args[1] != nil { + arg1 = args[1].(archiver.URI) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 int + if args[3] != nil { + arg3 = args[3].(int) + } + var arg4 int + if args[4] != nil { + arg4 = args[4].(int) + } + var arg5 []connector.Precondition + if args[5] != nil { + arg5 = args[5].([]connector.Precondition) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + arg5, + ) + }) + return _c +} + +func (_c *Client_QueryWithFilters_Call) Return(strings []string, b bool, n int, err error) *Client_QueryWithFilters_Call { + _c.Call.Return(strings, b, n, err) + return _c +} + +func (_c *Client_QueryWithFilters_Call) RunAndReturn(run func(ctx context.Context, URI archiver.URI, fileNamePrefix string, pageSize int, offset int, filters []connector.Precondition) ([]string, bool, int, error)) *Client_QueryWithFilters_Call { + _c.Call.Return(run) + return _c +} + +// Upload provides a mock function for the type Client +func (_mock *Client) Upload(ctx context.Context, URI archiver.URI, fileName string, file []byte) error { + ret := _mock.Called(ctx, URI, fileName, file) + + if len(ret) == 0 { + panic("no return value specified for Upload") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, archiver.URI, string, []byte) error); ok { - r0 = rf(ctx, URI, fileName, file) + if returnFunc, ok := ret.Get(0).(func(context.Context, archiver.URI, string, []byte) error); ok { + r0 = returnFunc(ctx, URI, fileName, file) } else { r0 = ret.Error(0) } - return r0 } + +// Client_Upload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Upload' +type Client_Upload_Call struct { + *mock.Call +} + +// Upload is a helper method to define mock.On call +// - ctx context.Context +// - URI archiver.URI +// - fileName string +// - file []byte +func (_e *Client_Expecter) Upload(ctx interface{}, URI interface{}, fileName interface{}, file interface{}) *Client_Upload_Call { + return &Client_Upload_Call{Call: _e.mock.On("Upload", ctx, URI, fileName, file)} +} + +func (_c *Client_Upload_Call) Run(run func(ctx context.Context, URI archiver.URI, fileName string, file []byte)) *Client_Upload_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 archiver.URI + if args[1] != nil { + arg1 = args[1].(archiver.URI) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 []byte + if args[3] != nil { + arg3 = args[3].([]byte) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *Client_Upload_Call) Return(err error) *Client_Upload_Call { + _c.Call.Return(err) + return _c +} + +func (_c *Client_Upload_Call) RunAndReturn(run func(ctx context.Context, URI archiver.URI, fileName string, file []byte) error) *Client_Upload_Call { + _c.Call.Return(run) + return _c +} diff --git a/common/archiver/gcloud/connector/mocks/GcloudStorageClient.go b/common/archiver/gcloud/connector/mocks/GcloudStorageClient.go index 92e3b47669f..77c7135ca4a 100644 --- a/common/archiver/gcloud/connector/mocks/GcloudStorageClient.go +++ b/common/archiver/gcloud/connector/mocks/GcloudStorageClient.go @@ -1,50 +1,91 @@ -// Copyright (c) 2020 Uber Technologies, Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -// Code generated by mockery v1.0.0. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( mock "github.com/stretchr/testify/mock" - connector "github.com/uber/cadence/common/archiver/gcloud/connector" + "github.com/uber/cadence/common/archiver/gcloud/connector" ) +// NewGcloudStorageClient creates a new instance of GcloudStorageClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewGcloudStorageClient(t interface { + mock.TestingT + Cleanup(func()) +}) *GcloudStorageClient { + mock := &GcloudStorageClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // GcloudStorageClient is an autogenerated mock type for the GcloudStorageClient type type GcloudStorageClient struct { mock.Mock } -// Bucket provides a mock function with given fields: URI -func (_m *GcloudStorageClient) Bucket(URI string) connector.BucketHandleWrapper { - ret := _m.Called(URI) +type GcloudStorageClient_Expecter struct { + mock *mock.Mock +} + +func (_m *GcloudStorageClient) EXPECT() *GcloudStorageClient_Expecter { + return &GcloudStorageClient_Expecter{mock: &_m.Mock} +} + +// Bucket provides a mock function for the type GcloudStorageClient +func (_mock *GcloudStorageClient) Bucket(URI string) connector.BucketHandleWrapper { + ret := _mock.Called(URI) + + if len(ret) == 0 { + panic("no return value specified for Bucket") + } var r0 connector.BucketHandleWrapper - if rf, ok := ret.Get(0).(func(string) connector.BucketHandleWrapper); ok { - r0 = rf(URI) + if returnFunc, ok := ret.Get(0).(func(string) connector.BucketHandleWrapper); ok { + r0 = returnFunc(URI) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(connector.BucketHandleWrapper) } } - return r0 } + +// GcloudStorageClient_Bucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bucket' +type GcloudStorageClient_Bucket_Call struct { + *mock.Call +} + +// Bucket is a helper method to define mock.On call +// - URI string +func (_e *GcloudStorageClient_Expecter) Bucket(URI interface{}) *GcloudStorageClient_Bucket_Call { + return &GcloudStorageClient_Bucket_Call{Call: _e.mock.On("Bucket", URI)} +} + +func (_c *GcloudStorageClient_Bucket_Call) Run(run func(URI string)) *GcloudStorageClient_Bucket_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 string + if args[0] != nil { + arg0 = args[0].(string) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *GcloudStorageClient_Bucket_Call) Return(bucketHandleWrapper connector.BucketHandleWrapper) *GcloudStorageClient_Bucket_Call { + _c.Call.Return(bucketHandleWrapper) + return _c +} + +func (_c *GcloudStorageClient_Bucket_Call) RunAndReturn(run func(URI string) connector.BucketHandleWrapper) *GcloudStorageClient_Bucket_Call { + _c.Call.Return(run) + return _c +} diff --git a/common/archiver/gcloud/connector/mocks/ObjectHandleWrapper.go b/common/archiver/gcloud/connector/mocks/ObjectHandleWrapper.go index 965545ee85d..d3f61ecfeea 100644 --- a/common/archiver/gcloud/connector/mocks/ObjectHandleWrapper.go +++ b/common/archiver/gcloud/connector/mocks/ObjectHandleWrapper.go @@ -1,99 +1,218 @@ -// Copyright (c) 2020 Uber Technologies, Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -// Code generated by mockery v1.0.0. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - context "context" + "context" - storage "cloud.google.com/go/storage" + "cloud.google.com/go/storage" mock "github.com/stretchr/testify/mock" - connector "github.com/uber/cadence/common/archiver/gcloud/connector" + "github.com/uber/cadence/common/archiver/gcloud/connector" ) +// NewObjectHandleWrapper creates a new instance of ObjectHandleWrapper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewObjectHandleWrapper(t interface { + mock.TestingT + Cleanup(func()) +}) *ObjectHandleWrapper { + mock := &ObjectHandleWrapper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // ObjectHandleWrapper is an autogenerated mock type for the ObjectHandleWrapper type type ObjectHandleWrapper struct { mock.Mock } -// Attrs provides a mock function with given fields: ctx -func (_m *ObjectHandleWrapper) Attrs(ctx context.Context) (*storage.ObjectAttrs, error) { - ret := _m.Called(ctx) +type ObjectHandleWrapper_Expecter struct { + mock *mock.Mock +} + +func (_m *ObjectHandleWrapper) EXPECT() *ObjectHandleWrapper_Expecter { + return &ObjectHandleWrapper_Expecter{mock: &_m.Mock} +} + +// Attrs provides a mock function for the type ObjectHandleWrapper +func (_mock *ObjectHandleWrapper) Attrs(ctx context.Context) (*storage.ObjectAttrs, error) { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Attrs") + } var r0 *storage.ObjectAttrs - if rf, ok := ret.Get(0).(func(context.Context) *storage.ObjectAttrs); ok { - r0 = rf(ctx) + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context) (*storage.ObjectAttrs, error)); ok { + return returnFunc(ctx) + } + if returnFunc, ok := ret.Get(0).(func(context.Context) *storage.ObjectAttrs); ok { + r0 = returnFunc(ctx) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*storage.ObjectAttrs) } } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context) error); ok { - r1 = rf(ctx) + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) } else { r1 = ret.Error(1) } - return r0, r1 } -// NewReader provides a mock function with given fields: ctx -func (_m *ObjectHandleWrapper) NewReader(ctx context.Context) (connector.ReaderWrapper, error) { - ret := _m.Called(ctx) +// ObjectHandleWrapper_Attrs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Attrs' +type ObjectHandleWrapper_Attrs_Call struct { + *mock.Call +} + +// Attrs is a helper method to define mock.On call +// - ctx context.Context +func (_e *ObjectHandleWrapper_Expecter) Attrs(ctx interface{}) *ObjectHandleWrapper_Attrs_Call { + return &ObjectHandleWrapper_Attrs_Call{Call: _e.mock.On("Attrs", ctx)} +} + +func (_c *ObjectHandleWrapper_Attrs_Call) Run(run func(ctx context.Context)) *ObjectHandleWrapper_Attrs_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *ObjectHandleWrapper_Attrs_Call) Return(objectAttrs *storage.ObjectAttrs, err error) *ObjectHandleWrapper_Attrs_Call { + _c.Call.Return(objectAttrs, err) + return _c +} + +func (_c *ObjectHandleWrapper_Attrs_Call) RunAndReturn(run func(ctx context.Context) (*storage.ObjectAttrs, error)) *ObjectHandleWrapper_Attrs_Call { + _c.Call.Return(run) + return _c +} + +// NewReader provides a mock function for the type ObjectHandleWrapper +func (_mock *ObjectHandleWrapper) NewReader(ctx context.Context) (connector.ReaderWrapper, error) { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for NewReader") + } var r0 connector.ReaderWrapper - if rf, ok := ret.Get(0).(func(context.Context) connector.ReaderWrapper); ok { - r0 = rf(ctx) + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context) (connector.ReaderWrapper, error)); ok { + return returnFunc(ctx) + } + if returnFunc, ok := ret.Get(0).(func(context.Context) connector.ReaderWrapper); ok { + r0 = returnFunc(ctx) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(connector.ReaderWrapper) } } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context) error); ok { - r1 = rf(ctx) + if returnFunc, ok := ret.Get(1).(func(context.Context) error); ok { + r1 = returnFunc(ctx) } else { r1 = ret.Error(1) } - return r0, r1 } -// NewWriter provides a mock function with given fields: ctx -func (_m *ObjectHandleWrapper) NewWriter(ctx context.Context) connector.WriterWrapper { - ret := _m.Called(ctx) +// ObjectHandleWrapper_NewReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewReader' +type ObjectHandleWrapper_NewReader_Call struct { + *mock.Call +} + +// NewReader is a helper method to define mock.On call +// - ctx context.Context +func (_e *ObjectHandleWrapper_Expecter) NewReader(ctx interface{}) *ObjectHandleWrapper_NewReader_Call { + return &ObjectHandleWrapper_NewReader_Call{Call: _e.mock.On("NewReader", ctx)} +} + +func (_c *ObjectHandleWrapper_NewReader_Call) Run(run func(ctx context.Context)) *ObjectHandleWrapper_NewReader_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *ObjectHandleWrapper_NewReader_Call) Return(readerWrapper connector.ReaderWrapper, err error) *ObjectHandleWrapper_NewReader_Call { + _c.Call.Return(readerWrapper, err) + return _c +} + +func (_c *ObjectHandleWrapper_NewReader_Call) RunAndReturn(run func(ctx context.Context) (connector.ReaderWrapper, error)) *ObjectHandleWrapper_NewReader_Call { + _c.Call.Return(run) + return _c +} + +// NewWriter provides a mock function for the type ObjectHandleWrapper +func (_mock *ObjectHandleWrapper) NewWriter(ctx context.Context) connector.WriterWrapper { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for NewWriter") + } var r0 connector.WriterWrapper - if rf, ok := ret.Get(0).(func(context.Context) connector.WriterWrapper); ok { - r0 = rf(ctx) + if returnFunc, ok := ret.Get(0).(func(context.Context) connector.WriterWrapper); ok { + r0 = returnFunc(ctx) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(connector.WriterWrapper) } } - return r0 } + +// ObjectHandleWrapper_NewWriter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NewWriter' +type ObjectHandleWrapper_NewWriter_Call struct { + *mock.Call +} + +// NewWriter is a helper method to define mock.On call +// - ctx context.Context +func (_e *ObjectHandleWrapper_Expecter) NewWriter(ctx interface{}) *ObjectHandleWrapper_NewWriter_Call { + return &ObjectHandleWrapper_NewWriter_Call{Call: _e.mock.On("NewWriter", ctx)} +} + +func (_c *ObjectHandleWrapper_NewWriter_Call) Run(run func(ctx context.Context)) *ObjectHandleWrapper_NewWriter_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *ObjectHandleWrapper_NewWriter_Call) Return(writerWrapper connector.WriterWrapper) *ObjectHandleWrapper_NewWriter_Call { + _c.Call.Return(writerWrapper) + return _c +} + +func (_c *ObjectHandleWrapper_NewWriter_Call) RunAndReturn(run func(ctx context.Context) connector.WriterWrapper) *ObjectHandleWrapper_NewWriter_Call { + _c.Call.Return(run) + return _c +} diff --git a/common/archiver/gcloud/connector/mocks/ObjectIteratorWrapper.go b/common/archiver/gcloud/connector/mocks/ObjectIteratorWrapper.go index 3004d206e1b..f5e75f27519 100644 --- a/common/archiver/gcloud/connector/mocks/ObjectIteratorWrapper.go +++ b/common/archiver/gcloud/connector/mocks/ObjectIteratorWrapper.go @@ -1,56 +1,92 @@ -// Copyright (c) 2020 Uber Technologies, Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -// Code generated by mockery v1.0.0. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - storage "cloud.google.com/go/storage" + "cloud.google.com/go/storage" mock "github.com/stretchr/testify/mock" ) +// NewObjectIteratorWrapper creates a new instance of ObjectIteratorWrapper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewObjectIteratorWrapper(t interface { + mock.TestingT + Cleanup(func()) +}) *ObjectIteratorWrapper { + mock := &ObjectIteratorWrapper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // ObjectIteratorWrapper is an autogenerated mock type for the ObjectIteratorWrapper type type ObjectIteratorWrapper struct { mock.Mock } -// Next provides a mock function with given fields: -func (_m *ObjectIteratorWrapper) Next() (*storage.ObjectAttrs, error) { - ret := _m.Called() +type ObjectIteratorWrapper_Expecter struct { + mock *mock.Mock +} + +func (_m *ObjectIteratorWrapper) EXPECT() *ObjectIteratorWrapper_Expecter { + return &ObjectIteratorWrapper_Expecter{mock: &_m.Mock} +} + +// Next provides a mock function for the type ObjectIteratorWrapper +func (_mock *ObjectIteratorWrapper) Next() (*storage.ObjectAttrs, error) { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Next") + } var r0 *storage.ObjectAttrs - if rf, ok := ret.Get(0).(func() *storage.ObjectAttrs); ok { - r0 = rf() + var r1 error + if returnFunc, ok := ret.Get(0).(func() (*storage.ObjectAttrs, error)); ok { + return returnFunc() + } + if returnFunc, ok := ret.Get(0).(func() *storage.ObjectAttrs); ok { + r0 = returnFunc() } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*storage.ObjectAttrs) } } - - var r1 error - if rf, ok := ret.Get(1).(func() error); ok { - r1 = rf() + if returnFunc, ok := ret.Get(1).(func() error); ok { + r1 = returnFunc() } else { r1 = ret.Error(1) } - return r0, r1 } + +// ObjectIteratorWrapper_Next_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Next' +type ObjectIteratorWrapper_Next_Call struct { + *mock.Call +} + +// Next is a helper method to define mock.On call +func (_e *ObjectIteratorWrapper_Expecter) Next() *ObjectIteratorWrapper_Next_Call { + return &ObjectIteratorWrapper_Next_Call{Call: _e.mock.On("Next")} +} + +func (_c *ObjectIteratorWrapper_Next_Call) Run(run func()) *ObjectIteratorWrapper_Next_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ObjectIteratorWrapper_Next_Call) Return(objectAttrs *storage.ObjectAttrs, err error) *ObjectIteratorWrapper_Next_Call { + _c.Call.Return(objectAttrs, err) + return _c +} + +func (_c *ObjectIteratorWrapper_Next_Call) RunAndReturn(run func() (*storage.ObjectAttrs, error)) *ObjectIteratorWrapper_Next_Call { + _c.Call.Return(run) + return _c +} diff --git a/common/archiver/gcloud/connector/mocks/ReaderWrapper.go b/common/archiver/gcloud/connector/mocks/ReaderWrapper.go index 9c7f92d7073..b25a12d54b4 100644 --- a/common/archiver/gcloud/connector/mocks/ReaderWrapper.go +++ b/common/archiver/gcloud/connector/mocks/ReaderWrapper.go @@ -1,65 +1,140 @@ -// Copyright (c) 2020 Uber Technologies, Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -// Code generated by mockery v1.0.0. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks -import mock "github.com/stretchr/testify/mock" +import ( + mock "github.com/stretchr/testify/mock" +) + +// NewReaderWrapper creates a new instance of ReaderWrapper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewReaderWrapper(t interface { + mock.TestingT + Cleanup(func()) +}) *ReaderWrapper { + mock := &ReaderWrapper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} // ReaderWrapper is an autogenerated mock type for the ReaderWrapper type type ReaderWrapper struct { mock.Mock } -// Close provides a mock function with given fields: -func (_m *ReaderWrapper) Close() error { - ret := _m.Called() +type ReaderWrapper_Expecter struct { + mock *mock.Mock +} + +func (_m *ReaderWrapper) EXPECT() *ReaderWrapper_Expecter { + return &ReaderWrapper_Expecter{mock: &_m.Mock} +} + +// Close provides a mock function for the type ReaderWrapper +func (_mock *ReaderWrapper) Close() error { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Close") + } var r0 error - if rf, ok := ret.Get(0).(func() error); ok { - r0 = rf() + if returnFunc, ok := ret.Get(0).(func() error); ok { + r0 = returnFunc() } else { r0 = ret.Error(0) } - return r0 } -// Read provides a mock function with given fields: p -func (_m *ReaderWrapper) Read(p []byte) (int, error) { - ret := _m.Called(p) +// ReaderWrapper_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type ReaderWrapper_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *ReaderWrapper_Expecter) Close() *ReaderWrapper_Close_Call { + return &ReaderWrapper_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *ReaderWrapper_Close_Call) Run(run func()) *ReaderWrapper_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ReaderWrapper_Close_Call) Return(err error) *ReaderWrapper_Close_Call { + _c.Call.Return(err) + return _c +} + +func (_c *ReaderWrapper_Close_Call) RunAndReturn(run func() error) *ReaderWrapper_Close_Call { + _c.Call.Return(run) + return _c +} + +// Read provides a mock function for the type ReaderWrapper +func (_mock *ReaderWrapper) Read(p []byte) (int, error) { + ret := _mock.Called(p) + + if len(ret) == 0 { + panic("no return value specified for Read") + } var r0 int - if rf, ok := ret.Get(0).(func([]byte) int); ok { - r0 = rf(p) + var r1 error + if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok { + return returnFunc(p) + } + if returnFunc, ok := ret.Get(0).(func([]byte) int); ok { + r0 = returnFunc(p) } else { r0 = ret.Get(0).(int) } - - var r1 error - if rf, ok := ret.Get(1).(func([]byte) error); ok { - r1 = rf(p) + if returnFunc, ok := ret.Get(1).(func([]byte) error); ok { + r1 = returnFunc(p) } else { r1 = ret.Error(1) } - return r0, r1 } + +// ReaderWrapper_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' +type ReaderWrapper_Read_Call struct { + *mock.Call +} + +// Read is a helper method to define mock.On call +// - p []byte +func (_e *ReaderWrapper_Expecter) Read(p interface{}) *ReaderWrapper_Read_Call { + return &ReaderWrapper_Read_Call{Call: _e.mock.On("Read", p)} +} + +func (_c *ReaderWrapper_Read_Call) Run(run func(p []byte)) *ReaderWrapper_Read_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 []byte + if args[0] != nil { + arg0 = args[0].([]byte) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *ReaderWrapper_Read_Call) Return(n int, err error) *ReaderWrapper_Read_Call { + _c.Call.Return(n, err) + return _c +} + +func (_c *ReaderWrapper_Read_Call) RunAndReturn(run func(p []byte) (int, error)) *ReaderWrapper_Read_Call { + _c.Call.Return(run) + return _c +} diff --git a/common/archiver/gcloud/connector/mocks/WriterWrapper.go b/common/archiver/gcloud/connector/mocks/WriterWrapper.go index e92b1a3844a..41c3d58d52b 100644 --- a/common/archiver/gcloud/connector/mocks/WriterWrapper.go +++ b/common/archiver/gcloud/connector/mocks/WriterWrapper.go @@ -1,79 +1,191 @@ -// Copyright (c) 2020 Uber Technologies, Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -// Code generated by mockery v1.0.0. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks -import mock "github.com/stretchr/testify/mock" +import ( + mock "github.com/stretchr/testify/mock" +) + +// NewWriterWrapper creates a new instance of WriterWrapper. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewWriterWrapper(t interface { + mock.TestingT + Cleanup(func()) +}) *WriterWrapper { + mock := &WriterWrapper{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} // WriterWrapper is an autogenerated mock type for the WriterWrapper type type WriterWrapper struct { mock.Mock } -// Close provides a mock function with given fields: -func (_m *WriterWrapper) Close() error { - ret := _m.Called() +type WriterWrapper_Expecter struct { + mock *mock.Mock +} + +func (_m *WriterWrapper) EXPECT() *WriterWrapper_Expecter { + return &WriterWrapper_Expecter{mock: &_m.Mock} +} + +// Close provides a mock function for the type WriterWrapper +func (_mock *WriterWrapper) Close() error { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Close") + } var r0 error - if rf, ok := ret.Get(0).(func() error); ok { - r0 = rf() + if returnFunc, ok := ret.Get(0).(func() error); ok { + r0 = returnFunc() } else { r0 = ret.Error(0) } - return r0 } -// CloseWithError provides a mock function with given fields: err -func (_m *WriterWrapper) CloseWithError(err error) error { - ret := _m.Called(err) +// WriterWrapper_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type WriterWrapper_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *WriterWrapper_Expecter) Close() *WriterWrapper_Close_Call { + return &WriterWrapper_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *WriterWrapper_Close_Call) Run(run func()) *WriterWrapper_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *WriterWrapper_Close_Call) Return(err error) *WriterWrapper_Close_Call { + _c.Call.Return(err) + return _c +} + +func (_c *WriterWrapper_Close_Call) RunAndReturn(run func() error) *WriterWrapper_Close_Call { + _c.Call.Return(run) + return _c +} + +// CloseWithError provides a mock function for the type WriterWrapper +func (_mock *WriterWrapper) CloseWithError(err error) error { + ret := _mock.Called(err) + + if len(ret) == 0 { + panic("no return value specified for CloseWithError") + } var r0 error - if rf, ok := ret.Get(0).(func(error) error); ok { - r0 = rf(err) + if returnFunc, ok := ret.Get(0).(func(error) error); ok { + r0 = returnFunc(err) } else { r0 = ret.Error(0) } - return r0 } -// Write provides a mock function with given fields: p -func (_m *WriterWrapper) Write(p []byte) (int, error) { - ret := _m.Called(p) +// WriterWrapper_CloseWithError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CloseWithError' +type WriterWrapper_CloseWithError_Call struct { + *mock.Call +} + +// CloseWithError is a helper method to define mock.On call +// - err error +func (_e *WriterWrapper_Expecter) CloseWithError(err interface{}) *WriterWrapper_CloseWithError_Call { + return &WriterWrapper_CloseWithError_Call{Call: _e.mock.On("CloseWithError", err)} +} + +func (_c *WriterWrapper_CloseWithError_Call) Run(run func(err error)) *WriterWrapper_CloseWithError_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 error + if args[0] != nil { + arg0 = args[0].(error) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *WriterWrapper_CloseWithError_Call) Return(err1 error) *WriterWrapper_CloseWithError_Call { + _c.Call.Return(err1) + return _c +} + +func (_c *WriterWrapper_CloseWithError_Call) RunAndReturn(run func(err error) error) *WriterWrapper_CloseWithError_Call { + _c.Call.Return(run) + return _c +} + +// Write provides a mock function for the type WriterWrapper +func (_mock *WriterWrapper) Write(p []byte) (int, error) { + ret := _mock.Called(p) + + if len(ret) == 0 { + panic("no return value specified for Write") + } var r0 int - if rf, ok := ret.Get(0).(func([]byte) int); ok { - r0 = rf(p) + var r1 error + if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok { + return returnFunc(p) + } + if returnFunc, ok := ret.Get(0).(func([]byte) int); ok { + r0 = returnFunc(p) } else { r0 = ret.Get(0).(int) } - - var r1 error - if rf, ok := ret.Get(1).(func([]byte) error); ok { - r1 = rf(p) + if returnFunc, ok := ret.Get(1).(func([]byte) error); ok { + r1 = returnFunc(p) } else { r1 = ret.Error(1) } - return r0, r1 } + +// WriterWrapper_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write' +type WriterWrapper_Write_Call struct { + *mock.Call +} + +// Write is a helper method to define mock.On call +// - p []byte +func (_e *WriterWrapper_Expecter) Write(p interface{}) *WriterWrapper_Write_Call { + return &WriterWrapper_Write_Call{Call: _e.mock.On("Write", p)} +} + +func (_c *WriterWrapper_Write_Call) Run(run func(p []byte)) *WriterWrapper_Write_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 []byte + if args[0] != nil { + arg0 = args[0].([]byte) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *WriterWrapper_Write_Call) Return(n int, err error) *WriterWrapper_Write_Call { + _c.Call.Return(n, err) + return _c +} + +func (_c *WriterWrapper_Write_Call) RunAndReturn(run func(p []byte) (int, error)) *WriterWrapper_Write_Call { + _c.Call.Return(run) + return _c +} diff --git a/common/archiver/gcloud/go.mod b/common/archiver/gcloud/go.mod index 9eb2cca1004..b537425c565 100644 --- a/common/archiver/gcloud/go.mod +++ b/common/archiver/gcloud/go.mod @@ -1,8 +1,8 @@ module github.com/uber/cadence/common/archiver/gcloud -go 1.23.0 +go 1.24 -toolchain go1.23.4 +toolchain go1.24.7 // build against the current code in the "main" module, not a specific SHA. // @@ -40,10 +40,10 @@ require ( go.uber.org/thriftrw v1.29.2 // indirect go.uber.org/yarpc v1.70.3 // indirect go.uber.org/zap v1.26.0 // indirect - golang.org/x/net v0.40.0 // indirect - golang.org/x/sync v0.14.0 // indirect + golang.org/x/net v0.43.0 // indirect + golang.org/x/sync v0.16.0 // indirect golang.org/x/time v0.5.0 // indirect - golang.org/x/tools v0.22.0 // indirect + golang.org/x/tools v0.36.0 // indirect google.golang.org/grpc v1.59.0 // indirect gopkg.in/validator.v2 v2.0.0-20180514200540-135c24b11c19 // indirect gopkg.in/yaml.v2 v2.4.0 // indirect @@ -52,7 +52,7 @@ require ( require ( cloud.google.com/go/storage v1.30.1 github.com/uber/cadence v0.0.0-00010101000000-000000000000 - go.uber.org/mock v0.5.0 + go.uber.org/mock v0.6.0 golang.org/x/oauth2 v0.11.0 google.golang.org/api v0.128.0 ) @@ -100,12 +100,12 @@ require ( go.uber.org/dig v1.18.0 // indirect go.uber.org/fx v1.23.0 // indirect go.uber.org/net/metrics v1.3.0 // indirect - golang.org/x/crypto v0.38.0 // indirect + golang.org/x/crypto v0.41.0 // indirect golang.org/x/exp/typeparams v0.0.0-20220218215828-6cf2b201936e // indirect golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 // indirect - golang.org/x/mod v0.18.0 // indirect - golang.org/x/sys v0.33.0 // indirect - golang.org/x/text v0.25.0 // indirect + golang.org/x/mod v0.27.0 // indirect + golang.org/x/sys v0.35.0 // indirect + golang.org/x/text v0.28.0 // indirect golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect google.golang.org/appengine v1.6.7 // indirect google.golang.org/genproto v0.0.0-20231016165738-49dd2c1f3d0b // indirect diff --git a/common/archiver/gcloud/go.sum b/common/archiver/gcloud/go.sum index 6a6a23a5aa2..0e3e3e70877 100644 --- a/common/archiver/gcloud/go.sum +++ b/common/archiver/gcloud/go.sum @@ -327,8 +327,8 @@ go.uber.org/goleak v0.10.0/go.mod h1:VCZuO8V8mFPlL0F5J5GK1rtHV3DrFcQ1R8ryq7FK0aI go.uber.org/goleak v1.0.0/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk= go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo= -go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU= -go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM= +go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= +go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= go.uber.org/multierr v1.4.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= @@ -356,8 +356,8 @@ golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8U golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.0.0-20220314234659-1baeb1ce4c0b/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8= -golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw= +golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4= +golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20231226003508-02704c960a9b h1:kLiC65FbiHWFAOu+lxwNPujcsl8VYyTYYEZnsOO1WK4= golang.org/x/exp v0.0.0-20231226003508-02704c960a9b/go.mod h1:iRJReGqOEeBhDZGkGbynYwcHlctCvnjTYIamk7uXpHI= @@ -377,8 +377,8 @@ golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0= -golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ= +golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -400,8 +400,8 @@ golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96b golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20211112202133-69e39bad7dc2/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= -golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY= -golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds= +golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE= +golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -417,8 +417,8 @@ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ= -golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw= +golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -445,8 +445,8 @@ golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= -golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI= +golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -456,8 +456,8 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= -golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4= -golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA= +golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng= +golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU= golang.org/x/time v0.0.0-20170927054726-6dc17368e09b/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= @@ -487,8 +487,10 @@ golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.11-0.20220513221640-090b14e8501f/go.mod h1:SgwaegtQh8clINPpECJMqnxLv9I09HLqnW3RMqW0CA4= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA= -golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c= +golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg= +golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s= +golang.org/x/tools/go/expect v0.1.1-deprecated h1:jpBZDwmgPhXsKZC6WhL20P4b/wmnpsEAGHaNy0n/rJM= +golang.org/x/tools/go/expect v0.1.1-deprecated/go.mod h1:eihoPOH+FgIqa3FpoTwguz/bVUSGBlGQU67vpBeOrBY= 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= diff --git a/common/archiver/interface_mock.go b/common/archiver/interface_mock.go index f6741127e39..316cadc4cc0 100644 --- a/common/archiver/interface_mock.go +++ b/common/archiver/interface_mock.go @@ -1,155 +1,471 @@ -// Copyright (c) 2017 Uber Technologies, Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -// Code generated by mockery v1.0.0. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package archiver import ( - context "context" + "context" mock "github.com/stretchr/testify/mock" ) +// NewHistoryArchiverMock creates a new instance of HistoryArchiverMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewHistoryArchiverMock(t interface { + mock.TestingT + Cleanup(func()) +}) *HistoryArchiverMock { + mock := &HistoryArchiverMock{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // HistoryArchiverMock is an autogenerated mock type for the HistoryArchiver type type HistoryArchiverMock struct { mock.Mock } -// Archive provides a mock function with given fields: ctx, uri, request, opts -func (_m *HistoryArchiverMock) Archive(ctx context.Context, uri URI, request *ArchiveHistoryRequest, opts ...ArchiveOption) error { - _va := make([]interface{}, len(opts)) - for _i := range opts { - _va[_i] = opts[_i] +type HistoryArchiverMock_Expecter struct { + mock *mock.Mock +} + +func (_m *HistoryArchiverMock) EXPECT() *HistoryArchiverMock_Expecter { + return &HistoryArchiverMock_Expecter{mock: &_m.Mock} +} + +// Archive provides a mock function for the type HistoryArchiverMock +func (_mock *HistoryArchiverMock) Archive(context1 context.Context, uRI URI, archiveHistoryRequest *ArchiveHistoryRequest, archiveOptions ...ArchiveOption) error { + var tmpRet mock.Arguments + if len(archiveOptions) > 0 { + tmpRet = _mock.Called(context1, uRI, archiveHistoryRequest, archiveOptions) + } else { + tmpRet = _mock.Called(context1, uRI, archiveHistoryRequest) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for Archive") } - var _ca []interface{} - _ca = append(_ca, ctx, uri, request) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, URI, *ArchiveHistoryRequest, ...ArchiveOption) error); ok { - r0 = rf(ctx, uri, request, opts...) + if returnFunc, ok := ret.Get(0).(func(context.Context, URI, *ArchiveHistoryRequest, ...ArchiveOption) error); ok { + r0 = returnFunc(context1, uRI, archiveHistoryRequest, archiveOptions...) } else { r0 = ret.Error(0) } - return r0 } -// Get provides a mock function with given fields: ctx, uri, request -func (_m *HistoryArchiverMock) Get(ctx context.Context, uri URI, request *GetHistoryRequest) (*GetHistoryResponse, error) { - ret := _m.Called(ctx, uri, request) +// HistoryArchiverMock_Archive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Archive' +type HistoryArchiverMock_Archive_Call struct { + *mock.Call +} + +// Archive is a helper method to define mock.On call +// - context1 context.Context +// - uRI URI +// - archiveHistoryRequest *ArchiveHistoryRequest +// - archiveOptions ...ArchiveOption +func (_e *HistoryArchiverMock_Expecter) Archive(context1 interface{}, uRI interface{}, archiveHistoryRequest interface{}, archiveOptions ...interface{}) *HistoryArchiverMock_Archive_Call { + return &HistoryArchiverMock_Archive_Call{Call: _e.mock.On("Archive", + append([]interface{}{context1, uRI, archiveHistoryRequest}, archiveOptions...)...)} +} + +func (_c *HistoryArchiverMock_Archive_Call) Run(run func(context1 context.Context, uRI URI, archiveHistoryRequest *ArchiveHistoryRequest, archiveOptions ...ArchiveOption)) *HistoryArchiverMock_Archive_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 URI + if args[1] != nil { + arg1 = args[1].(URI) + } + var arg2 *ArchiveHistoryRequest + if args[2] != nil { + arg2 = args[2].(*ArchiveHistoryRequest) + } + var arg3 []ArchiveOption + var variadicArgs []ArchiveOption + if len(args) > 3 { + variadicArgs = args[3].([]ArchiveOption) + } + arg3 = variadicArgs + run( + arg0, + arg1, + arg2, + arg3..., + ) + }) + return _c +} + +func (_c *HistoryArchiverMock_Archive_Call) Return(err error) *HistoryArchiverMock_Archive_Call { + _c.Call.Return(err) + return _c +} + +func (_c *HistoryArchiverMock_Archive_Call) RunAndReturn(run func(context1 context.Context, uRI URI, archiveHistoryRequest *ArchiveHistoryRequest, archiveOptions ...ArchiveOption) error) *HistoryArchiverMock_Archive_Call { + _c.Call.Return(run) + return _c +} + +// Get provides a mock function for the type HistoryArchiverMock +func (_mock *HistoryArchiverMock) Get(context1 context.Context, uRI URI, getHistoryRequest *GetHistoryRequest) (*GetHistoryResponse, error) { + ret := _mock.Called(context1, uRI, getHistoryRequest) + + if len(ret) == 0 { + panic("no return value specified for Get") + } var r0 *GetHistoryResponse - if rf, ok := ret.Get(0).(func(context.Context, URI, *GetHistoryRequest) *GetHistoryResponse); ok { - r0 = rf(ctx, uri, request) + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, URI, *GetHistoryRequest) (*GetHistoryResponse, error)); ok { + return returnFunc(context1, uRI, getHistoryRequest) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, URI, *GetHistoryRequest) *GetHistoryResponse); ok { + r0 = returnFunc(context1, uRI, getHistoryRequest) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*GetHistoryResponse) } } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, URI, *GetHistoryRequest) error); ok { - r1 = rf(ctx, uri, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, URI, *GetHistoryRequest) error); ok { + r1 = returnFunc(context1, uRI, getHistoryRequest) } else { r1 = ret.Error(1) } - return r0, r1 } -// ValidateURI provides a mock function with given fields: uri -func (_m *HistoryArchiverMock) ValidateURI(uri URI) error { - ret := _m.Called(uri) +// HistoryArchiverMock_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type HistoryArchiverMock_Get_Call struct { + *mock.Call +} + +// Get is a helper method to define mock.On call +// - context1 context.Context +// - uRI URI +// - getHistoryRequest *GetHistoryRequest +func (_e *HistoryArchiverMock_Expecter) Get(context1 interface{}, uRI interface{}, getHistoryRequest interface{}) *HistoryArchiverMock_Get_Call { + return &HistoryArchiverMock_Get_Call{Call: _e.mock.On("Get", context1, uRI, getHistoryRequest)} +} + +func (_c *HistoryArchiverMock_Get_Call) Run(run func(context1 context.Context, uRI URI, getHistoryRequest *GetHistoryRequest)) *HistoryArchiverMock_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 URI + if args[1] != nil { + arg1 = args[1].(URI) + } + var arg2 *GetHistoryRequest + if args[2] != nil { + arg2 = args[2].(*GetHistoryRequest) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *HistoryArchiverMock_Get_Call) Return(getHistoryResponse *GetHistoryResponse, err error) *HistoryArchiverMock_Get_Call { + _c.Call.Return(getHistoryResponse, err) + return _c +} + +func (_c *HistoryArchiverMock_Get_Call) RunAndReturn(run func(context1 context.Context, uRI URI, getHistoryRequest *GetHistoryRequest) (*GetHistoryResponse, error)) *HistoryArchiverMock_Get_Call { + _c.Call.Return(run) + return _c +} + +// ValidateURI provides a mock function for the type HistoryArchiverMock +func (_mock *HistoryArchiverMock) ValidateURI(uRI URI) error { + ret := _mock.Called(uRI) + + if len(ret) == 0 { + panic("no return value specified for ValidateURI") + } var r0 error - if rf, ok := ret.Get(0).(func(URI) error); ok { - r0 = rf(uri) + if returnFunc, ok := ret.Get(0).(func(URI) error); ok { + r0 = returnFunc(uRI) } else { r0 = ret.Error(0) } - return r0 } +// HistoryArchiverMock_ValidateURI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateURI' +type HistoryArchiverMock_ValidateURI_Call struct { + *mock.Call +} + +// ValidateURI is a helper method to define mock.On call +// - uRI URI +func (_e *HistoryArchiverMock_Expecter) ValidateURI(uRI interface{}) *HistoryArchiverMock_ValidateURI_Call { + return &HistoryArchiverMock_ValidateURI_Call{Call: _e.mock.On("ValidateURI", uRI)} +} + +func (_c *HistoryArchiverMock_ValidateURI_Call) Run(run func(uRI URI)) *HistoryArchiverMock_ValidateURI_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 URI + if args[0] != nil { + arg0 = args[0].(URI) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *HistoryArchiverMock_ValidateURI_Call) Return(err error) *HistoryArchiverMock_ValidateURI_Call { + _c.Call.Return(err) + return _c +} + +func (_c *HistoryArchiverMock_ValidateURI_Call) RunAndReturn(run func(uRI URI) error) *HistoryArchiverMock_ValidateURI_Call { + _c.Call.Return(run) + return _c +} + +// NewVisibilityArchiverMock creates a new instance of VisibilityArchiverMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewVisibilityArchiverMock(t interface { + mock.TestingT + Cleanup(func()) +}) *VisibilityArchiverMock { + mock := &VisibilityArchiverMock{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // VisibilityArchiverMock is an autogenerated mock type for the VisibilityArchiver type type VisibilityArchiverMock struct { mock.Mock } -// Archive provides a mock function with given fields: _a0, _a1, _a2, _a3 -func (_m *VisibilityArchiverMock) Archive(_a0 context.Context, _a1 URI, _a2 *ArchiveVisibilityRequest, _a3 ...ArchiveOption) error { - _va := make([]interface{}, len(_a3)) - for _i := range _a3 { - _va[_i] = _a3[_i] +type VisibilityArchiverMock_Expecter struct { + mock *mock.Mock +} + +func (_m *VisibilityArchiverMock) EXPECT() *VisibilityArchiverMock_Expecter { + return &VisibilityArchiverMock_Expecter{mock: &_m.Mock} +} + +// Archive provides a mock function for the type VisibilityArchiverMock +func (_mock *VisibilityArchiverMock) Archive(context1 context.Context, uRI URI, archiveVisibilityRequest *ArchiveVisibilityRequest, archiveOptions ...ArchiveOption) error { + var tmpRet mock.Arguments + if len(archiveOptions) > 0 { + tmpRet = _mock.Called(context1, uRI, archiveVisibilityRequest, archiveOptions) + } else { + tmpRet = _mock.Called(context1, uRI, archiveVisibilityRequest) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for Archive") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1, _a2) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, URI, *ArchiveVisibilityRequest, ...ArchiveOption) error); ok { - r0 = rf(_a0, _a1, _a2, _a3...) + if returnFunc, ok := ret.Get(0).(func(context.Context, URI, *ArchiveVisibilityRequest, ...ArchiveOption) error); ok { + r0 = returnFunc(context1, uRI, archiveVisibilityRequest, archiveOptions...) } else { r0 = ret.Error(0) } - return r0 } -// Query provides a mock function with given fields: _a0, _a1, _a2 -func (_m *VisibilityArchiverMock) Query(_a0 context.Context, _a1 URI, _a2 *QueryVisibilityRequest) (*QueryVisibilityResponse, error) { - ret := _m.Called(_a0, _a1, _a2) +// VisibilityArchiverMock_Archive_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Archive' +type VisibilityArchiverMock_Archive_Call struct { + *mock.Call +} + +// Archive is a helper method to define mock.On call +// - context1 context.Context +// - uRI URI +// - archiveVisibilityRequest *ArchiveVisibilityRequest +// - archiveOptions ...ArchiveOption +func (_e *VisibilityArchiverMock_Expecter) Archive(context1 interface{}, uRI interface{}, archiveVisibilityRequest interface{}, archiveOptions ...interface{}) *VisibilityArchiverMock_Archive_Call { + return &VisibilityArchiverMock_Archive_Call{Call: _e.mock.On("Archive", + append([]interface{}{context1, uRI, archiveVisibilityRequest}, archiveOptions...)...)} +} + +func (_c *VisibilityArchiverMock_Archive_Call) Run(run func(context1 context.Context, uRI URI, archiveVisibilityRequest *ArchiveVisibilityRequest, archiveOptions ...ArchiveOption)) *VisibilityArchiverMock_Archive_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 URI + if args[1] != nil { + arg1 = args[1].(URI) + } + var arg2 *ArchiveVisibilityRequest + if args[2] != nil { + arg2 = args[2].(*ArchiveVisibilityRequest) + } + var arg3 []ArchiveOption + var variadicArgs []ArchiveOption + if len(args) > 3 { + variadicArgs = args[3].([]ArchiveOption) + } + arg3 = variadicArgs + run( + arg0, + arg1, + arg2, + arg3..., + ) + }) + return _c +} + +func (_c *VisibilityArchiverMock_Archive_Call) Return(err error) *VisibilityArchiverMock_Archive_Call { + _c.Call.Return(err) + return _c +} + +func (_c *VisibilityArchiverMock_Archive_Call) RunAndReturn(run func(context1 context.Context, uRI URI, archiveVisibilityRequest *ArchiveVisibilityRequest, archiveOptions ...ArchiveOption) error) *VisibilityArchiverMock_Archive_Call { + _c.Call.Return(run) + return _c +} + +// Query provides a mock function for the type VisibilityArchiverMock +func (_mock *VisibilityArchiverMock) Query(context1 context.Context, uRI URI, queryVisibilityRequest *QueryVisibilityRequest) (*QueryVisibilityResponse, error) { + ret := _mock.Called(context1, uRI, queryVisibilityRequest) + + if len(ret) == 0 { + panic("no return value specified for Query") + } var r0 *QueryVisibilityResponse - if rf, ok := ret.Get(0).(func(context.Context, URI, *QueryVisibilityRequest) *QueryVisibilityResponse); ok { - r0 = rf(_a0, _a1, _a2) + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, URI, *QueryVisibilityRequest) (*QueryVisibilityResponse, error)); ok { + return returnFunc(context1, uRI, queryVisibilityRequest) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, URI, *QueryVisibilityRequest) *QueryVisibilityResponse); ok { + r0 = returnFunc(context1, uRI, queryVisibilityRequest) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*QueryVisibilityResponse) } } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, URI, *QueryVisibilityRequest) error); ok { - r1 = rf(_a0, _a1, _a2) + if returnFunc, ok := ret.Get(1).(func(context.Context, URI, *QueryVisibilityRequest) error); ok { + r1 = returnFunc(context1, uRI, queryVisibilityRequest) } else { r1 = ret.Error(1) } - return r0, r1 } -// ValidateURI provides a mock function with given fields: uri -func (_m *VisibilityArchiverMock) ValidateURI(uri URI) error { - ret := _m.Called(uri) +// VisibilityArchiverMock_Query_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Query' +type VisibilityArchiverMock_Query_Call struct { + *mock.Call +} + +// Query is a helper method to define mock.On call +// - context1 context.Context +// - uRI URI +// - queryVisibilityRequest *QueryVisibilityRequest +func (_e *VisibilityArchiverMock_Expecter) Query(context1 interface{}, uRI interface{}, queryVisibilityRequest interface{}) *VisibilityArchiverMock_Query_Call { + return &VisibilityArchiverMock_Query_Call{Call: _e.mock.On("Query", context1, uRI, queryVisibilityRequest)} +} + +func (_c *VisibilityArchiverMock_Query_Call) Run(run func(context1 context.Context, uRI URI, queryVisibilityRequest *QueryVisibilityRequest)) *VisibilityArchiverMock_Query_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 URI + if args[1] != nil { + arg1 = args[1].(URI) + } + var arg2 *QueryVisibilityRequest + if args[2] != nil { + arg2 = args[2].(*QueryVisibilityRequest) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *VisibilityArchiverMock_Query_Call) Return(queryVisibilityResponse *QueryVisibilityResponse, err error) *VisibilityArchiverMock_Query_Call { + _c.Call.Return(queryVisibilityResponse, err) + return _c +} + +func (_c *VisibilityArchiverMock_Query_Call) RunAndReturn(run func(context1 context.Context, uRI URI, queryVisibilityRequest *QueryVisibilityRequest) (*QueryVisibilityResponse, error)) *VisibilityArchiverMock_Query_Call { + _c.Call.Return(run) + return _c +} + +// ValidateURI provides a mock function for the type VisibilityArchiverMock +func (_mock *VisibilityArchiverMock) ValidateURI(uRI URI) error { + ret := _mock.Called(uRI) + + if len(ret) == 0 { + panic("no return value specified for ValidateURI") + } var r0 error - if rf, ok := ret.Get(0).(func(URI) error); ok { - r0 = rf(uri) + if returnFunc, ok := ret.Get(0).(func(URI) error); ok { + r0 = returnFunc(uRI) } else { r0 = ret.Error(0) } - return r0 } + +// VisibilityArchiverMock_ValidateURI_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ValidateURI' +type VisibilityArchiverMock_ValidateURI_Call struct { + *mock.Call +} + +// ValidateURI is a helper method to define mock.On call +// - uRI URI +func (_e *VisibilityArchiverMock_Expecter) ValidateURI(uRI interface{}) *VisibilityArchiverMock_ValidateURI_Call { + return &VisibilityArchiverMock_ValidateURI_Call{Call: _e.mock.On("ValidateURI", uRI)} +} + +func (_c *VisibilityArchiverMock_ValidateURI_Call) Run(run func(uRI URI)) *VisibilityArchiverMock_ValidateURI_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 URI + if args[0] != nil { + arg0 = args[0].(URI) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *VisibilityArchiverMock_ValidateURI_Call) Return(err error) *VisibilityArchiverMock_ValidateURI_Call { + _c.Call.Return(err) + return _c +} + +func (_c *VisibilityArchiverMock_ValidateURI_Call) RunAndReturn(run func(uRI URI) error) *VisibilityArchiverMock_ValidateURI_Call { + _c.Call.Return(run) + return _c +} diff --git a/common/archiver/s3store/mocks/S3API_generate.go b/common/archiver/s3store/mocks/S3API_generate.go deleted file mode 100644 index ce9ff8b4262..00000000000 --- a/common/archiver/s3store/mocks/S3API_generate.go +++ /dev/null @@ -1,25 +0,0 @@ -// The MIT License (MIT) - -// Copyright (c) 2017-2020 Uber Technologies Inc. - -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. - -package mocks - -//go:generate mockery --srcpkg github.com/aws/aws-sdk-go/service/s3/s3iface --quiet --name S3API --output . --filename s3_api_mock.go diff --git a/common/archiver/s3store/mocks/s3_api_mock.go b/common/archiver/s3store/mocks/s3_api_mock.go index 417d90a22b0..52d5fbf8c03 100644 --- a/common/archiver/s3store/mocks/s3_api_mock.go +++ b/common/archiver/s3store/mocks/s3_api_mock.go @@ -1,8993 +1,22032 @@ -// Code generated by mockery v2.32.0. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - context "context" - - request "github.com/aws/aws-sdk-go/aws/request" - s3 "github.com/aws/aws-sdk-go/service/s3" + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/request" + "github.com/aws/aws-sdk-go/service/s3" mock "github.com/stretchr/testify/mock" ) +// NewS3API creates a new instance of S3API. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewS3API(t interface { + mock.TestingT + Cleanup(func()) +}) *S3API { + mock := &S3API{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // S3API is an autogenerated mock type for the S3API type type S3API struct { mock.Mock } -// AbortMultipartUpload provides a mock function with given fields: _a0 -func (_m *S3API) AbortMultipartUpload(_a0 *s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error) { - ret := _m.Called(_a0) +type S3API_Expecter struct { + mock *mock.Mock +} + +func (_m *S3API) EXPECT() *S3API_Expecter { + return &S3API_Expecter{mock: &_m.Mock} +} + +// AbortMultipartUpload provides a mock function for the type S3API +func (_mock *S3API) AbortMultipartUpload(abortMultipartUploadInput *s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error) { + ret := _mock.Called(abortMultipartUploadInput) + + if len(ret) == 0 { + panic("no return value specified for AbortMultipartUpload") + } var r0 *s3.AbortMultipartUploadOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error)); ok { + return returnFunc(abortMultipartUploadInput) } - if rf, ok := ret.Get(0).(func(*s3.AbortMultipartUploadInput) *s3.AbortMultipartUploadOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.AbortMultipartUploadInput) *s3.AbortMultipartUploadOutput); ok { + r0 = returnFunc(abortMultipartUploadInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.AbortMultipartUploadOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.AbortMultipartUploadInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.AbortMultipartUploadInput) error); ok { + r1 = returnFunc(abortMultipartUploadInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// AbortMultipartUploadRequest provides a mock function with given fields: _a0 -func (_m *S3API) AbortMultipartUploadRequest(_a0 *s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput) { - ret := _m.Called(_a0) +// S3API_AbortMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortMultipartUpload' +type S3API_AbortMultipartUpload_Call struct { + *mock.Call +} + +// AbortMultipartUpload is a helper method to define mock.On call +// - abortMultipartUploadInput *s3.AbortMultipartUploadInput +func (_e *S3API_Expecter) AbortMultipartUpload(abortMultipartUploadInput interface{}) *S3API_AbortMultipartUpload_Call { + return &S3API_AbortMultipartUpload_Call{Call: _e.mock.On("AbortMultipartUpload", abortMultipartUploadInput)} +} + +func (_c *S3API_AbortMultipartUpload_Call) Run(run func(abortMultipartUploadInput *s3.AbortMultipartUploadInput)) *S3API_AbortMultipartUpload_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.AbortMultipartUploadInput + if args[0] != nil { + arg0 = args[0].(*s3.AbortMultipartUploadInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_AbortMultipartUpload_Call) Return(abortMultipartUploadOutput *s3.AbortMultipartUploadOutput, err error) *S3API_AbortMultipartUpload_Call { + _c.Call.Return(abortMultipartUploadOutput, err) + return _c +} + +func (_c *S3API_AbortMultipartUpload_Call) RunAndReturn(run func(abortMultipartUploadInput *s3.AbortMultipartUploadInput) (*s3.AbortMultipartUploadOutput, error)) *S3API_AbortMultipartUpload_Call { + _c.Call.Return(run) + return _c +} + +// AbortMultipartUploadRequest provides a mock function for the type S3API +func (_mock *S3API) AbortMultipartUploadRequest(abortMultipartUploadInput *s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput) { + ret := _mock.Called(abortMultipartUploadInput) + + if len(ret) == 0 { + panic("no return value specified for AbortMultipartUploadRequest") + } var r0 *request.Request var r1 *s3.AbortMultipartUploadOutput - if rf, ok := ret.Get(0).(func(*s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput)); ok { + return returnFunc(abortMultipartUploadInput) } - if rf, ok := ret.Get(0).(func(*s3.AbortMultipartUploadInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.AbortMultipartUploadInput) *request.Request); ok { + r0 = returnFunc(abortMultipartUploadInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.AbortMultipartUploadInput) *s3.AbortMultipartUploadOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.AbortMultipartUploadInput) *s3.AbortMultipartUploadOutput); ok { + r1 = returnFunc(abortMultipartUploadInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.AbortMultipartUploadOutput) } } - return r0, r1 } -// AbortMultipartUploadWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) AbortMultipartUploadWithContext(_a0 context.Context, _a1 *s3.AbortMultipartUploadInput, _a2 ...request.Option) (*s3.AbortMultipartUploadOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_AbortMultipartUploadRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortMultipartUploadRequest' +type S3API_AbortMultipartUploadRequest_Call struct { + *mock.Call +} + +// AbortMultipartUploadRequest is a helper method to define mock.On call +// - abortMultipartUploadInput *s3.AbortMultipartUploadInput +func (_e *S3API_Expecter) AbortMultipartUploadRequest(abortMultipartUploadInput interface{}) *S3API_AbortMultipartUploadRequest_Call { + return &S3API_AbortMultipartUploadRequest_Call{Call: _e.mock.On("AbortMultipartUploadRequest", abortMultipartUploadInput)} +} + +func (_c *S3API_AbortMultipartUploadRequest_Call) Run(run func(abortMultipartUploadInput *s3.AbortMultipartUploadInput)) *S3API_AbortMultipartUploadRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.AbortMultipartUploadInput + if args[0] != nil { + arg0 = args[0].(*s3.AbortMultipartUploadInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_AbortMultipartUploadRequest_Call) Return(request1 *request.Request, abortMultipartUploadOutput *s3.AbortMultipartUploadOutput) *S3API_AbortMultipartUploadRequest_Call { + _c.Call.Return(request1, abortMultipartUploadOutput) + return _c +} + +func (_c *S3API_AbortMultipartUploadRequest_Call) RunAndReturn(run func(abortMultipartUploadInput *s3.AbortMultipartUploadInput) (*request.Request, *s3.AbortMultipartUploadOutput)) *S3API_AbortMultipartUploadRequest_Call { + _c.Call.Return(run) + return _c +} + +// AbortMultipartUploadWithContext provides a mock function for the type S3API +func (_mock *S3API) AbortMultipartUploadWithContext(v aws.Context, abortMultipartUploadInput *s3.AbortMultipartUploadInput, options ...request.Option) (*s3.AbortMultipartUploadOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, abortMultipartUploadInput, options) + } else { + tmpRet = _mock.Called(v, abortMultipartUploadInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for AbortMultipartUploadWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.AbortMultipartUploadOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.AbortMultipartUploadInput, ...request.Option) (*s3.AbortMultipartUploadOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.AbortMultipartUploadInput, ...request.Option) (*s3.AbortMultipartUploadOutput, error)); ok { + return returnFunc(v, abortMultipartUploadInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.AbortMultipartUploadInput, ...request.Option) *s3.AbortMultipartUploadOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.AbortMultipartUploadInput, ...request.Option) *s3.AbortMultipartUploadOutput); ok { + r0 = returnFunc(v, abortMultipartUploadInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.AbortMultipartUploadOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.AbortMultipartUploadInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.AbortMultipartUploadInput, ...request.Option) error); ok { + r1 = returnFunc(v, abortMultipartUploadInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// CompleteMultipartUpload provides a mock function with given fields: _a0 -func (_m *S3API) CompleteMultipartUpload(_a0 *s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error) { - ret := _m.Called(_a0) +// S3API_AbortMultipartUploadWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AbortMultipartUploadWithContext' +type S3API_AbortMultipartUploadWithContext_Call struct { + *mock.Call +} + +// AbortMultipartUploadWithContext is a helper method to define mock.On call +// - v aws.Context +// - abortMultipartUploadInput *s3.AbortMultipartUploadInput +// - options ...request.Option +func (_e *S3API_Expecter) AbortMultipartUploadWithContext(v interface{}, abortMultipartUploadInput interface{}, options ...interface{}) *S3API_AbortMultipartUploadWithContext_Call { + return &S3API_AbortMultipartUploadWithContext_Call{Call: _e.mock.On("AbortMultipartUploadWithContext", + append([]interface{}{v, abortMultipartUploadInput}, options...)...)} +} + +func (_c *S3API_AbortMultipartUploadWithContext_Call) Run(run func(v aws.Context, abortMultipartUploadInput *s3.AbortMultipartUploadInput, options ...request.Option)) *S3API_AbortMultipartUploadWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.AbortMultipartUploadInput + if args[1] != nil { + arg1 = args[1].(*s3.AbortMultipartUploadInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_AbortMultipartUploadWithContext_Call) Return(abortMultipartUploadOutput *s3.AbortMultipartUploadOutput, err error) *S3API_AbortMultipartUploadWithContext_Call { + _c.Call.Return(abortMultipartUploadOutput, err) + return _c +} + +func (_c *S3API_AbortMultipartUploadWithContext_Call) RunAndReturn(run func(v aws.Context, abortMultipartUploadInput *s3.AbortMultipartUploadInput, options ...request.Option) (*s3.AbortMultipartUploadOutput, error)) *S3API_AbortMultipartUploadWithContext_Call { + _c.Call.Return(run) + return _c +} + +// CompleteMultipartUpload provides a mock function for the type S3API +func (_mock *S3API) CompleteMultipartUpload(completeMultipartUploadInput *s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error) { + ret := _mock.Called(completeMultipartUploadInput) + + if len(ret) == 0 { + panic("no return value specified for CompleteMultipartUpload") + } var r0 *s3.CompleteMultipartUploadOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error)); ok { + return returnFunc(completeMultipartUploadInput) } - if rf, ok := ret.Get(0).(func(*s3.CompleteMultipartUploadInput) *s3.CompleteMultipartUploadOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CompleteMultipartUploadInput) *s3.CompleteMultipartUploadOutput); ok { + r0 = returnFunc(completeMultipartUploadInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.CompleteMultipartUploadOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.CompleteMultipartUploadInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.CompleteMultipartUploadInput) error); ok { + r1 = returnFunc(completeMultipartUploadInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// CompleteMultipartUploadRequest provides a mock function with given fields: _a0 -func (_m *S3API) CompleteMultipartUploadRequest(_a0 *s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput) { - ret := _m.Called(_a0) +// S3API_CompleteMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteMultipartUpload' +type S3API_CompleteMultipartUpload_Call struct { + *mock.Call +} + +// CompleteMultipartUpload is a helper method to define mock.On call +// - completeMultipartUploadInput *s3.CompleteMultipartUploadInput +func (_e *S3API_Expecter) CompleteMultipartUpload(completeMultipartUploadInput interface{}) *S3API_CompleteMultipartUpload_Call { + return &S3API_CompleteMultipartUpload_Call{Call: _e.mock.On("CompleteMultipartUpload", completeMultipartUploadInput)} +} + +func (_c *S3API_CompleteMultipartUpload_Call) Run(run func(completeMultipartUploadInput *s3.CompleteMultipartUploadInput)) *S3API_CompleteMultipartUpload_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.CompleteMultipartUploadInput + if args[0] != nil { + arg0 = args[0].(*s3.CompleteMultipartUploadInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_CompleteMultipartUpload_Call) Return(completeMultipartUploadOutput *s3.CompleteMultipartUploadOutput, err error) *S3API_CompleteMultipartUpload_Call { + _c.Call.Return(completeMultipartUploadOutput, err) + return _c +} + +func (_c *S3API_CompleteMultipartUpload_Call) RunAndReturn(run func(completeMultipartUploadInput *s3.CompleteMultipartUploadInput) (*s3.CompleteMultipartUploadOutput, error)) *S3API_CompleteMultipartUpload_Call { + _c.Call.Return(run) + return _c +} + +// CompleteMultipartUploadRequest provides a mock function for the type S3API +func (_mock *S3API) CompleteMultipartUploadRequest(completeMultipartUploadInput *s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput) { + ret := _mock.Called(completeMultipartUploadInput) + + if len(ret) == 0 { + panic("no return value specified for CompleteMultipartUploadRequest") + } var r0 *request.Request var r1 *s3.CompleteMultipartUploadOutput - if rf, ok := ret.Get(0).(func(*s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput)); ok { + return returnFunc(completeMultipartUploadInput) } - if rf, ok := ret.Get(0).(func(*s3.CompleteMultipartUploadInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CompleteMultipartUploadInput) *request.Request); ok { + r0 = returnFunc(completeMultipartUploadInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.CompleteMultipartUploadInput) *s3.CompleteMultipartUploadOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.CompleteMultipartUploadInput) *s3.CompleteMultipartUploadOutput); ok { + r1 = returnFunc(completeMultipartUploadInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.CompleteMultipartUploadOutput) } } - return r0, r1 } -// CompleteMultipartUploadWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) CompleteMultipartUploadWithContext(_a0 context.Context, _a1 *s3.CompleteMultipartUploadInput, _a2 ...request.Option) (*s3.CompleteMultipartUploadOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_CompleteMultipartUploadRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteMultipartUploadRequest' +type S3API_CompleteMultipartUploadRequest_Call struct { + *mock.Call +} + +// CompleteMultipartUploadRequest is a helper method to define mock.On call +// - completeMultipartUploadInput *s3.CompleteMultipartUploadInput +func (_e *S3API_Expecter) CompleteMultipartUploadRequest(completeMultipartUploadInput interface{}) *S3API_CompleteMultipartUploadRequest_Call { + return &S3API_CompleteMultipartUploadRequest_Call{Call: _e.mock.On("CompleteMultipartUploadRequest", completeMultipartUploadInput)} +} + +func (_c *S3API_CompleteMultipartUploadRequest_Call) Run(run func(completeMultipartUploadInput *s3.CompleteMultipartUploadInput)) *S3API_CompleteMultipartUploadRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.CompleteMultipartUploadInput + if args[0] != nil { + arg0 = args[0].(*s3.CompleteMultipartUploadInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_CompleteMultipartUploadRequest_Call) Return(request1 *request.Request, completeMultipartUploadOutput *s3.CompleteMultipartUploadOutput) *S3API_CompleteMultipartUploadRequest_Call { + _c.Call.Return(request1, completeMultipartUploadOutput) + return _c +} + +func (_c *S3API_CompleteMultipartUploadRequest_Call) RunAndReturn(run func(completeMultipartUploadInput *s3.CompleteMultipartUploadInput) (*request.Request, *s3.CompleteMultipartUploadOutput)) *S3API_CompleteMultipartUploadRequest_Call { + _c.Call.Return(run) + return _c +} + +// CompleteMultipartUploadWithContext provides a mock function for the type S3API +func (_mock *S3API) CompleteMultipartUploadWithContext(v aws.Context, completeMultipartUploadInput *s3.CompleteMultipartUploadInput, options ...request.Option) (*s3.CompleteMultipartUploadOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, completeMultipartUploadInput, options) + } else { + tmpRet = _mock.Called(v, completeMultipartUploadInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for CompleteMultipartUploadWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.CompleteMultipartUploadOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.CompleteMultipartUploadInput, ...request.Option) (*s3.CompleteMultipartUploadOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.CompleteMultipartUploadInput, ...request.Option) (*s3.CompleteMultipartUploadOutput, error)); ok { + return returnFunc(v, completeMultipartUploadInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.CompleteMultipartUploadInput, ...request.Option) *s3.CompleteMultipartUploadOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.CompleteMultipartUploadInput, ...request.Option) *s3.CompleteMultipartUploadOutput); ok { + r0 = returnFunc(v, completeMultipartUploadInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.CompleteMultipartUploadOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.CompleteMultipartUploadInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.CompleteMultipartUploadInput, ...request.Option) error); ok { + r1 = returnFunc(v, completeMultipartUploadInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// CopyObject provides a mock function with given fields: _a0 -func (_m *S3API) CopyObject(_a0 *s3.CopyObjectInput) (*s3.CopyObjectOutput, error) { - ret := _m.Called(_a0) +// S3API_CompleteMultipartUploadWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteMultipartUploadWithContext' +type S3API_CompleteMultipartUploadWithContext_Call struct { + *mock.Call +} + +// CompleteMultipartUploadWithContext is a helper method to define mock.On call +// - v aws.Context +// - completeMultipartUploadInput *s3.CompleteMultipartUploadInput +// - options ...request.Option +func (_e *S3API_Expecter) CompleteMultipartUploadWithContext(v interface{}, completeMultipartUploadInput interface{}, options ...interface{}) *S3API_CompleteMultipartUploadWithContext_Call { + return &S3API_CompleteMultipartUploadWithContext_Call{Call: _e.mock.On("CompleteMultipartUploadWithContext", + append([]interface{}{v, completeMultipartUploadInput}, options...)...)} +} + +func (_c *S3API_CompleteMultipartUploadWithContext_Call) Run(run func(v aws.Context, completeMultipartUploadInput *s3.CompleteMultipartUploadInput, options ...request.Option)) *S3API_CompleteMultipartUploadWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.CompleteMultipartUploadInput + if args[1] != nil { + arg1 = args[1].(*s3.CompleteMultipartUploadInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_CompleteMultipartUploadWithContext_Call) Return(completeMultipartUploadOutput *s3.CompleteMultipartUploadOutput, err error) *S3API_CompleteMultipartUploadWithContext_Call { + _c.Call.Return(completeMultipartUploadOutput, err) + return _c +} + +func (_c *S3API_CompleteMultipartUploadWithContext_Call) RunAndReturn(run func(v aws.Context, completeMultipartUploadInput *s3.CompleteMultipartUploadInput, options ...request.Option) (*s3.CompleteMultipartUploadOutput, error)) *S3API_CompleteMultipartUploadWithContext_Call { + _c.Call.Return(run) + return _c +} + +// CopyObject provides a mock function for the type S3API +func (_mock *S3API) CopyObject(copyObjectInput *s3.CopyObjectInput) (*s3.CopyObjectOutput, error) { + ret := _mock.Called(copyObjectInput) + + if len(ret) == 0 { + panic("no return value specified for CopyObject") + } var r0 *s3.CopyObjectOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.CopyObjectInput) (*s3.CopyObjectOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CopyObjectInput) (*s3.CopyObjectOutput, error)); ok { + return returnFunc(copyObjectInput) } - if rf, ok := ret.Get(0).(func(*s3.CopyObjectInput) *s3.CopyObjectOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CopyObjectInput) *s3.CopyObjectOutput); ok { + r0 = returnFunc(copyObjectInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.CopyObjectOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.CopyObjectInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.CopyObjectInput) error); ok { + r1 = returnFunc(copyObjectInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// CopyObjectRequest provides a mock function with given fields: _a0 -func (_m *S3API) CopyObjectRequest(_a0 *s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput) { - ret := _m.Called(_a0) +// S3API_CopyObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyObject' +type S3API_CopyObject_Call struct { + *mock.Call +} + +// CopyObject is a helper method to define mock.On call +// - copyObjectInput *s3.CopyObjectInput +func (_e *S3API_Expecter) CopyObject(copyObjectInput interface{}) *S3API_CopyObject_Call { + return &S3API_CopyObject_Call{Call: _e.mock.On("CopyObject", copyObjectInput)} +} + +func (_c *S3API_CopyObject_Call) Run(run func(copyObjectInput *s3.CopyObjectInput)) *S3API_CopyObject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.CopyObjectInput + if args[0] != nil { + arg0 = args[0].(*s3.CopyObjectInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_CopyObject_Call) Return(copyObjectOutput *s3.CopyObjectOutput, err error) *S3API_CopyObject_Call { + _c.Call.Return(copyObjectOutput, err) + return _c +} + +func (_c *S3API_CopyObject_Call) RunAndReturn(run func(copyObjectInput *s3.CopyObjectInput) (*s3.CopyObjectOutput, error)) *S3API_CopyObject_Call { + _c.Call.Return(run) + return _c +} + +// CopyObjectRequest provides a mock function for the type S3API +func (_mock *S3API) CopyObjectRequest(copyObjectInput *s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput) { + ret := _mock.Called(copyObjectInput) + + if len(ret) == 0 { + panic("no return value specified for CopyObjectRequest") + } var r0 *request.Request var r1 *s3.CopyObjectOutput - if rf, ok := ret.Get(0).(func(*s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput)); ok { + return returnFunc(copyObjectInput) } - if rf, ok := ret.Get(0).(func(*s3.CopyObjectInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CopyObjectInput) *request.Request); ok { + r0 = returnFunc(copyObjectInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.CopyObjectInput) *s3.CopyObjectOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.CopyObjectInput) *s3.CopyObjectOutput); ok { + r1 = returnFunc(copyObjectInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.CopyObjectOutput) } } - return r0, r1 } -// CopyObjectWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) CopyObjectWithContext(_a0 context.Context, _a1 *s3.CopyObjectInput, _a2 ...request.Option) (*s3.CopyObjectOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_CopyObjectRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyObjectRequest' +type S3API_CopyObjectRequest_Call struct { + *mock.Call +} + +// CopyObjectRequest is a helper method to define mock.On call +// - copyObjectInput *s3.CopyObjectInput +func (_e *S3API_Expecter) CopyObjectRequest(copyObjectInput interface{}) *S3API_CopyObjectRequest_Call { + return &S3API_CopyObjectRequest_Call{Call: _e.mock.On("CopyObjectRequest", copyObjectInput)} +} + +func (_c *S3API_CopyObjectRequest_Call) Run(run func(copyObjectInput *s3.CopyObjectInput)) *S3API_CopyObjectRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.CopyObjectInput + if args[0] != nil { + arg0 = args[0].(*s3.CopyObjectInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_CopyObjectRequest_Call) Return(request1 *request.Request, copyObjectOutput *s3.CopyObjectOutput) *S3API_CopyObjectRequest_Call { + _c.Call.Return(request1, copyObjectOutput) + return _c +} + +func (_c *S3API_CopyObjectRequest_Call) RunAndReturn(run func(copyObjectInput *s3.CopyObjectInput) (*request.Request, *s3.CopyObjectOutput)) *S3API_CopyObjectRequest_Call { + _c.Call.Return(run) + return _c +} + +// CopyObjectWithContext provides a mock function for the type S3API +func (_mock *S3API) CopyObjectWithContext(v aws.Context, copyObjectInput *s3.CopyObjectInput, options ...request.Option) (*s3.CopyObjectOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, copyObjectInput, options) + } else { + tmpRet = _mock.Called(v, copyObjectInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for CopyObjectWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.CopyObjectOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.CopyObjectInput, ...request.Option) (*s3.CopyObjectOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.CopyObjectInput, ...request.Option) (*s3.CopyObjectOutput, error)); ok { + return returnFunc(v, copyObjectInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.CopyObjectInput, ...request.Option) *s3.CopyObjectOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.CopyObjectInput, ...request.Option) *s3.CopyObjectOutput); ok { + r0 = returnFunc(v, copyObjectInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.CopyObjectOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.CopyObjectInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.CopyObjectInput, ...request.Option) error); ok { + r1 = returnFunc(v, copyObjectInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// CreateBucket provides a mock function with given fields: _a0 -func (_m *S3API) CreateBucket(_a0 *s3.CreateBucketInput) (*s3.CreateBucketOutput, error) { - ret := _m.Called(_a0) +// S3API_CopyObjectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CopyObjectWithContext' +type S3API_CopyObjectWithContext_Call struct { + *mock.Call +} + +// CopyObjectWithContext is a helper method to define mock.On call +// - v aws.Context +// - copyObjectInput *s3.CopyObjectInput +// - options ...request.Option +func (_e *S3API_Expecter) CopyObjectWithContext(v interface{}, copyObjectInput interface{}, options ...interface{}) *S3API_CopyObjectWithContext_Call { + return &S3API_CopyObjectWithContext_Call{Call: _e.mock.On("CopyObjectWithContext", + append([]interface{}{v, copyObjectInput}, options...)...)} +} + +func (_c *S3API_CopyObjectWithContext_Call) Run(run func(v aws.Context, copyObjectInput *s3.CopyObjectInput, options ...request.Option)) *S3API_CopyObjectWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.CopyObjectInput + if args[1] != nil { + arg1 = args[1].(*s3.CopyObjectInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_CopyObjectWithContext_Call) Return(copyObjectOutput *s3.CopyObjectOutput, err error) *S3API_CopyObjectWithContext_Call { + _c.Call.Return(copyObjectOutput, err) + return _c +} + +func (_c *S3API_CopyObjectWithContext_Call) RunAndReturn(run func(v aws.Context, copyObjectInput *s3.CopyObjectInput, options ...request.Option) (*s3.CopyObjectOutput, error)) *S3API_CopyObjectWithContext_Call { + _c.Call.Return(run) + return _c +} + +// CreateBucket provides a mock function for the type S3API +func (_mock *S3API) CreateBucket(createBucketInput *s3.CreateBucketInput) (*s3.CreateBucketOutput, error) { + ret := _mock.Called(createBucketInput) + + if len(ret) == 0 { + panic("no return value specified for CreateBucket") + } var r0 *s3.CreateBucketOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.CreateBucketInput) (*s3.CreateBucketOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CreateBucketInput) (*s3.CreateBucketOutput, error)); ok { + return returnFunc(createBucketInput) } - if rf, ok := ret.Get(0).(func(*s3.CreateBucketInput) *s3.CreateBucketOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CreateBucketInput) *s3.CreateBucketOutput); ok { + r0 = returnFunc(createBucketInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.CreateBucketOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.CreateBucketInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.CreateBucketInput) error); ok { + r1 = returnFunc(createBucketInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// CreateBucketRequest provides a mock function with given fields: _a0 -func (_m *S3API) CreateBucketRequest(_a0 *s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput) { - ret := _m.Called(_a0) +// S3API_CreateBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBucket' +type S3API_CreateBucket_Call struct { + *mock.Call +} + +// CreateBucket is a helper method to define mock.On call +// - createBucketInput *s3.CreateBucketInput +func (_e *S3API_Expecter) CreateBucket(createBucketInput interface{}) *S3API_CreateBucket_Call { + return &S3API_CreateBucket_Call{Call: _e.mock.On("CreateBucket", createBucketInput)} +} + +func (_c *S3API_CreateBucket_Call) Run(run func(createBucketInput *s3.CreateBucketInput)) *S3API_CreateBucket_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.CreateBucketInput + if args[0] != nil { + arg0 = args[0].(*s3.CreateBucketInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_CreateBucket_Call) Return(createBucketOutput *s3.CreateBucketOutput, err error) *S3API_CreateBucket_Call { + _c.Call.Return(createBucketOutput, err) + return _c +} + +func (_c *S3API_CreateBucket_Call) RunAndReturn(run func(createBucketInput *s3.CreateBucketInput) (*s3.CreateBucketOutput, error)) *S3API_CreateBucket_Call { + _c.Call.Return(run) + return _c +} + +// CreateBucketRequest provides a mock function for the type S3API +func (_mock *S3API) CreateBucketRequest(createBucketInput *s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput) { + ret := _mock.Called(createBucketInput) + + if len(ret) == 0 { + panic("no return value specified for CreateBucketRequest") + } var r0 *request.Request var r1 *s3.CreateBucketOutput - if rf, ok := ret.Get(0).(func(*s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput)); ok { + return returnFunc(createBucketInput) } - if rf, ok := ret.Get(0).(func(*s3.CreateBucketInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CreateBucketInput) *request.Request); ok { + r0 = returnFunc(createBucketInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.CreateBucketInput) *s3.CreateBucketOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.CreateBucketInput) *s3.CreateBucketOutput); ok { + r1 = returnFunc(createBucketInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.CreateBucketOutput) } } - return r0, r1 } -// CreateBucketWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) CreateBucketWithContext(_a0 context.Context, _a1 *s3.CreateBucketInput, _a2 ...request.Option) (*s3.CreateBucketOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_CreateBucketRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBucketRequest' +type S3API_CreateBucketRequest_Call struct { + *mock.Call +} + +// CreateBucketRequest is a helper method to define mock.On call +// - createBucketInput *s3.CreateBucketInput +func (_e *S3API_Expecter) CreateBucketRequest(createBucketInput interface{}) *S3API_CreateBucketRequest_Call { + return &S3API_CreateBucketRequest_Call{Call: _e.mock.On("CreateBucketRequest", createBucketInput)} +} + +func (_c *S3API_CreateBucketRequest_Call) Run(run func(createBucketInput *s3.CreateBucketInput)) *S3API_CreateBucketRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.CreateBucketInput + if args[0] != nil { + arg0 = args[0].(*s3.CreateBucketInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_CreateBucketRequest_Call) Return(request1 *request.Request, createBucketOutput *s3.CreateBucketOutput) *S3API_CreateBucketRequest_Call { + _c.Call.Return(request1, createBucketOutput) + return _c +} + +func (_c *S3API_CreateBucketRequest_Call) RunAndReturn(run func(createBucketInput *s3.CreateBucketInput) (*request.Request, *s3.CreateBucketOutput)) *S3API_CreateBucketRequest_Call { + _c.Call.Return(run) + return _c +} + +// CreateBucketWithContext provides a mock function for the type S3API +func (_mock *S3API) CreateBucketWithContext(v aws.Context, createBucketInput *s3.CreateBucketInput, options ...request.Option) (*s3.CreateBucketOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, createBucketInput, options) + } else { + tmpRet = _mock.Called(v, createBucketInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for CreateBucketWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.CreateBucketOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.CreateBucketInput, ...request.Option) (*s3.CreateBucketOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.CreateBucketInput, ...request.Option) (*s3.CreateBucketOutput, error)); ok { + return returnFunc(v, createBucketInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.CreateBucketInput, ...request.Option) *s3.CreateBucketOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.CreateBucketInput, ...request.Option) *s3.CreateBucketOutput); ok { + r0 = returnFunc(v, createBucketInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.CreateBucketOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.CreateBucketInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.CreateBucketInput, ...request.Option) error); ok { + r1 = returnFunc(v, createBucketInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// CreateMultipartUpload provides a mock function with given fields: _a0 -func (_m *S3API) CreateMultipartUpload(_a0 *s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error) { - ret := _m.Called(_a0) +// S3API_CreateBucketWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateBucketWithContext' +type S3API_CreateBucketWithContext_Call struct { + *mock.Call +} + +// CreateBucketWithContext is a helper method to define mock.On call +// - v aws.Context +// - createBucketInput *s3.CreateBucketInput +// - options ...request.Option +func (_e *S3API_Expecter) CreateBucketWithContext(v interface{}, createBucketInput interface{}, options ...interface{}) *S3API_CreateBucketWithContext_Call { + return &S3API_CreateBucketWithContext_Call{Call: _e.mock.On("CreateBucketWithContext", + append([]interface{}{v, createBucketInput}, options...)...)} +} + +func (_c *S3API_CreateBucketWithContext_Call) Run(run func(v aws.Context, createBucketInput *s3.CreateBucketInput, options ...request.Option)) *S3API_CreateBucketWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.CreateBucketInput + if args[1] != nil { + arg1 = args[1].(*s3.CreateBucketInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_CreateBucketWithContext_Call) Return(createBucketOutput *s3.CreateBucketOutput, err error) *S3API_CreateBucketWithContext_Call { + _c.Call.Return(createBucketOutput, err) + return _c +} + +func (_c *S3API_CreateBucketWithContext_Call) RunAndReturn(run func(v aws.Context, createBucketInput *s3.CreateBucketInput, options ...request.Option) (*s3.CreateBucketOutput, error)) *S3API_CreateBucketWithContext_Call { + _c.Call.Return(run) + return _c +} + +// CreateMultipartUpload provides a mock function for the type S3API +func (_mock *S3API) CreateMultipartUpload(createMultipartUploadInput *s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error) { + ret := _mock.Called(createMultipartUploadInput) + + if len(ret) == 0 { + panic("no return value specified for CreateMultipartUpload") + } var r0 *s3.CreateMultipartUploadOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error)); ok { + return returnFunc(createMultipartUploadInput) } - if rf, ok := ret.Get(0).(func(*s3.CreateMultipartUploadInput) *s3.CreateMultipartUploadOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CreateMultipartUploadInput) *s3.CreateMultipartUploadOutput); ok { + r0 = returnFunc(createMultipartUploadInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.CreateMultipartUploadOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.CreateMultipartUploadInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.CreateMultipartUploadInput) error); ok { + r1 = returnFunc(createMultipartUploadInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// CreateMultipartUploadRequest provides a mock function with given fields: _a0 -func (_m *S3API) CreateMultipartUploadRequest(_a0 *s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput) { - ret := _m.Called(_a0) +// S3API_CreateMultipartUpload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMultipartUpload' +type S3API_CreateMultipartUpload_Call struct { + *mock.Call +} + +// CreateMultipartUpload is a helper method to define mock.On call +// - createMultipartUploadInput *s3.CreateMultipartUploadInput +func (_e *S3API_Expecter) CreateMultipartUpload(createMultipartUploadInput interface{}) *S3API_CreateMultipartUpload_Call { + return &S3API_CreateMultipartUpload_Call{Call: _e.mock.On("CreateMultipartUpload", createMultipartUploadInput)} +} + +func (_c *S3API_CreateMultipartUpload_Call) Run(run func(createMultipartUploadInput *s3.CreateMultipartUploadInput)) *S3API_CreateMultipartUpload_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.CreateMultipartUploadInput + if args[0] != nil { + arg0 = args[0].(*s3.CreateMultipartUploadInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_CreateMultipartUpload_Call) Return(createMultipartUploadOutput *s3.CreateMultipartUploadOutput, err error) *S3API_CreateMultipartUpload_Call { + _c.Call.Return(createMultipartUploadOutput, err) + return _c +} + +func (_c *S3API_CreateMultipartUpload_Call) RunAndReturn(run func(createMultipartUploadInput *s3.CreateMultipartUploadInput) (*s3.CreateMultipartUploadOutput, error)) *S3API_CreateMultipartUpload_Call { + _c.Call.Return(run) + return _c +} + +// CreateMultipartUploadRequest provides a mock function for the type S3API +func (_mock *S3API) CreateMultipartUploadRequest(createMultipartUploadInput *s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput) { + ret := _mock.Called(createMultipartUploadInput) + + if len(ret) == 0 { + panic("no return value specified for CreateMultipartUploadRequest") + } var r0 *request.Request var r1 *s3.CreateMultipartUploadOutput - if rf, ok := ret.Get(0).(func(*s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput)); ok { + return returnFunc(createMultipartUploadInput) } - if rf, ok := ret.Get(0).(func(*s3.CreateMultipartUploadInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CreateMultipartUploadInput) *request.Request); ok { + r0 = returnFunc(createMultipartUploadInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.CreateMultipartUploadInput) *s3.CreateMultipartUploadOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.CreateMultipartUploadInput) *s3.CreateMultipartUploadOutput); ok { + r1 = returnFunc(createMultipartUploadInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.CreateMultipartUploadOutput) } } - return r0, r1 } -// CreateMultipartUploadWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) CreateMultipartUploadWithContext(_a0 context.Context, _a1 *s3.CreateMultipartUploadInput, _a2 ...request.Option) (*s3.CreateMultipartUploadOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_CreateMultipartUploadRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMultipartUploadRequest' +type S3API_CreateMultipartUploadRequest_Call struct { + *mock.Call +} + +// CreateMultipartUploadRequest is a helper method to define mock.On call +// - createMultipartUploadInput *s3.CreateMultipartUploadInput +func (_e *S3API_Expecter) CreateMultipartUploadRequest(createMultipartUploadInput interface{}) *S3API_CreateMultipartUploadRequest_Call { + return &S3API_CreateMultipartUploadRequest_Call{Call: _e.mock.On("CreateMultipartUploadRequest", createMultipartUploadInput)} +} + +func (_c *S3API_CreateMultipartUploadRequest_Call) Run(run func(createMultipartUploadInput *s3.CreateMultipartUploadInput)) *S3API_CreateMultipartUploadRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.CreateMultipartUploadInput + if args[0] != nil { + arg0 = args[0].(*s3.CreateMultipartUploadInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_CreateMultipartUploadRequest_Call) Return(request1 *request.Request, createMultipartUploadOutput *s3.CreateMultipartUploadOutput) *S3API_CreateMultipartUploadRequest_Call { + _c.Call.Return(request1, createMultipartUploadOutput) + return _c +} + +func (_c *S3API_CreateMultipartUploadRequest_Call) RunAndReturn(run func(createMultipartUploadInput *s3.CreateMultipartUploadInput) (*request.Request, *s3.CreateMultipartUploadOutput)) *S3API_CreateMultipartUploadRequest_Call { + _c.Call.Return(run) + return _c +} + +// CreateMultipartUploadWithContext provides a mock function for the type S3API +func (_mock *S3API) CreateMultipartUploadWithContext(v aws.Context, createMultipartUploadInput *s3.CreateMultipartUploadInput, options ...request.Option) (*s3.CreateMultipartUploadOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, createMultipartUploadInput, options) + } else { + tmpRet = _mock.Called(v, createMultipartUploadInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for CreateMultipartUploadWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.CreateMultipartUploadOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.CreateMultipartUploadInput, ...request.Option) (*s3.CreateMultipartUploadOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.CreateMultipartUploadInput, ...request.Option) (*s3.CreateMultipartUploadOutput, error)); ok { + return returnFunc(v, createMultipartUploadInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.CreateMultipartUploadInput, ...request.Option) *s3.CreateMultipartUploadOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.CreateMultipartUploadInput, ...request.Option) *s3.CreateMultipartUploadOutput); ok { + r0 = returnFunc(v, createMultipartUploadInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.CreateMultipartUploadOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.CreateMultipartUploadInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.CreateMultipartUploadInput, ...request.Option) error); ok { + r1 = returnFunc(v, createMultipartUploadInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// CreateSession provides a mock function with given fields: _a0 -func (_m *S3API) CreateSession(_a0 *s3.CreateSessionInput) (*s3.CreateSessionOutput, error) { - ret := _m.Called(_a0) +// S3API_CreateMultipartUploadWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateMultipartUploadWithContext' +type S3API_CreateMultipartUploadWithContext_Call struct { + *mock.Call +} - var r0 *s3.CreateSessionOutput - var r1 error - if rf, ok := ret.Get(0).(func(*s3.CreateSessionInput) (*s3.CreateSessionOutput, error)); ok { - return rf(_a0) - } - if rf, ok := ret.Get(0).(func(*s3.CreateSessionInput) *s3.CreateSessionOutput); ok { - r0 = rf(_a0) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*s3.CreateSessionOutput) - } - } +// CreateMultipartUploadWithContext is a helper method to define mock.On call +// - v aws.Context +// - createMultipartUploadInput *s3.CreateMultipartUploadInput +// - options ...request.Option +func (_e *S3API_Expecter) CreateMultipartUploadWithContext(v interface{}, createMultipartUploadInput interface{}, options ...interface{}) *S3API_CreateMultipartUploadWithContext_Call { + return &S3API_CreateMultipartUploadWithContext_Call{Call: _e.mock.On("CreateMultipartUploadWithContext", + append([]interface{}{v, createMultipartUploadInput}, options...)...)} +} - if rf, ok := ret.Get(1).(func(*s3.CreateSessionInput) error); ok { - r1 = rf(_a0) +func (_c *S3API_CreateMultipartUploadWithContext_Call) Run(run func(v aws.Context, createMultipartUploadInput *s3.CreateMultipartUploadInput, options ...request.Option)) *S3API_CreateMultipartUploadWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.CreateMultipartUploadInput + if args[1] != nil { + arg1 = args[1].(*s3.CreateMultipartUploadInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_CreateMultipartUploadWithContext_Call) Return(createMultipartUploadOutput *s3.CreateMultipartUploadOutput, err error) *S3API_CreateMultipartUploadWithContext_Call { + _c.Call.Return(createMultipartUploadOutput, err) + return _c +} + +func (_c *S3API_CreateMultipartUploadWithContext_Call) RunAndReturn(run func(v aws.Context, createMultipartUploadInput *s3.CreateMultipartUploadInput, options ...request.Option) (*s3.CreateMultipartUploadOutput, error)) *S3API_CreateMultipartUploadWithContext_Call { + _c.Call.Return(run) + return _c +} + +// CreateSession provides a mock function for the type S3API +func (_mock *S3API) CreateSession(createSessionInput *s3.CreateSessionInput) (*s3.CreateSessionOutput, error) { + ret := _mock.Called(createSessionInput) + + if len(ret) == 0 { + panic("no return value specified for CreateSession") + } + + var r0 *s3.CreateSessionOutput + var r1 error + if returnFunc, ok := ret.Get(0).(func(*s3.CreateSessionInput) (*s3.CreateSessionOutput, error)); ok { + return returnFunc(createSessionInput) + } + if returnFunc, ok := ret.Get(0).(func(*s3.CreateSessionInput) *s3.CreateSessionOutput); ok { + r0 = returnFunc(createSessionInput) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*s3.CreateSessionOutput) + } + } + if returnFunc, ok := ret.Get(1).(func(*s3.CreateSessionInput) error); ok { + r1 = returnFunc(createSessionInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// CreateSessionRequest provides a mock function with given fields: _a0 -func (_m *S3API) CreateSessionRequest(_a0 *s3.CreateSessionInput) (*request.Request, *s3.CreateSessionOutput) { - ret := _m.Called(_a0) +// S3API_CreateSession_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSession' +type S3API_CreateSession_Call struct { + *mock.Call +} + +// CreateSession is a helper method to define mock.On call +// - createSessionInput *s3.CreateSessionInput +func (_e *S3API_Expecter) CreateSession(createSessionInput interface{}) *S3API_CreateSession_Call { + return &S3API_CreateSession_Call{Call: _e.mock.On("CreateSession", createSessionInput)} +} + +func (_c *S3API_CreateSession_Call) Run(run func(createSessionInput *s3.CreateSessionInput)) *S3API_CreateSession_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.CreateSessionInput + if args[0] != nil { + arg0 = args[0].(*s3.CreateSessionInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_CreateSession_Call) Return(createSessionOutput *s3.CreateSessionOutput, err error) *S3API_CreateSession_Call { + _c.Call.Return(createSessionOutput, err) + return _c +} + +func (_c *S3API_CreateSession_Call) RunAndReturn(run func(createSessionInput *s3.CreateSessionInput) (*s3.CreateSessionOutput, error)) *S3API_CreateSession_Call { + _c.Call.Return(run) + return _c +} + +// CreateSessionRequest provides a mock function for the type S3API +func (_mock *S3API) CreateSessionRequest(createSessionInput *s3.CreateSessionInput) (*request.Request, *s3.CreateSessionOutput) { + ret := _mock.Called(createSessionInput) + + if len(ret) == 0 { + panic("no return value specified for CreateSessionRequest") + } var r0 *request.Request var r1 *s3.CreateSessionOutput - if rf, ok := ret.Get(0).(func(*s3.CreateSessionInput) (*request.Request, *s3.CreateSessionOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CreateSessionInput) (*request.Request, *s3.CreateSessionOutput)); ok { + return returnFunc(createSessionInput) } - if rf, ok := ret.Get(0).(func(*s3.CreateSessionInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.CreateSessionInput) *request.Request); ok { + r0 = returnFunc(createSessionInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.CreateSessionInput) *s3.CreateSessionOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.CreateSessionInput) *s3.CreateSessionOutput); ok { + r1 = returnFunc(createSessionInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.CreateSessionOutput) } } - return r0, r1 } -// CreateSessionWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) CreateSessionWithContext(_a0 context.Context, _a1 *s3.CreateSessionInput, _a2 ...request.Option) (*s3.CreateSessionOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_CreateSessionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSessionRequest' +type S3API_CreateSessionRequest_Call struct { + *mock.Call +} + +// CreateSessionRequest is a helper method to define mock.On call +// - createSessionInput *s3.CreateSessionInput +func (_e *S3API_Expecter) CreateSessionRequest(createSessionInput interface{}) *S3API_CreateSessionRequest_Call { + return &S3API_CreateSessionRequest_Call{Call: _e.mock.On("CreateSessionRequest", createSessionInput)} +} + +func (_c *S3API_CreateSessionRequest_Call) Run(run func(createSessionInput *s3.CreateSessionInput)) *S3API_CreateSessionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.CreateSessionInput + if args[0] != nil { + arg0 = args[0].(*s3.CreateSessionInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_CreateSessionRequest_Call) Return(request1 *request.Request, createSessionOutput *s3.CreateSessionOutput) *S3API_CreateSessionRequest_Call { + _c.Call.Return(request1, createSessionOutput) + return _c +} + +func (_c *S3API_CreateSessionRequest_Call) RunAndReturn(run func(createSessionInput *s3.CreateSessionInput) (*request.Request, *s3.CreateSessionOutput)) *S3API_CreateSessionRequest_Call { + _c.Call.Return(run) + return _c +} + +// CreateSessionWithContext provides a mock function for the type S3API +func (_mock *S3API) CreateSessionWithContext(v aws.Context, createSessionInput *s3.CreateSessionInput, options ...request.Option) (*s3.CreateSessionOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, createSessionInput, options) + } else { + tmpRet = _mock.Called(v, createSessionInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for CreateSessionWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.CreateSessionOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.CreateSessionInput, ...request.Option) (*s3.CreateSessionOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.CreateSessionInput, ...request.Option) (*s3.CreateSessionOutput, error)); ok { + return returnFunc(v, createSessionInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.CreateSessionInput, ...request.Option) *s3.CreateSessionOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.CreateSessionInput, ...request.Option) *s3.CreateSessionOutput); ok { + r0 = returnFunc(v, createSessionInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.CreateSessionOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.CreateSessionInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.CreateSessionInput, ...request.Option) error); ok { + r1 = returnFunc(v, createSessionInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucket provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucket(_a0 *s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error) { - ret := _m.Called(_a0) +// S3API_CreateSessionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateSessionWithContext' +type S3API_CreateSessionWithContext_Call struct { + *mock.Call +} + +// CreateSessionWithContext is a helper method to define mock.On call +// - v aws.Context +// - createSessionInput *s3.CreateSessionInput +// - options ...request.Option +func (_e *S3API_Expecter) CreateSessionWithContext(v interface{}, createSessionInput interface{}, options ...interface{}) *S3API_CreateSessionWithContext_Call { + return &S3API_CreateSessionWithContext_Call{Call: _e.mock.On("CreateSessionWithContext", + append([]interface{}{v, createSessionInput}, options...)...)} +} + +func (_c *S3API_CreateSessionWithContext_Call) Run(run func(v aws.Context, createSessionInput *s3.CreateSessionInput, options ...request.Option)) *S3API_CreateSessionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.CreateSessionInput + if args[1] != nil { + arg1 = args[1].(*s3.CreateSessionInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_CreateSessionWithContext_Call) Return(createSessionOutput *s3.CreateSessionOutput, err error) *S3API_CreateSessionWithContext_Call { + _c.Call.Return(createSessionOutput, err) + return _c +} + +func (_c *S3API_CreateSessionWithContext_Call) RunAndReturn(run func(v aws.Context, createSessionInput *s3.CreateSessionInput, options ...request.Option) (*s3.CreateSessionOutput, error)) *S3API_CreateSessionWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucket provides a mock function for the type S3API +func (_mock *S3API) DeleteBucket(deleteBucketInput *s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error) { + ret := _mock.Called(deleteBucketInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucket") + } var r0 *s3.DeleteBucketOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error)); ok { + return returnFunc(deleteBucketInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInput) *s3.DeleteBucketOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketInput) *s3.DeleteBucketOutput); ok { + r0 = returnFunc(deleteBucketInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketInput) error); ok { + r1 = returnFunc(deleteBucketInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketAnalyticsConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketAnalyticsConfiguration(_a0 *s3.DeleteBucketAnalyticsConfigurationInput) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucket' +type S3API_DeleteBucket_Call struct { + *mock.Call +} + +// DeleteBucket is a helper method to define mock.On call +// - deleteBucketInput *s3.DeleteBucketInput +func (_e *S3API_Expecter) DeleteBucket(deleteBucketInput interface{}) *S3API_DeleteBucket_Call { + return &S3API_DeleteBucket_Call{Call: _e.mock.On("DeleteBucket", deleteBucketInput)} +} + +func (_c *S3API_DeleteBucket_Call) Run(run func(deleteBucketInput *s3.DeleteBucketInput)) *S3API_DeleteBucket_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucket_Call) Return(deleteBucketOutput *s3.DeleteBucketOutput, err error) *S3API_DeleteBucket_Call { + _c.Call.Return(deleteBucketOutput, err) + return _c +} + +func (_c *S3API_DeleteBucket_Call) RunAndReturn(run func(deleteBucketInput *s3.DeleteBucketInput) (*s3.DeleteBucketOutput, error)) *S3API_DeleteBucket_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketAnalyticsConfiguration provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketAnalyticsConfiguration(deleteBucketAnalyticsConfigurationInput *s3.DeleteBucketAnalyticsConfigurationInput) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) { + ret := _mock.Called(deleteBucketAnalyticsConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketAnalyticsConfiguration") + } var r0 *s3.DeleteBucketAnalyticsConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketAnalyticsConfigurationInput) (*s3.DeleteBucketAnalyticsConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketAnalyticsConfigurationInput) (*s3.DeleteBucketAnalyticsConfigurationOutput, error)); ok { + return returnFunc(deleteBucketAnalyticsConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketAnalyticsConfigurationInput) *s3.DeleteBucketAnalyticsConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketAnalyticsConfigurationInput) *s3.DeleteBucketAnalyticsConfigurationOutput); ok { + r0 = returnFunc(deleteBucketAnalyticsConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketAnalyticsConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketAnalyticsConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketAnalyticsConfigurationInput) error); ok { + r1 = returnFunc(deleteBucketAnalyticsConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketAnalyticsConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketAnalyticsConfigurationRequest(_a0 *s3.DeleteBucketAnalyticsConfigurationInput) (*request.Request, *s3.DeleteBucketAnalyticsConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_DeleteBucketAnalyticsConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketAnalyticsConfiguration' +type S3API_DeleteBucketAnalyticsConfiguration_Call struct { + *mock.Call +} + +// DeleteBucketAnalyticsConfiguration is a helper method to define mock.On call +// - deleteBucketAnalyticsConfigurationInput *s3.DeleteBucketAnalyticsConfigurationInput +func (_e *S3API_Expecter) DeleteBucketAnalyticsConfiguration(deleteBucketAnalyticsConfigurationInput interface{}) *S3API_DeleteBucketAnalyticsConfiguration_Call { + return &S3API_DeleteBucketAnalyticsConfiguration_Call{Call: _e.mock.On("DeleteBucketAnalyticsConfiguration", deleteBucketAnalyticsConfigurationInput)} +} + +func (_c *S3API_DeleteBucketAnalyticsConfiguration_Call) Run(run func(deleteBucketAnalyticsConfigurationInput *s3.DeleteBucketAnalyticsConfigurationInput)) *S3API_DeleteBucketAnalyticsConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketAnalyticsConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketAnalyticsConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketAnalyticsConfiguration_Call) Return(deleteBucketAnalyticsConfigurationOutput *s3.DeleteBucketAnalyticsConfigurationOutput, err error) *S3API_DeleteBucketAnalyticsConfiguration_Call { + _c.Call.Return(deleteBucketAnalyticsConfigurationOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketAnalyticsConfiguration_Call) RunAndReturn(run func(deleteBucketAnalyticsConfigurationInput *s3.DeleteBucketAnalyticsConfigurationInput) (*s3.DeleteBucketAnalyticsConfigurationOutput, error)) *S3API_DeleteBucketAnalyticsConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketAnalyticsConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketAnalyticsConfigurationRequest(deleteBucketAnalyticsConfigurationInput *s3.DeleteBucketAnalyticsConfigurationInput) (*request.Request, *s3.DeleteBucketAnalyticsConfigurationOutput) { + ret := _mock.Called(deleteBucketAnalyticsConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketAnalyticsConfigurationRequest") + } var r0 *request.Request var r1 *s3.DeleteBucketAnalyticsConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketAnalyticsConfigurationInput) (*request.Request, *s3.DeleteBucketAnalyticsConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketAnalyticsConfigurationInput) (*request.Request, *s3.DeleteBucketAnalyticsConfigurationOutput)); ok { + return returnFunc(deleteBucketAnalyticsConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketAnalyticsConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketAnalyticsConfigurationInput) *request.Request); ok { + r0 = returnFunc(deleteBucketAnalyticsConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketAnalyticsConfigurationInput) *s3.DeleteBucketAnalyticsConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketAnalyticsConfigurationInput) *s3.DeleteBucketAnalyticsConfigurationOutput); ok { + r1 = returnFunc(deleteBucketAnalyticsConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteBucketAnalyticsConfigurationOutput) } } - return r0, r1 } -// DeleteBucketAnalyticsConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteBucketAnalyticsConfigurationWithContext(_a0 context.Context, _a1 *s3.DeleteBucketAnalyticsConfigurationInput, _a2 ...request.Option) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeleteBucketAnalyticsConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketAnalyticsConfigurationRequest' +type S3API_DeleteBucketAnalyticsConfigurationRequest_Call struct { + *mock.Call +} + +// DeleteBucketAnalyticsConfigurationRequest is a helper method to define mock.On call +// - deleteBucketAnalyticsConfigurationInput *s3.DeleteBucketAnalyticsConfigurationInput +func (_e *S3API_Expecter) DeleteBucketAnalyticsConfigurationRequest(deleteBucketAnalyticsConfigurationInput interface{}) *S3API_DeleteBucketAnalyticsConfigurationRequest_Call { + return &S3API_DeleteBucketAnalyticsConfigurationRequest_Call{Call: _e.mock.On("DeleteBucketAnalyticsConfigurationRequest", deleteBucketAnalyticsConfigurationInput)} +} + +func (_c *S3API_DeleteBucketAnalyticsConfigurationRequest_Call) Run(run func(deleteBucketAnalyticsConfigurationInput *s3.DeleteBucketAnalyticsConfigurationInput)) *S3API_DeleteBucketAnalyticsConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketAnalyticsConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketAnalyticsConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketAnalyticsConfigurationRequest_Call) Return(request1 *request.Request, deleteBucketAnalyticsConfigurationOutput *s3.DeleteBucketAnalyticsConfigurationOutput) *S3API_DeleteBucketAnalyticsConfigurationRequest_Call { + _c.Call.Return(request1, deleteBucketAnalyticsConfigurationOutput) + return _c +} + +func (_c *S3API_DeleteBucketAnalyticsConfigurationRequest_Call) RunAndReturn(run func(deleteBucketAnalyticsConfigurationInput *s3.DeleteBucketAnalyticsConfigurationInput) (*request.Request, *s3.DeleteBucketAnalyticsConfigurationOutput)) *S3API_DeleteBucketAnalyticsConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketAnalyticsConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketAnalyticsConfigurationWithContext(v aws.Context, deleteBucketAnalyticsConfigurationInput *s3.DeleteBucketAnalyticsConfigurationInput, options ...request.Option) (*s3.DeleteBucketAnalyticsConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteBucketAnalyticsConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, deleteBucketAnalyticsConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketAnalyticsConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeleteBucketAnalyticsConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketAnalyticsConfigurationInput, ...request.Option) (*s3.DeleteBucketAnalyticsConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketAnalyticsConfigurationInput, ...request.Option) (*s3.DeleteBucketAnalyticsConfigurationOutput, error)); ok { + return returnFunc(v, deleteBucketAnalyticsConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketAnalyticsConfigurationInput, ...request.Option) *s3.DeleteBucketAnalyticsConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketAnalyticsConfigurationInput, ...request.Option) *s3.DeleteBucketAnalyticsConfigurationOutput); ok { + r0 = returnFunc(v, deleteBucketAnalyticsConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketAnalyticsConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketAnalyticsConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketAnalyticsConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteBucketAnalyticsConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketCors provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketCors(_a0 *s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteBucketAnalyticsConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketAnalyticsConfigurationWithContext' +type S3API_DeleteBucketAnalyticsConfigurationWithContext_Call struct { + *mock.Call +} + +// DeleteBucketAnalyticsConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteBucketAnalyticsConfigurationInput *s3.DeleteBucketAnalyticsConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteBucketAnalyticsConfigurationWithContext(v interface{}, deleteBucketAnalyticsConfigurationInput interface{}, options ...interface{}) *S3API_DeleteBucketAnalyticsConfigurationWithContext_Call { + return &S3API_DeleteBucketAnalyticsConfigurationWithContext_Call{Call: _e.mock.On("DeleteBucketAnalyticsConfigurationWithContext", + append([]interface{}{v, deleteBucketAnalyticsConfigurationInput}, options...)...)} +} + +func (_c *S3API_DeleteBucketAnalyticsConfigurationWithContext_Call) Run(run func(v aws.Context, deleteBucketAnalyticsConfigurationInput *s3.DeleteBucketAnalyticsConfigurationInput, options ...request.Option)) *S3API_DeleteBucketAnalyticsConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteBucketAnalyticsConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteBucketAnalyticsConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketAnalyticsConfigurationWithContext_Call) Return(deleteBucketAnalyticsConfigurationOutput *s3.DeleteBucketAnalyticsConfigurationOutput, err error) *S3API_DeleteBucketAnalyticsConfigurationWithContext_Call { + _c.Call.Return(deleteBucketAnalyticsConfigurationOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketAnalyticsConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, deleteBucketAnalyticsConfigurationInput *s3.DeleteBucketAnalyticsConfigurationInput, options ...request.Option) (*s3.DeleteBucketAnalyticsConfigurationOutput, error)) *S3API_DeleteBucketAnalyticsConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketCors provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketCors(deleteBucketCorsInput *s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error) { + ret := _mock.Called(deleteBucketCorsInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketCors") + } var r0 *s3.DeleteBucketCorsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error)); ok { + return returnFunc(deleteBucketCorsInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketCorsInput) *s3.DeleteBucketCorsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketCorsInput) *s3.DeleteBucketCorsOutput); ok { + r0 = returnFunc(deleteBucketCorsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketCorsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketCorsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketCorsInput) error); ok { + r1 = returnFunc(deleteBucketCorsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketCorsRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketCorsRequest(_a0 *s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput) { - ret := _m.Called(_a0) +// S3API_DeleteBucketCors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketCors' +type S3API_DeleteBucketCors_Call struct { + *mock.Call +} + +// DeleteBucketCors is a helper method to define mock.On call +// - deleteBucketCorsInput *s3.DeleteBucketCorsInput +func (_e *S3API_Expecter) DeleteBucketCors(deleteBucketCorsInput interface{}) *S3API_DeleteBucketCors_Call { + return &S3API_DeleteBucketCors_Call{Call: _e.mock.On("DeleteBucketCors", deleteBucketCorsInput)} +} + +func (_c *S3API_DeleteBucketCors_Call) Run(run func(deleteBucketCorsInput *s3.DeleteBucketCorsInput)) *S3API_DeleteBucketCors_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketCorsInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketCorsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketCors_Call) Return(deleteBucketCorsOutput *s3.DeleteBucketCorsOutput, err error) *S3API_DeleteBucketCors_Call { + _c.Call.Return(deleteBucketCorsOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketCors_Call) RunAndReturn(run func(deleteBucketCorsInput *s3.DeleteBucketCorsInput) (*s3.DeleteBucketCorsOutput, error)) *S3API_DeleteBucketCors_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketCorsRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketCorsRequest(deleteBucketCorsInput *s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput) { + ret := _mock.Called(deleteBucketCorsInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketCorsRequest") + } var r0 *request.Request var r1 *s3.DeleteBucketCorsOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput)); ok { + return returnFunc(deleteBucketCorsInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketCorsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketCorsInput) *request.Request); ok { + r0 = returnFunc(deleteBucketCorsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketCorsInput) *s3.DeleteBucketCorsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketCorsInput) *s3.DeleteBucketCorsOutput); ok { + r1 = returnFunc(deleteBucketCorsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteBucketCorsOutput) } } - return r0, r1 } -// DeleteBucketCorsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteBucketCorsWithContext(_a0 context.Context, _a1 *s3.DeleteBucketCorsInput, _a2 ...request.Option) (*s3.DeleteBucketCorsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeleteBucketCorsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketCorsRequest' +type S3API_DeleteBucketCorsRequest_Call struct { + *mock.Call +} + +// DeleteBucketCorsRequest is a helper method to define mock.On call +// - deleteBucketCorsInput *s3.DeleteBucketCorsInput +func (_e *S3API_Expecter) DeleteBucketCorsRequest(deleteBucketCorsInput interface{}) *S3API_DeleteBucketCorsRequest_Call { + return &S3API_DeleteBucketCorsRequest_Call{Call: _e.mock.On("DeleteBucketCorsRequest", deleteBucketCorsInput)} +} + +func (_c *S3API_DeleteBucketCorsRequest_Call) Run(run func(deleteBucketCorsInput *s3.DeleteBucketCorsInput)) *S3API_DeleteBucketCorsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketCorsInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketCorsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketCorsRequest_Call) Return(request1 *request.Request, deleteBucketCorsOutput *s3.DeleteBucketCorsOutput) *S3API_DeleteBucketCorsRequest_Call { + _c.Call.Return(request1, deleteBucketCorsOutput) + return _c +} + +func (_c *S3API_DeleteBucketCorsRequest_Call) RunAndReturn(run func(deleteBucketCorsInput *s3.DeleteBucketCorsInput) (*request.Request, *s3.DeleteBucketCorsOutput)) *S3API_DeleteBucketCorsRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketCorsWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketCorsWithContext(v aws.Context, deleteBucketCorsInput *s3.DeleteBucketCorsInput, options ...request.Option) (*s3.DeleteBucketCorsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteBucketCorsInput, options) + } else { + tmpRet = _mock.Called(v, deleteBucketCorsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketCorsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeleteBucketCorsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketCorsInput, ...request.Option) (*s3.DeleteBucketCorsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketCorsInput, ...request.Option) (*s3.DeleteBucketCorsOutput, error)); ok { + return returnFunc(v, deleteBucketCorsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketCorsInput, ...request.Option) *s3.DeleteBucketCorsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketCorsInput, ...request.Option) *s3.DeleteBucketCorsOutput); ok { + r0 = returnFunc(v, deleteBucketCorsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketCorsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketCorsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketCorsInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteBucketCorsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketEncryption provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketEncryption(_a0 *s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteBucketCorsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketCorsWithContext' +type S3API_DeleteBucketCorsWithContext_Call struct { + *mock.Call +} + +// DeleteBucketCorsWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteBucketCorsInput *s3.DeleteBucketCorsInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteBucketCorsWithContext(v interface{}, deleteBucketCorsInput interface{}, options ...interface{}) *S3API_DeleteBucketCorsWithContext_Call { + return &S3API_DeleteBucketCorsWithContext_Call{Call: _e.mock.On("DeleteBucketCorsWithContext", + append([]interface{}{v, deleteBucketCorsInput}, options...)...)} +} + +func (_c *S3API_DeleteBucketCorsWithContext_Call) Run(run func(v aws.Context, deleteBucketCorsInput *s3.DeleteBucketCorsInput, options ...request.Option)) *S3API_DeleteBucketCorsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteBucketCorsInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteBucketCorsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketCorsWithContext_Call) Return(deleteBucketCorsOutput *s3.DeleteBucketCorsOutput, err error) *S3API_DeleteBucketCorsWithContext_Call { + _c.Call.Return(deleteBucketCorsOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketCorsWithContext_Call) RunAndReturn(run func(v aws.Context, deleteBucketCorsInput *s3.DeleteBucketCorsInput, options ...request.Option) (*s3.DeleteBucketCorsOutput, error)) *S3API_DeleteBucketCorsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketEncryption provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketEncryption(deleteBucketEncryptionInput *s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error) { + ret := _mock.Called(deleteBucketEncryptionInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketEncryption") + } var r0 *s3.DeleteBucketEncryptionOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error)); ok { + return returnFunc(deleteBucketEncryptionInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketEncryptionInput) *s3.DeleteBucketEncryptionOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketEncryptionInput) *s3.DeleteBucketEncryptionOutput); ok { + r0 = returnFunc(deleteBucketEncryptionInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketEncryptionOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketEncryptionInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketEncryptionInput) error); ok { + r1 = returnFunc(deleteBucketEncryptionInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketEncryptionRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketEncryptionRequest(_a0 *s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput) { - ret := _m.Called(_a0) +// S3API_DeleteBucketEncryption_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketEncryption' +type S3API_DeleteBucketEncryption_Call struct { + *mock.Call +} + +// DeleteBucketEncryption is a helper method to define mock.On call +// - deleteBucketEncryptionInput *s3.DeleteBucketEncryptionInput +func (_e *S3API_Expecter) DeleteBucketEncryption(deleteBucketEncryptionInput interface{}) *S3API_DeleteBucketEncryption_Call { + return &S3API_DeleteBucketEncryption_Call{Call: _e.mock.On("DeleteBucketEncryption", deleteBucketEncryptionInput)} +} + +func (_c *S3API_DeleteBucketEncryption_Call) Run(run func(deleteBucketEncryptionInput *s3.DeleteBucketEncryptionInput)) *S3API_DeleteBucketEncryption_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketEncryptionInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketEncryptionInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketEncryption_Call) Return(deleteBucketEncryptionOutput *s3.DeleteBucketEncryptionOutput, err error) *S3API_DeleteBucketEncryption_Call { + _c.Call.Return(deleteBucketEncryptionOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketEncryption_Call) RunAndReturn(run func(deleteBucketEncryptionInput *s3.DeleteBucketEncryptionInput) (*s3.DeleteBucketEncryptionOutput, error)) *S3API_DeleteBucketEncryption_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketEncryptionRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketEncryptionRequest(deleteBucketEncryptionInput *s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput) { + ret := _mock.Called(deleteBucketEncryptionInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketEncryptionRequest") + } var r0 *request.Request var r1 *s3.DeleteBucketEncryptionOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput)); ok { + return returnFunc(deleteBucketEncryptionInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketEncryptionInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketEncryptionInput) *request.Request); ok { + r0 = returnFunc(deleteBucketEncryptionInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketEncryptionInput) *s3.DeleteBucketEncryptionOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketEncryptionInput) *s3.DeleteBucketEncryptionOutput); ok { + r1 = returnFunc(deleteBucketEncryptionInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteBucketEncryptionOutput) } } - return r0, r1 } -// DeleteBucketEncryptionWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteBucketEncryptionWithContext(_a0 context.Context, _a1 *s3.DeleteBucketEncryptionInput, _a2 ...request.Option) (*s3.DeleteBucketEncryptionOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeleteBucketEncryptionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketEncryptionRequest' +type S3API_DeleteBucketEncryptionRequest_Call struct { + *mock.Call +} + +// DeleteBucketEncryptionRequest is a helper method to define mock.On call +// - deleteBucketEncryptionInput *s3.DeleteBucketEncryptionInput +func (_e *S3API_Expecter) DeleteBucketEncryptionRequest(deleteBucketEncryptionInput interface{}) *S3API_DeleteBucketEncryptionRequest_Call { + return &S3API_DeleteBucketEncryptionRequest_Call{Call: _e.mock.On("DeleteBucketEncryptionRequest", deleteBucketEncryptionInput)} +} + +func (_c *S3API_DeleteBucketEncryptionRequest_Call) Run(run func(deleteBucketEncryptionInput *s3.DeleteBucketEncryptionInput)) *S3API_DeleteBucketEncryptionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketEncryptionInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketEncryptionInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketEncryptionRequest_Call) Return(request1 *request.Request, deleteBucketEncryptionOutput *s3.DeleteBucketEncryptionOutput) *S3API_DeleteBucketEncryptionRequest_Call { + _c.Call.Return(request1, deleteBucketEncryptionOutput) + return _c +} + +func (_c *S3API_DeleteBucketEncryptionRequest_Call) RunAndReturn(run func(deleteBucketEncryptionInput *s3.DeleteBucketEncryptionInput) (*request.Request, *s3.DeleteBucketEncryptionOutput)) *S3API_DeleteBucketEncryptionRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketEncryptionWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketEncryptionWithContext(v aws.Context, deleteBucketEncryptionInput *s3.DeleteBucketEncryptionInput, options ...request.Option) (*s3.DeleteBucketEncryptionOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteBucketEncryptionInput, options) + } else { + tmpRet = _mock.Called(v, deleteBucketEncryptionInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketEncryptionWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeleteBucketEncryptionOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketEncryptionInput, ...request.Option) (*s3.DeleteBucketEncryptionOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketEncryptionInput, ...request.Option) (*s3.DeleteBucketEncryptionOutput, error)); ok { + return returnFunc(v, deleteBucketEncryptionInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketEncryptionInput, ...request.Option) *s3.DeleteBucketEncryptionOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketEncryptionInput, ...request.Option) *s3.DeleteBucketEncryptionOutput); ok { + r0 = returnFunc(v, deleteBucketEncryptionInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketEncryptionOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketEncryptionInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketEncryptionInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteBucketEncryptionInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketIntelligentTieringConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketIntelligentTieringConfiguration(_a0 *s3.DeleteBucketIntelligentTieringConfigurationInput) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteBucketEncryptionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketEncryptionWithContext' +type S3API_DeleteBucketEncryptionWithContext_Call struct { + *mock.Call +} + +// DeleteBucketEncryptionWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteBucketEncryptionInput *s3.DeleteBucketEncryptionInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteBucketEncryptionWithContext(v interface{}, deleteBucketEncryptionInput interface{}, options ...interface{}) *S3API_DeleteBucketEncryptionWithContext_Call { + return &S3API_DeleteBucketEncryptionWithContext_Call{Call: _e.mock.On("DeleteBucketEncryptionWithContext", + append([]interface{}{v, deleteBucketEncryptionInput}, options...)...)} +} + +func (_c *S3API_DeleteBucketEncryptionWithContext_Call) Run(run func(v aws.Context, deleteBucketEncryptionInput *s3.DeleteBucketEncryptionInput, options ...request.Option)) *S3API_DeleteBucketEncryptionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteBucketEncryptionInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteBucketEncryptionInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketEncryptionWithContext_Call) Return(deleteBucketEncryptionOutput *s3.DeleteBucketEncryptionOutput, err error) *S3API_DeleteBucketEncryptionWithContext_Call { + _c.Call.Return(deleteBucketEncryptionOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketEncryptionWithContext_Call) RunAndReturn(run func(v aws.Context, deleteBucketEncryptionInput *s3.DeleteBucketEncryptionInput, options ...request.Option) (*s3.DeleteBucketEncryptionOutput, error)) *S3API_DeleteBucketEncryptionWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketIntelligentTieringConfiguration provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketIntelligentTieringConfiguration(deleteBucketIntelligentTieringConfigurationInput *s3.DeleteBucketIntelligentTieringConfigurationInput) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error) { + ret := _mock.Called(deleteBucketIntelligentTieringConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketIntelligentTieringConfiguration") + } var r0 *s3.DeleteBucketIntelligentTieringConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error)); ok { + return returnFunc(deleteBucketIntelligentTieringConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) *s3.DeleteBucketIntelligentTieringConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) *s3.DeleteBucketIntelligentTieringConfigurationOutput); ok { + r0 = returnFunc(deleteBucketIntelligentTieringConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketIntelligentTieringConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) error); ok { + r1 = returnFunc(deleteBucketIntelligentTieringConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketIntelligentTieringConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketIntelligentTieringConfigurationRequest(_a0 *s3.DeleteBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.DeleteBucketIntelligentTieringConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_DeleteBucketIntelligentTieringConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketIntelligentTieringConfiguration' +type S3API_DeleteBucketIntelligentTieringConfiguration_Call struct { + *mock.Call +} + +// DeleteBucketIntelligentTieringConfiguration is a helper method to define mock.On call +// - deleteBucketIntelligentTieringConfigurationInput *s3.DeleteBucketIntelligentTieringConfigurationInput +func (_e *S3API_Expecter) DeleteBucketIntelligentTieringConfiguration(deleteBucketIntelligentTieringConfigurationInput interface{}) *S3API_DeleteBucketIntelligentTieringConfiguration_Call { + return &S3API_DeleteBucketIntelligentTieringConfiguration_Call{Call: _e.mock.On("DeleteBucketIntelligentTieringConfiguration", deleteBucketIntelligentTieringConfigurationInput)} +} + +func (_c *S3API_DeleteBucketIntelligentTieringConfiguration_Call) Run(run func(deleteBucketIntelligentTieringConfigurationInput *s3.DeleteBucketIntelligentTieringConfigurationInput)) *S3API_DeleteBucketIntelligentTieringConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketIntelligentTieringConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketIntelligentTieringConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketIntelligentTieringConfiguration_Call) Return(deleteBucketIntelligentTieringConfigurationOutput *s3.DeleteBucketIntelligentTieringConfigurationOutput, err error) *S3API_DeleteBucketIntelligentTieringConfiguration_Call { + _c.Call.Return(deleteBucketIntelligentTieringConfigurationOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketIntelligentTieringConfiguration_Call) RunAndReturn(run func(deleteBucketIntelligentTieringConfigurationInput *s3.DeleteBucketIntelligentTieringConfigurationInput) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error)) *S3API_DeleteBucketIntelligentTieringConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketIntelligentTieringConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketIntelligentTieringConfigurationRequest(deleteBucketIntelligentTieringConfigurationInput *s3.DeleteBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.DeleteBucketIntelligentTieringConfigurationOutput) { + ret := _mock.Called(deleteBucketIntelligentTieringConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketIntelligentTieringConfigurationRequest") + } var r0 *request.Request var r1 *s3.DeleteBucketIntelligentTieringConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.DeleteBucketIntelligentTieringConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.DeleteBucketIntelligentTieringConfigurationOutput)); ok { + return returnFunc(deleteBucketIntelligentTieringConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) *request.Request); ok { + r0 = returnFunc(deleteBucketIntelligentTieringConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) *s3.DeleteBucketIntelligentTieringConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketIntelligentTieringConfigurationInput) *s3.DeleteBucketIntelligentTieringConfigurationOutput); ok { + r1 = returnFunc(deleteBucketIntelligentTieringConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteBucketIntelligentTieringConfigurationOutput) } } - return r0, r1 } -// DeleteBucketIntelligentTieringConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteBucketIntelligentTieringConfigurationWithContext(_a0 context.Context, _a1 *s3.DeleteBucketIntelligentTieringConfigurationInput, _a2 ...request.Option) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] - } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) +// S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketIntelligentTieringConfigurationRequest' +type S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call struct { + *mock.Call +} - var r0 *s3.DeleteBucketIntelligentTieringConfigurationOutput - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) - } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketIntelligentTieringConfigurationInput, ...request.Option) *s3.DeleteBucketIntelligentTieringConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*s3.DeleteBucketIntelligentTieringConfigurationOutput) +// DeleteBucketIntelligentTieringConfigurationRequest is a helper method to define mock.On call +// - deleteBucketIntelligentTieringConfigurationInput *s3.DeleteBucketIntelligentTieringConfigurationInput +func (_e *S3API_Expecter) DeleteBucketIntelligentTieringConfigurationRequest(deleteBucketIntelligentTieringConfigurationInput interface{}) *S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call { + return &S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call{Call: _e.mock.On("DeleteBucketIntelligentTieringConfigurationRequest", deleteBucketIntelligentTieringConfigurationInput)} +} + +func (_c *S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call) Run(run func(deleteBucketIntelligentTieringConfigurationInput *s3.DeleteBucketIntelligentTieringConfigurationInput)) *S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketIntelligentTieringConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketIntelligentTieringConfigurationInput) } - } + run( + arg0, + ) + }) + return _c +} - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketIntelligentTieringConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) - } else { - r1 = ret.Error(1) +func (_c *S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call) Return(request1 *request.Request, deleteBucketIntelligentTieringConfigurationOutput *s3.DeleteBucketIntelligentTieringConfigurationOutput) *S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call { + _c.Call.Return(request1, deleteBucketIntelligentTieringConfigurationOutput) + return _c +} + +func (_c *S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call) RunAndReturn(run func(deleteBucketIntelligentTieringConfigurationInput *s3.DeleteBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.DeleteBucketIntelligentTieringConfigurationOutput)) *S3API_DeleteBucketIntelligentTieringConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketIntelligentTieringConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketIntelligentTieringConfigurationWithContext(v aws.Context, deleteBucketIntelligentTieringConfigurationInput *s3.DeleteBucketIntelligentTieringConfigurationInput, options ...request.Option) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteBucketIntelligentTieringConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, deleteBucketIntelligentTieringConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketIntelligentTieringConfigurationWithContext") } + var r0 *s3.DeleteBucketIntelligentTieringConfigurationOutput + var r1 error + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error)); ok { + return returnFunc(v, deleteBucketIntelligentTieringConfigurationInput, options...) + } + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketIntelligentTieringConfigurationInput, ...request.Option) *s3.DeleteBucketIntelligentTieringConfigurationOutput); ok { + r0 = returnFunc(v, deleteBucketIntelligentTieringConfigurationInput, options...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*s3.DeleteBucketIntelligentTieringConfigurationOutput) + } + } + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketIntelligentTieringConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteBucketIntelligentTieringConfigurationInput, options...) + } else { + r1 = ret.Error(1) + } return r0, r1 } -// DeleteBucketInventoryConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketInventoryConfiguration(_a0 *s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketIntelligentTieringConfigurationWithContext' +type S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call struct { + *mock.Call +} + +// DeleteBucketIntelligentTieringConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteBucketIntelligentTieringConfigurationInput *s3.DeleteBucketIntelligentTieringConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteBucketIntelligentTieringConfigurationWithContext(v interface{}, deleteBucketIntelligentTieringConfigurationInput interface{}, options ...interface{}) *S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call { + return &S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call{Call: _e.mock.On("DeleteBucketIntelligentTieringConfigurationWithContext", + append([]interface{}{v, deleteBucketIntelligentTieringConfigurationInput}, options...)...)} +} + +func (_c *S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call) Run(run func(v aws.Context, deleteBucketIntelligentTieringConfigurationInput *s3.DeleteBucketIntelligentTieringConfigurationInput, options ...request.Option)) *S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteBucketIntelligentTieringConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteBucketIntelligentTieringConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call) Return(deleteBucketIntelligentTieringConfigurationOutput *s3.DeleteBucketIntelligentTieringConfigurationOutput, err error) *S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call { + _c.Call.Return(deleteBucketIntelligentTieringConfigurationOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, deleteBucketIntelligentTieringConfigurationInput *s3.DeleteBucketIntelligentTieringConfigurationInput, options ...request.Option) (*s3.DeleteBucketIntelligentTieringConfigurationOutput, error)) *S3API_DeleteBucketIntelligentTieringConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketInventoryConfiguration provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketInventoryConfiguration(deleteBucketInventoryConfigurationInput *s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error) { + ret := _mock.Called(deleteBucketInventoryConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketInventoryConfiguration") + } var r0 *s3.DeleteBucketInventoryConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error)); ok { + return returnFunc(deleteBucketInventoryConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInventoryConfigurationInput) *s3.DeleteBucketInventoryConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketInventoryConfigurationInput) *s3.DeleteBucketInventoryConfigurationOutput); ok { + r0 = returnFunc(deleteBucketInventoryConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketInventoryConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketInventoryConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketInventoryConfigurationInput) error); ok { + r1 = returnFunc(deleteBucketInventoryConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketInventoryConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketInventoryConfigurationRequest(_a0 *s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_DeleteBucketInventoryConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketInventoryConfiguration' +type S3API_DeleteBucketInventoryConfiguration_Call struct { + *mock.Call +} + +// DeleteBucketInventoryConfiguration is a helper method to define mock.On call +// - deleteBucketInventoryConfigurationInput *s3.DeleteBucketInventoryConfigurationInput +func (_e *S3API_Expecter) DeleteBucketInventoryConfiguration(deleteBucketInventoryConfigurationInput interface{}) *S3API_DeleteBucketInventoryConfiguration_Call { + return &S3API_DeleteBucketInventoryConfiguration_Call{Call: _e.mock.On("DeleteBucketInventoryConfiguration", deleteBucketInventoryConfigurationInput)} +} + +func (_c *S3API_DeleteBucketInventoryConfiguration_Call) Run(run func(deleteBucketInventoryConfigurationInput *s3.DeleteBucketInventoryConfigurationInput)) *S3API_DeleteBucketInventoryConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketInventoryConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketInventoryConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketInventoryConfiguration_Call) Return(deleteBucketInventoryConfigurationOutput *s3.DeleteBucketInventoryConfigurationOutput, err error) *S3API_DeleteBucketInventoryConfiguration_Call { + _c.Call.Return(deleteBucketInventoryConfigurationOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketInventoryConfiguration_Call) RunAndReturn(run func(deleteBucketInventoryConfigurationInput *s3.DeleteBucketInventoryConfigurationInput) (*s3.DeleteBucketInventoryConfigurationOutput, error)) *S3API_DeleteBucketInventoryConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketInventoryConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketInventoryConfigurationRequest(deleteBucketInventoryConfigurationInput *s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput) { + ret := _mock.Called(deleteBucketInventoryConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketInventoryConfigurationRequest") + } var r0 *request.Request var r1 *s3.DeleteBucketInventoryConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput)); ok { + return returnFunc(deleteBucketInventoryConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInventoryConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketInventoryConfigurationInput) *request.Request); ok { + r0 = returnFunc(deleteBucketInventoryConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketInventoryConfigurationInput) *s3.DeleteBucketInventoryConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketInventoryConfigurationInput) *s3.DeleteBucketInventoryConfigurationOutput); ok { + r1 = returnFunc(deleteBucketInventoryConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteBucketInventoryConfigurationOutput) } } - return r0, r1 } -// DeleteBucketInventoryConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteBucketInventoryConfigurationWithContext(_a0 context.Context, _a1 *s3.DeleteBucketInventoryConfigurationInput, _a2 ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeleteBucketInventoryConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketInventoryConfigurationRequest' +type S3API_DeleteBucketInventoryConfigurationRequest_Call struct { + *mock.Call +} + +// DeleteBucketInventoryConfigurationRequest is a helper method to define mock.On call +// - deleteBucketInventoryConfigurationInput *s3.DeleteBucketInventoryConfigurationInput +func (_e *S3API_Expecter) DeleteBucketInventoryConfigurationRequest(deleteBucketInventoryConfigurationInput interface{}) *S3API_DeleteBucketInventoryConfigurationRequest_Call { + return &S3API_DeleteBucketInventoryConfigurationRequest_Call{Call: _e.mock.On("DeleteBucketInventoryConfigurationRequest", deleteBucketInventoryConfigurationInput)} +} + +func (_c *S3API_DeleteBucketInventoryConfigurationRequest_Call) Run(run func(deleteBucketInventoryConfigurationInput *s3.DeleteBucketInventoryConfigurationInput)) *S3API_DeleteBucketInventoryConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketInventoryConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketInventoryConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketInventoryConfigurationRequest_Call) Return(request1 *request.Request, deleteBucketInventoryConfigurationOutput *s3.DeleteBucketInventoryConfigurationOutput) *S3API_DeleteBucketInventoryConfigurationRequest_Call { + _c.Call.Return(request1, deleteBucketInventoryConfigurationOutput) + return _c +} + +func (_c *S3API_DeleteBucketInventoryConfigurationRequest_Call) RunAndReturn(run func(deleteBucketInventoryConfigurationInput *s3.DeleteBucketInventoryConfigurationInput) (*request.Request, *s3.DeleteBucketInventoryConfigurationOutput)) *S3API_DeleteBucketInventoryConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketInventoryConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketInventoryConfigurationWithContext(v aws.Context, deleteBucketInventoryConfigurationInput *s3.DeleteBucketInventoryConfigurationInput, options ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteBucketInventoryConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, deleteBucketInventoryConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketInventoryConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeleteBucketInventoryConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketInventoryConfigurationInput, ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketInventoryConfigurationInput, ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error)); ok { + return returnFunc(v, deleteBucketInventoryConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketInventoryConfigurationInput, ...request.Option) *s3.DeleteBucketInventoryConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketInventoryConfigurationInput, ...request.Option) *s3.DeleteBucketInventoryConfigurationOutput); ok { + r0 = returnFunc(v, deleteBucketInventoryConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketInventoryConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketInventoryConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketInventoryConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteBucketInventoryConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketLifecycle provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketLifecycle(_a0 *s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteBucketInventoryConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketInventoryConfigurationWithContext' +type S3API_DeleteBucketInventoryConfigurationWithContext_Call struct { + *mock.Call +} + +// DeleteBucketInventoryConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteBucketInventoryConfigurationInput *s3.DeleteBucketInventoryConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteBucketInventoryConfigurationWithContext(v interface{}, deleteBucketInventoryConfigurationInput interface{}, options ...interface{}) *S3API_DeleteBucketInventoryConfigurationWithContext_Call { + return &S3API_DeleteBucketInventoryConfigurationWithContext_Call{Call: _e.mock.On("DeleteBucketInventoryConfigurationWithContext", + append([]interface{}{v, deleteBucketInventoryConfigurationInput}, options...)...)} +} + +func (_c *S3API_DeleteBucketInventoryConfigurationWithContext_Call) Run(run func(v aws.Context, deleteBucketInventoryConfigurationInput *s3.DeleteBucketInventoryConfigurationInput, options ...request.Option)) *S3API_DeleteBucketInventoryConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteBucketInventoryConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteBucketInventoryConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketInventoryConfigurationWithContext_Call) Return(deleteBucketInventoryConfigurationOutput *s3.DeleteBucketInventoryConfigurationOutput, err error) *S3API_DeleteBucketInventoryConfigurationWithContext_Call { + _c.Call.Return(deleteBucketInventoryConfigurationOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketInventoryConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, deleteBucketInventoryConfigurationInput *s3.DeleteBucketInventoryConfigurationInput, options ...request.Option) (*s3.DeleteBucketInventoryConfigurationOutput, error)) *S3API_DeleteBucketInventoryConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketLifecycle provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketLifecycle(deleteBucketLifecycleInput *s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error) { + ret := _mock.Called(deleteBucketLifecycleInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketLifecycle") + } var r0 *s3.DeleteBucketLifecycleOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error)); ok { + return returnFunc(deleteBucketLifecycleInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketLifecycleInput) *s3.DeleteBucketLifecycleOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketLifecycleInput) *s3.DeleteBucketLifecycleOutput); ok { + r0 = returnFunc(deleteBucketLifecycleInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketLifecycleOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketLifecycleInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketLifecycleInput) error); ok { + r1 = returnFunc(deleteBucketLifecycleInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketLifecycleRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketLifecycleRequest(_a0 *s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput) { - ret := _m.Called(_a0) +// S3API_DeleteBucketLifecycle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketLifecycle' +type S3API_DeleteBucketLifecycle_Call struct { + *mock.Call +} + +// DeleteBucketLifecycle is a helper method to define mock.On call +// - deleteBucketLifecycleInput *s3.DeleteBucketLifecycleInput +func (_e *S3API_Expecter) DeleteBucketLifecycle(deleteBucketLifecycleInput interface{}) *S3API_DeleteBucketLifecycle_Call { + return &S3API_DeleteBucketLifecycle_Call{Call: _e.mock.On("DeleteBucketLifecycle", deleteBucketLifecycleInput)} +} + +func (_c *S3API_DeleteBucketLifecycle_Call) Run(run func(deleteBucketLifecycleInput *s3.DeleteBucketLifecycleInput)) *S3API_DeleteBucketLifecycle_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketLifecycleInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketLifecycleInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketLifecycle_Call) Return(deleteBucketLifecycleOutput *s3.DeleteBucketLifecycleOutput, err error) *S3API_DeleteBucketLifecycle_Call { + _c.Call.Return(deleteBucketLifecycleOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketLifecycle_Call) RunAndReturn(run func(deleteBucketLifecycleInput *s3.DeleteBucketLifecycleInput) (*s3.DeleteBucketLifecycleOutput, error)) *S3API_DeleteBucketLifecycle_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketLifecycleRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketLifecycleRequest(deleteBucketLifecycleInput *s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput) { + ret := _mock.Called(deleteBucketLifecycleInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketLifecycleRequest") + } var r0 *request.Request var r1 *s3.DeleteBucketLifecycleOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput)); ok { + return returnFunc(deleteBucketLifecycleInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketLifecycleInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketLifecycleInput) *request.Request); ok { + r0 = returnFunc(deleteBucketLifecycleInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketLifecycleInput) *s3.DeleteBucketLifecycleOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketLifecycleInput) *s3.DeleteBucketLifecycleOutput); ok { + r1 = returnFunc(deleteBucketLifecycleInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteBucketLifecycleOutput) } } - return r0, r1 } -// DeleteBucketLifecycleWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteBucketLifecycleWithContext(_a0 context.Context, _a1 *s3.DeleteBucketLifecycleInput, _a2 ...request.Option) (*s3.DeleteBucketLifecycleOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeleteBucketLifecycleRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketLifecycleRequest' +type S3API_DeleteBucketLifecycleRequest_Call struct { + *mock.Call +} + +// DeleteBucketLifecycleRequest is a helper method to define mock.On call +// - deleteBucketLifecycleInput *s3.DeleteBucketLifecycleInput +func (_e *S3API_Expecter) DeleteBucketLifecycleRequest(deleteBucketLifecycleInput interface{}) *S3API_DeleteBucketLifecycleRequest_Call { + return &S3API_DeleteBucketLifecycleRequest_Call{Call: _e.mock.On("DeleteBucketLifecycleRequest", deleteBucketLifecycleInput)} +} + +func (_c *S3API_DeleteBucketLifecycleRequest_Call) Run(run func(deleteBucketLifecycleInput *s3.DeleteBucketLifecycleInput)) *S3API_DeleteBucketLifecycleRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketLifecycleInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketLifecycleInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketLifecycleRequest_Call) Return(request1 *request.Request, deleteBucketLifecycleOutput *s3.DeleteBucketLifecycleOutput) *S3API_DeleteBucketLifecycleRequest_Call { + _c.Call.Return(request1, deleteBucketLifecycleOutput) + return _c +} + +func (_c *S3API_DeleteBucketLifecycleRequest_Call) RunAndReturn(run func(deleteBucketLifecycleInput *s3.DeleteBucketLifecycleInput) (*request.Request, *s3.DeleteBucketLifecycleOutput)) *S3API_DeleteBucketLifecycleRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketLifecycleWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketLifecycleWithContext(v aws.Context, deleteBucketLifecycleInput *s3.DeleteBucketLifecycleInput, options ...request.Option) (*s3.DeleteBucketLifecycleOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteBucketLifecycleInput, options) + } else { + tmpRet = _mock.Called(v, deleteBucketLifecycleInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketLifecycleWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeleteBucketLifecycleOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketLifecycleInput, ...request.Option) (*s3.DeleteBucketLifecycleOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketLifecycleInput, ...request.Option) (*s3.DeleteBucketLifecycleOutput, error)); ok { + return returnFunc(v, deleteBucketLifecycleInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketLifecycleInput, ...request.Option) *s3.DeleteBucketLifecycleOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketLifecycleInput, ...request.Option) *s3.DeleteBucketLifecycleOutput); ok { + r0 = returnFunc(v, deleteBucketLifecycleInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketLifecycleOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketLifecycleInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketLifecycleInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteBucketLifecycleInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketMetricsConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketMetricsConfiguration(_a0 *s3.DeleteBucketMetricsConfigurationInput) (*s3.DeleteBucketMetricsConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteBucketLifecycleWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketLifecycleWithContext' +type S3API_DeleteBucketLifecycleWithContext_Call struct { + *mock.Call +} + +// DeleteBucketLifecycleWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteBucketLifecycleInput *s3.DeleteBucketLifecycleInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteBucketLifecycleWithContext(v interface{}, deleteBucketLifecycleInput interface{}, options ...interface{}) *S3API_DeleteBucketLifecycleWithContext_Call { + return &S3API_DeleteBucketLifecycleWithContext_Call{Call: _e.mock.On("DeleteBucketLifecycleWithContext", + append([]interface{}{v, deleteBucketLifecycleInput}, options...)...)} +} + +func (_c *S3API_DeleteBucketLifecycleWithContext_Call) Run(run func(v aws.Context, deleteBucketLifecycleInput *s3.DeleteBucketLifecycleInput, options ...request.Option)) *S3API_DeleteBucketLifecycleWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteBucketLifecycleInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteBucketLifecycleInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketLifecycleWithContext_Call) Return(deleteBucketLifecycleOutput *s3.DeleteBucketLifecycleOutput, err error) *S3API_DeleteBucketLifecycleWithContext_Call { + _c.Call.Return(deleteBucketLifecycleOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketLifecycleWithContext_Call) RunAndReturn(run func(v aws.Context, deleteBucketLifecycleInput *s3.DeleteBucketLifecycleInput, options ...request.Option) (*s3.DeleteBucketLifecycleOutput, error)) *S3API_DeleteBucketLifecycleWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketMetricsConfiguration provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketMetricsConfiguration(deleteBucketMetricsConfigurationInput *s3.DeleteBucketMetricsConfigurationInput) (*s3.DeleteBucketMetricsConfigurationOutput, error) { + ret := _mock.Called(deleteBucketMetricsConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketMetricsConfiguration") + } var r0 *s3.DeleteBucketMetricsConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketMetricsConfigurationInput) (*s3.DeleteBucketMetricsConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketMetricsConfigurationInput) (*s3.DeleteBucketMetricsConfigurationOutput, error)); ok { + return returnFunc(deleteBucketMetricsConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketMetricsConfigurationInput) *s3.DeleteBucketMetricsConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketMetricsConfigurationInput) *s3.DeleteBucketMetricsConfigurationOutput); ok { + r0 = returnFunc(deleteBucketMetricsConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketMetricsConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketMetricsConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketMetricsConfigurationInput) error); ok { + r1 = returnFunc(deleteBucketMetricsConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketMetricsConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketMetricsConfigurationRequest(_a0 *s3.DeleteBucketMetricsConfigurationInput) (*request.Request, *s3.DeleteBucketMetricsConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_DeleteBucketMetricsConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketMetricsConfiguration' +type S3API_DeleteBucketMetricsConfiguration_Call struct { + *mock.Call +} + +// DeleteBucketMetricsConfiguration is a helper method to define mock.On call +// - deleteBucketMetricsConfigurationInput *s3.DeleteBucketMetricsConfigurationInput +func (_e *S3API_Expecter) DeleteBucketMetricsConfiguration(deleteBucketMetricsConfigurationInput interface{}) *S3API_DeleteBucketMetricsConfiguration_Call { + return &S3API_DeleteBucketMetricsConfiguration_Call{Call: _e.mock.On("DeleteBucketMetricsConfiguration", deleteBucketMetricsConfigurationInput)} +} + +func (_c *S3API_DeleteBucketMetricsConfiguration_Call) Run(run func(deleteBucketMetricsConfigurationInput *s3.DeleteBucketMetricsConfigurationInput)) *S3API_DeleteBucketMetricsConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketMetricsConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketMetricsConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketMetricsConfiguration_Call) Return(deleteBucketMetricsConfigurationOutput *s3.DeleteBucketMetricsConfigurationOutput, err error) *S3API_DeleteBucketMetricsConfiguration_Call { + _c.Call.Return(deleteBucketMetricsConfigurationOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketMetricsConfiguration_Call) RunAndReturn(run func(deleteBucketMetricsConfigurationInput *s3.DeleteBucketMetricsConfigurationInput) (*s3.DeleteBucketMetricsConfigurationOutput, error)) *S3API_DeleteBucketMetricsConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketMetricsConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketMetricsConfigurationRequest(deleteBucketMetricsConfigurationInput *s3.DeleteBucketMetricsConfigurationInput) (*request.Request, *s3.DeleteBucketMetricsConfigurationOutput) { + ret := _mock.Called(deleteBucketMetricsConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketMetricsConfigurationRequest") + } var r0 *request.Request var r1 *s3.DeleteBucketMetricsConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketMetricsConfigurationInput) (*request.Request, *s3.DeleteBucketMetricsConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketMetricsConfigurationInput) (*request.Request, *s3.DeleteBucketMetricsConfigurationOutput)); ok { + return returnFunc(deleteBucketMetricsConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketMetricsConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketMetricsConfigurationInput) *request.Request); ok { + r0 = returnFunc(deleteBucketMetricsConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketMetricsConfigurationInput) *s3.DeleteBucketMetricsConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketMetricsConfigurationInput) *s3.DeleteBucketMetricsConfigurationOutput); ok { + r1 = returnFunc(deleteBucketMetricsConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteBucketMetricsConfigurationOutput) } } - return r0, r1 } -// DeleteBucketMetricsConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteBucketMetricsConfigurationWithContext(_a0 context.Context, _a1 *s3.DeleteBucketMetricsConfigurationInput, _a2 ...request.Option) (*s3.DeleteBucketMetricsConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeleteBucketMetricsConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketMetricsConfigurationRequest' +type S3API_DeleteBucketMetricsConfigurationRequest_Call struct { + *mock.Call +} + +// DeleteBucketMetricsConfigurationRequest is a helper method to define mock.On call +// - deleteBucketMetricsConfigurationInput *s3.DeleteBucketMetricsConfigurationInput +func (_e *S3API_Expecter) DeleteBucketMetricsConfigurationRequest(deleteBucketMetricsConfigurationInput interface{}) *S3API_DeleteBucketMetricsConfigurationRequest_Call { + return &S3API_DeleteBucketMetricsConfigurationRequest_Call{Call: _e.mock.On("DeleteBucketMetricsConfigurationRequest", deleteBucketMetricsConfigurationInput)} +} + +func (_c *S3API_DeleteBucketMetricsConfigurationRequest_Call) Run(run func(deleteBucketMetricsConfigurationInput *s3.DeleteBucketMetricsConfigurationInput)) *S3API_DeleteBucketMetricsConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketMetricsConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketMetricsConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketMetricsConfigurationRequest_Call) Return(request1 *request.Request, deleteBucketMetricsConfigurationOutput *s3.DeleteBucketMetricsConfigurationOutput) *S3API_DeleteBucketMetricsConfigurationRequest_Call { + _c.Call.Return(request1, deleteBucketMetricsConfigurationOutput) + return _c +} + +func (_c *S3API_DeleteBucketMetricsConfigurationRequest_Call) RunAndReturn(run func(deleteBucketMetricsConfigurationInput *s3.DeleteBucketMetricsConfigurationInput) (*request.Request, *s3.DeleteBucketMetricsConfigurationOutput)) *S3API_DeleteBucketMetricsConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketMetricsConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketMetricsConfigurationWithContext(v aws.Context, deleteBucketMetricsConfigurationInput *s3.DeleteBucketMetricsConfigurationInput, options ...request.Option) (*s3.DeleteBucketMetricsConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteBucketMetricsConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, deleteBucketMetricsConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketMetricsConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeleteBucketMetricsConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketMetricsConfigurationInput, ...request.Option) (*s3.DeleteBucketMetricsConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketMetricsConfigurationInput, ...request.Option) (*s3.DeleteBucketMetricsConfigurationOutput, error)); ok { + return returnFunc(v, deleteBucketMetricsConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketMetricsConfigurationInput, ...request.Option) *s3.DeleteBucketMetricsConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketMetricsConfigurationInput, ...request.Option) *s3.DeleteBucketMetricsConfigurationOutput); ok { + r0 = returnFunc(v, deleteBucketMetricsConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketMetricsConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketMetricsConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketMetricsConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteBucketMetricsConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketOwnershipControls provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketOwnershipControls(_a0 *s3.DeleteBucketOwnershipControlsInput) (*s3.DeleteBucketOwnershipControlsOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteBucketMetricsConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketMetricsConfigurationWithContext' +type S3API_DeleteBucketMetricsConfigurationWithContext_Call struct { + *mock.Call +} + +// DeleteBucketMetricsConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteBucketMetricsConfigurationInput *s3.DeleteBucketMetricsConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteBucketMetricsConfigurationWithContext(v interface{}, deleteBucketMetricsConfigurationInput interface{}, options ...interface{}) *S3API_DeleteBucketMetricsConfigurationWithContext_Call { + return &S3API_DeleteBucketMetricsConfigurationWithContext_Call{Call: _e.mock.On("DeleteBucketMetricsConfigurationWithContext", + append([]interface{}{v, deleteBucketMetricsConfigurationInput}, options...)...)} +} + +func (_c *S3API_DeleteBucketMetricsConfigurationWithContext_Call) Run(run func(v aws.Context, deleteBucketMetricsConfigurationInput *s3.DeleteBucketMetricsConfigurationInput, options ...request.Option)) *S3API_DeleteBucketMetricsConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteBucketMetricsConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteBucketMetricsConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketMetricsConfigurationWithContext_Call) Return(deleteBucketMetricsConfigurationOutput *s3.DeleteBucketMetricsConfigurationOutput, err error) *S3API_DeleteBucketMetricsConfigurationWithContext_Call { + _c.Call.Return(deleteBucketMetricsConfigurationOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketMetricsConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, deleteBucketMetricsConfigurationInput *s3.DeleteBucketMetricsConfigurationInput, options ...request.Option) (*s3.DeleteBucketMetricsConfigurationOutput, error)) *S3API_DeleteBucketMetricsConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketOwnershipControls provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketOwnershipControls(deleteBucketOwnershipControlsInput *s3.DeleteBucketOwnershipControlsInput) (*s3.DeleteBucketOwnershipControlsOutput, error) { + ret := _mock.Called(deleteBucketOwnershipControlsInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketOwnershipControls") + } var r0 *s3.DeleteBucketOwnershipControlsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketOwnershipControlsInput) (*s3.DeleteBucketOwnershipControlsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketOwnershipControlsInput) (*s3.DeleteBucketOwnershipControlsOutput, error)); ok { + return returnFunc(deleteBucketOwnershipControlsInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketOwnershipControlsInput) *s3.DeleteBucketOwnershipControlsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketOwnershipControlsInput) *s3.DeleteBucketOwnershipControlsOutput); ok { + r0 = returnFunc(deleteBucketOwnershipControlsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketOwnershipControlsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketOwnershipControlsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketOwnershipControlsInput) error); ok { + r1 = returnFunc(deleteBucketOwnershipControlsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketOwnershipControlsRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketOwnershipControlsRequest(_a0 *s3.DeleteBucketOwnershipControlsInput) (*request.Request, *s3.DeleteBucketOwnershipControlsOutput) { - ret := _m.Called(_a0) +// S3API_DeleteBucketOwnershipControls_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketOwnershipControls' +type S3API_DeleteBucketOwnershipControls_Call struct { + *mock.Call +} + +// DeleteBucketOwnershipControls is a helper method to define mock.On call +// - deleteBucketOwnershipControlsInput *s3.DeleteBucketOwnershipControlsInput +func (_e *S3API_Expecter) DeleteBucketOwnershipControls(deleteBucketOwnershipControlsInput interface{}) *S3API_DeleteBucketOwnershipControls_Call { + return &S3API_DeleteBucketOwnershipControls_Call{Call: _e.mock.On("DeleteBucketOwnershipControls", deleteBucketOwnershipControlsInput)} +} + +func (_c *S3API_DeleteBucketOwnershipControls_Call) Run(run func(deleteBucketOwnershipControlsInput *s3.DeleteBucketOwnershipControlsInput)) *S3API_DeleteBucketOwnershipControls_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketOwnershipControlsInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketOwnershipControlsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketOwnershipControls_Call) Return(deleteBucketOwnershipControlsOutput *s3.DeleteBucketOwnershipControlsOutput, err error) *S3API_DeleteBucketOwnershipControls_Call { + _c.Call.Return(deleteBucketOwnershipControlsOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketOwnershipControls_Call) RunAndReturn(run func(deleteBucketOwnershipControlsInput *s3.DeleteBucketOwnershipControlsInput) (*s3.DeleteBucketOwnershipControlsOutput, error)) *S3API_DeleteBucketOwnershipControls_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketOwnershipControlsRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketOwnershipControlsRequest(deleteBucketOwnershipControlsInput *s3.DeleteBucketOwnershipControlsInput) (*request.Request, *s3.DeleteBucketOwnershipControlsOutput) { + ret := _mock.Called(deleteBucketOwnershipControlsInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketOwnershipControlsRequest") + } var r0 *request.Request var r1 *s3.DeleteBucketOwnershipControlsOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketOwnershipControlsInput) (*request.Request, *s3.DeleteBucketOwnershipControlsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketOwnershipControlsInput) (*request.Request, *s3.DeleteBucketOwnershipControlsOutput)); ok { + return returnFunc(deleteBucketOwnershipControlsInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketOwnershipControlsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketOwnershipControlsInput) *request.Request); ok { + r0 = returnFunc(deleteBucketOwnershipControlsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketOwnershipControlsInput) *s3.DeleteBucketOwnershipControlsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketOwnershipControlsInput) *s3.DeleteBucketOwnershipControlsOutput); ok { + r1 = returnFunc(deleteBucketOwnershipControlsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteBucketOwnershipControlsOutput) } } - return r0, r1 } -// DeleteBucketOwnershipControlsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteBucketOwnershipControlsWithContext(_a0 context.Context, _a1 *s3.DeleteBucketOwnershipControlsInput, _a2 ...request.Option) (*s3.DeleteBucketOwnershipControlsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeleteBucketOwnershipControlsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketOwnershipControlsRequest' +type S3API_DeleteBucketOwnershipControlsRequest_Call struct { + *mock.Call +} + +// DeleteBucketOwnershipControlsRequest is a helper method to define mock.On call +// - deleteBucketOwnershipControlsInput *s3.DeleteBucketOwnershipControlsInput +func (_e *S3API_Expecter) DeleteBucketOwnershipControlsRequest(deleteBucketOwnershipControlsInput interface{}) *S3API_DeleteBucketOwnershipControlsRequest_Call { + return &S3API_DeleteBucketOwnershipControlsRequest_Call{Call: _e.mock.On("DeleteBucketOwnershipControlsRequest", deleteBucketOwnershipControlsInput)} +} + +func (_c *S3API_DeleteBucketOwnershipControlsRequest_Call) Run(run func(deleteBucketOwnershipControlsInput *s3.DeleteBucketOwnershipControlsInput)) *S3API_DeleteBucketOwnershipControlsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketOwnershipControlsInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketOwnershipControlsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketOwnershipControlsRequest_Call) Return(request1 *request.Request, deleteBucketOwnershipControlsOutput *s3.DeleteBucketOwnershipControlsOutput) *S3API_DeleteBucketOwnershipControlsRequest_Call { + _c.Call.Return(request1, deleteBucketOwnershipControlsOutput) + return _c +} + +func (_c *S3API_DeleteBucketOwnershipControlsRequest_Call) RunAndReturn(run func(deleteBucketOwnershipControlsInput *s3.DeleteBucketOwnershipControlsInput) (*request.Request, *s3.DeleteBucketOwnershipControlsOutput)) *S3API_DeleteBucketOwnershipControlsRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketOwnershipControlsWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketOwnershipControlsWithContext(v aws.Context, deleteBucketOwnershipControlsInput *s3.DeleteBucketOwnershipControlsInput, options ...request.Option) (*s3.DeleteBucketOwnershipControlsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteBucketOwnershipControlsInput, options) + } else { + tmpRet = _mock.Called(v, deleteBucketOwnershipControlsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketOwnershipControlsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeleteBucketOwnershipControlsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketOwnershipControlsInput, ...request.Option) (*s3.DeleteBucketOwnershipControlsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketOwnershipControlsInput, ...request.Option) (*s3.DeleteBucketOwnershipControlsOutput, error)); ok { + return returnFunc(v, deleteBucketOwnershipControlsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketOwnershipControlsInput, ...request.Option) *s3.DeleteBucketOwnershipControlsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketOwnershipControlsInput, ...request.Option) *s3.DeleteBucketOwnershipControlsOutput); ok { + r0 = returnFunc(v, deleteBucketOwnershipControlsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketOwnershipControlsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketOwnershipControlsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketOwnershipControlsInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteBucketOwnershipControlsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketPolicy provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketPolicy(_a0 *s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteBucketOwnershipControlsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketOwnershipControlsWithContext' +type S3API_DeleteBucketOwnershipControlsWithContext_Call struct { + *mock.Call +} + +// DeleteBucketOwnershipControlsWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteBucketOwnershipControlsInput *s3.DeleteBucketOwnershipControlsInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteBucketOwnershipControlsWithContext(v interface{}, deleteBucketOwnershipControlsInput interface{}, options ...interface{}) *S3API_DeleteBucketOwnershipControlsWithContext_Call { + return &S3API_DeleteBucketOwnershipControlsWithContext_Call{Call: _e.mock.On("DeleteBucketOwnershipControlsWithContext", + append([]interface{}{v, deleteBucketOwnershipControlsInput}, options...)...)} +} + +func (_c *S3API_DeleteBucketOwnershipControlsWithContext_Call) Run(run func(v aws.Context, deleteBucketOwnershipControlsInput *s3.DeleteBucketOwnershipControlsInput, options ...request.Option)) *S3API_DeleteBucketOwnershipControlsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteBucketOwnershipControlsInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteBucketOwnershipControlsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketOwnershipControlsWithContext_Call) Return(deleteBucketOwnershipControlsOutput *s3.DeleteBucketOwnershipControlsOutput, err error) *S3API_DeleteBucketOwnershipControlsWithContext_Call { + _c.Call.Return(deleteBucketOwnershipControlsOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketOwnershipControlsWithContext_Call) RunAndReturn(run func(v aws.Context, deleteBucketOwnershipControlsInput *s3.DeleteBucketOwnershipControlsInput, options ...request.Option) (*s3.DeleteBucketOwnershipControlsOutput, error)) *S3API_DeleteBucketOwnershipControlsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketPolicy provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketPolicy(deleteBucketPolicyInput *s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error) { + ret := _mock.Called(deleteBucketPolicyInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketPolicy") + } var r0 *s3.DeleteBucketPolicyOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error)); ok { + return returnFunc(deleteBucketPolicyInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketPolicyInput) *s3.DeleteBucketPolicyOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketPolicyInput) *s3.DeleteBucketPolicyOutput); ok { + r0 = returnFunc(deleteBucketPolicyInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketPolicyOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketPolicyInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketPolicyInput) error); ok { + r1 = returnFunc(deleteBucketPolicyInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketPolicyRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketPolicyRequest(_a0 *s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput) { - ret := _m.Called(_a0) +// S3API_DeleteBucketPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketPolicy' +type S3API_DeleteBucketPolicy_Call struct { + *mock.Call +} + +// DeleteBucketPolicy is a helper method to define mock.On call +// - deleteBucketPolicyInput *s3.DeleteBucketPolicyInput +func (_e *S3API_Expecter) DeleteBucketPolicy(deleteBucketPolicyInput interface{}) *S3API_DeleteBucketPolicy_Call { + return &S3API_DeleteBucketPolicy_Call{Call: _e.mock.On("DeleteBucketPolicy", deleteBucketPolicyInput)} +} + +func (_c *S3API_DeleteBucketPolicy_Call) Run(run func(deleteBucketPolicyInput *s3.DeleteBucketPolicyInput)) *S3API_DeleteBucketPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketPolicyInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketPolicyInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketPolicy_Call) Return(deleteBucketPolicyOutput *s3.DeleteBucketPolicyOutput, err error) *S3API_DeleteBucketPolicy_Call { + _c.Call.Return(deleteBucketPolicyOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketPolicy_Call) RunAndReturn(run func(deleteBucketPolicyInput *s3.DeleteBucketPolicyInput) (*s3.DeleteBucketPolicyOutput, error)) *S3API_DeleteBucketPolicy_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketPolicyRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketPolicyRequest(deleteBucketPolicyInput *s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput) { + ret := _mock.Called(deleteBucketPolicyInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketPolicyRequest") + } var r0 *request.Request var r1 *s3.DeleteBucketPolicyOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput)); ok { + return returnFunc(deleteBucketPolicyInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketPolicyInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketPolicyInput) *request.Request); ok { + r0 = returnFunc(deleteBucketPolicyInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketPolicyInput) *s3.DeleteBucketPolicyOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketPolicyInput) *s3.DeleteBucketPolicyOutput); ok { + r1 = returnFunc(deleteBucketPolicyInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteBucketPolicyOutput) } } - return r0, r1 } -// DeleteBucketPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteBucketPolicyWithContext(_a0 context.Context, _a1 *s3.DeleteBucketPolicyInput, _a2 ...request.Option) (*s3.DeleteBucketPolicyOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] - } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) +// S3API_DeleteBucketPolicyRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketPolicyRequest' +type S3API_DeleteBucketPolicyRequest_Call struct { + *mock.Call +} - var r0 *s3.DeleteBucketPolicyOutput - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketPolicyInput, ...request.Option) (*s3.DeleteBucketPolicyOutput, error)); ok { - return rf(_a0, _a1, _a2...) - } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketPolicyInput, ...request.Option) *s3.DeleteBucketPolicyOutput); ok { - r0 = rf(_a0, _a1, _a2...) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*s3.DeleteBucketPolicyOutput) +// DeleteBucketPolicyRequest is a helper method to define mock.On call +// - deleteBucketPolicyInput *s3.DeleteBucketPolicyInput +func (_e *S3API_Expecter) DeleteBucketPolicyRequest(deleteBucketPolicyInput interface{}) *S3API_DeleteBucketPolicyRequest_Call { + return &S3API_DeleteBucketPolicyRequest_Call{Call: _e.mock.On("DeleteBucketPolicyRequest", deleteBucketPolicyInput)} +} + +func (_c *S3API_DeleteBucketPolicyRequest_Call) Run(run func(deleteBucketPolicyInput *s3.DeleteBucketPolicyInput)) *S3API_DeleteBucketPolicyRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketPolicyInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketPolicyInput) } - } + run( + arg0, + ) + }) + return _c +} - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketPolicyInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) - } else { - r1 = ret.Error(1) +func (_c *S3API_DeleteBucketPolicyRequest_Call) Return(request1 *request.Request, deleteBucketPolicyOutput *s3.DeleteBucketPolicyOutput) *S3API_DeleteBucketPolicyRequest_Call { + _c.Call.Return(request1, deleteBucketPolicyOutput) + return _c +} + +func (_c *S3API_DeleteBucketPolicyRequest_Call) RunAndReturn(run func(deleteBucketPolicyInput *s3.DeleteBucketPolicyInput) (*request.Request, *s3.DeleteBucketPolicyOutput)) *S3API_DeleteBucketPolicyRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketPolicyWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketPolicyWithContext(v aws.Context, deleteBucketPolicyInput *s3.DeleteBucketPolicyInput, options ...request.Option) (*s3.DeleteBucketPolicyOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteBucketPolicyInput, options) + } else { + tmpRet = _mock.Called(v, deleteBucketPolicyInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketPolicyWithContext") } + var r0 *s3.DeleteBucketPolicyOutput + var r1 error + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketPolicyInput, ...request.Option) (*s3.DeleteBucketPolicyOutput, error)); ok { + return returnFunc(v, deleteBucketPolicyInput, options...) + } + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketPolicyInput, ...request.Option) *s3.DeleteBucketPolicyOutput); ok { + r0 = returnFunc(v, deleteBucketPolicyInput, options...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*s3.DeleteBucketPolicyOutput) + } + } + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketPolicyInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteBucketPolicyInput, options...) + } else { + r1 = ret.Error(1) + } return r0, r1 } -// DeleteBucketReplication provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketReplication(_a0 *s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteBucketPolicyWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketPolicyWithContext' +type S3API_DeleteBucketPolicyWithContext_Call struct { + *mock.Call +} + +// DeleteBucketPolicyWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteBucketPolicyInput *s3.DeleteBucketPolicyInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteBucketPolicyWithContext(v interface{}, deleteBucketPolicyInput interface{}, options ...interface{}) *S3API_DeleteBucketPolicyWithContext_Call { + return &S3API_DeleteBucketPolicyWithContext_Call{Call: _e.mock.On("DeleteBucketPolicyWithContext", + append([]interface{}{v, deleteBucketPolicyInput}, options...)...)} +} + +func (_c *S3API_DeleteBucketPolicyWithContext_Call) Run(run func(v aws.Context, deleteBucketPolicyInput *s3.DeleteBucketPolicyInput, options ...request.Option)) *S3API_DeleteBucketPolicyWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteBucketPolicyInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteBucketPolicyInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketPolicyWithContext_Call) Return(deleteBucketPolicyOutput *s3.DeleteBucketPolicyOutput, err error) *S3API_DeleteBucketPolicyWithContext_Call { + _c.Call.Return(deleteBucketPolicyOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketPolicyWithContext_Call) RunAndReturn(run func(v aws.Context, deleteBucketPolicyInput *s3.DeleteBucketPolicyInput, options ...request.Option) (*s3.DeleteBucketPolicyOutput, error)) *S3API_DeleteBucketPolicyWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketReplication provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketReplication(deleteBucketReplicationInput *s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error) { + ret := _mock.Called(deleteBucketReplicationInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketReplication") + } var r0 *s3.DeleteBucketReplicationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error)); ok { + return returnFunc(deleteBucketReplicationInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketReplicationInput) *s3.DeleteBucketReplicationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketReplicationInput) *s3.DeleteBucketReplicationOutput); ok { + r0 = returnFunc(deleteBucketReplicationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketReplicationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketReplicationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketReplicationInput) error); ok { + r1 = returnFunc(deleteBucketReplicationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketReplicationRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketReplicationRequest(_a0 *s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput) { - ret := _m.Called(_a0) +// S3API_DeleteBucketReplication_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketReplication' +type S3API_DeleteBucketReplication_Call struct { + *mock.Call +} + +// DeleteBucketReplication is a helper method to define mock.On call +// - deleteBucketReplicationInput *s3.DeleteBucketReplicationInput +func (_e *S3API_Expecter) DeleteBucketReplication(deleteBucketReplicationInput interface{}) *S3API_DeleteBucketReplication_Call { + return &S3API_DeleteBucketReplication_Call{Call: _e.mock.On("DeleteBucketReplication", deleteBucketReplicationInput)} +} + +func (_c *S3API_DeleteBucketReplication_Call) Run(run func(deleteBucketReplicationInput *s3.DeleteBucketReplicationInput)) *S3API_DeleteBucketReplication_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketReplicationInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketReplicationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketReplication_Call) Return(deleteBucketReplicationOutput *s3.DeleteBucketReplicationOutput, err error) *S3API_DeleteBucketReplication_Call { + _c.Call.Return(deleteBucketReplicationOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketReplication_Call) RunAndReturn(run func(deleteBucketReplicationInput *s3.DeleteBucketReplicationInput) (*s3.DeleteBucketReplicationOutput, error)) *S3API_DeleteBucketReplication_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketReplicationRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketReplicationRequest(deleteBucketReplicationInput *s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput) { + ret := _mock.Called(deleteBucketReplicationInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketReplicationRequest") + } var r0 *request.Request var r1 *s3.DeleteBucketReplicationOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput)); ok { + return returnFunc(deleteBucketReplicationInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketReplicationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketReplicationInput) *request.Request); ok { + r0 = returnFunc(deleteBucketReplicationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketReplicationInput) *s3.DeleteBucketReplicationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketReplicationInput) *s3.DeleteBucketReplicationOutput); ok { + r1 = returnFunc(deleteBucketReplicationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteBucketReplicationOutput) } } - return r0, r1 } -// DeleteBucketReplicationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteBucketReplicationWithContext(_a0 context.Context, _a1 *s3.DeleteBucketReplicationInput, _a2 ...request.Option) (*s3.DeleteBucketReplicationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeleteBucketReplicationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketReplicationRequest' +type S3API_DeleteBucketReplicationRequest_Call struct { + *mock.Call +} + +// DeleteBucketReplicationRequest is a helper method to define mock.On call +// - deleteBucketReplicationInput *s3.DeleteBucketReplicationInput +func (_e *S3API_Expecter) DeleteBucketReplicationRequest(deleteBucketReplicationInput interface{}) *S3API_DeleteBucketReplicationRequest_Call { + return &S3API_DeleteBucketReplicationRequest_Call{Call: _e.mock.On("DeleteBucketReplicationRequest", deleteBucketReplicationInput)} +} + +func (_c *S3API_DeleteBucketReplicationRequest_Call) Run(run func(deleteBucketReplicationInput *s3.DeleteBucketReplicationInput)) *S3API_DeleteBucketReplicationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketReplicationInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketReplicationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketReplicationRequest_Call) Return(request1 *request.Request, deleteBucketReplicationOutput *s3.DeleteBucketReplicationOutput) *S3API_DeleteBucketReplicationRequest_Call { + _c.Call.Return(request1, deleteBucketReplicationOutput) + return _c +} + +func (_c *S3API_DeleteBucketReplicationRequest_Call) RunAndReturn(run func(deleteBucketReplicationInput *s3.DeleteBucketReplicationInput) (*request.Request, *s3.DeleteBucketReplicationOutput)) *S3API_DeleteBucketReplicationRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketReplicationWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketReplicationWithContext(v aws.Context, deleteBucketReplicationInput *s3.DeleteBucketReplicationInput, options ...request.Option) (*s3.DeleteBucketReplicationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteBucketReplicationInput, options) + } else { + tmpRet = _mock.Called(v, deleteBucketReplicationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketReplicationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeleteBucketReplicationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketReplicationInput, ...request.Option) (*s3.DeleteBucketReplicationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketReplicationInput, ...request.Option) (*s3.DeleteBucketReplicationOutput, error)); ok { + return returnFunc(v, deleteBucketReplicationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketReplicationInput, ...request.Option) *s3.DeleteBucketReplicationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketReplicationInput, ...request.Option) *s3.DeleteBucketReplicationOutput); ok { + r0 = returnFunc(v, deleteBucketReplicationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketReplicationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketReplicationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketReplicationInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteBucketReplicationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketRequest(_a0 *s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput) { - ret := _m.Called(_a0) +// S3API_DeleteBucketReplicationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketReplicationWithContext' +type S3API_DeleteBucketReplicationWithContext_Call struct { + *mock.Call +} + +// DeleteBucketReplicationWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteBucketReplicationInput *s3.DeleteBucketReplicationInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteBucketReplicationWithContext(v interface{}, deleteBucketReplicationInput interface{}, options ...interface{}) *S3API_DeleteBucketReplicationWithContext_Call { + return &S3API_DeleteBucketReplicationWithContext_Call{Call: _e.mock.On("DeleteBucketReplicationWithContext", + append([]interface{}{v, deleteBucketReplicationInput}, options...)...)} +} + +func (_c *S3API_DeleteBucketReplicationWithContext_Call) Run(run func(v aws.Context, deleteBucketReplicationInput *s3.DeleteBucketReplicationInput, options ...request.Option)) *S3API_DeleteBucketReplicationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteBucketReplicationInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteBucketReplicationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketReplicationWithContext_Call) Return(deleteBucketReplicationOutput *s3.DeleteBucketReplicationOutput, err error) *S3API_DeleteBucketReplicationWithContext_Call { + _c.Call.Return(deleteBucketReplicationOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketReplicationWithContext_Call) RunAndReturn(run func(v aws.Context, deleteBucketReplicationInput *s3.DeleteBucketReplicationInput, options ...request.Option) (*s3.DeleteBucketReplicationOutput, error)) *S3API_DeleteBucketReplicationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketRequest(deleteBucketInput *s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput) { + ret := _mock.Called(deleteBucketInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketRequest") + } var r0 *request.Request var r1 *s3.DeleteBucketOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput)); ok { + return returnFunc(deleteBucketInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketInput) *request.Request); ok { + r0 = returnFunc(deleteBucketInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketInput) *s3.DeleteBucketOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketInput) *s3.DeleteBucketOutput); ok { + r1 = returnFunc(deleteBucketInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteBucketOutput) } } - return r0, r1 } -// DeleteBucketTagging provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketTagging(_a0 *s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteBucketRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketRequest' +type S3API_DeleteBucketRequest_Call struct { + *mock.Call +} + +// DeleteBucketRequest is a helper method to define mock.On call +// - deleteBucketInput *s3.DeleteBucketInput +func (_e *S3API_Expecter) DeleteBucketRequest(deleteBucketInput interface{}) *S3API_DeleteBucketRequest_Call { + return &S3API_DeleteBucketRequest_Call{Call: _e.mock.On("DeleteBucketRequest", deleteBucketInput)} +} + +func (_c *S3API_DeleteBucketRequest_Call) Run(run func(deleteBucketInput *s3.DeleteBucketInput)) *S3API_DeleteBucketRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketRequest_Call) Return(request1 *request.Request, deleteBucketOutput *s3.DeleteBucketOutput) *S3API_DeleteBucketRequest_Call { + _c.Call.Return(request1, deleteBucketOutput) + return _c +} + +func (_c *S3API_DeleteBucketRequest_Call) RunAndReturn(run func(deleteBucketInput *s3.DeleteBucketInput) (*request.Request, *s3.DeleteBucketOutput)) *S3API_DeleteBucketRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketTagging provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketTagging(deleteBucketTaggingInput *s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error) { + ret := _mock.Called(deleteBucketTaggingInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketTagging") + } var r0 *s3.DeleteBucketTaggingOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error)); ok { + return returnFunc(deleteBucketTaggingInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketTaggingInput) *s3.DeleteBucketTaggingOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketTaggingInput) *s3.DeleteBucketTaggingOutput); ok { + r0 = returnFunc(deleteBucketTaggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketTaggingOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketTaggingInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketTaggingInput) error); ok { + r1 = returnFunc(deleteBucketTaggingInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketTaggingRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketTaggingRequest(_a0 *s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput) { - ret := _m.Called(_a0) +// S3API_DeleteBucketTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketTagging' +type S3API_DeleteBucketTagging_Call struct { + *mock.Call +} + +// DeleteBucketTagging is a helper method to define mock.On call +// - deleteBucketTaggingInput *s3.DeleteBucketTaggingInput +func (_e *S3API_Expecter) DeleteBucketTagging(deleteBucketTaggingInput interface{}) *S3API_DeleteBucketTagging_Call { + return &S3API_DeleteBucketTagging_Call{Call: _e.mock.On("DeleteBucketTagging", deleteBucketTaggingInput)} +} + +func (_c *S3API_DeleteBucketTagging_Call) Run(run func(deleteBucketTaggingInput *s3.DeleteBucketTaggingInput)) *S3API_DeleteBucketTagging_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketTaggingInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketTaggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketTagging_Call) Return(deleteBucketTaggingOutput *s3.DeleteBucketTaggingOutput, err error) *S3API_DeleteBucketTagging_Call { + _c.Call.Return(deleteBucketTaggingOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketTagging_Call) RunAndReturn(run func(deleteBucketTaggingInput *s3.DeleteBucketTaggingInput) (*s3.DeleteBucketTaggingOutput, error)) *S3API_DeleteBucketTagging_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketTaggingRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketTaggingRequest(deleteBucketTaggingInput *s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput) { + ret := _mock.Called(deleteBucketTaggingInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketTaggingRequest") + } var r0 *request.Request var r1 *s3.DeleteBucketTaggingOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput)); ok { + return returnFunc(deleteBucketTaggingInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketTaggingInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketTaggingInput) *request.Request); ok { + r0 = returnFunc(deleteBucketTaggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketTaggingInput) *s3.DeleteBucketTaggingOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketTaggingInput) *s3.DeleteBucketTaggingOutput); ok { + r1 = returnFunc(deleteBucketTaggingInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteBucketTaggingOutput) } } - return r0, r1 } -// DeleteBucketTaggingWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteBucketTaggingWithContext(_a0 context.Context, _a1 *s3.DeleteBucketTaggingInput, _a2 ...request.Option) (*s3.DeleteBucketTaggingOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeleteBucketTaggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketTaggingRequest' +type S3API_DeleteBucketTaggingRequest_Call struct { + *mock.Call +} + +// DeleteBucketTaggingRequest is a helper method to define mock.On call +// - deleteBucketTaggingInput *s3.DeleteBucketTaggingInput +func (_e *S3API_Expecter) DeleteBucketTaggingRequest(deleteBucketTaggingInput interface{}) *S3API_DeleteBucketTaggingRequest_Call { + return &S3API_DeleteBucketTaggingRequest_Call{Call: _e.mock.On("DeleteBucketTaggingRequest", deleteBucketTaggingInput)} +} + +func (_c *S3API_DeleteBucketTaggingRequest_Call) Run(run func(deleteBucketTaggingInput *s3.DeleteBucketTaggingInput)) *S3API_DeleteBucketTaggingRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketTaggingInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketTaggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketTaggingRequest_Call) Return(request1 *request.Request, deleteBucketTaggingOutput *s3.DeleteBucketTaggingOutput) *S3API_DeleteBucketTaggingRequest_Call { + _c.Call.Return(request1, deleteBucketTaggingOutput) + return _c +} + +func (_c *S3API_DeleteBucketTaggingRequest_Call) RunAndReturn(run func(deleteBucketTaggingInput *s3.DeleteBucketTaggingInput) (*request.Request, *s3.DeleteBucketTaggingOutput)) *S3API_DeleteBucketTaggingRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketTaggingWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketTaggingWithContext(v aws.Context, deleteBucketTaggingInput *s3.DeleteBucketTaggingInput, options ...request.Option) (*s3.DeleteBucketTaggingOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteBucketTaggingInput, options) + } else { + tmpRet = _mock.Called(v, deleteBucketTaggingInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketTaggingWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeleteBucketTaggingOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketTaggingInput, ...request.Option) (*s3.DeleteBucketTaggingOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketTaggingInput, ...request.Option) (*s3.DeleteBucketTaggingOutput, error)); ok { + return returnFunc(v, deleteBucketTaggingInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketTaggingInput, ...request.Option) *s3.DeleteBucketTaggingOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketTaggingInput, ...request.Option) *s3.DeleteBucketTaggingOutput); ok { + r0 = returnFunc(v, deleteBucketTaggingInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketTaggingOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketTaggingInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketTaggingInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteBucketTaggingInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketWebsite provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketWebsite(_a0 *s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteBucketTaggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketTaggingWithContext' +type S3API_DeleteBucketTaggingWithContext_Call struct { + *mock.Call +} + +// DeleteBucketTaggingWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteBucketTaggingInput *s3.DeleteBucketTaggingInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteBucketTaggingWithContext(v interface{}, deleteBucketTaggingInput interface{}, options ...interface{}) *S3API_DeleteBucketTaggingWithContext_Call { + return &S3API_DeleteBucketTaggingWithContext_Call{Call: _e.mock.On("DeleteBucketTaggingWithContext", + append([]interface{}{v, deleteBucketTaggingInput}, options...)...)} +} + +func (_c *S3API_DeleteBucketTaggingWithContext_Call) Run(run func(v aws.Context, deleteBucketTaggingInput *s3.DeleteBucketTaggingInput, options ...request.Option)) *S3API_DeleteBucketTaggingWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteBucketTaggingInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteBucketTaggingInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketTaggingWithContext_Call) Return(deleteBucketTaggingOutput *s3.DeleteBucketTaggingOutput, err error) *S3API_DeleteBucketTaggingWithContext_Call { + _c.Call.Return(deleteBucketTaggingOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketTaggingWithContext_Call) RunAndReturn(run func(v aws.Context, deleteBucketTaggingInput *s3.DeleteBucketTaggingInput, options ...request.Option) (*s3.DeleteBucketTaggingOutput, error)) *S3API_DeleteBucketTaggingWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketWebsite provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketWebsite(deleteBucketWebsiteInput *s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error) { + ret := _mock.Called(deleteBucketWebsiteInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketWebsite") + } var r0 *s3.DeleteBucketWebsiteOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error)); ok { + return returnFunc(deleteBucketWebsiteInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketWebsiteInput) *s3.DeleteBucketWebsiteOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketWebsiteInput) *s3.DeleteBucketWebsiteOutput); ok { + r0 = returnFunc(deleteBucketWebsiteInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketWebsiteOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketWebsiteInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketWebsiteInput) error); ok { + r1 = returnFunc(deleteBucketWebsiteInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketWebsiteRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteBucketWebsiteRequest(_a0 *s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput) { - ret := _m.Called(_a0) +// S3API_DeleteBucketWebsite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketWebsite' +type S3API_DeleteBucketWebsite_Call struct { + *mock.Call +} + +// DeleteBucketWebsite is a helper method to define mock.On call +// - deleteBucketWebsiteInput *s3.DeleteBucketWebsiteInput +func (_e *S3API_Expecter) DeleteBucketWebsite(deleteBucketWebsiteInput interface{}) *S3API_DeleteBucketWebsite_Call { + return &S3API_DeleteBucketWebsite_Call{Call: _e.mock.On("DeleteBucketWebsite", deleteBucketWebsiteInput)} +} + +func (_c *S3API_DeleteBucketWebsite_Call) Run(run func(deleteBucketWebsiteInput *s3.DeleteBucketWebsiteInput)) *S3API_DeleteBucketWebsite_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketWebsiteInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketWebsiteInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketWebsite_Call) Return(deleteBucketWebsiteOutput *s3.DeleteBucketWebsiteOutput, err error) *S3API_DeleteBucketWebsite_Call { + _c.Call.Return(deleteBucketWebsiteOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketWebsite_Call) RunAndReturn(run func(deleteBucketWebsiteInput *s3.DeleteBucketWebsiteInput) (*s3.DeleteBucketWebsiteOutput, error)) *S3API_DeleteBucketWebsite_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketWebsiteRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketWebsiteRequest(deleteBucketWebsiteInput *s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput) { + ret := _mock.Called(deleteBucketWebsiteInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketWebsiteRequest") + } var r0 *request.Request var r1 *s3.DeleteBucketWebsiteOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput)); ok { + return returnFunc(deleteBucketWebsiteInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteBucketWebsiteInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteBucketWebsiteInput) *request.Request); ok { + r0 = returnFunc(deleteBucketWebsiteInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteBucketWebsiteInput) *s3.DeleteBucketWebsiteOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteBucketWebsiteInput) *s3.DeleteBucketWebsiteOutput); ok { + r1 = returnFunc(deleteBucketWebsiteInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteBucketWebsiteOutput) } } - return r0, r1 } -// DeleteBucketWebsiteWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteBucketWebsiteWithContext(_a0 context.Context, _a1 *s3.DeleteBucketWebsiteInput, _a2 ...request.Option) (*s3.DeleteBucketWebsiteOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeleteBucketWebsiteRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketWebsiteRequest' +type S3API_DeleteBucketWebsiteRequest_Call struct { + *mock.Call +} + +// DeleteBucketWebsiteRequest is a helper method to define mock.On call +// - deleteBucketWebsiteInput *s3.DeleteBucketWebsiteInput +func (_e *S3API_Expecter) DeleteBucketWebsiteRequest(deleteBucketWebsiteInput interface{}) *S3API_DeleteBucketWebsiteRequest_Call { + return &S3API_DeleteBucketWebsiteRequest_Call{Call: _e.mock.On("DeleteBucketWebsiteRequest", deleteBucketWebsiteInput)} +} + +func (_c *S3API_DeleteBucketWebsiteRequest_Call) Run(run func(deleteBucketWebsiteInput *s3.DeleteBucketWebsiteInput)) *S3API_DeleteBucketWebsiteRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteBucketWebsiteInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteBucketWebsiteInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketWebsiteRequest_Call) Return(request1 *request.Request, deleteBucketWebsiteOutput *s3.DeleteBucketWebsiteOutput) *S3API_DeleteBucketWebsiteRequest_Call { + _c.Call.Return(request1, deleteBucketWebsiteOutput) + return _c +} + +func (_c *S3API_DeleteBucketWebsiteRequest_Call) RunAndReturn(run func(deleteBucketWebsiteInput *s3.DeleteBucketWebsiteInput) (*request.Request, *s3.DeleteBucketWebsiteOutput)) *S3API_DeleteBucketWebsiteRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketWebsiteWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketWebsiteWithContext(v aws.Context, deleteBucketWebsiteInput *s3.DeleteBucketWebsiteInput, options ...request.Option) (*s3.DeleteBucketWebsiteOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteBucketWebsiteInput, options) + } else { + tmpRet = _mock.Called(v, deleteBucketWebsiteInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketWebsiteWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeleteBucketWebsiteOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketWebsiteInput, ...request.Option) (*s3.DeleteBucketWebsiteOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketWebsiteInput, ...request.Option) (*s3.DeleteBucketWebsiteOutput, error)); ok { + return returnFunc(v, deleteBucketWebsiteInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketWebsiteInput, ...request.Option) *s3.DeleteBucketWebsiteOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketWebsiteInput, ...request.Option) *s3.DeleteBucketWebsiteOutput); ok { + r0 = returnFunc(v, deleteBucketWebsiteInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketWebsiteOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketWebsiteInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketWebsiteInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteBucketWebsiteInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteBucketWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteBucketWithContext(_a0 context.Context, _a1 *s3.DeleteBucketInput, _a2 ...request.Option) (*s3.DeleteBucketOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeleteBucketWebsiteWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketWebsiteWithContext' +type S3API_DeleteBucketWebsiteWithContext_Call struct { + *mock.Call +} + +// DeleteBucketWebsiteWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteBucketWebsiteInput *s3.DeleteBucketWebsiteInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteBucketWebsiteWithContext(v interface{}, deleteBucketWebsiteInput interface{}, options ...interface{}) *S3API_DeleteBucketWebsiteWithContext_Call { + return &S3API_DeleteBucketWebsiteWithContext_Call{Call: _e.mock.On("DeleteBucketWebsiteWithContext", + append([]interface{}{v, deleteBucketWebsiteInput}, options...)...)} +} + +func (_c *S3API_DeleteBucketWebsiteWithContext_Call) Run(run func(v aws.Context, deleteBucketWebsiteInput *s3.DeleteBucketWebsiteInput, options ...request.Option)) *S3API_DeleteBucketWebsiteWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteBucketWebsiteInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteBucketWebsiteInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketWebsiteWithContext_Call) Return(deleteBucketWebsiteOutput *s3.DeleteBucketWebsiteOutput, err error) *S3API_DeleteBucketWebsiteWithContext_Call { + _c.Call.Return(deleteBucketWebsiteOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketWebsiteWithContext_Call) RunAndReturn(run func(v aws.Context, deleteBucketWebsiteInput *s3.DeleteBucketWebsiteInput, options ...request.Option) (*s3.DeleteBucketWebsiteOutput, error)) *S3API_DeleteBucketWebsiteWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteBucketWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteBucketWithContext(v aws.Context, deleteBucketInput *s3.DeleteBucketInput, options ...request.Option) (*s3.DeleteBucketOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteBucketInput, options) + } else { + tmpRet = _mock.Called(v, deleteBucketInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteBucketWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeleteBucketOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketInput, ...request.Option) (*s3.DeleteBucketOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketInput, ...request.Option) (*s3.DeleteBucketOutput, error)); ok { + return returnFunc(v, deleteBucketInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteBucketInput, ...request.Option) *s3.DeleteBucketOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteBucketInput, ...request.Option) *s3.DeleteBucketOutput); ok { + r0 = returnFunc(v, deleteBucketInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteBucketOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteBucketInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteBucketInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteBucketInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteObject provides a mock function with given fields: _a0 -func (_m *S3API) DeleteObject(_a0 *s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteBucketWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteBucketWithContext' +type S3API_DeleteBucketWithContext_Call struct { + *mock.Call +} + +// DeleteBucketWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteBucketInput *s3.DeleteBucketInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteBucketWithContext(v interface{}, deleteBucketInput interface{}, options ...interface{}) *S3API_DeleteBucketWithContext_Call { + return &S3API_DeleteBucketWithContext_Call{Call: _e.mock.On("DeleteBucketWithContext", + append([]interface{}{v, deleteBucketInput}, options...)...)} +} + +func (_c *S3API_DeleteBucketWithContext_Call) Run(run func(v aws.Context, deleteBucketInput *s3.DeleteBucketInput, options ...request.Option)) *S3API_DeleteBucketWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteBucketInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteBucketInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteBucketWithContext_Call) Return(deleteBucketOutput *s3.DeleteBucketOutput, err error) *S3API_DeleteBucketWithContext_Call { + _c.Call.Return(deleteBucketOutput, err) + return _c +} + +func (_c *S3API_DeleteBucketWithContext_Call) RunAndReturn(run func(v aws.Context, deleteBucketInput *s3.DeleteBucketInput, options ...request.Option) (*s3.DeleteBucketOutput, error)) *S3API_DeleteBucketWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteObject provides a mock function for the type S3API +func (_mock *S3API) DeleteObject(deleteObjectInput *s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error) { + ret := _mock.Called(deleteObjectInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteObject") + } var r0 *s3.DeleteObjectOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error)); ok { + return returnFunc(deleteObjectInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteObjectInput) *s3.DeleteObjectOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteObjectInput) *s3.DeleteObjectOutput); ok { + r0 = returnFunc(deleteObjectInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteObjectOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteObjectInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteObjectInput) error); ok { + r1 = returnFunc(deleteObjectInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteObjectRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteObjectRequest(_a0 *s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput) { - ret := _m.Called(_a0) +// S3API_DeleteObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObject' +type S3API_DeleteObject_Call struct { + *mock.Call +} + +// DeleteObject is a helper method to define mock.On call +// - deleteObjectInput *s3.DeleteObjectInput +func (_e *S3API_Expecter) DeleteObject(deleteObjectInput interface{}) *S3API_DeleteObject_Call { + return &S3API_DeleteObject_Call{Call: _e.mock.On("DeleteObject", deleteObjectInput)} +} + +func (_c *S3API_DeleteObject_Call) Run(run func(deleteObjectInput *s3.DeleteObjectInput)) *S3API_DeleteObject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteObjectInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteObjectInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteObject_Call) Return(deleteObjectOutput *s3.DeleteObjectOutput, err error) *S3API_DeleteObject_Call { + _c.Call.Return(deleteObjectOutput, err) + return _c +} + +func (_c *S3API_DeleteObject_Call) RunAndReturn(run func(deleteObjectInput *s3.DeleteObjectInput) (*s3.DeleteObjectOutput, error)) *S3API_DeleteObject_Call { + _c.Call.Return(run) + return _c +} + +// DeleteObjectRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteObjectRequest(deleteObjectInput *s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput) { + ret := _mock.Called(deleteObjectInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteObjectRequest") + } var r0 *request.Request var r1 *s3.DeleteObjectOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput)); ok { + return returnFunc(deleteObjectInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteObjectInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteObjectInput) *request.Request); ok { + r0 = returnFunc(deleteObjectInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteObjectInput) *s3.DeleteObjectOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteObjectInput) *s3.DeleteObjectOutput); ok { + r1 = returnFunc(deleteObjectInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteObjectOutput) } } - return r0, r1 } -// DeleteObjectTagging provides a mock function with given fields: _a0 -func (_m *S3API) DeleteObjectTagging(_a0 *s3.DeleteObjectTaggingInput) (*s3.DeleteObjectTaggingOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteObjectRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectRequest' +type S3API_DeleteObjectRequest_Call struct { + *mock.Call +} + +// DeleteObjectRequest is a helper method to define mock.On call +// - deleteObjectInput *s3.DeleteObjectInput +func (_e *S3API_Expecter) DeleteObjectRequest(deleteObjectInput interface{}) *S3API_DeleteObjectRequest_Call { + return &S3API_DeleteObjectRequest_Call{Call: _e.mock.On("DeleteObjectRequest", deleteObjectInput)} +} + +func (_c *S3API_DeleteObjectRequest_Call) Run(run func(deleteObjectInput *s3.DeleteObjectInput)) *S3API_DeleteObjectRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteObjectInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteObjectInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteObjectRequest_Call) Return(request1 *request.Request, deleteObjectOutput *s3.DeleteObjectOutput) *S3API_DeleteObjectRequest_Call { + _c.Call.Return(request1, deleteObjectOutput) + return _c +} + +func (_c *S3API_DeleteObjectRequest_Call) RunAndReturn(run func(deleteObjectInput *s3.DeleteObjectInput) (*request.Request, *s3.DeleteObjectOutput)) *S3API_DeleteObjectRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteObjectTagging provides a mock function for the type S3API +func (_mock *S3API) DeleteObjectTagging(deleteObjectTaggingInput *s3.DeleteObjectTaggingInput) (*s3.DeleteObjectTaggingOutput, error) { + ret := _mock.Called(deleteObjectTaggingInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteObjectTagging") + } var r0 *s3.DeleteObjectTaggingOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteObjectTaggingInput) (*s3.DeleteObjectTaggingOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteObjectTaggingInput) (*s3.DeleteObjectTaggingOutput, error)); ok { + return returnFunc(deleteObjectTaggingInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteObjectTaggingInput) *s3.DeleteObjectTaggingOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteObjectTaggingInput) *s3.DeleteObjectTaggingOutput); ok { + r0 = returnFunc(deleteObjectTaggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteObjectTaggingOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteObjectTaggingInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteObjectTaggingInput) error); ok { + r1 = returnFunc(deleteObjectTaggingInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteObjectTaggingRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteObjectTaggingRequest(_a0 *s3.DeleteObjectTaggingInput) (*request.Request, *s3.DeleteObjectTaggingOutput) { - ret := _m.Called(_a0) +// S3API_DeleteObjectTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectTagging' +type S3API_DeleteObjectTagging_Call struct { + *mock.Call +} + +// DeleteObjectTagging is a helper method to define mock.On call +// - deleteObjectTaggingInput *s3.DeleteObjectTaggingInput +func (_e *S3API_Expecter) DeleteObjectTagging(deleteObjectTaggingInput interface{}) *S3API_DeleteObjectTagging_Call { + return &S3API_DeleteObjectTagging_Call{Call: _e.mock.On("DeleteObjectTagging", deleteObjectTaggingInput)} +} + +func (_c *S3API_DeleteObjectTagging_Call) Run(run func(deleteObjectTaggingInput *s3.DeleteObjectTaggingInput)) *S3API_DeleteObjectTagging_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteObjectTaggingInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteObjectTaggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteObjectTagging_Call) Return(deleteObjectTaggingOutput *s3.DeleteObjectTaggingOutput, err error) *S3API_DeleteObjectTagging_Call { + _c.Call.Return(deleteObjectTaggingOutput, err) + return _c +} + +func (_c *S3API_DeleteObjectTagging_Call) RunAndReturn(run func(deleteObjectTaggingInput *s3.DeleteObjectTaggingInput) (*s3.DeleteObjectTaggingOutput, error)) *S3API_DeleteObjectTagging_Call { + _c.Call.Return(run) + return _c +} + +// DeleteObjectTaggingRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteObjectTaggingRequest(deleteObjectTaggingInput *s3.DeleteObjectTaggingInput) (*request.Request, *s3.DeleteObjectTaggingOutput) { + ret := _mock.Called(deleteObjectTaggingInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteObjectTaggingRequest") + } var r0 *request.Request var r1 *s3.DeleteObjectTaggingOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteObjectTaggingInput) (*request.Request, *s3.DeleteObjectTaggingOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteObjectTaggingInput) (*request.Request, *s3.DeleteObjectTaggingOutput)); ok { + return returnFunc(deleteObjectTaggingInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteObjectTaggingInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteObjectTaggingInput) *request.Request); ok { + r0 = returnFunc(deleteObjectTaggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteObjectTaggingInput) *s3.DeleteObjectTaggingOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteObjectTaggingInput) *s3.DeleteObjectTaggingOutput); ok { + r1 = returnFunc(deleteObjectTaggingInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteObjectTaggingOutput) } } - return r0, r1 } -// DeleteObjectTaggingWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteObjectTaggingWithContext(_a0 context.Context, _a1 *s3.DeleteObjectTaggingInput, _a2 ...request.Option) (*s3.DeleteObjectTaggingOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeleteObjectTaggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectTaggingRequest' +type S3API_DeleteObjectTaggingRequest_Call struct { + *mock.Call +} + +// DeleteObjectTaggingRequest is a helper method to define mock.On call +// - deleteObjectTaggingInput *s3.DeleteObjectTaggingInput +func (_e *S3API_Expecter) DeleteObjectTaggingRequest(deleteObjectTaggingInput interface{}) *S3API_DeleteObjectTaggingRequest_Call { + return &S3API_DeleteObjectTaggingRequest_Call{Call: _e.mock.On("DeleteObjectTaggingRequest", deleteObjectTaggingInput)} +} + +func (_c *S3API_DeleteObjectTaggingRequest_Call) Run(run func(deleteObjectTaggingInput *s3.DeleteObjectTaggingInput)) *S3API_DeleteObjectTaggingRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteObjectTaggingInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteObjectTaggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteObjectTaggingRequest_Call) Return(request1 *request.Request, deleteObjectTaggingOutput *s3.DeleteObjectTaggingOutput) *S3API_DeleteObjectTaggingRequest_Call { + _c.Call.Return(request1, deleteObjectTaggingOutput) + return _c +} + +func (_c *S3API_DeleteObjectTaggingRequest_Call) RunAndReturn(run func(deleteObjectTaggingInput *s3.DeleteObjectTaggingInput) (*request.Request, *s3.DeleteObjectTaggingOutput)) *S3API_DeleteObjectTaggingRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteObjectTaggingWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteObjectTaggingWithContext(v aws.Context, deleteObjectTaggingInput *s3.DeleteObjectTaggingInput, options ...request.Option) (*s3.DeleteObjectTaggingOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteObjectTaggingInput, options) + } else { + tmpRet = _mock.Called(v, deleteObjectTaggingInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteObjectTaggingWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeleteObjectTaggingOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteObjectTaggingInput, ...request.Option) (*s3.DeleteObjectTaggingOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteObjectTaggingInput, ...request.Option) (*s3.DeleteObjectTaggingOutput, error)); ok { + return returnFunc(v, deleteObjectTaggingInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteObjectTaggingInput, ...request.Option) *s3.DeleteObjectTaggingOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteObjectTaggingInput, ...request.Option) *s3.DeleteObjectTaggingOutput); ok { + r0 = returnFunc(v, deleteObjectTaggingInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteObjectTaggingOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteObjectTaggingInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteObjectTaggingInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteObjectTaggingInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteObjectWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteObjectWithContext(_a0 context.Context, _a1 *s3.DeleteObjectInput, _a2 ...request.Option) (*s3.DeleteObjectOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeleteObjectTaggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectTaggingWithContext' +type S3API_DeleteObjectTaggingWithContext_Call struct { + *mock.Call +} + +// DeleteObjectTaggingWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteObjectTaggingInput *s3.DeleteObjectTaggingInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteObjectTaggingWithContext(v interface{}, deleteObjectTaggingInput interface{}, options ...interface{}) *S3API_DeleteObjectTaggingWithContext_Call { + return &S3API_DeleteObjectTaggingWithContext_Call{Call: _e.mock.On("DeleteObjectTaggingWithContext", + append([]interface{}{v, deleteObjectTaggingInput}, options...)...)} +} + +func (_c *S3API_DeleteObjectTaggingWithContext_Call) Run(run func(v aws.Context, deleteObjectTaggingInput *s3.DeleteObjectTaggingInput, options ...request.Option)) *S3API_DeleteObjectTaggingWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteObjectTaggingInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteObjectTaggingInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteObjectTaggingWithContext_Call) Return(deleteObjectTaggingOutput *s3.DeleteObjectTaggingOutput, err error) *S3API_DeleteObjectTaggingWithContext_Call { + _c.Call.Return(deleteObjectTaggingOutput, err) + return _c +} + +func (_c *S3API_DeleteObjectTaggingWithContext_Call) RunAndReturn(run func(v aws.Context, deleteObjectTaggingInput *s3.DeleteObjectTaggingInput, options ...request.Option) (*s3.DeleteObjectTaggingOutput, error)) *S3API_DeleteObjectTaggingWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteObjectWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteObjectWithContext(v aws.Context, deleteObjectInput *s3.DeleteObjectInput, options ...request.Option) (*s3.DeleteObjectOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteObjectInput, options) + } else { + tmpRet = _mock.Called(v, deleteObjectInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteObjectWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeleteObjectOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteObjectInput, ...request.Option) (*s3.DeleteObjectOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteObjectInput, ...request.Option) (*s3.DeleteObjectOutput, error)); ok { + return returnFunc(v, deleteObjectInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteObjectInput, ...request.Option) *s3.DeleteObjectOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteObjectInput, ...request.Option) *s3.DeleteObjectOutput); ok { + r0 = returnFunc(v, deleteObjectInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteObjectOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteObjectInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteObjectInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteObjectInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteObjects provides a mock function with given fields: _a0 -func (_m *S3API) DeleteObjects(_a0 *s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteObjectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectWithContext' +type S3API_DeleteObjectWithContext_Call struct { + *mock.Call +} + +// DeleteObjectWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteObjectInput *s3.DeleteObjectInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteObjectWithContext(v interface{}, deleteObjectInput interface{}, options ...interface{}) *S3API_DeleteObjectWithContext_Call { + return &S3API_DeleteObjectWithContext_Call{Call: _e.mock.On("DeleteObjectWithContext", + append([]interface{}{v, deleteObjectInput}, options...)...)} +} + +func (_c *S3API_DeleteObjectWithContext_Call) Run(run func(v aws.Context, deleteObjectInput *s3.DeleteObjectInput, options ...request.Option)) *S3API_DeleteObjectWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteObjectInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteObjectInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteObjectWithContext_Call) Return(deleteObjectOutput *s3.DeleteObjectOutput, err error) *S3API_DeleteObjectWithContext_Call { + _c.Call.Return(deleteObjectOutput, err) + return _c +} + +func (_c *S3API_DeleteObjectWithContext_Call) RunAndReturn(run func(v aws.Context, deleteObjectInput *s3.DeleteObjectInput, options ...request.Option) (*s3.DeleteObjectOutput, error)) *S3API_DeleteObjectWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeleteObjects provides a mock function for the type S3API +func (_mock *S3API) DeleteObjects(deleteObjectsInput *s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error) { + ret := _mock.Called(deleteObjectsInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteObjects") + } var r0 *s3.DeleteObjectsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error)); ok { + return returnFunc(deleteObjectsInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteObjectsInput) *s3.DeleteObjectsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteObjectsInput) *s3.DeleteObjectsOutput); ok { + r0 = returnFunc(deleteObjectsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteObjectsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteObjectsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteObjectsInput) error); ok { + r1 = returnFunc(deleteObjectsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteObjectsRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeleteObjectsRequest(_a0 *s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput) { - ret := _m.Called(_a0) +// S3API_DeleteObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjects' +type S3API_DeleteObjects_Call struct { + *mock.Call +} + +// DeleteObjects is a helper method to define mock.On call +// - deleteObjectsInput *s3.DeleteObjectsInput +func (_e *S3API_Expecter) DeleteObjects(deleteObjectsInput interface{}) *S3API_DeleteObjects_Call { + return &S3API_DeleteObjects_Call{Call: _e.mock.On("DeleteObjects", deleteObjectsInput)} +} + +func (_c *S3API_DeleteObjects_Call) Run(run func(deleteObjectsInput *s3.DeleteObjectsInput)) *S3API_DeleteObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteObjectsInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteObjectsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteObjects_Call) Return(deleteObjectsOutput *s3.DeleteObjectsOutput, err error) *S3API_DeleteObjects_Call { + _c.Call.Return(deleteObjectsOutput, err) + return _c +} + +func (_c *S3API_DeleteObjects_Call) RunAndReturn(run func(deleteObjectsInput *s3.DeleteObjectsInput) (*s3.DeleteObjectsOutput, error)) *S3API_DeleteObjects_Call { + _c.Call.Return(run) + return _c +} + +// DeleteObjectsRequest provides a mock function for the type S3API +func (_mock *S3API) DeleteObjectsRequest(deleteObjectsInput *s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput) { + ret := _mock.Called(deleteObjectsInput) + + if len(ret) == 0 { + panic("no return value specified for DeleteObjectsRequest") + } var r0 *request.Request var r1 *s3.DeleteObjectsOutput - if rf, ok := ret.Get(0).(func(*s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput)); ok { + return returnFunc(deleteObjectsInput) } - if rf, ok := ret.Get(0).(func(*s3.DeleteObjectsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeleteObjectsInput) *request.Request); ok { + r0 = returnFunc(deleteObjectsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeleteObjectsInput) *s3.DeleteObjectsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeleteObjectsInput) *s3.DeleteObjectsOutput); ok { + r1 = returnFunc(deleteObjectsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeleteObjectsOutput) } } - return r0, r1 } -// DeleteObjectsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeleteObjectsWithContext(_a0 context.Context, _a1 *s3.DeleteObjectsInput, _a2 ...request.Option) (*s3.DeleteObjectsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeleteObjectsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectsRequest' +type S3API_DeleteObjectsRequest_Call struct { + *mock.Call +} + +// DeleteObjectsRequest is a helper method to define mock.On call +// - deleteObjectsInput *s3.DeleteObjectsInput +func (_e *S3API_Expecter) DeleteObjectsRequest(deleteObjectsInput interface{}) *S3API_DeleteObjectsRequest_Call { + return &S3API_DeleteObjectsRequest_Call{Call: _e.mock.On("DeleteObjectsRequest", deleteObjectsInput)} +} + +func (_c *S3API_DeleteObjectsRequest_Call) Run(run func(deleteObjectsInput *s3.DeleteObjectsInput)) *S3API_DeleteObjectsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeleteObjectsInput + if args[0] != nil { + arg0 = args[0].(*s3.DeleteObjectsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeleteObjectsRequest_Call) Return(request1 *request.Request, deleteObjectsOutput *s3.DeleteObjectsOutput) *S3API_DeleteObjectsRequest_Call { + _c.Call.Return(request1, deleteObjectsOutput) + return _c +} + +func (_c *S3API_DeleteObjectsRequest_Call) RunAndReturn(run func(deleteObjectsInput *s3.DeleteObjectsInput) (*request.Request, *s3.DeleteObjectsOutput)) *S3API_DeleteObjectsRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeleteObjectsWithContext provides a mock function for the type S3API +func (_mock *S3API) DeleteObjectsWithContext(v aws.Context, deleteObjectsInput *s3.DeleteObjectsInput, options ...request.Option) (*s3.DeleteObjectsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deleteObjectsInput, options) + } else { + tmpRet = _mock.Called(v, deleteObjectsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeleteObjectsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeleteObjectsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteObjectsInput, ...request.Option) (*s3.DeleteObjectsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteObjectsInput, ...request.Option) (*s3.DeleteObjectsOutput, error)); ok { + return returnFunc(v, deleteObjectsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeleteObjectsInput, ...request.Option) *s3.DeleteObjectsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeleteObjectsInput, ...request.Option) *s3.DeleteObjectsOutput); ok { + r0 = returnFunc(v, deleteObjectsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeleteObjectsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeleteObjectsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeleteObjectsInput, ...request.Option) error); ok { + r1 = returnFunc(v, deleteObjectsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeletePublicAccessBlock provides a mock function with given fields: _a0 -func (_m *S3API) DeletePublicAccessBlock(_a0 *s3.DeletePublicAccessBlockInput) (*s3.DeletePublicAccessBlockOutput, error) { - ret := _m.Called(_a0) +// S3API_DeleteObjectsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteObjectsWithContext' +type S3API_DeleteObjectsWithContext_Call struct { + *mock.Call +} + +// DeleteObjectsWithContext is a helper method to define mock.On call +// - v aws.Context +// - deleteObjectsInput *s3.DeleteObjectsInput +// - options ...request.Option +func (_e *S3API_Expecter) DeleteObjectsWithContext(v interface{}, deleteObjectsInput interface{}, options ...interface{}) *S3API_DeleteObjectsWithContext_Call { + return &S3API_DeleteObjectsWithContext_Call{Call: _e.mock.On("DeleteObjectsWithContext", + append([]interface{}{v, deleteObjectsInput}, options...)...)} +} + +func (_c *S3API_DeleteObjectsWithContext_Call) Run(run func(v aws.Context, deleteObjectsInput *s3.DeleteObjectsInput, options ...request.Option)) *S3API_DeleteObjectsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeleteObjectsInput + if args[1] != nil { + arg1 = args[1].(*s3.DeleteObjectsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeleteObjectsWithContext_Call) Return(deleteObjectsOutput *s3.DeleteObjectsOutput, err error) *S3API_DeleteObjectsWithContext_Call { + _c.Call.Return(deleteObjectsOutput, err) + return _c +} + +func (_c *S3API_DeleteObjectsWithContext_Call) RunAndReturn(run func(v aws.Context, deleteObjectsInput *s3.DeleteObjectsInput, options ...request.Option) (*s3.DeleteObjectsOutput, error)) *S3API_DeleteObjectsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// DeletePublicAccessBlock provides a mock function for the type S3API +func (_mock *S3API) DeletePublicAccessBlock(deletePublicAccessBlockInput *s3.DeletePublicAccessBlockInput) (*s3.DeletePublicAccessBlockOutput, error) { + ret := _mock.Called(deletePublicAccessBlockInput) + + if len(ret) == 0 { + panic("no return value specified for DeletePublicAccessBlock") + } var r0 *s3.DeletePublicAccessBlockOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.DeletePublicAccessBlockInput) (*s3.DeletePublicAccessBlockOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeletePublicAccessBlockInput) (*s3.DeletePublicAccessBlockOutput, error)); ok { + return returnFunc(deletePublicAccessBlockInput) } - if rf, ok := ret.Get(0).(func(*s3.DeletePublicAccessBlockInput) *s3.DeletePublicAccessBlockOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeletePublicAccessBlockInput) *s3.DeletePublicAccessBlockOutput); ok { + r0 = returnFunc(deletePublicAccessBlockInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeletePublicAccessBlockOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.DeletePublicAccessBlockInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeletePublicAccessBlockInput) error); ok { + r1 = returnFunc(deletePublicAccessBlockInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeletePublicAccessBlockRequest provides a mock function with given fields: _a0 -func (_m *S3API) DeletePublicAccessBlockRequest(_a0 *s3.DeletePublicAccessBlockInput) (*request.Request, *s3.DeletePublicAccessBlockOutput) { - ret := _m.Called(_a0) +// S3API_DeletePublicAccessBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePublicAccessBlock' +type S3API_DeletePublicAccessBlock_Call struct { + *mock.Call +} + +// DeletePublicAccessBlock is a helper method to define mock.On call +// - deletePublicAccessBlockInput *s3.DeletePublicAccessBlockInput +func (_e *S3API_Expecter) DeletePublicAccessBlock(deletePublicAccessBlockInput interface{}) *S3API_DeletePublicAccessBlock_Call { + return &S3API_DeletePublicAccessBlock_Call{Call: _e.mock.On("DeletePublicAccessBlock", deletePublicAccessBlockInput)} +} + +func (_c *S3API_DeletePublicAccessBlock_Call) Run(run func(deletePublicAccessBlockInput *s3.DeletePublicAccessBlockInput)) *S3API_DeletePublicAccessBlock_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeletePublicAccessBlockInput + if args[0] != nil { + arg0 = args[0].(*s3.DeletePublicAccessBlockInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeletePublicAccessBlock_Call) Return(deletePublicAccessBlockOutput *s3.DeletePublicAccessBlockOutput, err error) *S3API_DeletePublicAccessBlock_Call { + _c.Call.Return(deletePublicAccessBlockOutput, err) + return _c +} + +func (_c *S3API_DeletePublicAccessBlock_Call) RunAndReturn(run func(deletePublicAccessBlockInput *s3.DeletePublicAccessBlockInput) (*s3.DeletePublicAccessBlockOutput, error)) *S3API_DeletePublicAccessBlock_Call { + _c.Call.Return(run) + return _c +} + +// DeletePublicAccessBlockRequest provides a mock function for the type S3API +func (_mock *S3API) DeletePublicAccessBlockRequest(deletePublicAccessBlockInput *s3.DeletePublicAccessBlockInput) (*request.Request, *s3.DeletePublicAccessBlockOutput) { + ret := _mock.Called(deletePublicAccessBlockInput) + + if len(ret) == 0 { + panic("no return value specified for DeletePublicAccessBlockRequest") + } var r0 *request.Request var r1 *s3.DeletePublicAccessBlockOutput - if rf, ok := ret.Get(0).(func(*s3.DeletePublicAccessBlockInput) (*request.Request, *s3.DeletePublicAccessBlockOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeletePublicAccessBlockInput) (*request.Request, *s3.DeletePublicAccessBlockOutput)); ok { + return returnFunc(deletePublicAccessBlockInput) } - if rf, ok := ret.Get(0).(func(*s3.DeletePublicAccessBlockInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.DeletePublicAccessBlockInput) *request.Request); ok { + r0 = returnFunc(deletePublicAccessBlockInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.DeletePublicAccessBlockInput) *s3.DeletePublicAccessBlockOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.DeletePublicAccessBlockInput) *s3.DeletePublicAccessBlockOutput); ok { + r1 = returnFunc(deletePublicAccessBlockInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.DeletePublicAccessBlockOutput) } } - return r0, r1 } -// DeletePublicAccessBlockWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) DeletePublicAccessBlockWithContext(_a0 context.Context, _a1 *s3.DeletePublicAccessBlockInput, _a2 ...request.Option) (*s3.DeletePublicAccessBlockOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_DeletePublicAccessBlockRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePublicAccessBlockRequest' +type S3API_DeletePublicAccessBlockRequest_Call struct { + *mock.Call +} + +// DeletePublicAccessBlockRequest is a helper method to define mock.On call +// - deletePublicAccessBlockInput *s3.DeletePublicAccessBlockInput +func (_e *S3API_Expecter) DeletePublicAccessBlockRequest(deletePublicAccessBlockInput interface{}) *S3API_DeletePublicAccessBlockRequest_Call { + return &S3API_DeletePublicAccessBlockRequest_Call{Call: _e.mock.On("DeletePublicAccessBlockRequest", deletePublicAccessBlockInput)} +} + +func (_c *S3API_DeletePublicAccessBlockRequest_Call) Run(run func(deletePublicAccessBlockInput *s3.DeletePublicAccessBlockInput)) *S3API_DeletePublicAccessBlockRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.DeletePublicAccessBlockInput + if args[0] != nil { + arg0 = args[0].(*s3.DeletePublicAccessBlockInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_DeletePublicAccessBlockRequest_Call) Return(request1 *request.Request, deletePublicAccessBlockOutput *s3.DeletePublicAccessBlockOutput) *S3API_DeletePublicAccessBlockRequest_Call { + _c.Call.Return(request1, deletePublicAccessBlockOutput) + return _c +} + +func (_c *S3API_DeletePublicAccessBlockRequest_Call) RunAndReturn(run func(deletePublicAccessBlockInput *s3.DeletePublicAccessBlockInput) (*request.Request, *s3.DeletePublicAccessBlockOutput)) *S3API_DeletePublicAccessBlockRequest_Call { + _c.Call.Return(run) + return _c +} + +// DeletePublicAccessBlockWithContext provides a mock function for the type S3API +func (_mock *S3API) DeletePublicAccessBlockWithContext(v aws.Context, deletePublicAccessBlockInput *s3.DeletePublicAccessBlockInput, options ...request.Option) (*s3.DeletePublicAccessBlockOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, deletePublicAccessBlockInput, options) + } else { + tmpRet = _mock.Called(v, deletePublicAccessBlockInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for DeletePublicAccessBlockWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.DeletePublicAccessBlockOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeletePublicAccessBlockInput, ...request.Option) (*s3.DeletePublicAccessBlockOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeletePublicAccessBlockInput, ...request.Option) (*s3.DeletePublicAccessBlockOutput, error)); ok { + return returnFunc(v, deletePublicAccessBlockInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.DeletePublicAccessBlockInput, ...request.Option) *s3.DeletePublicAccessBlockOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.DeletePublicAccessBlockInput, ...request.Option) *s3.DeletePublicAccessBlockOutput); ok { + r0 = returnFunc(v, deletePublicAccessBlockInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.DeletePublicAccessBlockOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.DeletePublicAccessBlockInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.DeletePublicAccessBlockInput, ...request.Option) error); ok { + r1 = returnFunc(v, deletePublicAccessBlockInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketAccelerateConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketAccelerateConfiguration(_a0 *s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_DeletePublicAccessBlockWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeletePublicAccessBlockWithContext' +type S3API_DeletePublicAccessBlockWithContext_Call struct { + *mock.Call +} + +// DeletePublicAccessBlockWithContext is a helper method to define mock.On call +// - v aws.Context +// - deletePublicAccessBlockInput *s3.DeletePublicAccessBlockInput +// - options ...request.Option +func (_e *S3API_Expecter) DeletePublicAccessBlockWithContext(v interface{}, deletePublicAccessBlockInput interface{}, options ...interface{}) *S3API_DeletePublicAccessBlockWithContext_Call { + return &S3API_DeletePublicAccessBlockWithContext_Call{Call: _e.mock.On("DeletePublicAccessBlockWithContext", + append([]interface{}{v, deletePublicAccessBlockInput}, options...)...)} +} + +func (_c *S3API_DeletePublicAccessBlockWithContext_Call) Run(run func(v aws.Context, deletePublicAccessBlockInput *s3.DeletePublicAccessBlockInput, options ...request.Option)) *S3API_DeletePublicAccessBlockWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.DeletePublicAccessBlockInput + if args[1] != nil { + arg1 = args[1].(*s3.DeletePublicAccessBlockInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_DeletePublicAccessBlockWithContext_Call) Return(deletePublicAccessBlockOutput *s3.DeletePublicAccessBlockOutput, err error) *S3API_DeletePublicAccessBlockWithContext_Call { + _c.Call.Return(deletePublicAccessBlockOutput, err) + return _c +} + +func (_c *S3API_DeletePublicAccessBlockWithContext_Call) RunAndReturn(run func(v aws.Context, deletePublicAccessBlockInput *s3.DeletePublicAccessBlockInput, options ...request.Option) (*s3.DeletePublicAccessBlockOutput, error)) *S3API_DeletePublicAccessBlockWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketAccelerateConfiguration provides a mock function for the type S3API +func (_mock *S3API) GetBucketAccelerateConfiguration(getBucketAccelerateConfigurationInput *s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error) { + ret := _mock.Called(getBucketAccelerateConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketAccelerateConfiguration") + } var r0 *s3.GetBucketAccelerateConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error)); ok { + return returnFunc(getBucketAccelerateConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketAccelerateConfigurationInput) *s3.GetBucketAccelerateConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketAccelerateConfigurationInput) *s3.GetBucketAccelerateConfigurationOutput); ok { + r0 = returnFunc(getBucketAccelerateConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketAccelerateConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketAccelerateConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketAccelerateConfigurationInput) error); ok { + r1 = returnFunc(getBucketAccelerateConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketAccelerateConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketAccelerateConfigurationRequest(_a0 *s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketAccelerateConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAccelerateConfiguration' +type S3API_GetBucketAccelerateConfiguration_Call struct { + *mock.Call +} + +// GetBucketAccelerateConfiguration is a helper method to define mock.On call +// - getBucketAccelerateConfigurationInput *s3.GetBucketAccelerateConfigurationInput +func (_e *S3API_Expecter) GetBucketAccelerateConfiguration(getBucketAccelerateConfigurationInput interface{}) *S3API_GetBucketAccelerateConfiguration_Call { + return &S3API_GetBucketAccelerateConfiguration_Call{Call: _e.mock.On("GetBucketAccelerateConfiguration", getBucketAccelerateConfigurationInput)} +} + +func (_c *S3API_GetBucketAccelerateConfiguration_Call) Run(run func(getBucketAccelerateConfigurationInput *s3.GetBucketAccelerateConfigurationInput)) *S3API_GetBucketAccelerateConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketAccelerateConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketAccelerateConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketAccelerateConfiguration_Call) Return(getBucketAccelerateConfigurationOutput *s3.GetBucketAccelerateConfigurationOutput, err error) *S3API_GetBucketAccelerateConfiguration_Call { + _c.Call.Return(getBucketAccelerateConfigurationOutput, err) + return _c +} + +func (_c *S3API_GetBucketAccelerateConfiguration_Call) RunAndReturn(run func(getBucketAccelerateConfigurationInput *s3.GetBucketAccelerateConfigurationInput) (*s3.GetBucketAccelerateConfigurationOutput, error)) *S3API_GetBucketAccelerateConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketAccelerateConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketAccelerateConfigurationRequest(getBucketAccelerateConfigurationInput *s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput) { + ret := _mock.Called(getBucketAccelerateConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketAccelerateConfigurationRequest") + } var r0 *request.Request var r1 *s3.GetBucketAccelerateConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput)); ok { + return returnFunc(getBucketAccelerateConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketAccelerateConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketAccelerateConfigurationInput) *request.Request); ok { + r0 = returnFunc(getBucketAccelerateConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketAccelerateConfigurationInput) *s3.GetBucketAccelerateConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketAccelerateConfigurationInput) *s3.GetBucketAccelerateConfigurationOutput); ok { + r1 = returnFunc(getBucketAccelerateConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketAccelerateConfigurationOutput) } } - return r0, r1 } -// GetBucketAccelerateConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketAccelerateConfigurationWithContext(_a0 context.Context, _a1 *s3.GetBucketAccelerateConfigurationInput, _a2 ...request.Option) (*s3.GetBucketAccelerateConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketAccelerateConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAccelerateConfigurationRequest' +type S3API_GetBucketAccelerateConfigurationRequest_Call struct { + *mock.Call +} + +// GetBucketAccelerateConfigurationRequest is a helper method to define mock.On call +// - getBucketAccelerateConfigurationInput *s3.GetBucketAccelerateConfigurationInput +func (_e *S3API_Expecter) GetBucketAccelerateConfigurationRequest(getBucketAccelerateConfigurationInput interface{}) *S3API_GetBucketAccelerateConfigurationRequest_Call { + return &S3API_GetBucketAccelerateConfigurationRequest_Call{Call: _e.mock.On("GetBucketAccelerateConfigurationRequest", getBucketAccelerateConfigurationInput)} +} + +func (_c *S3API_GetBucketAccelerateConfigurationRequest_Call) Run(run func(getBucketAccelerateConfigurationInput *s3.GetBucketAccelerateConfigurationInput)) *S3API_GetBucketAccelerateConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketAccelerateConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketAccelerateConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketAccelerateConfigurationRequest_Call) Return(request1 *request.Request, getBucketAccelerateConfigurationOutput *s3.GetBucketAccelerateConfigurationOutput) *S3API_GetBucketAccelerateConfigurationRequest_Call { + _c.Call.Return(request1, getBucketAccelerateConfigurationOutput) + return _c +} + +func (_c *S3API_GetBucketAccelerateConfigurationRequest_Call) RunAndReturn(run func(getBucketAccelerateConfigurationInput *s3.GetBucketAccelerateConfigurationInput) (*request.Request, *s3.GetBucketAccelerateConfigurationOutput)) *S3API_GetBucketAccelerateConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketAccelerateConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketAccelerateConfigurationWithContext(v aws.Context, getBucketAccelerateConfigurationInput *s3.GetBucketAccelerateConfigurationInput, options ...request.Option) (*s3.GetBucketAccelerateConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketAccelerateConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, getBucketAccelerateConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketAccelerateConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketAccelerateConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketAccelerateConfigurationInput, ...request.Option) (*s3.GetBucketAccelerateConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketAccelerateConfigurationInput, ...request.Option) (*s3.GetBucketAccelerateConfigurationOutput, error)); ok { + return returnFunc(v, getBucketAccelerateConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketAccelerateConfigurationInput, ...request.Option) *s3.GetBucketAccelerateConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketAccelerateConfigurationInput, ...request.Option) *s3.GetBucketAccelerateConfigurationOutput); ok { + r0 = returnFunc(v, getBucketAccelerateConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketAccelerateConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketAccelerateConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketAccelerateConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketAccelerateConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketAcl provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketAcl(_a0 *s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketAccelerateConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAccelerateConfigurationWithContext' +type S3API_GetBucketAccelerateConfigurationWithContext_Call struct { + *mock.Call +} + +// GetBucketAccelerateConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketAccelerateConfigurationInput *s3.GetBucketAccelerateConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketAccelerateConfigurationWithContext(v interface{}, getBucketAccelerateConfigurationInput interface{}, options ...interface{}) *S3API_GetBucketAccelerateConfigurationWithContext_Call { + return &S3API_GetBucketAccelerateConfigurationWithContext_Call{Call: _e.mock.On("GetBucketAccelerateConfigurationWithContext", + append([]interface{}{v, getBucketAccelerateConfigurationInput}, options...)...)} +} + +func (_c *S3API_GetBucketAccelerateConfigurationWithContext_Call) Run(run func(v aws.Context, getBucketAccelerateConfigurationInput *s3.GetBucketAccelerateConfigurationInput, options ...request.Option)) *S3API_GetBucketAccelerateConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketAccelerateConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketAccelerateConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketAccelerateConfigurationWithContext_Call) Return(getBucketAccelerateConfigurationOutput *s3.GetBucketAccelerateConfigurationOutput, err error) *S3API_GetBucketAccelerateConfigurationWithContext_Call { + _c.Call.Return(getBucketAccelerateConfigurationOutput, err) + return _c +} + +func (_c *S3API_GetBucketAccelerateConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketAccelerateConfigurationInput *s3.GetBucketAccelerateConfigurationInput, options ...request.Option) (*s3.GetBucketAccelerateConfigurationOutput, error)) *S3API_GetBucketAccelerateConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketAcl provides a mock function for the type S3API +func (_mock *S3API) GetBucketAcl(getBucketAclInput *s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error) { + ret := _mock.Called(getBucketAclInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketAcl") + } var r0 *s3.GetBucketAclOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error)); ok { + return returnFunc(getBucketAclInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketAclInput) *s3.GetBucketAclOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketAclInput) *s3.GetBucketAclOutput); ok { + r0 = returnFunc(getBucketAclInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketAclOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketAclInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketAclInput) error); ok { + r1 = returnFunc(getBucketAclInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketAclRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketAclRequest(_a0 *s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketAcl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAcl' +type S3API_GetBucketAcl_Call struct { + *mock.Call +} + +// GetBucketAcl is a helper method to define mock.On call +// - getBucketAclInput *s3.GetBucketAclInput +func (_e *S3API_Expecter) GetBucketAcl(getBucketAclInput interface{}) *S3API_GetBucketAcl_Call { + return &S3API_GetBucketAcl_Call{Call: _e.mock.On("GetBucketAcl", getBucketAclInput)} +} + +func (_c *S3API_GetBucketAcl_Call) Run(run func(getBucketAclInput *s3.GetBucketAclInput)) *S3API_GetBucketAcl_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketAclInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketAclInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketAcl_Call) Return(getBucketAclOutput *s3.GetBucketAclOutput, err error) *S3API_GetBucketAcl_Call { + _c.Call.Return(getBucketAclOutput, err) + return _c +} + +func (_c *S3API_GetBucketAcl_Call) RunAndReturn(run func(getBucketAclInput *s3.GetBucketAclInput) (*s3.GetBucketAclOutput, error)) *S3API_GetBucketAcl_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketAclRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketAclRequest(getBucketAclInput *s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput) { + ret := _mock.Called(getBucketAclInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketAclRequest") + } var r0 *request.Request var r1 *s3.GetBucketAclOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput)); ok { + return returnFunc(getBucketAclInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketAclInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketAclInput) *request.Request); ok { + r0 = returnFunc(getBucketAclInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketAclInput) *s3.GetBucketAclOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketAclInput) *s3.GetBucketAclOutput); ok { + r1 = returnFunc(getBucketAclInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketAclOutput) } } - return r0, r1 } -// GetBucketAclWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketAclWithContext(_a0 context.Context, _a1 *s3.GetBucketAclInput, _a2 ...request.Option) (*s3.GetBucketAclOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketAclRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAclRequest' +type S3API_GetBucketAclRequest_Call struct { + *mock.Call +} + +// GetBucketAclRequest is a helper method to define mock.On call +// - getBucketAclInput *s3.GetBucketAclInput +func (_e *S3API_Expecter) GetBucketAclRequest(getBucketAclInput interface{}) *S3API_GetBucketAclRequest_Call { + return &S3API_GetBucketAclRequest_Call{Call: _e.mock.On("GetBucketAclRequest", getBucketAclInput)} +} + +func (_c *S3API_GetBucketAclRequest_Call) Run(run func(getBucketAclInput *s3.GetBucketAclInput)) *S3API_GetBucketAclRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketAclInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketAclInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketAclRequest_Call) Return(request1 *request.Request, getBucketAclOutput *s3.GetBucketAclOutput) *S3API_GetBucketAclRequest_Call { + _c.Call.Return(request1, getBucketAclOutput) + return _c +} + +func (_c *S3API_GetBucketAclRequest_Call) RunAndReturn(run func(getBucketAclInput *s3.GetBucketAclInput) (*request.Request, *s3.GetBucketAclOutput)) *S3API_GetBucketAclRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketAclWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketAclWithContext(v aws.Context, getBucketAclInput *s3.GetBucketAclInput, options ...request.Option) (*s3.GetBucketAclOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketAclInput, options) + } else { + tmpRet = _mock.Called(v, getBucketAclInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketAclWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketAclOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketAclInput, ...request.Option) (*s3.GetBucketAclOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketAclInput, ...request.Option) (*s3.GetBucketAclOutput, error)); ok { + return returnFunc(v, getBucketAclInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketAclInput, ...request.Option) *s3.GetBucketAclOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketAclInput, ...request.Option) *s3.GetBucketAclOutput); ok { + r0 = returnFunc(v, getBucketAclInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketAclOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketAclInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketAclInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketAclInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketAnalyticsConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketAnalyticsConfiguration(_a0 *s3.GetBucketAnalyticsConfigurationInput) (*s3.GetBucketAnalyticsConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketAclWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAclWithContext' +type S3API_GetBucketAclWithContext_Call struct { + *mock.Call +} + +// GetBucketAclWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketAclInput *s3.GetBucketAclInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketAclWithContext(v interface{}, getBucketAclInput interface{}, options ...interface{}) *S3API_GetBucketAclWithContext_Call { + return &S3API_GetBucketAclWithContext_Call{Call: _e.mock.On("GetBucketAclWithContext", + append([]interface{}{v, getBucketAclInput}, options...)...)} +} + +func (_c *S3API_GetBucketAclWithContext_Call) Run(run func(v aws.Context, getBucketAclInput *s3.GetBucketAclInput, options ...request.Option)) *S3API_GetBucketAclWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketAclInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketAclInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketAclWithContext_Call) Return(getBucketAclOutput *s3.GetBucketAclOutput, err error) *S3API_GetBucketAclWithContext_Call { + _c.Call.Return(getBucketAclOutput, err) + return _c +} + +func (_c *S3API_GetBucketAclWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketAclInput *s3.GetBucketAclInput, options ...request.Option) (*s3.GetBucketAclOutput, error)) *S3API_GetBucketAclWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketAnalyticsConfiguration provides a mock function for the type S3API +func (_mock *S3API) GetBucketAnalyticsConfiguration(getBucketAnalyticsConfigurationInput *s3.GetBucketAnalyticsConfigurationInput) (*s3.GetBucketAnalyticsConfigurationOutput, error) { + ret := _mock.Called(getBucketAnalyticsConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketAnalyticsConfiguration") + } var r0 *s3.GetBucketAnalyticsConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketAnalyticsConfigurationInput) (*s3.GetBucketAnalyticsConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketAnalyticsConfigurationInput) (*s3.GetBucketAnalyticsConfigurationOutput, error)); ok { + return returnFunc(getBucketAnalyticsConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketAnalyticsConfigurationInput) *s3.GetBucketAnalyticsConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketAnalyticsConfigurationInput) *s3.GetBucketAnalyticsConfigurationOutput); ok { + r0 = returnFunc(getBucketAnalyticsConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketAnalyticsConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketAnalyticsConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketAnalyticsConfigurationInput) error); ok { + r1 = returnFunc(getBucketAnalyticsConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketAnalyticsConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketAnalyticsConfigurationRequest(_a0 *s3.GetBucketAnalyticsConfigurationInput) (*request.Request, *s3.GetBucketAnalyticsConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketAnalyticsConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAnalyticsConfiguration' +type S3API_GetBucketAnalyticsConfiguration_Call struct { + *mock.Call +} - var r0 *request.Request - var r1 *s3.GetBucketAnalyticsConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketAnalyticsConfigurationInput) (*request.Request, *s3.GetBucketAnalyticsConfigurationOutput)); ok { - return rf(_a0) - } - if rf, ok := ret.Get(0).(func(*s3.GetBucketAnalyticsConfigurationInput) *request.Request); ok { - r0 = rf(_a0) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*request.Request) +// GetBucketAnalyticsConfiguration is a helper method to define mock.On call +// - getBucketAnalyticsConfigurationInput *s3.GetBucketAnalyticsConfigurationInput +func (_e *S3API_Expecter) GetBucketAnalyticsConfiguration(getBucketAnalyticsConfigurationInput interface{}) *S3API_GetBucketAnalyticsConfiguration_Call { + return &S3API_GetBucketAnalyticsConfiguration_Call{Call: _e.mock.On("GetBucketAnalyticsConfiguration", getBucketAnalyticsConfigurationInput)} +} + +func (_c *S3API_GetBucketAnalyticsConfiguration_Call) Run(run func(getBucketAnalyticsConfigurationInput *s3.GetBucketAnalyticsConfigurationInput)) *S3API_GetBucketAnalyticsConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketAnalyticsConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketAnalyticsConfigurationInput) } - } + run( + arg0, + ) + }) + return _c +} - if rf, ok := ret.Get(1).(func(*s3.GetBucketAnalyticsConfigurationInput) *s3.GetBucketAnalyticsConfigurationOutput); ok { - r1 = rf(_a0) +func (_c *S3API_GetBucketAnalyticsConfiguration_Call) Return(getBucketAnalyticsConfigurationOutput *s3.GetBucketAnalyticsConfigurationOutput, err error) *S3API_GetBucketAnalyticsConfiguration_Call { + _c.Call.Return(getBucketAnalyticsConfigurationOutput, err) + return _c +} + +func (_c *S3API_GetBucketAnalyticsConfiguration_Call) RunAndReturn(run func(getBucketAnalyticsConfigurationInput *s3.GetBucketAnalyticsConfigurationInput) (*s3.GetBucketAnalyticsConfigurationOutput, error)) *S3API_GetBucketAnalyticsConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketAnalyticsConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketAnalyticsConfigurationRequest(getBucketAnalyticsConfigurationInput *s3.GetBucketAnalyticsConfigurationInput) (*request.Request, *s3.GetBucketAnalyticsConfigurationOutput) { + ret := _mock.Called(getBucketAnalyticsConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketAnalyticsConfigurationRequest") + } + + var r0 *request.Request + var r1 *s3.GetBucketAnalyticsConfigurationOutput + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketAnalyticsConfigurationInput) (*request.Request, *s3.GetBucketAnalyticsConfigurationOutput)); ok { + return returnFunc(getBucketAnalyticsConfigurationInput) + } + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketAnalyticsConfigurationInput) *request.Request); ok { + r0 = returnFunc(getBucketAnalyticsConfigurationInput) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*request.Request) + } + } + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketAnalyticsConfigurationInput) *s3.GetBucketAnalyticsConfigurationOutput); ok { + r1 = returnFunc(getBucketAnalyticsConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketAnalyticsConfigurationOutput) } } - return r0, r1 } -// GetBucketAnalyticsConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketAnalyticsConfigurationWithContext(_a0 context.Context, _a1 *s3.GetBucketAnalyticsConfigurationInput, _a2 ...request.Option) (*s3.GetBucketAnalyticsConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketAnalyticsConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAnalyticsConfigurationRequest' +type S3API_GetBucketAnalyticsConfigurationRequest_Call struct { + *mock.Call +} + +// GetBucketAnalyticsConfigurationRequest is a helper method to define mock.On call +// - getBucketAnalyticsConfigurationInput *s3.GetBucketAnalyticsConfigurationInput +func (_e *S3API_Expecter) GetBucketAnalyticsConfigurationRequest(getBucketAnalyticsConfigurationInput interface{}) *S3API_GetBucketAnalyticsConfigurationRequest_Call { + return &S3API_GetBucketAnalyticsConfigurationRequest_Call{Call: _e.mock.On("GetBucketAnalyticsConfigurationRequest", getBucketAnalyticsConfigurationInput)} +} + +func (_c *S3API_GetBucketAnalyticsConfigurationRequest_Call) Run(run func(getBucketAnalyticsConfigurationInput *s3.GetBucketAnalyticsConfigurationInput)) *S3API_GetBucketAnalyticsConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketAnalyticsConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketAnalyticsConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketAnalyticsConfigurationRequest_Call) Return(request1 *request.Request, getBucketAnalyticsConfigurationOutput *s3.GetBucketAnalyticsConfigurationOutput) *S3API_GetBucketAnalyticsConfigurationRequest_Call { + _c.Call.Return(request1, getBucketAnalyticsConfigurationOutput) + return _c +} + +func (_c *S3API_GetBucketAnalyticsConfigurationRequest_Call) RunAndReturn(run func(getBucketAnalyticsConfigurationInput *s3.GetBucketAnalyticsConfigurationInput) (*request.Request, *s3.GetBucketAnalyticsConfigurationOutput)) *S3API_GetBucketAnalyticsConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketAnalyticsConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketAnalyticsConfigurationWithContext(v aws.Context, getBucketAnalyticsConfigurationInput *s3.GetBucketAnalyticsConfigurationInput, options ...request.Option) (*s3.GetBucketAnalyticsConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketAnalyticsConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, getBucketAnalyticsConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketAnalyticsConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketAnalyticsConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketAnalyticsConfigurationInput, ...request.Option) (*s3.GetBucketAnalyticsConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketAnalyticsConfigurationInput, ...request.Option) (*s3.GetBucketAnalyticsConfigurationOutput, error)); ok { + return returnFunc(v, getBucketAnalyticsConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketAnalyticsConfigurationInput, ...request.Option) *s3.GetBucketAnalyticsConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketAnalyticsConfigurationInput, ...request.Option) *s3.GetBucketAnalyticsConfigurationOutput); ok { + r0 = returnFunc(v, getBucketAnalyticsConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketAnalyticsConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketAnalyticsConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketAnalyticsConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketAnalyticsConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketCors provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketCors(_a0 *s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketAnalyticsConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketAnalyticsConfigurationWithContext' +type S3API_GetBucketAnalyticsConfigurationWithContext_Call struct { + *mock.Call +} + +// GetBucketAnalyticsConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketAnalyticsConfigurationInput *s3.GetBucketAnalyticsConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketAnalyticsConfigurationWithContext(v interface{}, getBucketAnalyticsConfigurationInput interface{}, options ...interface{}) *S3API_GetBucketAnalyticsConfigurationWithContext_Call { + return &S3API_GetBucketAnalyticsConfigurationWithContext_Call{Call: _e.mock.On("GetBucketAnalyticsConfigurationWithContext", + append([]interface{}{v, getBucketAnalyticsConfigurationInput}, options...)...)} +} + +func (_c *S3API_GetBucketAnalyticsConfigurationWithContext_Call) Run(run func(v aws.Context, getBucketAnalyticsConfigurationInput *s3.GetBucketAnalyticsConfigurationInput, options ...request.Option)) *S3API_GetBucketAnalyticsConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketAnalyticsConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketAnalyticsConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketAnalyticsConfigurationWithContext_Call) Return(getBucketAnalyticsConfigurationOutput *s3.GetBucketAnalyticsConfigurationOutput, err error) *S3API_GetBucketAnalyticsConfigurationWithContext_Call { + _c.Call.Return(getBucketAnalyticsConfigurationOutput, err) + return _c +} + +func (_c *S3API_GetBucketAnalyticsConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketAnalyticsConfigurationInput *s3.GetBucketAnalyticsConfigurationInput, options ...request.Option) (*s3.GetBucketAnalyticsConfigurationOutput, error)) *S3API_GetBucketAnalyticsConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketCors provides a mock function for the type S3API +func (_mock *S3API) GetBucketCors(getBucketCorsInput *s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error) { + ret := _mock.Called(getBucketCorsInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketCors") + } var r0 *s3.GetBucketCorsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error)); ok { + return returnFunc(getBucketCorsInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketCorsInput) *s3.GetBucketCorsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketCorsInput) *s3.GetBucketCorsOutput); ok { + r0 = returnFunc(getBucketCorsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketCorsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketCorsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketCorsInput) error); ok { + r1 = returnFunc(getBucketCorsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketCorsRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketCorsRequest(_a0 *s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketCors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketCors' +type S3API_GetBucketCors_Call struct { + *mock.Call +} + +// GetBucketCors is a helper method to define mock.On call +// - getBucketCorsInput *s3.GetBucketCorsInput +func (_e *S3API_Expecter) GetBucketCors(getBucketCorsInput interface{}) *S3API_GetBucketCors_Call { + return &S3API_GetBucketCors_Call{Call: _e.mock.On("GetBucketCors", getBucketCorsInput)} +} + +func (_c *S3API_GetBucketCors_Call) Run(run func(getBucketCorsInput *s3.GetBucketCorsInput)) *S3API_GetBucketCors_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketCorsInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketCorsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketCors_Call) Return(getBucketCorsOutput *s3.GetBucketCorsOutput, err error) *S3API_GetBucketCors_Call { + _c.Call.Return(getBucketCorsOutput, err) + return _c +} + +func (_c *S3API_GetBucketCors_Call) RunAndReturn(run func(getBucketCorsInput *s3.GetBucketCorsInput) (*s3.GetBucketCorsOutput, error)) *S3API_GetBucketCors_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketCorsRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketCorsRequest(getBucketCorsInput *s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput) { + ret := _mock.Called(getBucketCorsInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketCorsRequest") + } var r0 *request.Request var r1 *s3.GetBucketCorsOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput)); ok { + return returnFunc(getBucketCorsInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketCorsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketCorsInput) *request.Request); ok { + r0 = returnFunc(getBucketCorsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketCorsInput) *s3.GetBucketCorsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketCorsInput) *s3.GetBucketCorsOutput); ok { + r1 = returnFunc(getBucketCorsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketCorsOutput) } } - return r0, r1 } -// GetBucketCorsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketCorsWithContext(_a0 context.Context, _a1 *s3.GetBucketCorsInput, _a2 ...request.Option) (*s3.GetBucketCorsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketCorsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketCorsRequest' +type S3API_GetBucketCorsRequest_Call struct { + *mock.Call +} + +// GetBucketCorsRequest is a helper method to define mock.On call +// - getBucketCorsInput *s3.GetBucketCorsInput +func (_e *S3API_Expecter) GetBucketCorsRequest(getBucketCorsInput interface{}) *S3API_GetBucketCorsRequest_Call { + return &S3API_GetBucketCorsRequest_Call{Call: _e.mock.On("GetBucketCorsRequest", getBucketCorsInput)} +} + +func (_c *S3API_GetBucketCorsRequest_Call) Run(run func(getBucketCorsInput *s3.GetBucketCorsInput)) *S3API_GetBucketCorsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketCorsInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketCorsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketCorsRequest_Call) Return(request1 *request.Request, getBucketCorsOutput *s3.GetBucketCorsOutput) *S3API_GetBucketCorsRequest_Call { + _c.Call.Return(request1, getBucketCorsOutput) + return _c +} + +func (_c *S3API_GetBucketCorsRequest_Call) RunAndReturn(run func(getBucketCorsInput *s3.GetBucketCorsInput) (*request.Request, *s3.GetBucketCorsOutput)) *S3API_GetBucketCorsRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketCorsWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketCorsWithContext(v aws.Context, getBucketCorsInput *s3.GetBucketCorsInput, options ...request.Option) (*s3.GetBucketCorsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketCorsInput, options) + } else { + tmpRet = _mock.Called(v, getBucketCorsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketCorsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketCorsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketCorsInput, ...request.Option) (*s3.GetBucketCorsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketCorsInput, ...request.Option) (*s3.GetBucketCorsOutput, error)); ok { + return returnFunc(v, getBucketCorsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketCorsInput, ...request.Option) *s3.GetBucketCorsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketCorsInput, ...request.Option) *s3.GetBucketCorsOutput); ok { + r0 = returnFunc(v, getBucketCorsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketCorsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketCorsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketCorsInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketCorsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketEncryption provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketEncryption(_a0 *s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketCorsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketCorsWithContext' +type S3API_GetBucketCorsWithContext_Call struct { + *mock.Call +} + +// GetBucketCorsWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketCorsInput *s3.GetBucketCorsInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketCorsWithContext(v interface{}, getBucketCorsInput interface{}, options ...interface{}) *S3API_GetBucketCorsWithContext_Call { + return &S3API_GetBucketCorsWithContext_Call{Call: _e.mock.On("GetBucketCorsWithContext", + append([]interface{}{v, getBucketCorsInput}, options...)...)} +} + +func (_c *S3API_GetBucketCorsWithContext_Call) Run(run func(v aws.Context, getBucketCorsInput *s3.GetBucketCorsInput, options ...request.Option)) *S3API_GetBucketCorsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketCorsInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketCorsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketCorsWithContext_Call) Return(getBucketCorsOutput *s3.GetBucketCorsOutput, err error) *S3API_GetBucketCorsWithContext_Call { + _c.Call.Return(getBucketCorsOutput, err) + return _c +} + +func (_c *S3API_GetBucketCorsWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketCorsInput *s3.GetBucketCorsInput, options ...request.Option) (*s3.GetBucketCorsOutput, error)) *S3API_GetBucketCorsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketEncryption provides a mock function for the type S3API +func (_mock *S3API) GetBucketEncryption(getBucketEncryptionInput *s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error) { + ret := _mock.Called(getBucketEncryptionInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketEncryption") + } var r0 *s3.GetBucketEncryptionOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error)); ok { + return returnFunc(getBucketEncryptionInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketEncryptionInput) *s3.GetBucketEncryptionOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketEncryptionInput) *s3.GetBucketEncryptionOutput); ok { + r0 = returnFunc(getBucketEncryptionInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketEncryptionOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketEncryptionInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketEncryptionInput) error); ok { + r1 = returnFunc(getBucketEncryptionInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketEncryptionRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketEncryptionRequest(_a0 *s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketEncryption_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketEncryption' +type S3API_GetBucketEncryption_Call struct { + *mock.Call +} + +// GetBucketEncryption is a helper method to define mock.On call +// - getBucketEncryptionInput *s3.GetBucketEncryptionInput +func (_e *S3API_Expecter) GetBucketEncryption(getBucketEncryptionInput interface{}) *S3API_GetBucketEncryption_Call { + return &S3API_GetBucketEncryption_Call{Call: _e.mock.On("GetBucketEncryption", getBucketEncryptionInput)} +} + +func (_c *S3API_GetBucketEncryption_Call) Run(run func(getBucketEncryptionInput *s3.GetBucketEncryptionInput)) *S3API_GetBucketEncryption_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketEncryptionInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketEncryptionInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketEncryption_Call) Return(getBucketEncryptionOutput *s3.GetBucketEncryptionOutput, err error) *S3API_GetBucketEncryption_Call { + _c.Call.Return(getBucketEncryptionOutput, err) + return _c +} + +func (_c *S3API_GetBucketEncryption_Call) RunAndReturn(run func(getBucketEncryptionInput *s3.GetBucketEncryptionInput) (*s3.GetBucketEncryptionOutput, error)) *S3API_GetBucketEncryption_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketEncryptionRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketEncryptionRequest(getBucketEncryptionInput *s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput) { + ret := _mock.Called(getBucketEncryptionInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketEncryptionRequest") + } var r0 *request.Request var r1 *s3.GetBucketEncryptionOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput)); ok { + return returnFunc(getBucketEncryptionInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketEncryptionInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketEncryptionInput) *request.Request); ok { + r0 = returnFunc(getBucketEncryptionInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketEncryptionInput) *s3.GetBucketEncryptionOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketEncryptionInput) *s3.GetBucketEncryptionOutput); ok { + r1 = returnFunc(getBucketEncryptionInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketEncryptionOutput) } } - return r0, r1 } -// GetBucketEncryptionWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketEncryptionWithContext(_a0 context.Context, _a1 *s3.GetBucketEncryptionInput, _a2 ...request.Option) (*s3.GetBucketEncryptionOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketEncryptionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketEncryptionRequest' +type S3API_GetBucketEncryptionRequest_Call struct { + *mock.Call +} + +// GetBucketEncryptionRequest is a helper method to define mock.On call +// - getBucketEncryptionInput *s3.GetBucketEncryptionInput +func (_e *S3API_Expecter) GetBucketEncryptionRequest(getBucketEncryptionInput interface{}) *S3API_GetBucketEncryptionRequest_Call { + return &S3API_GetBucketEncryptionRequest_Call{Call: _e.mock.On("GetBucketEncryptionRequest", getBucketEncryptionInput)} +} + +func (_c *S3API_GetBucketEncryptionRequest_Call) Run(run func(getBucketEncryptionInput *s3.GetBucketEncryptionInput)) *S3API_GetBucketEncryptionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketEncryptionInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketEncryptionInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketEncryptionRequest_Call) Return(request1 *request.Request, getBucketEncryptionOutput *s3.GetBucketEncryptionOutput) *S3API_GetBucketEncryptionRequest_Call { + _c.Call.Return(request1, getBucketEncryptionOutput) + return _c +} + +func (_c *S3API_GetBucketEncryptionRequest_Call) RunAndReturn(run func(getBucketEncryptionInput *s3.GetBucketEncryptionInput) (*request.Request, *s3.GetBucketEncryptionOutput)) *S3API_GetBucketEncryptionRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketEncryptionWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketEncryptionWithContext(v aws.Context, getBucketEncryptionInput *s3.GetBucketEncryptionInput, options ...request.Option) (*s3.GetBucketEncryptionOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketEncryptionInput, options) + } else { + tmpRet = _mock.Called(v, getBucketEncryptionInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketEncryptionWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketEncryptionOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketEncryptionInput, ...request.Option) (*s3.GetBucketEncryptionOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketEncryptionInput, ...request.Option) (*s3.GetBucketEncryptionOutput, error)); ok { + return returnFunc(v, getBucketEncryptionInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketEncryptionInput, ...request.Option) *s3.GetBucketEncryptionOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketEncryptionInput, ...request.Option) *s3.GetBucketEncryptionOutput); ok { + r0 = returnFunc(v, getBucketEncryptionInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketEncryptionOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketEncryptionInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketEncryptionInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketEncryptionInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketIntelligentTieringConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketIntelligentTieringConfiguration(_a0 *s3.GetBucketIntelligentTieringConfigurationInput) (*s3.GetBucketIntelligentTieringConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketEncryptionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketEncryptionWithContext' +type S3API_GetBucketEncryptionWithContext_Call struct { + *mock.Call +} + +// GetBucketEncryptionWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketEncryptionInput *s3.GetBucketEncryptionInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketEncryptionWithContext(v interface{}, getBucketEncryptionInput interface{}, options ...interface{}) *S3API_GetBucketEncryptionWithContext_Call { + return &S3API_GetBucketEncryptionWithContext_Call{Call: _e.mock.On("GetBucketEncryptionWithContext", + append([]interface{}{v, getBucketEncryptionInput}, options...)...)} +} + +func (_c *S3API_GetBucketEncryptionWithContext_Call) Run(run func(v aws.Context, getBucketEncryptionInput *s3.GetBucketEncryptionInput, options ...request.Option)) *S3API_GetBucketEncryptionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketEncryptionInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketEncryptionInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketEncryptionWithContext_Call) Return(getBucketEncryptionOutput *s3.GetBucketEncryptionOutput, err error) *S3API_GetBucketEncryptionWithContext_Call { + _c.Call.Return(getBucketEncryptionOutput, err) + return _c +} + +func (_c *S3API_GetBucketEncryptionWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketEncryptionInput *s3.GetBucketEncryptionInput, options ...request.Option) (*s3.GetBucketEncryptionOutput, error)) *S3API_GetBucketEncryptionWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketIntelligentTieringConfiguration provides a mock function for the type S3API +func (_mock *S3API) GetBucketIntelligentTieringConfiguration(getBucketIntelligentTieringConfigurationInput *s3.GetBucketIntelligentTieringConfigurationInput) (*s3.GetBucketIntelligentTieringConfigurationOutput, error) { + ret := _mock.Called(getBucketIntelligentTieringConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketIntelligentTieringConfiguration") + } var r0 *s3.GetBucketIntelligentTieringConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketIntelligentTieringConfigurationInput) (*s3.GetBucketIntelligentTieringConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketIntelligentTieringConfigurationInput) (*s3.GetBucketIntelligentTieringConfigurationOutput, error)); ok { + return returnFunc(getBucketIntelligentTieringConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketIntelligentTieringConfigurationInput) *s3.GetBucketIntelligentTieringConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketIntelligentTieringConfigurationInput) *s3.GetBucketIntelligentTieringConfigurationOutput); ok { + r0 = returnFunc(getBucketIntelligentTieringConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketIntelligentTieringConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketIntelligentTieringConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketIntelligentTieringConfigurationInput) error); ok { + r1 = returnFunc(getBucketIntelligentTieringConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketIntelligentTieringConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketIntelligentTieringConfigurationRequest(_a0 *s3.GetBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.GetBucketIntelligentTieringConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketIntelligentTieringConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketIntelligentTieringConfiguration' +type S3API_GetBucketIntelligentTieringConfiguration_Call struct { + *mock.Call +} + +// GetBucketIntelligentTieringConfiguration is a helper method to define mock.On call +// - getBucketIntelligentTieringConfigurationInput *s3.GetBucketIntelligentTieringConfigurationInput +func (_e *S3API_Expecter) GetBucketIntelligentTieringConfiguration(getBucketIntelligentTieringConfigurationInput interface{}) *S3API_GetBucketIntelligentTieringConfiguration_Call { + return &S3API_GetBucketIntelligentTieringConfiguration_Call{Call: _e.mock.On("GetBucketIntelligentTieringConfiguration", getBucketIntelligentTieringConfigurationInput)} +} + +func (_c *S3API_GetBucketIntelligentTieringConfiguration_Call) Run(run func(getBucketIntelligentTieringConfigurationInput *s3.GetBucketIntelligentTieringConfigurationInput)) *S3API_GetBucketIntelligentTieringConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketIntelligentTieringConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketIntelligentTieringConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketIntelligentTieringConfiguration_Call) Return(getBucketIntelligentTieringConfigurationOutput *s3.GetBucketIntelligentTieringConfigurationOutput, err error) *S3API_GetBucketIntelligentTieringConfiguration_Call { + _c.Call.Return(getBucketIntelligentTieringConfigurationOutput, err) + return _c +} + +func (_c *S3API_GetBucketIntelligentTieringConfiguration_Call) RunAndReturn(run func(getBucketIntelligentTieringConfigurationInput *s3.GetBucketIntelligentTieringConfigurationInput) (*s3.GetBucketIntelligentTieringConfigurationOutput, error)) *S3API_GetBucketIntelligentTieringConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketIntelligentTieringConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketIntelligentTieringConfigurationRequest(getBucketIntelligentTieringConfigurationInput *s3.GetBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.GetBucketIntelligentTieringConfigurationOutput) { + ret := _mock.Called(getBucketIntelligentTieringConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketIntelligentTieringConfigurationRequest") + } var r0 *request.Request var r1 *s3.GetBucketIntelligentTieringConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.GetBucketIntelligentTieringConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.GetBucketIntelligentTieringConfigurationOutput)); ok { + return returnFunc(getBucketIntelligentTieringConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketIntelligentTieringConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketIntelligentTieringConfigurationInput) *request.Request); ok { + r0 = returnFunc(getBucketIntelligentTieringConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketIntelligentTieringConfigurationInput) *s3.GetBucketIntelligentTieringConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketIntelligentTieringConfigurationInput) *s3.GetBucketIntelligentTieringConfigurationOutput); ok { + r1 = returnFunc(getBucketIntelligentTieringConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketIntelligentTieringConfigurationOutput) } } - return r0, r1 } -// GetBucketIntelligentTieringConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketIntelligentTieringConfigurationWithContext(_a0 context.Context, _a1 *s3.GetBucketIntelligentTieringConfigurationInput, _a2 ...request.Option) (*s3.GetBucketIntelligentTieringConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketIntelligentTieringConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketIntelligentTieringConfigurationRequest' +type S3API_GetBucketIntelligentTieringConfigurationRequest_Call struct { + *mock.Call +} + +// GetBucketIntelligentTieringConfigurationRequest is a helper method to define mock.On call +// - getBucketIntelligentTieringConfigurationInput *s3.GetBucketIntelligentTieringConfigurationInput +func (_e *S3API_Expecter) GetBucketIntelligentTieringConfigurationRequest(getBucketIntelligentTieringConfigurationInput interface{}) *S3API_GetBucketIntelligentTieringConfigurationRequest_Call { + return &S3API_GetBucketIntelligentTieringConfigurationRequest_Call{Call: _e.mock.On("GetBucketIntelligentTieringConfigurationRequest", getBucketIntelligentTieringConfigurationInput)} +} + +func (_c *S3API_GetBucketIntelligentTieringConfigurationRequest_Call) Run(run func(getBucketIntelligentTieringConfigurationInput *s3.GetBucketIntelligentTieringConfigurationInput)) *S3API_GetBucketIntelligentTieringConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketIntelligentTieringConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketIntelligentTieringConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketIntelligentTieringConfigurationRequest_Call) Return(request1 *request.Request, getBucketIntelligentTieringConfigurationOutput *s3.GetBucketIntelligentTieringConfigurationOutput) *S3API_GetBucketIntelligentTieringConfigurationRequest_Call { + _c.Call.Return(request1, getBucketIntelligentTieringConfigurationOutput) + return _c +} + +func (_c *S3API_GetBucketIntelligentTieringConfigurationRequest_Call) RunAndReturn(run func(getBucketIntelligentTieringConfigurationInput *s3.GetBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.GetBucketIntelligentTieringConfigurationOutput)) *S3API_GetBucketIntelligentTieringConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketIntelligentTieringConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketIntelligentTieringConfigurationWithContext(v aws.Context, getBucketIntelligentTieringConfigurationInput *s3.GetBucketIntelligentTieringConfigurationInput, options ...request.Option) (*s3.GetBucketIntelligentTieringConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketIntelligentTieringConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, getBucketIntelligentTieringConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketIntelligentTieringConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketIntelligentTieringConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.GetBucketIntelligentTieringConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.GetBucketIntelligentTieringConfigurationOutput, error)); ok { + return returnFunc(v, getBucketIntelligentTieringConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketIntelligentTieringConfigurationInput, ...request.Option) *s3.GetBucketIntelligentTieringConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketIntelligentTieringConfigurationInput, ...request.Option) *s3.GetBucketIntelligentTieringConfigurationOutput); ok { + r0 = returnFunc(v, getBucketIntelligentTieringConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketIntelligentTieringConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketIntelligentTieringConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketIntelligentTieringConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketIntelligentTieringConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketInventoryConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketInventoryConfiguration(_a0 *s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketIntelligentTieringConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketIntelligentTieringConfigurationWithContext' +type S3API_GetBucketIntelligentTieringConfigurationWithContext_Call struct { + *mock.Call +} + +// GetBucketIntelligentTieringConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketIntelligentTieringConfigurationInput *s3.GetBucketIntelligentTieringConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketIntelligentTieringConfigurationWithContext(v interface{}, getBucketIntelligentTieringConfigurationInput interface{}, options ...interface{}) *S3API_GetBucketIntelligentTieringConfigurationWithContext_Call { + return &S3API_GetBucketIntelligentTieringConfigurationWithContext_Call{Call: _e.mock.On("GetBucketIntelligentTieringConfigurationWithContext", + append([]interface{}{v, getBucketIntelligentTieringConfigurationInput}, options...)...)} +} + +func (_c *S3API_GetBucketIntelligentTieringConfigurationWithContext_Call) Run(run func(v aws.Context, getBucketIntelligentTieringConfigurationInput *s3.GetBucketIntelligentTieringConfigurationInput, options ...request.Option)) *S3API_GetBucketIntelligentTieringConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketIntelligentTieringConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketIntelligentTieringConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketIntelligentTieringConfigurationWithContext_Call) Return(getBucketIntelligentTieringConfigurationOutput *s3.GetBucketIntelligentTieringConfigurationOutput, err error) *S3API_GetBucketIntelligentTieringConfigurationWithContext_Call { + _c.Call.Return(getBucketIntelligentTieringConfigurationOutput, err) + return _c +} + +func (_c *S3API_GetBucketIntelligentTieringConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketIntelligentTieringConfigurationInput *s3.GetBucketIntelligentTieringConfigurationInput, options ...request.Option) (*s3.GetBucketIntelligentTieringConfigurationOutput, error)) *S3API_GetBucketIntelligentTieringConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketInventoryConfiguration provides a mock function for the type S3API +func (_mock *S3API) GetBucketInventoryConfiguration(getBucketInventoryConfigurationInput *s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error) { + ret := _mock.Called(getBucketInventoryConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketInventoryConfiguration") + } var r0 *s3.GetBucketInventoryConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error)); ok { + return returnFunc(getBucketInventoryConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketInventoryConfigurationInput) *s3.GetBucketInventoryConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketInventoryConfigurationInput) *s3.GetBucketInventoryConfigurationOutput); ok { + r0 = returnFunc(getBucketInventoryConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketInventoryConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketInventoryConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketInventoryConfigurationInput) error); ok { + r1 = returnFunc(getBucketInventoryConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketInventoryConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketInventoryConfigurationRequest(_a0 *s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketInventoryConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketInventoryConfiguration' +type S3API_GetBucketInventoryConfiguration_Call struct { + *mock.Call +} + +// GetBucketInventoryConfiguration is a helper method to define mock.On call +// - getBucketInventoryConfigurationInput *s3.GetBucketInventoryConfigurationInput +func (_e *S3API_Expecter) GetBucketInventoryConfiguration(getBucketInventoryConfigurationInput interface{}) *S3API_GetBucketInventoryConfiguration_Call { + return &S3API_GetBucketInventoryConfiguration_Call{Call: _e.mock.On("GetBucketInventoryConfiguration", getBucketInventoryConfigurationInput)} +} + +func (_c *S3API_GetBucketInventoryConfiguration_Call) Run(run func(getBucketInventoryConfigurationInput *s3.GetBucketInventoryConfigurationInput)) *S3API_GetBucketInventoryConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketInventoryConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketInventoryConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketInventoryConfiguration_Call) Return(getBucketInventoryConfigurationOutput *s3.GetBucketInventoryConfigurationOutput, err error) *S3API_GetBucketInventoryConfiguration_Call { + _c.Call.Return(getBucketInventoryConfigurationOutput, err) + return _c +} + +func (_c *S3API_GetBucketInventoryConfiguration_Call) RunAndReturn(run func(getBucketInventoryConfigurationInput *s3.GetBucketInventoryConfigurationInput) (*s3.GetBucketInventoryConfigurationOutput, error)) *S3API_GetBucketInventoryConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketInventoryConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketInventoryConfigurationRequest(getBucketInventoryConfigurationInput *s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput) { + ret := _mock.Called(getBucketInventoryConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketInventoryConfigurationRequest") + } var r0 *request.Request var r1 *s3.GetBucketInventoryConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput)); ok { + return returnFunc(getBucketInventoryConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketInventoryConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketInventoryConfigurationInput) *request.Request); ok { + r0 = returnFunc(getBucketInventoryConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketInventoryConfigurationInput) *s3.GetBucketInventoryConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketInventoryConfigurationInput) *s3.GetBucketInventoryConfigurationOutput); ok { + r1 = returnFunc(getBucketInventoryConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketInventoryConfigurationOutput) } } - return r0, r1 } -// GetBucketInventoryConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketInventoryConfigurationWithContext(_a0 context.Context, _a1 *s3.GetBucketInventoryConfigurationInput, _a2 ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketInventoryConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketInventoryConfigurationRequest' +type S3API_GetBucketInventoryConfigurationRequest_Call struct { + *mock.Call +} + +// GetBucketInventoryConfigurationRequest is a helper method to define mock.On call +// - getBucketInventoryConfigurationInput *s3.GetBucketInventoryConfigurationInput +func (_e *S3API_Expecter) GetBucketInventoryConfigurationRequest(getBucketInventoryConfigurationInput interface{}) *S3API_GetBucketInventoryConfigurationRequest_Call { + return &S3API_GetBucketInventoryConfigurationRequest_Call{Call: _e.mock.On("GetBucketInventoryConfigurationRequest", getBucketInventoryConfigurationInput)} +} + +func (_c *S3API_GetBucketInventoryConfigurationRequest_Call) Run(run func(getBucketInventoryConfigurationInput *s3.GetBucketInventoryConfigurationInput)) *S3API_GetBucketInventoryConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketInventoryConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketInventoryConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketInventoryConfigurationRequest_Call) Return(request1 *request.Request, getBucketInventoryConfigurationOutput *s3.GetBucketInventoryConfigurationOutput) *S3API_GetBucketInventoryConfigurationRequest_Call { + _c.Call.Return(request1, getBucketInventoryConfigurationOutput) + return _c +} + +func (_c *S3API_GetBucketInventoryConfigurationRequest_Call) RunAndReturn(run func(getBucketInventoryConfigurationInput *s3.GetBucketInventoryConfigurationInput) (*request.Request, *s3.GetBucketInventoryConfigurationOutput)) *S3API_GetBucketInventoryConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketInventoryConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketInventoryConfigurationWithContext(v aws.Context, getBucketInventoryConfigurationInput *s3.GetBucketInventoryConfigurationInput, options ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketInventoryConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, getBucketInventoryConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketInventoryConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketInventoryConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketInventoryConfigurationInput, ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketInventoryConfigurationInput, ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error)); ok { + return returnFunc(v, getBucketInventoryConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketInventoryConfigurationInput, ...request.Option) *s3.GetBucketInventoryConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketInventoryConfigurationInput, ...request.Option) *s3.GetBucketInventoryConfigurationOutput); ok { + r0 = returnFunc(v, getBucketInventoryConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketInventoryConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketInventoryConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketInventoryConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketInventoryConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketLifecycle provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketLifecycle(_a0 *s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketInventoryConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketInventoryConfigurationWithContext' +type S3API_GetBucketInventoryConfigurationWithContext_Call struct { + *mock.Call +} + +// GetBucketInventoryConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketInventoryConfigurationInput *s3.GetBucketInventoryConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketInventoryConfigurationWithContext(v interface{}, getBucketInventoryConfigurationInput interface{}, options ...interface{}) *S3API_GetBucketInventoryConfigurationWithContext_Call { + return &S3API_GetBucketInventoryConfigurationWithContext_Call{Call: _e.mock.On("GetBucketInventoryConfigurationWithContext", + append([]interface{}{v, getBucketInventoryConfigurationInput}, options...)...)} +} + +func (_c *S3API_GetBucketInventoryConfigurationWithContext_Call) Run(run func(v aws.Context, getBucketInventoryConfigurationInput *s3.GetBucketInventoryConfigurationInput, options ...request.Option)) *S3API_GetBucketInventoryConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketInventoryConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketInventoryConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketInventoryConfigurationWithContext_Call) Return(getBucketInventoryConfigurationOutput *s3.GetBucketInventoryConfigurationOutput, err error) *S3API_GetBucketInventoryConfigurationWithContext_Call { + _c.Call.Return(getBucketInventoryConfigurationOutput, err) + return _c +} + +func (_c *S3API_GetBucketInventoryConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketInventoryConfigurationInput *s3.GetBucketInventoryConfigurationInput, options ...request.Option) (*s3.GetBucketInventoryConfigurationOutput, error)) *S3API_GetBucketInventoryConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketLifecycle provides a mock function for the type S3API +func (_mock *S3API) GetBucketLifecycle(getBucketLifecycleInput *s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error) { + ret := _mock.Called(getBucketLifecycleInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketLifecycle") + } var r0 *s3.GetBucketLifecycleOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error)); ok { + return returnFunc(getBucketLifecycleInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleInput) *s3.GetBucketLifecycleOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLifecycleInput) *s3.GetBucketLifecycleOutput); ok { + r0 = returnFunc(getBucketLifecycleInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketLifecycleOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketLifecycleInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketLifecycleInput) error); ok { + r1 = returnFunc(getBucketLifecycleInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketLifecycleConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketLifecycleConfiguration(_a0 *s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketLifecycle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLifecycle' +type S3API_GetBucketLifecycle_Call struct { + *mock.Call +} + +// GetBucketLifecycle is a helper method to define mock.On call +// - getBucketLifecycleInput *s3.GetBucketLifecycleInput +func (_e *S3API_Expecter) GetBucketLifecycle(getBucketLifecycleInput interface{}) *S3API_GetBucketLifecycle_Call { + return &S3API_GetBucketLifecycle_Call{Call: _e.mock.On("GetBucketLifecycle", getBucketLifecycleInput)} +} + +func (_c *S3API_GetBucketLifecycle_Call) Run(run func(getBucketLifecycleInput *s3.GetBucketLifecycleInput)) *S3API_GetBucketLifecycle_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketLifecycleInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketLifecycleInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketLifecycle_Call) Return(getBucketLifecycleOutput *s3.GetBucketLifecycleOutput, err error) *S3API_GetBucketLifecycle_Call { + _c.Call.Return(getBucketLifecycleOutput, err) + return _c +} + +func (_c *S3API_GetBucketLifecycle_Call) RunAndReturn(run func(getBucketLifecycleInput *s3.GetBucketLifecycleInput) (*s3.GetBucketLifecycleOutput, error)) *S3API_GetBucketLifecycle_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketLifecycleConfiguration provides a mock function for the type S3API +func (_mock *S3API) GetBucketLifecycleConfiguration(getBucketLifecycleConfigurationInput *s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error) { + ret := _mock.Called(getBucketLifecycleConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketLifecycleConfiguration") + } var r0 *s3.GetBucketLifecycleConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error)); ok { + return returnFunc(getBucketLifecycleConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleConfigurationInput) *s3.GetBucketLifecycleConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLifecycleConfigurationInput) *s3.GetBucketLifecycleConfigurationOutput); ok { + r0 = returnFunc(getBucketLifecycleConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketLifecycleConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketLifecycleConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketLifecycleConfigurationInput) error); ok { + r1 = returnFunc(getBucketLifecycleConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketLifecycleConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketLifecycleConfigurationRequest(_a0 *s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketLifecycleConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLifecycleConfiguration' +type S3API_GetBucketLifecycleConfiguration_Call struct { + *mock.Call +} + +// GetBucketLifecycleConfiguration is a helper method to define mock.On call +// - getBucketLifecycleConfigurationInput *s3.GetBucketLifecycleConfigurationInput +func (_e *S3API_Expecter) GetBucketLifecycleConfiguration(getBucketLifecycleConfigurationInput interface{}) *S3API_GetBucketLifecycleConfiguration_Call { + return &S3API_GetBucketLifecycleConfiguration_Call{Call: _e.mock.On("GetBucketLifecycleConfiguration", getBucketLifecycleConfigurationInput)} +} + +func (_c *S3API_GetBucketLifecycleConfiguration_Call) Run(run func(getBucketLifecycleConfigurationInput *s3.GetBucketLifecycleConfigurationInput)) *S3API_GetBucketLifecycleConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketLifecycleConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketLifecycleConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketLifecycleConfiguration_Call) Return(getBucketLifecycleConfigurationOutput *s3.GetBucketLifecycleConfigurationOutput, err error) *S3API_GetBucketLifecycleConfiguration_Call { + _c.Call.Return(getBucketLifecycleConfigurationOutput, err) + return _c +} + +func (_c *S3API_GetBucketLifecycleConfiguration_Call) RunAndReturn(run func(getBucketLifecycleConfigurationInput *s3.GetBucketLifecycleConfigurationInput) (*s3.GetBucketLifecycleConfigurationOutput, error)) *S3API_GetBucketLifecycleConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketLifecycleConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketLifecycleConfigurationRequest(getBucketLifecycleConfigurationInput *s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput) { + ret := _mock.Called(getBucketLifecycleConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketLifecycleConfigurationRequest") + } var r0 *request.Request var r1 *s3.GetBucketLifecycleConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput)); ok { + return returnFunc(getBucketLifecycleConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLifecycleConfigurationInput) *request.Request); ok { + r0 = returnFunc(getBucketLifecycleConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketLifecycleConfigurationInput) *s3.GetBucketLifecycleConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketLifecycleConfigurationInput) *s3.GetBucketLifecycleConfigurationOutput); ok { + r1 = returnFunc(getBucketLifecycleConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketLifecycleConfigurationOutput) } } - return r0, r1 } -// GetBucketLifecycleConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketLifecycleConfigurationWithContext(_a0 context.Context, _a1 *s3.GetBucketLifecycleConfigurationInput, _a2 ...request.Option) (*s3.GetBucketLifecycleConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketLifecycleConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLifecycleConfigurationRequest' +type S3API_GetBucketLifecycleConfigurationRequest_Call struct { + *mock.Call +} + +// GetBucketLifecycleConfigurationRequest is a helper method to define mock.On call +// - getBucketLifecycleConfigurationInput *s3.GetBucketLifecycleConfigurationInput +func (_e *S3API_Expecter) GetBucketLifecycleConfigurationRequest(getBucketLifecycleConfigurationInput interface{}) *S3API_GetBucketLifecycleConfigurationRequest_Call { + return &S3API_GetBucketLifecycleConfigurationRequest_Call{Call: _e.mock.On("GetBucketLifecycleConfigurationRequest", getBucketLifecycleConfigurationInput)} +} + +func (_c *S3API_GetBucketLifecycleConfigurationRequest_Call) Run(run func(getBucketLifecycleConfigurationInput *s3.GetBucketLifecycleConfigurationInput)) *S3API_GetBucketLifecycleConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketLifecycleConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketLifecycleConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketLifecycleConfigurationRequest_Call) Return(request1 *request.Request, getBucketLifecycleConfigurationOutput *s3.GetBucketLifecycleConfigurationOutput) *S3API_GetBucketLifecycleConfigurationRequest_Call { + _c.Call.Return(request1, getBucketLifecycleConfigurationOutput) + return _c +} + +func (_c *S3API_GetBucketLifecycleConfigurationRequest_Call) RunAndReturn(run func(getBucketLifecycleConfigurationInput *s3.GetBucketLifecycleConfigurationInput) (*request.Request, *s3.GetBucketLifecycleConfigurationOutput)) *S3API_GetBucketLifecycleConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketLifecycleConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketLifecycleConfigurationWithContext(v aws.Context, getBucketLifecycleConfigurationInput *s3.GetBucketLifecycleConfigurationInput, options ...request.Option) (*s3.GetBucketLifecycleConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketLifecycleConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, getBucketLifecycleConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketLifecycleConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketLifecycleConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketLifecycleConfigurationInput, ...request.Option) (*s3.GetBucketLifecycleConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLifecycleConfigurationInput, ...request.Option) (*s3.GetBucketLifecycleConfigurationOutput, error)); ok { + return returnFunc(v, getBucketLifecycleConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketLifecycleConfigurationInput, ...request.Option) *s3.GetBucketLifecycleConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLifecycleConfigurationInput, ...request.Option) *s3.GetBucketLifecycleConfigurationOutput); ok { + r0 = returnFunc(v, getBucketLifecycleConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketLifecycleConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketLifecycleConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketLifecycleConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketLifecycleConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketLifecycleRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketLifecycleRequest(_a0 *s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketLifecycleConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLifecycleConfigurationWithContext' +type S3API_GetBucketLifecycleConfigurationWithContext_Call struct { + *mock.Call +} + +// GetBucketLifecycleConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketLifecycleConfigurationInput *s3.GetBucketLifecycleConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketLifecycleConfigurationWithContext(v interface{}, getBucketLifecycleConfigurationInput interface{}, options ...interface{}) *S3API_GetBucketLifecycleConfigurationWithContext_Call { + return &S3API_GetBucketLifecycleConfigurationWithContext_Call{Call: _e.mock.On("GetBucketLifecycleConfigurationWithContext", + append([]interface{}{v, getBucketLifecycleConfigurationInput}, options...)...)} +} + +func (_c *S3API_GetBucketLifecycleConfigurationWithContext_Call) Run(run func(v aws.Context, getBucketLifecycleConfigurationInput *s3.GetBucketLifecycleConfigurationInput, options ...request.Option)) *S3API_GetBucketLifecycleConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketLifecycleConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketLifecycleConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketLifecycleConfigurationWithContext_Call) Return(getBucketLifecycleConfigurationOutput *s3.GetBucketLifecycleConfigurationOutput, err error) *S3API_GetBucketLifecycleConfigurationWithContext_Call { + _c.Call.Return(getBucketLifecycleConfigurationOutput, err) + return _c +} + +func (_c *S3API_GetBucketLifecycleConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketLifecycleConfigurationInput *s3.GetBucketLifecycleConfigurationInput, options ...request.Option) (*s3.GetBucketLifecycleConfigurationOutput, error)) *S3API_GetBucketLifecycleConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketLifecycleRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketLifecycleRequest(getBucketLifecycleInput *s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput) { + ret := _mock.Called(getBucketLifecycleInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketLifecycleRequest") + } var r0 *request.Request var r1 *s3.GetBucketLifecycleOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput)); ok { + return returnFunc(getBucketLifecycleInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketLifecycleInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLifecycleInput) *request.Request); ok { + r0 = returnFunc(getBucketLifecycleInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketLifecycleInput) *s3.GetBucketLifecycleOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketLifecycleInput) *s3.GetBucketLifecycleOutput); ok { + r1 = returnFunc(getBucketLifecycleInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketLifecycleOutput) } } - return r0, r1 } -// GetBucketLifecycleWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketLifecycleWithContext(_a0 context.Context, _a1 *s3.GetBucketLifecycleInput, _a2 ...request.Option) (*s3.GetBucketLifecycleOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketLifecycleRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLifecycleRequest' +type S3API_GetBucketLifecycleRequest_Call struct { + *mock.Call +} + +// GetBucketLifecycleRequest is a helper method to define mock.On call +// - getBucketLifecycleInput *s3.GetBucketLifecycleInput +func (_e *S3API_Expecter) GetBucketLifecycleRequest(getBucketLifecycleInput interface{}) *S3API_GetBucketLifecycleRequest_Call { + return &S3API_GetBucketLifecycleRequest_Call{Call: _e.mock.On("GetBucketLifecycleRequest", getBucketLifecycleInput)} +} + +func (_c *S3API_GetBucketLifecycleRequest_Call) Run(run func(getBucketLifecycleInput *s3.GetBucketLifecycleInput)) *S3API_GetBucketLifecycleRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketLifecycleInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketLifecycleInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketLifecycleRequest_Call) Return(request1 *request.Request, getBucketLifecycleOutput *s3.GetBucketLifecycleOutput) *S3API_GetBucketLifecycleRequest_Call { + _c.Call.Return(request1, getBucketLifecycleOutput) + return _c +} + +func (_c *S3API_GetBucketLifecycleRequest_Call) RunAndReturn(run func(getBucketLifecycleInput *s3.GetBucketLifecycleInput) (*request.Request, *s3.GetBucketLifecycleOutput)) *S3API_GetBucketLifecycleRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketLifecycleWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketLifecycleWithContext(v aws.Context, getBucketLifecycleInput *s3.GetBucketLifecycleInput, options ...request.Option) (*s3.GetBucketLifecycleOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketLifecycleInput, options) + } else { + tmpRet = _mock.Called(v, getBucketLifecycleInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketLifecycleWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketLifecycleOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketLifecycleInput, ...request.Option) (*s3.GetBucketLifecycleOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLifecycleInput, ...request.Option) (*s3.GetBucketLifecycleOutput, error)); ok { + return returnFunc(v, getBucketLifecycleInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketLifecycleInput, ...request.Option) *s3.GetBucketLifecycleOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLifecycleInput, ...request.Option) *s3.GetBucketLifecycleOutput); ok { + r0 = returnFunc(v, getBucketLifecycleInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketLifecycleOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketLifecycleInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketLifecycleInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketLifecycleInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketLocation provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketLocation(_a0 *s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketLifecycleWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLifecycleWithContext' +type S3API_GetBucketLifecycleWithContext_Call struct { + *mock.Call +} + +// GetBucketLifecycleWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketLifecycleInput *s3.GetBucketLifecycleInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketLifecycleWithContext(v interface{}, getBucketLifecycleInput interface{}, options ...interface{}) *S3API_GetBucketLifecycleWithContext_Call { + return &S3API_GetBucketLifecycleWithContext_Call{Call: _e.mock.On("GetBucketLifecycleWithContext", + append([]interface{}{v, getBucketLifecycleInput}, options...)...)} +} + +func (_c *S3API_GetBucketLifecycleWithContext_Call) Run(run func(v aws.Context, getBucketLifecycleInput *s3.GetBucketLifecycleInput, options ...request.Option)) *S3API_GetBucketLifecycleWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketLifecycleInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketLifecycleInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketLifecycleWithContext_Call) Return(getBucketLifecycleOutput *s3.GetBucketLifecycleOutput, err error) *S3API_GetBucketLifecycleWithContext_Call { + _c.Call.Return(getBucketLifecycleOutput, err) + return _c +} + +func (_c *S3API_GetBucketLifecycleWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketLifecycleInput *s3.GetBucketLifecycleInput, options ...request.Option) (*s3.GetBucketLifecycleOutput, error)) *S3API_GetBucketLifecycleWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketLocation provides a mock function for the type S3API +func (_mock *S3API) GetBucketLocation(getBucketLocationInput *s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error) { + ret := _mock.Called(getBucketLocationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketLocation") + } var r0 *s3.GetBucketLocationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error)); ok { + return returnFunc(getBucketLocationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketLocationInput) *s3.GetBucketLocationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLocationInput) *s3.GetBucketLocationOutput); ok { + r0 = returnFunc(getBucketLocationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketLocationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketLocationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketLocationInput) error); ok { + r1 = returnFunc(getBucketLocationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketLocationRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketLocationRequest(_a0 *s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketLocation_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLocation' +type S3API_GetBucketLocation_Call struct { + *mock.Call +} + +// GetBucketLocation is a helper method to define mock.On call +// - getBucketLocationInput *s3.GetBucketLocationInput +func (_e *S3API_Expecter) GetBucketLocation(getBucketLocationInput interface{}) *S3API_GetBucketLocation_Call { + return &S3API_GetBucketLocation_Call{Call: _e.mock.On("GetBucketLocation", getBucketLocationInput)} +} + +func (_c *S3API_GetBucketLocation_Call) Run(run func(getBucketLocationInput *s3.GetBucketLocationInput)) *S3API_GetBucketLocation_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketLocationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketLocationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketLocation_Call) Return(getBucketLocationOutput *s3.GetBucketLocationOutput, err error) *S3API_GetBucketLocation_Call { + _c.Call.Return(getBucketLocationOutput, err) + return _c +} + +func (_c *S3API_GetBucketLocation_Call) RunAndReturn(run func(getBucketLocationInput *s3.GetBucketLocationInput) (*s3.GetBucketLocationOutput, error)) *S3API_GetBucketLocation_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketLocationRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketLocationRequest(getBucketLocationInput *s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput) { + ret := _mock.Called(getBucketLocationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketLocationRequest") + } var r0 *request.Request var r1 *s3.GetBucketLocationOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput)); ok { + return returnFunc(getBucketLocationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketLocationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLocationInput) *request.Request); ok { + r0 = returnFunc(getBucketLocationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketLocationInput) *s3.GetBucketLocationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketLocationInput) *s3.GetBucketLocationOutput); ok { + r1 = returnFunc(getBucketLocationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketLocationOutput) } } - return r0, r1 } -// GetBucketLocationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketLocationWithContext(_a0 context.Context, _a1 *s3.GetBucketLocationInput, _a2 ...request.Option) (*s3.GetBucketLocationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketLocationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLocationRequest' +type S3API_GetBucketLocationRequest_Call struct { + *mock.Call +} + +// GetBucketLocationRequest is a helper method to define mock.On call +// - getBucketLocationInput *s3.GetBucketLocationInput +func (_e *S3API_Expecter) GetBucketLocationRequest(getBucketLocationInput interface{}) *S3API_GetBucketLocationRequest_Call { + return &S3API_GetBucketLocationRequest_Call{Call: _e.mock.On("GetBucketLocationRequest", getBucketLocationInput)} +} + +func (_c *S3API_GetBucketLocationRequest_Call) Run(run func(getBucketLocationInput *s3.GetBucketLocationInput)) *S3API_GetBucketLocationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketLocationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketLocationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketLocationRequest_Call) Return(request1 *request.Request, getBucketLocationOutput *s3.GetBucketLocationOutput) *S3API_GetBucketLocationRequest_Call { + _c.Call.Return(request1, getBucketLocationOutput) + return _c +} + +func (_c *S3API_GetBucketLocationRequest_Call) RunAndReturn(run func(getBucketLocationInput *s3.GetBucketLocationInput) (*request.Request, *s3.GetBucketLocationOutput)) *S3API_GetBucketLocationRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketLocationWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketLocationWithContext(v aws.Context, getBucketLocationInput *s3.GetBucketLocationInput, options ...request.Option) (*s3.GetBucketLocationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketLocationInput, options) + } else { + tmpRet = _mock.Called(v, getBucketLocationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketLocationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketLocationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketLocationInput, ...request.Option) (*s3.GetBucketLocationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLocationInput, ...request.Option) (*s3.GetBucketLocationOutput, error)); ok { + return returnFunc(v, getBucketLocationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketLocationInput, ...request.Option) *s3.GetBucketLocationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLocationInput, ...request.Option) *s3.GetBucketLocationOutput); ok { + r0 = returnFunc(v, getBucketLocationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketLocationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketLocationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketLocationInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketLocationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketLogging provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketLogging(_a0 *s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketLocationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLocationWithContext' +type S3API_GetBucketLocationWithContext_Call struct { + *mock.Call +} + +// GetBucketLocationWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketLocationInput *s3.GetBucketLocationInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketLocationWithContext(v interface{}, getBucketLocationInput interface{}, options ...interface{}) *S3API_GetBucketLocationWithContext_Call { + return &S3API_GetBucketLocationWithContext_Call{Call: _e.mock.On("GetBucketLocationWithContext", + append([]interface{}{v, getBucketLocationInput}, options...)...)} +} + +func (_c *S3API_GetBucketLocationWithContext_Call) Run(run func(v aws.Context, getBucketLocationInput *s3.GetBucketLocationInput, options ...request.Option)) *S3API_GetBucketLocationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketLocationInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketLocationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketLocationWithContext_Call) Return(getBucketLocationOutput *s3.GetBucketLocationOutput, err error) *S3API_GetBucketLocationWithContext_Call { + _c.Call.Return(getBucketLocationOutput, err) + return _c +} + +func (_c *S3API_GetBucketLocationWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketLocationInput *s3.GetBucketLocationInput, options ...request.Option) (*s3.GetBucketLocationOutput, error)) *S3API_GetBucketLocationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketLogging provides a mock function for the type S3API +func (_mock *S3API) GetBucketLogging(getBucketLoggingInput *s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error) { + ret := _mock.Called(getBucketLoggingInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketLogging") + } var r0 *s3.GetBucketLoggingOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error)); ok { + return returnFunc(getBucketLoggingInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketLoggingInput) *s3.GetBucketLoggingOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLoggingInput) *s3.GetBucketLoggingOutput); ok { + r0 = returnFunc(getBucketLoggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketLoggingOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketLoggingInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketLoggingInput) error); ok { + r1 = returnFunc(getBucketLoggingInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketLoggingRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketLoggingRequest(_a0 *s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketLogging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLogging' +type S3API_GetBucketLogging_Call struct { + *mock.Call +} + +// GetBucketLogging is a helper method to define mock.On call +// - getBucketLoggingInput *s3.GetBucketLoggingInput +func (_e *S3API_Expecter) GetBucketLogging(getBucketLoggingInput interface{}) *S3API_GetBucketLogging_Call { + return &S3API_GetBucketLogging_Call{Call: _e.mock.On("GetBucketLogging", getBucketLoggingInput)} +} + +func (_c *S3API_GetBucketLogging_Call) Run(run func(getBucketLoggingInput *s3.GetBucketLoggingInput)) *S3API_GetBucketLogging_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketLoggingInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketLoggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketLogging_Call) Return(getBucketLoggingOutput *s3.GetBucketLoggingOutput, err error) *S3API_GetBucketLogging_Call { + _c.Call.Return(getBucketLoggingOutput, err) + return _c +} + +func (_c *S3API_GetBucketLogging_Call) RunAndReturn(run func(getBucketLoggingInput *s3.GetBucketLoggingInput) (*s3.GetBucketLoggingOutput, error)) *S3API_GetBucketLogging_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketLoggingRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketLoggingRequest(getBucketLoggingInput *s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput) { + ret := _mock.Called(getBucketLoggingInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketLoggingRequest") + } var r0 *request.Request var r1 *s3.GetBucketLoggingOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput)); ok { + return returnFunc(getBucketLoggingInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketLoggingInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketLoggingInput) *request.Request); ok { + r0 = returnFunc(getBucketLoggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketLoggingInput) *s3.GetBucketLoggingOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketLoggingInput) *s3.GetBucketLoggingOutput); ok { + r1 = returnFunc(getBucketLoggingInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketLoggingOutput) } } - return r0, r1 } -// GetBucketLoggingWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketLoggingWithContext(_a0 context.Context, _a1 *s3.GetBucketLoggingInput, _a2 ...request.Option) (*s3.GetBucketLoggingOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketLoggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLoggingRequest' +type S3API_GetBucketLoggingRequest_Call struct { + *mock.Call +} + +// GetBucketLoggingRequest is a helper method to define mock.On call +// - getBucketLoggingInput *s3.GetBucketLoggingInput +func (_e *S3API_Expecter) GetBucketLoggingRequest(getBucketLoggingInput interface{}) *S3API_GetBucketLoggingRequest_Call { + return &S3API_GetBucketLoggingRequest_Call{Call: _e.mock.On("GetBucketLoggingRequest", getBucketLoggingInput)} +} + +func (_c *S3API_GetBucketLoggingRequest_Call) Run(run func(getBucketLoggingInput *s3.GetBucketLoggingInput)) *S3API_GetBucketLoggingRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketLoggingInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketLoggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketLoggingRequest_Call) Return(request1 *request.Request, getBucketLoggingOutput *s3.GetBucketLoggingOutput) *S3API_GetBucketLoggingRequest_Call { + _c.Call.Return(request1, getBucketLoggingOutput) + return _c +} + +func (_c *S3API_GetBucketLoggingRequest_Call) RunAndReturn(run func(getBucketLoggingInput *s3.GetBucketLoggingInput) (*request.Request, *s3.GetBucketLoggingOutput)) *S3API_GetBucketLoggingRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketLoggingWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketLoggingWithContext(v aws.Context, getBucketLoggingInput *s3.GetBucketLoggingInput, options ...request.Option) (*s3.GetBucketLoggingOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketLoggingInput, options) + } else { + tmpRet = _mock.Called(v, getBucketLoggingInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketLoggingWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketLoggingOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketLoggingInput, ...request.Option) (*s3.GetBucketLoggingOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLoggingInput, ...request.Option) (*s3.GetBucketLoggingOutput, error)); ok { + return returnFunc(v, getBucketLoggingInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketLoggingInput, ...request.Option) *s3.GetBucketLoggingOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketLoggingInput, ...request.Option) *s3.GetBucketLoggingOutput); ok { + r0 = returnFunc(v, getBucketLoggingInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketLoggingOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketLoggingInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketLoggingInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketLoggingInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketMetricsConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketMetricsConfiguration(_a0 *s3.GetBucketMetricsConfigurationInput) (*s3.GetBucketMetricsConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketLoggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketLoggingWithContext' +type S3API_GetBucketLoggingWithContext_Call struct { + *mock.Call +} + +// GetBucketLoggingWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketLoggingInput *s3.GetBucketLoggingInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketLoggingWithContext(v interface{}, getBucketLoggingInput interface{}, options ...interface{}) *S3API_GetBucketLoggingWithContext_Call { + return &S3API_GetBucketLoggingWithContext_Call{Call: _e.mock.On("GetBucketLoggingWithContext", + append([]interface{}{v, getBucketLoggingInput}, options...)...)} +} + +func (_c *S3API_GetBucketLoggingWithContext_Call) Run(run func(v aws.Context, getBucketLoggingInput *s3.GetBucketLoggingInput, options ...request.Option)) *S3API_GetBucketLoggingWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketLoggingInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketLoggingInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketLoggingWithContext_Call) Return(getBucketLoggingOutput *s3.GetBucketLoggingOutput, err error) *S3API_GetBucketLoggingWithContext_Call { + _c.Call.Return(getBucketLoggingOutput, err) + return _c +} + +func (_c *S3API_GetBucketLoggingWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketLoggingInput *s3.GetBucketLoggingInput, options ...request.Option) (*s3.GetBucketLoggingOutput, error)) *S3API_GetBucketLoggingWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketMetricsConfiguration provides a mock function for the type S3API +func (_mock *S3API) GetBucketMetricsConfiguration(getBucketMetricsConfigurationInput *s3.GetBucketMetricsConfigurationInput) (*s3.GetBucketMetricsConfigurationOutput, error) { + ret := _mock.Called(getBucketMetricsConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketMetricsConfiguration") + } var r0 *s3.GetBucketMetricsConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketMetricsConfigurationInput) (*s3.GetBucketMetricsConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketMetricsConfigurationInput) (*s3.GetBucketMetricsConfigurationOutput, error)); ok { + return returnFunc(getBucketMetricsConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketMetricsConfigurationInput) *s3.GetBucketMetricsConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketMetricsConfigurationInput) *s3.GetBucketMetricsConfigurationOutput); ok { + r0 = returnFunc(getBucketMetricsConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketMetricsConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketMetricsConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketMetricsConfigurationInput) error); ok { + r1 = returnFunc(getBucketMetricsConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketMetricsConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketMetricsConfigurationRequest(_a0 *s3.GetBucketMetricsConfigurationInput) (*request.Request, *s3.GetBucketMetricsConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketMetricsConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketMetricsConfiguration' +type S3API_GetBucketMetricsConfiguration_Call struct { + *mock.Call +} + +// GetBucketMetricsConfiguration is a helper method to define mock.On call +// - getBucketMetricsConfigurationInput *s3.GetBucketMetricsConfigurationInput +func (_e *S3API_Expecter) GetBucketMetricsConfiguration(getBucketMetricsConfigurationInput interface{}) *S3API_GetBucketMetricsConfiguration_Call { + return &S3API_GetBucketMetricsConfiguration_Call{Call: _e.mock.On("GetBucketMetricsConfiguration", getBucketMetricsConfigurationInput)} +} + +func (_c *S3API_GetBucketMetricsConfiguration_Call) Run(run func(getBucketMetricsConfigurationInput *s3.GetBucketMetricsConfigurationInput)) *S3API_GetBucketMetricsConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketMetricsConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketMetricsConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketMetricsConfiguration_Call) Return(getBucketMetricsConfigurationOutput *s3.GetBucketMetricsConfigurationOutput, err error) *S3API_GetBucketMetricsConfiguration_Call { + _c.Call.Return(getBucketMetricsConfigurationOutput, err) + return _c +} + +func (_c *S3API_GetBucketMetricsConfiguration_Call) RunAndReturn(run func(getBucketMetricsConfigurationInput *s3.GetBucketMetricsConfigurationInput) (*s3.GetBucketMetricsConfigurationOutput, error)) *S3API_GetBucketMetricsConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketMetricsConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketMetricsConfigurationRequest(getBucketMetricsConfigurationInput *s3.GetBucketMetricsConfigurationInput) (*request.Request, *s3.GetBucketMetricsConfigurationOutput) { + ret := _mock.Called(getBucketMetricsConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketMetricsConfigurationRequest") + } var r0 *request.Request var r1 *s3.GetBucketMetricsConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketMetricsConfigurationInput) (*request.Request, *s3.GetBucketMetricsConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketMetricsConfigurationInput) (*request.Request, *s3.GetBucketMetricsConfigurationOutput)); ok { + return returnFunc(getBucketMetricsConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketMetricsConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketMetricsConfigurationInput) *request.Request); ok { + r0 = returnFunc(getBucketMetricsConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketMetricsConfigurationInput) *s3.GetBucketMetricsConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketMetricsConfigurationInput) *s3.GetBucketMetricsConfigurationOutput); ok { + r1 = returnFunc(getBucketMetricsConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketMetricsConfigurationOutput) } } - return r0, r1 } -// GetBucketMetricsConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketMetricsConfigurationWithContext(_a0 context.Context, _a1 *s3.GetBucketMetricsConfigurationInput, _a2 ...request.Option) (*s3.GetBucketMetricsConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketMetricsConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketMetricsConfigurationRequest' +type S3API_GetBucketMetricsConfigurationRequest_Call struct { + *mock.Call +} + +// GetBucketMetricsConfigurationRequest is a helper method to define mock.On call +// - getBucketMetricsConfigurationInput *s3.GetBucketMetricsConfigurationInput +func (_e *S3API_Expecter) GetBucketMetricsConfigurationRequest(getBucketMetricsConfigurationInput interface{}) *S3API_GetBucketMetricsConfigurationRequest_Call { + return &S3API_GetBucketMetricsConfigurationRequest_Call{Call: _e.mock.On("GetBucketMetricsConfigurationRequest", getBucketMetricsConfigurationInput)} +} + +func (_c *S3API_GetBucketMetricsConfigurationRequest_Call) Run(run func(getBucketMetricsConfigurationInput *s3.GetBucketMetricsConfigurationInput)) *S3API_GetBucketMetricsConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketMetricsConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketMetricsConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketMetricsConfigurationRequest_Call) Return(request1 *request.Request, getBucketMetricsConfigurationOutput *s3.GetBucketMetricsConfigurationOutput) *S3API_GetBucketMetricsConfigurationRequest_Call { + _c.Call.Return(request1, getBucketMetricsConfigurationOutput) + return _c +} + +func (_c *S3API_GetBucketMetricsConfigurationRequest_Call) RunAndReturn(run func(getBucketMetricsConfigurationInput *s3.GetBucketMetricsConfigurationInput) (*request.Request, *s3.GetBucketMetricsConfigurationOutput)) *S3API_GetBucketMetricsConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketMetricsConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketMetricsConfigurationWithContext(v aws.Context, getBucketMetricsConfigurationInput *s3.GetBucketMetricsConfigurationInput, options ...request.Option) (*s3.GetBucketMetricsConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketMetricsConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, getBucketMetricsConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketMetricsConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketMetricsConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketMetricsConfigurationInput, ...request.Option) (*s3.GetBucketMetricsConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketMetricsConfigurationInput, ...request.Option) (*s3.GetBucketMetricsConfigurationOutput, error)); ok { + return returnFunc(v, getBucketMetricsConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketMetricsConfigurationInput, ...request.Option) *s3.GetBucketMetricsConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketMetricsConfigurationInput, ...request.Option) *s3.GetBucketMetricsConfigurationOutput); ok { + r0 = returnFunc(v, getBucketMetricsConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketMetricsConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketMetricsConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketMetricsConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketMetricsConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketNotification provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketNotification(_a0 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error) { - ret := _m.Called(_a0) +// S3API_GetBucketMetricsConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketMetricsConfigurationWithContext' +type S3API_GetBucketMetricsConfigurationWithContext_Call struct { + *mock.Call +} + +// GetBucketMetricsConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketMetricsConfigurationInput *s3.GetBucketMetricsConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketMetricsConfigurationWithContext(v interface{}, getBucketMetricsConfigurationInput interface{}, options ...interface{}) *S3API_GetBucketMetricsConfigurationWithContext_Call { + return &S3API_GetBucketMetricsConfigurationWithContext_Call{Call: _e.mock.On("GetBucketMetricsConfigurationWithContext", + append([]interface{}{v, getBucketMetricsConfigurationInput}, options...)...)} +} + +func (_c *S3API_GetBucketMetricsConfigurationWithContext_Call) Run(run func(v aws.Context, getBucketMetricsConfigurationInput *s3.GetBucketMetricsConfigurationInput, options ...request.Option)) *S3API_GetBucketMetricsConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketMetricsConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketMetricsConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketMetricsConfigurationWithContext_Call) Return(getBucketMetricsConfigurationOutput *s3.GetBucketMetricsConfigurationOutput, err error) *S3API_GetBucketMetricsConfigurationWithContext_Call { + _c.Call.Return(getBucketMetricsConfigurationOutput, err) + return _c +} + +func (_c *S3API_GetBucketMetricsConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketMetricsConfigurationInput *s3.GetBucketMetricsConfigurationInput, options ...request.Option) (*s3.GetBucketMetricsConfigurationOutput, error)) *S3API_GetBucketMetricsConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketNotification provides a mock function for the type S3API +func (_mock *S3API) GetBucketNotification(getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error) { + ret := _mock.Called(getBucketNotificationConfigurationRequest) + + if len(ret) == 0 { + panic("no return value specified for GetBucketNotification") + } var r0 *s3.NotificationConfigurationDeprecated var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error)); ok { + return returnFunc(getBucketNotificationConfigurationRequest) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) *s3.NotificationConfigurationDeprecated); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) *s3.NotificationConfigurationDeprecated); ok { + r0 = returnFunc(getBucketNotificationConfigurationRequest) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.NotificationConfigurationDeprecated) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketNotificationConfigurationRequest) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketNotificationConfigurationRequest) error); ok { + r1 = returnFunc(getBucketNotificationConfigurationRequest) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketNotificationConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketNotificationConfiguration(_a0 *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error) { - ret := _m.Called(_a0) +// S3API_GetBucketNotification_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketNotification' +type S3API_GetBucketNotification_Call struct { + *mock.Call +} + +// GetBucketNotification is a helper method to define mock.On call +// - getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest +func (_e *S3API_Expecter) GetBucketNotification(getBucketNotificationConfigurationRequest interface{}) *S3API_GetBucketNotification_Call { + return &S3API_GetBucketNotification_Call{Call: _e.mock.On("GetBucketNotification", getBucketNotificationConfigurationRequest)} +} + +func (_c *S3API_GetBucketNotification_Call) Run(run func(getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest)) *S3API_GetBucketNotification_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketNotificationConfigurationRequest + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketNotificationConfigurationRequest) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketNotification_Call) Return(notificationConfigurationDeprecated *s3.NotificationConfigurationDeprecated, err error) *S3API_GetBucketNotification_Call { + _c.Call.Return(notificationConfigurationDeprecated, err) + return _c +} + +func (_c *S3API_GetBucketNotification_Call) RunAndReturn(run func(getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfigurationDeprecated, error)) *S3API_GetBucketNotification_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketNotificationConfiguration provides a mock function for the type S3API +func (_mock *S3API) GetBucketNotificationConfiguration(getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error) { + ret := _mock.Called(getBucketNotificationConfigurationRequest) + + if len(ret) == 0 { + panic("no return value specified for GetBucketNotificationConfiguration") + } var r0 *s3.NotificationConfiguration var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error)); ok { + return returnFunc(getBucketNotificationConfigurationRequest) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) *s3.NotificationConfiguration); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) *s3.NotificationConfiguration); ok { + r0 = returnFunc(getBucketNotificationConfigurationRequest) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.NotificationConfiguration) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketNotificationConfigurationRequest) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketNotificationConfigurationRequest) error); ok { + r1 = returnFunc(getBucketNotificationConfigurationRequest) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketNotificationConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketNotificationConfigurationRequest(_a0 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration) { - ret := _m.Called(_a0) +// S3API_GetBucketNotificationConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketNotificationConfiguration' +type S3API_GetBucketNotificationConfiguration_Call struct { + *mock.Call +} + +// GetBucketNotificationConfiguration is a helper method to define mock.On call +// - getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest +func (_e *S3API_Expecter) GetBucketNotificationConfiguration(getBucketNotificationConfigurationRequest interface{}) *S3API_GetBucketNotificationConfiguration_Call { + return &S3API_GetBucketNotificationConfiguration_Call{Call: _e.mock.On("GetBucketNotificationConfiguration", getBucketNotificationConfigurationRequest)} +} + +func (_c *S3API_GetBucketNotificationConfiguration_Call) Run(run func(getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest)) *S3API_GetBucketNotificationConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketNotificationConfigurationRequest + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketNotificationConfigurationRequest) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketNotificationConfiguration_Call) Return(notificationConfiguration *s3.NotificationConfiguration, err error) *S3API_GetBucketNotificationConfiguration_Call { + _c.Call.Return(notificationConfiguration, err) + return _c +} + +func (_c *S3API_GetBucketNotificationConfiguration_Call) RunAndReturn(run func(getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest) (*s3.NotificationConfiguration, error)) *S3API_GetBucketNotificationConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketNotificationConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketNotificationConfigurationRequest(getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration) { + ret := _mock.Called(getBucketNotificationConfigurationRequest) + + if len(ret) == 0 { + panic("no return value specified for GetBucketNotificationConfigurationRequest") + } var r0 *request.Request var r1 *s3.NotificationConfiguration - if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration)); ok { + return returnFunc(getBucketNotificationConfigurationRequest) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) *request.Request); ok { + r0 = returnFunc(getBucketNotificationConfigurationRequest) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketNotificationConfigurationRequest) *s3.NotificationConfiguration); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketNotificationConfigurationRequest) *s3.NotificationConfiguration); ok { + r1 = returnFunc(getBucketNotificationConfigurationRequest) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.NotificationConfiguration) } } - return r0, r1 } -// GetBucketNotificationConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketNotificationConfigurationWithContext(_a0 context.Context, _a1 *s3.GetBucketNotificationConfigurationRequest, _a2 ...request.Option) (*s3.NotificationConfiguration, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] - } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) +// S3API_GetBucketNotificationConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketNotificationConfigurationRequest' +type S3API_GetBucketNotificationConfigurationRequest_Call struct { + *mock.Call +} + +// GetBucketNotificationConfigurationRequest is a helper method to define mock.On call +// - getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest +func (_e *S3API_Expecter) GetBucketNotificationConfigurationRequest(getBucketNotificationConfigurationRequest interface{}) *S3API_GetBucketNotificationConfigurationRequest_Call { + return &S3API_GetBucketNotificationConfigurationRequest_Call{Call: _e.mock.On("GetBucketNotificationConfigurationRequest", getBucketNotificationConfigurationRequest)} +} + +func (_c *S3API_GetBucketNotificationConfigurationRequest_Call) Run(run func(getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest)) *S3API_GetBucketNotificationConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketNotificationConfigurationRequest + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketNotificationConfigurationRequest) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketNotificationConfigurationRequest_Call) Return(request1 *request.Request, notificationConfiguration *s3.NotificationConfiguration) *S3API_GetBucketNotificationConfigurationRequest_Call { + _c.Call.Return(request1, notificationConfiguration) + return _c +} + +func (_c *S3API_GetBucketNotificationConfigurationRequest_Call) RunAndReturn(run func(getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfiguration)) *S3API_GetBucketNotificationConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketNotificationConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketNotificationConfigurationWithContext(v aws.Context, getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest, options ...request.Option) (*s3.NotificationConfiguration, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketNotificationConfigurationRequest, options) + } else { + tmpRet = _mock.Called(v, getBucketNotificationConfigurationRequest) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketNotificationConfigurationWithContext") + } var r0 *s3.NotificationConfiguration var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) (*s3.NotificationConfiguration, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) (*s3.NotificationConfiguration, error)); ok { + return returnFunc(v, getBucketNotificationConfigurationRequest, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) *s3.NotificationConfiguration); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) *s3.NotificationConfiguration); ok { + r0 = returnFunc(v, getBucketNotificationConfigurationRequest, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.NotificationConfiguration) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketNotificationConfigurationRequest, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketNotificationRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketNotificationRequest(_a0 *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated) { - ret := _m.Called(_a0) +// S3API_GetBucketNotificationConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketNotificationConfigurationWithContext' +type S3API_GetBucketNotificationConfigurationWithContext_Call struct { + *mock.Call +} + +// GetBucketNotificationConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketNotificationConfigurationWithContext(v interface{}, getBucketNotificationConfigurationRequest interface{}, options ...interface{}) *S3API_GetBucketNotificationConfigurationWithContext_Call { + return &S3API_GetBucketNotificationConfigurationWithContext_Call{Call: _e.mock.On("GetBucketNotificationConfigurationWithContext", + append([]interface{}{v, getBucketNotificationConfigurationRequest}, options...)...)} +} + +func (_c *S3API_GetBucketNotificationConfigurationWithContext_Call) Run(run func(v aws.Context, getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest, options ...request.Option)) *S3API_GetBucketNotificationConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketNotificationConfigurationRequest + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketNotificationConfigurationRequest) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketNotificationConfigurationWithContext_Call) Return(notificationConfiguration *s3.NotificationConfiguration, err error) *S3API_GetBucketNotificationConfigurationWithContext_Call { + _c.Call.Return(notificationConfiguration, err) + return _c +} + +func (_c *S3API_GetBucketNotificationConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest, options ...request.Option) (*s3.NotificationConfiguration, error)) *S3API_GetBucketNotificationConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketNotificationRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketNotificationRequest(getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated) { + ret := _mock.Called(getBucketNotificationConfigurationRequest) + + if len(ret) == 0 { + panic("no return value specified for GetBucketNotificationRequest") + } var r0 *request.Request var r1 *s3.NotificationConfigurationDeprecated - if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated)); ok { + return returnFunc(getBucketNotificationConfigurationRequest) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketNotificationConfigurationRequest) *request.Request); ok { + r0 = returnFunc(getBucketNotificationConfigurationRequest) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketNotificationConfigurationRequest) *s3.NotificationConfigurationDeprecated); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketNotificationConfigurationRequest) *s3.NotificationConfigurationDeprecated); ok { + r1 = returnFunc(getBucketNotificationConfigurationRequest) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.NotificationConfigurationDeprecated) } } - return r0, r1 } -// GetBucketNotificationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketNotificationWithContext(_a0 context.Context, _a1 *s3.GetBucketNotificationConfigurationRequest, _a2 ...request.Option) (*s3.NotificationConfigurationDeprecated, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketNotificationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketNotificationRequest' +type S3API_GetBucketNotificationRequest_Call struct { + *mock.Call +} + +// GetBucketNotificationRequest is a helper method to define mock.On call +// - getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest +func (_e *S3API_Expecter) GetBucketNotificationRequest(getBucketNotificationConfigurationRequest interface{}) *S3API_GetBucketNotificationRequest_Call { + return &S3API_GetBucketNotificationRequest_Call{Call: _e.mock.On("GetBucketNotificationRequest", getBucketNotificationConfigurationRequest)} +} + +func (_c *S3API_GetBucketNotificationRequest_Call) Run(run func(getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest)) *S3API_GetBucketNotificationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketNotificationConfigurationRequest + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketNotificationConfigurationRequest) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketNotificationRequest_Call) Return(request1 *request.Request, notificationConfigurationDeprecated *s3.NotificationConfigurationDeprecated) *S3API_GetBucketNotificationRequest_Call { + _c.Call.Return(request1, notificationConfigurationDeprecated) + return _c +} + +func (_c *S3API_GetBucketNotificationRequest_Call) RunAndReturn(run func(getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest) (*request.Request, *s3.NotificationConfigurationDeprecated)) *S3API_GetBucketNotificationRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketNotificationWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketNotificationWithContext(v aws.Context, getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest, options ...request.Option) (*s3.NotificationConfigurationDeprecated, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketNotificationConfigurationRequest, options) + } else { + tmpRet = _mock.Called(v, getBucketNotificationConfigurationRequest) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketNotificationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.NotificationConfigurationDeprecated var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) (*s3.NotificationConfigurationDeprecated, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) (*s3.NotificationConfigurationDeprecated, error)); ok { + return returnFunc(v, getBucketNotificationConfigurationRequest, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) *s3.NotificationConfigurationDeprecated); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) *s3.NotificationConfigurationDeprecated); ok { + r0 = returnFunc(v, getBucketNotificationConfigurationRequest, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.NotificationConfigurationDeprecated) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketNotificationConfigurationRequest, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketNotificationConfigurationRequest, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketOwnershipControls provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketOwnershipControls(_a0 *s3.GetBucketOwnershipControlsInput) (*s3.GetBucketOwnershipControlsOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketNotificationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketNotificationWithContext' +type S3API_GetBucketNotificationWithContext_Call struct { + *mock.Call +} + +// GetBucketNotificationWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketNotificationWithContext(v interface{}, getBucketNotificationConfigurationRequest interface{}, options ...interface{}) *S3API_GetBucketNotificationWithContext_Call { + return &S3API_GetBucketNotificationWithContext_Call{Call: _e.mock.On("GetBucketNotificationWithContext", + append([]interface{}{v, getBucketNotificationConfigurationRequest}, options...)...)} +} + +func (_c *S3API_GetBucketNotificationWithContext_Call) Run(run func(v aws.Context, getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest, options ...request.Option)) *S3API_GetBucketNotificationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketNotificationConfigurationRequest + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketNotificationConfigurationRequest) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketNotificationWithContext_Call) Return(notificationConfigurationDeprecated *s3.NotificationConfigurationDeprecated, err error) *S3API_GetBucketNotificationWithContext_Call { + _c.Call.Return(notificationConfigurationDeprecated, err) + return _c +} + +func (_c *S3API_GetBucketNotificationWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketNotificationConfigurationRequest *s3.GetBucketNotificationConfigurationRequest, options ...request.Option) (*s3.NotificationConfigurationDeprecated, error)) *S3API_GetBucketNotificationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketOwnershipControls provides a mock function for the type S3API +func (_mock *S3API) GetBucketOwnershipControls(getBucketOwnershipControlsInput *s3.GetBucketOwnershipControlsInput) (*s3.GetBucketOwnershipControlsOutput, error) { + ret := _mock.Called(getBucketOwnershipControlsInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketOwnershipControls") + } var r0 *s3.GetBucketOwnershipControlsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketOwnershipControlsInput) (*s3.GetBucketOwnershipControlsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketOwnershipControlsInput) (*s3.GetBucketOwnershipControlsOutput, error)); ok { + return returnFunc(getBucketOwnershipControlsInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketOwnershipControlsInput) *s3.GetBucketOwnershipControlsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketOwnershipControlsInput) *s3.GetBucketOwnershipControlsOutput); ok { + r0 = returnFunc(getBucketOwnershipControlsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketOwnershipControlsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketOwnershipControlsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketOwnershipControlsInput) error); ok { + r1 = returnFunc(getBucketOwnershipControlsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketOwnershipControlsRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketOwnershipControlsRequest(_a0 *s3.GetBucketOwnershipControlsInput) (*request.Request, *s3.GetBucketOwnershipControlsOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketOwnershipControls_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketOwnershipControls' +type S3API_GetBucketOwnershipControls_Call struct { + *mock.Call +} + +// GetBucketOwnershipControls is a helper method to define mock.On call +// - getBucketOwnershipControlsInput *s3.GetBucketOwnershipControlsInput +func (_e *S3API_Expecter) GetBucketOwnershipControls(getBucketOwnershipControlsInput interface{}) *S3API_GetBucketOwnershipControls_Call { + return &S3API_GetBucketOwnershipControls_Call{Call: _e.mock.On("GetBucketOwnershipControls", getBucketOwnershipControlsInput)} +} + +func (_c *S3API_GetBucketOwnershipControls_Call) Run(run func(getBucketOwnershipControlsInput *s3.GetBucketOwnershipControlsInput)) *S3API_GetBucketOwnershipControls_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketOwnershipControlsInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketOwnershipControlsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketOwnershipControls_Call) Return(getBucketOwnershipControlsOutput *s3.GetBucketOwnershipControlsOutput, err error) *S3API_GetBucketOwnershipControls_Call { + _c.Call.Return(getBucketOwnershipControlsOutput, err) + return _c +} + +func (_c *S3API_GetBucketOwnershipControls_Call) RunAndReturn(run func(getBucketOwnershipControlsInput *s3.GetBucketOwnershipControlsInput) (*s3.GetBucketOwnershipControlsOutput, error)) *S3API_GetBucketOwnershipControls_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketOwnershipControlsRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketOwnershipControlsRequest(getBucketOwnershipControlsInput *s3.GetBucketOwnershipControlsInput) (*request.Request, *s3.GetBucketOwnershipControlsOutput) { + ret := _mock.Called(getBucketOwnershipControlsInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketOwnershipControlsRequest") + } var r0 *request.Request var r1 *s3.GetBucketOwnershipControlsOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketOwnershipControlsInput) (*request.Request, *s3.GetBucketOwnershipControlsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketOwnershipControlsInput) (*request.Request, *s3.GetBucketOwnershipControlsOutput)); ok { + return returnFunc(getBucketOwnershipControlsInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketOwnershipControlsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketOwnershipControlsInput) *request.Request); ok { + r0 = returnFunc(getBucketOwnershipControlsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketOwnershipControlsInput) *s3.GetBucketOwnershipControlsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketOwnershipControlsInput) *s3.GetBucketOwnershipControlsOutput); ok { + r1 = returnFunc(getBucketOwnershipControlsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketOwnershipControlsOutput) } } - return r0, r1 } -// GetBucketOwnershipControlsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketOwnershipControlsWithContext(_a0 context.Context, _a1 *s3.GetBucketOwnershipControlsInput, _a2 ...request.Option) (*s3.GetBucketOwnershipControlsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketOwnershipControlsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketOwnershipControlsRequest' +type S3API_GetBucketOwnershipControlsRequest_Call struct { + *mock.Call +} + +// GetBucketOwnershipControlsRequest is a helper method to define mock.On call +// - getBucketOwnershipControlsInput *s3.GetBucketOwnershipControlsInput +func (_e *S3API_Expecter) GetBucketOwnershipControlsRequest(getBucketOwnershipControlsInput interface{}) *S3API_GetBucketOwnershipControlsRequest_Call { + return &S3API_GetBucketOwnershipControlsRequest_Call{Call: _e.mock.On("GetBucketOwnershipControlsRequest", getBucketOwnershipControlsInput)} +} + +func (_c *S3API_GetBucketOwnershipControlsRequest_Call) Run(run func(getBucketOwnershipControlsInput *s3.GetBucketOwnershipControlsInput)) *S3API_GetBucketOwnershipControlsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketOwnershipControlsInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketOwnershipControlsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketOwnershipControlsRequest_Call) Return(request1 *request.Request, getBucketOwnershipControlsOutput *s3.GetBucketOwnershipControlsOutput) *S3API_GetBucketOwnershipControlsRequest_Call { + _c.Call.Return(request1, getBucketOwnershipControlsOutput) + return _c +} + +func (_c *S3API_GetBucketOwnershipControlsRequest_Call) RunAndReturn(run func(getBucketOwnershipControlsInput *s3.GetBucketOwnershipControlsInput) (*request.Request, *s3.GetBucketOwnershipControlsOutput)) *S3API_GetBucketOwnershipControlsRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketOwnershipControlsWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketOwnershipControlsWithContext(v aws.Context, getBucketOwnershipControlsInput *s3.GetBucketOwnershipControlsInput, options ...request.Option) (*s3.GetBucketOwnershipControlsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketOwnershipControlsInput, options) + } else { + tmpRet = _mock.Called(v, getBucketOwnershipControlsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketOwnershipControlsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketOwnershipControlsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketOwnershipControlsInput, ...request.Option) (*s3.GetBucketOwnershipControlsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketOwnershipControlsInput, ...request.Option) (*s3.GetBucketOwnershipControlsOutput, error)); ok { + return returnFunc(v, getBucketOwnershipControlsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketOwnershipControlsInput, ...request.Option) *s3.GetBucketOwnershipControlsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketOwnershipControlsInput, ...request.Option) *s3.GetBucketOwnershipControlsOutput); ok { + r0 = returnFunc(v, getBucketOwnershipControlsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketOwnershipControlsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketOwnershipControlsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketOwnershipControlsInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketOwnershipControlsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketPolicy provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketPolicy(_a0 *s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketOwnershipControlsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketOwnershipControlsWithContext' +type S3API_GetBucketOwnershipControlsWithContext_Call struct { + *mock.Call +} + +// GetBucketOwnershipControlsWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketOwnershipControlsInput *s3.GetBucketOwnershipControlsInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketOwnershipControlsWithContext(v interface{}, getBucketOwnershipControlsInput interface{}, options ...interface{}) *S3API_GetBucketOwnershipControlsWithContext_Call { + return &S3API_GetBucketOwnershipControlsWithContext_Call{Call: _e.mock.On("GetBucketOwnershipControlsWithContext", + append([]interface{}{v, getBucketOwnershipControlsInput}, options...)...)} +} + +func (_c *S3API_GetBucketOwnershipControlsWithContext_Call) Run(run func(v aws.Context, getBucketOwnershipControlsInput *s3.GetBucketOwnershipControlsInput, options ...request.Option)) *S3API_GetBucketOwnershipControlsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketOwnershipControlsInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketOwnershipControlsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketOwnershipControlsWithContext_Call) Return(getBucketOwnershipControlsOutput *s3.GetBucketOwnershipControlsOutput, err error) *S3API_GetBucketOwnershipControlsWithContext_Call { + _c.Call.Return(getBucketOwnershipControlsOutput, err) + return _c +} + +func (_c *S3API_GetBucketOwnershipControlsWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketOwnershipControlsInput *s3.GetBucketOwnershipControlsInput, options ...request.Option) (*s3.GetBucketOwnershipControlsOutput, error)) *S3API_GetBucketOwnershipControlsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketPolicy provides a mock function for the type S3API +func (_mock *S3API) GetBucketPolicy(getBucketPolicyInput *s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error) { + ret := _mock.Called(getBucketPolicyInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketPolicy") + } var r0 *s3.GetBucketPolicyOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error)); ok { + return returnFunc(getBucketPolicyInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyInput) *s3.GetBucketPolicyOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketPolicyInput) *s3.GetBucketPolicyOutput); ok { + r0 = returnFunc(getBucketPolicyInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketPolicyOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketPolicyInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketPolicyInput) error); ok { + r1 = returnFunc(getBucketPolicyInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketPolicyRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketPolicyRequest(_a0 *s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketPolicy' +type S3API_GetBucketPolicy_Call struct { + *mock.Call +} + +// GetBucketPolicy is a helper method to define mock.On call +// - getBucketPolicyInput *s3.GetBucketPolicyInput +func (_e *S3API_Expecter) GetBucketPolicy(getBucketPolicyInput interface{}) *S3API_GetBucketPolicy_Call { + return &S3API_GetBucketPolicy_Call{Call: _e.mock.On("GetBucketPolicy", getBucketPolicyInput)} +} + +func (_c *S3API_GetBucketPolicy_Call) Run(run func(getBucketPolicyInput *s3.GetBucketPolicyInput)) *S3API_GetBucketPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketPolicyInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketPolicyInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketPolicy_Call) Return(getBucketPolicyOutput *s3.GetBucketPolicyOutput, err error) *S3API_GetBucketPolicy_Call { + _c.Call.Return(getBucketPolicyOutput, err) + return _c +} + +func (_c *S3API_GetBucketPolicy_Call) RunAndReturn(run func(getBucketPolicyInput *s3.GetBucketPolicyInput) (*s3.GetBucketPolicyOutput, error)) *S3API_GetBucketPolicy_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketPolicyRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketPolicyRequest(getBucketPolicyInput *s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput) { + ret := _mock.Called(getBucketPolicyInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketPolicyRequest") + } var r0 *request.Request var r1 *s3.GetBucketPolicyOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput)); ok { + return returnFunc(getBucketPolicyInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketPolicyInput) *request.Request); ok { + r0 = returnFunc(getBucketPolicyInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketPolicyInput) *s3.GetBucketPolicyOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketPolicyInput) *s3.GetBucketPolicyOutput); ok { + r1 = returnFunc(getBucketPolicyInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketPolicyOutput) } } - return r0, r1 } -// GetBucketPolicyStatus provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketPolicyStatus(_a0 *s3.GetBucketPolicyStatusInput) (*s3.GetBucketPolicyStatusOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketPolicyRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketPolicyRequest' +type S3API_GetBucketPolicyRequest_Call struct { + *mock.Call +} + +// GetBucketPolicyRequest is a helper method to define mock.On call +// - getBucketPolicyInput *s3.GetBucketPolicyInput +func (_e *S3API_Expecter) GetBucketPolicyRequest(getBucketPolicyInput interface{}) *S3API_GetBucketPolicyRequest_Call { + return &S3API_GetBucketPolicyRequest_Call{Call: _e.mock.On("GetBucketPolicyRequest", getBucketPolicyInput)} +} + +func (_c *S3API_GetBucketPolicyRequest_Call) Run(run func(getBucketPolicyInput *s3.GetBucketPolicyInput)) *S3API_GetBucketPolicyRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketPolicyInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketPolicyInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketPolicyRequest_Call) Return(request1 *request.Request, getBucketPolicyOutput *s3.GetBucketPolicyOutput) *S3API_GetBucketPolicyRequest_Call { + _c.Call.Return(request1, getBucketPolicyOutput) + return _c +} + +func (_c *S3API_GetBucketPolicyRequest_Call) RunAndReturn(run func(getBucketPolicyInput *s3.GetBucketPolicyInput) (*request.Request, *s3.GetBucketPolicyOutput)) *S3API_GetBucketPolicyRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketPolicyStatus provides a mock function for the type S3API +func (_mock *S3API) GetBucketPolicyStatus(getBucketPolicyStatusInput *s3.GetBucketPolicyStatusInput) (*s3.GetBucketPolicyStatusOutput, error) { + ret := _mock.Called(getBucketPolicyStatusInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketPolicyStatus") + } var r0 *s3.GetBucketPolicyStatusOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyStatusInput) (*s3.GetBucketPolicyStatusOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketPolicyStatusInput) (*s3.GetBucketPolicyStatusOutput, error)); ok { + return returnFunc(getBucketPolicyStatusInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyStatusInput) *s3.GetBucketPolicyStatusOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketPolicyStatusInput) *s3.GetBucketPolicyStatusOutput); ok { + r0 = returnFunc(getBucketPolicyStatusInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketPolicyStatusOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketPolicyStatusInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketPolicyStatusInput) error); ok { + r1 = returnFunc(getBucketPolicyStatusInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketPolicyStatusRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketPolicyStatusRequest(_a0 *s3.GetBucketPolicyStatusInput) (*request.Request, *s3.GetBucketPolicyStatusOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketPolicyStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketPolicyStatus' +type S3API_GetBucketPolicyStatus_Call struct { + *mock.Call +} + +// GetBucketPolicyStatus is a helper method to define mock.On call +// - getBucketPolicyStatusInput *s3.GetBucketPolicyStatusInput +func (_e *S3API_Expecter) GetBucketPolicyStatus(getBucketPolicyStatusInput interface{}) *S3API_GetBucketPolicyStatus_Call { + return &S3API_GetBucketPolicyStatus_Call{Call: _e.mock.On("GetBucketPolicyStatus", getBucketPolicyStatusInput)} +} + +func (_c *S3API_GetBucketPolicyStatus_Call) Run(run func(getBucketPolicyStatusInput *s3.GetBucketPolicyStatusInput)) *S3API_GetBucketPolicyStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketPolicyStatusInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketPolicyStatusInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketPolicyStatus_Call) Return(getBucketPolicyStatusOutput *s3.GetBucketPolicyStatusOutput, err error) *S3API_GetBucketPolicyStatus_Call { + _c.Call.Return(getBucketPolicyStatusOutput, err) + return _c +} + +func (_c *S3API_GetBucketPolicyStatus_Call) RunAndReturn(run func(getBucketPolicyStatusInput *s3.GetBucketPolicyStatusInput) (*s3.GetBucketPolicyStatusOutput, error)) *S3API_GetBucketPolicyStatus_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketPolicyStatusRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketPolicyStatusRequest(getBucketPolicyStatusInput *s3.GetBucketPolicyStatusInput) (*request.Request, *s3.GetBucketPolicyStatusOutput) { + ret := _mock.Called(getBucketPolicyStatusInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketPolicyStatusRequest") + } var r0 *request.Request var r1 *s3.GetBucketPolicyStatusOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyStatusInput) (*request.Request, *s3.GetBucketPolicyStatusOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketPolicyStatusInput) (*request.Request, *s3.GetBucketPolicyStatusOutput)); ok { + return returnFunc(getBucketPolicyStatusInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketPolicyStatusInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketPolicyStatusInput) *request.Request); ok { + r0 = returnFunc(getBucketPolicyStatusInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketPolicyStatusInput) *s3.GetBucketPolicyStatusOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketPolicyStatusInput) *s3.GetBucketPolicyStatusOutput); ok { + r1 = returnFunc(getBucketPolicyStatusInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketPolicyStatusOutput) } } - return r0, r1 } -// GetBucketPolicyStatusWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketPolicyStatusWithContext(_a0 context.Context, _a1 *s3.GetBucketPolicyStatusInput, _a2 ...request.Option) (*s3.GetBucketPolicyStatusOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketPolicyStatusRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketPolicyStatusRequest' +type S3API_GetBucketPolicyStatusRequest_Call struct { + *mock.Call +} + +// GetBucketPolicyStatusRequest is a helper method to define mock.On call +// - getBucketPolicyStatusInput *s3.GetBucketPolicyStatusInput +func (_e *S3API_Expecter) GetBucketPolicyStatusRequest(getBucketPolicyStatusInput interface{}) *S3API_GetBucketPolicyStatusRequest_Call { + return &S3API_GetBucketPolicyStatusRequest_Call{Call: _e.mock.On("GetBucketPolicyStatusRequest", getBucketPolicyStatusInput)} +} + +func (_c *S3API_GetBucketPolicyStatusRequest_Call) Run(run func(getBucketPolicyStatusInput *s3.GetBucketPolicyStatusInput)) *S3API_GetBucketPolicyStatusRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketPolicyStatusInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketPolicyStatusInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketPolicyStatusRequest_Call) Return(request1 *request.Request, getBucketPolicyStatusOutput *s3.GetBucketPolicyStatusOutput) *S3API_GetBucketPolicyStatusRequest_Call { + _c.Call.Return(request1, getBucketPolicyStatusOutput) + return _c +} + +func (_c *S3API_GetBucketPolicyStatusRequest_Call) RunAndReturn(run func(getBucketPolicyStatusInput *s3.GetBucketPolicyStatusInput) (*request.Request, *s3.GetBucketPolicyStatusOutput)) *S3API_GetBucketPolicyStatusRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketPolicyStatusWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketPolicyStatusWithContext(v aws.Context, getBucketPolicyStatusInput *s3.GetBucketPolicyStatusInput, options ...request.Option) (*s3.GetBucketPolicyStatusOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketPolicyStatusInput, options) + } else { + tmpRet = _mock.Called(v, getBucketPolicyStatusInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketPolicyStatusWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketPolicyStatusOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketPolicyStatusInput, ...request.Option) (*s3.GetBucketPolicyStatusOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketPolicyStatusInput, ...request.Option) (*s3.GetBucketPolicyStatusOutput, error)); ok { + return returnFunc(v, getBucketPolicyStatusInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketPolicyStatusInput, ...request.Option) *s3.GetBucketPolicyStatusOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketPolicyStatusInput, ...request.Option) *s3.GetBucketPolicyStatusOutput); ok { + r0 = returnFunc(v, getBucketPolicyStatusInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketPolicyStatusOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketPolicyStatusInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketPolicyStatusInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketPolicyStatusInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketPolicyWithContext(_a0 context.Context, _a1 *s3.GetBucketPolicyInput, _a2 ...request.Option) (*s3.GetBucketPolicyOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketPolicyStatusWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketPolicyStatusWithContext' +type S3API_GetBucketPolicyStatusWithContext_Call struct { + *mock.Call +} + +// GetBucketPolicyStatusWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketPolicyStatusInput *s3.GetBucketPolicyStatusInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketPolicyStatusWithContext(v interface{}, getBucketPolicyStatusInput interface{}, options ...interface{}) *S3API_GetBucketPolicyStatusWithContext_Call { + return &S3API_GetBucketPolicyStatusWithContext_Call{Call: _e.mock.On("GetBucketPolicyStatusWithContext", + append([]interface{}{v, getBucketPolicyStatusInput}, options...)...)} +} + +func (_c *S3API_GetBucketPolicyStatusWithContext_Call) Run(run func(v aws.Context, getBucketPolicyStatusInput *s3.GetBucketPolicyStatusInput, options ...request.Option)) *S3API_GetBucketPolicyStatusWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketPolicyStatusInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketPolicyStatusInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketPolicyStatusWithContext_Call) Return(getBucketPolicyStatusOutput *s3.GetBucketPolicyStatusOutput, err error) *S3API_GetBucketPolicyStatusWithContext_Call { + _c.Call.Return(getBucketPolicyStatusOutput, err) + return _c +} + +func (_c *S3API_GetBucketPolicyStatusWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketPolicyStatusInput *s3.GetBucketPolicyStatusInput, options ...request.Option) (*s3.GetBucketPolicyStatusOutput, error)) *S3API_GetBucketPolicyStatusWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketPolicyWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketPolicyWithContext(v aws.Context, getBucketPolicyInput *s3.GetBucketPolicyInput, options ...request.Option) (*s3.GetBucketPolicyOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketPolicyInput, options) + } else { + tmpRet = _mock.Called(v, getBucketPolicyInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketPolicyWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketPolicyOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketPolicyInput, ...request.Option) (*s3.GetBucketPolicyOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketPolicyInput, ...request.Option) (*s3.GetBucketPolicyOutput, error)); ok { + return returnFunc(v, getBucketPolicyInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketPolicyInput, ...request.Option) *s3.GetBucketPolicyOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketPolicyInput, ...request.Option) *s3.GetBucketPolicyOutput); ok { + r0 = returnFunc(v, getBucketPolicyInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketPolicyOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketPolicyInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketPolicyInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketPolicyInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketReplication provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketReplication(_a0 *s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketPolicyWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketPolicyWithContext' +type S3API_GetBucketPolicyWithContext_Call struct { + *mock.Call +} + +// GetBucketPolicyWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketPolicyInput *s3.GetBucketPolicyInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketPolicyWithContext(v interface{}, getBucketPolicyInput interface{}, options ...interface{}) *S3API_GetBucketPolicyWithContext_Call { + return &S3API_GetBucketPolicyWithContext_Call{Call: _e.mock.On("GetBucketPolicyWithContext", + append([]interface{}{v, getBucketPolicyInput}, options...)...)} +} + +func (_c *S3API_GetBucketPolicyWithContext_Call) Run(run func(v aws.Context, getBucketPolicyInput *s3.GetBucketPolicyInput, options ...request.Option)) *S3API_GetBucketPolicyWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketPolicyInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketPolicyInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketPolicyWithContext_Call) Return(getBucketPolicyOutput *s3.GetBucketPolicyOutput, err error) *S3API_GetBucketPolicyWithContext_Call { + _c.Call.Return(getBucketPolicyOutput, err) + return _c +} + +func (_c *S3API_GetBucketPolicyWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketPolicyInput *s3.GetBucketPolicyInput, options ...request.Option) (*s3.GetBucketPolicyOutput, error)) *S3API_GetBucketPolicyWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketReplication provides a mock function for the type S3API +func (_mock *S3API) GetBucketReplication(getBucketReplicationInput *s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error) { + ret := _mock.Called(getBucketReplicationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketReplication") + } var r0 *s3.GetBucketReplicationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error)); ok { + return returnFunc(getBucketReplicationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketReplicationInput) *s3.GetBucketReplicationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketReplicationInput) *s3.GetBucketReplicationOutput); ok { + r0 = returnFunc(getBucketReplicationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketReplicationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketReplicationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketReplicationInput) error); ok { + r1 = returnFunc(getBucketReplicationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketReplicationRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketReplicationRequest(_a0 *s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketReplication_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketReplication' +type S3API_GetBucketReplication_Call struct { + *mock.Call +} + +// GetBucketReplication is a helper method to define mock.On call +// - getBucketReplicationInput *s3.GetBucketReplicationInput +func (_e *S3API_Expecter) GetBucketReplication(getBucketReplicationInput interface{}) *S3API_GetBucketReplication_Call { + return &S3API_GetBucketReplication_Call{Call: _e.mock.On("GetBucketReplication", getBucketReplicationInput)} +} + +func (_c *S3API_GetBucketReplication_Call) Run(run func(getBucketReplicationInput *s3.GetBucketReplicationInput)) *S3API_GetBucketReplication_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketReplicationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketReplicationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketReplication_Call) Return(getBucketReplicationOutput *s3.GetBucketReplicationOutput, err error) *S3API_GetBucketReplication_Call { + _c.Call.Return(getBucketReplicationOutput, err) + return _c +} + +func (_c *S3API_GetBucketReplication_Call) RunAndReturn(run func(getBucketReplicationInput *s3.GetBucketReplicationInput) (*s3.GetBucketReplicationOutput, error)) *S3API_GetBucketReplication_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketReplicationRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketReplicationRequest(getBucketReplicationInput *s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput) { + ret := _mock.Called(getBucketReplicationInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketReplicationRequest") + } var r0 *request.Request var r1 *s3.GetBucketReplicationOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput)); ok { + return returnFunc(getBucketReplicationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketReplicationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketReplicationInput) *request.Request); ok { + r0 = returnFunc(getBucketReplicationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketReplicationInput) *s3.GetBucketReplicationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketReplicationInput) *s3.GetBucketReplicationOutput); ok { + r1 = returnFunc(getBucketReplicationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketReplicationOutput) } } - return r0, r1 } -// GetBucketReplicationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketReplicationWithContext(_a0 context.Context, _a1 *s3.GetBucketReplicationInput, _a2 ...request.Option) (*s3.GetBucketReplicationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] - } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) +// S3API_GetBucketReplicationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketReplicationRequest' +type S3API_GetBucketReplicationRequest_Call struct { + *mock.Call +} - var r0 *s3.GetBucketReplicationOutput - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketReplicationInput, ...request.Option) (*s3.GetBucketReplicationOutput, error)); ok { - return rf(_a0, _a1, _a2...) - } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketReplicationInput, ...request.Option) *s3.GetBucketReplicationOutput); ok { - r0 = rf(_a0, _a1, _a2...) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*s3.GetBucketReplicationOutput) +// GetBucketReplicationRequest is a helper method to define mock.On call +// - getBucketReplicationInput *s3.GetBucketReplicationInput +func (_e *S3API_Expecter) GetBucketReplicationRequest(getBucketReplicationInput interface{}) *S3API_GetBucketReplicationRequest_Call { + return &S3API_GetBucketReplicationRequest_Call{Call: _e.mock.On("GetBucketReplicationRequest", getBucketReplicationInput)} +} + +func (_c *S3API_GetBucketReplicationRequest_Call) Run(run func(getBucketReplicationInput *s3.GetBucketReplicationInput)) *S3API_GetBucketReplicationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketReplicationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketReplicationInput) } - } + run( + arg0, + ) + }) + return _c +} - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketReplicationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) - } else { - r1 = ret.Error(1) - } +func (_c *S3API_GetBucketReplicationRequest_Call) Return(request1 *request.Request, getBucketReplicationOutput *s3.GetBucketReplicationOutput) *S3API_GetBucketReplicationRequest_Call { + _c.Call.Return(request1, getBucketReplicationOutput) + return _c +} - return r0, r1 +func (_c *S3API_GetBucketReplicationRequest_Call) RunAndReturn(run func(getBucketReplicationInput *s3.GetBucketReplicationInput) (*request.Request, *s3.GetBucketReplicationOutput)) *S3API_GetBucketReplicationRequest_Call { + _c.Call.Return(run) + return _c } -// GetBucketRequestPayment provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketRequestPayment(_a0 *s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error) { - ret := _m.Called(_a0) +// GetBucketReplicationWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketReplicationWithContext(v aws.Context, getBucketReplicationInput *s3.GetBucketReplicationInput, options ...request.Option) (*s3.GetBucketReplicationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketReplicationInput, options) + } else { + tmpRet = _mock.Called(v, getBucketReplicationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketReplicationWithContext") + } - var r0 *s3.GetBucketRequestPaymentOutput + var r0 *s3.GetBucketReplicationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketReplicationInput, ...request.Option) (*s3.GetBucketReplicationOutput, error)); ok { + return returnFunc(v, getBucketReplicationInput, options...) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketRequestPaymentInput) *s3.GetBucketRequestPaymentOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketReplicationInput, ...request.Option) *s3.GetBucketReplicationOutput); ok { + r0 = returnFunc(v, getBucketReplicationInput, options...) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*s3.GetBucketRequestPaymentOutput) + r0 = ret.Get(0).(*s3.GetBucketReplicationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketRequestPaymentInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketReplicationInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketReplicationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketRequestPaymentRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketRequestPaymentRequest(_a0 *s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketReplicationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketReplicationWithContext' +type S3API_GetBucketReplicationWithContext_Call struct { + *mock.Call +} - var r0 *request.Request - var r1 *s3.GetBucketRequestPaymentOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput)); ok { - return rf(_a0) +// GetBucketReplicationWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketReplicationInput *s3.GetBucketReplicationInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketReplicationWithContext(v interface{}, getBucketReplicationInput interface{}, options ...interface{}) *S3API_GetBucketReplicationWithContext_Call { + return &S3API_GetBucketReplicationWithContext_Call{Call: _e.mock.On("GetBucketReplicationWithContext", + append([]interface{}{v, getBucketReplicationInput}, options...)...)} +} + +func (_c *S3API_GetBucketReplicationWithContext_Call) Run(run func(v aws.Context, getBucketReplicationInput *s3.GetBucketReplicationInput, options ...request.Option)) *S3API_GetBucketReplicationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketReplicationInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketReplicationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketReplicationWithContext_Call) Return(getBucketReplicationOutput *s3.GetBucketReplicationOutput, err error) *S3API_GetBucketReplicationWithContext_Call { + _c.Call.Return(getBucketReplicationOutput, err) + return _c +} + +func (_c *S3API_GetBucketReplicationWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketReplicationInput *s3.GetBucketReplicationInput, options ...request.Option) (*s3.GetBucketReplicationOutput, error)) *S3API_GetBucketReplicationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketRequestPayment provides a mock function for the type S3API +func (_mock *S3API) GetBucketRequestPayment(getBucketRequestPaymentInput *s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error) { + ret := _mock.Called(getBucketRequestPaymentInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketRequestPayment") + } + + var r0 *s3.GetBucketRequestPaymentOutput + var r1 error + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error)); ok { + return returnFunc(getBucketRequestPaymentInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketRequestPaymentInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketRequestPaymentInput) *s3.GetBucketRequestPaymentOutput); ok { + r0 = returnFunc(getBucketRequestPaymentInput) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*request.Request) + r0 = ret.Get(0).(*s3.GetBucketRequestPaymentOutput) + } + } + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketRequestPaymentInput) error); ok { + r1 = returnFunc(getBucketRequestPaymentInput) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// S3API_GetBucketRequestPayment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketRequestPayment' +type S3API_GetBucketRequestPayment_Call struct { + *mock.Call +} + +// GetBucketRequestPayment is a helper method to define mock.On call +// - getBucketRequestPaymentInput *s3.GetBucketRequestPaymentInput +func (_e *S3API_Expecter) GetBucketRequestPayment(getBucketRequestPaymentInput interface{}) *S3API_GetBucketRequestPayment_Call { + return &S3API_GetBucketRequestPayment_Call{Call: _e.mock.On("GetBucketRequestPayment", getBucketRequestPaymentInput)} +} + +func (_c *S3API_GetBucketRequestPayment_Call) Run(run func(getBucketRequestPaymentInput *s3.GetBucketRequestPaymentInput)) *S3API_GetBucketRequestPayment_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketRequestPaymentInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketRequestPaymentInput) } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketRequestPayment_Call) Return(getBucketRequestPaymentOutput *s3.GetBucketRequestPaymentOutput, err error) *S3API_GetBucketRequestPayment_Call { + _c.Call.Return(getBucketRequestPaymentOutput, err) + return _c +} + +func (_c *S3API_GetBucketRequestPayment_Call) RunAndReturn(run func(getBucketRequestPaymentInput *s3.GetBucketRequestPaymentInput) (*s3.GetBucketRequestPaymentOutput, error)) *S3API_GetBucketRequestPayment_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketRequestPaymentRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketRequestPaymentRequest(getBucketRequestPaymentInput *s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput) { + ret := _mock.Called(getBucketRequestPaymentInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketRequestPaymentRequest") } - if rf, ok := ret.Get(1).(func(*s3.GetBucketRequestPaymentInput) *s3.GetBucketRequestPaymentOutput); ok { - r1 = rf(_a0) + var r0 *request.Request + var r1 *s3.GetBucketRequestPaymentOutput + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput)); ok { + return returnFunc(getBucketRequestPaymentInput) + } + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketRequestPaymentInput) *request.Request); ok { + r0 = returnFunc(getBucketRequestPaymentInput) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*request.Request) + } + } + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketRequestPaymentInput) *s3.GetBucketRequestPaymentOutput); ok { + r1 = returnFunc(getBucketRequestPaymentInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketRequestPaymentOutput) } } - return r0, r1 } -// GetBucketRequestPaymentWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketRequestPaymentWithContext(_a0 context.Context, _a1 *s3.GetBucketRequestPaymentInput, _a2 ...request.Option) (*s3.GetBucketRequestPaymentOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketRequestPaymentRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketRequestPaymentRequest' +type S3API_GetBucketRequestPaymentRequest_Call struct { + *mock.Call +} + +// GetBucketRequestPaymentRequest is a helper method to define mock.On call +// - getBucketRequestPaymentInput *s3.GetBucketRequestPaymentInput +func (_e *S3API_Expecter) GetBucketRequestPaymentRequest(getBucketRequestPaymentInput interface{}) *S3API_GetBucketRequestPaymentRequest_Call { + return &S3API_GetBucketRequestPaymentRequest_Call{Call: _e.mock.On("GetBucketRequestPaymentRequest", getBucketRequestPaymentInput)} +} + +func (_c *S3API_GetBucketRequestPaymentRequest_Call) Run(run func(getBucketRequestPaymentInput *s3.GetBucketRequestPaymentInput)) *S3API_GetBucketRequestPaymentRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketRequestPaymentInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketRequestPaymentInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketRequestPaymentRequest_Call) Return(request1 *request.Request, getBucketRequestPaymentOutput *s3.GetBucketRequestPaymentOutput) *S3API_GetBucketRequestPaymentRequest_Call { + _c.Call.Return(request1, getBucketRequestPaymentOutput) + return _c +} + +func (_c *S3API_GetBucketRequestPaymentRequest_Call) RunAndReturn(run func(getBucketRequestPaymentInput *s3.GetBucketRequestPaymentInput) (*request.Request, *s3.GetBucketRequestPaymentOutput)) *S3API_GetBucketRequestPaymentRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketRequestPaymentWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketRequestPaymentWithContext(v aws.Context, getBucketRequestPaymentInput *s3.GetBucketRequestPaymentInput, options ...request.Option) (*s3.GetBucketRequestPaymentOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketRequestPaymentInput, options) + } else { + tmpRet = _mock.Called(v, getBucketRequestPaymentInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketRequestPaymentWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketRequestPaymentOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketRequestPaymentInput, ...request.Option) (*s3.GetBucketRequestPaymentOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketRequestPaymentInput, ...request.Option) (*s3.GetBucketRequestPaymentOutput, error)); ok { + return returnFunc(v, getBucketRequestPaymentInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketRequestPaymentInput, ...request.Option) *s3.GetBucketRequestPaymentOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketRequestPaymentInput, ...request.Option) *s3.GetBucketRequestPaymentOutput); ok { + r0 = returnFunc(v, getBucketRequestPaymentInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketRequestPaymentOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketRequestPaymentInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketRequestPaymentInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketRequestPaymentInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketTagging provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketTagging(_a0 *s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketRequestPaymentWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketRequestPaymentWithContext' +type S3API_GetBucketRequestPaymentWithContext_Call struct { + *mock.Call +} + +// GetBucketRequestPaymentWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketRequestPaymentInput *s3.GetBucketRequestPaymentInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketRequestPaymentWithContext(v interface{}, getBucketRequestPaymentInput interface{}, options ...interface{}) *S3API_GetBucketRequestPaymentWithContext_Call { + return &S3API_GetBucketRequestPaymentWithContext_Call{Call: _e.mock.On("GetBucketRequestPaymentWithContext", + append([]interface{}{v, getBucketRequestPaymentInput}, options...)...)} +} + +func (_c *S3API_GetBucketRequestPaymentWithContext_Call) Run(run func(v aws.Context, getBucketRequestPaymentInput *s3.GetBucketRequestPaymentInput, options ...request.Option)) *S3API_GetBucketRequestPaymentWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketRequestPaymentInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketRequestPaymentInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketRequestPaymentWithContext_Call) Return(getBucketRequestPaymentOutput *s3.GetBucketRequestPaymentOutput, err error) *S3API_GetBucketRequestPaymentWithContext_Call { + _c.Call.Return(getBucketRequestPaymentOutput, err) + return _c +} + +func (_c *S3API_GetBucketRequestPaymentWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketRequestPaymentInput *s3.GetBucketRequestPaymentInput, options ...request.Option) (*s3.GetBucketRequestPaymentOutput, error)) *S3API_GetBucketRequestPaymentWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketTagging provides a mock function for the type S3API +func (_mock *S3API) GetBucketTagging(getBucketTaggingInput *s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error) { + ret := _mock.Called(getBucketTaggingInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketTagging") + } var r0 *s3.GetBucketTaggingOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error)); ok { + return returnFunc(getBucketTaggingInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketTaggingInput) *s3.GetBucketTaggingOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketTaggingInput) *s3.GetBucketTaggingOutput); ok { + r0 = returnFunc(getBucketTaggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketTaggingOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketTaggingInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketTaggingInput) error); ok { + r1 = returnFunc(getBucketTaggingInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketTaggingRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketTaggingRequest(_a0 *s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketTagging' +type S3API_GetBucketTagging_Call struct { + *mock.Call +} + +// GetBucketTagging is a helper method to define mock.On call +// - getBucketTaggingInput *s3.GetBucketTaggingInput +func (_e *S3API_Expecter) GetBucketTagging(getBucketTaggingInput interface{}) *S3API_GetBucketTagging_Call { + return &S3API_GetBucketTagging_Call{Call: _e.mock.On("GetBucketTagging", getBucketTaggingInput)} +} + +func (_c *S3API_GetBucketTagging_Call) Run(run func(getBucketTaggingInput *s3.GetBucketTaggingInput)) *S3API_GetBucketTagging_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketTaggingInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketTaggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketTagging_Call) Return(getBucketTaggingOutput *s3.GetBucketTaggingOutput, err error) *S3API_GetBucketTagging_Call { + _c.Call.Return(getBucketTaggingOutput, err) + return _c +} + +func (_c *S3API_GetBucketTagging_Call) RunAndReturn(run func(getBucketTaggingInput *s3.GetBucketTaggingInput) (*s3.GetBucketTaggingOutput, error)) *S3API_GetBucketTagging_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketTaggingRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketTaggingRequest(getBucketTaggingInput *s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput) { + ret := _mock.Called(getBucketTaggingInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketTaggingRequest") + } var r0 *request.Request var r1 *s3.GetBucketTaggingOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput)); ok { + return returnFunc(getBucketTaggingInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketTaggingInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketTaggingInput) *request.Request); ok { + r0 = returnFunc(getBucketTaggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketTaggingInput) *s3.GetBucketTaggingOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketTaggingInput) *s3.GetBucketTaggingOutput); ok { + r1 = returnFunc(getBucketTaggingInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketTaggingOutput) } } - return r0, r1 } -// GetBucketTaggingWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketTaggingWithContext(_a0 context.Context, _a1 *s3.GetBucketTaggingInput, _a2 ...request.Option) (*s3.GetBucketTaggingOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketTaggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketTaggingRequest' +type S3API_GetBucketTaggingRequest_Call struct { + *mock.Call +} + +// GetBucketTaggingRequest is a helper method to define mock.On call +// - getBucketTaggingInput *s3.GetBucketTaggingInput +func (_e *S3API_Expecter) GetBucketTaggingRequest(getBucketTaggingInput interface{}) *S3API_GetBucketTaggingRequest_Call { + return &S3API_GetBucketTaggingRequest_Call{Call: _e.mock.On("GetBucketTaggingRequest", getBucketTaggingInput)} +} + +func (_c *S3API_GetBucketTaggingRequest_Call) Run(run func(getBucketTaggingInput *s3.GetBucketTaggingInput)) *S3API_GetBucketTaggingRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketTaggingInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketTaggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketTaggingRequest_Call) Return(request1 *request.Request, getBucketTaggingOutput *s3.GetBucketTaggingOutput) *S3API_GetBucketTaggingRequest_Call { + _c.Call.Return(request1, getBucketTaggingOutput) + return _c +} + +func (_c *S3API_GetBucketTaggingRequest_Call) RunAndReturn(run func(getBucketTaggingInput *s3.GetBucketTaggingInput) (*request.Request, *s3.GetBucketTaggingOutput)) *S3API_GetBucketTaggingRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketTaggingWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketTaggingWithContext(v aws.Context, getBucketTaggingInput *s3.GetBucketTaggingInput, options ...request.Option) (*s3.GetBucketTaggingOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketTaggingInput, options) + } else { + tmpRet = _mock.Called(v, getBucketTaggingInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketTaggingWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketTaggingOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketTaggingInput, ...request.Option) (*s3.GetBucketTaggingOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketTaggingInput, ...request.Option) (*s3.GetBucketTaggingOutput, error)); ok { + return returnFunc(v, getBucketTaggingInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketTaggingInput, ...request.Option) *s3.GetBucketTaggingOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketTaggingInput, ...request.Option) *s3.GetBucketTaggingOutput); ok { + r0 = returnFunc(v, getBucketTaggingInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketTaggingOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketTaggingInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketTaggingInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketTaggingInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketVersioning provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketVersioning(_a0 *s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketTaggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketTaggingWithContext' +type S3API_GetBucketTaggingWithContext_Call struct { + *mock.Call +} + +// GetBucketTaggingWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketTaggingInput *s3.GetBucketTaggingInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketTaggingWithContext(v interface{}, getBucketTaggingInput interface{}, options ...interface{}) *S3API_GetBucketTaggingWithContext_Call { + return &S3API_GetBucketTaggingWithContext_Call{Call: _e.mock.On("GetBucketTaggingWithContext", + append([]interface{}{v, getBucketTaggingInput}, options...)...)} +} + +func (_c *S3API_GetBucketTaggingWithContext_Call) Run(run func(v aws.Context, getBucketTaggingInput *s3.GetBucketTaggingInput, options ...request.Option)) *S3API_GetBucketTaggingWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketTaggingInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketTaggingInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketTaggingWithContext_Call) Return(getBucketTaggingOutput *s3.GetBucketTaggingOutput, err error) *S3API_GetBucketTaggingWithContext_Call { + _c.Call.Return(getBucketTaggingOutput, err) + return _c +} + +func (_c *S3API_GetBucketTaggingWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketTaggingInput *s3.GetBucketTaggingInput, options ...request.Option) (*s3.GetBucketTaggingOutput, error)) *S3API_GetBucketTaggingWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketVersioning provides a mock function for the type S3API +func (_mock *S3API) GetBucketVersioning(getBucketVersioningInput *s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error) { + ret := _mock.Called(getBucketVersioningInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketVersioning") + } var r0 *s3.GetBucketVersioningOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error)); ok { + return returnFunc(getBucketVersioningInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketVersioningInput) *s3.GetBucketVersioningOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketVersioningInput) *s3.GetBucketVersioningOutput); ok { + r0 = returnFunc(getBucketVersioningInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketVersioningOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketVersioningInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketVersioningInput) error); ok { + r1 = returnFunc(getBucketVersioningInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketVersioningRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketVersioningRequest(_a0 *s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketVersioning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketVersioning' +type S3API_GetBucketVersioning_Call struct { + *mock.Call +} + +// GetBucketVersioning is a helper method to define mock.On call +// - getBucketVersioningInput *s3.GetBucketVersioningInput +func (_e *S3API_Expecter) GetBucketVersioning(getBucketVersioningInput interface{}) *S3API_GetBucketVersioning_Call { + return &S3API_GetBucketVersioning_Call{Call: _e.mock.On("GetBucketVersioning", getBucketVersioningInput)} +} + +func (_c *S3API_GetBucketVersioning_Call) Run(run func(getBucketVersioningInput *s3.GetBucketVersioningInput)) *S3API_GetBucketVersioning_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketVersioningInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketVersioningInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketVersioning_Call) Return(getBucketVersioningOutput *s3.GetBucketVersioningOutput, err error) *S3API_GetBucketVersioning_Call { + _c.Call.Return(getBucketVersioningOutput, err) + return _c +} + +func (_c *S3API_GetBucketVersioning_Call) RunAndReturn(run func(getBucketVersioningInput *s3.GetBucketVersioningInput) (*s3.GetBucketVersioningOutput, error)) *S3API_GetBucketVersioning_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketVersioningRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketVersioningRequest(getBucketVersioningInput *s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput) { + ret := _mock.Called(getBucketVersioningInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketVersioningRequest") + } var r0 *request.Request var r1 *s3.GetBucketVersioningOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput)); ok { + return returnFunc(getBucketVersioningInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketVersioningInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketVersioningInput) *request.Request); ok { + r0 = returnFunc(getBucketVersioningInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketVersioningInput) *s3.GetBucketVersioningOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketVersioningInput) *s3.GetBucketVersioningOutput); ok { + r1 = returnFunc(getBucketVersioningInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketVersioningOutput) } } - return r0, r1 } -// GetBucketVersioningWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketVersioningWithContext(_a0 context.Context, _a1 *s3.GetBucketVersioningInput, _a2 ...request.Option) (*s3.GetBucketVersioningOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketVersioningRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketVersioningRequest' +type S3API_GetBucketVersioningRequest_Call struct { + *mock.Call +} + +// GetBucketVersioningRequest is a helper method to define mock.On call +// - getBucketVersioningInput *s3.GetBucketVersioningInput +func (_e *S3API_Expecter) GetBucketVersioningRequest(getBucketVersioningInput interface{}) *S3API_GetBucketVersioningRequest_Call { + return &S3API_GetBucketVersioningRequest_Call{Call: _e.mock.On("GetBucketVersioningRequest", getBucketVersioningInput)} +} + +func (_c *S3API_GetBucketVersioningRequest_Call) Run(run func(getBucketVersioningInput *s3.GetBucketVersioningInput)) *S3API_GetBucketVersioningRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketVersioningInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketVersioningInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketVersioningRequest_Call) Return(request1 *request.Request, getBucketVersioningOutput *s3.GetBucketVersioningOutput) *S3API_GetBucketVersioningRequest_Call { + _c.Call.Return(request1, getBucketVersioningOutput) + return _c +} + +func (_c *S3API_GetBucketVersioningRequest_Call) RunAndReturn(run func(getBucketVersioningInput *s3.GetBucketVersioningInput) (*request.Request, *s3.GetBucketVersioningOutput)) *S3API_GetBucketVersioningRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketVersioningWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketVersioningWithContext(v aws.Context, getBucketVersioningInput *s3.GetBucketVersioningInput, options ...request.Option) (*s3.GetBucketVersioningOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketVersioningInput, options) + } else { + tmpRet = _mock.Called(v, getBucketVersioningInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketVersioningWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketVersioningOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketVersioningInput, ...request.Option) (*s3.GetBucketVersioningOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketVersioningInput, ...request.Option) (*s3.GetBucketVersioningOutput, error)); ok { + return returnFunc(v, getBucketVersioningInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketVersioningInput, ...request.Option) *s3.GetBucketVersioningOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketVersioningInput, ...request.Option) *s3.GetBucketVersioningOutput); ok { + r0 = returnFunc(v, getBucketVersioningInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketVersioningOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketVersioningInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketVersioningInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketVersioningInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketWebsite provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketWebsite(_a0 *s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketVersioningWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketVersioningWithContext' +type S3API_GetBucketVersioningWithContext_Call struct { + *mock.Call +} + +// GetBucketVersioningWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketVersioningInput *s3.GetBucketVersioningInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketVersioningWithContext(v interface{}, getBucketVersioningInput interface{}, options ...interface{}) *S3API_GetBucketVersioningWithContext_Call { + return &S3API_GetBucketVersioningWithContext_Call{Call: _e.mock.On("GetBucketVersioningWithContext", + append([]interface{}{v, getBucketVersioningInput}, options...)...)} +} + +func (_c *S3API_GetBucketVersioningWithContext_Call) Run(run func(v aws.Context, getBucketVersioningInput *s3.GetBucketVersioningInput, options ...request.Option)) *S3API_GetBucketVersioningWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketVersioningInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketVersioningInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketVersioningWithContext_Call) Return(getBucketVersioningOutput *s3.GetBucketVersioningOutput, err error) *S3API_GetBucketVersioningWithContext_Call { + _c.Call.Return(getBucketVersioningOutput, err) + return _c +} + +func (_c *S3API_GetBucketVersioningWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketVersioningInput *s3.GetBucketVersioningInput, options ...request.Option) (*s3.GetBucketVersioningOutput, error)) *S3API_GetBucketVersioningWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketWebsite provides a mock function for the type S3API +func (_mock *S3API) GetBucketWebsite(getBucketWebsiteInput *s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error) { + ret := _mock.Called(getBucketWebsiteInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketWebsite") + } var r0 *s3.GetBucketWebsiteOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error)); ok { + return returnFunc(getBucketWebsiteInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketWebsiteInput) *s3.GetBucketWebsiteOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketWebsiteInput) *s3.GetBucketWebsiteOutput); ok { + r0 = returnFunc(getBucketWebsiteInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketWebsiteOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketWebsiteInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketWebsiteInput) error); ok { + r1 = returnFunc(getBucketWebsiteInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetBucketWebsiteRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetBucketWebsiteRequest(_a0 *s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput) { - ret := _m.Called(_a0) +// S3API_GetBucketWebsite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketWebsite' +type S3API_GetBucketWebsite_Call struct { + *mock.Call +} + +// GetBucketWebsite is a helper method to define mock.On call +// - getBucketWebsiteInput *s3.GetBucketWebsiteInput +func (_e *S3API_Expecter) GetBucketWebsite(getBucketWebsiteInput interface{}) *S3API_GetBucketWebsite_Call { + return &S3API_GetBucketWebsite_Call{Call: _e.mock.On("GetBucketWebsite", getBucketWebsiteInput)} +} + +func (_c *S3API_GetBucketWebsite_Call) Run(run func(getBucketWebsiteInput *s3.GetBucketWebsiteInput)) *S3API_GetBucketWebsite_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketWebsiteInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketWebsiteInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketWebsite_Call) Return(getBucketWebsiteOutput *s3.GetBucketWebsiteOutput, err error) *S3API_GetBucketWebsite_Call { + _c.Call.Return(getBucketWebsiteOutput, err) + return _c +} + +func (_c *S3API_GetBucketWebsite_Call) RunAndReturn(run func(getBucketWebsiteInput *s3.GetBucketWebsiteInput) (*s3.GetBucketWebsiteOutput, error)) *S3API_GetBucketWebsite_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketWebsiteRequest provides a mock function for the type S3API +func (_mock *S3API) GetBucketWebsiteRequest(getBucketWebsiteInput *s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput) { + ret := _mock.Called(getBucketWebsiteInput) + + if len(ret) == 0 { + panic("no return value specified for GetBucketWebsiteRequest") + } var r0 *request.Request var r1 *s3.GetBucketWebsiteOutput - if rf, ok := ret.Get(0).(func(*s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput)); ok { + return returnFunc(getBucketWebsiteInput) } - if rf, ok := ret.Get(0).(func(*s3.GetBucketWebsiteInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetBucketWebsiteInput) *request.Request); ok { + r0 = returnFunc(getBucketWebsiteInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetBucketWebsiteInput) *s3.GetBucketWebsiteOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetBucketWebsiteInput) *s3.GetBucketWebsiteOutput); ok { + r1 = returnFunc(getBucketWebsiteInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetBucketWebsiteOutput) } } - return r0, r1 } -// GetBucketWebsiteWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetBucketWebsiteWithContext(_a0 context.Context, _a1 *s3.GetBucketWebsiteInput, _a2 ...request.Option) (*s3.GetBucketWebsiteOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetBucketWebsiteRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketWebsiteRequest' +type S3API_GetBucketWebsiteRequest_Call struct { + *mock.Call +} + +// GetBucketWebsiteRequest is a helper method to define mock.On call +// - getBucketWebsiteInput *s3.GetBucketWebsiteInput +func (_e *S3API_Expecter) GetBucketWebsiteRequest(getBucketWebsiteInput interface{}) *S3API_GetBucketWebsiteRequest_Call { + return &S3API_GetBucketWebsiteRequest_Call{Call: _e.mock.On("GetBucketWebsiteRequest", getBucketWebsiteInput)} +} + +func (_c *S3API_GetBucketWebsiteRequest_Call) Run(run func(getBucketWebsiteInput *s3.GetBucketWebsiteInput)) *S3API_GetBucketWebsiteRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetBucketWebsiteInput + if args[0] != nil { + arg0 = args[0].(*s3.GetBucketWebsiteInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetBucketWebsiteRequest_Call) Return(request1 *request.Request, getBucketWebsiteOutput *s3.GetBucketWebsiteOutput) *S3API_GetBucketWebsiteRequest_Call { + _c.Call.Return(request1, getBucketWebsiteOutput) + return _c +} + +func (_c *S3API_GetBucketWebsiteRequest_Call) RunAndReturn(run func(getBucketWebsiteInput *s3.GetBucketWebsiteInput) (*request.Request, *s3.GetBucketWebsiteOutput)) *S3API_GetBucketWebsiteRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetBucketWebsiteWithContext provides a mock function for the type S3API +func (_mock *S3API) GetBucketWebsiteWithContext(v aws.Context, getBucketWebsiteInput *s3.GetBucketWebsiteInput, options ...request.Option) (*s3.GetBucketWebsiteOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getBucketWebsiteInput, options) + } else { + tmpRet = _mock.Called(v, getBucketWebsiteInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetBucketWebsiteWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetBucketWebsiteOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketWebsiteInput, ...request.Option) (*s3.GetBucketWebsiteOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketWebsiteInput, ...request.Option) (*s3.GetBucketWebsiteOutput, error)); ok { + return returnFunc(v, getBucketWebsiteInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetBucketWebsiteInput, ...request.Option) *s3.GetBucketWebsiteOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetBucketWebsiteInput, ...request.Option) *s3.GetBucketWebsiteOutput); ok { + r0 = returnFunc(v, getBucketWebsiteInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetBucketWebsiteOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetBucketWebsiteInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetBucketWebsiteInput, ...request.Option) error); ok { + r1 = returnFunc(v, getBucketWebsiteInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObject provides a mock function with given fields: _a0 -func (_m *S3API) GetObject(_a0 *s3.GetObjectInput) (*s3.GetObjectOutput, error) { - ret := _m.Called(_a0) +// S3API_GetBucketWebsiteWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetBucketWebsiteWithContext' +type S3API_GetBucketWebsiteWithContext_Call struct { + *mock.Call +} + +// GetBucketWebsiteWithContext is a helper method to define mock.On call +// - v aws.Context +// - getBucketWebsiteInput *s3.GetBucketWebsiteInput +// - options ...request.Option +func (_e *S3API_Expecter) GetBucketWebsiteWithContext(v interface{}, getBucketWebsiteInput interface{}, options ...interface{}) *S3API_GetBucketWebsiteWithContext_Call { + return &S3API_GetBucketWebsiteWithContext_Call{Call: _e.mock.On("GetBucketWebsiteWithContext", + append([]interface{}{v, getBucketWebsiteInput}, options...)...)} +} + +func (_c *S3API_GetBucketWebsiteWithContext_Call) Run(run func(v aws.Context, getBucketWebsiteInput *s3.GetBucketWebsiteInput, options ...request.Option)) *S3API_GetBucketWebsiteWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetBucketWebsiteInput + if args[1] != nil { + arg1 = args[1].(*s3.GetBucketWebsiteInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetBucketWebsiteWithContext_Call) Return(getBucketWebsiteOutput *s3.GetBucketWebsiteOutput, err error) *S3API_GetBucketWebsiteWithContext_Call { + _c.Call.Return(getBucketWebsiteOutput, err) + return _c +} + +func (_c *S3API_GetBucketWebsiteWithContext_Call) RunAndReturn(run func(v aws.Context, getBucketWebsiteInput *s3.GetBucketWebsiteInput, options ...request.Option) (*s3.GetBucketWebsiteOutput, error)) *S3API_GetBucketWebsiteWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetObject provides a mock function for the type S3API +func (_mock *S3API) GetObject(getObjectInput *s3.GetObjectInput) (*s3.GetObjectOutput, error) { + ret := _mock.Called(getObjectInput) + + if len(ret) == 0 { + panic("no return value specified for GetObject") + } var r0 *s3.GetObjectOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetObjectInput) (*s3.GetObjectOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectInput) (*s3.GetObjectOutput, error)); ok { + return returnFunc(getObjectInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectInput) *s3.GetObjectOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectInput) *s3.GetObjectOutput); ok { + r0 = returnFunc(getObjectInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectInput) error); ok { + r1 = returnFunc(getObjectInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectAcl provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectAcl(_a0 *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) { - ret := _m.Called(_a0) +// S3API_GetObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObject' +type S3API_GetObject_Call struct { + *mock.Call +} + +// GetObject is a helper method to define mock.On call +// - getObjectInput *s3.GetObjectInput +func (_e *S3API_Expecter) GetObject(getObjectInput interface{}) *S3API_GetObject_Call { + return &S3API_GetObject_Call{Call: _e.mock.On("GetObject", getObjectInput)} +} + +func (_c *S3API_GetObject_Call) Run(run func(getObjectInput *s3.GetObjectInput)) *S3API_GetObject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObject_Call) Return(getObjectOutput *s3.GetObjectOutput, err error) *S3API_GetObject_Call { + _c.Call.Return(getObjectOutput, err) + return _c +} + +func (_c *S3API_GetObject_Call) RunAndReturn(run func(getObjectInput *s3.GetObjectInput) (*s3.GetObjectOutput, error)) *S3API_GetObject_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectAcl provides a mock function for the type S3API +func (_mock *S3API) GetObjectAcl(getObjectAclInput *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error) { + ret := _mock.Called(getObjectAclInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectAcl") + } var r0 *s3.GetObjectAclOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error)); ok { + return returnFunc(getObjectAclInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectAclInput) *s3.GetObjectAclOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectAclInput) *s3.GetObjectAclOutput); ok { + r0 = returnFunc(getObjectAclInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectAclOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectAclInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectAclInput) error); ok { + r1 = returnFunc(getObjectAclInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectAclRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectAclRequest(_a0 *s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput) { - ret := _m.Called(_a0) +// S3API_GetObjectAcl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectAcl' +type S3API_GetObjectAcl_Call struct { + *mock.Call +} + +// GetObjectAcl is a helper method to define mock.On call +// - getObjectAclInput *s3.GetObjectAclInput +func (_e *S3API_Expecter) GetObjectAcl(getObjectAclInput interface{}) *S3API_GetObjectAcl_Call { + return &S3API_GetObjectAcl_Call{Call: _e.mock.On("GetObjectAcl", getObjectAclInput)} +} + +func (_c *S3API_GetObjectAcl_Call) Run(run func(getObjectAclInput *s3.GetObjectAclInput)) *S3API_GetObjectAcl_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectAclInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectAclInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectAcl_Call) Return(getObjectAclOutput *s3.GetObjectAclOutput, err error) *S3API_GetObjectAcl_Call { + _c.Call.Return(getObjectAclOutput, err) + return _c +} + +func (_c *S3API_GetObjectAcl_Call) RunAndReturn(run func(getObjectAclInput *s3.GetObjectAclInput) (*s3.GetObjectAclOutput, error)) *S3API_GetObjectAcl_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectAclRequest provides a mock function for the type S3API +func (_mock *S3API) GetObjectAclRequest(getObjectAclInput *s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput) { + ret := _mock.Called(getObjectAclInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectAclRequest") + } var r0 *request.Request var r1 *s3.GetObjectAclOutput - if rf, ok := ret.Get(0).(func(*s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput)); ok { + return returnFunc(getObjectAclInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectAclInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectAclInput) *request.Request); ok { + r0 = returnFunc(getObjectAclInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectAclInput) *s3.GetObjectAclOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectAclInput) *s3.GetObjectAclOutput); ok { + r1 = returnFunc(getObjectAclInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetObjectAclOutput) } } - return r0, r1 } -// GetObjectAclWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetObjectAclWithContext(_a0 context.Context, _a1 *s3.GetObjectAclInput, _a2 ...request.Option) (*s3.GetObjectAclOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] - } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) +// S3API_GetObjectAclRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectAclRequest' +type S3API_GetObjectAclRequest_Call struct { + *mock.Call +} - var r0 *s3.GetObjectAclOutput +// GetObjectAclRequest is a helper method to define mock.On call +// - getObjectAclInput *s3.GetObjectAclInput +func (_e *S3API_Expecter) GetObjectAclRequest(getObjectAclInput interface{}) *S3API_GetObjectAclRequest_Call { + return &S3API_GetObjectAclRequest_Call{Call: _e.mock.On("GetObjectAclRequest", getObjectAclInput)} +} + +func (_c *S3API_GetObjectAclRequest_Call) Run(run func(getObjectAclInput *s3.GetObjectAclInput)) *S3API_GetObjectAclRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectAclInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectAclInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectAclRequest_Call) Return(request1 *request.Request, getObjectAclOutput *s3.GetObjectAclOutput) *S3API_GetObjectAclRequest_Call { + _c.Call.Return(request1, getObjectAclOutput) + return _c +} + +func (_c *S3API_GetObjectAclRequest_Call) RunAndReturn(run func(getObjectAclInput *s3.GetObjectAclInput) (*request.Request, *s3.GetObjectAclOutput)) *S3API_GetObjectAclRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectAclWithContext provides a mock function for the type S3API +func (_mock *S3API) GetObjectAclWithContext(v aws.Context, getObjectAclInput *s3.GetObjectAclInput, options ...request.Option) (*s3.GetObjectAclOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getObjectAclInput, options) + } else { + tmpRet = _mock.Called(v, getObjectAclInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetObjectAclWithContext") + } + + var r0 *s3.GetObjectAclOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectAclInput, ...request.Option) (*s3.GetObjectAclOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectAclInput, ...request.Option) (*s3.GetObjectAclOutput, error)); ok { + return returnFunc(v, getObjectAclInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectAclInput, ...request.Option) *s3.GetObjectAclOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectAclInput, ...request.Option) *s3.GetObjectAclOutput); ok { + r0 = returnFunc(v, getObjectAclInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectAclOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetObjectAclInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectAclInput, ...request.Option) error); ok { + r1 = returnFunc(v, getObjectAclInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectAttributes provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectAttributes(_a0 *s3.GetObjectAttributesInput) (*s3.GetObjectAttributesOutput, error) { - ret := _m.Called(_a0) +// S3API_GetObjectAclWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectAclWithContext' +type S3API_GetObjectAclWithContext_Call struct { + *mock.Call +} + +// GetObjectAclWithContext is a helper method to define mock.On call +// - v aws.Context +// - getObjectAclInput *s3.GetObjectAclInput +// - options ...request.Option +func (_e *S3API_Expecter) GetObjectAclWithContext(v interface{}, getObjectAclInput interface{}, options ...interface{}) *S3API_GetObjectAclWithContext_Call { + return &S3API_GetObjectAclWithContext_Call{Call: _e.mock.On("GetObjectAclWithContext", + append([]interface{}{v, getObjectAclInput}, options...)...)} +} + +func (_c *S3API_GetObjectAclWithContext_Call) Run(run func(v aws.Context, getObjectAclInput *s3.GetObjectAclInput, options ...request.Option)) *S3API_GetObjectAclWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetObjectAclInput + if args[1] != nil { + arg1 = args[1].(*s3.GetObjectAclInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetObjectAclWithContext_Call) Return(getObjectAclOutput *s3.GetObjectAclOutput, err error) *S3API_GetObjectAclWithContext_Call { + _c.Call.Return(getObjectAclOutput, err) + return _c +} + +func (_c *S3API_GetObjectAclWithContext_Call) RunAndReturn(run func(v aws.Context, getObjectAclInput *s3.GetObjectAclInput, options ...request.Option) (*s3.GetObjectAclOutput, error)) *S3API_GetObjectAclWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectAttributes provides a mock function for the type S3API +func (_mock *S3API) GetObjectAttributes(getObjectAttributesInput *s3.GetObjectAttributesInput) (*s3.GetObjectAttributesOutput, error) { + ret := _mock.Called(getObjectAttributesInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectAttributes") + } var r0 *s3.GetObjectAttributesOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetObjectAttributesInput) (*s3.GetObjectAttributesOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectAttributesInput) (*s3.GetObjectAttributesOutput, error)); ok { + return returnFunc(getObjectAttributesInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectAttributesInput) *s3.GetObjectAttributesOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectAttributesInput) *s3.GetObjectAttributesOutput); ok { + r0 = returnFunc(getObjectAttributesInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectAttributesOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectAttributesInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectAttributesInput) error); ok { + r1 = returnFunc(getObjectAttributesInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectAttributesRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectAttributesRequest(_a0 *s3.GetObjectAttributesInput) (*request.Request, *s3.GetObjectAttributesOutput) { - ret := _m.Called(_a0) +// S3API_GetObjectAttributes_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectAttributes' +type S3API_GetObjectAttributes_Call struct { + *mock.Call +} + +// GetObjectAttributes is a helper method to define mock.On call +// - getObjectAttributesInput *s3.GetObjectAttributesInput +func (_e *S3API_Expecter) GetObjectAttributes(getObjectAttributesInput interface{}) *S3API_GetObjectAttributes_Call { + return &S3API_GetObjectAttributes_Call{Call: _e.mock.On("GetObjectAttributes", getObjectAttributesInput)} +} + +func (_c *S3API_GetObjectAttributes_Call) Run(run func(getObjectAttributesInput *s3.GetObjectAttributesInput)) *S3API_GetObjectAttributes_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectAttributesInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectAttributesInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectAttributes_Call) Return(getObjectAttributesOutput *s3.GetObjectAttributesOutput, err error) *S3API_GetObjectAttributes_Call { + _c.Call.Return(getObjectAttributesOutput, err) + return _c +} + +func (_c *S3API_GetObjectAttributes_Call) RunAndReturn(run func(getObjectAttributesInput *s3.GetObjectAttributesInput) (*s3.GetObjectAttributesOutput, error)) *S3API_GetObjectAttributes_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectAttributesRequest provides a mock function for the type S3API +func (_mock *S3API) GetObjectAttributesRequest(getObjectAttributesInput *s3.GetObjectAttributesInput) (*request.Request, *s3.GetObjectAttributesOutput) { + ret := _mock.Called(getObjectAttributesInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectAttributesRequest") + } var r0 *request.Request var r1 *s3.GetObjectAttributesOutput - if rf, ok := ret.Get(0).(func(*s3.GetObjectAttributesInput) (*request.Request, *s3.GetObjectAttributesOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectAttributesInput) (*request.Request, *s3.GetObjectAttributesOutput)); ok { + return returnFunc(getObjectAttributesInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectAttributesInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectAttributesInput) *request.Request); ok { + r0 = returnFunc(getObjectAttributesInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectAttributesInput) *s3.GetObjectAttributesOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectAttributesInput) *s3.GetObjectAttributesOutput); ok { + r1 = returnFunc(getObjectAttributesInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetObjectAttributesOutput) } } - return r0, r1 } -// GetObjectAttributesWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetObjectAttributesWithContext(_a0 context.Context, _a1 *s3.GetObjectAttributesInput, _a2 ...request.Option) (*s3.GetObjectAttributesOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetObjectAttributesRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectAttributesRequest' +type S3API_GetObjectAttributesRequest_Call struct { + *mock.Call +} + +// GetObjectAttributesRequest is a helper method to define mock.On call +// - getObjectAttributesInput *s3.GetObjectAttributesInput +func (_e *S3API_Expecter) GetObjectAttributesRequest(getObjectAttributesInput interface{}) *S3API_GetObjectAttributesRequest_Call { + return &S3API_GetObjectAttributesRequest_Call{Call: _e.mock.On("GetObjectAttributesRequest", getObjectAttributesInput)} +} + +func (_c *S3API_GetObjectAttributesRequest_Call) Run(run func(getObjectAttributesInput *s3.GetObjectAttributesInput)) *S3API_GetObjectAttributesRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectAttributesInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectAttributesInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectAttributesRequest_Call) Return(request1 *request.Request, getObjectAttributesOutput *s3.GetObjectAttributesOutput) *S3API_GetObjectAttributesRequest_Call { + _c.Call.Return(request1, getObjectAttributesOutput) + return _c +} + +func (_c *S3API_GetObjectAttributesRequest_Call) RunAndReturn(run func(getObjectAttributesInput *s3.GetObjectAttributesInput) (*request.Request, *s3.GetObjectAttributesOutput)) *S3API_GetObjectAttributesRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectAttributesWithContext provides a mock function for the type S3API +func (_mock *S3API) GetObjectAttributesWithContext(v aws.Context, getObjectAttributesInput *s3.GetObjectAttributesInput, options ...request.Option) (*s3.GetObjectAttributesOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getObjectAttributesInput, options) + } else { + tmpRet = _mock.Called(v, getObjectAttributesInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetObjectAttributesWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetObjectAttributesOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectAttributesInput, ...request.Option) (*s3.GetObjectAttributesOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectAttributesInput, ...request.Option) (*s3.GetObjectAttributesOutput, error)); ok { + return returnFunc(v, getObjectAttributesInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectAttributesInput, ...request.Option) *s3.GetObjectAttributesOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectAttributesInput, ...request.Option) *s3.GetObjectAttributesOutput); ok { + r0 = returnFunc(v, getObjectAttributesInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectAttributesOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetObjectAttributesInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectAttributesInput, ...request.Option) error); ok { + r1 = returnFunc(v, getObjectAttributesInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectLegalHold provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectLegalHold(_a0 *s3.GetObjectLegalHoldInput) (*s3.GetObjectLegalHoldOutput, error) { - ret := _m.Called(_a0) +// S3API_GetObjectAttributesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectAttributesWithContext' +type S3API_GetObjectAttributesWithContext_Call struct { + *mock.Call +} + +// GetObjectAttributesWithContext is a helper method to define mock.On call +// - v aws.Context +// - getObjectAttributesInput *s3.GetObjectAttributesInput +// - options ...request.Option +func (_e *S3API_Expecter) GetObjectAttributesWithContext(v interface{}, getObjectAttributesInput interface{}, options ...interface{}) *S3API_GetObjectAttributesWithContext_Call { + return &S3API_GetObjectAttributesWithContext_Call{Call: _e.mock.On("GetObjectAttributesWithContext", + append([]interface{}{v, getObjectAttributesInput}, options...)...)} +} + +func (_c *S3API_GetObjectAttributesWithContext_Call) Run(run func(v aws.Context, getObjectAttributesInput *s3.GetObjectAttributesInput, options ...request.Option)) *S3API_GetObjectAttributesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetObjectAttributesInput + if args[1] != nil { + arg1 = args[1].(*s3.GetObjectAttributesInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetObjectAttributesWithContext_Call) Return(getObjectAttributesOutput *s3.GetObjectAttributesOutput, err error) *S3API_GetObjectAttributesWithContext_Call { + _c.Call.Return(getObjectAttributesOutput, err) + return _c +} + +func (_c *S3API_GetObjectAttributesWithContext_Call) RunAndReturn(run func(v aws.Context, getObjectAttributesInput *s3.GetObjectAttributesInput, options ...request.Option) (*s3.GetObjectAttributesOutput, error)) *S3API_GetObjectAttributesWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectLegalHold provides a mock function for the type S3API +func (_mock *S3API) GetObjectLegalHold(getObjectLegalHoldInput *s3.GetObjectLegalHoldInput) (*s3.GetObjectLegalHoldOutput, error) { + ret := _mock.Called(getObjectLegalHoldInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectLegalHold") + } var r0 *s3.GetObjectLegalHoldOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetObjectLegalHoldInput) (*s3.GetObjectLegalHoldOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectLegalHoldInput) (*s3.GetObjectLegalHoldOutput, error)); ok { + return returnFunc(getObjectLegalHoldInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectLegalHoldInput) *s3.GetObjectLegalHoldOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectLegalHoldInput) *s3.GetObjectLegalHoldOutput); ok { + r0 = returnFunc(getObjectLegalHoldInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectLegalHoldOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectLegalHoldInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectLegalHoldInput) error); ok { + r1 = returnFunc(getObjectLegalHoldInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectLegalHoldRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectLegalHoldRequest(_a0 *s3.GetObjectLegalHoldInput) (*request.Request, *s3.GetObjectLegalHoldOutput) { - ret := _m.Called(_a0) +// S3API_GetObjectLegalHold_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectLegalHold' +type S3API_GetObjectLegalHold_Call struct { + *mock.Call +} + +// GetObjectLegalHold is a helper method to define mock.On call +// - getObjectLegalHoldInput *s3.GetObjectLegalHoldInput +func (_e *S3API_Expecter) GetObjectLegalHold(getObjectLegalHoldInput interface{}) *S3API_GetObjectLegalHold_Call { + return &S3API_GetObjectLegalHold_Call{Call: _e.mock.On("GetObjectLegalHold", getObjectLegalHoldInput)} +} + +func (_c *S3API_GetObjectLegalHold_Call) Run(run func(getObjectLegalHoldInput *s3.GetObjectLegalHoldInput)) *S3API_GetObjectLegalHold_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectLegalHoldInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectLegalHoldInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectLegalHold_Call) Return(getObjectLegalHoldOutput *s3.GetObjectLegalHoldOutput, err error) *S3API_GetObjectLegalHold_Call { + _c.Call.Return(getObjectLegalHoldOutput, err) + return _c +} + +func (_c *S3API_GetObjectLegalHold_Call) RunAndReturn(run func(getObjectLegalHoldInput *s3.GetObjectLegalHoldInput) (*s3.GetObjectLegalHoldOutput, error)) *S3API_GetObjectLegalHold_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectLegalHoldRequest provides a mock function for the type S3API +func (_mock *S3API) GetObjectLegalHoldRequest(getObjectLegalHoldInput *s3.GetObjectLegalHoldInput) (*request.Request, *s3.GetObjectLegalHoldOutput) { + ret := _mock.Called(getObjectLegalHoldInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectLegalHoldRequest") + } var r0 *request.Request var r1 *s3.GetObjectLegalHoldOutput - if rf, ok := ret.Get(0).(func(*s3.GetObjectLegalHoldInput) (*request.Request, *s3.GetObjectLegalHoldOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectLegalHoldInput) (*request.Request, *s3.GetObjectLegalHoldOutput)); ok { + return returnFunc(getObjectLegalHoldInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectLegalHoldInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectLegalHoldInput) *request.Request); ok { + r0 = returnFunc(getObjectLegalHoldInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectLegalHoldInput) *s3.GetObjectLegalHoldOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectLegalHoldInput) *s3.GetObjectLegalHoldOutput); ok { + r1 = returnFunc(getObjectLegalHoldInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetObjectLegalHoldOutput) } } - return r0, r1 } -// GetObjectLegalHoldWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetObjectLegalHoldWithContext(_a0 context.Context, _a1 *s3.GetObjectLegalHoldInput, _a2 ...request.Option) (*s3.GetObjectLegalHoldOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetObjectLegalHoldRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectLegalHoldRequest' +type S3API_GetObjectLegalHoldRequest_Call struct { + *mock.Call +} + +// GetObjectLegalHoldRequest is a helper method to define mock.On call +// - getObjectLegalHoldInput *s3.GetObjectLegalHoldInput +func (_e *S3API_Expecter) GetObjectLegalHoldRequest(getObjectLegalHoldInput interface{}) *S3API_GetObjectLegalHoldRequest_Call { + return &S3API_GetObjectLegalHoldRequest_Call{Call: _e.mock.On("GetObjectLegalHoldRequest", getObjectLegalHoldInput)} +} + +func (_c *S3API_GetObjectLegalHoldRequest_Call) Run(run func(getObjectLegalHoldInput *s3.GetObjectLegalHoldInput)) *S3API_GetObjectLegalHoldRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectLegalHoldInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectLegalHoldInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectLegalHoldRequest_Call) Return(request1 *request.Request, getObjectLegalHoldOutput *s3.GetObjectLegalHoldOutput) *S3API_GetObjectLegalHoldRequest_Call { + _c.Call.Return(request1, getObjectLegalHoldOutput) + return _c +} + +func (_c *S3API_GetObjectLegalHoldRequest_Call) RunAndReturn(run func(getObjectLegalHoldInput *s3.GetObjectLegalHoldInput) (*request.Request, *s3.GetObjectLegalHoldOutput)) *S3API_GetObjectLegalHoldRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectLegalHoldWithContext provides a mock function for the type S3API +func (_mock *S3API) GetObjectLegalHoldWithContext(v aws.Context, getObjectLegalHoldInput *s3.GetObjectLegalHoldInput, options ...request.Option) (*s3.GetObjectLegalHoldOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getObjectLegalHoldInput, options) + } else { + tmpRet = _mock.Called(v, getObjectLegalHoldInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetObjectLegalHoldWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetObjectLegalHoldOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectLegalHoldInput, ...request.Option) (*s3.GetObjectLegalHoldOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectLegalHoldInput, ...request.Option) (*s3.GetObjectLegalHoldOutput, error)); ok { + return returnFunc(v, getObjectLegalHoldInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectLegalHoldInput, ...request.Option) *s3.GetObjectLegalHoldOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectLegalHoldInput, ...request.Option) *s3.GetObjectLegalHoldOutput); ok { + r0 = returnFunc(v, getObjectLegalHoldInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectLegalHoldOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetObjectLegalHoldInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectLegalHoldInput, ...request.Option) error); ok { + r1 = returnFunc(v, getObjectLegalHoldInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectLockConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectLockConfiguration(_a0 *s3.GetObjectLockConfigurationInput) (*s3.GetObjectLockConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_GetObjectLegalHoldWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectLegalHoldWithContext' +type S3API_GetObjectLegalHoldWithContext_Call struct { + *mock.Call +} + +// GetObjectLegalHoldWithContext is a helper method to define mock.On call +// - v aws.Context +// - getObjectLegalHoldInput *s3.GetObjectLegalHoldInput +// - options ...request.Option +func (_e *S3API_Expecter) GetObjectLegalHoldWithContext(v interface{}, getObjectLegalHoldInput interface{}, options ...interface{}) *S3API_GetObjectLegalHoldWithContext_Call { + return &S3API_GetObjectLegalHoldWithContext_Call{Call: _e.mock.On("GetObjectLegalHoldWithContext", + append([]interface{}{v, getObjectLegalHoldInput}, options...)...)} +} + +func (_c *S3API_GetObjectLegalHoldWithContext_Call) Run(run func(v aws.Context, getObjectLegalHoldInput *s3.GetObjectLegalHoldInput, options ...request.Option)) *S3API_GetObjectLegalHoldWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetObjectLegalHoldInput + if args[1] != nil { + arg1 = args[1].(*s3.GetObjectLegalHoldInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetObjectLegalHoldWithContext_Call) Return(getObjectLegalHoldOutput *s3.GetObjectLegalHoldOutput, err error) *S3API_GetObjectLegalHoldWithContext_Call { + _c.Call.Return(getObjectLegalHoldOutput, err) + return _c +} + +func (_c *S3API_GetObjectLegalHoldWithContext_Call) RunAndReturn(run func(v aws.Context, getObjectLegalHoldInput *s3.GetObjectLegalHoldInput, options ...request.Option) (*s3.GetObjectLegalHoldOutput, error)) *S3API_GetObjectLegalHoldWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectLockConfiguration provides a mock function for the type S3API +func (_mock *S3API) GetObjectLockConfiguration(getObjectLockConfigurationInput *s3.GetObjectLockConfigurationInput) (*s3.GetObjectLockConfigurationOutput, error) { + ret := _mock.Called(getObjectLockConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectLockConfiguration") + } var r0 *s3.GetObjectLockConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetObjectLockConfigurationInput) (*s3.GetObjectLockConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectLockConfigurationInput) (*s3.GetObjectLockConfigurationOutput, error)); ok { + return returnFunc(getObjectLockConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectLockConfigurationInput) *s3.GetObjectLockConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectLockConfigurationInput) *s3.GetObjectLockConfigurationOutput); ok { + r0 = returnFunc(getObjectLockConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectLockConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectLockConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectLockConfigurationInput) error); ok { + r1 = returnFunc(getObjectLockConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectLockConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectLockConfigurationRequest(_a0 *s3.GetObjectLockConfigurationInput) (*request.Request, *s3.GetObjectLockConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_GetObjectLockConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectLockConfiguration' +type S3API_GetObjectLockConfiguration_Call struct { + *mock.Call +} + +// GetObjectLockConfiguration is a helper method to define mock.On call +// - getObjectLockConfigurationInput *s3.GetObjectLockConfigurationInput +func (_e *S3API_Expecter) GetObjectLockConfiguration(getObjectLockConfigurationInput interface{}) *S3API_GetObjectLockConfiguration_Call { + return &S3API_GetObjectLockConfiguration_Call{Call: _e.mock.On("GetObjectLockConfiguration", getObjectLockConfigurationInput)} +} + +func (_c *S3API_GetObjectLockConfiguration_Call) Run(run func(getObjectLockConfigurationInput *s3.GetObjectLockConfigurationInput)) *S3API_GetObjectLockConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectLockConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectLockConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectLockConfiguration_Call) Return(getObjectLockConfigurationOutput *s3.GetObjectLockConfigurationOutput, err error) *S3API_GetObjectLockConfiguration_Call { + _c.Call.Return(getObjectLockConfigurationOutput, err) + return _c +} + +func (_c *S3API_GetObjectLockConfiguration_Call) RunAndReturn(run func(getObjectLockConfigurationInput *s3.GetObjectLockConfigurationInput) (*s3.GetObjectLockConfigurationOutput, error)) *S3API_GetObjectLockConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectLockConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) GetObjectLockConfigurationRequest(getObjectLockConfigurationInput *s3.GetObjectLockConfigurationInput) (*request.Request, *s3.GetObjectLockConfigurationOutput) { + ret := _mock.Called(getObjectLockConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectLockConfigurationRequest") + } var r0 *request.Request var r1 *s3.GetObjectLockConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.GetObjectLockConfigurationInput) (*request.Request, *s3.GetObjectLockConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectLockConfigurationInput) (*request.Request, *s3.GetObjectLockConfigurationOutput)); ok { + return returnFunc(getObjectLockConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectLockConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectLockConfigurationInput) *request.Request); ok { + r0 = returnFunc(getObjectLockConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectLockConfigurationInput) *s3.GetObjectLockConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectLockConfigurationInput) *s3.GetObjectLockConfigurationOutput); ok { + r1 = returnFunc(getObjectLockConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetObjectLockConfigurationOutput) } } - return r0, r1 } -// GetObjectLockConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetObjectLockConfigurationWithContext(_a0 context.Context, _a1 *s3.GetObjectLockConfigurationInput, _a2 ...request.Option) (*s3.GetObjectLockConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetObjectLockConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectLockConfigurationRequest' +type S3API_GetObjectLockConfigurationRequest_Call struct { + *mock.Call +} + +// GetObjectLockConfigurationRequest is a helper method to define mock.On call +// - getObjectLockConfigurationInput *s3.GetObjectLockConfigurationInput +func (_e *S3API_Expecter) GetObjectLockConfigurationRequest(getObjectLockConfigurationInput interface{}) *S3API_GetObjectLockConfigurationRequest_Call { + return &S3API_GetObjectLockConfigurationRequest_Call{Call: _e.mock.On("GetObjectLockConfigurationRequest", getObjectLockConfigurationInput)} +} + +func (_c *S3API_GetObjectLockConfigurationRequest_Call) Run(run func(getObjectLockConfigurationInput *s3.GetObjectLockConfigurationInput)) *S3API_GetObjectLockConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectLockConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectLockConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectLockConfigurationRequest_Call) Return(request1 *request.Request, getObjectLockConfigurationOutput *s3.GetObjectLockConfigurationOutput) *S3API_GetObjectLockConfigurationRequest_Call { + _c.Call.Return(request1, getObjectLockConfigurationOutput) + return _c +} + +func (_c *S3API_GetObjectLockConfigurationRequest_Call) RunAndReturn(run func(getObjectLockConfigurationInput *s3.GetObjectLockConfigurationInput) (*request.Request, *s3.GetObjectLockConfigurationOutput)) *S3API_GetObjectLockConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectLockConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) GetObjectLockConfigurationWithContext(v aws.Context, getObjectLockConfigurationInput *s3.GetObjectLockConfigurationInput, options ...request.Option) (*s3.GetObjectLockConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getObjectLockConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, getObjectLockConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetObjectLockConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetObjectLockConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectLockConfigurationInput, ...request.Option) (*s3.GetObjectLockConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectLockConfigurationInput, ...request.Option) (*s3.GetObjectLockConfigurationOutput, error)); ok { + return returnFunc(v, getObjectLockConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectLockConfigurationInput, ...request.Option) *s3.GetObjectLockConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectLockConfigurationInput, ...request.Option) *s3.GetObjectLockConfigurationOutput); ok { + r0 = returnFunc(v, getObjectLockConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectLockConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetObjectLockConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectLockConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, getObjectLockConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectRequest(_a0 *s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput) { - ret := _m.Called(_a0) +// S3API_GetObjectLockConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectLockConfigurationWithContext' +type S3API_GetObjectLockConfigurationWithContext_Call struct { + *mock.Call +} + +// GetObjectLockConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - getObjectLockConfigurationInput *s3.GetObjectLockConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) GetObjectLockConfigurationWithContext(v interface{}, getObjectLockConfigurationInput interface{}, options ...interface{}) *S3API_GetObjectLockConfigurationWithContext_Call { + return &S3API_GetObjectLockConfigurationWithContext_Call{Call: _e.mock.On("GetObjectLockConfigurationWithContext", + append([]interface{}{v, getObjectLockConfigurationInput}, options...)...)} +} + +func (_c *S3API_GetObjectLockConfigurationWithContext_Call) Run(run func(v aws.Context, getObjectLockConfigurationInput *s3.GetObjectLockConfigurationInput, options ...request.Option)) *S3API_GetObjectLockConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetObjectLockConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.GetObjectLockConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetObjectLockConfigurationWithContext_Call) Return(getObjectLockConfigurationOutput *s3.GetObjectLockConfigurationOutput, err error) *S3API_GetObjectLockConfigurationWithContext_Call { + _c.Call.Return(getObjectLockConfigurationOutput, err) + return _c +} + +func (_c *S3API_GetObjectLockConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, getObjectLockConfigurationInput *s3.GetObjectLockConfigurationInput, options ...request.Option) (*s3.GetObjectLockConfigurationOutput, error)) *S3API_GetObjectLockConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectRequest provides a mock function for the type S3API +func (_mock *S3API) GetObjectRequest(getObjectInput *s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput) { + ret := _mock.Called(getObjectInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectRequest") + } var r0 *request.Request var r1 *s3.GetObjectOutput - if rf, ok := ret.Get(0).(func(*s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput)); ok { + return returnFunc(getObjectInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectInput) *request.Request); ok { + r0 = returnFunc(getObjectInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectInput) *s3.GetObjectOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectInput) *s3.GetObjectOutput); ok { + r1 = returnFunc(getObjectInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetObjectOutput) } } - return r0, r1 } -// GetObjectRetention provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectRetention(_a0 *s3.GetObjectRetentionInput) (*s3.GetObjectRetentionOutput, error) { - ret := _m.Called(_a0) +// S3API_GetObjectRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectRequest' +type S3API_GetObjectRequest_Call struct { + *mock.Call +} + +// GetObjectRequest is a helper method to define mock.On call +// - getObjectInput *s3.GetObjectInput +func (_e *S3API_Expecter) GetObjectRequest(getObjectInput interface{}) *S3API_GetObjectRequest_Call { + return &S3API_GetObjectRequest_Call{Call: _e.mock.On("GetObjectRequest", getObjectInput)} +} + +func (_c *S3API_GetObjectRequest_Call) Run(run func(getObjectInput *s3.GetObjectInput)) *S3API_GetObjectRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectRequest_Call) Return(request1 *request.Request, getObjectOutput *s3.GetObjectOutput) *S3API_GetObjectRequest_Call { + _c.Call.Return(request1, getObjectOutput) + return _c +} + +func (_c *S3API_GetObjectRequest_Call) RunAndReturn(run func(getObjectInput *s3.GetObjectInput) (*request.Request, *s3.GetObjectOutput)) *S3API_GetObjectRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectRetention provides a mock function for the type S3API +func (_mock *S3API) GetObjectRetention(getObjectRetentionInput *s3.GetObjectRetentionInput) (*s3.GetObjectRetentionOutput, error) { + ret := _mock.Called(getObjectRetentionInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectRetention") + } var r0 *s3.GetObjectRetentionOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetObjectRetentionInput) (*s3.GetObjectRetentionOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectRetentionInput) (*s3.GetObjectRetentionOutput, error)); ok { + return returnFunc(getObjectRetentionInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectRetentionInput) *s3.GetObjectRetentionOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectRetentionInput) *s3.GetObjectRetentionOutput); ok { + r0 = returnFunc(getObjectRetentionInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectRetentionOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectRetentionInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectRetentionInput) error); ok { + r1 = returnFunc(getObjectRetentionInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectRetentionRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectRetentionRequest(_a0 *s3.GetObjectRetentionInput) (*request.Request, *s3.GetObjectRetentionOutput) { - ret := _m.Called(_a0) +// S3API_GetObjectRetention_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectRetention' +type S3API_GetObjectRetention_Call struct { + *mock.Call +} + +// GetObjectRetention is a helper method to define mock.On call +// - getObjectRetentionInput *s3.GetObjectRetentionInput +func (_e *S3API_Expecter) GetObjectRetention(getObjectRetentionInput interface{}) *S3API_GetObjectRetention_Call { + return &S3API_GetObjectRetention_Call{Call: _e.mock.On("GetObjectRetention", getObjectRetentionInput)} +} + +func (_c *S3API_GetObjectRetention_Call) Run(run func(getObjectRetentionInput *s3.GetObjectRetentionInput)) *S3API_GetObjectRetention_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectRetentionInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectRetentionInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectRetention_Call) Return(getObjectRetentionOutput *s3.GetObjectRetentionOutput, err error) *S3API_GetObjectRetention_Call { + _c.Call.Return(getObjectRetentionOutput, err) + return _c +} + +func (_c *S3API_GetObjectRetention_Call) RunAndReturn(run func(getObjectRetentionInput *s3.GetObjectRetentionInput) (*s3.GetObjectRetentionOutput, error)) *S3API_GetObjectRetention_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectRetentionRequest provides a mock function for the type S3API +func (_mock *S3API) GetObjectRetentionRequest(getObjectRetentionInput *s3.GetObjectRetentionInput) (*request.Request, *s3.GetObjectRetentionOutput) { + ret := _mock.Called(getObjectRetentionInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectRetentionRequest") + } var r0 *request.Request var r1 *s3.GetObjectRetentionOutput - if rf, ok := ret.Get(0).(func(*s3.GetObjectRetentionInput) (*request.Request, *s3.GetObjectRetentionOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectRetentionInput) (*request.Request, *s3.GetObjectRetentionOutput)); ok { + return returnFunc(getObjectRetentionInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectRetentionInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectRetentionInput) *request.Request); ok { + r0 = returnFunc(getObjectRetentionInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectRetentionInput) *s3.GetObjectRetentionOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectRetentionInput) *s3.GetObjectRetentionOutput); ok { + r1 = returnFunc(getObjectRetentionInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetObjectRetentionOutput) } } - return r0, r1 } -// GetObjectRetentionWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetObjectRetentionWithContext(_a0 context.Context, _a1 *s3.GetObjectRetentionInput, _a2 ...request.Option) (*s3.GetObjectRetentionOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetObjectRetentionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectRetentionRequest' +type S3API_GetObjectRetentionRequest_Call struct { + *mock.Call +} + +// GetObjectRetentionRequest is a helper method to define mock.On call +// - getObjectRetentionInput *s3.GetObjectRetentionInput +func (_e *S3API_Expecter) GetObjectRetentionRequest(getObjectRetentionInput interface{}) *S3API_GetObjectRetentionRequest_Call { + return &S3API_GetObjectRetentionRequest_Call{Call: _e.mock.On("GetObjectRetentionRequest", getObjectRetentionInput)} +} + +func (_c *S3API_GetObjectRetentionRequest_Call) Run(run func(getObjectRetentionInput *s3.GetObjectRetentionInput)) *S3API_GetObjectRetentionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectRetentionInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectRetentionInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectRetentionRequest_Call) Return(request1 *request.Request, getObjectRetentionOutput *s3.GetObjectRetentionOutput) *S3API_GetObjectRetentionRequest_Call { + _c.Call.Return(request1, getObjectRetentionOutput) + return _c +} + +func (_c *S3API_GetObjectRetentionRequest_Call) RunAndReturn(run func(getObjectRetentionInput *s3.GetObjectRetentionInput) (*request.Request, *s3.GetObjectRetentionOutput)) *S3API_GetObjectRetentionRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectRetentionWithContext provides a mock function for the type S3API +func (_mock *S3API) GetObjectRetentionWithContext(v aws.Context, getObjectRetentionInput *s3.GetObjectRetentionInput, options ...request.Option) (*s3.GetObjectRetentionOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getObjectRetentionInput, options) + } else { + tmpRet = _mock.Called(v, getObjectRetentionInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetObjectRetentionWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetObjectRetentionOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectRetentionInput, ...request.Option) (*s3.GetObjectRetentionOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectRetentionInput, ...request.Option) (*s3.GetObjectRetentionOutput, error)); ok { + return returnFunc(v, getObjectRetentionInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectRetentionInput, ...request.Option) *s3.GetObjectRetentionOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectRetentionInput, ...request.Option) *s3.GetObjectRetentionOutput); ok { + r0 = returnFunc(v, getObjectRetentionInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectRetentionOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetObjectRetentionInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectRetentionInput, ...request.Option) error); ok { + r1 = returnFunc(v, getObjectRetentionInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectTagging provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectTagging(_a0 *s3.GetObjectTaggingInput) (*s3.GetObjectTaggingOutput, error) { - ret := _m.Called(_a0) +// S3API_GetObjectRetentionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectRetentionWithContext' +type S3API_GetObjectRetentionWithContext_Call struct { + *mock.Call +} + +// GetObjectRetentionWithContext is a helper method to define mock.On call +// - v aws.Context +// - getObjectRetentionInput *s3.GetObjectRetentionInput +// - options ...request.Option +func (_e *S3API_Expecter) GetObjectRetentionWithContext(v interface{}, getObjectRetentionInput interface{}, options ...interface{}) *S3API_GetObjectRetentionWithContext_Call { + return &S3API_GetObjectRetentionWithContext_Call{Call: _e.mock.On("GetObjectRetentionWithContext", + append([]interface{}{v, getObjectRetentionInput}, options...)...)} +} + +func (_c *S3API_GetObjectRetentionWithContext_Call) Run(run func(v aws.Context, getObjectRetentionInput *s3.GetObjectRetentionInput, options ...request.Option)) *S3API_GetObjectRetentionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetObjectRetentionInput + if args[1] != nil { + arg1 = args[1].(*s3.GetObjectRetentionInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetObjectRetentionWithContext_Call) Return(getObjectRetentionOutput *s3.GetObjectRetentionOutput, err error) *S3API_GetObjectRetentionWithContext_Call { + _c.Call.Return(getObjectRetentionOutput, err) + return _c +} + +func (_c *S3API_GetObjectRetentionWithContext_Call) RunAndReturn(run func(v aws.Context, getObjectRetentionInput *s3.GetObjectRetentionInput, options ...request.Option) (*s3.GetObjectRetentionOutput, error)) *S3API_GetObjectRetentionWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectTagging provides a mock function for the type S3API +func (_mock *S3API) GetObjectTagging(getObjectTaggingInput *s3.GetObjectTaggingInput) (*s3.GetObjectTaggingOutput, error) { + ret := _mock.Called(getObjectTaggingInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectTagging") + } var r0 *s3.GetObjectTaggingOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetObjectTaggingInput) (*s3.GetObjectTaggingOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectTaggingInput) (*s3.GetObjectTaggingOutput, error)); ok { + return returnFunc(getObjectTaggingInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectTaggingInput) *s3.GetObjectTaggingOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectTaggingInput) *s3.GetObjectTaggingOutput); ok { + r0 = returnFunc(getObjectTaggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectTaggingOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectTaggingInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectTaggingInput) error); ok { + r1 = returnFunc(getObjectTaggingInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectTaggingRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectTaggingRequest(_a0 *s3.GetObjectTaggingInput) (*request.Request, *s3.GetObjectTaggingOutput) { - ret := _m.Called(_a0) +// S3API_GetObjectTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectTagging' +type S3API_GetObjectTagging_Call struct { + *mock.Call +} + +// GetObjectTagging is a helper method to define mock.On call +// - getObjectTaggingInput *s3.GetObjectTaggingInput +func (_e *S3API_Expecter) GetObjectTagging(getObjectTaggingInput interface{}) *S3API_GetObjectTagging_Call { + return &S3API_GetObjectTagging_Call{Call: _e.mock.On("GetObjectTagging", getObjectTaggingInput)} +} + +func (_c *S3API_GetObjectTagging_Call) Run(run func(getObjectTaggingInput *s3.GetObjectTaggingInput)) *S3API_GetObjectTagging_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectTaggingInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectTaggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectTagging_Call) Return(getObjectTaggingOutput *s3.GetObjectTaggingOutput, err error) *S3API_GetObjectTagging_Call { + _c.Call.Return(getObjectTaggingOutput, err) + return _c +} + +func (_c *S3API_GetObjectTagging_Call) RunAndReturn(run func(getObjectTaggingInput *s3.GetObjectTaggingInput) (*s3.GetObjectTaggingOutput, error)) *S3API_GetObjectTagging_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectTaggingRequest provides a mock function for the type S3API +func (_mock *S3API) GetObjectTaggingRequest(getObjectTaggingInput *s3.GetObjectTaggingInput) (*request.Request, *s3.GetObjectTaggingOutput) { + ret := _mock.Called(getObjectTaggingInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectTaggingRequest") + } var r0 *request.Request var r1 *s3.GetObjectTaggingOutput - if rf, ok := ret.Get(0).(func(*s3.GetObjectTaggingInput) (*request.Request, *s3.GetObjectTaggingOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectTaggingInput) (*request.Request, *s3.GetObjectTaggingOutput)); ok { + return returnFunc(getObjectTaggingInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectTaggingInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectTaggingInput) *request.Request); ok { + r0 = returnFunc(getObjectTaggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectTaggingInput) *s3.GetObjectTaggingOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectTaggingInput) *s3.GetObjectTaggingOutput); ok { + r1 = returnFunc(getObjectTaggingInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetObjectTaggingOutput) } } - return r0, r1 } -// GetObjectTaggingWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetObjectTaggingWithContext(_a0 context.Context, _a1 *s3.GetObjectTaggingInput, _a2 ...request.Option) (*s3.GetObjectTaggingOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetObjectTaggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectTaggingRequest' +type S3API_GetObjectTaggingRequest_Call struct { + *mock.Call +} + +// GetObjectTaggingRequest is a helper method to define mock.On call +// - getObjectTaggingInput *s3.GetObjectTaggingInput +func (_e *S3API_Expecter) GetObjectTaggingRequest(getObjectTaggingInput interface{}) *S3API_GetObjectTaggingRequest_Call { + return &S3API_GetObjectTaggingRequest_Call{Call: _e.mock.On("GetObjectTaggingRequest", getObjectTaggingInput)} +} + +func (_c *S3API_GetObjectTaggingRequest_Call) Run(run func(getObjectTaggingInput *s3.GetObjectTaggingInput)) *S3API_GetObjectTaggingRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectTaggingInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectTaggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectTaggingRequest_Call) Return(request1 *request.Request, getObjectTaggingOutput *s3.GetObjectTaggingOutput) *S3API_GetObjectTaggingRequest_Call { + _c.Call.Return(request1, getObjectTaggingOutput) + return _c +} + +func (_c *S3API_GetObjectTaggingRequest_Call) RunAndReturn(run func(getObjectTaggingInput *s3.GetObjectTaggingInput) (*request.Request, *s3.GetObjectTaggingOutput)) *S3API_GetObjectTaggingRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectTaggingWithContext provides a mock function for the type S3API +func (_mock *S3API) GetObjectTaggingWithContext(v aws.Context, getObjectTaggingInput *s3.GetObjectTaggingInput, options ...request.Option) (*s3.GetObjectTaggingOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getObjectTaggingInput, options) + } else { + tmpRet = _mock.Called(v, getObjectTaggingInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetObjectTaggingWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetObjectTaggingOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectTaggingInput, ...request.Option) (*s3.GetObjectTaggingOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectTaggingInput, ...request.Option) (*s3.GetObjectTaggingOutput, error)); ok { + return returnFunc(v, getObjectTaggingInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectTaggingInput, ...request.Option) *s3.GetObjectTaggingOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectTaggingInput, ...request.Option) *s3.GetObjectTaggingOutput); ok { + r0 = returnFunc(v, getObjectTaggingInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectTaggingOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetObjectTaggingInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectTaggingInput, ...request.Option) error); ok { + r1 = returnFunc(v, getObjectTaggingInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectTorrent provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectTorrent(_a0 *s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error) { - ret := _m.Called(_a0) +// S3API_GetObjectTaggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectTaggingWithContext' +type S3API_GetObjectTaggingWithContext_Call struct { + *mock.Call +} + +// GetObjectTaggingWithContext is a helper method to define mock.On call +// - v aws.Context +// - getObjectTaggingInput *s3.GetObjectTaggingInput +// - options ...request.Option +func (_e *S3API_Expecter) GetObjectTaggingWithContext(v interface{}, getObjectTaggingInput interface{}, options ...interface{}) *S3API_GetObjectTaggingWithContext_Call { + return &S3API_GetObjectTaggingWithContext_Call{Call: _e.mock.On("GetObjectTaggingWithContext", + append([]interface{}{v, getObjectTaggingInput}, options...)...)} +} + +func (_c *S3API_GetObjectTaggingWithContext_Call) Run(run func(v aws.Context, getObjectTaggingInput *s3.GetObjectTaggingInput, options ...request.Option)) *S3API_GetObjectTaggingWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetObjectTaggingInput + if args[1] != nil { + arg1 = args[1].(*s3.GetObjectTaggingInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetObjectTaggingWithContext_Call) Return(getObjectTaggingOutput *s3.GetObjectTaggingOutput, err error) *S3API_GetObjectTaggingWithContext_Call { + _c.Call.Return(getObjectTaggingOutput, err) + return _c +} + +func (_c *S3API_GetObjectTaggingWithContext_Call) RunAndReturn(run func(v aws.Context, getObjectTaggingInput *s3.GetObjectTaggingInput, options ...request.Option) (*s3.GetObjectTaggingOutput, error)) *S3API_GetObjectTaggingWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectTorrent provides a mock function for the type S3API +func (_mock *S3API) GetObjectTorrent(getObjectTorrentInput *s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error) { + ret := _mock.Called(getObjectTorrentInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectTorrent") + } var r0 *s3.GetObjectTorrentOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error)); ok { + return returnFunc(getObjectTorrentInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectTorrentInput) *s3.GetObjectTorrentOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectTorrentInput) *s3.GetObjectTorrentOutput); ok { + r0 = returnFunc(getObjectTorrentInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectTorrentOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectTorrentInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectTorrentInput) error); ok { + r1 = returnFunc(getObjectTorrentInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectTorrentRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetObjectTorrentRequest(_a0 *s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput) { - ret := _m.Called(_a0) +// S3API_GetObjectTorrent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectTorrent' +type S3API_GetObjectTorrent_Call struct { + *mock.Call +} + +// GetObjectTorrent is a helper method to define mock.On call +// - getObjectTorrentInput *s3.GetObjectTorrentInput +func (_e *S3API_Expecter) GetObjectTorrent(getObjectTorrentInput interface{}) *S3API_GetObjectTorrent_Call { + return &S3API_GetObjectTorrent_Call{Call: _e.mock.On("GetObjectTorrent", getObjectTorrentInput)} +} + +func (_c *S3API_GetObjectTorrent_Call) Run(run func(getObjectTorrentInput *s3.GetObjectTorrentInput)) *S3API_GetObjectTorrent_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectTorrentInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectTorrentInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectTorrent_Call) Return(getObjectTorrentOutput *s3.GetObjectTorrentOutput, err error) *S3API_GetObjectTorrent_Call { + _c.Call.Return(getObjectTorrentOutput, err) + return _c +} + +func (_c *S3API_GetObjectTorrent_Call) RunAndReturn(run func(getObjectTorrentInput *s3.GetObjectTorrentInput) (*s3.GetObjectTorrentOutput, error)) *S3API_GetObjectTorrent_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectTorrentRequest provides a mock function for the type S3API +func (_mock *S3API) GetObjectTorrentRequest(getObjectTorrentInput *s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput) { + ret := _mock.Called(getObjectTorrentInput) + + if len(ret) == 0 { + panic("no return value specified for GetObjectTorrentRequest") + } var r0 *request.Request var r1 *s3.GetObjectTorrentOutput - if rf, ok := ret.Get(0).(func(*s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput)); ok { + return returnFunc(getObjectTorrentInput) } - if rf, ok := ret.Get(0).(func(*s3.GetObjectTorrentInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetObjectTorrentInput) *request.Request); ok { + r0 = returnFunc(getObjectTorrentInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetObjectTorrentInput) *s3.GetObjectTorrentOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetObjectTorrentInput) *s3.GetObjectTorrentOutput); ok { + r1 = returnFunc(getObjectTorrentInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetObjectTorrentOutput) } } - return r0, r1 } -// GetObjectTorrentWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetObjectTorrentWithContext(_a0 context.Context, _a1 *s3.GetObjectTorrentInput, _a2 ...request.Option) (*s3.GetObjectTorrentOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetObjectTorrentRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectTorrentRequest' +type S3API_GetObjectTorrentRequest_Call struct { + *mock.Call +} + +// GetObjectTorrentRequest is a helper method to define mock.On call +// - getObjectTorrentInput *s3.GetObjectTorrentInput +func (_e *S3API_Expecter) GetObjectTorrentRequest(getObjectTorrentInput interface{}) *S3API_GetObjectTorrentRequest_Call { + return &S3API_GetObjectTorrentRequest_Call{Call: _e.mock.On("GetObjectTorrentRequest", getObjectTorrentInput)} +} + +func (_c *S3API_GetObjectTorrentRequest_Call) Run(run func(getObjectTorrentInput *s3.GetObjectTorrentInput)) *S3API_GetObjectTorrentRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetObjectTorrentInput + if args[0] != nil { + arg0 = args[0].(*s3.GetObjectTorrentInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetObjectTorrentRequest_Call) Return(request1 *request.Request, getObjectTorrentOutput *s3.GetObjectTorrentOutput) *S3API_GetObjectTorrentRequest_Call { + _c.Call.Return(request1, getObjectTorrentOutput) + return _c +} + +func (_c *S3API_GetObjectTorrentRequest_Call) RunAndReturn(run func(getObjectTorrentInput *s3.GetObjectTorrentInput) (*request.Request, *s3.GetObjectTorrentOutput)) *S3API_GetObjectTorrentRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectTorrentWithContext provides a mock function for the type S3API +func (_mock *S3API) GetObjectTorrentWithContext(v aws.Context, getObjectTorrentInput *s3.GetObjectTorrentInput, options ...request.Option) (*s3.GetObjectTorrentOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getObjectTorrentInput, options) + } else { + tmpRet = _mock.Called(v, getObjectTorrentInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetObjectTorrentWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetObjectTorrentOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectTorrentInput, ...request.Option) (*s3.GetObjectTorrentOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectTorrentInput, ...request.Option) (*s3.GetObjectTorrentOutput, error)); ok { + return returnFunc(v, getObjectTorrentInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectTorrentInput, ...request.Option) *s3.GetObjectTorrentOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectTorrentInput, ...request.Option) *s3.GetObjectTorrentOutput); ok { + r0 = returnFunc(v, getObjectTorrentInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectTorrentOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetObjectTorrentInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectTorrentInput, ...request.Option) error); ok { + r1 = returnFunc(v, getObjectTorrentInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetObjectWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetObjectWithContext(_a0 context.Context, _a1 *s3.GetObjectInput, _a2 ...request.Option) (*s3.GetObjectOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetObjectTorrentWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectTorrentWithContext' +type S3API_GetObjectTorrentWithContext_Call struct { + *mock.Call +} + +// GetObjectTorrentWithContext is a helper method to define mock.On call +// - v aws.Context +// - getObjectTorrentInput *s3.GetObjectTorrentInput +// - options ...request.Option +func (_e *S3API_Expecter) GetObjectTorrentWithContext(v interface{}, getObjectTorrentInput interface{}, options ...interface{}) *S3API_GetObjectTorrentWithContext_Call { + return &S3API_GetObjectTorrentWithContext_Call{Call: _e.mock.On("GetObjectTorrentWithContext", + append([]interface{}{v, getObjectTorrentInput}, options...)...)} +} + +func (_c *S3API_GetObjectTorrentWithContext_Call) Run(run func(v aws.Context, getObjectTorrentInput *s3.GetObjectTorrentInput, options ...request.Option)) *S3API_GetObjectTorrentWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetObjectTorrentInput + if args[1] != nil { + arg1 = args[1].(*s3.GetObjectTorrentInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetObjectTorrentWithContext_Call) Return(getObjectTorrentOutput *s3.GetObjectTorrentOutput, err error) *S3API_GetObjectTorrentWithContext_Call { + _c.Call.Return(getObjectTorrentOutput, err) + return _c +} + +func (_c *S3API_GetObjectTorrentWithContext_Call) RunAndReturn(run func(v aws.Context, getObjectTorrentInput *s3.GetObjectTorrentInput, options ...request.Option) (*s3.GetObjectTorrentOutput, error)) *S3API_GetObjectTorrentWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetObjectWithContext provides a mock function for the type S3API +func (_mock *S3API) GetObjectWithContext(v aws.Context, getObjectInput *s3.GetObjectInput, options ...request.Option) (*s3.GetObjectOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getObjectInput, options) + } else { + tmpRet = _mock.Called(v, getObjectInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetObjectWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetObjectOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectInput, ...request.Option) (*s3.GetObjectOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectInput, ...request.Option) (*s3.GetObjectOutput, error)); ok { + return returnFunc(v, getObjectInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetObjectInput, ...request.Option) *s3.GetObjectOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetObjectInput, ...request.Option) *s3.GetObjectOutput); ok { + r0 = returnFunc(v, getObjectInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetObjectOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetObjectInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetObjectInput, ...request.Option) error); ok { + r1 = returnFunc(v, getObjectInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetPublicAccessBlock provides a mock function with given fields: _a0 -func (_m *S3API) GetPublicAccessBlock(_a0 *s3.GetPublicAccessBlockInput) (*s3.GetPublicAccessBlockOutput, error) { - ret := _m.Called(_a0) +// S3API_GetObjectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetObjectWithContext' +type S3API_GetObjectWithContext_Call struct { + *mock.Call +} + +// GetObjectWithContext is a helper method to define mock.On call +// - v aws.Context +// - getObjectInput *s3.GetObjectInput +// - options ...request.Option +func (_e *S3API_Expecter) GetObjectWithContext(v interface{}, getObjectInput interface{}, options ...interface{}) *S3API_GetObjectWithContext_Call { + return &S3API_GetObjectWithContext_Call{Call: _e.mock.On("GetObjectWithContext", + append([]interface{}{v, getObjectInput}, options...)...)} +} + +func (_c *S3API_GetObjectWithContext_Call) Run(run func(v aws.Context, getObjectInput *s3.GetObjectInput, options ...request.Option)) *S3API_GetObjectWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetObjectInput + if args[1] != nil { + arg1 = args[1].(*s3.GetObjectInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetObjectWithContext_Call) Return(getObjectOutput *s3.GetObjectOutput, err error) *S3API_GetObjectWithContext_Call { + _c.Call.Return(getObjectOutput, err) + return _c +} + +func (_c *S3API_GetObjectWithContext_Call) RunAndReturn(run func(v aws.Context, getObjectInput *s3.GetObjectInput, options ...request.Option) (*s3.GetObjectOutput, error)) *S3API_GetObjectWithContext_Call { + _c.Call.Return(run) + return _c +} + +// GetPublicAccessBlock provides a mock function for the type S3API +func (_mock *S3API) GetPublicAccessBlock(getPublicAccessBlockInput *s3.GetPublicAccessBlockInput) (*s3.GetPublicAccessBlockOutput, error) { + ret := _mock.Called(getPublicAccessBlockInput) + + if len(ret) == 0 { + panic("no return value specified for GetPublicAccessBlock") + } var r0 *s3.GetPublicAccessBlockOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.GetPublicAccessBlockInput) (*s3.GetPublicAccessBlockOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetPublicAccessBlockInput) (*s3.GetPublicAccessBlockOutput, error)); ok { + return returnFunc(getPublicAccessBlockInput) } - if rf, ok := ret.Get(0).(func(*s3.GetPublicAccessBlockInput) *s3.GetPublicAccessBlockOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetPublicAccessBlockInput) *s3.GetPublicAccessBlockOutput); ok { + r0 = returnFunc(getPublicAccessBlockInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetPublicAccessBlockOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.GetPublicAccessBlockInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetPublicAccessBlockInput) error); ok { + r1 = returnFunc(getPublicAccessBlockInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetPublicAccessBlockRequest provides a mock function with given fields: _a0 -func (_m *S3API) GetPublicAccessBlockRequest(_a0 *s3.GetPublicAccessBlockInput) (*request.Request, *s3.GetPublicAccessBlockOutput) { - ret := _m.Called(_a0) +// S3API_GetPublicAccessBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPublicAccessBlock' +type S3API_GetPublicAccessBlock_Call struct { + *mock.Call +} + +// GetPublicAccessBlock is a helper method to define mock.On call +// - getPublicAccessBlockInput *s3.GetPublicAccessBlockInput +func (_e *S3API_Expecter) GetPublicAccessBlock(getPublicAccessBlockInput interface{}) *S3API_GetPublicAccessBlock_Call { + return &S3API_GetPublicAccessBlock_Call{Call: _e.mock.On("GetPublicAccessBlock", getPublicAccessBlockInput)} +} + +func (_c *S3API_GetPublicAccessBlock_Call) Run(run func(getPublicAccessBlockInput *s3.GetPublicAccessBlockInput)) *S3API_GetPublicAccessBlock_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetPublicAccessBlockInput + if args[0] != nil { + arg0 = args[0].(*s3.GetPublicAccessBlockInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetPublicAccessBlock_Call) Return(getPublicAccessBlockOutput *s3.GetPublicAccessBlockOutput, err error) *S3API_GetPublicAccessBlock_Call { + _c.Call.Return(getPublicAccessBlockOutput, err) + return _c +} + +func (_c *S3API_GetPublicAccessBlock_Call) RunAndReturn(run func(getPublicAccessBlockInput *s3.GetPublicAccessBlockInput) (*s3.GetPublicAccessBlockOutput, error)) *S3API_GetPublicAccessBlock_Call { + _c.Call.Return(run) + return _c +} + +// GetPublicAccessBlockRequest provides a mock function for the type S3API +func (_mock *S3API) GetPublicAccessBlockRequest(getPublicAccessBlockInput *s3.GetPublicAccessBlockInput) (*request.Request, *s3.GetPublicAccessBlockOutput) { + ret := _mock.Called(getPublicAccessBlockInput) + + if len(ret) == 0 { + panic("no return value specified for GetPublicAccessBlockRequest") + } var r0 *request.Request var r1 *s3.GetPublicAccessBlockOutput - if rf, ok := ret.Get(0).(func(*s3.GetPublicAccessBlockInput) (*request.Request, *s3.GetPublicAccessBlockOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetPublicAccessBlockInput) (*request.Request, *s3.GetPublicAccessBlockOutput)); ok { + return returnFunc(getPublicAccessBlockInput) } - if rf, ok := ret.Get(0).(func(*s3.GetPublicAccessBlockInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.GetPublicAccessBlockInput) *request.Request); ok { + r0 = returnFunc(getPublicAccessBlockInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.GetPublicAccessBlockInput) *s3.GetPublicAccessBlockOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.GetPublicAccessBlockInput) *s3.GetPublicAccessBlockOutput); ok { + r1 = returnFunc(getPublicAccessBlockInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.GetPublicAccessBlockOutput) } } - return r0, r1 } -// GetPublicAccessBlockWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) GetPublicAccessBlockWithContext(_a0 context.Context, _a1 *s3.GetPublicAccessBlockInput, _a2 ...request.Option) (*s3.GetPublicAccessBlockOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_GetPublicAccessBlockRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPublicAccessBlockRequest' +type S3API_GetPublicAccessBlockRequest_Call struct { + *mock.Call +} + +// GetPublicAccessBlockRequest is a helper method to define mock.On call +// - getPublicAccessBlockInput *s3.GetPublicAccessBlockInput +func (_e *S3API_Expecter) GetPublicAccessBlockRequest(getPublicAccessBlockInput interface{}) *S3API_GetPublicAccessBlockRequest_Call { + return &S3API_GetPublicAccessBlockRequest_Call{Call: _e.mock.On("GetPublicAccessBlockRequest", getPublicAccessBlockInput)} +} + +func (_c *S3API_GetPublicAccessBlockRequest_Call) Run(run func(getPublicAccessBlockInput *s3.GetPublicAccessBlockInput)) *S3API_GetPublicAccessBlockRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.GetPublicAccessBlockInput + if args[0] != nil { + arg0 = args[0].(*s3.GetPublicAccessBlockInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_GetPublicAccessBlockRequest_Call) Return(request1 *request.Request, getPublicAccessBlockOutput *s3.GetPublicAccessBlockOutput) *S3API_GetPublicAccessBlockRequest_Call { + _c.Call.Return(request1, getPublicAccessBlockOutput) + return _c +} + +func (_c *S3API_GetPublicAccessBlockRequest_Call) RunAndReturn(run func(getPublicAccessBlockInput *s3.GetPublicAccessBlockInput) (*request.Request, *s3.GetPublicAccessBlockOutput)) *S3API_GetPublicAccessBlockRequest_Call { + _c.Call.Return(run) + return _c +} + +// GetPublicAccessBlockWithContext provides a mock function for the type S3API +func (_mock *S3API) GetPublicAccessBlockWithContext(v aws.Context, getPublicAccessBlockInput *s3.GetPublicAccessBlockInput, options ...request.Option) (*s3.GetPublicAccessBlockOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, getPublicAccessBlockInput, options) + } else { + tmpRet = _mock.Called(v, getPublicAccessBlockInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for GetPublicAccessBlockWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.GetPublicAccessBlockOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetPublicAccessBlockInput, ...request.Option) (*s3.GetPublicAccessBlockOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetPublicAccessBlockInput, ...request.Option) (*s3.GetPublicAccessBlockOutput, error)); ok { + return returnFunc(v, getPublicAccessBlockInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.GetPublicAccessBlockInput, ...request.Option) *s3.GetPublicAccessBlockOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.GetPublicAccessBlockInput, ...request.Option) *s3.GetPublicAccessBlockOutput); ok { + r0 = returnFunc(v, getPublicAccessBlockInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.GetPublicAccessBlockOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.GetPublicAccessBlockInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.GetPublicAccessBlockInput, ...request.Option) error); ok { + r1 = returnFunc(v, getPublicAccessBlockInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// HeadBucket provides a mock function with given fields: _a0 -func (_m *S3API) HeadBucket(_a0 *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) { - ret := _m.Called(_a0) +// S3API_GetPublicAccessBlockWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPublicAccessBlockWithContext' +type S3API_GetPublicAccessBlockWithContext_Call struct { + *mock.Call +} + +// GetPublicAccessBlockWithContext is a helper method to define mock.On call +// - v aws.Context +// - getPublicAccessBlockInput *s3.GetPublicAccessBlockInput +// - options ...request.Option +func (_e *S3API_Expecter) GetPublicAccessBlockWithContext(v interface{}, getPublicAccessBlockInput interface{}, options ...interface{}) *S3API_GetPublicAccessBlockWithContext_Call { + return &S3API_GetPublicAccessBlockWithContext_Call{Call: _e.mock.On("GetPublicAccessBlockWithContext", + append([]interface{}{v, getPublicAccessBlockInput}, options...)...)} +} + +func (_c *S3API_GetPublicAccessBlockWithContext_Call) Run(run func(v aws.Context, getPublicAccessBlockInput *s3.GetPublicAccessBlockInput, options ...request.Option)) *S3API_GetPublicAccessBlockWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.GetPublicAccessBlockInput + if args[1] != nil { + arg1 = args[1].(*s3.GetPublicAccessBlockInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_GetPublicAccessBlockWithContext_Call) Return(getPublicAccessBlockOutput *s3.GetPublicAccessBlockOutput, err error) *S3API_GetPublicAccessBlockWithContext_Call { + _c.Call.Return(getPublicAccessBlockOutput, err) + return _c +} + +func (_c *S3API_GetPublicAccessBlockWithContext_Call) RunAndReturn(run func(v aws.Context, getPublicAccessBlockInput *s3.GetPublicAccessBlockInput, options ...request.Option) (*s3.GetPublicAccessBlockOutput, error)) *S3API_GetPublicAccessBlockWithContext_Call { + _c.Call.Return(run) + return _c +} + +// HeadBucket provides a mock function for the type S3API +func (_mock *S3API) HeadBucket(headBucketInput *s3.HeadBucketInput) (*s3.HeadBucketOutput, error) { + ret := _mock.Called(headBucketInput) + + if len(ret) == 0 { + panic("no return value specified for HeadBucket") + } var r0 *s3.HeadBucketOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.HeadBucketInput) (*s3.HeadBucketOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.HeadBucketInput) (*s3.HeadBucketOutput, error)); ok { + return returnFunc(headBucketInput) } - if rf, ok := ret.Get(0).(func(*s3.HeadBucketInput) *s3.HeadBucketOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.HeadBucketInput) *s3.HeadBucketOutput); ok { + r0 = returnFunc(headBucketInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.HeadBucketOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.HeadBucketInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.HeadBucketInput) error); ok { + r1 = returnFunc(headBucketInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// HeadBucketRequest provides a mock function with given fields: _a0 -func (_m *S3API) HeadBucketRequest(_a0 *s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput) { - ret := _m.Called(_a0) +// S3API_HeadBucket_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadBucket' +type S3API_HeadBucket_Call struct { + *mock.Call +} + +// HeadBucket is a helper method to define mock.On call +// - headBucketInput *s3.HeadBucketInput +func (_e *S3API_Expecter) HeadBucket(headBucketInput interface{}) *S3API_HeadBucket_Call { + return &S3API_HeadBucket_Call{Call: _e.mock.On("HeadBucket", headBucketInput)} +} + +func (_c *S3API_HeadBucket_Call) Run(run func(headBucketInput *s3.HeadBucketInput)) *S3API_HeadBucket_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.HeadBucketInput + if args[0] != nil { + arg0 = args[0].(*s3.HeadBucketInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_HeadBucket_Call) Return(headBucketOutput *s3.HeadBucketOutput, err error) *S3API_HeadBucket_Call { + _c.Call.Return(headBucketOutput, err) + return _c +} + +func (_c *S3API_HeadBucket_Call) RunAndReturn(run func(headBucketInput *s3.HeadBucketInput) (*s3.HeadBucketOutput, error)) *S3API_HeadBucket_Call { + _c.Call.Return(run) + return _c +} + +// HeadBucketRequest provides a mock function for the type S3API +func (_mock *S3API) HeadBucketRequest(headBucketInput *s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput) { + ret := _mock.Called(headBucketInput) + + if len(ret) == 0 { + panic("no return value specified for HeadBucketRequest") + } var r0 *request.Request var r1 *s3.HeadBucketOutput - if rf, ok := ret.Get(0).(func(*s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput)); ok { + return returnFunc(headBucketInput) } - if rf, ok := ret.Get(0).(func(*s3.HeadBucketInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.HeadBucketInput) *request.Request); ok { + r0 = returnFunc(headBucketInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.HeadBucketInput) *s3.HeadBucketOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.HeadBucketInput) *s3.HeadBucketOutput); ok { + r1 = returnFunc(headBucketInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.HeadBucketOutput) } } - return r0, r1 } -// HeadBucketWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) HeadBucketWithContext(_a0 context.Context, _a1 *s3.HeadBucketInput, _a2 ...request.Option) (*s3.HeadBucketOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_HeadBucketRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadBucketRequest' +type S3API_HeadBucketRequest_Call struct { + *mock.Call +} + +// HeadBucketRequest is a helper method to define mock.On call +// - headBucketInput *s3.HeadBucketInput +func (_e *S3API_Expecter) HeadBucketRequest(headBucketInput interface{}) *S3API_HeadBucketRequest_Call { + return &S3API_HeadBucketRequest_Call{Call: _e.mock.On("HeadBucketRequest", headBucketInput)} +} + +func (_c *S3API_HeadBucketRequest_Call) Run(run func(headBucketInput *s3.HeadBucketInput)) *S3API_HeadBucketRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.HeadBucketInput + if args[0] != nil { + arg0 = args[0].(*s3.HeadBucketInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_HeadBucketRequest_Call) Return(request1 *request.Request, headBucketOutput *s3.HeadBucketOutput) *S3API_HeadBucketRequest_Call { + _c.Call.Return(request1, headBucketOutput) + return _c +} + +func (_c *S3API_HeadBucketRequest_Call) RunAndReturn(run func(headBucketInput *s3.HeadBucketInput) (*request.Request, *s3.HeadBucketOutput)) *S3API_HeadBucketRequest_Call { + _c.Call.Return(run) + return _c +} + +// HeadBucketWithContext provides a mock function for the type S3API +func (_mock *S3API) HeadBucketWithContext(v aws.Context, headBucketInput *s3.HeadBucketInput, options ...request.Option) (*s3.HeadBucketOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, headBucketInput, options) + } else { + tmpRet = _mock.Called(v, headBucketInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for HeadBucketWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.HeadBucketOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadBucketInput, ...request.Option) (*s3.HeadBucketOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.HeadBucketInput, ...request.Option) (*s3.HeadBucketOutput, error)); ok { + return returnFunc(v, headBucketInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadBucketInput, ...request.Option) *s3.HeadBucketOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.HeadBucketInput, ...request.Option) *s3.HeadBucketOutput); ok { + r0 = returnFunc(v, headBucketInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.HeadBucketOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.HeadBucketInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.HeadBucketInput, ...request.Option) error); ok { + r1 = returnFunc(v, headBucketInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// HeadObject provides a mock function with given fields: _a0 -func (_m *S3API) HeadObject(_a0 *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) { - ret := _m.Called(_a0) +// S3API_HeadBucketWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadBucketWithContext' +type S3API_HeadBucketWithContext_Call struct { + *mock.Call +} + +// HeadBucketWithContext is a helper method to define mock.On call +// - v aws.Context +// - headBucketInput *s3.HeadBucketInput +// - options ...request.Option +func (_e *S3API_Expecter) HeadBucketWithContext(v interface{}, headBucketInput interface{}, options ...interface{}) *S3API_HeadBucketWithContext_Call { + return &S3API_HeadBucketWithContext_Call{Call: _e.mock.On("HeadBucketWithContext", + append([]interface{}{v, headBucketInput}, options...)...)} +} + +func (_c *S3API_HeadBucketWithContext_Call) Run(run func(v aws.Context, headBucketInput *s3.HeadBucketInput, options ...request.Option)) *S3API_HeadBucketWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.HeadBucketInput + if args[1] != nil { + arg1 = args[1].(*s3.HeadBucketInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_HeadBucketWithContext_Call) Return(headBucketOutput *s3.HeadBucketOutput, err error) *S3API_HeadBucketWithContext_Call { + _c.Call.Return(headBucketOutput, err) + return _c +} + +func (_c *S3API_HeadBucketWithContext_Call) RunAndReturn(run func(v aws.Context, headBucketInput *s3.HeadBucketInput, options ...request.Option) (*s3.HeadBucketOutput, error)) *S3API_HeadBucketWithContext_Call { + _c.Call.Return(run) + return _c +} + +// HeadObject provides a mock function for the type S3API +func (_mock *S3API) HeadObject(headObjectInput *s3.HeadObjectInput) (*s3.HeadObjectOutput, error) { + ret := _mock.Called(headObjectInput) + + if len(ret) == 0 { + panic("no return value specified for HeadObject") + } var r0 *s3.HeadObjectOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.HeadObjectInput) (*s3.HeadObjectOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.HeadObjectInput) (*s3.HeadObjectOutput, error)); ok { + return returnFunc(headObjectInput) } - if rf, ok := ret.Get(0).(func(*s3.HeadObjectInput) *s3.HeadObjectOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.HeadObjectInput) *s3.HeadObjectOutput); ok { + r0 = returnFunc(headObjectInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.HeadObjectOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.HeadObjectInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.HeadObjectInput) error); ok { + r1 = returnFunc(headObjectInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// HeadObjectRequest provides a mock function with given fields: _a0 -func (_m *S3API) HeadObjectRequest(_a0 *s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput) { - ret := _m.Called(_a0) +// S3API_HeadObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadObject' +type S3API_HeadObject_Call struct { + *mock.Call +} + +// HeadObject is a helper method to define mock.On call +// - headObjectInput *s3.HeadObjectInput +func (_e *S3API_Expecter) HeadObject(headObjectInput interface{}) *S3API_HeadObject_Call { + return &S3API_HeadObject_Call{Call: _e.mock.On("HeadObject", headObjectInput)} +} + +func (_c *S3API_HeadObject_Call) Run(run func(headObjectInput *s3.HeadObjectInput)) *S3API_HeadObject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.HeadObjectInput + if args[0] != nil { + arg0 = args[0].(*s3.HeadObjectInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_HeadObject_Call) Return(headObjectOutput *s3.HeadObjectOutput, err error) *S3API_HeadObject_Call { + _c.Call.Return(headObjectOutput, err) + return _c +} + +func (_c *S3API_HeadObject_Call) RunAndReturn(run func(headObjectInput *s3.HeadObjectInput) (*s3.HeadObjectOutput, error)) *S3API_HeadObject_Call { + _c.Call.Return(run) + return _c +} + +// HeadObjectRequest provides a mock function for the type S3API +func (_mock *S3API) HeadObjectRequest(headObjectInput *s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput) { + ret := _mock.Called(headObjectInput) + + if len(ret) == 0 { + panic("no return value specified for HeadObjectRequest") + } var r0 *request.Request var r1 *s3.HeadObjectOutput - if rf, ok := ret.Get(0).(func(*s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput)); ok { + return returnFunc(headObjectInput) } - if rf, ok := ret.Get(0).(func(*s3.HeadObjectInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.HeadObjectInput) *request.Request); ok { + r0 = returnFunc(headObjectInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.HeadObjectInput) *s3.HeadObjectOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.HeadObjectInput) *s3.HeadObjectOutput); ok { + r1 = returnFunc(headObjectInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.HeadObjectOutput) } } - return r0, r1 } -// HeadObjectWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) HeadObjectWithContext(_a0 context.Context, _a1 *s3.HeadObjectInput, _a2 ...request.Option) (*s3.HeadObjectOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_HeadObjectRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadObjectRequest' +type S3API_HeadObjectRequest_Call struct { + *mock.Call +} + +// HeadObjectRequest is a helper method to define mock.On call +// - headObjectInput *s3.HeadObjectInput +func (_e *S3API_Expecter) HeadObjectRequest(headObjectInput interface{}) *S3API_HeadObjectRequest_Call { + return &S3API_HeadObjectRequest_Call{Call: _e.mock.On("HeadObjectRequest", headObjectInput)} +} + +func (_c *S3API_HeadObjectRequest_Call) Run(run func(headObjectInput *s3.HeadObjectInput)) *S3API_HeadObjectRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.HeadObjectInput + if args[0] != nil { + arg0 = args[0].(*s3.HeadObjectInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_HeadObjectRequest_Call) Return(request1 *request.Request, headObjectOutput *s3.HeadObjectOutput) *S3API_HeadObjectRequest_Call { + _c.Call.Return(request1, headObjectOutput) + return _c +} + +func (_c *S3API_HeadObjectRequest_Call) RunAndReturn(run func(headObjectInput *s3.HeadObjectInput) (*request.Request, *s3.HeadObjectOutput)) *S3API_HeadObjectRequest_Call { + _c.Call.Return(run) + return _c +} + +// HeadObjectWithContext provides a mock function for the type S3API +func (_mock *S3API) HeadObjectWithContext(v aws.Context, headObjectInput *s3.HeadObjectInput, options ...request.Option) (*s3.HeadObjectOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, headObjectInput, options) + } else { + tmpRet = _mock.Called(v, headObjectInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for HeadObjectWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.HeadObjectOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadObjectInput, ...request.Option) (*s3.HeadObjectOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.HeadObjectInput, ...request.Option) (*s3.HeadObjectOutput, error)); ok { + return returnFunc(v, headObjectInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadObjectInput, ...request.Option) *s3.HeadObjectOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.HeadObjectInput, ...request.Option) *s3.HeadObjectOutput); ok { + r0 = returnFunc(v, headObjectInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.HeadObjectOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.HeadObjectInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.HeadObjectInput, ...request.Option) error); ok { + r1 = returnFunc(v, headObjectInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListBucketAnalyticsConfigurations provides a mock function with given fields: _a0 -func (_m *S3API) ListBucketAnalyticsConfigurations(_a0 *s3.ListBucketAnalyticsConfigurationsInput) (*s3.ListBucketAnalyticsConfigurationsOutput, error) { - ret := _m.Called(_a0) +// S3API_HeadObjectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeadObjectWithContext' +type S3API_HeadObjectWithContext_Call struct { + *mock.Call +} + +// HeadObjectWithContext is a helper method to define mock.On call +// - v aws.Context +// - headObjectInput *s3.HeadObjectInput +// - options ...request.Option +func (_e *S3API_Expecter) HeadObjectWithContext(v interface{}, headObjectInput interface{}, options ...interface{}) *S3API_HeadObjectWithContext_Call { + return &S3API_HeadObjectWithContext_Call{Call: _e.mock.On("HeadObjectWithContext", + append([]interface{}{v, headObjectInput}, options...)...)} +} + +func (_c *S3API_HeadObjectWithContext_Call) Run(run func(v aws.Context, headObjectInput *s3.HeadObjectInput, options ...request.Option)) *S3API_HeadObjectWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.HeadObjectInput + if args[1] != nil { + arg1 = args[1].(*s3.HeadObjectInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_HeadObjectWithContext_Call) Return(headObjectOutput *s3.HeadObjectOutput, err error) *S3API_HeadObjectWithContext_Call { + _c.Call.Return(headObjectOutput, err) + return _c +} + +func (_c *S3API_HeadObjectWithContext_Call) RunAndReturn(run func(v aws.Context, headObjectInput *s3.HeadObjectInput, options ...request.Option) (*s3.HeadObjectOutput, error)) *S3API_HeadObjectWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListBucketAnalyticsConfigurations provides a mock function for the type S3API +func (_mock *S3API) ListBucketAnalyticsConfigurations(listBucketAnalyticsConfigurationsInput *s3.ListBucketAnalyticsConfigurationsInput) (*s3.ListBucketAnalyticsConfigurationsOutput, error) { + ret := _mock.Called(listBucketAnalyticsConfigurationsInput) + + if len(ret) == 0 { + panic("no return value specified for ListBucketAnalyticsConfigurations") + } var r0 *s3.ListBucketAnalyticsConfigurationsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.ListBucketAnalyticsConfigurationsInput) (*s3.ListBucketAnalyticsConfigurationsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketAnalyticsConfigurationsInput) (*s3.ListBucketAnalyticsConfigurationsOutput, error)); ok { + return returnFunc(listBucketAnalyticsConfigurationsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListBucketAnalyticsConfigurationsInput) *s3.ListBucketAnalyticsConfigurationsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketAnalyticsConfigurationsInput) *s3.ListBucketAnalyticsConfigurationsOutput); ok { + r0 = returnFunc(listBucketAnalyticsConfigurationsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListBucketAnalyticsConfigurationsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.ListBucketAnalyticsConfigurationsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListBucketAnalyticsConfigurationsInput) error); ok { + r1 = returnFunc(listBucketAnalyticsConfigurationsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListBucketAnalyticsConfigurationsRequest provides a mock function with given fields: _a0 -func (_m *S3API) ListBucketAnalyticsConfigurationsRequest(_a0 *s3.ListBucketAnalyticsConfigurationsInput) (*request.Request, *s3.ListBucketAnalyticsConfigurationsOutput) { - ret := _m.Called(_a0) +// S3API_ListBucketAnalyticsConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketAnalyticsConfigurations' +type S3API_ListBucketAnalyticsConfigurations_Call struct { + *mock.Call +} + +// ListBucketAnalyticsConfigurations is a helper method to define mock.On call +// - listBucketAnalyticsConfigurationsInput *s3.ListBucketAnalyticsConfigurationsInput +func (_e *S3API_Expecter) ListBucketAnalyticsConfigurations(listBucketAnalyticsConfigurationsInput interface{}) *S3API_ListBucketAnalyticsConfigurations_Call { + return &S3API_ListBucketAnalyticsConfigurations_Call{Call: _e.mock.On("ListBucketAnalyticsConfigurations", listBucketAnalyticsConfigurationsInput)} +} + +func (_c *S3API_ListBucketAnalyticsConfigurations_Call) Run(run func(listBucketAnalyticsConfigurationsInput *s3.ListBucketAnalyticsConfigurationsInput)) *S3API_ListBucketAnalyticsConfigurations_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListBucketAnalyticsConfigurationsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListBucketAnalyticsConfigurationsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListBucketAnalyticsConfigurations_Call) Return(listBucketAnalyticsConfigurationsOutput *s3.ListBucketAnalyticsConfigurationsOutput, err error) *S3API_ListBucketAnalyticsConfigurations_Call { + _c.Call.Return(listBucketAnalyticsConfigurationsOutput, err) + return _c +} + +func (_c *S3API_ListBucketAnalyticsConfigurations_Call) RunAndReturn(run func(listBucketAnalyticsConfigurationsInput *s3.ListBucketAnalyticsConfigurationsInput) (*s3.ListBucketAnalyticsConfigurationsOutput, error)) *S3API_ListBucketAnalyticsConfigurations_Call { + _c.Call.Return(run) + return _c +} + +// ListBucketAnalyticsConfigurationsRequest provides a mock function for the type S3API +func (_mock *S3API) ListBucketAnalyticsConfigurationsRequest(listBucketAnalyticsConfigurationsInput *s3.ListBucketAnalyticsConfigurationsInput) (*request.Request, *s3.ListBucketAnalyticsConfigurationsOutput) { + ret := _mock.Called(listBucketAnalyticsConfigurationsInput) + + if len(ret) == 0 { + panic("no return value specified for ListBucketAnalyticsConfigurationsRequest") + } var r0 *request.Request var r1 *s3.ListBucketAnalyticsConfigurationsOutput - if rf, ok := ret.Get(0).(func(*s3.ListBucketAnalyticsConfigurationsInput) (*request.Request, *s3.ListBucketAnalyticsConfigurationsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketAnalyticsConfigurationsInput) (*request.Request, *s3.ListBucketAnalyticsConfigurationsOutput)); ok { + return returnFunc(listBucketAnalyticsConfigurationsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListBucketAnalyticsConfigurationsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketAnalyticsConfigurationsInput) *request.Request); ok { + r0 = returnFunc(listBucketAnalyticsConfigurationsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.ListBucketAnalyticsConfigurationsInput) *s3.ListBucketAnalyticsConfigurationsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListBucketAnalyticsConfigurationsInput) *s3.ListBucketAnalyticsConfigurationsOutput); ok { + r1 = returnFunc(listBucketAnalyticsConfigurationsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.ListBucketAnalyticsConfigurationsOutput) } } - return r0, r1 } -// ListBucketAnalyticsConfigurationsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) ListBucketAnalyticsConfigurationsWithContext(_a0 context.Context, _a1 *s3.ListBucketAnalyticsConfigurationsInput, _a2 ...request.Option) (*s3.ListBucketAnalyticsConfigurationsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_ListBucketAnalyticsConfigurationsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketAnalyticsConfigurationsRequest' +type S3API_ListBucketAnalyticsConfigurationsRequest_Call struct { + *mock.Call +} + +// ListBucketAnalyticsConfigurationsRequest is a helper method to define mock.On call +// - listBucketAnalyticsConfigurationsInput *s3.ListBucketAnalyticsConfigurationsInput +func (_e *S3API_Expecter) ListBucketAnalyticsConfigurationsRequest(listBucketAnalyticsConfigurationsInput interface{}) *S3API_ListBucketAnalyticsConfigurationsRequest_Call { + return &S3API_ListBucketAnalyticsConfigurationsRequest_Call{Call: _e.mock.On("ListBucketAnalyticsConfigurationsRequest", listBucketAnalyticsConfigurationsInput)} +} + +func (_c *S3API_ListBucketAnalyticsConfigurationsRequest_Call) Run(run func(listBucketAnalyticsConfigurationsInput *s3.ListBucketAnalyticsConfigurationsInput)) *S3API_ListBucketAnalyticsConfigurationsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListBucketAnalyticsConfigurationsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListBucketAnalyticsConfigurationsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListBucketAnalyticsConfigurationsRequest_Call) Return(request1 *request.Request, listBucketAnalyticsConfigurationsOutput *s3.ListBucketAnalyticsConfigurationsOutput) *S3API_ListBucketAnalyticsConfigurationsRequest_Call { + _c.Call.Return(request1, listBucketAnalyticsConfigurationsOutput) + return _c +} + +func (_c *S3API_ListBucketAnalyticsConfigurationsRequest_Call) RunAndReturn(run func(listBucketAnalyticsConfigurationsInput *s3.ListBucketAnalyticsConfigurationsInput) (*request.Request, *s3.ListBucketAnalyticsConfigurationsOutput)) *S3API_ListBucketAnalyticsConfigurationsRequest_Call { + _c.Call.Return(run) + return _c +} + +// ListBucketAnalyticsConfigurationsWithContext provides a mock function for the type S3API +func (_mock *S3API) ListBucketAnalyticsConfigurationsWithContext(v aws.Context, listBucketAnalyticsConfigurationsInput *s3.ListBucketAnalyticsConfigurationsInput, options ...request.Option) (*s3.ListBucketAnalyticsConfigurationsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listBucketAnalyticsConfigurationsInput, options) + } else { + tmpRet = _mock.Called(v, listBucketAnalyticsConfigurationsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListBucketAnalyticsConfigurationsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.ListBucketAnalyticsConfigurationsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListBucketAnalyticsConfigurationsInput, ...request.Option) (*s3.ListBucketAnalyticsConfigurationsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketAnalyticsConfigurationsInput, ...request.Option) (*s3.ListBucketAnalyticsConfigurationsOutput, error)); ok { + return returnFunc(v, listBucketAnalyticsConfigurationsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListBucketAnalyticsConfigurationsInput, ...request.Option) *s3.ListBucketAnalyticsConfigurationsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketAnalyticsConfigurationsInput, ...request.Option) *s3.ListBucketAnalyticsConfigurationsOutput); ok { + r0 = returnFunc(v, listBucketAnalyticsConfigurationsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListBucketAnalyticsConfigurationsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.ListBucketAnalyticsConfigurationsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.ListBucketAnalyticsConfigurationsInput, ...request.Option) error); ok { + r1 = returnFunc(v, listBucketAnalyticsConfigurationsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListBucketIntelligentTieringConfigurations provides a mock function with given fields: _a0 -func (_m *S3API) ListBucketIntelligentTieringConfigurations(_a0 *s3.ListBucketIntelligentTieringConfigurationsInput) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error) { - ret := _m.Called(_a0) +// S3API_ListBucketAnalyticsConfigurationsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketAnalyticsConfigurationsWithContext' +type S3API_ListBucketAnalyticsConfigurationsWithContext_Call struct { + *mock.Call +} + +// ListBucketAnalyticsConfigurationsWithContext is a helper method to define mock.On call +// - v aws.Context +// - listBucketAnalyticsConfigurationsInput *s3.ListBucketAnalyticsConfigurationsInput +// - options ...request.Option +func (_e *S3API_Expecter) ListBucketAnalyticsConfigurationsWithContext(v interface{}, listBucketAnalyticsConfigurationsInput interface{}, options ...interface{}) *S3API_ListBucketAnalyticsConfigurationsWithContext_Call { + return &S3API_ListBucketAnalyticsConfigurationsWithContext_Call{Call: _e.mock.On("ListBucketAnalyticsConfigurationsWithContext", + append([]interface{}{v, listBucketAnalyticsConfigurationsInput}, options...)...)} +} + +func (_c *S3API_ListBucketAnalyticsConfigurationsWithContext_Call) Run(run func(v aws.Context, listBucketAnalyticsConfigurationsInput *s3.ListBucketAnalyticsConfigurationsInput, options ...request.Option)) *S3API_ListBucketAnalyticsConfigurationsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListBucketAnalyticsConfigurationsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListBucketAnalyticsConfigurationsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_ListBucketAnalyticsConfigurationsWithContext_Call) Return(listBucketAnalyticsConfigurationsOutput *s3.ListBucketAnalyticsConfigurationsOutput, err error) *S3API_ListBucketAnalyticsConfigurationsWithContext_Call { + _c.Call.Return(listBucketAnalyticsConfigurationsOutput, err) + return _c +} + +func (_c *S3API_ListBucketAnalyticsConfigurationsWithContext_Call) RunAndReturn(run func(v aws.Context, listBucketAnalyticsConfigurationsInput *s3.ListBucketAnalyticsConfigurationsInput, options ...request.Option) (*s3.ListBucketAnalyticsConfigurationsOutput, error)) *S3API_ListBucketAnalyticsConfigurationsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListBucketIntelligentTieringConfigurations provides a mock function for the type S3API +func (_mock *S3API) ListBucketIntelligentTieringConfigurations(listBucketIntelligentTieringConfigurationsInput *s3.ListBucketIntelligentTieringConfigurationsInput) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error) { + ret := _mock.Called(listBucketIntelligentTieringConfigurationsInput) + + if len(ret) == 0 { + panic("no return value specified for ListBucketIntelligentTieringConfigurations") + } var r0 *s3.ListBucketIntelligentTieringConfigurationsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error)); ok { + return returnFunc(listBucketIntelligentTieringConfigurationsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) *s3.ListBucketIntelligentTieringConfigurationsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) *s3.ListBucketIntelligentTieringConfigurationsOutput); ok { + r0 = returnFunc(listBucketIntelligentTieringConfigurationsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListBucketIntelligentTieringConfigurationsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) error); ok { + r1 = returnFunc(listBucketIntelligentTieringConfigurationsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListBucketIntelligentTieringConfigurationsRequest provides a mock function with given fields: _a0 -func (_m *S3API) ListBucketIntelligentTieringConfigurationsRequest(_a0 *s3.ListBucketIntelligentTieringConfigurationsInput) (*request.Request, *s3.ListBucketIntelligentTieringConfigurationsOutput) { - ret := _m.Called(_a0) +// S3API_ListBucketIntelligentTieringConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketIntelligentTieringConfigurations' +type S3API_ListBucketIntelligentTieringConfigurations_Call struct { + *mock.Call +} + +// ListBucketIntelligentTieringConfigurations is a helper method to define mock.On call +// - listBucketIntelligentTieringConfigurationsInput *s3.ListBucketIntelligentTieringConfigurationsInput +func (_e *S3API_Expecter) ListBucketIntelligentTieringConfigurations(listBucketIntelligentTieringConfigurationsInput interface{}) *S3API_ListBucketIntelligentTieringConfigurations_Call { + return &S3API_ListBucketIntelligentTieringConfigurations_Call{Call: _e.mock.On("ListBucketIntelligentTieringConfigurations", listBucketIntelligentTieringConfigurationsInput)} +} + +func (_c *S3API_ListBucketIntelligentTieringConfigurations_Call) Run(run func(listBucketIntelligentTieringConfigurationsInput *s3.ListBucketIntelligentTieringConfigurationsInput)) *S3API_ListBucketIntelligentTieringConfigurations_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListBucketIntelligentTieringConfigurationsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListBucketIntelligentTieringConfigurationsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListBucketIntelligentTieringConfigurations_Call) Return(listBucketIntelligentTieringConfigurationsOutput *s3.ListBucketIntelligentTieringConfigurationsOutput, err error) *S3API_ListBucketIntelligentTieringConfigurations_Call { + _c.Call.Return(listBucketIntelligentTieringConfigurationsOutput, err) + return _c +} + +func (_c *S3API_ListBucketIntelligentTieringConfigurations_Call) RunAndReturn(run func(listBucketIntelligentTieringConfigurationsInput *s3.ListBucketIntelligentTieringConfigurationsInput) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error)) *S3API_ListBucketIntelligentTieringConfigurations_Call { + _c.Call.Return(run) + return _c +} + +// ListBucketIntelligentTieringConfigurationsRequest provides a mock function for the type S3API +func (_mock *S3API) ListBucketIntelligentTieringConfigurationsRequest(listBucketIntelligentTieringConfigurationsInput *s3.ListBucketIntelligentTieringConfigurationsInput) (*request.Request, *s3.ListBucketIntelligentTieringConfigurationsOutput) { + ret := _mock.Called(listBucketIntelligentTieringConfigurationsInput) + + if len(ret) == 0 { + panic("no return value specified for ListBucketIntelligentTieringConfigurationsRequest") + } var r0 *request.Request var r1 *s3.ListBucketIntelligentTieringConfigurationsOutput - if rf, ok := ret.Get(0).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) (*request.Request, *s3.ListBucketIntelligentTieringConfigurationsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) (*request.Request, *s3.ListBucketIntelligentTieringConfigurationsOutput)); ok { + return returnFunc(listBucketIntelligentTieringConfigurationsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) *request.Request); ok { + r0 = returnFunc(listBucketIntelligentTieringConfigurationsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) *s3.ListBucketIntelligentTieringConfigurationsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListBucketIntelligentTieringConfigurationsInput) *s3.ListBucketIntelligentTieringConfigurationsOutput); ok { + r1 = returnFunc(listBucketIntelligentTieringConfigurationsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.ListBucketIntelligentTieringConfigurationsOutput) } } - return r0, r1 } -// ListBucketIntelligentTieringConfigurationsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) ListBucketIntelligentTieringConfigurationsWithContext(_a0 context.Context, _a1 *s3.ListBucketIntelligentTieringConfigurationsInput, _a2 ...request.Option) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_ListBucketIntelligentTieringConfigurationsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketIntelligentTieringConfigurationsRequest' +type S3API_ListBucketIntelligentTieringConfigurationsRequest_Call struct { + *mock.Call +} + +// ListBucketIntelligentTieringConfigurationsRequest is a helper method to define mock.On call +// - listBucketIntelligentTieringConfigurationsInput *s3.ListBucketIntelligentTieringConfigurationsInput +func (_e *S3API_Expecter) ListBucketIntelligentTieringConfigurationsRequest(listBucketIntelligentTieringConfigurationsInput interface{}) *S3API_ListBucketIntelligentTieringConfigurationsRequest_Call { + return &S3API_ListBucketIntelligentTieringConfigurationsRequest_Call{Call: _e.mock.On("ListBucketIntelligentTieringConfigurationsRequest", listBucketIntelligentTieringConfigurationsInput)} +} + +func (_c *S3API_ListBucketIntelligentTieringConfigurationsRequest_Call) Run(run func(listBucketIntelligentTieringConfigurationsInput *s3.ListBucketIntelligentTieringConfigurationsInput)) *S3API_ListBucketIntelligentTieringConfigurationsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListBucketIntelligentTieringConfigurationsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListBucketIntelligentTieringConfigurationsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListBucketIntelligentTieringConfigurationsRequest_Call) Return(request1 *request.Request, listBucketIntelligentTieringConfigurationsOutput *s3.ListBucketIntelligentTieringConfigurationsOutput) *S3API_ListBucketIntelligentTieringConfigurationsRequest_Call { + _c.Call.Return(request1, listBucketIntelligentTieringConfigurationsOutput) + return _c +} + +func (_c *S3API_ListBucketIntelligentTieringConfigurationsRequest_Call) RunAndReturn(run func(listBucketIntelligentTieringConfigurationsInput *s3.ListBucketIntelligentTieringConfigurationsInput) (*request.Request, *s3.ListBucketIntelligentTieringConfigurationsOutput)) *S3API_ListBucketIntelligentTieringConfigurationsRequest_Call { + _c.Call.Return(run) + return _c +} + +// ListBucketIntelligentTieringConfigurationsWithContext provides a mock function for the type S3API +func (_mock *S3API) ListBucketIntelligentTieringConfigurationsWithContext(v aws.Context, listBucketIntelligentTieringConfigurationsInput *s3.ListBucketIntelligentTieringConfigurationsInput, options ...request.Option) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listBucketIntelligentTieringConfigurationsInput, options) + } else { + tmpRet = _mock.Called(v, listBucketIntelligentTieringConfigurationsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListBucketIntelligentTieringConfigurationsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.ListBucketIntelligentTieringConfigurationsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListBucketIntelligentTieringConfigurationsInput, ...request.Option) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketIntelligentTieringConfigurationsInput, ...request.Option) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error)); ok { + return returnFunc(v, listBucketIntelligentTieringConfigurationsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListBucketIntelligentTieringConfigurationsInput, ...request.Option) *s3.ListBucketIntelligentTieringConfigurationsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketIntelligentTieringConfigurationsInput, ...request.Option) *s3.ListBucketIntelligentTieringConfigurationsOutput); ok { + r0 = returnFunc(v, listBucketIntelligentTieringConfigurationsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListBucketIntelligentTieringConfigurationsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.ListBucketIntelligentTieringConfigurationsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.ListBucketIntelligentTieringConfigurationsInput, ...request.Option) error); ok { + r1 = returnFunc(v, listBucketIntelligentTieringConfigurationsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListBucketInventoryConfigurations provides a mock function with given fields: _a0 -func (_m *S3API) ListBucketInventoryConfigurations(_a0 *s3.ListBucketInventoryConfigurationsInput) (*s3.ListBucketInventoryConfigurationsOutput, error) { - ret := _m.Called(_a0) +// S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketIntelligentTieringConfigurationsWithContext' +type S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call struct { + *mock.Call +} + +// ListBucketIntelligentTieringConfigurationsWithContext is a helper method to define mock.On call +// - v aws.Context +// - listBucketIntelligentTieringConfigurationsInput *s3.ListBucketIntelligentTieringConfigurationsInput +// - options ...request.Option +func (_e *S3API_Expecter) ListBucketIntelligentTieringConfigurationsWithContext(v interface{}, listBucketIntelligentTieringConfigurationsInput interface{}, options ...interface{}) *S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call { + return &S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call{Call: _e.mock.On("ListBucketIntelligentTieringConfigurationsWithContext", + append([]interface{}{v, listBucketIntelligentTieringConfigurationsInput}, options...)...)} +} + +func (_c *S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call) Run(run func(v aws.Context, listBucketIntelligentTieringConfigurationsInput *s3.ListBucketIntelligentTieringConfigurationsInput, options ...request.Option)) *S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListBucketIntelligentTieringConfigurationsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListBucketIntelligentTieringConfigurationsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call) Return(listBucketIntelligentTieringConfigurationsOutput *s3.ListBucketIntelligentTieringConfigurationsOutput, err error) *S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call { + _c.Call.Return(listBucketIntelligentTieringConfigurationsOutput, err) + return _c +} + +func (_c *S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call) RunAndReturn(run func(v aws.Context, listBucketIntelligentTieringConfigurationsInput *s3.ListBucketIntelligentTieringConfigurationsInput, options ...request.Option) (*s3.ListBucketIntelligentTieringConfigurationsOutput, error)) *S3API_ListBucketIntelligentTieringConfigurationsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListBucketInventoryConfigurations provides a mock function for the type S3API +func (_mock *S3API) ListBucketInventoryConfigurations(listBucketInventoryConfigurationsInput *s3.ListBucketInventoryConfigurationsInput) (*s3.ListBucketInventoryConfigurationsOutput, error) { + ret := _mock.Called(listBucketInventoryConfigurationsInput) + + if len(ret) == 0 { + panic("no return value specified for ListBucketInventoryConfigurations") + } var r0 *s3.ListBucketInventoryConfigurationsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.ListBucketInventoryConfigurationsInput) (*s3.ListBucketInventoryConfigurationsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketInventoryConfigurationsInput) (*s3.ListBucketInventoryConfigurationsOutput, error)); ok { + return returnFunc(listBucketInventoryConfigurationsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListBucketInventoryConfigurationsInput) *s3.ListBucketInventoryConfigurationsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketInventoryConfigurationsInput) *s3.ListBucketInventoryConfigurationsOutput); ok { + r0 = returnFunc(listBucketInventoryConfigurationsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListBucketInventoryConfigurationsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.ListBucketInventoryConfigurationsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListBucketInventoryConfigurationsInput) error); ok { + r1 = returnFunc(listBucketInventoryConfigurationsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListBucketInventoryConfigurationsRequest provides a mock function with given fields: _a0 -func (_m *S3API) ListBucketInventoryConfigurationsRequest(_a0 *s3.ListBucketInventoryConfigurationsInput) (*request.Request, *s3.ListBucketInventoryConfigurationsOutput) { - ret := _m.Called(_a0) +// S3API_ListBucketInventoryConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketInventoryConfigurations' +type S3API_ListBucketInventoryConfigurations_Call struct { + *mock.Call +} + +// ListBucketInventoryConfigurations is a helper method to define mock.On call +// - listBucketInventoryConfigurationsInput *s3.ListBucketInventoryConfigurationsInput +func (_e *S3API_Expecter) ListBucketInventoryConfigurations(listBucketInventoryConfigurationsInput interface{}) *S3API_ListBucketInventoryConfigurations_Call { + return &S3API_ListBucketInventoryConfigurations_Call{Call: _e.mock.On("ListBucketInventoryConfigurations", listBucketInventoryConfigurationsInput)} +} + +func (_c *S3API_ListBucketInventoryConfigurations_Call) Run(run func(listBucketInventoryConfigurationsInput *s3.ListBucketInventoryConfigurationsInput)) *S3API_ListBucketInventoryConfigurations_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListBucketInventoryConfigurationsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListBucketInventoryConfigurationsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListBucketInventoryConfigurations_Call) Return(listBucketInventoryConfigurationsOutput *s3.ListBucketInventoryConfigurationsOutput, err error) *S3API_ListBucketInventoryConfigurations_Call { + _c.Call.Return(listBucketInventoryConfigurationsOutput, err) + return _c +} + +func (_c *S3API_ListBucketInventoryConfigurations_Call) RunAndReturn(run func(listBucketInventoryConfigurationsInput *s3.ListBucketInventoryConfigurationsInput) (*s3.ListBucketInventoryConfigurationsOutput, error)) *S3API_ListBucketInventoryConfigurations_Call { + _c.Call.Return(run) + return _c +} + +// ListBucketInventoryConfigurationsRequest provides a mock function for the type S3API +func (_mock *S3API) ListBucketInventoryConfigurationsRequest(listBucketInventoryConfigurationsInput *s3.ListBucketInventoryConfigurationsInput) (*request.Request, *s3.ListBucketInventoryConfigurationsOutput) { + ret := _mock.Called(listBucketInventoryConfigurationsInput) + + if len(ret) == 0 { + panic("no return value specified for ListBucketInventoryConfigurationsRequest") + } var r0 *request.Request var r1 *s3.ListBucketInventoryConfigurationsOutput - if rf, ok := ret.Get(0).(func(*s3.ListBucketInventoryConfigurationsInput) (*request.Request, *s3.ListBucketInventoryConfigurationsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketInventoryConfigurationsInput) (*request.Request, *s3.ListBucketInventoryConfigurationsOutput)); ok { + return returnFunc(listBucketInventoryConfigurationsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListBucketInventoryConfigurationsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketInventoryConfigurationsInput) *request.Request); ok { + r0 = returnFunc(listBucketInventoryConfigurationsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.ListBucketInventoryConfigurationsInput) *s3.ListBucketInventoryConfigurationsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListBucketInventoryConfigurationsInput) *s3.ListBucketInventoryConfigurationsOutput); ok { + r1 = returnFunc(listBucketInventoryConfigurationsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.ListBucketInventoryConfigurationsOutput) } } - return r0, r1 } -// ListBucketInventoryConfigurationsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) ListBucketInventoryConfigurationsWithContext(_a0 context.Context, _a1 *s3.ListBucketInventoryConfigurationsInput, _a2 ...request.Option) (*s3.ListBucketInventoryConfigurationsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_ListBucketInventoryConfigurationsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketInventoryConfigurationsRequest' +type S3API_ListBucketInventoryConfigurationsRequest_Call struct { + *mock.Call +} + +// ListBucketInventoryConfigurationsRequest is a helper method to define mock.On call +// - listBucketInventoryConfigurationsInput *s3.ListBucketInventoryConfigurationsInput +func (_e *S3API_Expecter) ListBucketInventoryConfigurationsRequest(listBucketInventoryConfigurationsInput interface{}) *S3API_ListBucketInventoryConfigurationsRequest_Call { + return &S3API_ListBucketInventoryConfigurationsRequest_Call{Call: _e.mock.On("ListBucketInventoryConfigurationsRequest", listBucketInventoryConfigurationsInput)} +} + +func (_c *S3API_ListBucketInventoryConfigurationsRequest_Call) Run(run func(listBucketInventoryConfigurationsInput *s3.ListBucketInventoryConfigurationsInput)) *S3API_ListBucketInventoryConfigurationsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListBucketInventoryConfigurationsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListBucketInventoryConfigurationsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListBucketInventoryConfigurationsRequest_Call) Return(request1 *request.Request, listBucketInventoryConfigurationsOutput *s3.ListBucketInventoryConfigurationsOutput) *S3API_ListBucketInventoryConfigurationsRequest_Call { + _c.Call.Return(request1, listBucketInventoryConfigurationsOutput) + return _c +} + +func (_c *S3API_ListBucketInventoryConfigurationsRequest_Call) RunAndReturn(run func(listBucketInventoryConfigurationsInput *s3.ListBucketInventoryConfigurationsInput) (*request.Request, *s3.ListBucketInventoryConfigurationsOutput)) *S3API_ListBucketInventoryConfigurationsRequest_Call { + _c.Call.Return(run) + return _c +} + +// ListBucketInventoryConfigurationsWithContext provides a mock function for the type S3API +func (_mock *S3API) ListBucketInventoryConfigurationsWithContext(v aws.Context, listBucketInventoryConfigurationsInput *s3.ListBucketInventoryConfigurationsInput, options ...request.Option) (*s3.ListBucketInventoryConfigurationsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listBucketInventoryConfigurationsInput, options) + } else { + tmpRet = _mock.Called(v, listBucketInventoryConfigurationsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListBucketInventoryConfigurationsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.ListBucketInventoryConfigurationsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListBucketInventoryConfigurationsInput, ...request.Option) (*s3.ListBucketInventoryConfigurationsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketInventoryConfigurationsInput, ...request.Option) (*s3.ListBucketInventoryConfigurationsOutput, error)); ok { + return returnFunc(v, listBucketInventoryConfigurationsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListBucketInventoryConfigurationsInput, ...request.Option) *s3.ListBucketInventoryConfigurationsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketInventoryConfigurationsInput, ...request.Option) *s3.ListBucketInventoryConfigurationsOutput); ok { + r0 = returnFunc(v, listBucketInventoryConfigurationsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListBucketInventoryConfigurationsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.ListBucketInventoryConfigurationsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.ListBucketInventoryConfigurationsInput, ...request.Option) error); ok { + r1 = returnFunc(v, listBucketInventoryConfigurationsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListBucketMetricsConfigurations provides a mock function with given fields: _a0 -func (_m *S3API) ListBucketMetricsConfigurations(_a0 *s3.ListBucketMetricsConfigurationsInput) (*s3.ListBucketMetricsConfigurationsOutput, error) { - ret := _m.Called(_a0) +// S3API_ListBucketInventoryConfigurationsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketInventoryConfigurationsWithContext' +type S3API_ListBucketInventoryConfigurationsWithContext_Call struct { + *mock.Call +} + +// ListBucketInventoryConfigurationsWithContext is a helper method to define mock.On call +// - v aws.Context +// - listBucketInventoryConfigurationsInput *s3.ListBucketInventoryConfigurationsInput +// - options ...request.Option +func (_e *S3API_Expecter) ListBucketInventoryConfigurationsWithContext(v interface{}, listBucketInventoryConfigurationsInput interface{}, options ...interface{}) *S3API_ListBucketInventoryConfigurationsWithContext_Call { + return &S3API_ListBucketInventoryConfigurationsWithContext_Call{Call: _e.mock.On("ListBucketInventoryConfigurationsWithContext", + append([]interface{}{v, listBucketInventoryConfigurationsInput}, options...)...)} +} + +func (_c *S3API_ListBucketInventoryConfigurationsWithContext_Call) Run(run func(v aws.Context, listBucketInventoryConfigurationsInput *s3.ListBucketInventoryConfigurationsInput, options ...request.Option)) *S3API_ListBucketInventoryConfigurationsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListBucketInventoryConfigurationsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListBucketInventoryConfigurationsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_ListBucketInventoryConfigurationsWithContext_Call) Return(listBucketInventoryConfigurationsOutput *s3.ListBucketInventoryConfigurationsOutput, err error) *S3API_ListBucketInventoryConfigurationsWithContext_Call { + _c.Call.Return(listBucketInventoryConfigurationsOutput, err) + return _c +} + +func (_c *S3API_ListBucketInventoryConfigurationsWithContext_Call) RunAndReturn(run func(v aws.Context, listBucketInventoryConfigurationsInput *s3.ListBucketInventoryConfigurationsInput, options ...request.Option) (*s3.ListBucketInventoryConfigurationsOutput, error)) *S3API_ListBucketInventoryConfigurationsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListBucketMetricsConfigurations provides a mock function for the type S3API +func (_mock *S3API) ListBucketMetricsConfigurations(listBucketMetricsConfigurationsInput *s3.ListBucketMetricsConfigurationsInput) (*s3.ListBucketMetricsConfigurationsOutput, error) { + ret := _mock.Called(listBucketMetricsConfigurationsInput) + + if len(ret) == 0 { + panic("no return value specified for ListBucketMetricsConfigurations") + } var r0 *s3.ListBucketMetricsConfigurationsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.ListBucketMetricsConfigurationsInput) (*s3.ListBucketMetricsConfigurationsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketMetricsConfigurationsInput) (*s3.ListBucketMetricsConfigurationsOutput, error)); ok { + return returnFunc(listBucketMetricsConfigurationsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListBucketMetricsConfigurationsInput) *s3.ListBucketMetricsConfigurationsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketMetricsConfigurationsInput) *s3.ListBucketMetricsConfigurationsOutput); ok { + r0 = returnFunc(listBucketMetricsConfigurationsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListBucketMetricsConfigurationsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.ListBucketMetricsConfigurationsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListBucketMetricsConfigurationsInput) error); ok { + r1 = returnFunc(listBucketMetricsConfigurationsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListBucketMetricsConfigurationsRequest provides a mock function with given fields: _a0 -func (_m *S3API) ListBucketMetricsConfigurationsRequest(_a0 *s3.ListBucketMetricsConfigurationsInput) (*request.Request, *s3.ListBucketMetricsConfigurationsOutput) { - ret := _m.Called(_a0) +// S3API_ListBucketMetricsConfigurations_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketMetricsConfigurations' +type S3API_ListBucketMetricsConfigurations_Call struct { + *mock.Call +} + +// ListBucketMetricsConfigurations is a helper method to define mock.On call +// - listBucketMetricsConfigurationsInput *s3.ListBucketMetricsConfigurationsInput +func (_e *S3API_Expecter) ListBucketMetricsConfigurations(listBucketMetricsConfigurationsInput interface{}) *S3API_ListBucketMetricsConfigurations_Call { + return &S3API_ListBucketMetricsConfigurations_Call{Call: _e.mock.On("ListBucketMetricsConfigurations", listBucketMetricsConfigurationsInput)} +} + +func (_c *S3API_ListBucketMetricsConfigurations_Call) Run(run func(listBucketMetricsConfigurationsInput *s3.ListBucketMetricsConfigurationsInput)) *S3API_ListBucketMetricsConfigurations_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListBucketMetricsConfigurationsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListBucketMetricsConfigurationsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListBucketMetricsConfigurations_Call) Return(listBucketMetricsConfigurationsOutput *s3.ListBucketMetricsConfigurationsOutput, err error) *S3API_ListBucketMetricsConfigurations_Call { + _c.Call.Return(listBucketMetricsConfigurationsOutput, err) + return _c +} + +func (_c *S3API_ListBucketMetricsConfigurations_Call) RunAndReturn(run func(listBucketMetricsConfigurationsInput *s3.ListBucketMetricsConfigurationsInput) (*s3.ListBucketMetricsConfigurationsOutput, error)) *S3API_ListBucketMetricsConfigurations_Call { + _c.Call.Return(run) + return _c +} + +// ListBucketMetricsConfigurationsRequest provides a mock function for the type S3API +func (_mock *S3API) ListBucketMetricsConfigurationsRequest(listBucketMetricsConfigurationsInput *s3.ListBucketMetricsConfigurationsInput) (*request.Request, *s3.ListBucketMetricsConfigurationsOutput) { + ret := _mock.Called(listBucketMetricsConfigurationsInput) + + if len(ret) == 0 { + panic("no return value specified for ListBucketMetricsConfigurationsRequest") + } var r0 *request.Request var r1 *s3.ListBucketMetricsConfigurationsOutput - if rf, ok := ret.Get(0).(func(*s3.ListBucketMetricsConfigurationsInput) (*request.Request, *s3.ListBucketMetricsConfigurationsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketMetricsConfigurationsInput) (*request.Request, *s3.ListBucketMetricsConfigurationsOutput)); ok { + return returnFunc(listBucketMetricsConfigurationsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListBucketMetricsConfigurationsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketMetricsConfigurationsInput) *request.Request); ok { + r0 = returnFunc(listBucketMetricsConfigurationsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.ListBucketMetricsConfigurationsInput) *s3.ListBucketMetricsConfigurationsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListBucketMetricsConfigurationsInput) *s3.ListBucketMetricsConfigurationsOutput); ok { + r1 = returnFunc(listBucketMetricsConfigurationsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.ListBucketMetricsConfigurationsOutput) } } - return r0, r1 } -// ListBucketMetricsConfigurationsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) ListBucketMetricsConfigurationsWithContext(_a0 context.Context, _a1 *s3.ListBucketMetricsConfigurationsInput, _a2 ...request.Option) (*s3.ListBucketMetricsConfigurationsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_ListBucketMetricsConfigurationsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketMetricsConfigurationsRequest' +type S3API_ListBucketMetricsConfigurationsRequest_Call struct { + *mock.Call +} + +// ListBucketMetricsConfigurationsRequest is a helper method to define mock.On call +// - listBucketMetricsConfigurationsInput *s3.ListBucketMetricsConfigurationsInput +func (_e *S3API_Expecter) ListBucketMetricsConfigurationsRequest(listBucketMetricsConfigurationsInput interface{}) *S3API_ListBucketMetricsConfigurationsRequest_Call { + return &S3API_ListBucketMetricsConfigurationsRequest_Call{Call: _e.mock.On("ListBucketMetricsConfigurationsRequest", listBucketMetricsConfigurationsInput)} +} + +func (_c *S3API_ListBucketMetricsConfigurationsRequest_Call) Run(run func(listBucketMetricsConfigurationsInput *s3.ListBucketMetricsConfigurationsInput)) *S3API_ListBucketMetricsConfigurationsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListBucketMetricsConfigurationsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListBucketMetricsConfigurationsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListBucketMetricsConfigurationsRequest_Call) Return(request1 *request.Request, listBucketMetricsConfigurationsOutput *s3.ListBucketMetricsConfigurationsOutput) *S3API_ListBucketMetricsConfigurationsRequest_Call { + _c.Call.Return(request1, listBucketMetricsConfigurationsOutput) + return _c +} + +func (_c *S3API_ListBucketMetricsConfigurationsRequest_Call) RunAndReturn(run func(listBucketMetricsConfigurationsInput *s3.ListBucketMetricsConfigurationsInput) (*request.Request, *s3.ListBucketMetricsConfigurationsOutput)) *S3API_ListBucketMetricsConfigurationsRequest_Call { + _c.Call.Return(run) + return _c +} + +// ListBucketMetricsConfigurationsWithContext provides a mock function for the type S3API +func (_mock *S3API) ListBucketMetricsConfigurationsWithContext(v aws.Context, listBucketMetricsConfigurationsInput *s3.ListBucketMetricsConfigurationsInput, options ...request.Option) (*s3.ListBucketMetricsConfigurationsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listBucketMetricsConfigurationsInput, options) + } else { + tmpRet = _mock.Called(v, listBucketMetricsConfigurationsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListBucketMetricsConfigurationsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.ListBucketMetricsConfigurationsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListBucketMetricsConfigurationsInput, ...request.Option) (*s3.ListBucketMetricsConfigurationsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketMetricsConfigurationsInput, ...request.Option) (*s3.ListBucketMetricsConfigurationsOutput, error)); ok { + return returnFunc(v, listBucketMetricsConfigurationsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListBucketMetricsConfigurationsInput, ...request.Option) *s3.ListBucketMetricsConfigurationsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketMetricsConfigurationsInput, ...request.Option) *s3.ListBucketMetricsConfigurationsOutput); ok { + r0 = returnFunc(v, listBucketMetricsConfigurationsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListBucketMetricsConfigurationsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.ListBucketMetricsConfigurationsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.ListBucketMetricsConfigurationsInput, ...request.Option) error); ok { + r1 = returnFunc(v, listBucketMetricsConfigurationsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListBuckets provides a mock function with given fields: _a0 -func (_m *S3API) ListBuckets(_a0 *s3.ListBucketsInput) (*s3.ListBucketsOutput, error) { - ret := _m.Called(_a0) +// S3API_ListBucketMetricsConfigurationsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketMetricsConfigurationsWithContext' +type S3API_ListBucketMetricsConfigurationsWithContext_Call struct { + *mock.Call +} + +// ListBucketMetricsConfigurationsWithContext is a helper method to define mock.On call +// - v aws.Context +// - listBucketMetricsConfigurationsInput *s3.ListBucketMetricsConfigurationsInput +// - options ...request.Option +func (_e *S3API_Expecter) ListBucketMetricsConfigurationsWithContext(v interface{}, listBucketMetricsConfigurationsInput interface{}, options ...interface{}) *S3API_ListBucketMetricsConfigurationsWithContext_Call { + return &S3API_ListBucketMetricsConfigurationsWithContext_Call{Call: _e.mock.On("ListBucketMetricsConfigurationsWithContext", + append([]interface{}{v, listBucketMetricsConfigurationsInput}, options...)...)} +} + +func (_c *S3API_ListBucketMetricsConfigurationsWithContext_Call) Run(run func(v aws.Context, listBucketMetricsConfigurationsInput *s3.ListBucketMetricsConfigurationsInput, options ...request.Option)) *S3API_ListBucketMetricsConfigurationsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListBucketMetricsConfigurationsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListBucketMetricsConfigurationsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_ListBucketMetricsConfigurationsWithContext_Call) Return(listBucketMetricsConfigurationsOutput *s3.ListBucketMetricsConfigurationsOutput, err error) *S3API_ListBucketMetricsConfigurationsWithContext_Call { + _c.Call.Return(listBucketMetricsConfigurationsOutput, err) + return _c +} + +func (_c *S3API_ListBucketMetricsConfigurationsWithContext_Call) RunAndReturn(run func(v aws.Context, listBucketMetricsConfigurationsInput *s3.ListBucketMetricsConfigurationsInput, options ...request.Option) (*s3.ListBucketMetricsConfigurationsOutput, error)) *S3API_ListBucketMetricsConfigurationsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListBuckets provides a mock function for the type S3API +func (_mock *S3API) ListBuckets(listBucketsInput *s3.ListBucketsInput) (*s3.ListBucketsOutput, error) { + ret := _mock.Called(listBucketsInput) + + if len(ret) == 0 { + panic("no return value specified for ListBuckets") + } var r0 *s3.ListBucketsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.ListBucketsInput) (*s3.ListBucketsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketsInput) (*s3.ListBucketsOutput, error)); ok { + return returnFunc(listBucketsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListBucketsInput) *s3.ListBucketsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketsInput) *s3.ListBucketsOutput); ok { + r0 = returnFunc(listBucketsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListBucketsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.ListBucketsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListBucketsInput) error); ok { + r1 = returnFunc(listBucketsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListBucketsRequest provides a mock function with given fields: _a0 -func (_m *S3API) ListBucketsRequest(_a0 *s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput) { - ret := _m.Called(_a0) +// S3API_ListBuckets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBuckets' +type S3API_ListBuckets_Call struct { + *mock.Call +} + +// ListBuckets is a helper method to define mock.On call +// - listBucketsInput *s3.ListBucketsInput +func (_e *S3API_Expecter) ListBuckets(listBucketsInput interface{}) *S3API_ListBuckets_Call { + return &S3API_ListBuckets_Call{Call: _e.mock.On("ListBuckets", listBucketsInput)} +} + +func (_c *S3API_ListBuckets_Call) Run(run func(listBucketsInput *s3.ListBucketsInput)) *S3API_ListBuckets_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListBucketsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListBucketsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListBuckets_Call) Return(listBucketsOutput *s3.ListBucketsOutput, err error) *S3API_ListBuckets_Call { + _c.Call.Return(listBucketsOutput, err) + return _c +} + +func (_c *S3API_ListBuckets_Call) RunAndReturn(run func(listBucketsInput *s3.ListBucketsInput) (*s3.ListBucketsOutput, error)) *S3API_ListBuckets_Call { + _c.Call.Return(run) + return _c +} + +// ListBucketsRequest provides a mock function for the type S3API +func (_mock *S3API) ListBucketsRequest(listBucketsInput *s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput) { + ret := _mock.Called(listBucketsInput) + + if len(ret) == 0 { + panic("no return value specified for ListBucketsRequest") + } var r0 *request.Request var r1 *s3.ListBucketsOutput - if rf, ok := ret.Get(0).(func(*s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput)); ok { + return returnFunc(listBucketsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListBucketsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListBucketsInput) *request.Request); ok { + r0 = returnFunc(listBucketsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.ListBucketsInput) *s3.ListBucketsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListBucketsInput) *s3.ListBucketsOutput); ok { + r1 = returnFunc(listBucketsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.ListBucketsOutput) } } - return r0, r1 } -// ListBucketsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) ListBucketsWithContext(_a0 context.Context, _a1 *s3.ListBucketsInput, _a2 ...request.Option) (*s3.ListBucketsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_ListBucketsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketsRequest' +type S3API_ListBucketsRequest_Call struct { + *mock.Call +} + +// ListBucketsRequest is a helper method to define mock.On call +// - listBucketsInput *s3.ListBucketsInput +func (_e *S3API_Expecter) ListBucketsRequest(listBucketsInput interface{}) *S3API_ListBucketsRequest_Call { + return &S3API_ListBucketsRequest_Call{Call: _e.mock.On("ListBucketsRequest", listBucketsInput)} +} + +func (_c *S3API_ListBucketsRequest_Call) Run(run func(listBucketsInput *s3.ListBucketsInput)) *S3API_ListBucketsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListBucketsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListBucketsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListBucketsRequest_Call) Return(request1 *request.Request, listBucketsOutput *s3.ListBucketsOutput) *S3API_ListBucketsRequest_Call { + _c.Call.Return(request1, listBucketsOutput) + return _c +} + +func (_c *S3API_ListBucketsRequest_Call) RunAndReturn(run func(listBucketsInput *s3.ListBucketsInput) (*request.Request, *s3.ListBucketsOutput)) *S3API_ListBucketsRequest_Call { + _c.Call.Return(run) + return _c +} + +// ListBucketsWithContext provides a mock function for the type S3API +func (_mock *S3API) ListBucketsWithContext(v aws.Context, listBucketsInput *s3.ListBucketsInput, options ...request.Option) (*s3.ListBucketsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listBucketsInput, options) + } else { + tmpRet = _mock.Called(v, listBucketsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListBucketsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.ListBucketsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListBucketsInput, ...request.Option) (*s3.ListBucketsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketsInput, ...request.Option) (*s3.ListBucketsOutput, error)); ok { + return returnFunc(v, listBucketsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListBucketsInput, ...request.Option) *s3.ListBucketsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListBucketsInput, ...request.Option) *s3.ListBucketsOutput); ok { + r0 = returnFunc(v, listBucketsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListBucketsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.ListBucketsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.ListBucketsInput, ...request.Option) error); ok { + r1 = returnFunc(v, listBucketsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListDirectoryBuckets provides a mock function with given fields: _a0 -func (_m *S3API) ListDirectoryBuckets(_a0 *s3.ListDirectoryBucketsInput) (*s3.ListDirectoryBucketsOutput, error) { - ret := _m.Called(_a0) +// S3API_ListBucketsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListBucketsWithContext' +type S3API_ListBucketsWithContext_Call struct { + *mock.Call +} + +// ListBucketsWithContext is a helper method to define mock.On call +// - v aws.Context +// - listBucketsInput *s3.ListBucketsInput +// - options ...request.Option +func (_e *S3API_Expecter) ListBucketsWithContext(v interface{}, listBucketsInput interface{}, options ...interface{}) *S3API_ListBucketsWithContext_Call { + return &S3API_ListBucketsWithContext_Call{Call: _e.mock.On("ListBucketsWithContext", + append([]interface{}{v, listBucketsInput}, options...)...)} +} + +func (_c *S3API_ListBucketsWithContext_Call) Run(run func(v aws.Context, listBucketsInput *s3.ListBucketsInput, options ...request.Option)) *S3API_ListBucketsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListBucketsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListBucketsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_ListBucketsWithContext_Call) Return(listBucketsOutput *s3.ListBucketsOutput, err error) *S3API_ListBucketsWithContext_Call { + _c.Call.Return(listBucketsOutput, err) + return _c +} + +func (_c *S3API_ListBucketsWithContext_Call) RunAndReturn(run func(v aws.Context, listBucketsInput *s3.ListBucketsInput, options ...request.Option) (*s3.ListBucketsOutput, error)) *S3API_ListBucketsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListDirectoryBuckets provides a mock function for the type S3API +func (_mock *S3API) ListDirectoryBuckets(listDirectoryBucketsInput *s3.ListDirectoryBucketsInput) (*s3.ListDirectoryBucketsOutput, error) { + ret := _mock.Called(listDirectoryBucketsInput) + + if len(ret) == 0 { + panic("no return value specified for ListDirectoryBuckets") + } var r0 *s3.ListDirectoryBucketsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput) (*s3.ListDirectoryBucketsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput) (*s3.ListDirectoryBucketsOutput, error)); ok { + return returnFunc(listDirectoryBucketsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput) *s3.ListDirectoryBucketsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput) *s3.ListDirectoryBucketsOutput); ok { + r0 = returnFunc(listDirectoryBucketsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListDirectoryBucketsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.ListDirectoryBucketsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListDirectoryBucketsInput) error); ok { + r1 = returnFunc(listDirectoryBucketsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListDirectoryBucketsPages provides a mock function with given fields: _a0, _a1 -func (_m *S3API) ListDirectoryBucketsPages(_a0 *s3.ListDirectoryBucketsInput, _a1 func(*s3.ListDirectoryBucketsOutput, bool) bool) error { - ret := _m.Called(_a0, _a1) +// S3API_ListDirectoryBuckets_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDirectoryBuckets' +type S3API_ListDirectoryBuckets_Call struct { + *mock.Call +} - var r0 error - if rf, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput, func(*s3.ListDirectoryBucketsOutput, bool) bool) error); ok { - r0 = rf(_a0, _a1) - } else { - r0 = ret.Error(0) - } +// ListDirectoryBuckets is a helper method to define mock.On call +// - listDirectoryBucketsInput *s3.ListDirectoryBucketsInput +func (_e *S3API_Expecter) ListDirectoryBuckets(listDirectoryBucketsInput interface{}) *S3API_ListDirectoryBuckets_Call { + return &S3API_ListDirectoryBuckets_Call{Call: _e.mock.On("ListDirectoryBuckets", listDirectoryBucketsInput)} +} - return r0 +func (_c *S3API_ListDirectoryBuckets_Call) Run(run func(listDirectoryBucketsInput *s3.ListDirectoryBucketsInput)) *S3API_ListDirectoryBuckets_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListDirectoryBucketsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListDirectoryBucketsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListDirectoryBuckets_Call) Return(listDirectoryBucketsOutput *s3.ListDirectoryBucketsOutput, err error) *S3API_ListDirectoryBuckets_Call { + _c.Call.Return(listDirectoryBucketsOutput, err) + return _c +} + +func (_c *S3API_ListDirectoryBuckets_Call) RunAndReturn(run func(listDirectoryBucketsInput *s3.ListDirectoryBucketsInput) (*s3.ListDirectoryBucketsOutput, error)) *S3API_ListDirectoryBuckets_Call { + _c.Call.Return(run) + return _c } -// ListDirectoryBucketsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 -func (_m *S3API) ListDirectoryBucketsPagesWithContext(_a0 context.Context, _a1 *s3.ListDirectoryBucketsInput, _a2 func(*s3.ListDirectoryBucketsOutput, bool) bool, _a3 ...request.Option) error { - _va := make([]interface{}, len(_a3)) - for _i := range _a3 { - _va[_i] = _a3[_i] +// ListDirectoryBucketsPages provides a mock function for the type S3API +func (_mock *S3API) ListDirectoryBucketsPages(listDirectoryBucketsInput *s3.ListDirectoryBucketsInput, fn func(*s3.ListDirectoryBucketsOutput, bool) bool) error { + ret := _mock.Called(listDirectoryBucketsInput, fn) + + if len(ret) == 0 { + panic("no return value specified for ListDirectoryBucketsPages") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1, _a2) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListDirectoryBucketsInput, func(*s3.ListDirectoryBucketsOutput, bool) bool, ...request.Option) error); ok { - r0 = rf(_a0, _a1, _a2, _a3...) + if returnFunc, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput, func(*s3.ListDirectoryBucketsOutput, bool) bool) error); ok { + r0 = returnFunc(listDirectoryBucketsInput, fn) } else { r0 = ret.Error(0) } - return r0 } -// ListDirectoryBucketsRequest provides a mock function with given fields: _a0 -func (_m *S3API) ListDirectoryBucketsRequest(_a0 *s3.ListDirectoryBucketsInput) (*request.Request, *s3.ListDirectoryBucketsOutput) { - ret := _m.Called(_a0) +// S3API_ListDirectoryBucketsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDirectoryBucketsPages' +type S3API_ListDirectoryBucketsPages_Call struct { + *mock.Call +} - var r0 *request.Request - var r1 *s3.ListDirectoryBucketsOutput - if rf, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput) (*request.Request, *s3.ListDirectoryBucketsOutput)); ok { - return rf(_a0) - } - if rf, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput) *request.Request); ok { - r0 = rf(_a0) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*request.Request) - } - } +// ListDirectoryBucketsPages is a helper method to define mock.On call +// - listDirectoryBucketsInput *s3.ListDirectoryBucketsInput +// - fn func(*s3.ListDirectoryBucketsOutput, bool) bool +func (_e *S3API_Expecter) ListDirectoryBucketsPages(listDirectoryBucketsInput interface{}, fn interface{}) *S3API_ListDirectoryBucketsPages_Call { + return &S3API_ListDirectoryBucketsPages_Call{Call: _e.mock.On("ListDirectoryBucketsPages", listDirectoryBucketsInput, fn)} +} - if rf, ok := ret.Get(1).(func(*s3.ListDirectoryBucketsInput) *s3.ListDirectoryBucketsOutput); ok { - r1 = rf(_a0) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*s3.ListDirectoryBucketsOutput) +func (_c *S3API_ListDirectoryBucketsPages_Call) Run(run func(listDirectoryBucketsInput *s3.ListDirectoryBucketsInput, fn func(*s3.ListDirectoryBucketsOutput, bool) bool)) *S3API_ListDirectoryBucketsPages_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListDirectoryBucketsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListDirectoryBucketsInput) } - } - + var arg1 func(*s3.ListDirectoryBucketsOutput, bool) bool + if args[1] != nil { + arg1 = args[1].(func(*s3.ListDirectoryBucketsOutput, bool) bool) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *S3API_ListDirectoryBucketsPages_Call) Return(err error) *S3API_ListDirectoryBucketsPages_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_ListDirectoryBucketsPages_Call) RunAndReturn(run func(listDirectoryBucketsInput *s3.ListDirectoryBucketsInput, fn func(*s3.ListDirectoryBucketsOutput, bool) bool) error) *S3API_ListDirectoryBucketsPages_Call { + _c.Call.Return(run) + return _c +} + +// ListDirectoryBucketsPagesWithContext provides a mock function for the type S3API +func (_mock *S3API) ListDirectoryBucketsPagesWithContext(v aws.Context, listDirectoryBucketsInput *s3.ListDirectoryBucketsInput, fn func(*s3.ListDirectoryBucketsOutput, bool) bool, options ...request.Option) error { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listDirectoryBucketsInput, fn, options) + } else { + tmpRet = _mock.Called(v, listDirectoryBucketsInput, fn) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListDirectoryBucketsPagesWithContext") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListDirectoryBucketsInput, func(*s3.ListDirectoryBucketsOutput, bool) bool, ...request.Option) error); ok { + r0 = returnFunc(v, listDirectoryBucketsInput, fn, options...) + } else { + r0 = ret.Error(0) + } + return r0 +} + +// S3API_ListDirectoryBucketsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDirectoryBucketsPagesWithContext' +type S3API_ListDirectoryBucketsPagesWithContext_Call struct { + *mock.Call +} + +// ListDirectoryBucketsPagesWithContext is a helper method to define mock.On call +// - v aws.Context +// - listDirectoryBucketsInput *s3.ListDirectoryBucketsInput +// - fn func(*s3.ListDirectoryBucketsOutput, bool) bool +// - options ...request.Option +func (_e *S3API_Expecter) ListDirectoryBucketsPagesWithContext(v interface{}, listDirectoryBucketsInput interface{}, fn interface{}, options ...interface{}) *S3API_ListDirectoryBucketsPagesWithContext_Call { + return &S3API_ListDirectoryBucketsPagesWithContext_Call{Call: _e.mock.On("ListDirectoryBucketsPagesWithContext", + append([]interface{}{v, listDirectoryBucketsInput, fn}, options...)...)} +} + +func (_c *S3API_ListDirectoryBucketsPagesWithContext_Call) Run(run func(v aws.Context, listDirectoryBucketsInput *s3.ListDirectoryBucketsInput, fn func(*s3.ListDirectoryBucketsOutput, bool) bool, options ...request.Option)) *S3API_ListDirectoryBucketsPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListDirectoryBucketsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListDirectoryBucketsInput) + } + var arg2 func(*s3.ListDirectoryBucketsOutput, bool) bool + if args[2] != nil { + arg2 = args[2].(func(*s3.ListDirectoryBucketsOutput, bool) bool) + } + var arg3 []request.Option + var variadicArgs []request.Option + if len(args) > 3 { + variadicArgs = args[3].([]request.Option) + } + arg3 = variadicArgs + run( + arg0, + arg1, + arg2, + arg3..., + ) + }) + return _c +} + +func (_c *S3API_ListDirectoryBucketsPagesWithContext_Call) Return(err error) *S3API_ListDirectoryBucketsPagesWithContext_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_ListDirectoryBucketsPagesWithContext_Call) RunAndReturn(run func(v aws.Context, listDirectoryBucketsInput *s3.ListDirectoryBucketsInput, fn func(*s3.ListDirectoryBucketsOutput, bool) bool, options ...request.Option) error) *S3API_ListDirectoryBucketsPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListDirectoryBucketsRequest provides a mock function for the type S3API +func (_mock *S3API) ListDirectoryBucketsRequest(listDirectoryBucketsInput *s3.ListDirectoryBucketsInput) (*request.Request, *s3.ListDirectoryBucketsOutput) { + ret := _mock.Called(listDirectoryBucketsInput) + + if len(ret) == 0 { + panic("no return value specified for ListDirectoryBucketsRequest") + } + + var r0 *request.Request + var r1 *s3.ListDirectoryBucketsOutput + if returnFunc, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput) (*request.Request, *s3.ListDirectoryBucketsOutput)); ok { + return returnFunc(listDirectoryBucketsInput) + } + if returnFunc, ok := ret.Get(0).(func(*s3.ListDirectoryBucketsInput) *request.Request); ok { + r0 = returnFunc(listDirectoryBucketsInput) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*request.Request) + } + } + if returnFunc, ok := ret.Get(1).(func(*s3.ListDirectoryBucketsInput) *s3.ListDirectoryBucketsOutput); ok { + r1 = returnFunc(listDirectoryBucketsInput) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(*s3.ListDirectoryBucketsOutput) + } + } return r0, r1 } -// ListDirectoryBucketsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) ListDirectoryBucketsWithContext(_a0 context.Context, _a1 *s3.ListDirectoryBucketsInput, _a2 ...request.Option) (*s3.ListDirectoryBucketsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_ListDirectoryBucketsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDirectoryBucketsRequest' +type S3API_ListDirectoryBucketsRequest_Call struct { + *mock.Call +} + +// ListDirectoryBucketsRequest is a helper method to define mock.On call +// - listDirectoryBucketsInput *s3.ListDirectoryBucketsInput +func (_e *S3API_Expecter) ListDirectoryBucketsRequest(listDirectoryBucketsInput interface{}) *S3API_ListDirectoryBucketsRequest_Call { + return &S3API_ListDirectoryBucketsRequest_Call{Call: _e.mock.On("ListDirectoryBucketsRequest", listDirectoryBucketsInput)} +} + +func (_c *S3API_ListDirectoryBucketsRequest_Call) Run(run func(listDirectoryBucketsInput *s3.ListDirectoryBucketsInput)) *S3API_ListDirectoryBucketsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListDirectoryBucketsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListDirectoryBucketsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListDirectoryBucketsRequest_Call) Return(request1 *request.Request, listDirectoryBucketsOutput *s3.ListDirectoryBucketsOutput) *S3API_ListDirectoryBucketsRequest_Call { + _c.Call.Return(request1, listDirectoryBucketsOutput) + return _c +} + +func (_c *S3API_ListDirectoryBucketsRequest_Call) RunAndReturn(run func(listDirectoryBucketsInput *s3.ListDirectoryBucketsInput) (*request.Request, *s3.ListDirectoryBucketsOutput)) *S3API_ListDirectoryBucketsRequest_Call { + _c.Call.Return(run) + return _c +} + +// ListDirectoryBucketsWithContext provides a mock function for the type S3API +func (_mock *S3API) ListDirectoryBucketsWithContext(v aws.Context, listDirectoryBucketsInput *s3.ListDirectoryBucketsInput, options ...request.Option) (*s3.ListDirectoryBucketsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listDirectoryBucketsInput, options) + } else { + tmpRet = _mock.Called(v, listDirectoryBucketsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListDirectoryBucketsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.ListDirectoryBucketsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListDirectoryBucketsInput, ...request.Option) (*s3.ListDirectoryBucketsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListDirectoryBucketsInput, ...request.Option) (*s3.ListDirectoryBucketsOutput, error)); ok { + return returnFunc(v, listDirectoryBucketsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListDirectoryBucketsInput, ...request.Option) *s3.ListDirectoryBucketsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListDirectoryBucketsInput, ...request.Option) *s3.ListDirectoryBucketsOutput); ok { + r0 = returnFunc(v, listDirectoryBucketsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListDirectoryBucketsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.ListDirectoryBucketsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.ListDirectoryBucketsInput, ...request.Option) error); ok { + r1 = returnFunc(v, listDirectoryBucketsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListMultipartUploads provides a mock function with given fields: _a0 -func (_m *S3API) ListMultipartUploads(_a0 *s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error) { - ret := _m.Called(_a0) +// S3API_ListDirectoryBucketsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListDirectoryBucketsWithContext' +type S3API_ListDirectoryBucketsWithContext_Call struct { + *mock.Call +} + +// ListDirectoryBucketsWithContext is a helper method to define mock.On call +// - v aws.Context +// - listDirectoryBucketsInput *s3.ListDirectoryBucketsInput +// - options ...request.Option +func (_e *S3API_Expecter) ListDirectoryBucketsWithContext(v interface{}, listDirectoryBucketsInput interface{}, options ...interface{}) *S3API_ListDirectoryBucketsWithContext_Call { + return &S3API_ListDirectoryBucketsWithContext_Call{Call: _e.mock.On("ListDirectoryBucketsWithContext", + append([]interface{}{v, listDirectoryBucketsInput}, options...)...)} +} + +func (_c *S3API_ListDirectoryBucketsWithContext_Call) Run(run func(v aws.Context, listDirectoryBucketsInput *s3.ListDirectoryBucketsInput, options ...request.Option)) *S3API_ListDirectoryBucketsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListDirectoryBucketsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListDirectoryBucketsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_ListDirectoryBucketsWithContext_Call) Return(listDirectoryBucketsOutput *s3.ListDirectoryBucketsOutput, err error) *S3API_ListDirectoryBucketsWithContext_Call { + _c.Call.Return(listDirectoryBucketsOutput, err) + return _c +} + +func (_c *S3API_ListDirectoryBucketsWithContext_Call) RunAndReturn(run func(v aws.Context, listDirectoryBucketsInput *s3.ListDirectoryBucketsInput, options ...request.Option) (*s3.ListDirectoryBucketsOutput, error)) *S3API_ListDirectoryBucketsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListMultipartUploads provides a mock function for the type S3API +func (_mock *S3API) ListMultipartUploads(listMultipartUploadsInput *s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error) { + ret := _mock.Called(listMultipartUploadsInput) + + if len(ret) == 0 { + panic("no return value specified for ListMultipartUploads") + } var r0 *s3.ListMultipartUploadsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error)); ok { + return returnFunc(listMultipartUploadsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput) *s3.ListMultipartUploadsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput) *s3.ListMultipartUploadsOutput); ok { + r0 = returnFunc(listMultipartUploadsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListMultipartUploadsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.ListMultipartUploadsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListMultipartUploadsInput) error); ok { + r1 = returnFunc(listMultipartUploadsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListMultipartUploadsPages provides a mock function with given fields: _a0, _a1 -func (_m *S3API) ListMultipartUploadsPages(_a0 *s3.ListMultipartUploadsInput, _a1 func(*s3.ListMultipartUploadsOutput, bool) bool) error { - ret := _m.Called(_a0, _a1) +// S3API_ListMultipartUploads_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMultipartUploads' +type S3API_ListMultipartUploads_Call struct { + *mock.Call +} + +// ListMultipartUploads is a helper method to define mock.On call +// - listMultipartUploadsInput *s3.ListMultipartUploadsInput +func (_e *S3API_Expecter) ListMultipartUploads(listMultipartUploadsInput interface{}) *S3API_ListMultipartUploads_Call { + return &S3API_ListMultipartUploads_Call{Call: _e.mock.On("ListMultipartUploads", listMultipartUploadsInput)} +} + +func (_c *S3API_ListMultipartUploads_Call) Run(run func(listMultipartUploadsInput *s3.ListMultipartUploadsInput)) *S3API_ListMultipartUploads_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListMultipartUploadsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListMultipartUploadsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListMultipartUploads_Call) Return(listMultipartUploadsOutput *s3.ListMultipartUploadsOutput, err error) *S3API_ListMultipartUploads_Call { + _c.Call.Return(listMultipartUploadsOutput, err) + return _c +} + +func (_c *S3API_ListMultipartUploads_Call) RunAndReturn(run func(listMultipartUploadsInput *s3.ListMultipartUploadsInput) (*s3.ListMultipartUploadsOutput, error)) *S3API_ListMultipartUploads_Call { + _c.Call.Return(run) + return _c +} + +// ListMultipartUploadsPages provides a mock function for the type S3API +func (_mock *S3API) ListMultipartUploadsPages(listMultipartUploadsInput *s3.ListMultipartUploadsInput, fn func(*s3.ListMultipartUploadsOutput, bool) bool) error { + ret := _mock.Called(listMultipartUploadsInput, fn) + + if len(ret) == 0 { + panic("no return value specified for ListMultipartUploadsPages") + } var r0 error - if rf, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool) error); ok { - r0 = rf(_a0, _a1) + if returnFunc, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool) error); ok { + r0 = returnFunc(listMultipartUploadsInput, fn) } else { r0 = ret.Error(0) } - return r0 } -// ListMultipartUploadsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 -func (_m *S3API) ListMultipartUploadsPagesWithContext(_a0 context.Context, _a1 *s3.ListMultipartUploadsInput, _a2 func(*s3.ListMultipartUploadsOutput, bool) bool, _a3 ...request.Option) error { - _va := make([]interface{}, len(_a3)) - for _i := range _a3 { - _va[_i] = _a3[_i] +// S3API_ListMultipartUploadsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMultipartUploadsPages' +type S3API_ListMultipartUploadsPages_Call struct { + *mock.Call +} + +// ListMultipartUploadsPages is a helper method to define mock.On call +// - listMultipartUploadsInput *s3.ListMultipartUploadsInput +// - fn func(*s3.ListMultipartUploadsOutput, bool) bool +func (_e *S3API_Expecter) ListMultipartUploadsPages(listMultipartUploadsInput interface{}, fn interface{}) *S3API_ListMultipartUploadsPages_Call { + return &S3API_ListMultipartUploadsPages_Call{Call: _e.mock.On("ListMultipartUploadsPages", listMultipartUploadsInput, fn)} +} + +func (_c *S3API_ListMultipartUploadsPages_Call) Run(run func(listMultipartUploadsInput *s3.ListMultipartUploadsInput, fn func(*s3.ListMultipartUploadsOutput, bool) bool)) *S3API_ListMultipartUploadsPages_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListMultipartUploadsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListMultipartUploadsInput) + } + var arg1 func(*s3.ListMultipartUploadsOutput, bool) bool + if args[1] != nil { + arg1 = args[1].(func(*s3.ListMultipartUploadsOutput, bool) bool) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *S3API_ListMultipartUploadsPages_Call) Return(err error) *S3API_ListMultipartUploadsPages_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_ListMultipartUploadsPages_Call) RunAndReturn(run func(listMultipartUploadsInput *s3.ListMultipartUploadsInput, fn func(*s3.ListMultipartUploadsOutput, bool) bool) error) *S3API_ListMultipartUploadsPages_Call { + _c.Call.Return(run) + return _c +} + +// ListMultipartUploadsPagesWithContext provides a mock function for the type S3API +func (_mock *S3API) ListMultipartUploadsPagesWithContext(v aws.Context, listMultipartUploadsInput *s3.ListMultipartUploadsInput, fn func(*s3.ListMultipartUploadsOutput, bool) bool, options ...request.Option) error { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listMultipartUploadsInput, fn, options) + } else { + tmpRet = _mock.Called(v, listMultipartUploadsInput, fn) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListMultipartUploadsPagesWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1, _a2) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool, ...request.Option) error); ok { - r0 = rf(_a0, _a1, _a2, _a3...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListMultipartUploadsInput, func(*s3.ListMultipartUploadsOutput, bool) bool, ...request.Option) error); ok { + r0 = returnFunc(v, listMultipartUploadsInput, fn, options...) } else { r0 = ret.Error(0) } - return r0 } -// ListMultipartUploadsRequest provides a mock function with given fields: _a0 -func (_m *S3API) ListMultipartUploadsRequest(_a0 *s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput) { - ret := _m.Called(_a0) +// S3API_ListMultipartUploadsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMultipartUploadsPagesWithContext' +type S3API_ListMultipartUploadsPagesWithContext_Call struct { + *mock.Call +} + +// ListMultipartUploadsPagesWithContext is a helper method to define mock.On call +// - v aws.Context +// - listMultipartUploadsInput *s3.ListMultipartUploadsInput +// - fn func(*s3.ListMultipartUploadsOutput, bool) bool +// - options ...request.Option +func (_e *S3API_Expecter) ListMultipartUploadsPagesWithContext(v interface{}, listMultipartUploadsInput interface{}, fn interface{}, options ...interface{}) *S3API_ListMultipartUploadsPagesWithContext_Call { + return &S3API_ListMultipartUploadsPagesWithContext_Call{Call: _e.mock.On("ListMultipartUploadsPagesWithContext", + append([]interface{}{v, listMultipartUploadsInput, fn}, options...)...)} +} + +func (_c *S3API_ListMultipartUploadsPagesWithContext_Call) Run(run func(v aws.Context, listMultipartUploadsInput *s3.ListMultipartUploadsInput, fn func(*s3.ListMultipartUploadsOutput, bool) bool, options ...request.Option)) *S3API_ListMultipartUploadsPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListMultipartUploadsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListMultipartUploadsInput) + } + var arg2 func(*s3.ListMultipartUploadsOutput, bool) bool + if args[2] != nil { + arg2 = args[2].(func(*s3.ListMultipartUploadsOutput, bool) bool) + } + var arg3 []request.Option + var variadicArgs []request.Option + if len(args) > 3 { + variadicArgs = args[3].([]request.Option) + } + arg3 = variadicArgs + run( + arg0, + arg1, + arg2, + arg3..., + ) + }) + return _c +} + +func (_c *S3API_ListMultipartUploadsPagesWithContext_Call) Return(err error) *S3API_ListMultipartUploadsPagesWithContext_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_ListMultipartUploadsPagesWithContext_Call) RunAndReturn(run func(v aws.Context, listMultipartUploadsInput *s3.ListMultipartUploadsInput, fn func(*s3.ListMultipartUploadsOutput, bool) bool, options ...request.Option) error) *S3API_ListMultipartUploadsPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListMultipartUploadsRequest provides a mock function for the type S3API +func (_mock *S3API) ListMultipartUploadsRequest(listMultipartUploadsInput *s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput) { + ret := _mock.Called(listMultipartUploadsInput) + + if len(ret) == 0 { + panic("no return value specified for ListMultipartUploadsRequest") + } var r0 *request.Request var r1 *s3.ListMultipartUploadsOutput - if rf, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput)); ok { + return returnFunc(listMultipartUploadsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListMultipartUploadsInput) *request.Request); ok { + r0 = returnFunc(listMultipartUploadsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.ListMultipartUploadsInput) *s3.ListMultipartUploadsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListMultipartUploadsInput) *s3.ListMultipartUploadsOutput); ok { + r1 = returnFunc(listMultipartUploadsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.ListMultipartUploadsOutput) } } - return r0, r1 } -// ListMultipartUploadsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) ListMultipartUploadsWithContext(_a0 context.Context, _a1 *s3.ListMultipartUploadsInput, _a2 ...request.Option) (*s3.ListMultipartUploadsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_ListMultipartUploadsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMultipartUploadsRequest' +type S3API_ListMultipartUploadsRequest_Call struct { + *mock.Call +} + +// ListMultipartUploadsRequest is a helper method to define mock.On call +// - listMultipartUploadsInput *s3.ListMultipartUploadsInput +func (_e *S3API_Expecter) ListMultipartUploadsRequest(listMultipartUploadsInput interface{}) *S3API_ListMultipartUploadsRequest_Call { + return &S3API_ListMultipartUploadsRequest_Call{Call: _e.mock.On("ListMultipartUploadsRequest", listMultipartUploadsInput)} +} + +func (_c *S3API_ListMultipartUploadsRequest_Call) Run(run func(listMultipartUploadsInput *s3.ListMultipartUploadsInput)) *S3API_ListMultipartUploadsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListMultipartUploadsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListMultipartUploadsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListMultipartUploadsRequest_Call) Return(request1 *request.Request, listMultipartUploadsOutput *s3.ListMultipartUploadsOutput) *S3API_ListMultipartUploadsRequest_Call { + _c.Call.Return(request1, listMultipartUploadsOutput) + return _c +} + +func (_c *S3API_ListMultipartUploadsRequest_Call) RunAndReturn(run func(listMultipartUploadsInput *s3.ListMultipartUploadsInput) (*request.Request, *s3.ListMultipartUploadsOutput)) *S3API_ListMultipartUploadsRequest_Call { + _c.Call.Return(run) + return _c +} + +// ListMultipartUploadsWithContext provides a mock function for the type S3API +func (_mock *S3API) ListMultipartUploadsWithContext(v aws.Context, listMultipartUploadsInput *s3.ListMultipartUploadsInput, options ...request.Option) (*s3.ListMultipartUploadsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listMultipartUploadsInput, options) + } else { + tmpRet = _mock.Called(v, listMultipartUploadsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListMultipartUploadsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.ListMultipartUploadsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListMultipartUploadsInput, ...request.Option) (*s3.ListMultipartUploadsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListMultipartUploadsInput, ...request.Option) (*s3.ListMultipartUploadsOutput, error)); ok { + return returnFunc(v, listMultipartUploadsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListMultipartUploadsInput, ...request.Option) *s3.ListMultipartUploadsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListMultipartUploadsInput, ...request.Option) *s3.ListMultipartUploadsOutput); ok { + r0 = returnFunc(v, listMultipartUploadsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListMultipartUploadsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.ListMultipartUploadsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.ListMultipartUploadsInput, ...request.Option) error); ok { + r1 = returnFunc(v, listMultipartUploadsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListObjectVersions provides a mock function with given fields: _a0 -func (_m *S3API) ListObjectVersions(_a0 *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error) { - ret := _m.Called(_a0) +// S3API_ListMultipartUploadsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListMultipartUploadsWithContext' +type S3API_ListMultipartUploadsWithContext_Call struct { + *mock.Call +} + +// ListMultipartUploadsWithContext is a helper method to define mock.On call +// - v aws.Context +// - listMultipartUploadsInput *s3.ListMultipartUploadsInput +// - options ...request.Option +func (_e *S3API_Expecter) ListMultipartUploadsWithContext(v interface{}, listMultipartUploadsInput interface{}, options ...interface{}) *S3API_ListMultipartUploadsWithContext_Call { + return &S3API_ListMultipartUploadsWithContext_Call{Call: _e.mock.On("ListMultipartUploadsWithContext", + append([]interface{}{v, listMultipartUploadsInput}, options...)...)} +} + +func (_c *S3API_ListMultipartUploadsWithContext_Call) Run(run func(v aws.Context, listMultipartUploadsInput *s3.ListMultipartUploadsInput, options ...request.Option)) *S3API_ListMultipartUploadsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListMultipartUploadsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListMultipartUploadsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_ListMultipartUploadsWithContext_Call) Return(listMultipartUploadsOutput *s3.ListMultipartUploadsOutput, err error) *S3API_ListMultipartUploadsWithContext_Call { + _c.Call.Return(listMultipartUploadsOutput, err) + return _c +} + +func (_c *S3API_ListMultipartUploadsWithContext_Call) RunAndReturn(run func(v aws.Context, listMultipartUploadsInput *s3.ListMultipartUploadsInput, options ...request.Option) (*s3.ListMultipartUploadsOutput, error)) *S3API_ListMultipartUploadsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListObjectVersions provides a mock function for the type S3API +func (_mock *S3API) ListObjectVersions(listObjectVersionsInput *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error) { + ret := _mock.Called(listObjectVersionsInput) + + if len(ret) == 0 { + panic("no return value specified for ListObjectVersions") + } var r0 *s3.ListObjectVersionsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error)); ok { + return returnFunc(listObjectVersionsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput) *s3.ListObjectVersionsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput) *s3.ListObjectVersionsOutput); ok { + r0 = returnFunc(listObjectVersionsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListObjectVersionsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.ListObjectVersionsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListObjectVersionsInput) error); ok { + r1 = returnFunc(listObjectVersionsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListObjectVersionsPages provides a mock function with given fields: _a0, _a1 -func (_m *S3API) ListObjectVersionsPages(_a0 *s3.ListObjectVersionsInput, _a1 func(*s3.ListObjectVersionsOutput, bool) bool) error { - ret := _m.Called(_a0, _a1) +// S3API_ListObjectVersions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectVersions' +type S3API_ListObjectVersions_Call struct { + *mock.Call +} + +// ListObjectVersions is a helper method to define mock.On call +// - listObjectVersionsInput *s3.ListObjectVersionsInput +func (_e *S3API_Expecter) ListObjectVersions(listObjectVersionsInput interface{}) *S3API_ListObjectVersions_Call { + return &S3API_ListObjectVersions_Call{Call: _e.mock.On("ListObjectVersions", listObjectVersionsInput)} +} + +func (_c *S3API_ListObjectVersions_Call) Run(run func(listObjectVersionsInput *s3.ListObjectVersionsInput)) *S3API_ListObjectVersions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListObjectVersionsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListObjectVersionsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListObjectVersions_Call) Return(listObjectVersionsOutput *s3.ListObjectVersionsOutput, err error) *S3API_ListObjectVersions_Call { + _c.Call.Return(listObjectVersionsOutput, err) + return _c +} + +func (_c *S3API_ListObjectVersions_Call) RunAndReturn(run func(listObjectVersionsInput *s3.ListObjectVersionsInput) (*s3.ListObjectVersionsOutput, error)) *S3API_ListObjectVersions_Call { + _c.Call.Return(run) + return _c +} + +// ListObjectVersionsPages provides a mock function for the type S3API +func (_mock *S3API) ListObjectVersionsPages(listObjectVersionsInput *s3.ListObjectVersionsInput, fn func(*s3.ListObjectVersionsOutput, bool) bool) error { + ret := _mock.Called(listObjectVersionsInput, fn) + + if len(ret) == 0 { + panic("no return value specified for ListObjectVersionsPages") + } var r0 error - if rf, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool) error); ok { - r0 = rf(_a0, _a1) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool) error); ok { + r0 = returnFunc(listObjectVersionsInput, fn) } else { r0 = ret.Error(0) } - return r0 } -// ListObjectVersionsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 -func (_m *S3API) ListObjectVersionsPagesWithContext(_a0 context.Context, _a1 *s3.ListObjectVersionsInput, _a2 func(*s3.ListObjectVersionsOutput, bool) bool, _a3 ...request.Option) error { - _va := make([]interface{}, len(_a3)) - for _i := range _a3 { - _va[_i] = _a3[_i] +// S3API_ListObjectVersionsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectVersionsPages' +type S3API_ListObjectVersionsPages_Call struct { + *mock.Call +} + +// ListObjectVersionsPages is a helper method to define mock.On call +// - listObjectVersionsInput *s3.ListObjectVersionsInput +// - fn func(*s3.ListObjectVersionsOutput, bool) bool +func (_e *S3API_Expecter) ListObjectVersionsPages(listObjectVersionsInput interface{}, fn interface{}) *S3API_ListObjectVersionsPages_Call { + return &S3API_ListObjectVersionsPages_Call{Call: _e.mock.On("ListObjectVersionsPages", listObjectVersionsInput, fn)} +} + +func (_c *S3API_ListObjectVersionsPages_Call) Run(run func(listObjectVersionsInput *s3.ListObjectVersionsInput, fn func(*s3.ListObjectVersionsOutput, bool) bool)) *S3API_ListObjectVersionsPages_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListObjectVersionsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListObjectVersionsInput) + } + var arg1 func(*s3.ListObjectVersionsOutput, bool) bool + if args[1] != nil { + arg1 = args[1].(func(*s3.ListObjectVersionsOutput, bool) bool) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *S3API_ListObjectVersionsPages_Call) Return(err error) *S3API_ListObjectVersionsPages_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_ListObjectVersionsPages_Call) RunAndReturn(run func(listObjectVersionsInput *s3.ListObjectVersionsInput, fn func(*s3.ListObjectVersionsOutput, bool) bool) error) *S3API_ListObjectVersionsPages_Call { + _c.Call.Return(run) + return _c +} + +// ListObjectVersionsPagesWithContext provides a mock function for the type S3API +func (_mock *S3API) ListObjectVersionsPagesWithContext(v aws.Context, listObjectVersionsInput *s3.ListObjectVersionsInput, fn func(*s3.ListObjectVersionsOutput, bool) bool, options ...request.Option) error { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listObjectVersionsInput, fn, options) + } else { + tmpRet = _mock.Called(v, listObjectVersionsInput, fn) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListObjectVersionsPagesWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1, _a2) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool, ...request.Option) error); ok { - r0 = rf(_a0, _a1, _a2, _a3...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectVersionsInput, func(*s3.ListObjectVersionsOutput, bool) bool, ...request.Option) error); ok { + r0 = returnFunc(v, listObjectVersionsInput, fn, options...) } else { r0 = ret.Error(0) } - return r0 } -// ListObjectVersionsRequest provides a mock function with given fields: _a0 -func (_m *S3API) ListObjectVersionsRequest(_a0 *s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput) { - ret := _m.Called(_a0) +// S3API_ListObjectVersionsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectVersionsPagesWithContext' +type S3API_ListObjectVersionsPagesWithContext_Call struct { + *mock.Call +} + +// ListObjectVersionsPagesWithContext is a helper method to define mock.On call +// - v aws.Context +// - listObjectVersionsInput *s3.ListObjectVersionsInput +// - fn func(*s3.ListObjectVersionsOutput, bool) bool +// - options ...request.Option +func (_e *S3API_Expecter) ListObjectVersionsPagesWithContext(v interface{}, listObjectVersionsInput interface{}, fn interface{}, options ...interface{}) *S3API_ListObjectVersionsPagesWithContext_Call { + return &S3API_ListObjectVersionsPagesWithContext_Call{Call: _e.mock.On("ListObjectVersionsPagesWithContext", + append([]interface{}{v, listObjectVersionsInput, fn}, options...)...)} +} + +func (_c *S3API_ListObjectVersionsPagesWithContext_Call) Run(run func(v aws.Context, listObjectVersionsInput *s3.ListObjectVersionsInput, fn func(*s3.ListObjectVersionsOutput, bool) bool, options ...request.Option)) *S3API_ListObjectVersionsPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListObjectVersionsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListObjectVersionsInput) + } + var arg2 func(*s3.ListObjectVersionsOutput, bool) bool + if args[2] != nil { + arg2 = args[2].(func(*s3.ListObjectVersionsOutput, bool) bool) + } + var arg3 []request.Option + var variadicArgs []request.Option + if len(args) > 3 { + variadicArgs = args[3].([]request.Option) + } + arg3 = variadicArgs + run( + arg0, + arg1, + arg2, + arg3..., + ) + }) + return _c +} + +func (_c *S3API_ListObjectVersionsPagesWithContext_Call) Return(err error) *S3API_ListObjectVersionsPagesWithContext_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_ListObjectVersionsPagesWithContext_Call) RunAndReturn(run func(v aws.Context, listObjectVersionsInput *s3.ListObjectVersionsInput, fn func(*s3.ListObjectVersionsOutput, bool) bool, options ...request.Option) error) *S3API_ListObjectVersionsPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListObjectVersionsRequest provides a mock function for the type S3API +func (_mock *S3API) ListObjectVersionsRequest(listObjectVersionsInput *s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput) { + ret := _mock.Called(listObjectVersionsInput) + + if len(ret) == 0 { + panic("no return value specified for ListObjectVersionsRequest") + } var r0 *request.Request var r1 *s3.ListObjectVersionsOutput - if rf, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput)); ok { + return returnFunc(listObjectVersionsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectVersionsInput) *request.Request); ok { + r0 = returnFunc(listObjectVersionsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.ListObjectVersionsInput) *s3.ListObjectVersionsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListObjectVersionsInput) *s3.ListObjectVersionsOutput); ok { + r1 = returnFunc(listObjectVersionsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.ListObjectVersionsOutput) } } - return r0, r1 } -// ListObjectVersionsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) ListObjectVersionsWithContext(_a0 context.Context, _a1 *s3.ListObjectVersionsInput, _a2 ...request.Option) (*s3.ListObjectVersionsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_ListObjectVersionsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectVersionsRequest' +type S3API_ListObjectVersionsRequest_Call struct { + *mock.Call +} + +// ListObjectVersionsRequest is a helper method to define mock.On call +// - listObjectVersionsInput *s3.ListObjectVersionsInput +func (_e *S3API_Expecter) ListObjectVersionsRequest(listObjectVersionsInput interface{}) *S3API_ListObjectVersionsRequest_Call { + return &S3API_ListObjectVersionsRequest_Call{Call: _e.mock.On("ListObjectVersionsRequest", listObjectVersionsInput)} +} + +func (_c *S3API_ListObjectVersionsRequest_Call) Run(run func(listObjectVersionsInput *s3.ListObjectVersionsInput)) *S3API_ListObjectVersionsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListObjectVersionsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListObjectVersionsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListObjectVersionsRequest_Call) Return(request1 *request.Request, listObjectVersionsOutput *s3.ListObjectVersionsOutput) *S3API_ListObjectVersionsRequest_Call { + _c.Call.Return(request1, listObjectVersionsOutput) + return _c +} + +func (_c *S3API_ListObjectVersionsRequest_Call) RunAndReturn(run func(listObjectVersionsInput *s3.ListObjectVersionsInput) (*request.Request, *s3.ListObjectVersionsOutput)) *S3API_ListObjectVersionsRequest_Call { + _c.Call.Return(run) + return _c +} + +// ListObjectVersionsWithContext provides a mock function for the type S3API +func (_mock *S3API) ListObjectVersionsWithContext(v aws.Context, listObjectVersionsInput *s3.ListObjectVersionsInput, options ...request.Option) (*s3.ListObjectVersionsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listObjectVersionsInput, options) + } else { + tmpRet = _mock.Called(v, listObjectVersionsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListObjectVersionsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.ListObjectVersionsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectVersionsInput, ...request.Option) (*s3.ListObjectVersionsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectVersionsInput, ...request.Option) (*s3.ListObjectVersionsOutput, error)); ok { + return returnFunc(v, listObjectVersionsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectVersionsInput, ...request.Option) *s3.ListObjectVersionsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectVersionsInput, ...request.Option) *s3.ListObjectVersionsOutput); ok { + r0 = returnFunc(v, listObjectVersionsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListObjectVersionsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.ListObjectVersionsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.ListObjectVersionsInput, ...request.Option) error); ok { + r1 = returnFunc(v, listObjectVersionsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListObjects provides a mock function with given fields: _a0 -func (_m *S3API) ListObjects(_a0 *s3.ListObjectsInput) (*s3.ListObjectsOutput, error) { - ret := _m.Called(_a0) +// S3API_ListObjectVersionsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectVersionsWithContext' +type S3API_ListObjectVersionsWithContext_Call struct { + *mock.Call +} + +// ListObjectVersionsWithContext is a helper method to define mock.On call +// - v aws.Context +// - listObjectVersionsInput *s3.ListObjectVersionsInput +// - options ...request.Option +func (_e *S3API_Expecter) ListObjectVersionsWithContext(v interface{}, listObjectVersionsInput interface{}, options ...interface{}) *S3API_ListObjectVersionsWithContext_Call { + return &S3API_ListObjectVersionsWithContext_Call{Call: _e.mock.On("ListObjectVersionsWithContext", + append([]interface{}{v, listObjectVersionsInput}, options...)...)} +} + +func (_c *S3API_ListObjectVersionsWithContext_Call) Run(run func(v aws.Context, listObjectVersionsInput *s3.ListObjectVersionsInput, options ...request.Option)) *S3API_ListObjectVersionsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListObjectVersionsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListObjectVersionsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_ListObjectVersionsWithContext_Call) Return(listObjectVersionsOutput *s3.ListObjectVersionsOutput, err error) *S3API_ListObjectVersionsWithContext_Call { + _c.Call.Return(listObjectVersionsOutput, err) + return _c +} + +func (_c *S3API_ListObjectVersionsWithContext_Call) RunAndReturn(run func(v aws.Context, listObjectVersionsInput *s3.ListObjectVersionsInput, options ...request.Option) (*s3.ListObjectVersionsOutput, error)) *S3API_ListObjectVersionsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListObjects provides a mock function for the type S3API +func (_mock *S3API) ListObjects(listObjectsInput *s3.ListObjectsInput) (*s3.ListObjectsOutput, error) { + ret := _mock.Called(listObjectsInput) + + if len(ret) == 0 { + panic("no return value specified for ListObjects") + } var r0 *s3.ListObjectsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.ListObjectsInput) (*s3.ListObjectsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectsInput) (*s3.ListObjectsOutput, error)); ok { + return returnFunc(listObjectsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListObjectsInput) *s3.ListObjectsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectsInput) *s3.ListObjectsOutput); ok { + r0 = returnFunc(listObjectsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListObjectsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.ListObjectsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListObjectsInput) error); ok { + r1 = returnFunc(listObjectsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListObjectsPages provides a mock function with given fields: _a0, _a1 -func (_m *S3API) ListObjectsPages(_a0 *s3.ListObjectsInput, _a1 func(*s3.ListObjectsOutput, bool) bool) error { - ret := _m.Called(_a0, _a1) +// S3API_ListObjects_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjects' +type S3API_ListObjects_Call struct { + *mock.Call +} + +// ListObjects is a helper method to define mock.On call +// - listObjectsInput *s3.ListObjectsInput +func (_e *S3API_Expecter) ListObjects(listObjectsInput interface{}) *S3API_ListObjects_Call { + return &S3API_ListObjects_Call{Call: _e.mock.On("ListObjects", listObjectsInput)} +} + +func (_c *S3API_ListObjects_Call) Run(run func(listObjectsInput *s3.ListObjectsInput)) *S3API_ListObjects_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListObjectsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListObjectsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListObjects_Call) Return(listObjectsOutput *s3.ListObjectsOutput, err error) *S3API_ListObjects_Call { + _c.Call.Return(listObjectsOutput, err) + return _c +} + +func (_c *S3API_ListObjects_Call) RunAndReturn(run func(listObjectsInput *s3.ListObjectsInput) (*s3.ListObjectsOutput, error)) *S3API_ListObjects_Call { + _c.Call.Return(run) + return _c +} + +// ListObjectsPages provides a mock function for the type S3API +func (_mock *S3API) ListObjectsPages(listObjectsInput *s3.ListObjectsInput, fn func(*s3.ListObjectsOutput, bool) bool) error { + ret := _mock.Called(listObjectsInput, fn) + + if len(ret) == 0 { + panic("no return value specified for ListObjectsPages") + } var r0 error - if rf, ok := ret.Get(0).(func(*s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool) error); ok { - r0 = rf(_a0, _a1) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool) error); ok { + r0 = returnFunc(listObjectsInput, fn) } else { r0 = ret.Error(0) } - return r0 } -// ListObjectsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 -func (_m *S3API) ListObjectsPagesWithContext(_a0 context.Context, _a1 *s3.ListObjectsInput, _a2 func(*s3.ListObjectsOutput, bool) bool, _a3 ...request.Option) error { - _va := make([]interface{}, len(_a3)) - for _i := range _a3 { - _va[_i] = _a3[_i] +// S3API_ListObjectsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsPages' +type S3API_ListObjectsPages_Call struct { + *mock.Call +} + +// ListObjectsPages is a helper method to define mock.On call +// - listObjectsInput *s3.ListObjectsInput +// - fn func(*s3.ListObjectsOutput, bool) bool +func (_e *S3API_Expecter) ListObjectsPages(listObjectsInput interface{}, fn interface{}) *S3API_ListObjectsPages_Call { + return &S3API_ListObjectsPages_Call{Call: _e.mock.On("ListObjectsPages", listObjectsInput, fn)} +} + +func (_c *S3API_ListObjectsPages_Call) Run(run func(listObjectsInput *s3.ListObjectsInput, fn func(*s3.ListObjectsOutput, bool) bool)) *S3API_ListObjectsPages_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListObjectsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListObjectsInput) + } + var arg1 func(*s3.ListObjectsOutput, bool) bool + if args[1] != nil { + arg1 = args[1].(func(*s3.ListObjectsOutput, bool) bool) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *S3API_ListObjectsPages_Call) Return(err error) *S3API_ListObjectsPages_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_ListObjectsPages_Call) RunAndReturn(run func(listObjectsInput *s3.ListObjectsInput, fn func(*s3.ListObjectsOutput, bool) bool) error) *S3API_ListObjectsPages_Call { + _c.Call.Return(run) + return _c +} + +// ListObjectsPagesWithContext provides a mock function for the type S3API +func (_mock *S3API) ListObjectsPagesWithContext(v aws.Context, listObjectsInput *s3.ListObjectsInput, fn func(*s3.ListObjectsOutput, bool) bool, options ...request.Option) error { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listObjectsInput, fn, options) + } else { + tmpRet = _mock.Called(v, listObjectsInput, fn) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListObjectsPagesWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1, _a2) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool, ...request.Option) error); ok { - r0 = rf(_a0, _a1, _a2, _a3...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectsInput, func(*s3.ListObjectsOutput, bool) bool, ...request.Option) error); ok { + r0 = returnFunc(v, listObjectsInput, fn, options...) } else { r0 = ret.Error(0) } - return r0 } -// ListObjectsRequest provides a mock function with given fields: _a0 -func (_m *S3API) ListObjectsRequest(_a0 *s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput) { - ret := _m.Called(_a0) +// S3API_ListObjectsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsPagesWithContext' +type S3API_ListObjectsPagesWithContext_Call struct { + *mock.Call +} + +// ListObjectsPagesWithContext is a helper method to define mock.On call +// - v aws.Context +// - listObjectsInput *s3.ListObjectsInput +// - fn func(*s3.ListObjectsOutput, bool) bool +// - options ...request.Option +func (_e *S3API_Expecter) ListObjectsPagesWithContext(v interface{}, listObjectsInput interface{}, fn interface{}, options ...interface{}) *S3API_ListObjectsPagesWithContext_Call { + return &S3API_ListObjectsPagesWithContext_Call{Call: _e.mock.On("ListObjectsPagesWithContext", + append([]interface{}{v, listObjectsInput, fn}, options...)...)} +} + +func (_c *S3API_ListObjectsPagesWithContext_Call) Run(run func(v aws.Context, listObjectsInput *s3.ListObjectsInput, fn func(*s3.ListObjectsOutput, bool) bool, options ...request.Option)) *S3API_ListObjectsPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListObjectsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListObjectsInput) + } + var arg2 func(*s3.ListObjectsOutput, bool) bool + if args[2] != nil { + arg2 = args[2].(func(*s3.ListObjectsOutput, bool) bool) + } + var arg3 []request.Option + var variadicArgs []request.Option + if len(args) > 3 { + variadicArgs = args[3].([]request.Option) + } + arg3 = variadicArgs + run( + arg0, + arg1, + arg2, + arg3..., + ) + }) + return _c +} + +func (_c *S3API_ListObjectsPagesWithContext_Call) Return(err error) *S3API_ListObjectsPagesWithContext_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_ListObjectsPagesWithContext_Call) RunAndReturn(run func(v aws.Context, listObjectsInput *s3.ListObjectsInput, fn func(*s3.ListObjectsOutput, bool) bool, options ...request.Option) error) *S3API_ListObjectsPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListObjectsRequest provides a mock function for the type S3API +func (_mock *S3API) ListObjectsRequest(listObjectsInput *s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput) { + ret := _mock.Called(listObjectsInput) + + if len(ret) == 0 { + panic("no return value specified for ListObjectsRequest") + } var r0 *request.Request var r1 *s3.ListObjectsOutput - if rf, ok := ret.Get(0).(func(*s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput)); ok { + return returnFunc(listObjectsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListObjectsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectsInput) *request.Request); ok { + r0 = returnFunc(listObjectsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.ListObjectsInput) *s3.ListObjectsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListObjectsInput) *s3.ListObjectsOutput); ok { + r1 = returnFunc(listObjectsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.ListObjectsOutput) } } - return r0, r1 } -// ListObjectsV2 provides a mock function with given fields: _a0 -func (_m *S3API) ListObjectsV2(_a0 *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error) { - ret := _m.Called(_a0) +// S3API_ListObjectsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsRequest' +type S3API_ListObjectsRequest_Call struct { + *mock.Call +} + +// ListObjectsRequest is a helper method to define mock.On call +// - listObjectsInput *s3.ListObjectsInput +func (_e *S3API_Expecter) ListObjectsRequest(listObjectsInput interface{}) *S3API_ListObjectsRequest_Call { + return &S3API_ListObjectsRequest_Call{Call: _e.mock.On("ListObjectsRequest", listObjectsInput)} +} + +func (_c *S3API_ListObjectsRequest_Call) Run(run func(listObjectsInput *s3.ListObjectsInput)) *S3API_ListObjectsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListObjectsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListObjectsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListObjectsRequest_Call) Return(request1 *request.Request, listObjectsOutput *s3.ListObjectsOutput) *S3API_ListObjectsRequest_Call { + _c.Call.Return(request1, listObjectsOutput) + return _c +} + +func (_c *S3API_ListObjectsRequest_Call) RunAndReturn(run func(listObjectsInput *s3.ListObjectsInput) (*request.Request, *s3.ListObjectsOutput)) *S3API_ListObjectsRequest_Call { + _c.Call.Return(run) + return _c +} + +// ListObjectsV2 provides a mock function for the type S3API +func (_mock *S3API) ListObjectsV2(listObjectsV2Input *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error) { + ret := _mock.Called(listObjectsV2Input) + + if len(ret) == 0 { + panic("no return value specified for ListObjectsV2") + } var r0 *s3.ListObjectsV2Output var r1 error - if rf, ok := ret.Get(0).(func(*s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error)); ok { + return returnFunc(listObjectsV2Input) } - if rf, ok := ret.Get(0).(func(*s3.ListObjectsV2Input) *s3.ListObjectsV2Output); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectsV2Input) *s3.ListObjectsV2Output); ok { + r0 = returnFunc(listObjectsV2Input) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListObjectsV2Output) } } - - if rf, ok := ret.Get(1).(func(*s3.ListObjectsV2Input) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListObjectsV2Input) error); ok { + r1 = returnFunc(listObjectsV2Input) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListObjectsV2Pages provides a mock function with given fields: _a0, _a1 -func (_m *S3API) ListObjectsV2Pages(_a0 *s3.ListObjectsV2Input, _a1 func(*s3.ListObjectsV2Output, bool) bool) error { - ret := _m.Called(_a0, _a1) +// S3API_ListObjectsV2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsV2' +type S3API_ListObjectsV2_Call struct { + *mock.Call +} + +// ListObjectsV2 is a helper method to define mock.On call +// - listObjectsV2Input *s3.ListObjectsV2Input +func (_e *S3API_Expecter) ListObjectsV2(listObjectsV2Input interface{}) *S3API_ListObjectsV2_Call { + return &S3API_ListObjectsV2_Call{Call: _e.mock.On("ListObjectsV2", listObjectsV2Input)} +} + +func (_c *S3API_ListObjectsV2_Call) Run(run func(listObjectsV2Input *s3.ListObjectsV2Input)) *S3API_ListObjectsV2_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListObjectsV2Input + if args[0] != nil { + arg0 = args[0].(*s3.ListObjectsV2Input) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListObjectsV2_Call) Return(listObjectsV2Output *s3.ListObjectsV2Output, err error) *S3API_ListObjectsV2_Call { + _c.Call.Return(listObjectsV2Output, err) + return _c +} + +func (_c *S3API_ListObjectsV2_Call) RunAndReturn(run func(listObjectsV2Input *s3.ListObjectsV2Input) (*s3.ListObjectsV2Output, error)) *S3API_ListObjectsV2_Call { + _c.Call.Return(run) + return _c +} + +// ListObjectsV2Pages provides a mock function for the type S3API +func (_mock *S3API) ListObjectsV2Pages(listObjectsV2Input *s3.ListObjectsV2Input, fn func(*s3.ListObjectsV2Output, bool) bool) error { + ret := _mock.Called(listObjectsV2Input, fn) + + if len(ret) == 0 { + panic("no return value specified for ListObjectsV2Pages") + } var r0 error - if rf, ok := ret.Get(0).(func(*s3.ListObjectsV2Input, func(*s3.ListObjectsV2Output, bool) bool) error); ok { - r0 = rf(_a0, _a1) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectsV2Input, func(*s3.ListObjectsV2Output, bool) bool) error); ok { + r0 = returnFunc(listObjectsV2Input, fn) } else { r0 = ret.Error(0) } - return r0 } -// ListObjectsV2PagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 -func (_m *S3API) ListObjectsV2PagesWithContext(_a0 context.Context, _a1 *s3.ListObjectsV2Input, _a2 func(*s3.ListObjectsV2Output, bool) bool, _a3 ...request.Option) error { - _va := make([]interface{}, len(_a3)) - for _i := range _a3 { - _va[_i] = _a3[_i] +// S3API_ListObjectsV2Pages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsV2Pages' +type S3API_ListObjectsV2Pages_Call struct { + *mock.Call +} + +// ListObjectsV2Pages is a helper method to define mock.On call +// - listObjectsV2Input *s3.ListObjectsV2Input +// - fn func(*s3.ListObjectsV2Output, bool) bool +func (_e *S3API_Expecter) ListObjectsV2Pages(listObjectsV2Input interface{}, fn interface{}) *S3API_ListObjectsV2Pages_Call { + return &S3API_ListObjectsV2Pages_Call{Call: _e.mock.On("ListObjectsV2Pages", listObjectsV2Input, fn)} +} + +func (_c *S3API_ListObjectsV2Pages_Call) Run(run func(listObjectsV2Input *s3.ListObjectsV2Input, fn func(*s3.ListObjectsV2Output, bool) bool)) *S3API_ListObjectsV2Pages_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListObjectsV2Input + if args[0] != nil { + arg0 = args[0].(*s3.ListObjectsV2Input) + } + var arg1 func(*s3.ListObjectsV2Output, bool) bool + if args[1] != nil { + arg1 = args[1].(func(*s3.ListObjectsV2Output, bool) bool) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *S3API_ListObjectsV2Pages_Call) Return(err error) *S3API_ListObjectsV2Pages_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_ListObjectsV2Pages_Call) RunAndReturn(run func(listObjectsV2Input *s3.ListObjectsV2Input, fn func(*s3.ListObjectsV2Output, bool) bool) error) *S3API_ListObjectsV2Pages_Call { + _c.Call.Return(run) + return _c +} + +// ListObjectsV2PagesWithContext provides a mock function for the type S3API +func (_mock *S3API) ListObjectsV2PagesWithContext(v aws.Context, listObjectsV2Input *s3.ListObjectsV2Input, fn func(*s3.ListObjectsV2Output, bool) bool, options ...request.Option) error { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listObjectsV2Input, fn, options) + } else { + tmpRet = _mock.Called(v, listObjectsV2Input, fn) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListObjectsV2PagesWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1, _a2) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectsV2Input, func(*s3.ListObjectsV2Output, bool) bool, ...request.Option) error); ok { - r0 = rf(_a0, _a1, _a2, _a3...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectsV2Input, func(*s3.ListObjectsV2Output, bool) bool, ...request.Option) error); ok { + r0 = returnFunc(v, listObjectsV2Input, fn, options...) } else { r0 = ret.Error(0) } - return r0 } -// ListObjectsV2Request provides a mock function with given fields: _a0 -func (_m *S3API) ListObjectsV2Request(_a0 *s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output) { - ret := _m.Called(_a0) +// S3API_ListObjectsV2PagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsV2PagesWithContext' +type S3API_ListObjectsV2PagesWithContext_Call struct { + *mock.Call +} + +// ListObjectsV2PagesWithContext is a helper method to define mock.On call +// - v aws.Context +// - listObjectsV2Input *s3.ListObjectsV2Input +// - fn func(*s3.ListObjectsV2Output, bool) bool +// - options ...request.Option +func (_e *S3API_Expecter) ListObjectsV2PagesWithContext(v interface{}, listObjectsV2Input interface{}, fn interface{}, options ...interface{}) *S3API_ListObjectsV2PagesWithContext_Call { + return &S3API_ListObjectsV2PagesWithContext_Call{Call: _e.mock.On("ListObjectsV2PagesWithContext", + append([]interface{}{v, listObjectsV2Input, fn}, options...)...)} +} + +func (_c *S3API_ListObjectsV2PagesWithContext_Call) Run(run func(v aws.Context, listObjectsV2Input *s3.ListObjectsV2Input, fn func(*s3.ListObjectsV2Output, bool) bool, options ...request.Option)) *S3API_ListObjectsV2PagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListObjectsV2Input + if args[1] != nil { + arg1 = args[1].(*s3.ListObjectsV2Input) + } + var arg2 func(*s3.ListObjectsV2Output, bool) bool + if args[2] != nil { + arg2 = args[2].(func(*s3.ListObjectsV2Output, bool) bool) + } + var arg3 []request.Option + var variadicArgs []request.Option + if len(args) > 3 { + variadicArgs = args[3].([]request.Option) + } + arg3 = variadicArgs + run( + arg0, + arg1, + arg2, + arg3..., + ) + }) + return _c +} + +func (_c *S3API_ListObjectsV2PagesWithContext_Call) Return(err error) *S3API_ListObjectsV2PagesWithContext_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_ListObjectsV2PagesWithContext_Call) RunAndReturn(run func(v aws.Context, listObjectsV2Input *s3.ListObjectsV2Input, fn func(*s3.ListObjectsV2Output, bool) bool, options ...request.Option) error) *S3API_ListObjectsV2PagesWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListObjectsV2Request provides a mock function for the type S3API +func (_mock *S3API) ListObjectsV2Request(listObjectsV2Input *s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output) { + ret := _mock.Called(listObjectsV2Input) + + if len(ret) == 0 { + panic("no return value specified for ListObjectsV2Request") + } var r0 *request.Request var r1 *s3.ListObjectsV2Output - if rf, ok := ret.Get(0).(func(*s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output)); ok { + return returnFunc(listObjectsV2Input) } - if rf, ok := ret.Get(0).(func(*s3.ListObjectsV2Input) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListObjectsV2Input) *request.Request); ok { + r0 = returnFunc(listObjectsV2Input) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.ListObjectsV2Input) *s3.ListObjectsV2Output); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListObjectsV2Input) *s3.ListObjectsV2Output); ok { + r1 = returnFunc(listObjectsV2Input) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.ListObjectsV2Output) } } - return r0, r1 } -// ListObjectsV2WithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) ListObjectsV2WithContext(_a0 context.Context, _a1 *s3.ListObjectsV2Input, _a2 ...request.Option) (*s3.ListObjectsV2Output, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_ListObjectsV2Request_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsV2Request' +type S3API_ListObjectsV2Request_Call struct { + *mock.Call +} + +// ListObjectsV2Request is a helper method to define mock.On call +// - listObjectsV2Input *s3.ListObjectsV2Input +func (_e *S3API_Expecter) ListObjectsV2Request(listObjectsV2Input interface{}) *S3API_ListObjectsV2Request_Call { + return &S3API_ListObjectsV2Request_Call{Call: _e.mock.On("ListObjectsV2Request", listObjectsV2Input)} +} + +func (_c *S3API_ListObjectsV2Request_Call) Run(run func(listObjectsV2Input *s3.ListObjectsV2Input)) *S3API_ListObjectsV2Request_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListObjectsV2Input + if args[0] != nil { + arg0 = args[0].(*s3.ListObjectsV2Input) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListObjectsV2Request_Call) Return(request1 *request.Request, listObjectsV2Output *s3.ListObjectsV2Output) *S3API_ListObjectsV2Request_Call { + _c.Call.Return(request1, listObjectsV2Output) + return _c +} + +func (_c *S3API_ListObjectsV2Request_Call) RunAndReturn(run func(listObjectsV2Input *s3.ListObjectsV2Input) (*request.Request, *s3.ListObjectsV2Output)) *S3API_ListObjectsV2Request_Call { + _c.Call.Return(run) + return _c +} + +// ListObjectsV2WithContext provides a mock function for the type S3API +func (_mock *S3API) ListObjectsV2WithContext(v aws.Context, listObjectsV2Input *s3.ListObjectsV2Input, options ...request.Option) (*s3.ListObjectsV2Output, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listObjectsV2Input, options) + } else { + tmpRet = _mock.Called(v, listObjectsV2Input) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListObjectsV2WithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.ListObjectsV2Output var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectsV2Input, ...request.Option) (*s3.ListObjectsV2Output, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectsV2Input, ...request.Option) (*s3.ListObjectsV2Output, error)); ok { + return returnFunc(v, listObjectsV2Input, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectsV2Input, ...request.Option) *s3.ListObjectsV2Output); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectsV2Input, ...request.Option) *s3.ListObjectsV2Output); ok { + r0 = returnFunc(v, listObjectsV2Input, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListObjectsV2Output) } } + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.ListObjectsV2Input, ...request.Option) error); ok { + r1 = returnFunc(v, listObjectsV2Input, options...) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// S3API_ListObjectsV2WithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsV2WithContext' +type S3API_ListObjectsV2WithContext_Call struct { + *mock.Call +} + +// ListObjectsV2WithContext is a helper method to define mock.On call +// - v aws.Context +// - listObjectsV2Input *s3.ListObjectsV2Input +// - options ...request.Option +func (_e *S3API_Expecter) ListObjectsV2WithContext(v interface{}, listObjectsV2Input interface{}, options ...interface{}) *S3API_ListObjectsV2WithContext_Call { + return &S3API_ListObjectsV2WithContext_Call{Call: _e.mock.On("ListObjectsV2WithContext", + append([]interface{}{v, listObjectsV2Input}, options...)...)} +} + +func (_c *S3API_ListObjectsV2WithContext_Call) Run(run func(v aws.Context, listObjectsV2Input *s3.ListObjectsV2Input, options ...request.Option)) *S3API_ListObjectsV2WithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListObjectsV2Input + if args[1] != nil { + arg1 = args[1].(*s3.ListObjectsV2Input) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_ListObjectsV2WithContext_Call) Return(listObjectsV2Output *s3.ListObjectsV2Output, err error) *S3API_ListObjectsV2WithContext_Call { + _c.Call.Return(listObjectsV2Output, err) + return _c +} + +func (_c *S3API_ListObjectsV2WithContext_Call) RunAndReturn(run func(v aws.Context, listObjectsV2Input *s3.ListObjectsV2Input, options ...request.Option) (*s3.ListObjectsV2Output, error)) *S3API_ListObjectsV2WithContext_Call { + _c.Call.Return(run) + return _c +} - if rf, ok := ret.Get(1).(func(context.Context, *s3.ListObjectsV2Input, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) +// ListObjectsWithContext provides a mock function for the type S3API +func (_mock *S3API) ListObjectsWithContext(v aws.Context, listObjectsInput *s3.ListObjectsInput, options ...request.Option) (*s3.ListObjectsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listObjectsInput, options) } else { - r1 = ret.Error(1) + tmpRet = _mock.Called(v, listObjectsInput) } + ret := tmpRet - return r0, r1 -} - -// ListObjectsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) ListObjectsWithContext(_a0 context.Context, _a1 *s3.ListObjectsInput, _a2 ...request.Option) (*s3.ListObjectsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] + if len(ret) == 0 { + panic("no return value specified for ListObjectsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.ListObjectsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectsInput, ...request.Option) (*s3.ListObjectsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectsInput, ...request.Option) (*s3.ListObjectsOutput, error)); ok { + return returnFunc(v, listObjectsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListObjectsInput, ...request.Option) *s3.ListObjectsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListObjectsInput, ...request.Option) *s3.ListObjectsOutput); ok { + r0 = returnFunc(v, listObjectsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListObjectsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.ListObjectsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.ListObjectsInput, ...request.Option) error); ok { + r1 = returnFunc(v, listObjectsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListParts provides a mock function with given fields: _a0 -func (_m *S3API) ListParts(_a0 *s3.ListPartsInput) (*s3.ListPartsOutput, error) { - ret := _m.Called(_a0) +// S3API_ListObjectsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListObjectsWithContext' +type S3API_ListObjectsWithContext_Call struct { + *mock.Call +} + +// ListObjectsWithContext is a helper method to define mock.On call +// - v aws.Context +// - listObjectsInput *s3.ListObjectsInput +// - options ...request.Option +func (_e *S3API_Expecter) ListObjectsWithContext(v interface{}, listObjectsInput interface{}, options ...interface{}) *S3API_ListObjectsWithContext_Call { + return &S3API_ListObjectsWithContext_Call{Call: _e.mock.On("ListObjectsWithContext", + append([]interface{}{v, listObjectsInput}, options...)...)} +} + +func (_c *S3API_ListObjectsWithContext_Call) Run(run func(v aws.Context, listObjectsInput *s3.ListObjectsInput, options ...request.Option)) *S3API_ListObjectsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListObjectsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListObjectsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_ListObjectsWithContext_Call) Return(listObjectsOutput *s3.ListObjectsOutput, err error) *S3API_ListObjectsWithContext_Call { + _c.Call.Return(listObjectsOutput, err) + return _c +} + +func (_c *S3API_ListObjectsWithContext_Call) RunAndReturn(run func(v aws.Context, listObjectsInput *s3.ListObjectsInput, options ...request.Option) (*s3.ListObjectsOutput, error)) *S3API_ListObjectsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListParts provides a mock function for the type S3API +func (_mock *S3API) ListParts(listPartsInput *s3.ListPartsInput) (*s3.ListPartsOutput, error) { + ret := _mock.Called(listPartsInput) + + if len(ret) == 0 { + panic("no return value specified for ListParts") + } var r0 *s3.ListPartsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.ListPartsInput) (*s3.ListPartsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListPartsInput) (*s3.ListPartsOutput, error)); ok { + return returnFunc(listPartsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListPartsInput) *s3.ListPartsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListPartsInput) *s3.ListPartsOutput); ok { + r0 = returnFunc(listPartsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListPartsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.ListPartsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListPartsInput) error); ok { + r1 = returnFunc(listPartsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListPartsPages provides a mock function with given fields: _a0, _a1 -func (_m *S3API) ListPartsPages(_a0 *s3.ListPartsInput, _a1 func(*s3.ListPartsOutput, bool) bool) error { - ret := _m.Called(_a0, _a1) +// S3API_ListParts_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListParts' +type S3API_ListParts_Call struct { + *mock.Call +} + +// ListParts is a helper method to define mock.On call +// - listPartsInput *s3.ListPartsInput +func (_e *S3API_Expecter) ListParts(listPartsInput interface{}) *S3API_ListParts_Call { + return &S3API_ListParts_Call{Call: _e.mock.On("ListParts", listPartsInput)} +} + +func (_c *S3API_ListParts_Call) Run(run func(listPartsInput *s3.ListPartsInput)) *S3API_ListParts_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListPartsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListPartsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListParts_Call) Return(listPartsOutput *s3.ListPartsOutput, err error) *S3API_ListParts_Call { + _c.Call.Return(listPartsOutput, err) + return _c +} + +func (_c *S3API_ListParts_Call) RunAndReturn(run func(listPartsInput *s3.ListPartsInput) (*s3.ListPartsOutput, error)) *S3API_ListParts_Call { + _c.Call.Return(run) + return _c +} + +// ListPartsPages provides a mock function for the type S3API +func (_mock *S3API) ListPartsPages(listPartsInput *s3.ListPartsInput, fn func(*s3.ListPartsOutput, bool) bool) error { + ret := _mock.Called(listPartsInput, fn) + + if len(ret) == 0 { + panic("no return value specified for ListPartsPages") + } var r0 error - if rf, ok := ret.Get(0).(func(*s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool) error); ok { - r0 = rf(_a0, _a1) + if returnFunc, ok := ret.Get(0).(func(*s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool) error); ok { + r0 = returnFunc(listPartsInput, fn) } else { r0 = ret.Error(0) } - return r0 } -// ListPartsPagesWithContext provides a mock function with given fields: _a0, _a1, _a2, _a3 -func (_m *S3API) ListPartsPagesWithContext(_a0 context.Context, _a1 *s3.ListPartsInput, _a2 func(*s3.ListPartsOutput, bool) bool, _a3 ...request.Option) error { - _va := make([]interface{}, len(_a3)) - for _i := range _a3 { - _va[_i] = _a3[_i] +// S3API_ListPartsPages_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPartsPages' +type S3API_ListPartsPages_Call struct { + *mock.Call +} + +// ListPartsPages is a helper method to define mock.On call +// - listPartsInput *s3.ListPartsInput +// - fn func(*s3.ListPartsOutput, bool) bool +func (_e *S3API_Expecter) ListPartsPages(listPartsInput interface{}, fn interface{}) *S3API_ListPartsPages_Call { + return &S3API_ListPartsPages_Call{Call: _e.mock.On("ListPartsPages", listPartsInput, fn)} +} + +func (_c *S3API_ListPartsPages_Call) Run(run func(listPartsInput *s3.ListPartsInput, fn func(*s3.ListPartsOutput, bool) bool)) *S3API_ListPartsPages_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListPartsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListPartsInput) + } + var arg1 func(*s3.ListPartsOutput, bool) bool + if args[1] != nil { + arg1 = args[1].(func(*s3.ListPartsOutput, bool) bool) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *S3API_ListPartsPages_Call) Return(err error) *S3API_ListPartsPages_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_ListPartsPages_Call) RunAndReturn(run func(listPartsInput *s3.ListPartsInput, fn func(*s3.ListPartsOutput, bool) bool) error) *S3API_ListPartsPages_Call { + _c.Call.Return(run) + return _c +} + +// ListPartsPagesWithContext provides a mock function for the type S3API +func (_mock *S3API) ListPartsPagesWithContext(v aws.Context, listPartsInput *s3.ListPartsInput, fn func(*s3.ListPartsOutput, bool) bool, options ...request.Option) error { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listPartsInput, fn, options) + } else { + tmpRet = _mock.Called(v, listPartsInput, fn) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListPartsPagesWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1, _a2) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool, ...request.Option) error); ok { - r0 = rf(_a0, _a1, _a2, _a3...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListPartsInput, func(*s3.ListPartsOutput, bool) bool, ...request.Option) error); ok { + r0 = returnFunc(v, listPartsInput, fn, options...) } else { r0 = ret.Error(0) } - return r0 } -// ListPartsRequest provides a mock function with given fields: _a0 -func (_m *S3API) ListPartsRequest(_a0 *s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput) { - ret := _m.Called(_a0) +// S3API_ListPartsPagesWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPartsPagesWithContext' +type S3API_ListPartsPagesWithContext_Call struct { + *mock.Call +} + +// ListPartsPagesWithContext is a helper method to define mock.On call +// - v aws.Context +// - listPartsInput *s3.ListPartsInput +// - fn func(*s3.ListPartsOutput, bool) bool +// - options ...request.Option +func (_e *S3API_Expecter) ListPartsPagesWithContext(v interface{}, listPartsInput interface{}, fn interface{}, options ...interface{}) *S3API_ListPartsPagesWithContext_Call { + return &S3API_ListPartsPagesWithContext_Call{Call: _e.mock.On("ListPartsPagesWithContext", + append([]interface{}{v, listPartsInput, fn}, options...)...)} +} + +func (_c *S3API_ListPartsPagesWithContext_Call) Run(run func(v aws.Context, listPartsInput *s3.ListPartsInput, fn func(*s3.ListPartsOutput, bool) bool, options ...request.Option)) *S3API_ListPartsPagesWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListPartsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListPartsInput) + } + var arg2 func(*s3.ListPartsOutput, bool) bool + if args[2] != nil { + arg2 = args[2].(func(*s3.ListPartsOutput, bool) bool) + } + var arg3 []request.Option + var variadicArgs []request.Option + if len(args) > 3 { + variadicArgs = args[3].([]request.Option) + } + arg3 = variadicArgs + run( + arg0, + arg1, + arg2, + arg3..., + ) + }) + return _c +} + +func (_c *S3API_ListPartsPagesWithContext_Call) Return(err error) *S3API_ListPartsPagesWithContext_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_ListPartsPagesWithContext_Call) RunAndReturn(run func(v aws.Context, listPartsInput *s3.ListPartsInput, fn func(*s3.ListPartsOutput, bool) bool, options ...request.Option) error) *S3API_ListPartsPagesWithContext_Call { + _c.Call.Return(run) + return _c +} + +// ListPartsRequest provides a mock function for the type S3API +func (_mock *S3API) ListPartsRequest(listPartsInput *s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput) { + ret := _mock.Called(listPartsInput) + + if len(ret) == 0 { + panic("no return value specified for ListPartsRequest") + } var r0 *request.Request var r1 *s3.ListPartsOutput - if rf, ok := ret.Get(0).(func(*s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput)); ok { + return returnFunc(listPartsInput) } - if rf, ok := ret.Get(0).(func(*s3.ListPartsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.ListPartsInput) *request.Request); ok { + r0 = returnFunc(listPartsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.ListPartsInput) *s3.ListPartsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.ListPartsInput) *s3.ListPartsOutput); ok { + r1 = returnFunc(listPartsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.ListPartsOutput) } } - return r0, r1 } -// ListPartsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) ListPartsWithContext(_a0 context.Context, _a1 *s3.ListPartsInput, _a2 ...request.Option) (*s3.ListPartsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_ListPartsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPartsRequest' +type S3API_ListPartsRequest_Call struct { + *mock.Call +} + +// ListPartsRequest is a helper method to define mock.On call +// - listPartsInput *s3.ListPartsInput +func (_e *S3API_Expecter) ListPartsRequest(listPartsInput interface{}) *S3API_ListPartsRequest_Call { + return &S3API_ListPartsRequest_Call{Call: _e.mock.On("ListPartsRequest", listPartsInput)} +} + +func (_c *S3API_ListPartsRequest_Call) Run(run func(listPartsInput *s3.ListPartsInput)) *S3API_ListPartsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.ListPartsInput + if args[0] != nil { + arg0 = args[0].(*s3.ListPartsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_ListPartsRequest_Call) Return(request1 *request.Request, listPartsOutput *s3.ListPartsOutput) *S3API_ListPartsRequest_Call { + _c.Call.Return(request1, listPartsOutput) + return _c +} + +func (_c *S3API_ListPartsRequest_Call) RunAndReturn(run func(listPartsInput *s3.ListPartsInput) (*request.Request, *s3.ListPartsOutput)) *S3API_ListPartsRequest_Call { + _c.Call.Return(run) + return _c +} + +// ListPartsWithContext provides a mock function for the type S3API +func (_mock *S3API) ListPartsWithContext(v aws.Context, listPartsInput *s3.ListPartsInput, options ...request.Option) (*s3.ListPartsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, listPartsInput, options) + } else { + tmpRet = _mock.Called(v, listPartsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for ListPartsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.ListPartsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListPartsInput, ...request.Option) (*s3.ListPartsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListPartsInput, ...request.Option) (*s3.ListPartsOutput, error)); ok { + return returnFunc(v, listPartsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.ListPartsInput, ...request.Option) *s3.ListPartsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.ListPartsInput, ...request.Option) *s3.ListPartsOutput); ok { + r0 = returnFunc(v, listPartsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.ListPartsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.ListPartsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.ListPartsInput, ...request.Option) error); ok { + r1 = returnFunc(v, listPartsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketAccelerateConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketAccelerateConfiguration(_a0 *s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_ListPartsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListPartsWithContext' +type S3API_ListPartsWithContext_Call struct { + *mock.Call +} + +// ListPartsWithContext is a helper method to define mock.On call +// - v aws.Context +// - listPartsInput *s3.ListPartsInput +// - options ...request.Option +func (_e *S3API_Expecter) ListPartsWithContext(v interface{}, listPartsInput interface{}, options ...interface{}) *S3API_ListPartsWithContext_Call { + return &S3API_ListPartsWithContext_Call{Call: _e.mock.On("ListPartsWithContext", + append([]interface{}{v, listPartsInput}, options...)...)} +} + +func (_c *S3API_ListPartsWithContext_Call) Run(run func(v aws.Context, listPartsInput *s3.ListPartsInput, options ...request.Option)) *S3API_ListPartsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.ListPartsInput + if args[1] != nil { + arg1 = args[1].(*s3.ListPartsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_ListPartsWithContext_Call) Return(listPartsOutput *s3.ListPartsOutput, err error) *S3API_ListPartsWithContext_Call { + _c.Call.Return(listPartsOutput, err) + return _c +} + +func (_c *S3API_ListPartsWithContext_Call) RunAndReturn(run func(v aws.Context, listPartsInput *s3.ListPartsInput, options ...request.Option) (*s3.ListPartsOutput, error)) *S3API_ListPartsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketAccelerateConfiguration provides a mock function for the type S3API +func (_mock *S3API) PutBucketAccelerateConfiguration(putBucketAccelerateConfigurationInput *s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error) { + ret := _mock.Called(putBucketAccelerateConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketAccelerateConfiguration") + } var r0 *s3.PutBucketAccelerateConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error)); ok { + return returnFunc(putBucketAccelerateConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketAccelerateConfigurationInput) *s3.PutBucketAccelerateConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketAccelerateConfigurationInput) *s3.PutBucketAccelerateConfigurationOutput); ok { + r0 = returnFunc(putBucketAccelerateConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketAccelerateConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketAccelerateConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketAccelerateConfigurationInput) error); ok { + r1 = returnFunc(putBucketAccelerateConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketAccelerateConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketAccelerateConfigurationRequest(_a0 *s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketAccelerateConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAccelerateConfiguration' +type S3API_PutBucketAccelerateConfiguration_Call struct { + *mock.Call +} + +// PutBucketAccelerateConfiguration is a helper method to define mock.On call +// - putBucketAccelerateConfigurationInput *s3.PutBucketAccelerateConfigurationInput +func (_e *S3API_Expecter) PutBucketAccelerateConfiguration(putBucketAccelerateConfigurationInput interface{}) *S3API_PutBucketAccelerateConfiguration_Call { + return &S3API_PutBucketAccelerateConfiguration_Call{Call: _e.mock.On("PutBucketAccelerateConfiguration", putBucketAccelerateConfigurationInput)} +} + +func (_c *S3API_PutBucketAccelerateConfiguration_Call) Run(run func(putBucketAccelerateConfigurationInput *s3.PutBucketAccelerateConfigurationInput)) *S3API_PutBucketAccelerateConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketAccelerateConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketAccelerateConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketAccelerateConfiguration_Call) Return(putBucketAccelerateConfigurationOutput *s3.PutBucketAccelerateConfigurationOutput, err error) *S3API_PutBucketAccelerateConfiguration_Call { + _c.Call.Return(putBucketAccelerateConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutBucketAccelerateConfiguration_Call) RunAndReturn(run func(putBucketAccelerateConfigurationInput *s3.PutBucketAccelerateConfigurationInput) (*s3.PutBucketAccelerateConfigurationOutput, error)) *S3API_PutBucketAccelerateConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketAccelerateConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketAccelerateConfigurationRequest(putBucketAccelerateConfigurationInput *s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput) { + ret := _mock.Called(putBucketAccelerateConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketAccelerateConfigurationRequest") + } var r0 *request.Request var r1 *s3.PutBucketAccelerateConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput)); ok { + return returnFunc(putBucketAccelerateConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketAccelerateConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketAccelerateConfigurationInput) *request.Request); ok { + r0 = returnFunc(putBucketAccelerateConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketAccelerateConfigurationInput) *s3.PutBucketAccelerateConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketAccelerateConfigurationInput) *s3.PutBucketAccelerateConfigurationOutput); ok { + r1 = returnFunc(putBucketAccelerateConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketAccelerateConfigurationOutput) } } - return r0, r1 } -// PutBucketAccelerateConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketAccelerateConfigurationWithContext(_a0 context.Context, _a1 *s3.PutBucketAccelerateConfigurationInput, _a2 ...request.Option) (*s3.PutBucketAccelerateConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketAccelerateConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAccelerateConfigurationRequest' +type S3API_PutBucketAccelerateConfigurationRequest_Call struct { + *mock.Call +} + +// PutBucketAccelerateConfigurationRequest is a helper method to define mock.On call +// - putBucketAccelerateConfigurationInput *s3.PutBucketAccelerateConfigurationInput +func (_e *S3API_Expecter) PutBucketAccelerateConfigurationRequest(putBucketAccelerateConfigurationInput interface{}) *S3API_PutBucketAccelerateConfigurationRequest_Call { + return &S3API_PutBucketAccelerateConfigurationRequest_Call{Call: _e.mock.On("PutBucketAccelerateConfigurationRequest", putBucketAccelerateConfigurationInput)} +} + +func (_c *S3API_PutBucketAccelerateConfigurationRequest_Call) Run(run func(putBucketAccelerateConfigurationInput *s3.PutBucketAccelerateConfigurationInput)) *S3API_PutBucketAccelerateConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketAccelerateConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketAccelerateConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketAccelerateConfigurationRequest_Call) Return(request1 *request.Request, putBucketAccelerateConfigurationOutput *s3.PutBucketAccelerateConfigurationOutput) *S3API_PutBucketAccelerateConfigurationRequest_Call { + _c.Call.Return(request1, putBucketAccelerateConfigurationOutput) + return _c +} + +func (_c *S3API_PutBucketAccelerateConfigurationRequest_Call) RunAndReturn(run func(putBucketAccelerateConfigurationInput *s3.PutBucketAccelerateConfigurationInput) (*request.Request, *s3.PutBucketAccelerateConfigurationOutput)) *S3API_PutBucketAccelerateConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketAccelerateConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketAccelerateConfigurationWithContext(v aws.Context, putBucketAccelerateConfigurationInput *s3.PutBucketAccelerateConfigurationInput, options ...request.Option) (*s3.PutBucketAccelerateConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketAccelerateConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, putBucketAccelerateConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketAccelerateConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketAccelerateConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketAccelerateConfigurationInput, ...request.Option) (*s3.PutBucketAccelerateConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketAccelerateConfigurationInput, ...request.Option) (*s3.PutBucketAccelerateConfigurationOutput, error)); ok { + return returnFunc(v, putBucketAccelerateConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketAccelerateConfigurationInput, ...request.Option) *s3.PutBucketAccelerateConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketAccelerateConfigurationInput, ...request.Option) *s3.PutBucketAccelerateConfigurationOutput); ok { + r0 = returnFunc(v, putBucketAccelerateConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketAccelerateConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketAccelerateConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketAccelerateConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketAccelerateConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketAcl provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketAcl(_a0 *s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketAccelerateConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAccelerateConfigurationWithContext' +type S3API_PutBucketAccelerateConfigurationWithContext_Call struct { + *mock.Call +} + +// PutBucketAccelerateConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketAccelerateConfigurationInput *s3.PutBucketAccelerateConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketAccelerateConfigurationWithContext(v interface{}, putBucketAccelerateConfigurationInput interface{}, options ...interface{}) *S3API_PutBucketAccelerateConfigurationWithContext_Call { + return &S3API_PutBucketAccelerateConfigurationWithContext_Call{Call: _e.mock.On("PutBucketAccelerateConfigurationWithContext", + append([]interface{}{v, putBucketAccelerateConfigurationInput}, options...)...)} +} + +func (_c *S3API_PutBucketAccelerateConfigurationWithContext_Call) Run(run func(v aws.Context, putBucketAccelerateConfigurationInput *s3.PutBucketAccelerateConfigurationInput, options ...request.Option)) *S3API_PutBucketAccelerateConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketAccelerateConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketAccelerateConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketAccelerateConfigurationWithContext_Call) Return(putBucketAccelerateConfigurationOutput *s3.PutBucketAccelerateConfigurationOutput, err error) *S3API_PutBucketAccelerateConfigurationWithContext_Call { + _c.Call.Return(putBucketAccelerateConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutBucketAccelerateConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketAccelerateConfigurationInput *s3.PutBucketAccelerateConfigurationInput, options ...request.Option) (*s3.PutBucketAccelerateConfigurationOutput, error)) *S3API_PutBucketAccelerateConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketAcl provides a mock function for the type S3API +func (_mock *S3API) PutBucketAcl(putBucketAclInput *s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error) { + ret := _mock.Called(putBucketAclInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketAcl") + } var r0 *s3.PutBucketAclOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error)); ok { + return returnFunc(putBucketAclInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketAclInput) *s3.PutBucketAclOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketAclInput) *s3.PutBucketAclOutput); ok { + r0 = returnFunc(putBucketAclInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketAclOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketAclInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketAclInput) error); ok { + r1 = returnFunc(putBucketAclInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketAclRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketAclRequest(_a0 *s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketAcl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAcl' +type S3API_PutBucketAcl_Call struct { + *mock.Call +} + +// PutBucketAcl is a helper method to define mock.On call +// - putBucketAclInput *s3.PutBucketAclInput +func (_e *S3API_Expecter) PutBucketAcl(putBucketAclInput interface{}) *S3API_PutBucketAcl_Call { + return &S3API_PutBucketAcl_Call{Call: _e.mock.On("PutBucketAcl", putBucketAclInput)} +} + +func (_c *S3API_PutBucketAcl_Call) Run(run func(putBucketAclInput *s3.PutBucketAclInput)) *S3API_PutBucketAcl_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketAclInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketAclInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketAcl_Call) Return(putBucketAclOutput *s3.PutBucketAclOutput, err error) *S3API_PutBucketAcl_Call { + _c.Call.Return(putBucketAclOutput, err) + return _c +} + +func (_c *S3API_PutBucketAcl_Call) RunAndReturn(run func(putBucketAclInput *s3.PutBucketAclInput) (*s3.PutBucketAclOutput, error)) *S3API_PutBucketAcl_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketAclRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketAclRequest(putBucketAclInput *s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput) { + ret := _mock.Called(putBucketAclInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketAclRequest") + } var r0 *request.Request var r1 *s3.PutBucketAclOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput)); ok { + return returnFunc(putBucketAclInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketAclInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketAclInput) *request.Request); ok { + r0 = returnFunc(putBucketAclInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketAclInput) *s3.PutBucketAclOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketAclInput) *s3.PutBucketAclOutput); ok { + r1 = returnFunc(putBucketAclInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketAclOutput) } } - return r0, r1 } -// PutBucketAclWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketAclWithContext(_a0 context.Context, _a1 *s3.PutBucketAclInput, _a2 ...request.Option) (*s3.PutBucketAclOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketAclRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAclRequest' +type S3API_PutBucketAclRequest_Call struct { + *mock.Call +} + +// PutBucketAclRequest is a helper method to define mock.On call +// - putBucketAclInput *s3.PutBucketAclInput +func (_e *S3API_Expecter) PutBucketAclRequest(putBucketAclInput interface{}) *S3API_PutBucketAclRequest_Call { + return &S3API_PutBucketAclRequest_Call{Call: _e.mock.On("PutBucketAclRequest", putBucketAclInput)} +} + +func (_c *S3API_PutBucketAclRequest_Call) Run(run func(putBucketAclInput *s3.PutBucketAclInput)) *S3API_PutBucketAclRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketAclInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketAclInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketAclRequest_Call) Return(request1 *request.Request, putBucketAclOutput *s3.PutBucketAclOutput) *S3API_PutBucketAclRequest_Call { + _c.Call.Return(request1, putBucketAclOutput) + return _c +} + +func (_c *S3API_PutBucketAclRequest_Call) RunAndReturn(run func(putBucketAclInput *s3.PutBucketAclInput) (*request.Request, *s3.PutBucketAclOutput)) *S3API_PutBucketAclRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketAclWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketAclWithContext(v aws.Context, putBucketAclInput *s3.PutBucketAclInput, options ...request.Option) (*s3.PutBucketAclOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketAclInput, options) + } else { + tmpRet = _mock.Called(v, putBucketAclInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketAclWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketAclOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketAclInput, ...request.Option) (*s3.PutBucketAclOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketAclInput, ...request.Option) (*s3.PutBucketAclOutput, error)); ok { + return returnFunc(v, putBucketAclInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketAclInput, ...request.Option) *s3.PutBucketAclOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketAclInput, ...request.Option) *s3.PutBucketAclOutput); ok { + r0 = returnFunc(v, putBucketAclInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketAclOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketAclInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketAclInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketAclInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketAnalyticsConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketAnalyticsConfiguration(_a0 *s3.PutBucketAnalyticsConfigurationInput) (*s3.PutBucketAnalyticsConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketAclWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAclWithContext' +type S3API_PutBucketAclWithContext_Call struct { + *mock.Call +} + +// PutBucketAclWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketAclInput *s3.PutBucketAclInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketAclWithContext(v interface{}, putBucketAclInput interface{}, options ...interface{}) *S3API_PutBucketAclWithContext_Call { + return &S3API_PutBucketAclWithContext_Call{Call: _e.mock.On("PutBucketAclWithContext", + append([]interface{}{v, putBucketAclInput}, options...)...)} +} + +func (_c *S3API_PutBucketAclWithContext_Call) Run(run func(v aws.Context, putBucketAclInput *s3.PutBucketAclInput, options ...request.Option)) *S3API_PutBucketAclWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketAclInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketAclInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketAclWithContext_Call) Return(putBucketAclOutput *s3.PutBucketAclOutput, err error) *S3API_PutBucketAclWithContext_Call { + _c.Call.Return(putBucketAclOutput, err) + return _c +} + +func (_c *S3API_PutBucketAclWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketAclInput *s3.PutBucketAclInput, options ...request.Option) (*s3.PutBucketAclOutput, error)) *S3API_PutBucketAclWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketAnalyticsConfiguration provides a mock function for the type S3API +func (_mock *S3API) PutBucketAnalyticsConfiguration(putBucketAnalyticsConfigurationInput *s3.PutBucketAnalyticsConfigurationInput) (*s3.PutBucketAnalyticsConfigurationOutput, error) { + ret := _mock.Called(putBucketAnalyticsConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketAnalyticsConfiguration") + } var r0 *s3.PutBucketAnalyticsConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketAnalyticsConfigurationInput) (*s3.PutBucketAnalyticsConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketAnalyticsConfigurationInput) (*s3.PutBucketAnalyticsConfigurationOutput, error)); ok { + return returnFunc(putBucketAnalyticsConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketAnalyticsConfigurationInput) *s3.PutBucketAnalyticsConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketAnalyticsConfigurationInput) *s3.PutBucketAnalyticsConfigurationOutput); ok { + r0 = returnFunc(putBucketAnalyticsConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketAnalyticsConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketAnalyticsConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketAnalyticsConfigurationInput) error); ok { + r1 = returnFunc(putBucketAnalyticsConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketAnalyticsConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketAnalyticsConfigurationRequest(_a0 *s3.PutBucketAnalyticsConfigurationInput) (*request.Request, *s3.PutBucketAnalyticsConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketAnalyticsConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAnalyticsConfiguration' +type S3API_PutBucketAnalyticsConfiguration_Call struct { + *mock.Call +} + +// PutBucketAnalyticsConfiguration is a helper method to define mock.On call +// - putBucketAnalyticsConfigurationInput *s3.PutBucketAnalyticsConfigurationInput +func (_e *S3API_Expecter) PutBucketAnalyticsConfiguration(putBucketAnalyticsConfigurationInput interface{}) *S3API_PutBucketAnalyticsConfiguration_Call { + return &S3API_PutBucketAnalyticsConfiguration_Call{Call: _e.mock.On("PutBucketAnalyticsConfiguration", putBucketAnalyticsConfigurationInput)} +} + +func (_c *S3API_PutBucketAnalyticsConfiguration_Call) Run(run func(putBucketAnalyticsConfigurationInput *s3.PutBucketAnalyticsConfigurationInput)) *S3API_PutBucketAnalyticsConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketAnalyticsConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketAnalyticsConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketAnalyticsConfiguration_Call) Return(putBucketAnalyticsConfigurationOutput *s3.PutBucketAnalyticsConfigurationOutput, err error) *S3API_PutBucketAnalyticsConfiguration_Call { + _c.Call.Return(putBucketAnalyticsConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutBucketAnalyticsConfiguration_Call) RunAndReturn(run func(putBucketAnalyticsConfigurationInput *s3.PutBucketAnalyticsConfigurationInput) (*s3.PutBucketAnalyticsConfigurationOutput, error)) *S3API_PutBucketAnalyticsConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketAnalyticsConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketAnalyticsConfigurationRequest(putBucketAnalyticsConfigurationInput *s3.PutBucketAnalyticsConfigurationInput) (*request.Request, *s3.PutBucketAnalyticsConfigurationOutput) { + ret := _mock.Called(putBucketAnalyticsConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketAnalyticsConfigurationRequest") + } var r0 *request.Request var r1 *s3.PutBucketAnalyticsConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketAnalyticsConfigurationInput) (*request.Request, *s3.PutBucketAnalyticsConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketAnalyticsConfigurationInput) (*request.Request, *s3.PutBucketAnalyticsConfigurationOutput)); ok { + return returnFunc(putBucketAnalyticsConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketAnalyticsConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketAnalyticsConfigurationInput) *request.Request); ok { + r0 = returnFunc(putBucketAnalyticsConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketAnalyticsConfigurationInput) *s3.PutBucketAnalyticsConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketAnalyticsConfigurationInput) *s3.PutBucketAnalyticsConfigurationOutput); ok { + r1 = returnFunc(putBucketAnalyticsConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketAnalyticsConfigurationOutput) } } - return r0, r1 } -// PutBucketAnalyticsConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketAnalyticsConfigurationWithContext(_a0 context.Context, _a1 *s3.PutBucketAnalyticsConfigurationInput, _a2 ...request.Option) (*s3.PutBucketAnalyticsConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketAnalyticsConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAnalyticsConfigurationRequest' +type S3API_PutBucketAnalyticsConfigurationRequest_Call struct { + *mock.Call +} + +// PutBucketAnalyticsConfigurationRequest is a helper method to define mock.On call +// - putBucketAnalyticsConfigurationInput *s3.PutBucketAnalyticsConfigurationInput +func (_e *S3API_Expecter) PutBucketAnalyticsConfigurationRequest(putBucketAnalyticsConfigurationInput interface{}) *S3API_PutBucketAnalyticsConfigurationRequest_Call { + return &S3API_PutBucketAnalyticsConfigurationRequest_Call{Call: _e.mock.On("PutBucketAnalyticsConfigurationRequest", putBucketAnalyticsConfigurationInput)} +} + +func (_c *S3API_PutBucketAnalyticsConfigurationRequest_Call) Run(run func(putBucketAnalyticsConfigurationInput *s3.PutBucketAnalyticsConfigurationInput)) *S3API_PutBucketAnalyticsConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketAnalyticsConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketAnalyticsConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketAnalyticsConfigurationRequest_Call) Return(request1 *request.Request, putBucketAnalyticsConfigurationOutput *s3.PutBucketAnalyticsConfigurationOutput) *S3API_PutBucketAnalyticsConfigurationRequest_Call { + _c.Call.Return(request1, putBucketAnalyticsConfigurationOutput) + return _c +} + +func (_c *S3API_PutBucketAnalyticsConfigurationRequest_Call) RunAndReturn(run func(putBucketAnalyticsConfigurationInput *s3.PutBucketAnalyticsConfigurationInput) (*request.Request, *s3.PutBucketAnalyticsConfigurationOutput)) *S3API_PutBucketAnalyticsConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketAnalyticsConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketAnalyticsConfigurationWithContext(v aws.Context, putBucketAnalyticsConfigurationInput *s3.PutBucketAnalyticsConfigurationInput, options ...request.Option) (*s3.PutBucketAnalyticsConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketAnalyticsConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, putBucketAnalyticsConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketAnalyticsConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketAnalyticsConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketAnalyticsConfigurationInput, ...request.Option) (*s3.PutBucketAnalyticsConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketAnalyticsConfigurationInput, ...request.Option) (*s3.PutBucketAnalyticsConfigurationOutput, error)); ok { + return returnFunc(v, putBucketAnalyticsConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketAnalyticsConfigurationInput, ...request.Option) *s3.PutBucketAnalyticsConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketAnalyticsConfigurationInput, ...request.Option) *s3.PutBucketAnalyticsConfigurationOutput); ok { + r0 = returnFunc(v, putBucketAnalyticsConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketAnalyticsConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketAnalyticsConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketAnalyticsConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketAnalyticsConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketCors provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketCors(_a0 *s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketAnalyticsConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketAnalyticsConfigurationWithContext' +type S3API_PutBucketAnalyticsConfigurationWithContext_Call struct { + *mock.Call +} + +// PutBucketAnalyticsConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketAnalyticsConfigurationInput *s3.PutBucketAnalyticsConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketAnalyticsConfigurationWithContext(v interface{}, putBucketAnalyticsConfigurationInput interface{}, options ...interface{}) *S3API_PutBucketAnalyticsConfigurationWithContext_Call { + return &S3API_PutBucketAnalyticsConfigurationWithContext_Call{Call: _e.mock.On("PutBucketAnalyticsConfigurationWithContext", + append([]interface{}{v, putBucketAnalyticsConfigurationInput}, options...)...)} +} + +func (_c *S3API_PutBucketAnalyticsConfigurationWithContext_Call) Run(run func(v aws.Context, putBucketAnalyticsConfigurationInput *s3.PutBucketAnalyticsConfigurationInput, options ...request.Option)) *S3API_PutBucketAnalyticsConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketAnalyticsConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketAnalyticsConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketAnalyticsConfigurationWithContext_Call) Return(putBucketAnalyticsConfigurationOutput *s3.PutBucketAnalyticsConfigurationOutput, err error) *S3API_PutBucketAnalyticsConfigurationWithContext_Call { + _c.Call.Return(putBucketAnalyticsConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutBucketAnalyticsConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketAnalyticsConfigurationInput *s3.PutBucketAnalyticsConfigurationInput, options ...request.Option) (*s3.PutBucketAnalyticsConfigurationOutput, error)) *S3API_PutBucketAnalyticsConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketCors provides a mock function for the type S3API +func (_mock *S3API) PutBucketCors(putBucketCorsInput *s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error) { + ret := _mock.Called(putBucketCorsInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketCors") + } var r0 *s3.PutBucketCorsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error)); ok { + return returnFunc(putBucketCorsInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketCorsInput) *s3.PutBucketCorsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketCorsInput) *s3.PutBucketCorsOutput); ok { + r0 = returnFunc(putBucketCorsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketCorsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketCorsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketCorsInput) error); ok { + r1 = returnFunc(putBucketCorsInput) } else { r1 = ret.Error(1) } + return r0, r1 +} + +// S3API_PutBucketCors_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketCors' +type S3API_PutBucketCors_Call struct { + *mock.Call +} + +// PutBucketCors is a helper method to define mock.On call +// - putBucketCorsInput *s3.PutBucketCorsInput +func (_e *S3API_Expecter) PutBucketCors(putBucketCorsInput interface{}) *S3API_PutBucketCors_Call { + return &S3API_PutBucketCors_Call{Call: _e.mock.On("PutBucketCors", putBucketCorsInput)} +} + +func (_c *S3API_PutBucketCors_Call) Run(run func(putBucketCorsInput *s3.PutBucketCorsInput)) *S3API_PutBucketCors_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketCorsInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketCorsInput) + } + run( + arg0, + ) + }) + return _c +} - return r0, r1 +func (_c *S3API_PutBucketCors_Call) Return(putBucketCorsOutput *s3.PutBucketCorsOutput, err error) *S3API_PutBucketCors_Call { + _c.Call.Return(putBucketCorsOutput, err) + return _c +} + +func (_c *S3API_PutBucketCors_Call) RunAndReturn(run func(putBucketCorsInput *s3.PutBucketCorsInput) (*s3.PutBucketCorsOutput, error)) *S3API_PutBucketCors_Call { + _c.Call.Return(run) + return _c } -// PutBucketCorsRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketCorsRequest(_a0 *s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput) { - ret := _m.Called(_a0) +// PutBucketCorsRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketCorsRequest(putBucketCorsInput *s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput) { + ret := _mock.Called(putBucketCorsInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketCorsRequest") + } var r0 *request.Request var r1 *s3.PutBucketCorsOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput)); ok { + return returnFunc(putBucketCorsInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketCorsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketCorsInput) *request.Request); ok { + r0 = returnFunc(putBucketCorsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketCorsInput) *s3.PutBucketCorsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketCorsInput) *s3.PutBucketCorsOutput); ok { + r1 = returnFunc(putBucketCorsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketCorsOutput) } } - return r0, r1 } -// PutBucketCorsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketCorsWithContext(_a0 context.Context, _a1 *s3.PutBucketCorsInput, _a2 ...request.Option) (*s3.PutBucketCorsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketCorsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketCorsRequest' +type S3API_PutBucketCorsRequest_Call struct { + *mock.Call +} + +// PutBucketCorsRequest is a helper method to define mock.On call +// - putBucketCorsInput *s3.PutBucketCorsInput +func (_e *S3API_Expecter) PutBucketCorsRequest(putBucketCorsInput interface{}) *S3API_PutBucketCorsRequest_Call { + return &S3API_PutBucketCorsRequest_Call{Call: _e.mock.On("PutBucketCorsRequest", putBucketCorsInput)} +} + +func (_c *S3API_PutBucketCorsRequest_Call) Run(run func(putBucketCorsInput *s3.PutBucketCorsInput)) *S3API_PutBucketCorsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketCorsInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketCorsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketCorsRequest_Call) Return(request1 *request.Request, putBucketCorsOutput *s3.PutBucketCorsOutput) *S3API_PutBucketCorsRequest_Call { + _c.Call.Return(request1, putBucketCorsOutput) + return _c +} + +func (_c *S3API_PutBucketCorsRequest_Call) RunAndReturn(run func(putBucketCorsInput *s3.PutBucketCorsInput) (*request.Request, *s3.PutBucketCorsOutput)) *S3API_PutBucketCorsRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketCorsWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketCorsWithContext(v aws.Context, putBucketCorsInput *s3.PutBucketCorsInput, options ...request.Option) (*s3.PutBucketCorsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketCorsInput, options) + } else { + tmpRet = _mock.Called(v, putBucketCorsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketCorsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketCorsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketCorsInput, ...request.Option) (*s3.PutBucketCorsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketCorsInput, ...request.Option) (*s3.PutBucketCorsOutput, error)); ok { + return returnFunc(v, putBucketCorsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketCorsInput, ...request.Option) *s3.PutBucketCorsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketCorsInput, ...request.Option) *s3.PutBucketCorsOutput); ok { + r0 = returnFunc(v, putBucketCorsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketCorsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketCorsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketCorsInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketCorsInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketEncryption provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketEncryption(_a0 *s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketCorsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketCorsWithContext' +type S3API_PutBucketCorsWithContext_Call struct { + *mock.Call +} + +// PutBucketCorsWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketCorsInput *s3.PutBucketCorsInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketCorsWithContext(v interface{}, putBucketCorsInput interface{}, options ...interface{}) *S3API_PutBucketCorsWithContext_Call { + return &S3API_PutBucketCorsWithContext_Call{Call: _e.mock.On("PutBucketCorsWithContext", + append([]interface{}{v, putBucketCorsInput}, options...)...)} +} + +func (_c *S3API_PutBucketCorsWithContext_Call) Run(run func(v aws.Context, putBucketCorsInput *s3.PutBucketCorsInput, options ...request.Option)) *S3API_PutBucketCorsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketCorsInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketCorsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketCorsWithContext_Call) Return(putBucketCorsOutput *s3.PutBucketCorsOutput, err error) *S3API_PutBucketCorsWithContext_Call { + _c.Call.Return(putBucketCorsOutput, err) + return _c +} + +func (_c *S3API_PutBucketCorsWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketCorsInput *s3.PutBucketCorsInput, options ...request.Option) (*s3.PutBucketCorsOutput, error)) *S3API_PutBucketCorsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketEncryption provides a mock function for the type S3API +func (_mock *S3API) PutBucketEncryption(putBucketEncryptionInput *s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error) { + ret := _mock.Called(putBucketEncryptionInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketEncryption") + } var r0 *s3.PutBucketEncryptionOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error)); ok { + return returnFunc(putBucketEncryptionInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketEncryptionInput) *s3.PutBucketEncryptionOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketEncryptionInput) *s3.PutBucketEncryptionOutput); ok { + r0 = returnFunc(putBucketEncryptionInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketEncryptionOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketEncryptionInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketEncryptionInput) error); ok { + r1 = returnFunc(putBucketEncryptionInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketEncryptionRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketEncryptionRequest(_a0 *s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketEncryption_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketEncryption' +type S3API_PutBucketEncryption_Call struct { + *mock.Call +} + +// PutBucketEncryption is a helper method to define mock.On call +// - putBucketEncryptionInput *s3.PutBucketEncryptionInput +func (_e *S3API_Expecter) PutBucketEncryption(putBucketEncryptionInput interface{}) *S3API_PutBucketEncryption_Call { + return &S3API_PutBucketEncryption_Call{Call: _e.mock.On("PutBucketEncryption", putBucketEncryptionInput)} +} + +func (_c *S3API_PutBucketEncryption_Call) Run(run func(putBucketEncryptionInput *s3.PutBucketEncryptionInput)) *S3API_PutBucketEncryption_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketEncryptionInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketEncryptionInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketEncryption_Call) Return(putBucketEncryptionOutput *s3.PutBucketEncryptionOutput, err error) *S3API_PutBucketEncryption_Call { + _c.Call.Return(putBucketEncryptionOutput, err) + return _c +} + +func (_c *S3API_PutBucketEncryption_Call) RunAndReturn(run func(putBucketEncryptionInput *s3.PutBucketEncryptionInput) (*s3.PutBucketEncryptionOutput, error)) *S3API_PutBucketEncryption_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketEncryptionRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketEncryptionRequest(putBucketEncryptionInput *s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput) { + ret := _mock.Called(putBucketEncryptionInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketEncryptionRequest") + } var r0 *request.Request var r1 *s3.PutBucketEncryptionOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput)); ok { + return returnFunc(putBucketEncryptionInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketEncryptionInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketEncryptionInput) *request.Request); ok { + r0 = returnFunc(putBucketEncryptionInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketEncryptionInput) *s3.PutBucketEncryptionOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketEncryptionInput) *s3.PutBucketEncryptionOutput); ok { + r1 = returnFunc(putBucketEncryptionInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketEncryptionOutput) } } - return r0, r1 } -// PutBucketEncryptionWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketEncryptionWithContext(_a0 context.Context, _a1 *s3.PutBucketEncryptionInput, _a2 ...request.Option) (*s3.PutBucketEncryptionOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketEncryptionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketEncryptionRequest' +type S3API_PutBucketEncryptionRequest_Call struct { + *mock.Call +} + +// PutBucketEncryptionRequest is a helper method to define mock.On call +// - putBucketEncryptionInput *s3.PutBucketEncryptionInput +func (_e *S3API_Expecter) PutBucketEncryptionRequest(putBucketEncryptionInput interface{}) *S3API_PutBucketEncryptionRequest_Call { + return &S3API_PutBucketEncryptionRequest_Call{Call: _e.mock.On("PutBucketEncryptionRequest", putBucketEncryptionInput)} +} + +func (_c *S3API_PutBucketEncryptionRequest_Call) Run(run func(putBucketEncryptionInput *s3.PutBucketEncryptionInput)) *S3API_PutBucketEncryptionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketEncryptionInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketEncryptionInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketEncryptionRequest_Call) Return(request1 *request.Request, putBucketEncryptionOutput *s3.PutBucketEncryptionOutput) *S3API_PutBucketEncryptionRequest_Call { + _c.Call.Return(request1, putBucketEncryptionOutput) + return _c +} + +func (_c *S3API_PutBucketEncryptionRequest_Call) RunAndReturn(run func(putBucketEncryptionInput *s3.PutBucketEncryptionInput) (*request.Request, *s3.PutBucketEncryptionOutput)) *S3API_PutBucketEncryptionRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketEncryptionWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketEncryptionWithContext(v aws.Context, putBucketEncryptionInput *s3.PutBucketEncryptionInput, options ...request.Option) (*s3.PutBucketEncryptionOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketEncryptionInput, options) + } else { + tmpRet = _mock.Called(v, putBucketEncryptionInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketEncryptionWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketEncryptionOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketEncryptionInput, ...request.Option) (*s3.PutBucketEncryptionOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketEncryptionInput, ...request.Option) (*s3.PutBucketEncryptionOutput, error)); ok { + return returnFunc(v, putBucketEncryptionInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketEncryptionInput, ...request.Option) *s3.PutBucketEncryptionOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketEncryptionInput, ...request.Option) *s3.PutBucketEncryptionOutput); ok { + r0 = returnFunc(v, putBucketEncryptionInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketEncryptionOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketEncryptionInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketEncryptionInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketEncryptionInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketIntelligentTieringConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketIntelligentTieringConfiguration(_a0 *s3.PutBucketIntelligentTieringConfigurationInput) (*s3.PutBucketIntelligentTieringConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketEncryptionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketEncryptionWithContext' +type S3API_PutBucketEncryptionWithContext_Call struct { + *mock.Call +} + +// PutBucketEncryptionWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketEncryptionInput *s3.PutBucketEncryptionInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketEncryptionWithContext(v interface{}, putBucketEncryptionInput interface{}, options ...interface{}) *S3API_PutBucketEncryptionWithContext_Call { + return &S3API_PutBucketEncryptionWithContext_Call{Call: _e.mock.On("PutBucketEncryptionWithContext", + append([]interface{}{v, putBucketEncryptionInput}, options...)...)} +} + +func (_c *S3API_PutBucketEncryptionWithContext_Call) Run(run func(v aws.Context, putBucketEncryptionInput *s3.PutBucketEncryptionInput, options ...request.Option)) *S3API_PutBucketEncryptionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketEncryptionInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketEncryptionInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketEncryptionWithContext_Call) Return(putBucketEncryptionOutput *s3.PutBucketEncryptionOutput, err error) *S3API_PutBucketEncryptionWithContext_Call { + _c.Call.Return(putBucketEncryptionOutput, err) + return _c +} + +func (_c *S3API_PutBucketEncryptionWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketEncryptionInput *s3.PutBucketEncryptionInput, options ...request.Option) (*s3.PutBucketEncryptionOutput, error)) *S3API_PutBucketEncryptionWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketIntelligentTieringConfiguration provides a mock function for the type S3API +func (_mock *S3API) PutBucketIntelligentTieringConfiguration(putBucketIntelligentTieringConfigurationInput *s3.PutBucketIntelligentTieringConfigurationInput) (*s3.PutBucketIntelligentTieringConfigurationOutput, error) { + ret := _mock.Called(putBucketIntelligentTieringConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketIntelligentTieringConfiguration") + } var r0 *s3.PutBucketIntelligentTieringConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketIntelligentTieringConfigurationInput) (*s3.PutBucketIntelligentTieringConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketIntelligentTieringConfigurationInput) (*s3.PutBucketIntelligentTieringConfigurationOutput, error)); ok { + return returnFunc(putBucketIntelligentTieringConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketIntelligentTieringConfigurationInput) *s3.PutBucketIntelligentTieringConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketIntelligentTieringConfigurationInput) *s3.PutBucketIntelligentTieringConfigurationOutput); ok { + r0 = returnFunc(putBucketIntelligentTieringConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketIntelligentTieringConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketIntelligentTieringConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketIntelligentTieringConfigurationInput) error); ok { + r1 = returnFunc(putBucketIntelligentTieringConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketIntelligentTieringConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketIntelligentTieringConfigurationRequest(_a0 *s3.PutBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.PutBucketIntelligentTieringConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketIntelligentTieringConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketIntelligentTieringConfiguration' +type S3API_PutBucketIntelligentTieringConfiguration_Call struct { + *mock.Call +} + +// PutBucketIntelligentTieringConfiguration is a helper method to define mock.On call +// - putBucketIntelligentTieringConfigurationInput *s3.PutBucketIntelligentTieringConfigurationInput +func (_e *S3API_Expecter) PutBucketIntelligentTieringConfiguration(putBucketIntelligentTieringConfigurationInput interface{}) *S3API_PutBucketIntelligentTieringConfiguration_Call { + return &S3API_PutBucketIntelligentTieringConfiguration_Call{Call: _e.mock.On("PutBucketIntelligentTieringConfiguration", putBucketIntelligentTieringConfigurationInput)} +} + +func (_c *S3API_PutBucketIntelligentTieringConfiguration_Call) Run(run func(putBucketIntelligentTieringConfigurationInput *s3.PutBucketIntelligentTieringConfigurationInput)) *S3API_PutBucketIntelligentTieringConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketIntelligentTieringConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketIntelligentTieringConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketIntelligentTieringConfiguration_Call) Return(putBucketIntelligentTieringConfigurationOutput *s3.PutBucketIntelligentTieringConfigurationOutput, err error) *S3API_PutBucketIntelligentTieringConfiguration_Call { + _c.Call.Return(putBucketIntelligentTieringConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutBucketIntelligentTieringConfiguration_Call) RunAndReturn(run func(putBucketIntelligentTieringConfigurationInput *s3.PutBucketIntelligentTieringConfigurationInput) (*s3.PutBucketIntelligentTieringConfigurationOutput, error)) *S3API_PutBucketIntelligentTieringConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketIntelligentTieringConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketIntelligentTieringConfigurationRequest(putBucketIntelligentTieringConfigurationInput *s3.PutBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.PutBucketIntelligentTieringConfigurationOutput) { + ret := _mock.Called(putBucketIntelligentTieringConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketIntelligentTieringConfigurationRequest") + } var r0 *request.Request var r1 *s3.PutBucketIntelligentTieringConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.PutBucketIntelligentTieringConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.PutBucketIntelligentTieringConfigurationOutput)); ok { + return returnFunc(putBucketIntelligentTieringConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketIntelligentTieringConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketIntelligentTieringConfigurationInput) *request.Request); ok { + r0 = returnFunc(putBucketIntelligentTieringConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketIntelligentTieringConfigurationInput) *s3.PutBucketIntelligentTieringConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketIntelligentTieringConfigurationInput) *s3.PutBucketIntelligentTieringConfigurationOutput); ok { + r1 = returnFunc(putBucketIntelligentTieringConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketIntelligentTieringConfigurationOutput) } } - return r0, r1 } -// PutBucketIntelligentTieringConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketIntelligentTieringConfigurationWithContext(_a0 context.Context, _a1 *s3.PutBucketIntelligentTieringConfigurationInput, _a2 ...request.Option) (*s3.PutBucketIntelligentTieringConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketIntelligentTieringConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketIntelligentTieringConfigurationRequest' +type S3API_PutBucketIntelligentTieringConfigurationRequest_Call struct { + *mock.Call +} + +// PutBucketIntelligentTieringConfigurationRequest is a helper method to define mock.On call +// - putBucketIntelligentTieringConfigurationInput *s3.PutBucketIntelligentTieringConfigurationInput +func (_e *S3API_Expecter) PutBucketIntelligentTieringConfigurationRequest(putBucketIntelligentTieringConfigurationInput interface{}) *S3API_PutBucketIntelligentTieringConfigurationRequest_Call { + return &S3API_PutBucketIntelligentTieringConfigurationRequest_Call{Call: _e.mock.On("PutBucketIntelligentTieringConfigurationRequest", putBucketIntelligentTieringConfigurationInput)} +} + +func (_c *S3API_PutBucketIntelligentTieringConfigurationRequest_Call) Run(run func(putBucketIntelligentTieringConfigurationInput *s3.PutBucketIntelligentTieringConfigurationInput)) *S3API_PutBucketIntelligentTieringConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketIntelligentTieringConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketIntelligentTieringConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketIntelligentTieringConfigurationRequest_Call) Return(request1 *request.Request, putBucketIntelligentTieringConfigurationOutput *s3.PutBucketIntelligentTieringConfigurationOutput) *S3API_PutBucketIntelligentTieringConfigurationRequest_Call { + _c.Call.Return(request1, putBucketIntelligentTieringConfigurationOutput) + return _c +} + +func (_c *S3API_PutBucketIntelligentTieringConfigurationRequest_Call) RunAndReturn(run func(putBucketIntelligentTieringConfigurationInput *s3.PutBucketIntelligentTieringConfigurationInput) (*request.Request, *s3.PutBucketIntelligentTieringConfigurationOutput)) *S3API_PutBucketIntelligentTieringConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketIntelligentTieringConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketIntelligentTieringConfigurationWithContext(v aws.Context, putBucketIntelligentTieringConfigurationInput *s3.PutBucketIntelligentTieringConfigurationInput, options ...request.Option) (*s3.PutBucketIntelligentTieringConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketIntelligentTieringConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, putBucketIntelligentTieringConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketIntelligentTieringConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketIntelligentTieringConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.PutBucketIntelligentTieringConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketIntelligentTieringConfigurationInput, ...request.Option) (*s3.PutBucketIntelligentTieringConfigurationOutput, error)); ok { + return returnFunc(v, putBucketIntelligentTieringConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketIntelligentTieringConfigurationInput, ...request.Option) *s3.PutBucketIntelligentTieringConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketIntelligentTieringConfigurationInput, ...request.Option) *s3.PutBucketIntelligentTieringConfigurationOutput); ok { + r0 = returnFunc(v, putBucketIntelligentTieringConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketIntelligentTieringConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketIntelligentTieringConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketIntelligentTieringConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketIntelligentTieringConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketInventoryConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketInventoryConfiguration(_a0 *s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketIntelligentTieringConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketIntelligentTieringConfigurationWithContext' +type S3API_PutBucketIntelligentTieringConfigurationWithContext_Call struct { + *mock.Call +} + +// PutBucketIntelligentTieringConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketIntelligentTieringConfigurationInput *s3.PutBucketIntelligentTieringConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketIntelligentTieringConfigurationWithContext(v interface{}, putBucketIntelligentTieringConfigurationInput interface{}, options ...interface{}) *S3API_PutBucketIntelligentTieringConfigurationWithContext_Call { + return &S3API_PutBucketIntelligentTieringConfigurationWithContext_Call{Call: _e.mock.On("PutBucketIntelligentTieringConfigurationWithContext", + append([]interface{}{v, putBucketIntelligentTieringConfigurationInput}, options...)...)} +} + +func (_c *S3API_PutBucketIntelligentTieringConfigurationWithContext_Call) Run(run func(v aws.Context, putBucketIntelligentTieringConfigurationInput *s3.PutBucketIntelligentTieringConfigurationInput, options ...request.Option)) *S3API_PutBucketIntelligentTieringConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketIntelligentTieringConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketIntelligentTieringConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketIntelligentTieringConfigurationWithContext_Call) Return(putBucketIntelligentTieringConfigurationOutput *s3.PutBucketIntelligentTieringConfigurationOutput, err error) *S3API_PutBucketIntelligentTieringConfigurationWithContext_Call { + _c.Call.Return(putBucketIntelligentTieringConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutBucketIntelligentTieringConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketIntelligentTieringConfigurationInput *s3.PutBucketIntelligentTieringConfigurationInput, options ...request.Option) (*s3.PutBucketIntelligentTieringConfigurationOutput, error)) *S3API_PutBucketIntelligentTieringConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketInventoryConfiguration provides a mock function for the type S3API +func (_mock *S3API) PutBucketInventoryConfiguration(putBucketInventoryConfigurationInput *s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error) { + ret := _mock.Called(putBucketInventoryConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketInventoryConfiguration") + } var r0 *s3.PutBucketInventoryConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error)); ok { + return returnFunc(putBucketInventoryConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketInventoryConfigurationInput) *s3.PutBucketInventoryConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketInventoryConfigurationInput) *s3.PutBucketInventoryConfigurationOutput); ok { + r0 = returnFunc(putBucketInventoryConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketInventoryConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketInventoryConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketInventoryConfigurationInput) error); ok { + r1 = returnFunc(putBucketInventoryConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketInventoryConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketInventoryConfigurationRequest(_a0 *s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketInventoryConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketInventoryConfiguration' +type S3API_PutBucketInventoryConfiguration_Call struct { + *mock.Call +} + +// PutBucketInventoryConfiguration is a helper method to define mock.On call +// - putBucketInventoryConfigurationInput *s3.PutBucketInventoryConfigurationInput +func (_e *S3API_Expecter) PutBucketInventoryConfiguration(putBucketInventoryConfigurationInput interface{}) *S3API_PutBucketInventoryConfiguration_Call { + return &S3API_PutBucketInventoryConfiguration_Call{Call: _e.mock.On("PutBucketInventoryConfiguration", putBucketInventoryConfigurationInput)} +} + +func (_c *S3API_PutBucketInventoryConfiguration_Call) Run(run func(putBucketInventoryConfigurationInput *s3.PutBucketInventoryConfigurationInput)) *S3API_PutBucketInventoryConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketInventoryConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketInventoryConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketInventoryConfiguration_Call) Return(putBucketInventoryConfigurationOutput *s3.PutBucketInventoryConfigurationOutput, err error) *S3API_PutBucketInventoryConfiguration_Call { + _c.Call.Return(putBucketInventoryConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutBucketInventoryConfiguration_Call) RunAndReturn(run func(putBucketInventoryConfigurationInput *s3.PutBucketInventoryConfigurationInput) (*s3.PutBucketInventoryConfigurationOutput, error)) *S3API_PutBucketInventoryConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketInventoryConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketInventoryConfigurationRequest(putBucketInventoryConfigurationInput *s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput) { + ret := _mock.Called(putBucketInventoryConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketInventoryConfigurationRequest") + } var r0 *request.Request var r1 *s3.PutBucketInventoryConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput)); ok { + return returnFunc(putBucketInventoryConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketInventoryConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketInventoryConfigurationInput) *request.Request); ok { + r0 = returnFunc(putBucketInventoryConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketInventoryConfigurationInput) *s3.PutBucketInventoryConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketInventoryConfigurationInput) *s3.PutBucketInventoryConfigurationOutput); ok { + r1 = returnFunc(putBucketInventoryConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketInventoryConfigurationOutput) } } - return r0, r1 } -// PutBucketInventoryConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketInventoryConfigurationWithContext(_a0 context.Context, _a1 *s3.PutBucketInventoryConfigurationInput, _a2 ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketInventoryConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketInventoryConfigurationRequest' +type S3API_PutBucketInventoryConfigurationRequest_Call struct { + *mock.Call +} + +// PutBucketInventoryConfigurationRequest is a helper method to define mock.On call +// - putBucketInventoryConfigurationInput *s3.PutBucketInventoryConfigurationInput +func (_e *S3API_Expecter) PutBucketInventoryConfigurationRequest(putBucketInventoryConfigurationInput interface{}) *S3API_PutBucketInventoryConfigurationRequest_Call { + return &S3API_PutBucketInventoryConfigurationRequest_Call{Call: _e.mock.On("PutBucketInventoryConfigurationRequest", putBucketInventoryConfigurationInput)} +} + +func (_c *S3API_PutBucketInventoryConfigurationRequest_Call) Run(run func(putBucketInventoryConfigurationInput *s3.PutBucketInventoryConfigurationInput)) *S3API_PutBucketInventoryConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketInventoryConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketInventoryConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketInventoryConfigurationRequest_Call) Return(request1 *request.Request, putBucketInventoryConfigurationOutput *s3.PutBucketInventoryConfigurationOutput) *S3API_PutBucketInventoryConfigurationRequest_Call { + _c.Call.Return(request1, putBucketInventoryConfigurationOutput) + return _c +} + +func (_c *S3API_PutBucketInventoryConfigurationRequest_Call) RunAndReturn(run func(putBucketInventoryConfigurationInput *s3.PutBucketInventoryConfigurationInput) (*request.Request, *s3.PutBucketInventoryConfigurationOutput)) *S3API_PutBucketInventoryConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketInventoryConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketInventoryConfigurationWithContext(v aws.Context, putBucketInventoryConfigurationInput *s3.PutBucketInventoryConfigurationInput, options ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketInventoryConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, putBucketInventoryConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketInventoryConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketInventoryConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketInventoryConfigurationInput, ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketInventoryConfigurationInput, ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error)); ok { + return returnFunc(v, putBucketInventoryConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketInventoryConfigurationInput, ...request.Option) *s3.PutBucketInventoryConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketInventoryConfigurationInput, ...request.Option) *s3.PutBucketInventoryConfigurationOutput); ok { + r0 = returnFunc(v, putBucketInventoryConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketInventoryConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketInventoryConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketInventoryConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketInventoryConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketLifecycle provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketLifecycle(_a0 *s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketInventoryConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketInventoryConfigurationWithContext' +type S3API_PutBucketInventoryConfigurationWithContext_Call struct { + *mock.Call +} + +// PutBucketInventoryConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketInventoryConfigurationInput *s3.PutBucketInventoryConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketInventoryConfigurationWithContext(v interface{}, putBucketInventoryConfigurationInput interface{}, options ...interface{}) *S3API_PutBucketInventoryConfigurationWithContext_Call { + return &S3API_PutBucketInventoryConfigurationWithContext_Call{Call: _e.mock.On("PutBucketInventoryConfigurationWithContext", + append([]interface{}{v, putBucketInventoryConfigurationInput}, options...)...)} +} + +func (_c *S3API_PutBucketInventoryConfigurationWithContext_Call) Run(run func(v aws.Context, putBucketInventoryConfigurationInput *s3.PutBucketInventoryConfigurationInput, options ...request.Option)) *S3API_PutBucketInventoryConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketInventoryConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketInventoryConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketInventoryConfigurationWithContext_Call) Return(putBucketInventoryConfigurationOutput *s3.PutBucketInventoryConfigurationOutput, err error) *S3API_PutBucketInventoryConfigurationWithContext_Call { + _c.Call.Return(putBucketInventoryConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutBucketInventoryConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketInventoryConfigurationInput *s3.PutBucketInventoryConfigurationInput, options ...request.Option) (*s3.PutBucketInventoryConfigurationOutput, error)) *S3API_PutBucketInventoryConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketLifecycle provides a mock function for the type S3API +func (_mock *S3API) PutBucketLifecycle(putBucketLifecycleInput *s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error) { + ret := _mock.Called(putBucketLifecycleInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketLifecycle") + } var r0 *s3.PutBucketLifecycleOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error)); ok { + return returnFunc(putBucketLifecycleInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleInput) *s3.PutBucketLifecycleOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketLifecycleInput) *s3.PutBucketLifecycleOutput); ok { + r0 = returnFunc(putBucketLifecycleInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketLifecycleOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketLifecycleInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketLifecycleInput) error); ok { + r1 = returnFunc(putBucketLifecycleInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketLifecycleConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketLifecycleConfiguration(_a0 *s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketLifecycle_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLifecycle' +type S3API_PutBucketLifecycle_Call struct { + *mock.Call +} + +// PutBucketLifecycle is a helper method to define mock.On call +// - putBucketLifecycleInput *s3.PutBucketLifecycleInput +func (_e *S3API_Expecter) PutBucketLifecycle(putBucketLifecycleInput interface{}) *S3API_PutBucketLifecycle_Call { + return &S3API_PutBucketLifecycle_Call{Call: _e.mock.On("PutBucketLifecycle", putBucketLifecycleInput)} +} + +func (_c *S3API_PutBucketLifecycle_Call) Run(run func(putBucketLifecycleInput *s3.PutBucketLifecycleInput)) *S3API_PutBucketLifecycle_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketLifecycleInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketLifecycleInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketLifecycle_Call) Return(putBucketLifecycleOutput *s3.PutBucketLifecycleOutput, err error) *S3API_PutBucketLifecycle_Call { + _c.Call.Return(putBucketLifecycleOutput, err) + return _c +} + +func (_c *S3API_PutBucketLifecycle_Call) RunAndReturn(run func(putBucketLifecycleInput *s3.PutBucketLifecycleInput) (*s3.PutBucketLifecycleOutput, error)) *S3API_PutBucketLifecycle_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketLifecycleConfiguration provides a mock function for the type S3API +func (_mock *S3API) PutBucketLifecycleConfiguration(putBucketLifecycleConfigurationInput *s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error) { + ret := _mock.Called(putBucketLifecycleConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketLifecycleConfiguration") + } var r0 *s3.PutBucketLifecycleConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error)); ok { + return returnFunc(putBucketLifecycleConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleConfigurationInput) *s3.PutBucketLifecycleConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketLifecycleConfigurationInput) *s3.PutBucketLifecycleConfigurationOutput); ok { + r0 = returnFunc(putBucketLifecycleConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketLifecycleConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketLifecycleConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketLifecycleConfigurationInput) error); ok { + r1 = returnFunc(putBucketLifecycleConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketLifecycleConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketLifecycleConfigurationRequest(_a0 *s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketLifecycleConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLifecycleConfiguration' +type S3API_PutBucketLifecycleConfiguration_Call struct { + *mock.Call +} + +// PutBucketLifecycleConfiguration is a helper method to define mock.On call +// - putBucketLifecycleConfigurationInput *s3.PutBucketLifecycleConfigurationInput +func (_e *S3API_Expecter) PutBucketLifecycleConfiguration(putBucketLifecycleConfigurationInput interface{}) *S3API_PutBucketLifecycleConfiguration_Call { + return &S3API_PutBucketLifecycleConfiguration_Call{Call: _e.mock.On("PutBucketLifecycleConfiguration", putBucketLifecycleConfigurationInput)} +} + +func (_c *S3API_PutBucketLifecycleConfiguration_Call) Run(run func(putBucketLifecycleConfigurationInput *s3.PutBucketLifecycleConfigurationInput)) *S3API_PutBucketLifecycleConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketLifecycleConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketLifecycleConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketLifecycleConfiguration_Call) Return(putBucketLifecycleConfigurationOutput *s3.PutBucketLifecycleConfigurationOutput, err error) *S3API_PutBucketLifecycleConfiguration_Call { + _c.Call.Return(putBucketLifecycleConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutBucketLifecycleConfiguration_Call) RunAndReturn(run func(putBucketLifecycleConfigurationInput *s3.PutBucketLifecycleConfigurationInput) (*s3.PutBucketLifecycleConfigurationOutput, error)) *S3API_PutBucketLifecycleConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketLifecycleConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketLifecycleConfigurationRequest(putBucketLifecycleConfigurationInput *s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput) { + ret := _mock.Called(putBucketLifecycleConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketLifecycleConfigurationRequest") + } var r0 *request.Request var r1 *s3.PutBucketLifecycleConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput)); ok { + return returnFunc(putBucketLifecycleConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketLifecycleConfigurationInput) *request.Request); ok { + r0 = returnFunc(putBucketLifecycleConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketLifecycleConfigurationInput) *s3.PutBucketLifecycleConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketLifecycleConfigurationInput) *s3.PutBucketLifecycleConfigurationOutput); ok { + r1 = returnFunc(putBucketLifecycleConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketLifecycleConfigurationOutput) } } - return r0, r1 } -// PutBucketLifecycleConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketLifecycleConfigurationWithContext(_a0 context.Context, _a1 *s3.PutBucketLifecycleConfigurationInput, _a2 ...request.Option) (*s3.PutBucketLifecycleConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketLifecycleConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLifecycleConfigurationRequest' +type S3API_PutBucketLifecycleConfigurationRequest_Call struct { + *mock.Call +} + +// PutBucketLifecycleConfigurationRequest is a helper method to define mock.On call +// - putBucketLifecycleConfigurationInput *s3.PutBucketLifecycleConfigurationInput +func (_e *S3API_Expecter) PutBucketLifecycleConfigurationRequest(putBucketLifecycleConfigurationInput interface{}) *S3API_PutBucketLifecycleConfigurationRequest_Call { + return &S3API_PutBucketLifecycleConfigurationRequest_Call{Call: _e.mock.On("PutBucketLifecycleConfigurationRequest", putBucketLifecycleConfigurationInput)} +} + +func (_c *S3API_PutBucketLifecycleConfigurationRequest_Call) Run(run func(putBucketLifecycleConfigurationInput *s3.PutBucketLifecycleConfigurationInput)) *S3API_PutBucketLifecycleConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketLifecycleConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketLifecycleConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketLifecycleConfigurationRequest_Call) Return(request1 *request.Request, putBucketLifecycleConfigurationOutput *s3.PutBucketLifecycleConfigurationOutput) *S3API_PutBucketLifecycleConfigurationRequest_Call { + _c.Call.Return(request1, putBucketLifecycleConfigurationOutput) + return _c +} + +func (_c *S3API_PutBucketLifecycleConfigurationRequest_Call) RunAndReturn(run func(putBucketLifecycleConfigurationInput *s3.PutBucketLifecycleConfigurationInput) (*request.Request, *s3.PutBucketLifecycleConfigurationOutput)) *S3API_PutBucketLifecycleConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketLifecycleConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketLifecycleConfigurationWithContext(v aws.Context, putBucketLifecycleConfigurationInput *s3.PutBucketLifecycleConfigurationInput, options ...request.Option) (*s3.PutBucketLifecycleConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketLifecycleConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, putBucketLifecycleConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketLifecycleConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketLifecycleConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketLifecycleConfigurationInput, ...request.Option) (*s3.PutBucketLifecycleConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketLifecycleConfigurationInput, ...request.Option) (*s3.PutBucketLifecycleConfigurationOutput, error)); ok { + return returnFunc(v, putBucketLifecycleConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketLifecycleConfigurationInput, ...request.Option) *s3.PutBucketLifecycleConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketLifecycleConfigurationInput, ...request.Option) *s3.PutBucketLifecycleConfigurationOutput); ok { + r0 = returnFunc(v, putBucketLifecycleConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketLifecycleConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketLifecycleConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketLifecycleConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketLifecycleConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketLifecycleRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketLifecycleRequest(_a0 *s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketLifecycleConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLifecycleConfigurationWithContext' +type S3API_PutBucketLifecycleConfigurationWithContext_Call struct { + *mock.Call +} + +// PutBucketLifecycleConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketLifecycleConfigurationInput *s3.PutBucketLifecycleConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketLifecycleConfigurationWithContext(v interface{}, putBucketLifecycleConfigurationInput interface{}, options ...interface{}) *S3API_PutBucketLifecycleConfigurationWithContext_Call { + return &S3API_PutBucketLifecycleConfigurationWithContext_Call{Call: _e.mock.On("PutBucketLifecycleConfigurationWithContext", + append([]interface{}{v, putBucketLifecycleConfigurationInput}, options...)...)} +} + +func (_c *S3API_PutBucketLifecycleConfigurationWithContext_Call) Run(run func(v aws.Context, putBucketLifecycleConfigurationInput *s3.PutBucketLifecycleConfigurationInput, options ...request.Option)) *S3API_PutBucketLifecycleConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketLifecycleConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketLifecycleConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketLifecycleConfigurationWithContext_Call) Return(putBucketLifecycleConfigurationOutput *s3.PutBucketLifecycleConfigurationOutput, err error) *S3API_PutBucketLifecycleConfigurationWithContext_Call { + _c.Call.Return(putBucketLifecycleConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutBucketLifecycleConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketLifecycleConfigurationInput *s3.PutBucketLifecycleConfigurationInput, options ...request.Option) (*s3.PutBucketLifecycleConfigurationOutput, error)) *S3API_PutBucketLifecycleConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketLifecycleRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketLifecycleRequest(putBucketLifecycleInput *s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput) { + ret := _mock.Called(putBucketLifecycleInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketLifecycleRequest") + } var r0 *request.Request var r1 *s3.PutBucketLifecycleOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput)); ok { + return returnFunc(putBucketLifecycleInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketLifecycleInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketLifecycleInput) *request.Request); ok { + r0 = returnFunc(putBucketLifecycleInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketLifecycleInput) *s3.PutBucketLifecycleOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketLifecycleInput) *s3.PutBucketLifecycleOutput); ok { + r1 = returnFunc(putBucketLifecycleInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketLifecycleOutput) } } + return r0, r1 +} + +// S3API_PutBucketLifecycleRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLifecycleRequest' +type S3API_PutBucketLifecycleRequest_Call struct { + *mock.Call +} + +// PutBucketLifecycleRequest is a helper method to define mock.On call +// - putBucketLifecycleInput *s3.PutBucketLifecycleInput +func (_e *S3API_Expecter) PutBucketLifecycleRequest(putBucketLifecycleInput interface{}) *S3API_PutBucketLifecycleRequest_Call { + return &S3API_PutBucketLifecycleRequest_Call{Call: _e.mock.On("PutBucketLifecycleRequest", putBucketLifecycleInput)} +} + +func (_c *S3API_PutBucketLifecycleRequest_Call) Run(run func(putBucketLifecycleInput *s3.PutBucketLifecycleInput)) *S3API_PutBucketLifecycleRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketLifecycleInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketLifecycleInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketLifecycleRequest_Call) Return(request1 *request.Request, putBucketLifecycleOutput *s3.PutBucketLifecycleOutput) *S3API_PutBucketLifecycleRequest_Call { + _c.Call.Return(request1, putBucketLifecycleOutput) + return _c +} - return r0, r1 +func (_c *S3API_PutBucketLifecycleRequest_Call) RunAndReturn(run func(putBucketLifecycleInput *s3.PutBucketLifecycleInput) (*request.Request, *s3.PutBucketLifecycleOutput)) *S3API_PutBucketLifecycleRequest_Call { + _c.Call.Return(run) + return _c } -// PutBucketLifecycleWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketLifecycleWithContext(_a0 context.Context, _a1 *s3.PutBucketLifecycleInput, _a2 ...request.Option) (*s3.PutBucketLifecycleOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// PutBucketLifecycleWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketLifecycleWithContext(v aws.Context, putBucketLifecycleInput *s3.PutBucketLifecycleInput, options ...request.Option) (*s3.PutBucketLifecycleOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketLifecycleInput, options) + } else { + tmpRet = _mock.Called(v, putBucketLifecycleInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketLifecycleWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketLifecycleOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketLifecycleInput, ...request.Option) (*s3.PutBucketLifecycleOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketLifecycleInput, ...request.Option) (*s3.PutBucketLifecycleOutput, error)); ok { + return returnFunc(v, putBucketLifecycleInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketLifecycleInput, ...request.Option) *s3.PutBucketLifecycleOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketLifecycleInput, ...request.Option) *s3.PutBucketLifecycleOutput); ok { + r0 = returnFunc(v, putBucketLifecycleInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketLifecycleOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketLifecycleInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketLifecycleInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketLifecycleInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketLogging provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketLogging(_a0 *s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketLifecycleWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLifecycleWithContext' +type S3API_PutBucketLifecycleWithContext_Call struct { + *mock.Call +} + +// PutBucketLifecycleWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketLifecycleInput *s3.PutBucketLifecycleInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketLifecycleWithContext(v interface{}, putBucketLifecycleInput interface{}, options ...interface{}) *S3API_PutBucketLifecycleWithContext_Call { + return &S3API_PutBucketLifecycleWithContext_Call{Call: _e.mock.On("PutBucketLifecycleWithContext", + append([]interface{}{v, putBucketLifecycleInput}, options...)...)} +} + +func (_c *S3API_PutBucketLifecycleWithContext_Call) Run(run func(v aws.Context, putBucketLifecycleInput *s3.PutBucketLifecycleInput, options ...request.Option)) *S3API_PutBucketLifecycleWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketLifecycleInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketLifecycleInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketLifecycleWithContext_Call) Return(putBucketLifecycleOutput *s3.PutBucketLifecycleOutput, err error) *S3API_PutBucketLifecycleWithContext_Call { + _c.Call.Return(putBucketLifecycleOutput, err) + return _c +} + +func (_c *S3API_PutBucketLifecycleWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketLifecycleInput *s3.PutBucketLifecycleInput, options ...request.Option) (*s3.PutBucketLifecycleOutput, error)) *S3API_PutBucketLifecycleWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketLogging provides a mock function for the type S3API +func (_mock *S3API) PutBucketLogging(putBucketLoggingInput *s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error) { + ret := _mock.Called(putBucketLoggingInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketLogging") + } var r0 *s3.PutBucketLoggingOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error)); ok { + return returnFunc(putBucketLoggingInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketLoggingInput) *s3.PutBucketLoggingOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketLoggingInput) *s3.PutBucketLoggingOutput); ok { + r0 = returnFunc(putBucketLoggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketLoggingOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketLoggingInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketLoggingInput) error); ok { + r1 = returnFunc(putBucketLoggingInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketLoggingRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketLoggingRequest(_a0 *s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketLogging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLogging' +type S3API_PutBucketLogging_Call struct { + *mock.Call +} + +// PutBucketLogging is a helper method to define mock.On call +// - putBucketLoggingInput *s3.PutBucketLoggingInput +func (_e *S3API_Expecter) PutBucketLogging(putBucketLoggingInput interface{}) *S3API_PutBucketLogging_Call { + return &S3API_PutBucketLogging_Call{Call: _e.mock.On("PutBucketLogging", putBucketLoggingInput)} +} + +func (_c *S3API_PutBucketLogging_Call) Run(run func(putBucketLoggingInput *s3.PutBucketLoggingInput)) *S3API_PutBucketLogging_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketLoggingInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketLoggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketLogging_Call) Return(putBucketLoggingOutput *s3.PutBucketLoggingOutput, err error) *S3API_PutBucketLogging_Call { + _c.Call.Return(putBucketLoggingOutput, err) + return _c +} + +func (_c *S3API_PutBucketLogging_Call) RunAndReturn(run func(putBucketLoggingInput *s3.PutBucketLoggingInput) (*s3.PutBucketLoggingOutput, error)) *S3API_PutBucketLogging_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketLoggingRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketLoggingRequest(putBucketLoggingInput *s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput) { + ret := _mock.Called(putBucketLoggingInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketLoggingRequest") + } var r0 *request.Request var r1 *s3.PutBucketLoggingOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput)); ok { + return returnFunc(putBucketLoggingInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketLoggingInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketLoggingInput) *request.Request); ok { + r0 = returnFunc(putBucketLoggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketLoggingInput) *s3.PutBucketLoggingOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketLoggingInput) *s3.PutBucketLoggingOutput); ok { + r1 = returnFunc(putBucketLoggingInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketLoggingOutput) } } - return r0, r1 } -// PutBucketLoggingWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketLoggingWithContext(_a0 context.Context, _a1 *s3.PutBucketLoggingInput, _a2 ...request.Option) (*s3.PutBucketLoggingOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketLoggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLoggingRequest' +type S3API_PutBucketLoggingRequest_Call struct { + *mock.Call +} + +// PutBucketLoggingRequest is a helper method to define mock.On call +// - putBucketLoggingInput *s3.PutBucketLoggingInput +func (_e *S3API_Expecter) PutBucketLoggingRequest(putBucketLoggingInput interface{}) *S3API_PutBucketLoggingRequest_Call { + return &S3API_PutBucketLoggingRequest_Call{Call: _e.mock.On("PutBucketLoggingRequest", putBucketLoggingInput)} +} + +func (_c *S3API_PutBucketLoggingRequest_Call) Run(run func(putBucketLoggingInput *s3.PutBucketLoggingInput)) *S3API_PutBucketLoggingRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketLoggingInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketLoggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketLoggingRequest_Call) Return(request1 *request.Request, putBucketLoggingOutput *s3.PutBucketLoggingOutput) *S3API_PutBucketLoggingRequest_Call { + _c.Call.Return(request1, putBucketLoggingOutput) + return _c +} + +func (_c *S3API_PutBucketLoggingRequest_Call) RunAndReturn(run func(putBucketLoggingInput *s3.PutBucketLoggingInput) (*request.Request, *s3.PutBucketLoggingOutput)) *S3API_PutBucketLoggingRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketLoggingWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketLoggingWithContext(v aws.Context, putBucketLoggingInput *s3.PutBucketLoggingInput, options ...request.Option) (*s3.PutBucketLoggingOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketLoggingInput, options) + } else { + tmpRet = _mock.Called(v, putBucketLoggingInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketLoggingWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketLoggingOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketLoggingInput, ...request.Option) (*s3.PutBucketLoggingOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketLoggingInput, ...request.Option) (*s3.PutBucketLoggingOutput, error)); ok { + return returnFunc(v, putBucketLoggingInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketLoggingInput, ...request.Option) *s3.PutBucketLoggingOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketLoggingInput, ...request.Option) *s3.PutBucketLoggingOutput); ok { + r0 = returnFunc(v, putBucketLoggingInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketLoggingOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketLoggingInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketLoggingInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketLoggingInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketMetricsConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketMetricsConfiguration(_a0 *s3.PutBucketMetricsConfigurationInput) (*s3.PutBucketMetricsConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketLoggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketLoggingWithContext' +type S3API_PutBucketLoggingWithContext_Call struct { + *mock.Call +} + +// PutBucketLoggingWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketLoggingInput *s3.PutBucketLoggingInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketLoggingWithContext(v interface{}, putBucketLoggingInput interface{}, options ...interface{}) *S3API_PutBucketLoggingWithContext_Call { + return &S3API_PutBucketLoggingWithContext_Call{Call: _e.mock.On("PutBucketLoggingWithContext", + append([]interface{}{v, putBucketLoggingInput}, options...)...)} +} + +func (_c *S3API_PutBucketLoggingWithContext_Call) Run(run func(v aws.Context, putBucketLoggingInput *s3.PutBucketLoggingInput, options ...request.Option)) *S3API_PutBucketLoggingWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketLoggingInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketLoggingInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketLoggingWithContext_Call) Return(putBucketLoggingOutput *s3.PutBucketLoggingOutput, err error) *S3API_PutBucketLoggingWithContext_Call { + _c.Call.Return(putBucketLoggingOutput, err) + return _c +} + +func (_c *S3API_PutBucketLoggingWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketLoggingInput *s3.PutBucketLoggingInput, options ...request.Option) (*s3.PutBucketLoggingOutput, error)) *S3API_PutBucketLoggingWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketMetricsConfiguration provides a mock function for the type S3API +func (_mock *S3API) PutBucketMetricsConfiguration(putBucketMetricsConfigurationInput *s3.PutBucketMetricsConfigurationInput) (*s3.PutBucketMetricsConfigurationOutput, error) { + ret := _mock.Called(putBucketMetricsConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketMetricsConfiguration") + } var r0 *s3.PutBucketMetricsConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketMetricsConfigurationInput) (*s3.PutBucketMetricsConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketMetricsConfigurationInput) (*s3.PutBucketMetricsConfigurationOutput, error)); ok { + return returnFunc(putBucketMetricsConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketMetricsConfigurationInput) *s3.PutBucketMetricsConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketMetricsConfigurationInput) *s3.PutBucketMetricsConfigurationOutput); ok { + r0 = returnFunc(putBucketMetricsConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketMetricsConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketMetricsConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketMetricsConfigurationInput) error); ok { + r1 = returnFunc(putBucketMetricsConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketMetricsConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketMetricsConfigurationRequest(_a0 *s3.PutBucketMetricsConfigurationInput) (*request.Request, *s3.PutBucketMetricsConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketMetricsConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketMetricsConfiguration' +type S3API_PutBucketMetricsConfiguration_Call struct { + *mock.Call +} + +// PutBucketMetricsConfiguration is a helper method to define mock.On call +// - putBucketMetricsConfigurationInput *s3.PutBucketMetricsConfigurationInput +func (_e *S3API_Expecter) PutBucketMetricsConfiguration(putBucketMetricsConfigurationInput interface{}) *S3API_PutBucketMetricsConfiguration_Call { + return &S3API_PutBucketMetricsConfiguration_Call{Call: _e.mock.On("PutBucketMetricsConfiguration", putBucketMetricsConfigurationInput)} +} + +func (_c *S3API_PutBucketMetricsConfiguration_Call) Run(run func(putBucketMetricsConfigurationInput *s3.PutBucketMetricsConfigurationInput)) *S3API_PutBucketMetricsConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketMetricsConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketMetricsConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketMetricsConfiguration_Call) Return(putBucketMetricsConfigurationOutput *s3.PutBucketMetricsConfigurationOutput, err error) *S3API_PutBucketMetricsConfiguration_Call { + _c.Call.Return(putBucketMetricsConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutBucketMetricsConfiguration_Call) RunAndReturn(run func(putBucketMetricsConfigurationInput *s3.PutBucketMetricsConfigurationInput) (*s3.PutBucketMetricsConfigurationOutput, error)) *S3API_PutBucketMetricsConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketMetricsConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketMetricsConfigurationRequest(putBucketMetricsConfigurationInput *s3.PutBucketMetricsConfigurationInput) (*request.Request, *s3.PutBucketMetricsConfigurationOutput) { + ret := _mock.Called(putBucketMetricsConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketMetricsConfigurationRequest") + } var r0 *request.Request var r1 *s3.PutBucketMetricsConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketMetricsConfigurationInput) (*request.Request, *s3.PutBucketMetricsConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketMetricsConfigurationInput) (*request.Request, *s3.PutBucketMetricsConfigurationOutput)); ok { + return returnFunc(putBucketMetricsConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketMetricsConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketMetricsConfigurationInput) *request.Request); ok { + r0 = returnFunc(putBucketMetricsConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketMetricsConfigurationInput) *s3.PutBucketMetricsConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketMetricsConfigurationInput) *s3.PutBucketMetricsConfigurationOutput); ok { + r1 = returnFunc(putBucketMetricsConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketMetricsConfigurationOutput) } } - return r0, r1 } -// PutBucketMetricsConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketMetricsConfigurationWithContext(_a0 context.Context, _a1 *s3.PutBucketMetricsConfigurationInput, _a2 ...request.Option) (*s3.PutBucketMetricsConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketMetricsConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketMetricsConfigurationRequest' +type S3API_PutBucketMetricsConfigurationRequest_Call struct { + *mock.Call +} + +// PutBucketMetricsConfigurationRequest is a helper method to define mock.On call +// - putBucketMetricsConfigurationInput *s3.PutBucketMetricsConfigurationInput +func (_e *S3API_Expecter) PutBucketMetricsConfigurationRequest(putBucketMetricsConfigurationInput interface{}) *S3API_PutBucketMetricsConfigurationRequest_Call { + return &S3API_PutBucketMetricsConfigurationRequest_Call{Call: _e.mock.On("PutBucketMetricsConfigurationRequest", putBucketMetricsConfigurationInput)} +} + +func (_c *S3API_PutBucketMetricsConfigurationRequest_Call) Run(run func(putBucketMetricsConfigurationInput *s3.PutBucketMetricsConfigurationInput)) *S3API_PutBucketMetricsConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketMetricsConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketMetricsConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketMetricsConfigurationRequest_Call) Return(request1 *request.Request, putBucketMetricsConfigurationOutput *s3.PutBucketMetricsConfigurationOutput) *S3API_PutBucketMetricsConfigurationRequest_Call { + _c.Call.Return(request1, putBucketMetricsConfigurationOutput) + return _c +} + +func (_c *S3API_PutBucketMetricsConfigurationRequest_Call) RunAndReturn(run func(putBucketMetricsConfigurationInput *s3.PutBucketMetricsConfigurationInput) (*request.Request, *s3.PutBucketMetricsConfigurationOutput)) *S3API_PutBucketMetricsConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketMetricsConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketMetricsConfigurationWithContext(v aws.Context, putBucketMetricsConfigurationInput *s3.PutBucketMetricsConfigurationInput, options ...request.Option) (*s3.PutBucketMetricsConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketMetricsConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, putBucketMetricsConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketMetricsConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketMetricsConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketMetricsConfigurationInput, ...request.Option) (*s3.PutBucketMetricsConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketMetricsConfigurationInput, ...request.Option) (*s3.PutBucketMetricsConfigurationOutput, error)); ok { + return returnFunc(v, putBucketMetricsConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketMetricsConfigurationInput, ...request.Option) *s3.PutBucketMetricsConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketMetricsConfigurationInput, ...request.Option) *s3.PutBucketMetricsConfigurationOutput); ok { + r0 = returnFunc(v, putBucketMetricsConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketMetricsConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketMetricsConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketMetricsConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketMetricsConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketNotification provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketNotification(_a0 *s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketMetricsConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketMetricsConfigurationWithContext' +type S3API_PutBucketMetricsConfigurationWithContext_Call struct { + *mock.Call +} + +// PutBucketMetricsConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketMetricsConfigurationInput *s3.PutBucketMetricsConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketMetricsConfigurationWithContext(v interface{}, putBucketMetricsConfigurationInput interface{}, options ...interface{}) *S3API_PutBucketMetricsConfigurationWithContext_Call { + return &S3API_PutBucketMetricsConfigurationWithContext_Call{Call: _e.mock.On("PutBucketMetricsConfigurationWithContext", + append([]interface{}{v, putBucketMetricsConfigurationInput}, options...)...)} +} + +func (_c *S3API_PutBucketMetricsConfigurationWithContext_Call) Run(run func(v aws.Context, putBucketMetricsConfigurationInput *s3.PutBucketMetricsConfigurationInput, options ...request.Option)) *S3API_PutBucketMetricsConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketMetricsConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketMetricsConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketMetricsConfigurationWithContext_Call) Return(putBucketMetricsConfigurationOutput *s3.PutBucketMetricsConfigurationOutput, err error) *S3API_PutBucketMetricsConfigurationWithContext_Call { + _c.Call.Return(putBucketMetricsConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutBucketMetricsConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketMetricsConfigurationInput *s3.PutBucketMetricsConfigurationInput, options ...request.Option) (*s3.PutBucketMetricsConfigurationOutput, error)) *S3API_PutBucketMetricsConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketNotification provides a mock function for the type S3API +func (_mock *S3API) PutBucketNotification(putBucketNotificationInput *s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error) { + ret := _mock.Called(putBucketNotificationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketNotification") + } var r0 *s3.PutBucketNotificationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error)); ok { + return returnFunc(putBucketNotificationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationInput) *s3.PutBucketNotificationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketNotificationInput) *s3.PutBucketNotificationOutput); ok { + r0 = returnFunc(putBucketNotificationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketNotificationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketNotificationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketNotificationInput) error); ok { + r1 = returnFunc(putBucketNotificationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketNotificationConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketNotificationConfiguration(_a0 *s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketNotification_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketNotification' +type S3API_PutBucketNotification_Call struct { + *mock.Call +} + +// PutBucketNotification is a helper method to define mock.On call +// - putBucketNotificationInput *s3.PutBucketNotificationInput +func (_e *S3API_Expecter) PutBucketNotification(putBucketNotificationInput interface{}) *S3API_PutBucketNotification_Call { + return &S3API_PutBucketNotification_Call{Call: _e.mock.On("PutBucketNotification", putBucketNotificationInput)} +} + +func (_c *S3API_PutBucketNotification_Call) Run(run func(putBucketNotificationInput *s3.PutBucketNotificationInput)) *S3API_PutBucketNotification_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketNotificationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketNotificationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketNotification_Call) Return(putBucketNotificationOutput *s3.PutBucketNotificationOutput, err error) *S3API_PutBucketNotification_Call { + _c.Call.Return(putBucketNotificationOutput, err) + return _c +} + +func (_c *S3API_PutBucketNotification_Call) RunAndReturn(run func(putBucketNotificationInput *s3.PutBucketNotificationInput) (*s3.PutBucketNotificationOutput, error)) *S3API_PutBucketNotification_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketNotificationConfiguration provides a mock function for the type S3API +func (_mock *S3API) PutBucketNotificationConfiguration(putBucketNotificationConfigurationInput *s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error) { + ret := _mock.Called(putBucketNotificationConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketNotificationConfiguration") + } var r0 *s3.PutBucketNotificationConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error)); ok { + return returnFunc(putBucketNotificationConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationConfigurationInput) *s3.PutBucketNotificationConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketNotificationConfigurationInput) *s3.PutBucketNotificationConfigurationOutput); ok { + r0 = returnFunc(putBucketNotificationConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketNotificationConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketNotificationConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketNotificationConfigurationInput) error); ok { + r1 = returnFunc(putBucketNotificationConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketNotificationConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketNotificationConfigurationRequest(_a0 *s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketNotificationConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketNotificationConfiguration' +type S3API_PutBucketNotificationConfiguration_Call struct { + *mock.Call +} + +// PutBucketNotificationConfiguration is a helper method to define mock.On call +// - putBucketNotificationConfigurationInput *s3.PutBucketNotificationConfigurationInput +func (_e *S3API_Expecter) PutBucketNotificationConfiguration(putBucketNotificationConfigurationInput interface{}) *S3API_PutBucketNotificationConfiguration_Call { + return &S3API_PutBucketNotificationConfiguration_Call{Call: _e.mock.On("PutBucketNotificationConfiguration", putBucketNotificationConfigurationInput)} +} + +func (_c *S3API_PutBucketNotificationConfiguration_Call) Run(run func(putBucketNotificationConfigurationInput *s3.PutBucketNotificationConfigurationInput)) *S3API_PutBucketNotificationConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketNotificationConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketNotificationConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketNotificationConfiguration_Call) Return(putBucketNotificationConfigurationOutput *s3.PutBucketNotificationConfigurationOutput, err error) *S3API_PutBucketNotificationConfiguration_Call { + _c.Call.Return(putBucketNotificationConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutBucketNotificationConfiguration_Call) RunAndReturn(run func(putBucketNotificationConfigurationInput *s3.PutBucketNotificationConfigurationInput) (*s3.PutBucketNotificationConfigurationOutput, error)) *S3API_PutBucketNotificationConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketNotificationConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketNotificationConfigurationRequest(putBucketNotificationConfigurationInput *s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput) { + ret := _mock.Called(putBucketNotificationConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketNotificationConfigurationRequest") + } var r0 *request.Request var r1 *s3.PutBucketNotificationConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput)); ok { + return returnFunc(putBucketNotificationConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketNotificationConfigurationInput) *request.Request); ok { + r0 = returnFunc(putBucketNotificationConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketNotificationConfigurationInput) *s3.PutBucketNotificationConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketNotificationConfigurationInput) *s3.PutBucketNotificationConfigurationOutput); ok { + r1 = returnFunc(putBucketNotificationConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketNotificationConfigurationOutput) } } - return r0, r1 } -// PutBucketNotificationConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketNotificationConfigurationWithContext(_a0 context.Context, _a1 *s3.PutBucketNotificationConfigurationInput, _a2 ...request.Option) (*s3.PutBucketNotificationConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketNotificationConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketNotificationConfigurationRequest' +type S3API_PutBucketNotificationConfigurationRequest_Call struct { + *mock.Call +} + +// PutBucketNotificationConfigurationRequest is a helper method to define mock.On call +// - putBucketNotificationConfigurationInput *s3.PutBucketNotificationConfigurationInput +func (_e *S3API_Expecter) PutBucketNotificationConfigurationRequest(putBucketNotificationConfigurationInput interface{}) *S3API_PutBucketNotificationConfigurationRequest_Call { + return &S3API_PutBucketNotificationConfigurationRequest_Call{Call: _e.mock.On("PutBucketNotificationConfigurationRequest", putBucketNotificationConfigurationInput)} +} + +func (_c *S3API_PutBucketNotificationConfigurationRequest_Call) Run(run func(putBucketNotificationConfigurationInput *s3.PutBucketNotificationConfigurationInput)) *S3API_PutBucketNotificationConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketNotificationConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketNotificationConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketNotificationConfigurationRequest_Call) Return(request1 *request.Request, putBucketNotificationConfigurationOutput *s3.PutBucketNotificationConfigurationOutput) *S3API_PutBucketNotificationConfigurationRequest_Call { + _c.Call.Return(request1, putBucketNotificationConfigurationOutput) + return _c +} + +func (_c *S3API_PutBucketNotificationConfigurationRequest_Call) RunAndReturn(run func(putBucketNotificationConfigurationInput *s3.PutBucketNotificationConfigurationInput) (*request.Request, *s3.PutBucketNotificationConfigurationOutput)) *S3API_PutBucketNotificationConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketNotificationConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketNotificationConfigurationWithContext(v aws.Context, putBucketNotificationConfigurationInput *s3.PutBucketNotificationConfigurationInput, options ...request.Option) (*s3.PutBucketNotificationConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketNotificationConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, putBucketNotificationConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketNotificationConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketNotificationConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketNotificationConfigurationInput, ...request.Option) (*s3.PutBucketNotificationConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketNotificationConfigurationInput, ...request.Option) (*s3.PutBucketNotificationConfigurationOutput, error)); ok { + return returnFunc(v, putBucketNotificationConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketNotificationConfigurationInput, ...request.Option) *s3.PutBucketNotificationConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketNotificationConfigurationInput, ...request.Option) *s3.PutBucketNotificationConfigurationOutput); ok { + r0 = returnFunc(v, putBucketNotificationConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketNotificationConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketNotificationConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketNotificationConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketNotificationConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketNotificationRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketNotificationRequest(_a0 *s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketNotificationConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketNotificationConfigurationWithContext' +type S3API_PutBucketNotificationConfigurationWithContext_Call struct { + *mock.Call +} + +// PutBucketNotificationConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketNotificationConfigurationInput *s3.PutBucketNotificationConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketNotificationConfigurationWithContext(v interface{}, putBucketNotificationConfigurationInput interface{}, options ...interface{}) *S3API_PutBucketNotificationConfigurationWithContext_Call { + return &S3API_PutBucketNotificationConfigurationWithContext_Call{Call: _e.mock.On("PutBucketNotificationConfigurationWithContext", + append([]interface{}{v, putBucketNotificationConfigurationInput}, options...)...)} +} + +func (_c *S3API_PutBucketNotificationConfigurationWithContext_Call) Run(run func(v aws.Context, putBucketNotificationConfigurationInput *s3.PutBucketNotificationConfigurationInput, options ...request.Option)) *S3API_PutBucketNotificationConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketNotificationConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketNotificationConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketNotificationConfigurationWithContext_Call) Return(putBucketNotificationConfigurationOutput *s3.PutBucketNotificationConfigurationOutput, err error) *S3API_PutBucketNotificationConfigurationWithContext_Call { + _c.Call.Return(putBucketNotificationConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutBucketNotificationConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketNotificationConfigurationInput *s3.PutBucketNotificationConfigurationInput, options ...request.Option) (*s3.PutBucketNotificationConfigurationOutput, error)) *S3API_PutBucketNotificationConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketNotificationRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketNotificationRequest(putBucketNotificationInput *s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput) { + ret := _mock.Called(putBucketNotificationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketNotificationRequest") + } var r0 *request.Request var r1 *s3.PutBucketNotificationOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput)); ok { + return returnFunc(putBucketNotificationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketNotificationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketNotificationInput) *request.Request); ok { + r0 = returnFunc(putBucketNotificationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketNotificationInput) *s3.PutBucketNotificationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketNotificationInput) *s3.PutBucketNotificationOutput); ok { + r1 = returnFunc(putBucketNotificationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketNotificationOutput) } } - return r0, r1 } -// PutBucketNotificationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketNotificationWithContext(_a0 context.Context, _a1 *s3.PutBucketNotificationInput, _a2 ...request.Option) (*s3.PutBucketNotificationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketNotificationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketNotificationRequest' +type S3API_PutBucketNotificationRequest_Call struct { + *mock.Call +} + +// PutBucketNotificationRequest is a helper method to define mock.On call +// - putBucketNotificationInput *s3.PutBucketNotificationInput +func (_e *S3API_Expecter) PutBucketNotificationRequest(putBucketNotificationInput interface{}) *S3API_PutBucketNotificationRequest_Call { + return &S3API_PutBucketNotificationRequest_Call{Call: _e.mock.On("PutBucketNotificationRequest", putBucketNotificationInput)} +} + +func (_c *S3API_PutBucketNotificationRequest_Call) Run(run func(putBucketNotificationInput *s3.PutBucketNotificationInput)) *S3API_PutBucketNotificationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketNotificationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketNotificationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketNotificationRequest_Call) Return(request1 *request.Request, putBucketNotificationOutput *s3.PutBucketNotificationOutput) *S3API_PutBucketNotificationRequest_Call { + _c.Call.Return(request1, putBucketNotificationOutput) + return _c +} + +func (_c *S3API_PutBucketNotificationRequest_Call) RunAndReturn(run func(putBucketNotificationInput *s3.PutBucketNotificationInput) (*request.Request, *s3.PutBucketNotificationOutput)) *S3API_PutBucketNotificationRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketNotificationWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketNotificationWithContext(v aws.Context, putBucketNotificationInput *s3.PutBucketNotificationInput, options ...request.Option) (*s3.PutBucketNotificationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketNotificationInput, options) + } else { + tmpRet = _mock.Called(v, putBucketNotificationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketNotificationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketNotificationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketNotificationInput, ...request.Option) (*s3.PutBucketNotificationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketNotificationInput, ...request.Option) (*s3.PutBucketNotificationOutput, error)); ok { + return returnFunc(v, putBucketNotificationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketNotificationInput, ...request.Option) *s3.PutBucketNotificationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketNotificationInput, ...request.Option) *s3.PutBucketNotificationOutput); ok { + r0 = returnFunc(v, putBucketNotificationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketNotificationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketNotificationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketNotificationInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketNotificationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketOwnershipControls provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketOwnershipControls(_a0 *s3.PutBucketOwnershipControlsInput) (*s3.PutBucketOwnershipControlsOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketNotificationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketNotificationWithContext' +type S3API_PutBucketNotificationWithContext_Call struct { + *mock.Call +} + +// PutBucketNotificationWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketNotificationInput *s3.PutBucketNotificationInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketNotificationWithContext(v interface{}, putBucketNotificationInput interface{}, options ...interface{}) *S3API_PutBucketNotificationWithContext_Call { + return &S3API_PutBucketNotificationWithContext_Call{Call: _e.mock.On("PutBucketNotificationWithContext", + append([]interface{}{v, putBucketNotificationInput}, options...)...)} +} + +func (_c *S3API_PutBucketNotificationWithContext_Call) Run(run func(v aws.Context, putBucketNotificationInput *s3.PutBucketNotificationInput, options ...request.Option)) *S3API_PutBucketNotificationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketNotificationInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketNotificationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketNotificationWithContext_Call) Return(putBucketNotificationOutput *s3.PutBucketNotificationOutput, err error) *S3API_PutBucketNotificationWithContext_Call { + _c.Call.Return(putBucketNotificationOutput, err) + return _c +} + +func (_c *S3API_PutBucketNotificationWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketNotificationInput *s3.PutBucketNotificationInput, options ...request.Option) (*s3.PutBucketNotificationOutput, error)) *S3API_PutBucketNotificationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketOwnershipControls provides a mock function for the type S3API +func (_mock *S3API) PutBucketOwnershipControls(putBucketOwnershipControlsInput *s3.PutBucketOwnershipControlsInput) (*s3.PutBucketOwnershipControlsOutput, error) { + ret := _mock.Called(putBucketOwnershipControlsInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketOwnershipControls") + } var r0 *s3.PutBucketOwnershipControlsOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketOwnershipControlsInput) (*s3.PutBucketOwnershipControlsOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketOwnershipControlsInput) (*s3.PutBucketOwnershipControlsOutput, error)); ok { + return returnFunc(putBucketOwnershipControlsInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketOwnershipControlsInput) *s3.PutBucketOwnershipControlsOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketOwnershipControlsInput) *s3.PutBucketOwnershipControlsOutput); ok { + r0 = returnFunc(putBucketOwnershipControlsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketOwnershipControlsOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketOwnershipControlsInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketOwnershipControlsInput) error); ok { + r1 = returnFunc(putBucketOwnershipControlsInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketOwnershipControlsRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketOwnershipControlsRequest(_a0 *s3.PutBucketOwnershipControlsInput) (*request.Request, *s3.PutBucketOwnershipControlsOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketOwnershipControls_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketOwnershipControls' +type S3API_PutBucketOwnershipControls_Call struct { + *mock.Call +} + +// PutBucketOwnershipControls is a helper method to define mock.On call +// - putBucketOwnershipControlsInput *s3.PutBucketOwnershipControlsInput +func (_e *S3API_Expecter) PutBucketOwnershipControls(putBucketOwnershipControlsInput interface{}) *S3API_PutBucketOwnershipControls_Call { + return &S3API_PutBucketOwnershipControls_Call{Call: _e.mock.On("PutBucketOwnershipControls", putBucketOwnershipControlsInput)} +} + +func (_c *S3API_PutBucketOwnershipControls_Call) Run(run func(putBucketOwnershipControlsInput *s3.PutBucketOwnershipControlsInput)) *S3API_PutBucketOwnershipControls_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketOwnershipControlsInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketOwnershipControlsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketOwnershipControls_Call) Return(putBucketOwnershipControlsOutput *s3.PutBucketOwnershipControlsOutput, err error) *S3API_PutBucketOwnershipControls_Call { + _c.Call.Return(putBucketOwnershipControlsOutput, err) + return _c +} + +func (_c *S3API_PutBucketOwnershipControls_Call) RunAndReturn(run func(putBucketOwnershipControlsInput *s3.PutBucketOwnershipControlsInput) (*s3.PutBucketOwnershipControlsOutput, error)) *S3API_PutBucketOwnershipControls_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketOwnershipControlsRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketOwnershipControlsRequest(putBucketOwnershipControlsInput *s3.PutBucketOwnershipControlsInput) (*request.Request, *s3.PutBucketOwnershipControlsOutput) { + ret := _mock.Called(putBucketOwnershipControlsInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketOwnershipControlsRequest") + } var r0 *request.Request var r1 *s3.PutBucketOwnershipControlsOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketOwnershipControlsInput) (*request.Request, *s3.PutBucketOwnershipControlsOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketOwnershipControlsInput) (*request.Request, *s3.PutBucketOwnershipControlsOutput)); ok { + return returnFunc(putBucketOwnershipControlsInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketOwnershipControlsInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketOwnershipControlsInput) *request.Request); ok { + r0 = returnFunc(putBucketOwnershipControlsInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketOwnershipControlsInput) *s3.PutBucketOwnershipControlsOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketOwnershipControlsInput) *s3.PutBucketOwnershipControlsOutput); ok { + r1 = returnFunc(putBucketOwnershipControlsInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketOwnershipControlsOutput) } } - return r0, r1 } -// PutBucketOwnershipControlsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketOwnershipControlsWithContext(_a0 context.Context, _a1 *s3.PutBucketOwnershipControlsInput, _a2 ...request.Option) (*s3.PutBucketOwnershipControlsOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketOwnershipControlsRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketOwnershipControlsRequest' +type S3API_PutBucketOwnershipControlsRequest_Call struct { + *mock.Call +} + +// PutBucketOwnershipControlsRequest is a helper method to define mock.On call +// - putBucketOwnershipControlsInput *s3.PutBucketOwnershipControlsInput +func (_e *S3API_Expecter) PutBucketOwnershipControlsRequest(putBucketOwnershipControlsInput interface{}) *S3API_PutBucketOwnershipControlsRequest_Call { + return &S3API_PutBucketOwnershipControlsRequest_Call{Call: _e.mock.On("PutBucketOwnershipControlsRequest", putBucketOwnershipControlsInput)} +} + +func (_c *S3API_PutBucketOwnershipControlsRequest_Call) Run(run func(putBucketOwnershipControlsInput *s3.PutBucketOwnershipControlsInput)) *S3API_PutBucketOwnershipControlsRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketOwnershipControlsInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketOwnershipControlsInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketOwnershipControlsRequest_Call) Return(request1 *request.Request, putBucketOwnershipControlsOutput *s3.PutBucketOwnershipControlsOutput) *S3API_PutBucketOwnershipControlsRequest_Call { + _c.Call.Return(request1, putBucketOwnershipControlsOutput) + return _c +} + +func (_c *S3API_PutBucketOwnershipControlsRequest_Call) RunAndReturn(run func(putBucketOwnershipControlsInput *s3.PutBucketOwnershipControlsInput) (*request.Request, *s3.PutBucketOwnershipControlsOutput)) *S3API_PutBucketOwnershipControlsRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketOwnershipControlsWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketOwnershipControlsWithContext(v aws.Context, putBucketOwnershipControlsInput *s3.PutBucketOwnershipControlsInput, options ...request.Option) (*s3.PutBucketOwnershipControlsOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketOwnershipControlsInput, options) + } else { + tmpRet = _mock.Called(v, putBucketOwnershipControlsInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketOwnershipControlsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketOwnershipControlsOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketOwnershipControlsInput, ...request.Option) (*s3.PutBucketOwnershipControlsOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketOwnershipControlsInput, ...request.Option) (*s3.PutBucketOwnershipControlsOutput, error)); ok { + return returnFunc(v, putBucketOwnershipControlsInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketOwnershipControlsInput, ...request.Option) *s3.PutBucketOwnershipControlsOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketOwnershipControlsInput, ...request.Option) *s3.PutBucketOwnershipControlsOutput); ok { + r0 = returnFunc(v, putBucketOwnershipControlsInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketOwnershipControlsOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketOwnershipControlsInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketOwnershipControlsInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketOwnershipControlsInput, options...) } else { r1 = ret.Error(1) } + return r0, r1 +} + +// S3API_PutBucketOwnershipControlsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketOwnershipControlsWithContext' +type S3API_PutBucketOwnershipControlsWithContext_Call struct { + *mock.Call +} + +// PutBucketOwnershipControlsWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketOwnershipControlsInput *s3.PutBucketOwnershipControlsInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketOwnershipControlsWithContext(v interface{}, putBucketOwnershipControlsInput interface{}, options ...interface{}) *S3API_PutBucketOwnershipControlsWithContext_Call { + return &S3API_PutBucketOwnershipControlsWithContext_Call{Call: _e.mock.On("PutBucketOwnershipControlsWithContext", + append([]interface{}{v, putBucketOwnershipControlsInput}, options...)...)} +} + +func (_c *S3API_PutBucketOwnershipControlsWithContext_Call) Run(run func(v aws.Context, putBucketOwnershipControlsInput *s3.PutBucketOwnershipControlsInput, options ...request.Option)) *S3API_PutBucketOwnershipControlsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketOwnershipControlsInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketOwnershipControlsInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} - return r0, r1 +func (_c *S3API_PutBucketOwnershipControlsWithContext_Call) Return(putBucketOwnershipControlsOutput *s3.PutBucketOwnershipControlsOutput, err error) *S3API_PutBucketOwnershipControlsWithContext_Call { + _c.Call.Return(putBucketOwnershipControlsOutput, err) + return _c +} + +func (_c *S3API_PutBucketOwnershipControlsWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketOwnershipControlsInput *s3.PutBucketOwnershipControlsInput, options ...request.Option) (*s3.PutBucketOwnershipControlsOutput, error)) *S3API_PutBucketOwnershipControlsWithContext_Call { + _c.Call.Return(run) + return _c } -// PutBucketPolicy provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketPolicy(_a0 *s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error) { - ret := _m.Called(_a0) +// PutBucketPolicy provides a mock function for the type S3API +func (_mock *S3API) PutBucketPolicy(putBucketPolicyInput *s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error) { + ret := _mock.Called(putBucketPolicyInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketPolicy") + } var r0 *s3.PutBucketPolicyOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error)); ok { + return returnFunc(putBucketPolicyInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketPolicyInput) *s3.PutBucketPolicyOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketPolicyInput) *s3.PutBucketPolicyOutput); ok { + r0 = returnFunc(putBucketPolicyInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketPolicyOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketPolicyInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketPolicyInput) error); ok { + r1 = returnFunc(putBucketPolicyInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketPolicyRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketPolicyRequest(_a0 *s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketPolicy' +type S3API_PutBucketPolicy_Call struct { + *mock.Call +} + +// PutBucketPolicy is a helper method to define mock.On call +// - putBucketPolicyInput *s3.PutBucketPolicyInput +func (_e *S3API_Expecter) PutBucketPolicy(putBucketPolicyInput interface{}) *S3API_PutBucketPolicy_Call { + return &S3API_PutBucketPolicy_Call{Call: _e.mock.On("PutBucketPolicy", putBucketPolicyInput)} +} + +func (_c *S3API_PutBucketPolicy_Call) Run(run func(putBucketPolicyInput *s3.PutBucketPolicyInput)) *S3API_PutBucketPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketPolicyInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketPolicyInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketPolicy_Call) Return(putBucketPolicyOutput *s3.PutBucketPolicyOutput, err error) *S3API_PutBucketPolicy_Call { + _c.Call.Return(putBucketPolicyOutput, err) + return _c +} + +func (_c *S3API_PutBucketPolicy_Call) RunAndReturn(run func(putBucketPolicyInput *s3.PutBucketPolicyInput) (*s3.PutBucketPolicyOutput, error)) *S3API_PutBucketPolicy_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketPolicyRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketPolicyRequest(putBucketPolicyInput *s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput) { + ret := _mock.Called(putBucketPolicyInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketPolicyRequest") + } var r0 *request.Request var r1 *s3.PutBucketPolicyOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput)); ok { + return returnFunc(putBucketPolicyInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketPolicyInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketPolicyInput) *request.Request); ok { + r0 = returnFunc(putBucketPolicyInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketPolicyInput) *s3.PutBucketPolicyOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketPolicyInput) *s3.PutBucketPolicyOutput); ok { + r1 = returnFunc(putBucketPolicyInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketPolicyOutput) } } - return r0, r1 } -// PutBucketPolicyWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketPolicyWithContext(_a0 context.Context, _a1 *s3.PutBucketPolicyInput, _a2 ...request.Option) (*s3.PutBucketPolicyOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketPolicyRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketPolicyRequest' +type S3API_PutBucketPolicyRequest_Call struct { + *mock.Call +} + +// PutBucketPolicyRequest is a helper method to define mock.On call +// - putBucketPolicyInput *s3.PutBucketPolicyInput +func (_e *S3API_Expecter) PutBucketPolicyRequest(putBucketPolicyInput interface{}) *S3API_PutBucketPolicyRequest_Call { + return &S3API_PutBucketPolicyRequest_Call{Call: _e.mock.On("PutBucketPolicyRequest", putBucketPolicyInput)} +} + +func (_c *S3API_PutBucketPolicyRequest_Call) Run(run func(putBucketPolicyInput *s3.PutBucketPolicyInput)) *S3API_PutBucketPolicyRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketPolicyInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketPolicyInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketPolicyRequest_Call) Return(request1 *request.Request, putBucketPolicyOutput *s3.PutBucketPolicyOutput) *S3API_PutBucketPolicyRequest_Call { + _c.Call.Return(request1, putBucketPolicyOutput) + return _c +} + +func (_c *S3API_PutBucketPolicyRequest_Call) RunAndReturn(run func(putBucketPolicyInput *s3.PutBucketPolicyInput) (*request.Request, *s3.PutBucketPolicyOutput)) *S3API_PutBucketPolicyRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketPolicyWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketPolicyWithContext(v aws.Context, putBucketPolicyInput *s3.PutBucketPolicyInput, options ...request.Option) (*s3.PutBucketPolicyOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketPolicyInput, options) + } else { + tmpRet = _mock.Called(v, putBucketPolicyInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketPolicyWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketPolicyOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketPolicyInput, ...request.Option) (*s3.PutBucketPolicyOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketPolicyInput, ...request.Option) (*s3.PutBucketPolicyOutput, error)); ok { + return returnFunc(v, putBucketPolicyInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketPolicyInput, ...request.Option) *s3.PutBucketPolicyOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketPolicyInput, ...request.Option) *s3.PutBucketPolicyOutput); ok { + r0 = returnFunc(v, putBucketPolicyInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketPolicyOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketPolicyInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketPolicyInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketPolicyInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketReplication provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketReplication(_a0 *s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketPolicyWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketPolicyWithContext' +type S3API_PutBucketPolicyWithContext_Call struct { + *mock.Call +} + +// PutBucketPolicyWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketPolicyInput *s3.PutBucketPolicyInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketPolicyWithContext(v interface{}, putBucketPolicyInput interface{}, options ...interface{}) *S3API_PutBucketPolicyWithContext_Call { + return &S3API_PutBucketPolicyWithContext_Call{Call: _e.mock.On("PutBucketPolicyWithContext", + append([]interface{}{v, putBucketPolicyInput}, options...)...)} +} + +func (_c *S3API_PutBucketPolicyWithContext_Call) Run(run func(v aws.Context, putBucketPolicyInput *s3.PutBucketPolicyInput, options ...request.Option)) *S3API_PutBucketPolicyWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketPolicyInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketPolicyInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketPolicyWithContext_Call) Return(putBucketPolicyOutput *s3.PutBucketPolicyOutput, err error) *S3API_PutBucketPolicyWithContext_Call { + _c.Call.Return(putBucketPolicyOutput, err) + return _c +} + +func (_c *S3API_PutBucketPolicyWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketPolicyInput *s3.PutBucketPolicyInput, options ...request.Option) (*s3.PutBucketPolicyOutput, error)) *S3API_PutBucketPolicyWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketReplication provides a mock function for the type S3API +func (_mock *S3API) PutBucketReplication(putBucketReplicationInput *s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error) { + ret := _mock.Called(putBucketReplicationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketReplication") + } var r0 *s3.PutBucketReplicationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error)); ok { + return returnFunc(putBucketReplicationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketReplicationInput) *s3.PutBucketReplicationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketReplicationInput) *s3.PutBucketReplicationOutput); ok { + r0 = returnFunc(putBucketReplicationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketReplicationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketReplicationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketReplicationInput) error); ok { + r1 = returnFunc(putBucketReplicationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketReplicationRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketReplicationRequest(_a0 *s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketReplication_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketReplication' +type S3API_PutBucketReplication_Call struct { + *mock.Call +} + +// PutBucketReplication is a helper method to define mock.On call +// - putBucketReplicationInput *s3.PutBucketReplicationInput +func (_e *S3API_Expecter) PutBucketReplication(putBucketReplicationInput interface{}) *S3API_PutBucketReplication_Call { + return &S3API_PutBucketReplication_Call{Call: _e.mock.On("PutBucketReplication", putBucketReplicationInput)} +} + +func (_c *S3API_PutBucketReplication_Call) Run(run func(putBucketReplicationInput *s3.PutBucketReplicationInput)) *S3API_PutBucketReplication_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketReplicationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketReplicationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketReplication_Call) Return(putBucketReplicationOutput *s3.PutBucketReplicationOutput, err error) *S3API_PutBucketReplication_Call { + _c.Call.Return(putBucketReplicationOutput, err) + return _c +} + +func (_c *S3API_PutBucketReplication_Call) RunAndReturn(run func(putBucketReplicationInput *s3.PutBucketReplicationInput) (*s3.PutBucketReplicationOutput, error)) *S3API_PutBucketReplication_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketReplicationRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketReplicationRequest(putBucketReplicationInput *s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput) { + ret := _mock.Called(putBucketReplicationInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketReplicationRequest") + } var r0 *request.Request var r1 *s3.PutBucketReplicationOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput)); ok { + return returnFunc(putBucketReplicationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketReplicationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketReplicationInput) *request.Request); ok { + r0 = returnFunc(putBucketReplicationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketReplicationInput) *s3.PutBucketReplicationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketReplicationInput) *s3.PutBucketReplicationOutput); ok { + r1 = returnFunc(putBucketReplicationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketReplicationOutput) } } - return r0, r1 } -// PutBucketReplicationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketReplicationWithContext(_a0 context.Context, _a1 *s3.PutBucketReplicationInput, _a2 ...request.Option) (*s3.PutBucketReplicationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketReplicationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketReplicationRequest' +type S3API_PutBucketReplicationRequest_Call struct { + *mock.Call +} + +// PutBucketReplicationRequest is a helper method to define mock.On call +// - putBucketReplicationInput *s3.PutBucketReplicationInput +func (_e *S3API_Expecter) PutBucketReplicationRequest(putBucketReplicationInput interface{}) *S3API_PutBucketReplicationRequest_Call { + return &S3API_PutBucketReplicationRequest_Call{Call: _e.mock.On("PutBucketReplicationRequest", putBucketReplicationInput)} +} + +func (_c *S3API_PutBucketReplicationRequest_Call) Run(run func(putBucketReplicationInput *s3.PutBucketReplicationInput)) *S3API_PutBucketReplicationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketReplicationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketReplicationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketReplicationRequest_Call) Return(request1 *request.Request, putBucketReplicationOutput *s3.PutBucketReplicationOutput) *S3API_PutBucketReplicationRequest_Call { + _c.Call.Return(request1, putBucketReplicationOutput) + return _c +} + +func (_c *S3API_PutBucketReplicationRequest_Call) RunAndReturn(run func(putBucketReplicationInput *s3.PutBucketReplicationInput) (*request.Request, *s3.PutBucketReplicationOutput)) *S3API_PutBucketReplicationRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketReplicationWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketReplicationWithContext(v aws.Context, putBucketReplicationInput *s3.PutBucketReplicationInput, options ...request.Option) (*s3.PutBucketReplicationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketReplicationInput, options) + } else { + tmpRet = _mock.Called(v, putBucketReplicationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketReplicationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketReplicationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketReplicationInput, ...request.Option) (*s3.PutBucketReplicationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketReplicationInput, ...request.Option) (*s3.PutBucketReplicationOutput, error)); ok { + return returnFunc(v, putBucketReplicationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketReplicationInput, ...request.Option) *s3.PutBucketReplicationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketReplicationInput, ...request.Option) *s3.PutBucketReplicationOutput); ok { + r0 = returnFunc(v, putBucketReplicationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketReplicationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketReplicationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketReplicationInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketReplicationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketRequestPayment provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketRequestPayment(_a0 *s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketReplicationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketReplicationWithContext' +type S3API_PutBucketReplicationWithContext_Call struct { + *mock.Call +} + +// PutBucketReplicationWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketReplicationInput *s3.PutBucketReplicationInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketReplicationWithContext(v interface{}, putBucketReplicationInput interface{}, options ...interface{}) *S3API_PutBucketReplicationWithContext_Call { + return &S3API_PutBucketReplicationWithContext_Call{Call: _e.mock.On("PutBucketReplicationWithContext", + append([]interface{}{v, putBucketReplicationInput}, options...)...)} +} + +func (_c *S3API_PutBucketReplicationWithContext_Call) Run(run func(v aws.Context, putBucketReplicationInput *s3.PutBucketReplicationInput, options ...request.Option)) *S3API_PutBucketReplicationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketReplicationInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketReplicationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketReplicationWithContext_Call) Return(putBucketReplicationOutput *s3.PutBucketReplicationOutput, err error) *S3API_PutBucketReplicationWithContext_Call { + _c.Call.Return(putBucketReplicationOutput, err) + return _c +} + +func (_c *S3API_PutBucketReplicationWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketReplicationInput *s3.PutBucketReplicationInput, options ...request.Option) (*s3.PutBucketReplicationOutput, error)) *S3API_PutBucketReplicationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketRequestPayment provides a mock function for the type S3API +func (_mock *S3API) PutBucketRequestPayment(putBucketRequestPaymentInput *s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error) { + ret := _mock.Called(putBucketRequestPaymentInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketRequestPayment") + } var r0 *s3.PutBucketRequestPaymentOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error)); ok { + return returnFunc(putBucketRequestPaymentInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketRequestPaymentInput) *s3.PutBucketRequestPaymentOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketRequestPaymentInput) *s3.PutBucketRequestPaymentOutput); ok { + r0 = returnFunc(putBucketRequestPaymentInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketRequestPaymentOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketRequestPaymentInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketRequestPaymentInput) error); ok { + r1 = returnFunc(putBucketRequestPaymentInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketRequestPaymentRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketRequestPaymentRequest(_a0 *s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketRequestPayment_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketRequestPayment' +type S3API_PutBucketRequestPayment_Call struct { + *mock.Call +} + +// PutBucketRequestPayment is a helper method to define mock.On call +// - putBucketRequestPaymentInput *s3.PutBucketRequestPaymentInput +func (_e *S3API_Expecter) PutBucketRequestPayment(putBucketRequestPaymentInput interface{}) *S3API_PutBucketRequestPayment_Call { + return &S3API_PutBucketRequestPayment_Call{Call: _e.mock.On("PutBucketRequestPayment", putBucketRequestPaymentInput)} +} + +func (_c *S3API_PutBucketRequestPayment_Call) Run(run func(putBucketRequestPaymentInput *s3.PutBucketRequestPaymentInput)) *S3API_PutBucketRequestPayment_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketRequestPaymentInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketRequestPaymentInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketRequestPayment_Call) Return(putBucketRequestPaymentOutput *s3.PutBucketRequestPaymentOutput, err error) *S3API_PutBucketRequestPayment_Call { + _c.Call.Return(putBucketRequestPaymentOutput, err) + return _c +} + +func (_c *S3API_PutBucketRequestPayment_Call) RunAndReturn(run func(putBucketRequestPaymentInput *s3.PutBucketRequestPaymentInput) (*s3.PutBucketRequestPaymentOutput, error)) *S3API_PutBucketRequestPayment_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketRequestPaymentRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketRequestPaymentRequest(putBucketRequestPaymentInput *s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput) { + ret := _mock.Called(putBucketRequestPaymentInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketRequestPaymentRequest") + } var r0 *request.Request var r1 *s3.PutBucketRequestPaymentOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput)); ok { + return returnFunc(putBucketRequestPaymentInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketRequestPaymentInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketRequestPaymentInput) *request.Request); ok { + r0 = returnFunc(putBucketRequestPaymentInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketRequestPaymentInput) *s3.PutBucketRequestPaymentOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketRequestPaymentInput) *s3.PutBucketRequestPaymentOutput); ok { + r1 = returnFunc(putBucketRequestPaymentInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketRequestPaymentOutput) } } - return r0, r1 } -// PutBucketRequestPaymentWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketRequestPaymentWithContext(_a0 context.Context, _a1 *s3.PutBucketRequestPaymentInput, _a2 ...request.Option) (*s3.PutBucketRequestPaymentOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketRequestPaymentRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketRequestPaymentRequest' +type S3API_PutBucketRequestPaymentRequest_Call struct { + *mock.Call +} + +// PutBucketRequestPaymentRequest is a helper method to define mock.On call +// - putBucketRequestPaymentInput *s3.PutBucketRequestPaymentInput +func (_e *S3API_Expecter) PutBucketRequestPaymentRequest(putBucketRequestPaymentInput interface{}) *S3API_PutBucketRequestPaymentRequest_Call { + return &S3API_PutBucketRequestPaymentRequest_Call{Call: _e.mock.On("PutBucketRequestPaymentRequest", putBucketRequestPaymentInput)} +} + +func (_c *S3API_PutBucketRequestPaymentRequest_Call) Run(run func(putBucketRequestPaymentInput *s3.PutBucketRequestPaymentInput)) *S3API_PutBucketRequestPaymentRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketRequestPaymentInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketRequestPaymentInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketRequestPaymentRequest_Call) Return(request1 *request.Request, putBucketRequestPaymentOutput *s3.PutBucketRequestPaymentOutput) *S3API_PutBucketRequestPaymentRequest_Call { + _c.Call.Return(request1, putBucketRequestPaymentOutput) + return _c +} + +func (_c *S3API_PutBucketRequestPaymentRequest_Call) RunAndReturn(run func(putBucketRequestPaymentInput *s3.PutBucketRequestPaymentInput) (*request.Request, *s3.PutBucketRequestPaymentOutput)) *S3API_PutBucketRequestPaymentRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketRequestPaymentWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketRequestPaymentWithContext(v aws.Context, putBucketRequestPaymentInput *s3.PutBucketRequestPaymentInput, options ...request.Option) (*s3.PutBucketRequestPaymentOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketRequestPaymentInput, options) + } else { + tmpRet = _mock.Called(v, putBucketRequestPaymentInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketRequestPaymentWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketRequestPaymentOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketRequestPaymentInput, ...request.Option) (*s3.PutBucketRequestPaymentOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketRequestPaymentInput, ...request.Option) (*s3.PutBucketRequestPaymentOutput, error)); ok { + return returnFunc(v, putBucketRequestPaymentInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketRequestPaymentInput, ...request.Option) *s3.PutBucketRequestPaymentOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketRequestPaymentInput, ...request.Option) *s3.PutBucketRequestPaymentOutput); ok { + r0 = returnFunc(v, putBucketRequestPaymentInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketRequestPaymentOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketRequestPaymentInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketRequestPaymentInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketRequestPaymentInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketTagging provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketTagging(_a0 *s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketRequestPaymentWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketRequestPaymentWithContext' +type S3API_PutBucketRequestPaymentWithContext_Call struct { + *mock.Call +} + +// PutBucketRequestPaymentWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketRequestPaymentInput *s3.PutBucketRequestPaymentInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketRequestPaymentWithContext(v interface{}, putBucketRequestPaymentInput interface{}, options ...interface{}) *S3API_PutBucketRequestPaymentWithContext_Call { + return &S3API_PutBucketRequestPaymentWithContext_Call{Call: _e.mock.On("PutBucketRequestPaymentWithContext", + append([]interface{}{v, putBucketRequestPaymentInput}, options...)...)} +} + +func (_c *S3API_PutBucketRequestPaymentWithContext_Call) Run(run func(v aws.Context, putBucketRequestPaymentInput *s3.PutBucketRequestPaymentInput, options ...request.Option)) *S3API_PutBucketRequestPaymentWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketRequestPaymentInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketRequestPaymentInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketRequestPaymentWithContext_Call) Return(putBucketRequestPaymentOutput *s3.PutBucketRequestPaymentOutput, err error) *S3API_PutBucketRequestPaymentWithContext_Call { + _c.Call.Return(putBucketRequestPaymentOutput, err) + return _c +} + +func (_c *S3API_PutBucketRequestPaymentWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketRequestPaymentInput *s3.PutBucketRequestPaymentInput, options ...request.Option) (*s3.PutBucketRequestPaymentOutput, error)) *S3API_PutBucketRequestPaymentWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketTagging provides a mock function for the type S3API +func (_mock *S3API) PutBucketTagging(putBucketTaggingInput *s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error) { + ret := _mock.Called(putBucketTaggingInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketTagging") + } var r0 *s3.PutBucketTaggingOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error)); ok { + return returnFunc(putBucketTaggingInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketTaggingInput) *s3.PutBucketTaggingOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketTaggingInput) *s3.PutBucketTaggingOutput); ok { + r0 = returnFunc(putBucketTaggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketTaggingOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketTaggingInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketTaggingInput) error); ok { + r1 = returnFunc(putBucketTaggingInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketTaggingRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketTaggingRequest(_a0 *s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketTagging' +type S3API_PutBucketTagging_Call struct { + *mock.Call +} + +// PutBucketTagging is a helper method to define mock.On call +// - putBucketTaggingInput *s3.PutBucketTaggingInput +func (_e *S3API_Expecter) PutBucketTagging(putBucketTaggingInput interface{}) *S3API_PutBucketTagging_Call { + return &S3API_PutBucketTagging_Call{Call: _e.mock.On("PutBucketTagging", putBucketTaggingInput)} +} + +func (_c *S3API_PutBucketTagging_Call) Run(run func(putBucketTaggingInput *s3.PutBucketTaggingInput)) *S3API_PutBucketTagging_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketTaggingInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketTaggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketTagging_Call) Return(putBucketTaggingOutput *s3.PutBucketTaggingOutput, err error) *S3API_PutBucketTagging_Call { + _c.Call.Return(putBucketTaggingOutput, err) + return _c +} + +func (_c *S3API_PutBucketTagging_Call) RunAndReturn(run func(putBucketTaggingInput *s3.PutBucketTaggingInput) (*s3.PutBucketTaggingOutput, error)) *S3API_PutBucketTagging_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketTaggingRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketTaggingRequest(putBucketTaggingInput *s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput) { + ret := _mock.Called(putBucketTaggingInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketTaggingRequest") + } var r0 *request.Request var r1 *s3.PutBucketTaggingOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput)); ok { + return returnFunc(putBucketTaggingInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketTaggingInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketTaggingInput) *request.Request); ok { + r0 = returnFunc(putBucketTaggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketTaggingInput) *s3.PutBucketTaggingOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketTaggingInput) *s3.PutBucketTaggingOutput); ok { + r1 = returnFunc(putBucketTaggingInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketTaggingOutput) } } - return r0, r1 } -// PutBucketTaggingWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketTaggingWithContext(_a0 context.Context, _a1 *s3.PutBucketTaggingInput, _a2 ...request.Option) (*s3.PutBucketTaggingOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketTaggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketTaggingRequest' +type S3API_PutBucketTaggingRequest_Call struct { + *mock.Call +} + +// PutBucketTaggingRequest is a helper method to define mock.On call +// - putBucketTaggingInput *s3.PutBucketTaggingInput +func (_e *S3API_Expecter) PutBucketTaggingRequest(putBucketTaggingInput interface{}) *S3API_PutBucketTaggingRequest_Call { + return &S3API_PutBucketTaggingRequest_Call{Call: _e.mock.On("PutBucketTaggingRequest", putBucketTaggingInput)} +} + +func (_c *S3API_PutBucketTaggingRequest_Call) Run(run func(putBucketTaggingInput *s3.PutBucketTaggingInput)) *S3API_PutBucketTaggingRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketTaggingInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketTaggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketTaggingRequest_Call) Return(request1 *request.Request, putBucketTaggingOutput *s3.PutBucketTaggingOutput) *S3API_PutBucketTaggingRequest_Call { + _c.Call.Return(request1, putBucketTaggingOutput) + return _c +} + +func (_c *S3API_PutBucketTaggingRequest_Call) RunAndReturn(run func(putBucketTaggingInput *s3.PutBucketTaggingInput) (*request.Request, *s3.PutBucketTaggingOutput)) *S3API_PutBucketTaggingRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketTaggingWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketTaggingWithContext(v aws.Context, putBucketTaggingInput *s3.PutBucketTaggingInput, options ...request.Option) (*s3.PutBucketTaggingOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketTaggingInput, options) + } else { + tmpRet = _mock.Called(v, putBucketTaggingInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketTaggingWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketTaggingOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketTaggingInput, ...request.Option) (*s3.PutBucketTaggingOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketTaggingInput, ...request.Option) (*s3.PutBucketTaggingOutput, error)); ok { + return returnFunc(v, putBucketTaggingInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketTaggingInput, ...request.Option) *s3.PutBucketTaggingOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketTaggingInput, ...request.Option) *s3.PutBucketTaggingOutput); ok { + r0 = returnFunc(v, putBucketTaggingInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketTaggingOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketTaggingInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketTaggingInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketTaggingInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketVersioning provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketVersioning(_a0 *s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketTaggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketTaggingWithContext' +type S3API_PutBucketTaggingWithContext_Call struct { + *mock.Call +} + +// PutBucketTaggingWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketTaggingInput *s3.PutBucketTaggingInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketTaggingWithContext(v interface{}, putBucketTaggingInput interface{}, options ...interface{}) *S3API_PutBucketTaggingWithContext_Call { + return &S3API_PutBucketTaggingWithContext_Call{Call: _e.mock.On("PutBucketTaggingWithContext", + append([]interface{}{v, putBucketTaggingInput}, options...)...)} +} + +func (_c *S3API_PutBucketTaggingWithContext_Call) Run(run func(v aws.Context, putBucketTaggingInput *s3.PutBucketTaggingInput, options ...request.Option)) *S3API_PutBucketTaggingWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketTaggingInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketTaggingInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketTaggingWithContext_Call) Return(putBucketTaggingOutput *s3.PutBucketTaggingOutput, err error) *S3API_PutBucketTaggingWithContext_Call { + _c.Call.Return(putBucketTaggingOutput, err) + return _c +} + +func (_c *S3API_PutBucketTaggingWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketTaggingInput *s3.PutBucketTaggingInput, options ...request.Option) (*s3.PutBucketTaggingOutput, error)) *S3API_PutBucketTaggingWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketVersioning provides a mock function for the type S3API +func (_mock *S3API) PutBucketVersioning(putBucketVersioningInput *s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error) { + ret := _mock.Called(putBucketVersioningInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketVersioning") + } var r0 *s3.PutBucketVersioningOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error)); ok { + return returnFunc(putBucketVersioningInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketVersioningInput) *s3.PutBucketVersioningOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketVersioningInput) *s3.PutBucketVersioningOutput); ok { + r0 = returnFunc(putBucketVersioningInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketVersioningOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketVersioningInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketVersioningInput) error); ok { + r1 = returnFunc(putBucketVersioningInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketVersioningRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketVersioningRequest(_a0 *s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput) { - ret := _m.Called(_a0) +// S3API_PutBucketVersioning_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketVersioning' +type S3API_PutBucketVersioning_Call struct { + *mock.Call +} + +// PutBucketVersioning is a helper method to define mock.On call +// - putBucketVersioningInput *s3.PutBucketVersioningInput +func (_e *S3API_Expecter) PutBucketVersioning(putBucketVersioningInput interface{}) *S3API_PutBucketVersioning_Call { + return &S3API_PutBucketVersioning_Call{Call: _e.mock.On("PutBucketVersioning", putBucketVersioningInput)} +} + +func (_c *S3API_PutBucketVersioning_Call) Run(run func(putBucketVersioningInput *s3.PutBucketVersioningInput)) *S3API_PutBucketVersioning_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketVersioningInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketVersioningInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketVersioning_Call) Return(putBucketVersioningOutput *s3.PutBucketVersioningOutput, err error) *S3API_PutBucketVersioning_Call { + _c.Call.Return(putBucketVersioningOutput, err) + return _c +} + +func (_c *S3API_PutBucketVersioning_Call) RunAndReturn(run func(putBucketVersioningInput *s3.PutBucketVersioningInput) (*s3.PutBucketVersioningOutput, error)) *S3API_PutBucketVersioning_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketVersioningRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketVersioningRequest(putBucketVersioningInput *s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput) { + ret := _mock.Called(putBucketVersioningInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketVersioningRequest") + } var r0 *request.Request var r1 *s3.PutBucketVersioningOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput)); ok { + return returnFunc(putBucketVersioningInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketVersioningInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketVersioningInput) *request.Request); ok { + r0 = returnFunc(putBucketVersioningInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketVersioningInput) *s3.PutBucketVersioningOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketVersioningInput) *s3.PutBucketVersioningOutput); ok { + r1 = returnFunc(putBucketVersioningInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketVersioningOutput) } } + return r0, r1 +} + +// S3API_PutBucketVersioningRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketVersioningRequest' +type S3API_PutBucketVersioningRequest_Call struct { + *mock.Call +} + +// PutBucketVersioningRequest is a helper method to define mock.On call +// - putBucketVersioningInput *s3.PutBucketVersioningInput +func (_e *S3API_Expecter) PutBucketVersioningRequest(putBucketVersioningInput interface{}) *S3API_PutBucketVersioningRequest_Call { + return &S3API_PutBucketVersioningRequest_Call{Call: _e.mock.On("PutBucketVersioningRequest", putBucketVersioningInput)} +} + +func (_c *S3API_PutBucketVersioningRequest_Call) Run(run func(putBucketVersioningInput *s3.PutBucketVersioningInput)) *S3API_PutBucketVersioningRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketVersioningInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketVersioningInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketVersioningRequest_Call) Return(request1 *request.Request, putBucketVersioningOutput *s3.PutBucketVersioningOutput) *S3API_PutBucketVersioningRequest_Call { + _c.Call.Return(request1, putBucketVersioningOutput) + return _c +} + +func (_c *S3API_PutBucketVersioningRequest_Call) RunAndReturn(run func(putBucketVersioningInput *s3.PutBucketVersioningInput) (*request.Request, *s3.PutBucketVersioningOutput)) *S3API_PutBucketVersioningRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketVersioningWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketVersioningWithContext(v aws.Context, putBucketVersioningInput *s3.PutBucketVersioningInput, options ...request.Option) (*s3.PutBucketVersioningOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketVersioningInput, options) + } else { + tmpRet = _mock.Called(v, putBucketVersioningInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketVersioningWithContext") + } + var r0 *s3.PutBucketVersioningOutput + var r1 error + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketVersioningInput, ...request.Option) (*s3.PutBucketVersioningOutput, error)); ok { + return returnFunc(v, putBucketVersioningInput, options...) + } + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketVersioningInput, ...request.Option) *s3.PutBucketVersioningOutput); ok { + r0 = returnFunc(v, putBucketVersioningInput, options...) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*s3.PutBucketVersioningOutput) + } + } + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketVersioningInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketVersioningInput, options...) + } else { + r1 = ret.Error(1) + } return r0, r1 } -// PutBucketVersioningWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketVersioningWithContext(_a0 context.Context, _a1 *s3.PutBucketVersioningInput, _a2 ...request.Option) (*s3.PutBucketVersioningOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketVersioningWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketVersioningWithContext' +type S3API_PutBucketVersioningWithContext_Call struct { + *mock.Call +} + +// PutBucketVersioningWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketVersioningInput *s3.PutBucketVersioningInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketVersioningWithContext(v interface{}, putBucketVersioningInput interface{}, options ...interface{}) *S3API_PutBucketVersioningWithContext_Call { + return &S3API_PutBucketVersioningWithContext_Call{Call: _e.mock.On("PutBucketVersioningWithContext", + append([]interface{}{v, putBucketVersioningInput}, options...)...)} +} + +func (_c *S3API_PutBucketVersioningWithContext_Call) Run(run func(v aws.Context, putBucketVersioningInput *s3.PutBucketVersioningInput, options ...request.Option)) *S3API_PutBucketVersioningWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketVersioningInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketVersioningInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketVersioningWithContext_Call) Return(putBucketVersioningOutput *s3.PutBucketVersioningOutput, err error) *S3API_PutBucketVersioningWithContext_Call { + _c.Call.Return(putBucketVersioningOutput, err) + return _c +} + +func (_c *S3API_PutBucketVersioningWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketVersioningInput *s3.PutBucketVersioningInput, options ...request.Option) (*s3.PutBucketVersioningOutput, error)) *S3API_PutBucketVersioningWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketWebsite provides a mock function for the type S3API +func (_mock *S3API) PutBucketWebsite(putBucketWebsiteInput *s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error) { + ret := _mock.Called(putBucketWebsiteInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketWebsite") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) - var r0 *s3.PutBucketVersioningOutput + var r0 *s3.PutBucketWebsiteOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketVersioningInput, ...request.Option) (*s3.PutBucketVersioningOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error)); ok { + return returnFunc(putBucketWebsiteInput) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketVersioningInput, ...request.Option) *s3.PutBucketVersioningOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketWebsiteInput) *s3.PutBucketWebsiteOutput); ok { + r0 = returnFunc(putBucketWebsiteInput) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*s3.PutBucketVersioningOutput) + r0 = ret.Get(0).(*s3.PutBucketWebsiteOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketVersioningInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketWebsiteInput) error); ok { + r1 = returnFunc(putBucketWebsiteInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutBucketWebsite provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketWebsite(_a0 *s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketWebsite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketWebsite' +type S3API_PutBucketWebsite_Call struct { + *mock.Call +} + +// PutBucketWebsite is a helper method to define mock.On call +// - putBucketWebsiteInput *s3.PutBucketWebsiteInput +func (_e *S3API_Expecter) PutBucketWebsite(putBucketWebsiteInput interface{}) *S3API_PutBucketWebsite_Call { + return &S3API_PutBucketWebsite_Call{Call: _e.mock.On("PutBucketWebsite", putBucketWebsiteInput)} +} - var r0 *s3.PutBucketWebsiteOutput - var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error)); ok { - return rf(_a0) - } - if rf, ok := ret.Get(0).(func(*s3.PutBucketWebsiteInput) *s3.PutBucketWebsiteOutput); ok { - r0 = rf(_a0) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*s3.PutBucketWebsiteOutput) +func (_c *S3API_PutBucketWebsite_Call) Run(run func(putBucketWebsiteInput *s3.PutBucketWebsiteInput)) *S3API_PutBucketWebsite_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketWebsiteInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketWebsiteInput) } - } + run( + arg0, + ) + }) + return _c +} - if rf, ok := ret.Get(1).(func(*s3.PutBucketWebsiteInput) error); ok { - r1 = rf(_a0) - } else { - r1 = ret.Error(1) - } +func (_c *S3API_PutBucketWebsite_Call) Return(putBucketWebsiteOutput *s3.PutBucketWebsiteOutput, err error) *S3API_PutBucketWebsite_Call { + _c.Call.Return(putBucketWebsiteOutput, err) + return _c +} - return r0, r1 +func (_c *S3API_PutBucketWebsite_Call) RunAndReturn(run func(putBucketWebsiteInput *s3.PutBucketWebsiteInput) (*s3.PutBucketWebsiteOutput, error)) *S3API_PutBucketWebsite_Call { + _c.Call.Return(run) + return _c } -// PutBucketWebsiteRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutBucketWebsiteRequest(_a0 *s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput) { - ret := _m.Called(_a0) +// PutBucketWebsiteRequest provides a mock function for the type S3API +func (_mock *S3API) PutBucketWebsiteRequest(putBucketWebsiteInput *s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput) { + ret := _mock.Called(putBucketWebsiteInput) + + if len(ret) == 0 { + panic("no return value specified for PutBucketWebsiteRequest") + } var r0 *request.Request var r1 *s3.PutBucketWebsiteOutput - if rf, ok := ret.Get(0).(func(*s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput)); ok { + return returnFunc(putBucketWebsiteInput) } - if rf, ok := ret.Get(0).(func(*s3.PutBucketWebsiteInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutBucketWebsiteInput) *request.Request); ok { + r0 = returnFunc(putBucketWebsiteInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutBucketWebsiteInput) *s3.PutBucketWebsiteOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutBucketWebsiteInput) *s3.PutBucketWebsiteOutput); ok { + r1 = returnFunc(putBucketWebsiteInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutBucketWebsiteOutput) } } - return r0, r1 } -// PutBucketWebsiteWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutBucketWebsiteWithContext(_a0 context.Context, _a1 *s3.PutBucketWebsiteInput, _a2 ...request.Option) (*s3.PutBucketWebsiteOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutBucketWebsiteRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketWebsiteRequest' +type S3API_PutBucketWebsiteRequest_Call struct { + *mock.Call +} + +// PutBucketWebsiteRequest is a helper method to define mock.On call +// - putBucketWebsiteInput *s3.PutBucketWebsiteInput +func (_e *S3API_Expecter) PutBucketWebsiteRequest(putBucketWebsiteInput interface{}) *S3API_PutBucketWebsiteRequest_Call { + return &S3API_PutBucketWebsiteRequest_Call{Call: _e.mock.On("PutBucketWebsiteRequest", putBucketWebsiteInput)} +} + +func (_c *S3API_PutBucketWebsiteRequest_Call) Run(run func(putBucketWebsiteInput *s3.PutBucketWebsiteInput)) *S3API_PutBucketWebsiteRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutBucketWebsiteInput + if args[0] != nil { + arg0 = args[0].(*s3.PutBucketWebsiteInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutBucketWebsiteRequest_Call) Return(request1 *request.Request, putBucketWebsiteOutput *s3.PutBucketWebsiteOutput) *S3API_PutBucketWebsiteRequest_Call { + _c.Call.Return(request1, putBucketWebsiteOutput) + return _c +} + +func (_c *S3API_PutBucketWebsiteRequest_Call) RunAndReturn(run func(putBucketWebsiteInput *s3.PutBucketWebsiteInput) (*request.Request, *s3.PutBucketWebsiteOutput)) *S3API_PutBucketWebsiteRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutBucketWebsiteWithContext provides a mock function for the type S3API +func (_mock *S3API) PutBucketWebsiteWithContext(v aws.Context, putBucketWebsiteInput *s3.PutBucketWebsiteInput, options ...request.Option) (*s3.PutBucketWebsiteOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putBucketWebsiteInput, options) + } else { + tmpRet = _mock.Called(v, putBucketWebsiteInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutBucketWebsiteWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutBucketWebsiteOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketWebsiteInput, ...request.Option) (*s3.PutBucketWebsiteOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketWebsiteInput, ...request.Option) (*s3.PutBucketWebsiteOutput, error)); ok { + return returnFunc(v, putBucketWebsiteInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutBucketWebsiteInput, ...request.Option) *s3.PutBucketWebsiteOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutBucketWebsiteInput, ...request.Option) *s3.PutBucketWebsiteOutput); ok { + r0 = returnFunc(v, putBucketWebsiteInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutBucketWebsiteOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutBucketWebsiteInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutBucketWebsiteInput, ...request.Option) error); ok { + r1 = returnFunc(v, putBucketWebsiteInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutObject provides a mock function with given fields: _a0 -func (_m *S3API) PutObject(_a0 *s3.PutObjectInput) (*s3.PutObjectOutput, error) { - ret := _m.Called(_a0) +// S3API_PutBucketWebsiteWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutBucketWebsiteWithContext' +type S3API_PutBucketWebsiteWithContext_Call struct { + *mock.Call +} + +// PutBucketWebsiteWithContext is a helper method to define mock.On call +// - v aws.Context +// - putBucketWebsiteInput *s3.PutBucketWebsiteInput +// - options ...request.Option +func (_e *S3API_Expecter) PutBucketWebsiteWithContext(v interface{}, putBucketWebsiteInput interface{}, options ...interface{}) *S3API_PutBucketWebsiteWithContext_Call { + return &S3API_PutBucketWebsiteWithContext_Call{Call: _e.mock.On("PutBucketWebsiteWithContext", + append([]interface{}{v, putBucketWebsiteInput}, options...)...)} +} + +func (_c *S3API_PutBucketWebsiteWithContext_Call) Run(run func(v aws.Context, putBucketWebsiteInput *s3.PutBucketWebsiteInput, options ...request.Option)) *S3API_PutBucketWebsiteWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutBucketWebsiteInput + if args[1] != nil { + arg1 = args[1].(*s3.PutBucketWebsiteInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutBucketWebsiteWithContext_Call) Return(putBucketWebsiteOutput *s3.PutBucketWebsiteOutput, err error) *S3API_PutBucketWebsiteWithContext_Call { + _c.Call.Return(putBucketWebsiteOutput, err) + return _c +} + +func (_c *S3API_PutBucketWebsiteWithContext_Call) RunAndReturn(run func(v aws.Context, putBucketWebsiteInput *s3.PutBucketWebsiteInput, options ...request.Option) (*s3.PutBucketWebsiteOutput, error)) *S3API_PutBucketWebsiteWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutObject provides a mock function for the type S3API +func (_mock *S3API) PutObject(putObjectInput *s3.PutObjectInput) (*s3.PutObjectOutput, error) { + ret := _mock.Called(putObjectInput) + + if len(ret) == 0 { + panic("no return value specified for PutObject") + } var r0 *s3.PutObjectOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutObjectInput) (*s3.PutObjectOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectInput) (*s3.PutObjectOutput, error)); ok { + return returnFunc(putObjectInput) } - if rf, ok := ret.Get(0).(func(*s3.PutObjectInput) *s3.PutObjectOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectInput) *s3.PutObjectOutput); ok { + r0 = returnFunc(putObjectInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutObjectOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutObjectInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutObjectInput) error); ok { + r1 = returnFunc(putObjectInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutObjectAcl provides a mock function with given fields: _a0 -func (_m *S3API) PutObjectAcl(_a0 *s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error) { - ret := _m.Called(_a0) +// S3API_PutObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObject' +type S3API_PutObject_Call struct { + *mock.Call +} + +// PutObject is a helper method to define mock.On call +// - putObjectInput *s3.PutObjectInput +func (_e *S3API_Expecter) PutObject(putObjectInput interface{}) *S3API_PutObject_Call { + return &S3API_PutObject_Call{Call: _e.mock.On("PutObject", putObjectInput)} +} + +func (_c *S3API_PutObject_Call) Run(run func(putObjectInput *s3.PutObjectInput)) *S3API_PutObject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutObjectInput + if args[0] != nil { + arg0 = args[0].(*s3.PutObjectInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutObject_Call) Return(putObjectOutput *s3.PutObjectOutput, err error) *S3API_PutObject_Call { + _c.Call.Return(putObjectOutput, err) + return _c +} + +func (_c *S3API_PutObject_Call) RunAndReturn(run func(putObjectInput *s3.PutObjectInput) (*s3.PutObjectOutput, error)) *S3API_PutObject_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectAcl provides a mock function for the type S3API +func (_mock *S3API) PutObjectAcl(putObjectAclInput *s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error) { + ret := _mock.Called(putObjectAclInput) + + if len(ret) == 0 { + panic("no return value specified for PutObjectAcl") + } var r0 *s3.PutObjectAclOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error)); ok { + return returnFunc(putObjectAclInput) } - if rf, ok := ret.Get(0).(func(*s3.PutObjectAclInput) *s3.PutObjectAclOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectAclInput) *s3.PutObjectAclOutput); ok { + r0 = returnFunc(putObjectAclInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutObjectAclOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutObjectAclInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutObjectAclInput) error); ok { + r1 = returnFunc(putObjectAclInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutObjectAclRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutObjectAclRequest(_a0 *s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput) { - ret := _m.Called(_a0) +// S3API_PutObjectAcl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectAcl' +type S3API_PutObjectAcl_Call struct { + *mock.Call +} + +// PutObjectAcl is a helper method to define mock.On call +// - putObjectAclInput *s3.PutObjectAclInput +func (_e *S3API_Expecter) PutObjectAcl(putObjectAclInput interface{}) *S3API_PutObjectAcl_Call { + return &S3API_PutObjectAcl_Call{Call: _e.mock.On("PutObjectAcl", putObjectAclInput)} +} + +func (_c *S3API_PutObjectAcl_Call) Run(run func(putObjectAclInput *s3.PutObjectAclInput)) *S3API_PutObjectAcl_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutObjectAclInput + if args[0] != nil { + arg0 = args[0].(*s3.PutObjectAclInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutObjectAcl_Call) Return(putObjectAclOutput *s3.PutObjectAclOutput, err error) *S3API_PutObjectAcl_Call { + _c.Call.Return(putObjectAclOutput, err) + return _c +} + +func (_c *S3API_PutObjectAcl_Call) RunAndReturn(run func(putObjectAclInput *s3.PutObjectAclInput) (*s3.PutObjectAclOutput, error)) *S3API_PutObjectAcl_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectAclRequest provides a mock function for the type S3API +func (_mock *S3API) PutObjectAclRequest(putObjectAclInput *s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput) { + ret := _mock.Called(putObjectAclInput) + + if len(ret) == 0 { + panic("no return value specified for PutObjectAclRequest") + } var r0 *request.Request var r1 *s3.PutObjectAclOutput - if rf, ok := ret.Get(0).(func(*s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput)); ok { + return returnFunc(putObjectAclInput) } - if rf, ok := ret.Get(0).(func(*s3.PutObjectAclInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectAclInput) *request.Request); ok { + r0 = returnFunc(putObjectAclInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutObjectAclInput) *s3.PutObjectAclOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutObjectAclInput) *s3.PutObjectAclOutput); ok { + r1 = returnFunc(putObjectAclInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutObjectAclOutput) } } - return r0, r1 } -// PutObjectAclWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutObjectAclWithContext(_a0 context.Context, _a1 *s3.PutObjectAclInput, _a2 ...request.Option) (*s3.PutObjectAclOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutObjectAclRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectAclRequest' +type S3API_PutObjectAclRequest_Call struct { + *mock.Call +} + +// PutObjectAclRequest is a helper method to define mock.On call +// - putObjectAclInput *s3.PutObjectAclInput +func (_e *S3API_Expecter) PutObjectAclRequest(putObjectAclInput interface{}) *S3API_PutObjectAclRequest_Call { + return &S3API_PutObjectAclRequest_Call{Call: _e.mock.On("PutObjectAclRequest", putObjectAclInput)} +} + +func (_c *S3API_PutObjectAclRequest_Call) Run(run func(putObjectAclInput *s3.PutObjectAclInput)) *S3API_PutObjectAclRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutObjectAclInput + if args[0] != nil { + arg0 = args[0].(*s3.PutObjectAclInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutObjectAclRequest_Call) Return(request1 *request.Request, putObjectAclOutput *s3.PutObjectAclOutput) *S3API_PutObjectAclRequest_Call { + _c.Call.Return(request1, putObjectAclOutput) + return _c +} + +func (_c *S3API_PutObjectAclRequest_Call) RunAndReturn(run func(putObjectAclInput *s3.PutObjectAclInput) (*request.Request, *s3.PutObjectAclOutput)) *S3API_PutObjectAclRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectAclWithContext provides a mock function for the type S3API +func (_mock *S3API) PutObjectAclWithContext(v aws.Context, putObjectAclInput *s3.PutObjectAclInput, options ...request.Option) (*s3.PutObjectAclOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putObjectAclInput, options) + } else { + tmpRet = _mock.Called(v, putObjectAclInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutObjectAclWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutObjectAclOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectAclInput, ...request.Option) (*s3.PutObjectAclOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectAclInput, ...request.Option) (*s3.PutObjectAclOutput, error)); ok { + return returnFunc(v, putObjectAclInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectAclInput, ...request.Option) *s3.PutObjectAclOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectAclInput, ...request.Option) *s3.PutObjectAclOutput); ok { + r0 = returnFunc(v, putObjectAclInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutObjectAclOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutObjectAclInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutObjectAclInput, ...request.Option) error); ok { + r1 = returnFunc(v, putObjectAclInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutObjectLegalHold provides a mock function with given fields: _a0 -func (_m *S3API) PutObjectLegalHold(_a0 *s3.PutObjectLegalHoldInput) (*s3.PutObjectLegalHoldOutput, error) { - ret := _m.Called(_a0) +// S3API_PutObjectAclWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectAclWithContext' +type S3API_PutObjectAclWithContext_Call struct { + *mock.Call +} + +// PutObjectAclWithContext is a helper method to define mock.On call +// - v aws.Context +// - putObjectAclInput *s3.PutObjectAclInput +// - options ...request.Option +func (_e *S3API_Expecter) PutObjectAclWithContext(v interface{}, putObjectAclInput interface{}, options ...interface{}) *S3API_PutObjectAclWithContext_Call { + return &S3API_PutObjectAclWithContext_Call{Call: _e.mock.On("PutObjectAclWithContext", + append([]interface{}{v, putObjectAclInput}, options...)...)} +} + +func (_c *S3API_PutObjectAclWithContext_Call) Run(run func(v aws.Context, putObjectAclInput *s3.PutObjectAclInput, options ...request.Option)) *S3API_PutObjectAclWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutObjectAclInput + if args[1] != nil { + arg1 = args[1].(*s3.PutObjectAclInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutObjectAclWithContext_Call) Return(putObjectAclOutput *s3.PutObjectAclOutput, err error) *S3API_PutObjectAclWithContext_Call { + _c.Call.Return(putObjectAclOutput, err) + return _c +} + +func (_c *S3API_PutObjectAclWithContext_Call) RunAndReturn(run func(v aws.Context, putObjectAclInput *s3.PutObjectAclInput, options ...request.Option) (*s3.PutObjectAclOutput, error)) *S3API_PutObjectAclWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectLegalHold provides a mock function for the type S3API +func (_mock *S3API) PutObjectLegalHold(putObjectLegalHoldInput *s3.PutObjectLegalHoldInput) (*s3.PutObjectLegalHoldOutput, error) { + ret := _mock.Called(putObjectLegalHoldInput) + + if len(ret) == 0 { + panic("no return value specified for PutObjectLegalHold") + } var r0 *s3.PutObjectLegalHoldOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutObjectLegalHoldInput) (*s3.PutObjectLegalHoldOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectLegalHoldInput) (*s3.PutObjectLegalHoldOutput, error)); ok { + return returnFunc(putObjectLegalHoldInput) } - if rf, ok := ret.Get(0).(func(*s3.PutObjectLegalHoldInput) *s3.PutObjectLegalHoldOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectLegalHoldInput) *s3.PutObjectLegalHoldOutput); ok { + r0 = returnFunc(putObjectLegalHoldInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutObjectLegalHoldOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutObjectLegalHoldInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutObjectLegalHoldInput) error); ok { + r1 = returnFunc(putObjectLegalHoldInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutObjectLegalHoldRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutObjectLegalHoldRequest(_a0 *s3.PutObjectLegalHoldInput) (*request.Request, *s3.PutObjectLegalHoldOutput) { - ret := _m.Called(_a0) +// S3API_PutObjectLegalHold_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectLegalHold' +type S3API_PutObjectLegalHold_Call struct { + *mock.Call +} + +// PutObjectLegalHold is a helper method to define mock.On call +// - putObjectLegalHoldInput *s3.PutObjectLegalHoldInput +func (_e *S3API_Expecter) PutObjectLegalHold(putObjectLegalHoldInput interface{}) *S3API_PutObjectLegalHold_Call { + return &S3API_PutObjectLegalHold_Call{Call: _e.mock.On("PutObjectLegalHold", putObjectLegalHoldInput)} +} + +func (_c *S3API_PutObjectLegalHold_Call) Run(run func(putObjectLegalHoldInput *s3.PutObjectLegalHoldInput)) *S3API_PutObjectLegalHold_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutObjectLegalHoldInput + if args[0] != nil { + arg0 = args[0].(*s3.PutObjectLegalHoldInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutObjectLegalHold_Call) Return(putObjectLegalHoldOutput *s3.PutObjectLegalHoldOutput, err error) *S3API_PutObjectLegalHold_Call { + _c.Call.Return(putObjectLegalHoldOutput, err) + return _c +} + +func (_c *S3API_PutObjectLegalHold_Call) RunAndReturn(run func(putObjectLegalHoldInput *s3.PutObjectLegalHoldInput) (*s3.PutObjectLegalHoldOutput, error)) *S3API_PutObjectLegalHold_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectLegalHoldRequest provides a mock function for the type S3API +func (_mock *S3API) PutObjectLegalHoldRequest(putObjectLegalHoldInput *s3.PutObjectLegalHoldInput) (*request.Request, *s3.PutObjectLegalHoldOutput) { + ret := _mock.Called(putObjectLegalHoldInput) + + if len(ret) == 0 { + panic("no return value specified for PutObjectLegalHoldRequest") + } var r0 *request.Request var r1 *s3.PutObjectLegalHoldOutput - if rf, ok := ret.Get(0).(func(*s3.PutObjectLegalHoldInput) (*request.Request, *s3.PutObjectLegalHoldOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectLegalHoldInput) (*request.Request, *s3.PutObjectLegalHoldOutput)); ok { + return returnFunc(putObjectLegalHoldInput) } - if rf, ok := ret.Get(0).(func(*s3.PutObjectLegalHoldInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectLegalHoldInput) *request.Request); ok { + r0 = returnFunc(putObjectLegalHoldInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutObjectLegalHoldInput) *s3.PutObjectLegalHoldOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutObjectLegalHoldInput) *s3.PutObjectLegalHoldOutput); ok { + r1 = returnFunc(putObjectLegalHoldInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutObjectLegalHoldOutput) } } - return r0, r1 } -// PutObjectLegalHoldWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutObjectLegalHoldWithContext(_a0 context.Context, _a1 *s3.PutObjectLegalHoldInput, _a2 ...request.Option) (*s3.PutObjectLegalHoldOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutObjectLegalHoldRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectLegalHoldRequest' +type S3API_PutObjectLegalHoldRequest_Call struct { + *mock.Call +} + +// PutObjectLegalHoldRequest is a helper method to define mock.On call +// - putObjectLegalHoldInput *s3.PutObjectLegalHoldInput +func (_e *S3API_Expecter) PutObjectLegalHoldRequest(putObjectLegalHoldInput interface{}) *S3API_PutObjectLegalHoldRequest_Call { + return &S3API_PutObjectLegalHoldRequest_Call{Call: _e.mock.On("PutObjectLegalHoldRequest", putObjectLegalHoldInput)} +} + +func (_c *S3API_PutObjectLegalHoldRequest_Call) Run(run func(putObjectLegalHoldInput *s3.PutObjectLegalHoldInput)) *S3API_PutObjectLegalHoldRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutObjectLegalHoldInput + if args[0] != nil { + arg0 = args[0].(*s3.PutObjectLegalHoldInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutObjectLegalHoldRequest_Call) Return(request1 *request.Request, putObjectLegalHoldOutput *s3.PutObjectLegalHoldOutput) *S3API_PutObjectLegalHoldRequest_Call { + _c.Call.Return(request1, putObjectLegalHoldOutput) + return _c +} + +func (_c *S3API_PutObjectLegalHoldRequest_Call) RunAndReturn(run func(putObjectLegalHoldInput *s3.PutObjectLegalHoldInput) (*request.Request, *s3.PutObjectLegalHoldOutput)) *S3API_PutObjectLegalHoldRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectLegalHoldWithContext provides a mock function for the type S3API +func (_mock *S3API) PutObjectLegalHoldWithContext(v aws.Context, putObjectLegalHoldInput *s3.PutObjectLegalHoldInput, options ...request.Option) (*s3.PutObjectLegalHoldOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putObjectLegalHoldInput, options) + } else { + tmpRet = _mock.Called(v, putObjectLegalHoldInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutObjectLegalHoldWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutObjectLegalHoldOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectLegalHoldInput, ...request.Option) (*s3.PutObjectLegalHoldOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectLegalHoldInput, ...request.Option) (*s3.PutObjectLegalHoldOutput, error)); ok { + return returnFunc(v, putObjectLegalHoldInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectLegalHoldInput, ...request.Option) *s3.PutObjectLegalHoldOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectLegalHoldInput, ...request.Option) *s3.PutObjectLegalHoldOutput); ok { + r0 = returnFunc(v, putObjectLegalHoldInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutObjectLegalHoldOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutObjectLegalHoldInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutObjectLegalHoldInput, ...request.Option) error); ok { + r1 = returnFunc(v, putObjectLegalHoldInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutObjectLockConfiguration provides a mock function with given fields: _a0 -func (_m *S3API) PutObjectLockConfiguration(_a0 *s3.PutObjectLockConfigurationInput) (*s3.PutObjectLockConfigurationOutput, error) { - ret := _m.Called(_a0) +// S3API_PutObjectLegalHoldWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectLegalHoldWithContext' +type S3API_PutObjectLegalHoldWithContext_Call struct { + *mock.Call +} + +// PutObjectLegalHoldWithContext is a helper method to define mock.On call +// - v aws.Context +// - putObjectLegalHoldInput *s3.PutObjectLegalHoldInput +// - options ...request.Option +func (_e *S3API_Expecter) PutObjectLegalHoldWithContext(v interface{}, putObjectLegalHoldInput interface{}, options ...interface{}) *S3API_PutObjectLegalHoldWithContext_Call { + return &S3API_PutObjectLegalHoldWithContext_Call{Call: _e.mock.On("PutObjectLegalHoldWithContext", + append([]interface{}{v, putObjectLegalHoldInput}, options...)...)} +} + +func (_c *S3API_PutObjectLegalHoldWithContext_Call) Run(run func(v aws.Context, putObjectLegalHoldInput *s3.PutObjectLegalHoldInput, options ...request.Option)) *S3API_PutObjectLegalHoldWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutObjectLegalHoldInput + if args[1] != nil { + arg1 = args[1].(*s3.PutObjectLegalHoldInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutObjectLegalHoldWithContext_Call) Return(putObjectLegalHoldOutput *s3.PutObjectLegalHoldOutput, err error) *S3API_PutObjectLegalHoldWithContext_Call { + _c.Call.Return(putObjectLegalHoldOutput, err) + return _c +} + +func (_c *S3API_PutObjectLegalHoldWithContext_Call) RunAndReturn(run func(v aws.Context, putObjectLegalHoldInput *s3.PutObjectLegalHoldInput, options ...request.Option) (*s3.PutObjectLegalHoldOutput, error)) *S3API_PutObjectLegalHoldWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectLockConfiguration provides a mock function for the type S3API +func (_mock *S3API) PutObjectLockConfiguration(putObjectLockConfigurationInput *s3.PutObjectLockConfigurationInput) (*s3.PutObjectLockConfigurationOutput, error) { + ret := _mock.Called(putObjectLockConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutObjectLockConfiguration") + } var r0 *s3.PutObjectLockConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutObjectLockConfigurationInput) (*s3.PutObjectLockConfigurationOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectLockConfigurationInput) (*s3.PutObjectLockConfigurationOutput, error)); ok { + return returnFunc(putObjectLockConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutObjectLockConfigurationInput) *s3.PutObjectLockConfigurationOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectLockConfigurationInput) *s3.PutObjectLockConfigurationOutput); ok { + r0 = returnFunc(putObjectLockConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutObjectLockConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutObjectLockConfigurationInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutObjectLockConfigurationInput) error); ok { + r1 = returnFunc(putObjectLockConfigurationInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutObjectLockConfigurationRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutObjectLockConfigurationRequest(_a0 *s3.PutObjectLockConfigurationInput) (*request.Request, *s3.PutObjectLockConfigurationOutput) { - ret := _m.Called(_a0) +// S3API_PutObjectLockConfiguration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectLockConfiguration' +type S3API_PutObjectLockConfiguration_Call struct { + *mock.Call +} + +// PutObjectLockConfiguration is a helper method to define mock.On call +// - putObjectLockConfigurationInput *s3.PutObjectLockConfigurationInput +func (_e *S3API_Expecter) PutObjectLockConfiguration(putObjectLockConfigurationInput interface{}) *S3API_PutObjectLockConfiguration_Call { + return &S3API_PutObjectLockConfiguration_Call{Call: _e.mock.On("PutObjectLockConfiguration", putObjectLockConfigurationInput)} +} + +func (_c *S3API_PutObjectLockConfiguration_Call) Run(run func(putObjectLockConfigurationInput *s3.PutObjectLockConfigurationInput)) *S3API_PutObjectLockConfiguration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutObjectLockConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutObjectLockConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutObjectLockConfiguration_Call) Return(putObjectLockConfigurationOutput *s3.PutObjectLockConfigurationOutput, err error) *S3API_PutObjectLockConfiguration_Call { + _c.Call.Return(putObjectLockConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutObjectLockConfiguration_Call) RunAndReturn(run func(putObjectLockConfigurationInput *s3.PutObjectLockConfigurationInput) (*s3.PutObjectLockConfigurationOutput, error)) *S3API_PutObjectLockConfiguration_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectLockConfigurationRequest provides a mock function for the type S3API +func (_mock *S3API) PutObjectLockConfigurationRequest(putObjectLockConfigurationInput *s3.PutObjectLockConfigurationInput) (*request.Request, *s3.PutObjectLockConfigurationOutput) { + ret := _mock.Called(putObjectLockConfigurationInput) + + if len(ret) == 0 { + panic("no return value specified for PutObjectLockConfigurationRequest") + } var r0 *request.Request var r1 *s3.PutObjectLockConfigurationOutput - if rf, ok := ret.Get(0).(func(*s3.PutObjectLockConfigurationInput) (*request.Request, *s3.PutObjectLockConfigurationOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectLockConfigurationInput) (*request.Request, *s3.PutObjectLockConfigurationOutput)); ok { + return returnFunc(putObjectLockConfigurationInput) } - if rf, ok := ret.Get(0).(func(*s3.PutObjectLockConfigurationInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectLockConfigurationInput) *request.Request); ok { + r0 = returnFunc(putObjectLockConfigurationInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutObjectLockConfigurationInput) *s3.PutObjectLockConfigurationOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutObjectLockConfigurationInput) *s3.PutObjectLockConfigurationOutput); ok { + r1 = returnFunc(putObjectLockConfigurationInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutObjectLockConfigurationOutput) } } - return r0, r1 } -// PutObjectLockConfigurationWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutObjectLockConfigurationWithContext(_a0 context.Context, _a1 *s3.PutObjectLockConfigurationInput, _a2 ...request.Option) (*s3.PutObjectLockConfigurationOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutObjectLockConfigurationRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectLockConfigurationRequest' +type S3API_PutObjectLockConfigurationRequest_Call struct { + *mock.Call +} + +// PutObjectLockConfigurationRequest is a helper method to define mock.On call +// - putObjectLockConfigurationInput *s3.PutObjectLockConfigurationInput +func (_e *S3API_Expecter) PutObjectLockConfigurationRequest(putObjectLockConfigurationInput interface{}) *S3API_PutObjectLockConfigurationRequest_Call { + return &S3API_PutObjectLockConfigurationRequest_Call{Call: _e.mock.On("PutObjectLockConfigurationRequest", putObjectLockConfigurationInput)} +} + +func (_c *S3API_PutObjectLockConfigurationRequest_Call) Run(run func(putObjectLockConfigurationInput *s3.PutObjectLockConfigurationInput)) *S3API_PutObjectLockConfigurationRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutObjectLockConfigurationInput + if args[0] != nil { + arg0 = args[0].(*s3.PutObjectLockConfigurationInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutObjectLockConfigurationRequest_Call) Return(request1 *request.Request, putObjectLockConfigurationOutput *s3.PutObjectLockConfigurationOutput) *S3API_PutObjectLockConfigurationRequest_Call { + _c.Call.Return(request1, putObjectLockConfigurationOutput) + return _c +} + +func (_c *S3API_PutObjectLockConfigurationRequest_Call) RunAndReturn(run func(putObjectLockConfigurationInput *s3.PutObjectLockConfigurationInput) (*request.Request, *s3.PutObjectLockConfigurationOutput)) *S3API_PutObjectLockConfigurationRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectLockConfigurationWithContext provides a mock function for the type S3API +func (_mock *S3API) PutObjectLockConfigurationWithContext(v aws.Context, putObjectLockConfigurationInput *s3.PutObjectLockConfigurationInput, options ...request.Option) (*s3.PutObjectLockConfigurationOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putObjectLockConfigurationInput, options) + } else { + tmpRet = _mock.Called(v, putObjectLockConfigurationInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutObjectLockConfigurationWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutObjectLockConfigurationOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectLockConfigurationInput, ...request.Option) (*s3.PutObjectLockConfigurationOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectLockConfigurationInput, ...request.Option) (*s3.PutObjectLockConfigurationOutput, error)); ok { + return returnFunc(v, putObjectLockConfigurationInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectLockConfigurationInput, ...request.Option) *s3.PutObjectLockConfigurationOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectLockConfigurationInput, ...request.Option) *s3.PutObjectLockConfigurationOutput); ok { + r0 = returnFunc(v, putObjectLockConfigurationInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutObjectLockConfigurationOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutObjectLockConfigurationInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutObjectLockConfigurationInput, ...request.Option) error); ok { + r1 = returnFunc(v, putObjectLockConfigurationInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutObjectRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutObjectRequest(_a0 *s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput) { - ret := _m.Called(_a0) +// S3API_PutObjectLockConfigurationWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectLockConfigurationWithContext' +type S3API_PutObjectLockConfigurationWithContext_Call struct { + *mock.Call +} + +// PutObjectLockConfigurationWithContext is a helper method to define mock.On call +// - v aws.Context +// - putObjectLockConfigurationInput *s3.PutObjectLockConfigurationInput +// - options ...request.Option +func (_e *S3API_Expecter) PutObjectLockConfigurationWithContext(v interface{}, putObjectLockConfigurationInput interface{}, options ...interface{}) *S3API_PutObjectLockConfigurationWithContext_Call { + return &S3API_PutObjectLockConfigurationWithContext_Call{Call: _e.mock.On("PutObjectLockConfigurationWithContext", + append([]interface{}{v, putObjectLockConfigurationInput}, options...)...)} +} + +func (_c *S3API_PutObjectLockConfigurationWithContext_Call) Run(run func(v aws.Context, putObjectLockConfigurationInput *s3.PutObjectLockConfigurationInput, options ...request.Option)) *S3API_PutObjectLockConfigurationWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutObjectLockConfigurationInput + if args[1] != nil { + arg1 = args[1].(*s3.PutObjectLockConfigurationInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutObjectLockConfigurationWithContext_Call) Return(putObjectLockConfigurationOutput *s3.PutObjectLockConfigurationOutput, err error) *S3API_PutObjectLockConfigurationWithContext_Call { + _c.Call.Return(putObjectLockConfigurationOutput, err) + return _c +} + +func (_c *S3API_PutObjectLockConfigurationWithContext_Call) RunAndReturn(run func(v aws.Context, putObjectLockConfigurationInput *s3.PutObjectLockConfigurationInput, options ...request.Option) (*s3.PutObjectLockConfigurationOutput, error)) *S3API_PutObjectLockConfigurationWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectRequest provides a mock function for the type S3API +func (_mock *S3API) PutObjectRequest(putObjectInput *s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput) { + ret := _mock.Called(putObjectInput) + + if len(ret) == 0 { + panic("no return value specified for PutObjectRequest") + } var r0 *request.Request var r1 *s3.PutObjectOutput - if rf, ok := ret.Get(0).(func(*s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput)); ok { + return returnFunc(putObjectInput) } - if rf, ok := ret.Get(0).(func(*s3.PutObjectInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectInput) *request.Request); ok { + r0 = returnFunc(putObjectInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutObjectInput) *s3.PutObjectOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutObjectInput) *s3.PutObjectOutput); ok { + r1 = returnFunc(putObjectInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutObjectOutput) } } - return r0, r1 } -// PutObjectRetention provides a mock function with given fields: _a0 -func (_m *S3API) PutObjectRetention(_a0 *s3.PutObjectRetentionInput) (*s3.PutObjectRetentionOutput, error) { - ret := _m.Called(_a0) +// S3API_PutObjectRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectRequest' +type S3API_PutObjectRequest_Call struct { + *mock.Call +} + +// PutObjectRequest is a helper method to define mock.On call +// - putObjectInput *s3.PutObjectInput +func (_e *S3API_Expecter) PutObjectRequest(putObjectInput interface{}) *S3API_PutObjectRequest_Call { + return &S3API_PutObjectRequest_Call{Call: _e.mock.On("PutObjectRequest", putObjectInput)} +} + +func (_c *S3API_PutObjectRequest_Call) Run(run func(putObjectInput *s3.PutObjectInput)) *S3API_PutObjectRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutObjectInput + if args[0] != nil { + arg0 = args[0].(*s3.PutObjectInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutObjectRequest_Call) Return(request1 *request.Request, putObjectOutput *s3.PutObjectOutput) *S3API_PutObjectRequest_Call { + _c.Call.Return(request1, putObjectOutput) + return _c +} + +func (_c *S3API_PutObjectRequest_Call) RunAndReturn(run func(putObjectInput *s3.PutObjectInput) (*request.Request, *s3.PutObjectOutput)) *S3API_PutObjectRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectRetention provides a mock function for the type S3API +func (_mock *S3API) PutObjectRetention(putObjectRetentionInput *s3.PutObjectRetentionInput) (*s3.PutObjectRetentionOutput, error) { + ret := _mock.Called(putObjectRetentionInput) + + if len(ret) == 0 { + panic("no return value specified for PutObjectRetention") + } var r0 *s3.PutObjectRetentionOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutObjectRetentionInput) (*s3.PutObjectRetentionOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectRetentionInput) (*s3.PutObjectRetentionOutput, error)); ok { + return returnFunc(putObjectRetentionInput) } - if rf, ok := ret.Get(0).(func(*s3.PutObjectRetentionInput) *s3.PutObjectRetentionOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectRetentionInput) *s3.PutObjectRetentionOutput); ok { + r0 = returnFunc(putObjectRetentionInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutObjectRetentionOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutObjectRetentionInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutObjectRetentionInput) error); ok { + r1 = returnFunc(putObjectRetentionInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutObjectRetentionRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutObjectRetentionRequest(_a0 *s3.PutObjectRetentionInput) (*request.Request, *s3.PutObjectRetentionOutput) { - ret := _m.Called(_a0) +// S3API_PutObjectRetention_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectRetention' +type S3API_PutObjectRetention_Call struct { + *mock.Call +} + +// PutObjectRetention is a helper method to define mock.On call +// - putObjectRetentionInput *s3.PutObjectRetentionInput +func (_e *S3API_Expecter) PutObjectRetention(putObjectRetentionInput interface{}) *S3API_PutObjectRetention_Call { + return &S3API_PutObjectRetention_Call{Call: _e.mock.On("PutObjectRetention", putObjectRetentionInput)} +} + +func (_c *S3API_PutObjectRetention_Call) Run(run func(putObjectRetentionInput *s3.PutObjectRetentionInput)) *S3API_PutObjectRetention_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutObjectRetentionInput + if args[0] != nil { + arg0 = args[0].(*s3.PutObjectRetentionInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutObjectRetention_Call) Return(putObjectRetentionOutput *s3.PutObjectRetentionOutput, err error) *S3API_PutObjectRetention_Call { + _c.Call.Return(putObjectRetentionOutput, err) + return _c +} + +func (_c *S3API_PutObjectRetention_Call) RunAndReturn(run func(putObjectRetentionInput *s3.PutObjectRetentionInput) (*s3.PutObjectRetentionOutput, error)) *S3API_PutObjectRetention_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectRetentionRequest provides a mock function for the type S3API +func (_mock *S3API) PutObjectRetentionRequest(putObjectRetentionInput *s3.PutObjectRetentionInput) (*request.Request, *s3.PutObjectRetentionOutput) { + ret := _mock.Called(putObjectRetentionInput) + + if len(ret) == 0 { + panic("no return value specified for PutObjectRetentionRequest") + } var r0 *request.Request var r1 *s3.PutObjectRetentionOutput - if rf, ok := ret.Get(0).(func(*s3.PutObjectRetentionInput) (*request.Request, *s3.PutObjectRetentionOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectRetentionInput) (*request.Request, *s3.PutObjectRetentionOutput)); ok { + return returnFunc(putObjectRetentionInput) } - if rf, ok := ret.Get(0).(func(*s3.PutObjectRetentionInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectRetentionInput) *request.Request); ok { + r0 = returnFunc(putObjectRetentionInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } + if returnFunc, ok := ret.Get(1).(func(*s3.PutObjectRetentionInput) *s3.PutObjectRetentionOutput); ok { + r1 = returnFunc(putObjectRetentionInput) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(*s3.PutObjectRetentionOutput) + } + } + return r0, r1 +} + +// S3API_PutObjectRetentionRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectRetentionRequest' +type S3API_PutObjectRetentionRequest_Call struct { + *mock.Call +} - if rf, ok := ret.Get(1).(func(*s3.PutObjectRetentionInput) *s3.PutObjectRetentionOutput); ok { - r1 = rf(_a0) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*s3.PutObjectRetentionOutput) +// PutObjectRetentionRequest is a helper method to define mock.On call +// - putObjectRetentionInput *s3.PutObjectRetentionInput +func (_e *S3API_Expecter) PutObjectRetentionRequest(putObjectRetentionInput interface{}) *S3API_PutObjectRetentionRequest_Call { + return &S3API_PutObjectRetentionRequest_Call{Call: _e.mock.On("PutObjectRetentionRequest", putObjectRetentionInput)} +} + +func (_c *S3API_PutObjectRetentionRequest_Call) Run(run func(putObjectRetentionInput *s3.PutObjectRetentionInput)) *S3API_PutObjectRetentionRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutObjectRetentionInput + if args[0] != nil { + arg0 = args[0].(*s3.PutObjectRetentionInput) } - } + run( + arg0, + ) + }) + return _c +} - return r0, r1 +func (_c *S3API_PutObjectRetentionRequest_Call) Return(request1 *request.Request, putObjectRetentionOutput *s3.PutObjectRetentionOutput) *S3API_PutObjectRetentionRequest_Call { + _c.Call.Return(request1, putObjectRetentionOutput) + return _c } -// PutObjectRetentionWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutObjectRetentionWithContext(_a0 context.Context, _a1 *s3.PutObjectRetentionInput, _a2 ...request.Option) (*s3.PutObjectRetentionOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +func (_c *S3API_PutObjectRetentionRequest_Call) RunAndReturn(run func(putObjectRetentionInput *s3.PutObjectRetentionInput) (*request.Request, *s3.PutObjectRetentionOutput)) *S3API_PutObjectRetentionRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectRetentionWithContext provides a mock function for the type S3API +func (_mock *S3API) PutObjectRetentionWithContext(v aws.Context, putObjectRetentionInput *s3.PutObjectRetentionInput, options ...request.Option) (*s3.PutObjectRetentionOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putObjectRetentionInput, options) + } else { + tmpRet = _mock.Called(v, putObjectRetentionInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutObjectRetentionWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutObjectRetentionOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectRetentionInput, ...request.Option) (*s3.PutObjectRetentionOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectRetentionInput, ...request.Option) (*s3.PutObjectRetentionOutput, error)); ok { + return returnFunc(v, putObjectRetentionInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectRetentionInput, ...request.Option) *s3.PutObjectRetentionOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectRetentionInput, ...request.Option) *s3.PutObjectRetentionOutput); ok { + r0 = returnFunc(v, putObjectRetentionInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutObjectRetentionOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutObjectRetentionInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutObjectRetentionInput, ...request.Option) error); ok { + r1 = returnFunc(v, putObjectRetentionInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutObjectTagging provides a mock function with given fields: _a0 -func (_m *S3API) PutObjectTagging(_a0 *s3.PutObjectTaggingInput) (*s3.PutObjectTaggingOutput, error) { - ret := _m.Called(_a0) +// S3API_PutObjectRetentionWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectRetentionWithContext' +type S3API_PutObjectRetentionWithContext_Call struct { + *mock.Call +} + +// PutObjectRetentionWithContext is a helper method to define mock.On call +// - v aws.Context +// - putObjectRetentionInput *s3.PutObjectRetentionInput +// - options ...request.Option +func (_e *S3API_Expecter) PutObjectRetentionWithContext(v interface{}, putObjectRetentionInput interface{}, options ...interface{}) *S3API_PutObjectRetentionWithContext_Call { + return &S3API_PutObjectRetentionWithContext_Call{Call: _e.mock.On("PutObjectRetentionWithContext", + append([]interface{}{v, putObjectRetentionInput}, options...)...)} +} + +func (_c *S3API_PutObjectRetentionWithContext_Call) Run(run func(v aws.Context, putObjectRetentionInput *s3.PutObjectRetentionInput, options ...request.Option)) *S3API_PutObjectRetentionWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutObjectRetentionInput + if args[1] != nil { + arg1 = args[1].(*s3.PutObjectRetentionInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutObjectRetentionWithContext_Call) Return(putObjectRetentionOutput *s3.PutObjectRetentionOutput, err error) *S3API_PutObjectRetentionWithContext_Call { + _c.Call.Return(putObjectRetentionOutput, err) + return _c +} + +func (_c *S3API_PutObjectRetentionWithContext_Call) RunAndReturn(run func(v aws.Context, putObjectRetentionInput *s3.PutObjectRetentionInput, options ...request.Option) (*s3.PutObjectRetentionOutput, error)) *S3API_PutObjectRetentionWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectTagging provides a mock function for the type S3API +func (_mock *S3API) PutObjectTagging(putObjectTaggingInput *s3.PutObjectTaggingInput) (*s3.PutObjectTaggingOutput, error) { + ret := _mock.Called(putObjectTaggingInput) + + if len(ret) == 0 { + panic("no return value specified for PutObjectTagging") + } var r0 *s3.PutObjectTaggingOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutObjectTaggingInput) (*s3.PutObjectTaggingOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectTaggingInput) (*s3.PutObjectTaggingOutput, error)); ok { + return returnFunc(putObjectTaggingInput) } - if rf, ok := ret.Get(0).(func(*s3.PutObjectTaggingInput) *s3.PutObjectTaggingOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectTaggingInput) *s3.PutObjectTaggingOutput); ok { + r0 = returnFunc(putObjectTaggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutObjectTaggingOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutObjectTaggingInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutObjectTaggingInput) error); ok { + r1 = returnFunc(putObjectTaggingInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutObjectTaggingRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutObjectTaggingRequest(_a0 *s3.PutObjectTaggingInput) (*request.Request, *s3.PutObjectTaggingOutput) { - ret := _m.Called(_a0) +// S3API_PutObjectTagging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectTagging' +type S3API_PutObjectTagging_Call struct { + *mock.Call +} + +// PutObjectTagging is a helper method to define mock.On call +// - putObjectTaggingInput *s3.PutObjectTaggingInput +func (_e *S3API_Expecter) PutObjectTagging(putObjectTaggingInput interface{}) *S3API_PutObjectTagging_Call { + return &S3API_PutObjectTagging_Call{Call: _e.mock.On("PutObjectTagging", putObjectTaggingInput)} +} + +func (_c *S3API_PutObjectTagging_Call) Run(run func(putObjectTaggingInput *s3.PutObjectTaggingInput)) *S3API_PutObjectTagging_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutObjectTaggingInput + if args[0] != nil { + arg0 = args[0].(*s3.PutObjectTaggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutObjectTagging_Call) Return(putObjectTaggingOutput *s3.PutObjectTaggingOutput, err error) *S3API_PutObjectTagging_Call { + _c.Call.Return(putObjectTaggingOutput, err) + return _c +} + +func (_c *S3API_PutObjectTagging_Call) RunAndReturn(run func(putObjectTaggingInput *s3.PutObjectTaggingInput) (*s3.PutObjectTaggingOutput, error)) *S3API_PutObjectTagging_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectTaggingRequest provides a mock function for the type S3API +func (_mock *S3API) PutObjectTaggingRequest(putObjectTaggingInput *s3.PutObjectTaggingInput) (*request.Request, *s3.PutObjectTaggingOutput) { + ret := _mock.Called(putObjectTaggingInput) + + if len(ret) == 0 { + panic("no return value specified for PutObjectTaggingRequest") + } var r0 *request.Request var r1 *s3.PutObjectTaggingOutput - if rf, ok := ret.Get(0).(func(*s3.PutObjectTaggingInput) (*request.Request, *s3.PutObjectTaggingOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectTaggingInput) (*request.Request, *s3.PutObjectTaggingOutput)); ok { + return returnFunc(putObjectTaggingInput) } - if rf, ok := ret.Get(0).(func(*s3.PutObjectTaggingInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutObjectTaggingInput) *request.Request); ok { + r0 = returnFunc(putObjectTaggingInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutObjectTaggingInput) *s3.PutObjectTaggingOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutObjectTaggingInput) *s3.PutObjectTaggingOutput); ok { + r1 = returnFunc(putObjectTaggingInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutObjectTaggingOutput) } } - return r0, r1 } -// PutObjectTaggingWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutObjectTaggingWithContext(_a0 context.Context, _a1 *s3.PutObjectTaggingInput, _a2 ...request.Option) (*s3.PutObjectTaggingOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutObjectTaggingRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectTaggingRequest' +type S3API_PutObjectTaggingRequest_Call struct { + *mock.Call +} + +// PutObjectTaggingRequest is a helper method to define mock.On call +// - putObjectTaggingInput *s3.PutObjectTaggingInput +func (_e *S3API_Expecter) PutObjectTaggingRequest(putObjectTaggingInput interface{}) *S3API_PutObjectTaggingRequest_Call { + return &S3API_PutObjectTaggingRequest_Call{Call: _e.mock.On("PutObjectTaggingRequest", putObjectTaggingInput)} +} + +func (_c *S3API_PutObjectTaggingRequest_Call) Run(run func(putObjectTaggingInput *s3.PutObjectTaggingInput)) *S3API_PutObjectTaggingRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutObjectTaggingInput + if args[0] != nil { + arg0 = args[0].(*s3.PutObjectTaggingInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutObjectTaggingRequest_Call) Return(request1 *request.Request, putObjectTaggingOutput *s3.PutObjectTaggingOutput) *S3API_PutObjectTaggingRequest_Call { + _c.Call.Return(request1, putObjectTaggingOutput) + return _c +} + +func (_c *S3API_PutObjectTaggingRequest_Call) RunAndReturn(run func(putObjectTaggingInput *s3.PutObjectTaggingInput) (*request.Request, *s3.PutObjectTaggingOutput)) *S3API_PutObjectTaggingRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectTaggingWithContext provides a mock function for the type S3API +func (_mock *S3API) PutObjectTaggingWithContext(v aws.Context, putObjectTaggingInput *s3.PutObjectTaggingInput, options ...request.Option) (*s3.PutObjectTaggingOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putObjectTaggingInput, options) + } else { + tmpRet = _mock.Called(v, putObjectTaggingInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutObjectTaggingWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutObjectTaggingOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectTaggingInput, ...request.Option) (*s3.PutObjectTaggingOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectTaggingInput, ...request.Option) (*s3.PutObjectTaggingOutput, error)); ok { + return returnFunc(v, putObjectTaggingInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectTaggingInput, ...request.Option) *s3.PutObjectTaggingOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectTaggingInput, ...request.Option) *s3.PutObjectTaggingOutput); ok { + r0 = returnFunc(v, putObjectTaggingInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutObjectTaggingOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutObjectTaggingInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutObjectTaggingInput, ...request.Option) error); ok { + r1 = returnFunc(v, putObjectTaggingInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutObjectWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutObjectWithContext(_a0 context.Context, _a1 *s3.PutObjectInput, _a2 ...request.Option) (*s3.PutObjectOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutObjectTaggingWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectTaggingWithContext' +type S3API_PutObjectTaggingWithContext_Call struct { + *mock.Call +} + +// PutObjectTaggingWithContext is a helper method to define mock.On call +// - v aws.Context +// - putObjectTaggingInput *s3.PutObjectTaggingInput +// - options ...request.Option +func (_e *S3API_Expecter) PutObjectTaggingWithContext(v interface{}, putObjectTaggingInput interface{}, options ...interface{}) *S3API_PutObjectTaggingWithContext_Call { + return &S3API_PutObjectTaggingWithContext_Call{Call: _e.mock.On("PutObjectTaggingWithContext", + append([]interface{}{v, putObjectTaggingInput}, options...)...)} +} + +func (_c *S3API_PutObjectTaggingWithContext_Call) Run(run func(v aws.Context, putObjectTaggingInput *s3.PutObjectTaggingInput, options ...request.Option)) *S3API_PutObjectTaggingWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutObjectTaggingInput + if args[1] != nil { + arg1 = args[1].(*s3.PutObjectTaggingInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutObjectTaggingWithContext_Call) Return(putObjectTaggingOutput *s3.PutObjectTaggingOutput, err error) *S3API_PutObjectTaggingWithContext_Call { + _c.Call.Return(putObjectTaggingOutput, err) + return _c +} + +func (_c *S3API_PutObjectTaggingWithContext_Call) RunAndReturn(run func(v aws.Context, putObjectTaggingInput *s3.PutObjectTaggingInput, options ...request.Option) (*s3.PutObjectTaggingOutput, error)) *S3API_PutObjectTaggingWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutObjectWithContext provides a mock function for the type S3API +func (_mock *S3API) PutObjectWithContext(v aws.Context, putObjectInput *s3.PutObjectInput, options ...request.Option) (*s3.PutObjectOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putObjectInput, options) + } else { + tmpRet = _mock.Called(v, putObjectInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutObjectWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutObjectOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectInput, ...request.Option) (*s3.PutObjectOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectInput, ...request.Option) (*s3.PutObjectOutput, error)); ok { + return returnFunc(v, putObjectInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutObjectInput, ...request.Option) *s3.PutObjectOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutObjectInput, ...request.Option) *s3.PutObjectOutput); ok { + r0 = returnFunc(v, putObjectInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutObjectOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutObjectInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutObjectInput, ...request.Option) error); ok { + r1 = returnFunc(v, putObjectInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutPublicAccessBlock provides a mock function with given fields: _a0 -func (_m *S3API) PutPublicAccessBlock(_a0 *s3.PutPublicAccessBlockInput) (*s3.PutPublicAccessBlockOutput, error) { - ret := _m.Called(_a0) +// S3API_PutObjectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutObjectWithContext' +type S3API_PutObjectWithContext_Call struct { + *mock.Call +} + +// PutObjectWithContext is a helper method to define mock.On call +// - v aws.Context +// - putObjectInput *s3.PutObjectInput +// - options ...request.Option +func (_e *S3API_Expecter) PutObjectWithContext(v interface{}, putObjectInput interface{}, options ...interface{}) *S3API_PutObjectWithContext_Call { + return &S3API_PutObjectWithContext_Call{Call: _e.mock.On("PutObjectWithContext", + append([]interface{}{v, putObjectInput}, options...)...)} +} + +func (_c *S3API_PutObjectWithContext_Call) Run(run func(v aws.Context, putObjectInput *s3.PutObjectInput, options ...request.Option)) *S3API_PutObjectWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutObjectInput + if args[1] != nil { + arg1 = args[1].(*s3.PutObjectInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutObjectWithContext_Call) Return(putObjectOutput *s3.PutObjectOutput, err error) *S3API_PutObjectWithContext_Call { + _c.Call.Return(putObjectOutput, err) + return _c +} + +func (_c *S3API_PutObjectWithContext_Call) RunAndReturn(run func(v aws.Context, putObjectInput *s3.PutObjectInput, options ...request.Option) (*s3.PutObjectOutput, error)) *S3API_PutObjectWithContext_Call { + _c.Call.Return(run) + return _c +} + +// PutPublicAccessBlock provides a mock function for the type S3API +func (_mock *S3API) PutPublicAccessBlock(putPublicAccessBlockInput *s3.PutPublicAccessBlockInput) (*s3.PutPublicAccessBlockOutput, error) { + ret := _mock.Called(putPublicAccessBlockInput) + + if len(ret) == 0 { + panic("no return value specified for PutPublicAccessBlock") + } var r0 *s3.PutPublicAccessBlockOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.PutPublicAccessBlockInput) (*s3.PutPublicAccessBlockOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutPublicAccessBlockInput) (*s3.PutPublicAccessBlockOutput, error)); ok { + return returnFunc(putPublicAccessBlockInput) } - if rf, ok := ret.Get(0).(func(*s3.PutPublicAccessBlockInput) *s3.PutPublicAccessBlockOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutPublicAccessBlockInput) *s3.PutPublicAccessBlockOutput); ok { + r0 = returnFunc(putPublicAccessBlockInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutPublicAccessBlockOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.PutPublicAccessBlockInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutPublicAccessBlockInput) error); ok { + r1 = returnFunc(putPublicAccessBlockInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutPublicAccessBlockRequest provides a mock function with given fields: _a0 -func (_m *S3API) PutPublicAccessBlockRequest(_a0 *s3.PutPublicAccessBlockInput) (*request.Request, *s3.PutPublicAccessBlockOutput) { - ret := _m.Called(_a0) +// S3API_PutPublicAccessBlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutPublicAccessBlock' +type S3API_PutPublicAccessBlock_Call struct { + *mock.Call +} + +// PutPublicAccessBlock is a helper method to define mock.On call +// - putPublicAccessBlockInput *s3.PutPublicAccessBlockInput +func (_e *S3API_Expecter) PutPublicAccessBlock(putPublicAccessBlockInput interface{}) *S3API_PutPublicAccessBlock_Call { + return &S3API_PutPublicAccessBlock_Call{Call: _e.mock.On("PutPublicAccessBlock", putPublicAccessBlockInput)} +} + +func (_c *S3API_PutPublicAccessBlock_Call) Run(run func(putPublicAccessBlockInput *s3.PutPublicAccessBlockInput)) *S3API_PutPublicAccessBlock_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutPublicAccessBlockInput + if args[0] != nil { + arg0 = args[0].(*s3.PutPublicAccessBlockInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutPublicAccessBlock_Call) Return(putPublicAccessBlockOutput *s3.PutPublicAccessBlockOutput, err error) *S3API_PutPublicAccessBlock_Call { + _c.Call.Return(putPublicAccessBlockOutput, err) + return _c +} + +func (_c *S3API_PutPublicAccessBlock_Call) RunAndReturn(run func(putPublicAccessBlockInput *s3.PutPublicAccessBlockInput) (*s3.PutPublicAccessBlockOutput, error)) *S3API_PutPublicAccessBlock_Call { + _c.Call.Return(run) + return _c +} + +// PutPublicAccessBlockRequest provides a mock function for the type S3API +func (_mock *S3API) PutPublicAccessBlockRequest(putPublicAccessBlockInput *s3.PutPublicAccessBlockInput) (*request.Request, *s3.PutPublicAccessBlockOutput) { + ret := _mock.Called(putPublicAccessBlockInput) + + if len(ret) == 0 { + panic("no return value specified for PutPublicAccessBlockRequest") + } var r0 *request.Request var r1 *s3.PutPublicAccessBlockOutput - if rf, ok := ret.Get(0).(func(*s3.PutPublicAccessBlockInput) (*request.Request, *s3.PutPublicAccessBlockOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutPublicAccessBlockInput) (*request.Request, *s3.PutPublicAccessBlockOutput)); ok { + return returnFunc(putPublicAccessBlockInput) } - if rf, ok := ret.Get(0).(func(*s3.PutPublicAccessBlockInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.PutPublicAccessBlockInput) *request.Request); ok { + r0 = returnFunc(putPublicAccessBlockInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.PutPublicAccessBlockInput) *s3.PutPublicAccessBlockOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.PutPublicAccessBlockInput) *s3.PutPublicAccessBlockOutput); ok { + r1 = returnFunc(putPublicAccessBlockInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.PutPublicAccessBlockOutput) } } - return r0, r1 } -// PutPublicAccessBlockWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) PutPublicAccessBlockWithContext(_a0 context.Context, _a1 *s3.PutPublicAccessBlockInput, _a2 ...request.Option) (*s3.PutPublicAccessBlockOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_PutPublicAccessBlockRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutPublicAccessBlockRequest' +type S3API_PutPublicAccessBlockRequest_Call struct { + *mock.Call +} + +// PutPublicAccessBlockRequest is a helper method to define mock.On call +// - putPublicAccessBlockInput *s3.PutPublicAccessBlockInput +func (_e *S3API_Expecter) PutPublicAccessBlockRequest(putPublicAccessBlockInput interface{}) *S3API_PutPublicAccessBlockRequest_Call { + return &S3API_PutPublicAccessBlockRequest_Call{Call: _e.mock.On("PutPublicAccessBlockRequest", putPublicAccessBlockInput)} +} + +func (_c *S3API_PutPublicAccessBlockRequest_Call) Run(run func(putPublicAccessBlockInput *s3.PutPublicAccessBlockInput)) *S3API_PutPublicAccessBlockRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.PutPublicAccessBlockInput + if args[0] != nil { + arg0 = args[0].(*s3.PutPublicAccessBlockInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_PutPublicAccessBlockRequest_Call) Return(request1 *request.Request, putPublicAccessBlockOutput *s3.PutPublicAccessBlockOutput) *S3API_PutPublicAccessBlockRequest_Call { + _c.Call.Return(request1, putPublicAccessBlockOutput) + return _c +} + +func (_c *S3API_PutPublicAccessBlockRequest_Call) RunAndReturn(run func(putPublicAccessBlockInput *s3.PutPublicAccessBlockInput) (*request.Request, *s3.PutPublicAccessBlockOutput)) *S3API_PutPublicAccessBlockRequest_Call { + _c.Call.Return(run) + return _c +} + +// PutPublicAccessBlockWithContext provides a mock function for the type S3API +func (_mock *S3API) PutPublicAccessBlockWithContext(v aws.Context, putPublicAccessBlockInput *s3.PutPublicAccessBlockInput, options ...request.Option) (*s3.PutPublicAccessBlockOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, putPublicAccessBlockInput, options) + } else { + tmpRet = _mock.Called(v, putPublicAccessBlockInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for PutPublicAccessBlockWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.PutPublicAccessBlockOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutPublicAccessBlockInput, ...request.Option) (*s3.PutPublicAccessBlockOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutPublicAccessBlockInput, ...request.Option) (*s3.PutPublicAccessBlockOutput, error)); ok { + return returnFunc(v, putPublicAccessBlockInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.PutPublicAccessBlockInput, ...request.Option) *s3.PutPublicAccessBlockOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.PutPublicAccessBlockInput, ...request.Option) *s3.PutPublicAccessBlockOutput); ok { + r0 = returnFunc(v, putPublicAccessBlockInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.PutPublicAccessBlockOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.PutPublicAccessBlockInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.PutPublicAccessBlockInput, ...request.Option) error); ok { + r1 = returnFunc(v, putPublicAccessBlockInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// RestoreObject provides a mock function with given fields: _a0 -func (_m *S3API) RestoreObject(_a0 *s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error) { - ret := _m.Called(_a0) +// S3API_PutPublicAccessBlockWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutPublicAccessBlockWithContext' +type S3API_PutPublicAccessBlockWithContext_Call struct { + *mock.Call +} + +// PutPublicAccessBlockWithContext is a helper method to define mock.On call +// - v aws.Context +// - putPublicAccessBlockInput *s3.PutPublicAccessBlockInput +// - options ...request.Option +func (_e *S3API_Expecter) PutPublicAccessBlockWithContext(v interface{}, putPublicAccessBlockInput interface{}, options ...interface{}) *S3API_PutPublicAccessBlockWithContext_Call { + return &S3API_PutPublicAccessBlockWithContext_Call{Call: _e.mock.On("PutPublicAccessBlockWithContext", + append([]interface{}{v, putPublicAccessBlockInput}, options...)...)} +} + +func (_c *S3API_PutPublicAccessBlockWithContext_Call) Run(run func(v aws.Context, putPublicAccessBlockInput *s3.PutPublicAccessBlockInput, options ...request.Option)) *S3API_PutPublicAccessBlockWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.PutPublicAccessBlockInput + if args[1] != nil { + arg1 = args[1].(*s3.PutPublicAccessBlockInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_PutPublicAccessBlockWithContext_Call) Return(putPublicAccessBlockOutput *s3.PutPublicAccessBlockOutput, err error) *S3API_PutPublicAccessBlockWithContext_Call { + _c.Call.Return(putPublicAccessBlockOutput, err) + return _c +} + +func (_c *S3API_PutPublicAccessBlockWithContext_Call) RunAndReturn(run func(v aws.Context, putPublicAccessBlockInput *s3.PutPublicAccessBlockInput, options ...request.Option) (*s3.PutPublicAccessBlockOutput, error)) *S3API_PutPublicAccessBlockWithContext_Call { + _c.Call.Return(run) + return _c +} + +// RestoreObject provides a mock function for the type S3API +func (_mock *S3API) RestoreObject(restoreObjectInput *s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error) { + ret := _mock.Called(restoreObjectInput) + + if len(ret) == 0 { + panic("no return value specified for RestoreObject") + } var r0 *s3.RestoreObjectOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error)); ok { + return returnFunc(restoreObjectInput) } - if rf, ok := ret.Get(0).(func(*s3.RestoreObjectInput) *s3.RestoreObjectOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.RestoreObjectInput) *s3.RestoreObjectOutput); ok { + r0 = returnFunc(restoreObjectInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.RestoreObjectOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.RestoreObjectInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.RestoreObjectInput) error); ok { + r1 = returnFunc(restoreObjectInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// RestoreObjectRequest provides a mock function with given fields: _a0 -func (_m *S3API) RestoreObjectRequest(_a0 *s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput) { - ret := _m.Called(_a0) +// S3API_RestoreObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreObject' +type S3API_RestoreObject_Call struct { + *mock.Call +} + +// RestoreObject is a helper method to define mock.On call +// - restoreObjectInput *s3.RestoreObjectInput +func (_e *S3API_Expecter) RestoreObject(restoreObjectInput interface{}) *S3API_RestoreObject_Call { + return &S3API_RestoreObject_Call{Call: _e.mock.On("RestoreObject", restoreObjectInput)} +} + +func (_c *S3API_RestoreObject_Call) Run(run func(restoreObjectInput *s3.RestoreObjectInput)) *S3API_RestoreObject_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.RestoreObjectInput + if args[0] != nil { + arg0 = args[0].(*s3.RestoreObjectInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_RestoreObject_Call) Return(restoreObjectOutput *s3.RestoreObjectOutput, err error) *S3API_RestoreObject_Call { + _c.Call.Return(restoreObjectOutput, err) + return _c +} + +func (_c *S3API_RestoreObject_Call) RunAndReturn(run func(restoreObjectInput *s3.RestoreObjectInput) (*s3.RestoreObjectOutput, error)) *S3API_RestoreObject_Call { + _c.Call.Return(run) + return _c +} + +// RestoreObjectRequest provides a mock function for the type S3API +func (_mock *S3API) RestoreObjectRequest(restoreObjectInput *s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput) { + ret := _mock.Called(restoreObjectInput) + + if len(ret) == 0 { + panic("no return value specified for RestoreObjectRequest") + } var r0 *request.Request var r1 *s3.RestoreObjectOutput - if rf, ok := ret.Get(0).(func(*s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput)); ok { + return returnFunc(restoreObjectInput) } - if rf, ok := ret.Get(0).(func(*s3.RestoreObjectInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.RestoreObjectInput) *request.Request); ok { + r0 = returnFunc(restoreObjectInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.RestoreObjectInput) *s3.RestoreObjectOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.RestoreObjectInput) *s3.RestoreObjectOutput); ok { + r1 = returnFunc(restoreObjectInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.RestoreObjectOutput) } } - return r0, r1 } -// RestoreObjectWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) RestoreObjectWithContext(_a0 context.Context, _a1 *s3.RestoreObjectInput, _a2 ...request.Option) (*s3.RestoreObjectOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_RestoreObjectRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreObjectRequest' +type S3API_RestoreObjectRequest_Call struct { + *mock.Call +} + +// RestoreObjectRequest is a helper method to define mock.On call +// - restoreObjectInput *s3.RestoreObjectInput +func (_e *S3API_Expecter) RestoreObjectRequest(restoreObjectInput interface{}) *S3API_RestoreObjectRequest_Call { + return &S3API_RestoreObjectRequest_Call{Call: _e.mock.On("RestoreObjectRequest", restoreObjectInput)} +} + +func (_c *S3API_RestoreObjectRequest_Call) Run(run func(restoreObjectInput *s3.RestoreObjectInput)) *S3API_RestoreObjectRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.RestoreObjectInput + if args[0] != nil { + arg0 = args[0].(*s3.RestoreObjectInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_RestoreObjectRequest_Call) Return(request1 *request.Request, restoreObjectOutput *s3.RestoreObjectOutput) *S3API_RestoreObjectRequest_Call { + _c.Call.Return(request1, restoreObjectOutput) + return _c +} + +func (_c *S3API_RestoreObjectRequest_Call) RunAndReturn(run func(restoreObjectInput *s3.RestoreObjectInput) (*request.Request, *s3.RestoreObjectOutput)) *S3API_RestoreObjectRequest_Call { + _c.Call.Return(run) + return _c +} + +// RestoreObjectWithContext provides a mock function for the type S3API +func (_mock *S3API) RestoreObjectWithContext(v aws.Context, restoreObjectInput *s3.RestoreObjectInput, options ...request.Option) (*s3.RestoreObjectOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, restoreObjectInput, options) + } else { + tmpRet = _mock.Called(v, restoreObjectInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for RestoreObjectWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.RestoreObjectOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.RestoreObjectInput, ...request.Option) (*s3.RestoreObjectOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.RestoreObjectInput, ...request.Option) (*s3.RestoreObjectOutput, error)); ok { + return returnFunc(v, restoreObjectInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.RestoreObjectInput, ...request.Option) *s3.RestoreObjectOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.RestoreObjectInput, ...request.Option) *s3.RestoreObjectOutput); ok { + r0 = returnFunc(v, restoreObjectInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.RestoreObjectOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.RestoreObjectInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.RestoreObjectInput, ...request.Option) error); ok { + r1 = returnFunc(v, restoreObjectInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// SelectObjectContent provides a mock function with given fields: _a0 -func (_m *S3API) SelectObjectContent(_a0 *s3.SelectObjectContentInput) (*s3.SelectObjectContentOutput, error) { - ret := _m.Called(_a0) +// S3API_RestoreObjectWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RestoreObjectWithContext' +type S3API_RestoreObjectWithContext_Call struct { + *mock.Call +} + +// RestoreObjectWithContext is a helper method to define mock.On call +// - v aws.Context +// - restoreObjectInput *s3.RestoreObjectInput +// - options ...request.Option +func (_e *S3API_Expecter) RestoreObjectWithContext(v interface{}, restoreObjectInput interface{}, options ...interface{}) *S3API_RestoreObjectWithContext_Call { + return &S3API_RestoreObjectWithContext_Call{Call: _e.mock.On("RestoreObjectWithContext", + append([]interface{}{v, restoreObjectInput}, options...)...)} +} + +func (_c *S3API_RestoreObjectWithContext_Call) Run(run func(v aws.Context, restoreObjectInput *s3.RestoreObjectInput, options ...request.Option)) *S3API_RestoreObjectWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.RestoreObjectInput + if args[1] != nil { + arg1 = args[1].(*s3.RestoreObjectInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_RestoreObjectWithContext_Call) Return(restoreObjectOutput *s3.RestoreObjectOutput, err error) *S3API_RestoreObjectWithContext_Call { + _c.Call.Return(restoreObjectOutput, err) + return _c +} + +func (_c *S3API_RestoreObjectWithContext_Call) RunAndReturn(run func(v aws.Context, restoreObjectInput *s3.RestoreObjectInput, options ...request.Option) (*s3.RestoreObjectOutput, error)) *S3API_RestoreObjectWithContext_Call { + _c.Call.Return(run) + return _c +} + +// SelectObjectContent provides a mock function for the type S3API +func (_mock *S3API) SelectObjectContent(selectObjectContentInput *s3.SelectObjectContentInput) (*s3.SelectObjectContentOutput, error) { + ret := _mock.Called(selectObjectContentInput) + + if len(ret) == 0 { + panic("no return value specified for SelectObjectContent") + } var r0 *s3.SelectObjectContentOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.SelectObjectContentInput) (*s3.SelectObjectContentOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.SelectObjectContentInput) (*s3.SelectObjectContentOutput, error)); ok { + return returnFunc(selectObjectContentInput) } - if rf, ok := ret.Get(0).(func(*s3.SelectObjectContentInput) *s3.SelectObjectContentOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.SelectObjectContentInput) *s3.SelectObjectContentOutput); ok { + r0 = returnFunc(selectObjectContentInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.SelectObjectContentOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.SelectObjectContentInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.SelectObjectContentInput) error); ok { + r1 = returnFunc(selectObjectContentInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// SelectObjectContentRequest provides a mock function with given fields: _a0 -func (_m *S3API) SelectObjectContentRequest(_a0 *s3.SelectObjectContentInput) (*request.Request, *s3.SelectObjectContentOutput) { - ret := _m.Called(_a0) +// S3API_SelectObjectContent_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectObjectContent' +type S3API_SelectObjectContent_Call struct { + *mock.Call +} + +// SelectObjectContent is a helper method to define mock.On call +// - selectObjectContentInput *s3.SelectObjectContentInput +func (_e *S3API_Expecter) SelectObjectContent(selectObjectContentInput interface{}) *S3API_SelectObjectContent_Call { + return &S3API_SelectObjectContent_Call{Call: _e.mock.On("SelectObjectContent", selectObjectContentInput)} +} + +func (_c *S3API_SelectObjectContent_Call) Run(run func(selectObjectContentInput *s3.SelectObjectContentInput)) *S3API_SelectObjectContent_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.SelectObjectContentInput + if args[0] != nil { + arg0 = args[0].(*s3.SelectObjectContentInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_SelectObjectContent_Call) Return(selectObjectContentOutput *s3.SelectObjectContentOutput, err error) *S3API_SelectObjectContent_Call { + _c.Call.Return(selectObjectContentOutput, err) + return _c +} + +func (_c *S3API_SelectObjectContent_Call) RunAndReturn(run func(selectObjectContentInput *s3.SelectObjectContentInput) (*s3.SelectObjectContentOutput, error)) *S3API_SelectObjectContent_Call { + _c.Call.Return(run) + return _c +} + +// SelectObjectContentRequest provides a mock function for the type S3API +func (_mock *S3API) SelectObjectContentRequest(selectObjectContentInput *s3.SelectObjectContentInput) (*request.Request, *s3.SelectObjectContentOutput) { + ret := _mock.Called(selectObjectContentInput) + + if len(ret) == 0 { + panic("no return value specified for SelectObjectContentRequest") + } var r0 *request.Request var r1 *s3.SelectObjectContentOutput - if rf, ok := ret.Get(0).(func(*s3.SelectObjectContentInput) (*request.Request, *s3.SelectObjectContentOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.SelectObjectContentInput) (*request.Request, *s3.SelectObjectContentOutput)); ok { + return returnFunc(selectObjectContentInput) } - if rf, ok := ret.Get(0).(func(*s3.SelectObjectContentInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.SelectObjectContentInput) *request.Request); ok { + r0 = returnFunc(selectObjectContentInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.SelectObjectContentInput) *s3.SelectObjectContentOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.SelectObjectContentInput) *s3.SelectObjectContentOutput); ok { + r1 = returnFunc(selectObjectContentInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.SelectObjectContentOutput) } } - return r0, r1 } -// SelectObjectContentWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) SelectObjectContentWithContext(_a0 context.Context, _a1 *s3.SelectObjectContentInput, _a2 ...request.Option) (*s3.SelectObjectContentOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_SelectObjectContentRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectObjectContentRequest' +type S3API_SelectObjectContentRequest_Call struct { + *mock.Call +} + +// SelectObjectContentRequest is a helper method to define mock.On call +// - selectObjectContentInput *s3.SelectObjectContentInput +func (_e *S3API_Expecter) SelectObjectContentRequest(selectObjectContentInput interface{}) *S3API_SelectObjectContentRequest_Call { + return &S3API_SelectObjectContentRequest_Call{Call: _e.mock.On("SelectObjectContentRequest", selectObjectContentInput)} +} + +func (_c *S3API_SelectObjectContentRequest_Call) Run(run func(selectObjectContentInput *s3.SelectObjectContentInput)) *S3API_SelectObjectContentRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.SelectObjectContentInput + if args[0] != nil { + arg0 = args[0].(*s3.SelectObjectContentInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_SelectObjectContentRequest_Call) Return(request1 *request.Request, selectObjectContentOutput *s3.SelectObjectContentOutput) *S3API_SelectObjectContentRequest_Call { + _c.Call.Return(request1, selectObjectContentOutput) + return _c +} + +func (_c *S3API_SelectObjectContentRequest_Call) RunAndReturn(run func(selectObjectContentInput *s3.SelectObjectContentInput) (*request.Request, *s3.SelectObjectContentOutput)) *S3API_SelectObjectContentRequest_Call { + _c.Call.Return(run) + return _c +} + +// SelectObjectContentWithContext provides a mock function for the type S3API +func (_mock *S3API) SelectObjectContentWithContext(v aws.Context, selectObjectContentInput *s3.SelectObjectContentInput, options ...request.Option) (*s3.SelectObjectContentOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, selectObjectContentInput, options) + } else { + tmpRet = _mock.Called(v, selectObjectContentInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for SelectObjectContentWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.SelectObjectContentOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.SelectObjectContentInput, ...request.Option) (*s3.SelectObjectContentOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.SelectObjectContentInput, ...request.Option) (*s3.SelectObjectContentOutput, error)); ok { + return returnFunc(v, selectObjectContentInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.SelectObjectContentInput, ...request.Option) *s3.SelectObjectContentOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.SelectObjectContentInput, ...request.Option) *s3.SelectObjectContentOutput); ok { + r0 = returnFunc(v, selectObjectContentInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.SelectObjectContentOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.SelectObjectContentInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.SelectObjectContentInput, ...request.Option) error); ok { + r1 = returnFunc(v, selectObjectContentInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// UploadPart provides a mock function with given fields: _a0 -func (_m *S3API) UploadPart(_a0 *s3.UploadPartInput) (*s3.UploadPartOutput, error) { - ret := _m.Called(_a0) +// S3API_SelectObjectContentWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SelectObjectContentWithContext' +type S3API_SelectObjectContentWithContext_Call struct { + *mock.Call +} + +// SelectObjectContentWithContext is a helper method to define mock.On call +// - v aws.Context +// - selectObjectContentInput *s3.SelectObjectContentInput +// - options ...request.Option +func (_e *S3API_Expecter) SelectObjectContentWithContext(v interface{}, selectObjectContentInput interface{}, options ...interface{}) *S3API_SelectObjectContentWithContext_Call { + return &S3API_SelectObjectContentWithContext_Call{Call: _e.mock.On("SelectObjectContentWithContext", + append([]interface{}{v, selectObjectContentInput}, options...)...)} +} + +func (_c *S3API_SelectObjectContentWithContext_Call) Run(run func(v aws.Context, selectObjectContentInput *s3.SelectObjectContentInput, options ...request.Option)) *S3API_SelectObjectContentWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.SelectObjectContentInput + if args[1] != nil { + arg1 = args[1].(*s3.SelectObjectContentInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_SelectObjectContentWithContext_Call) Return(selectObjectContentOutput *s3.SelectObjectContentOutput, err error) *S3API_SelectObjectContentWithContext_Call { + _c.Call.Return(selectObjectContentOutput, err) + return _c +} + +func (_c *S3API_SelectObjectContentWithContext_Call) RunAndReturn(run func(v aws.Context, selectObjectContentInput *s3.SelectObjectContentInput, options ...request.Option) (*s3.SelectObjectContentOutput, error)) *S3API_SelectObjectContentWithContext_Call { + _c.Call.Return(run) + return _c +} + +// UploadPart provides a mock function for the type S3API +func (_mock *S3API) UploadPart(uploadPartInput *s3.UploadPartInput) (*s3.UploadPartOutput, error) { + ret := _mock.Called(uploadPartInput) + + if len(ret) == 0 { + panic("no return value specified for UploadPart") + } var r0 *s3.UploadPartOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.UploadPartInput) (*s3.UploadPartOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.UploadPartInput) (*s3.UploadPartOutput, error)); ok { + return returnFunc(uploadPartInput) } - if rf, ok := ret.Get(0).(func(*s3.UploadPartInput) *s3.UploadPartOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.UploadPartInput) *s3.UploadPartOutput); ok { + r0 = returnFunc(uploadPartInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.UploadPartOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.UploadPartInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.UploadPartInput) error); ok { + r1 = returnFunc(uploadPartInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// UploadPartCopy provides a mock function with given fields: _a0 -func (_m *S3API) UploadPartCopy(_a0 *s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error) { - ret := _m.Called(_a0) +// S3API_UploadPart_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPart' +type S3API_UploadPart_Call struct { + *mock.Call +} + +// UploadPart is a helper method to define mock.On call +// - uploadPartInput *s3.UploadPartInput +func (_e *S3API_Expecter) UploadPart(uploadPartInput interface{}) *S3API_UploadPart_Call { + return &S3API_UploadPart_Call{Call: _e.mock.On("UploadPart", uploadPartInput)} +} + +func (_c *S3API_UploadPart_Call) Run(run func(uploadPartInput *s3.UploadPartInput)) *S3API_UploadPart_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.UploadPartInput + if args[0] != nil { + arg0 = args[0].(*s3.UploadPartInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_UploadPart_Call) Return(uploadPartOutput *s3.UploadPartOutput, err error) *S3API_UploadPart_Call { + _c.Call.Return(uploadPartOutput, err) + return _c +} + +func (_c *S3API_UploadPart_Call) RunAndReturn(run func(uploadPartInput *s3.UploadPartInput) (*s3.UploadPartOutput, error)) *S3API_UploadPart_Call { + _c.Call.Return(run) + return _c +} + +// UploadPartCopy provides a mock function for the type S3API +func (_mock *S3API) UploadPartCopy(uploadPartCopyInput *s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error) { + ret := _mock.Called(uploadPartCopyInput) + + if len(ret) == 0 { + panic("no return value specified for UploadPartCopy") + } var r0 *s3.UploadPartCopyOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error)); ok { + return returnFunc(uploadPartCopyInput) } - if rf, ok := ret.Get(0).(func(*s3.UploadPartCopyInput) *s3.UploadPartCopyOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.UploadPartCopyInput) *s3.UploadPartCopyOutput); ok { + r0 = returnFunc(uploadPartCopyInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.UploadPartCopyOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.UploadPartCopyInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.UploadPartCopyInput) error); ok { + r1 = returnFunc(uploadPartCopyInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// UploadPartCopyRequest provides a mock function with given fields: _a0 -func (_m *S3API) UploadPartCopyRequest(_a0 *s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput) { - ret := _m.Called(_a0) +// S3API_UploadPartCopy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPartCopy' +type S3API_UploadPartCopy_Call struct { + *mock.Call +} + +// UploadPartCopy is a helper method to define mock.On call +// - uploadPartCopyInput *s3.UploadPartCopyInput +func (_e *S3API_Expecter) UploadPartCopy(uploadPartCopyInput interface{}) *S3API_UploadPartCopy_Call { + return &S3API_UploadPartCopy_Call{Call: _e.mock.On("UploadPartCopy", uploadPartCopyInput)} +} + +func (_c *S3API_UploadPartCopy_Call) Run(run func(uploadPartCopyInput *s3.UploadPartCopyInput)) *S3API_UploadPartCopy_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.UploadPartCopyInput + if args[0] != nil { + arg0 = args[0].(*s3.UploadPartCopyInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_UploadPartCopy_Call) Return(uploadPartCopyOutput *s3.UploadPartCopyOutput, err error) *S3API_UploadPartCopy_Call { + _c.Call.Return(uploadPartCopyOutput, err) + return _c +} + +func (_c *S3API_UploadPartCopy_Call) RunAndReturn(run func(uploadPartCopyInput *s3.UploadPartCopyInput) (*s3.UploadPartCopyOutput, error)) *S3API_UploadPartCopy_Call { + _c.Call.Return(run) + return _c +} + +// UploadPartCopyRequest provides a mock function for the type S3API +func (_mock *S3API) UploadPartCopyRequest(uploadPartCopyInput *s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput) { + ret := _mock.Called(uploadPartCopyInput) + + if len(ret) == 0 { + panic("no return value specified for UploadPartCopyRequest") + } var r0 *request.Request var r1 *s3.UploadPartCopyOutput - if rf, ok := ret.Get(0).(func(*s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput)); ok { + return returnFunc(uploadPartCopyInput) } - if rf, ok := ret.Get(0).(func(*s3.UploadPartCopyInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.UploadPartCopyInput) *request.Request); ok { + r0 = returnFunc(uploadPartCopyInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.UploadPartCopyInput) *s3.UploadPartCopyOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.UploadPartCopyInput) *s3.UploadPartCopyOutput); ok { + r1 = returnFunc(uploadPartCopyInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.UploadPartCopyOutput) } } - return r0, r1 } -// UploadPartCopyWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) UploadPartCopyWithContext(_a0 context.Context, _a1 *s3.UploadPartCopyInput, _a2 ...request.Option) (*s3.UploadPartCopyOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_UploadPartCopyRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPartCopyRequest' +type S3API_UploadPartCopyRequest_Call struct { + *mock.Call +} + +// UploadPartCopyRequest is a helper method to define mock.On call +// - uploadPartCopyInput *s3.UploadPartCopyInput +func (_e *S3API_Expecter) UploadPartCopyRequest(uploadPartCopyInput interface{}) *S3API_UploadPartCopyRequest_Call { + return &S3API_UploadPartCopyRequest_Call{Call: _e.mock.On("UploadPartCopyRequest", uploadPartCopyInput)} +} + +func (_c *S3API_UploadPartCopyRequest_Call) Run(run func(uploadPartCopyInput *s3.UploadPartCopyInput)) *S3API_UploadPartCopyRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.UploadPartCopyInput + if args[0] != nil { + arg0 = args[0].(*s3.UploadPartCopyInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_UploadPartCopyRequest_Call) Return(request1 *request.Request, uploadPartCopyOutput *s3.UploadPartCopyOutput) *S3API_UploadPartCopyRequest_Call { + _c.Call.Return(request1, uploadPartCopyOutput) + return _c +} + +func (_c *S3API_UploadPartCopyRequest_Call) RunAndReturn(run func(uploadPartCopyInput *s3.UploadPartCopyInput) (*request.Request, *s3.UploadPartCopyOutput)) *S3API_UploadPartCopyRequest_Call { + _c.Call.Return(run) + return _c +} + +// UploadPartCopyWithContext provides a mock function for the type S3API +func (_mock *S3API) UploadPartCopyWithContext(v aws.Context, uploadPartCopyInput *s3.UploadPartCopyInput, options ...request.Option) (*s3.UploadPartCopyOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, uploadPartCopyInput, options) + } else { + tmpRet = _mock.Called(v, uploadPartCopyInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for UploadPartCopyWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.UploadPartCopyOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.UploadPartCopyInput, ...request.Option) (*s3.UploadPartCopyOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.UploadPartCopyInput, ...request.Option) (*s3.UploadPartCopyOutput, error)); ok { + return returnFunc(v, uploadPartCopyInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.UploadPartCopyInput, ...request.Option) *s3.UploadPartCopyOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.UploadPartCopyInput, ...request.Option) *s3.UploadPartCopyOutput); ok { + r0 = returnFunc(v, uploadPartCopyInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.UploadPartCopyOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.UploadPartCopyInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.UploadPartCopyInput, ...request.Option) error); ok { + r1 = returnFunc(v, uploadPartCopyInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// UploadPartRequest provides a mock function with given fields: _a0 -func (_m *S3API) UploadPartRequest(_a0 *s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput) { - ret := _m.Called(_a0) +// S3API_UploadPartCopyWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPartCopyWithContext' +type S3API_UploadPartCopyWithContext_Call struct { + *mock.Call +} + +// UploadPartCopyWithContext is a helper method to define mock.On call +// - v aws.Context +// - uploadPartCopyInput *s3.UploadPartCopyInput +// - options ...request.Option +func (_e *S3API_Expecter) UploadPartCopyWithContext(v interface{}, uploadPartCopyInput interface{}, options ...interface{}) *S3API_UploadPartCopyWithContext_Call { + return &S3API_UploadPartCopyWithContext_Call{Call: _e.mock.On("UploadPartCopyWithContext", + append([]interface{}{v, uploadPartCopyInput}, options...)...)} +} + +func (_c *S3API_UploadPartCopyWithContext_Call) Run(run func(v aws.Context, uploadPartCopyInput *s3.UploadPartCopyInput, options ...request.Option)) *S3API_UploadPartCopyWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.UploadPartCopyInput + if args[1] != nil { + arg1 = args[1].(*s3.UploadPartCopyInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_UploadPartCopyWithContext_Call) Return(uploadPartCopyOutput *s3.UploadPartCopyOutput, err error) *S3API_UploadPartCopyWithContext_Call { + _c.Call.Return(uploadPartCopyOutput, err) + return _c +} + +func (_c *S3API_UploadPartCopyWithContext_Call) RunAndReturn(run func(v aws.Context, uploadPartCopyInput *s3.UploadPartCopyInput, options ...request.Option) (*s3.UploadPartCopyOutput, error)) *S3API_UploadPartCopyWithContext_Call { + _c.Call.Return(run) + return _c +} + +// UploadPartRequest provides a mock function for the type S3API +func (_mock *S3API) UploadPartRequest(uploadPartInput *s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput) { + ret := _mock.Called(uploadPartInput) + + if len(ret) == 0 { + panic("no return value specified for UploadPartRequest") + } var r0 *request.Request var r1 *s3.UploadPartOutput - if rf, ok := ret.Get(0).(func(*s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput)); ok { + return returnFunc(uploadPartInput) } - if rf, ok := ret.Get(0).(func(*s3.UploadPartInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.UploadPartInput) *request.Request); ok { + r0 = returnFunc(uploadPartInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.UploadPartInput) *s3.UploadPartOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.UploadPartInput) *s3.UploadPartOutput); ok { + r1 = returnFunc(uploadPartInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.UploadPartOutput) } } - return r0, r1 } -// UploadPartWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) UploadPartWithContext(_a0 context.Context, _a1 *s3.UploadPartInput, _a2 ...request.Option) (*s3.UploadPartOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_UploadPartRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPartRequest' +type S3API_UploadPartRequest_Call struct { + *mock.Call +} + +// UploadPartRequest is a helper method to define mock.On call +// - uploadPartInput *s3.UploadPartInput +func (_e *S3API_Expecter) UploadPartRequest(uploadPartInput interface{}) *S3API_UploadPartRequest_Call { + return &S3API_UploadPartRequest_Call{Call: _e.mock.On("UploadPartRequest", uploadPartInput)} +} + +func (_c *S3API_UploadPartRequest_Call) Run(run func(uploadPartInput *s3.UploadPartInput)) *S3API_UploadPartRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.UploadPartInput + if args[0] != nil { + arg0 = args[0].(*s3.UploadPartInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_UploadPartRequest_Call) Return(request1 *request.Request, uploadPartOutput *s3.UploadPartOutput) *S3API_UploadPartRequest_Call { + _c.Call.Return(request1, uploadPartOutput) + return _c +} + +func (_c *S3API_UploadPartRequest_Call) RunAndReturn(run func(uploadPartInput *s3.UploadPartInput) (*request.Request, *s3.UploadPartOutput)) *S3API_UploadPartRequest_Call { + _c.Call.Return(run) + return _c +} + +// UploadPartWithContext provides a mock function for the type S3API +func (_mock *S3API) UploadPartWithContext(v aws.Context, uploadPartInput *s3.UploadPartInput, options ...request.Option) (*s3.UploadPartOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, uploadPartInput, options) + } else { + tmpRet = _mock.Called(v, uploadPartInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for UploadPartWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.UploadPartOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.UploadPartInput, ...request.Option) (*s3.UploadPartOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.UploadPartInput, ...request.Option) (*s3.UploadPartOutput, error)); ok { + return returnFunc(v, uploadPartInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.UploadPartInput, ...request.Option) *s3.UploadPartOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.UploadPartInput, ...request.Option) *s3.UploadPartOutput); ok { + r0 = returnFunc(v, uploadPartInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.UploadPartOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.UploadPartInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.UploadPartInput, ...request.Option) error); ok { + r1 = returnFunc(v, uploadPartInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// WaitUntilBucketExists provides a mock function with given fields: _a0 -func (_m *S3API) WaitUntilBucketExists(_a0 *s3.HeadBucketInput) error { - ret := _m.Called(_a0) +// S3API_UploadPartWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UploadPartWithContext' +type S3API_UploadPartWithContext_Call struct { + *mock.Call +} + +// UploadPartWithContext is a helper method to define mock.On call +// - v aws.Context +// - uploadPartInput *s3.UploadPartInput +// - options ...request.Option +func (_e *S3API_Expecter) UploadPartWithContext(v interface{}, uploadPartInput interface{}, options ...interface{}) *S3API_UploadPartWithContext_Call { + return &S3API_UploadPartWithContext_Call{Call: _e.mock.On("UploadPartWithContext", + append([]interface{}{v, uploadPartInput}, options...)...)} +} + +func (_c *S3API_UploadPartWithContext_Call) Run(run func(v aws.Context, uploadPartInput *s3.UploadPartInput, options ...request.Option)) *S3API_UploadPartWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.UploadPartInput + if args[1] != nil { + arg1 = args[1].(*s3.UploadPartInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_UploadPartWithContext_Call) Return(uploadPartOutput *s3.UploadPartOutput, err error) *S3API_UploadPartWithContext_Call { + _c.Call.Return(uploadPartOutput, err) + return _c +} + +func (_c *S3API_UploadPartWithContext_Call) RunAndReturn(run func(v aws.Context, uploadPartInput *s3.UploadPartInput, options ...request.Option) (*s3.UploadPartOutput, error)) *S3API_UploadPartWithContext_Call { + _c.Call.Return(run) + return _c +} + +// WaitUntilBucketExists provides a mock function for the type S3API +func (_mock *S3API) WaitUntilBucketExists(headBucketInput *s3.HeadBucketInput) error { + ret := _mock.Called(headBucketInput) + + if len(ret) == 0 { + panic("no return value specified for WaitUntilBucketExists") + } var r0 error - if rf, ok := ret.Get(0).(func(*s3.HeadBucketInput) error); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.HeadBucketInput) error); ok { + r0 = returnFunc(headBucketInput) } else { r0 = ret.Error(0) } - return r0 } -// WaitUntilBucketExistsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) WaitUntilBucketExistsWithContext(_a0 context.Context, _a1 *s3.HeadBucketInput, _a2 ...request.WaiterOption) error { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_WaitUntilBucketExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilBucketExists' +type S3API_WaitUntilBucketExists_Call struct { + *mock.Call +} + +// WaitUntilBucketExists is a helper method to define mock.On call +// - headBucketInput *s3.HeadBucketInput +func (_e *S3API_Expecter) WaitUntilBucketExists(headBucketInput interface{}) *S3API_WaitUntilBucketExists_Call { + return &S3API_WaitUntilBucketExists_Call{Call: _e.mock.On("WaitUntilBucketExists", headBucketInput)} +} + +func (_c *S3API_WaitUntilBucketExists_Call) Run(run func(headBucketInput *s3.HeadBucketInput)) *S3API_WaitUntilBucketExists_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.HeadBucketInput + if args[0] != nil { + arg0 = args[0].(*s3.HeadBucketInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_WaitUntilBucketExists_Call) Return(err error) *S3API_WaitUntilBucketExists_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_WaitUntilBucketExists_Call) RunAndReturn(run func(headBucketInput *s3.HeadBucketInput) error) *S3API_WaitUntilBucketExists_Call { + _c.Call.Return(run) + return _c +} + +// WaitUntilBucketExistsWithContext provides a mock function for the type S3API +func (_mock *S3API) WaitUntilBucketExistsWithContext(v aws.Context, headBucketInput *s3.HeadBucketInput, waiterOptions ...request.WaiterOption) error { + var tmpRet mock.Arguments + if len(waiterOptions) > 0 { + tmpRet = _mock.Called(v, headBucketInput, waiterOptions) + } else { + tmpRet = _mock.Called(v, headBucketInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for WaitUntilBucketExistsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadBucketInput, ...request.WaiterOption) error); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.HeadBucketInput, ...request.WaiterOption) error); ok { + r0 = returnFunc(v, headBucketInput, waiterOptions...) } else { r0 = ret.Error(0) } - return r0 } -// WaitUntilBucketNotExists provides a mock function with given fields: _a0 -func (_m *S3API) WaitUntilBucketNotExists(_a0 *s3.HeadBucketInput) error { - ret := _m.Called(_a0) +// S3API_WaitUntilBucketExistsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilBucketExistsWithContext' +type S3API_WaitUntilBucketExistsWithContext_Call struct { + *mock.Call +} + +// WaitUntilBucketExistsWithContext is a helper method to define mock.On call +// - v aws.Context +// - headBucketInput *s3.HeadBucketInput +// - waiterOptions ...request.WaiterOption +func (_e *S3API_Expecter) WaitUntilBucketExistsWithContext(v interface{}, headBucketInput interface{}, waiterOptions ...interface{}) *S3API_WaitUntilBucketExistsWithContext_Call { + return &S3API_WaitUntilBucketExistsWithContext_Call{Call: _e.mock.On("WaitUntilBucketExistsWithContext", + append([]interface{}{v, headBucketInput}, waiterOptions...)...)} +} + +func (_c *S3API_WaitUntilBucketExistsWithContext_Call) Run(run func(v aws.Context, headBucketInput *s3.HeadBucketInput, waiterOptions ...request.WaiterOption)) *S3API_WaitUntilBucketExistsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.HeadBucketInput + if args[1] != nil { + arg1 = args[1].(*s3.HeadBucketInput) + } + var arg2 []request.WaiterOption + var variadicArgs []request.WaiterOption + if len(args) > 2 { + variadicArgs = args[2].([]request.WaiterOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_WaitUntilBucketExistsWithContext_Call) Return(err error) *S3API_WaitUntilBucketExistsWithContext_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_WaitUntilBucketExistsWithContext_Call) RunAndReturn(run func(v aws.Context, headBucketInput *s3.HeadBucketInput, waiterOptions ...request.WaiterOption) error) *S3API_WaitUntilBucketExistsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// WaitUntilBucketNotExists provides a mock function for the type S3API +func (_mock *S3API) WaitUntilBucketNotExists(headBucketInput *s3.HeadBucketInput) error { + ret := _mock.Called(headBucketInput) + + if len(ret) == 0 { + panic("no return value specified for WaitUntilBucketNotExists") + } var r0 error - if rf, ok := ret.Get(0).(func(*s3.HeadBucketInput) error); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.HeadBucketInput) error); ok { + r0 = returnFunc(headBucketInput) } else { r0 = ret.Error(0) } - return r0 } -// WaitUntilBucketNotExistsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) WaitUntilBucketNotExistsWithContext(_a0 context.Context, _a1 *s3.HeadBucketInput, _a2 ...request.WaiterOption) error { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_WaitUntilBucketNotExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilBucketNotExists' +type S3API_WaitUntilBucketNotExists_Call struct { + *mock.Call +} + +// WaitUntilBucketNotExists is a helper method to define mock.On call +// - headBucketInput *s3.HeadBucketInput +func (_e *S3API_Expecter) WaitUntilBucketNotExists(headBucketInput interface{}) *S3API_WaitUntilBucketNotExists_Call { + return &S3API_WaitUntilBucketNotExists_Call{Call: _e.mock.On("WaitUntilBucketNotExists", headBucketInput)} +} + +func (_c *S3API_WaitUntilBucketNotExists_Call) Run(run func(headBucketInput *s3.HeadBucketInput)) *S3API_WaitUntilBucketNotExists_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.HeadBucketInput + if args[0] != nil { + arg0 = args[0].(*s3.HeadBucketInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_WaitUntilBucketNotExists_Call) Return(err error) *S3API_WaitUntilBucketNotExists_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_WaitUntilBucketNotExists_Call) RunAndReturn(run func(headBucketInput *s3.HeadBucketInput) error) *S3API_WaitUntilBucketNotExists_Call { + _c.Call.Return(run) + return _c +} + +// WaitUntilBucketNotExistsWithContext provides a mock function for the type S3API +func (_mock *S3API) WaitUntilBucketNotExistsWithContext(v aws.Context, headBucketInput *s3.HeadBucketInput, waiterOptions ...request.WaiterOption) error { + var tmpRet mock.Arguments + if len(waiterOptions) > 0 { + tmpRet = _mock.Called(v, headBucketInput, waiterOptions) + } else { + tmpRet = _mock.Called(v, headBucketInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for WaitUntilBucketNotExistsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadBucketInput, ...request.WaiterOption) error); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.HeadBucketInput, ...request.WaiterOption) error); ok { + r0 = returnFunc(v, headBucketInput, waiterOptions...) } else { r0 = ret.Error(0) } - return r0 } -// WaitUntilObjectExists provides a mock function with given fields: _a0 -func (_m *S3API) WaitUntilObjectExists(_a0 *s3.HeadObjectInput) error { - ret := _m.Called(_a0) +// S3API_WaitUntilBucketNotExistsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilBucketNotExistsWithContext' +type S3API_WaitUntilBucketNotExistsWithContext_Call struct { + *mock.Call +} + +// WaitUntilBucketNotExistsWithContext is a helper method to define mock.On call +// - v aws.Context +// - headBucketInput *s3.HeadBucketInput +// - waiterOptions ...request.WaiterOption +func (_e *S3API_Expecter) WaitUntilBucketNotExistsWithContext(v interface{}, headBucketInput interface{}, waiterOptions ...interface{}) *S3API_WaitUntilBucketNotExistsWithContext_Call { + return &S3API_WaitUntilBucketNotExistsWithContext_Call{Call: _e.mock.On("WaitUntilBucketNotExistsWithContext", + append([]interface{}{v, headBucketInput}, waiterOptions...)...)} +} + +func (_c *S3API_WaitUntilBucketNotExistsWithContext_Call) Run(run func(v aws.Context, headBucketInput *s3.HeadBucketInput, waiterOptions ...request.WaiterOption)) *S3API_WaitUntilBucketNotExistsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.HeadBucketInput + if args[1] != nil { + arg1 = args[1].(*s3.HeadBucketInput) + } + var arg2 []request.WaiterOption + var variadicArgs []request.WaiterOption + if len(args) > 2 { + variadicArgs = args[2].([]request.WaiterOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_WaitUntilBucketNotExistsWithContext_Call) Return(err error) *S3API_WaitUntilBucketNotExistsWithContext_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_WaitUntilBucketNotExistsWithContext_Call) RunAndReturn(run func(v aws.Context, headBucketInput *s3.HeadBucketInput, waiterOptions ...request.WaiterOption) error) *S3API_WaitUntilBucketNotExistsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// WaitUntilObjectExists provides a mock function for the type S3API +func (_mock *S3API) WaitUntilObjectExists(headObjectInput *s3.HeadObjectInput) error { + ret := _mock.Called(headObjectInput) + + if len(ret) == 0 { + panic("no return value specified for WaitUntilObjectExists") + } var r0 error - if rf, ok := ret.Get(0).(func(*s3.HeadObjectInput) error); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.HeadObjectInput) error); ok { + r0 = returnFunc(headObjectInput) } else { r0 = ret.Error(0) } - return r0 } -// WaitUntilObjectExistsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) WaitUntilObjectExistsWithContext(_a0 context.Context, _a1 *s3.HeadObjectInput, _a2 ...request.WaiterOption) error { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_WaitUntilObjectExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilObjectExists' +type S3API_WaitUntilObjectExists_Call struct { + *mock.Call +} + +// WaitUntilObjectExists is a helper method to define mock.On call +// - headObjectInput *s3.HeadObjectInput +func (_e *S3API_Expecter) WaitUntilObjectExists(headObjectInput interface{}) *S3API_WaitUntilObjectExists_Call { + return &S3API_WaitUntilObjectExists_Call{Call: _e.mock.On("WaitUntilObjectExists", headObjectInput)} +} + +func (_c *S3API_WaitUntilObjectExists_Call) Run(run func(headObjectInput *s3.HeadObjectInput)) *S3API_WaitUntilObjectExists_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.HeadObjectInput + if args[0] != nil { + arg0 = args[0].(*s3.HeadObjectInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_WaitUntilObjectExists_Call) Return(err error) *S3API_WaitUntilObjectExists_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_WaitUntilObjectExists_Call) RunAndReturn(run func(headObjectInput *s3.HeadObjectInput) error) *S3API_WaitUntilObjectExists_Call { + _c.Call.Return(run) + return _c +} + +// WaitUntilObjectExistsWithContext provides a mock function for the type S3API +func (_mock *S3API) WaitUntilObjectExistsWithContext(v aws.Context, headObjectInput *s3.HeadObjectInput, waiterOptions ...request.WaiterOption) error { + var tmpRet mock.Arguments + if len(waiterOptions) > 0 { + tmpRet = _mock.Called(v, headObjectInput, waiterOptions) + } else { + tmpRet = _mock.Called(v, headObjectInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for WaitUntilObjectExistsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadObjectInput, ...request.WaiterOption) error); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.HeadObjectInput, ...request.WaiterOption) error); ok { + r0 = returnFunc(v, headObjectInput, waiterOptions...) } else { r0 = ret.Error(0) } - return r0 } -// WaitUntilObjectNotExists provides a mock function with given fields: _a0 -func (_m *S3API) WaitUntilObjectNotExists(_a0 *s3.HeadObjectInput) error { - ret := _m.Called(_a0) +// S3API_WaitUntilObjectExistsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilObjectExistsWithContext' +type S3API_WaitUntilObjectExistsWithContext_Call struct { + *mock.Call +} + +// WaitUntilObjectExistsWithContext is a helper method to define mock.On call +// - v aws.Context +// - headObjectInput *s3.HeadObjectInput +// - waiterOptions ...request.WaiterOption +func (_e *S3API_Expecter) WaitUntilObjectExistsWithContext(v interface{}, headObjectInput interface{}, waiterOptions ...interface{}) *S3API_WaitUntilObjectExistsWithContext_Call { + return &S3API_WaitUntilObjectExistsWithContext_Call{Call: _e.mock.On("WaitUntilObjectExistsWithContext", + append([]interface{}{v, headObjectInput}, waiterOptions...)...)} +} + +func (_c *S3API_WaitUntilObjectExistsWithContext_Call) Run(run func(v aws.Context, headObjectInput *s3.HeadObjectInput, waiterOptions ...request.WaiterOption)) *S3API_WaitUntilObjectExistsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.HeadObjectInput + if args[1] != nil { + arg1 = args[1].(*s3.HeadObjectInput) + } + var arg2 []request.WaiterOption + var variadicArgs []request.WaiterOption + if len(args) > 2 { + variadicArgs = args[2].([]request.WaiterOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_WaitUntilObjectExistsWithContext_Call) Return(err error) *S3API_WaitUntilObjectExistsWithContext_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_WaitUntilObjectExistsWithContext_Call) RunAndReturn(run func(v aws.Context, headObjectInput *s3.HeadObjectInput, waiterOptions ...request.WaiterOption) error) *S3API_WaitUntilObjectExistsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// WaitUntilObjectNotExists provides a mock function for the type S3API +func (_mock *S3API) WaitUntilObjectNotExists(headObjectInput *s3.HeadObjectInput) error { + ret := _mock.Called(headObjectInput) + + if len(ret) == 0 { + panic("no return value specified for WaitUntilObjectNotExists") + } var r0 error - if rf, ok := ret.Get(0).(func(*s3.HeadObjectInput) error); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.HeadObjectInput) error); ok { + r0 = returnFunc(headObjectInput) } else { r0 = ret.Error(0) } - return r0 } -// WaitUntilObjectNotExistsWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) WaitUntilObjectNotExistsWithContext(_a0 context.Context, _a1 *s3.HeadObjectInput, _a2 ...request.WaiterOption) error { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_WaitUntilObjectNotExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilObjectNotExists' +type S3API_WaitUntilObjectNotExists_Call struct { + *mock.Call +} + +// WaitUntilObjectNotExists is a helper method to define mock.On call +// - headObjectInput *s3.HeadObjectInput +func (_e *S3API_Expecter) WaitUntilObjectNotExists(headObjectInput interface{}) *S3API_WaitUntilObjectNotExists_Call { + return &S3API_WaitUntilObjectNotExists_Call{Call: _e.mock.On("WaitUntilObjectNotExists", headObjectInput)} +} + +func (_c *S3API_WaitUntilObjectNotExists_Call) Run(run func(headObjectInput *s3.HeadObjectInput)) *S3API_WaitUntilObjectNotExists_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.HeadObjectInput + if args[0] != nil { + arg0 = args[0].(*s3.HeadObjectInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_WaitUntilObjectNotExists_Call) Return(err error) *S3API_WaitUntilObjectNotExists_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_WaitUntilObjectNotExists_Call) RunAndReturn(run func(headObjectInput *s3.HeadObjectInput) error) *S3API_WaitUntilObjectNotExists_Call { + _c.Call.Return(run) + return _c +} + +// WaitUntilObjectNotExistsWithContext provides a mock function for the type S3API +func (_mock *S3API) WaitUntilObjectNotExistsWithContext(v aws.Context, headObjectInput *s3.HeadObjectInput, waiterOptions ...request.WaiterOption) error { + var tmpRet mock.Arguments + if len(waiterOptions) > 0 { + tmpRet = _mock.Called(v, headObjectInput, waiterOptions) + } else { + tmpRet = _mock.Called(v, headObjectInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for WaitUntilObjectNotExistsWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.HeadObjectInput, ...request.WaiterOption) error); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.HeadObjectInput, ...request.WaiterOption) error); ok { + r0 = returnFunc(v, headObjectInput, waiterOptions...) } else { r0 = ret.Error(0) } - return r0 } -// WriteGetObjectResponse provides a mock function with given fields: _a0 -func (_m *S3API) WriteGetObjectResponse(_a0 *s3.WriteGetObjectResponseInput) (*s3.WriteGetObjectResponseOutput, error) { - ret := _m.Called(_a0) +// S3API_WaitUntilObjectNotExistsWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WaitUntilObjectNotExistsWithContext' +type S3API_WaitUntilObjectNotExistsWithContext_Call struct { + *mock.Call +} + +// WaitUntilObjectNotExistsWithContext is a helper method to define mock.On call +// - v aws.Context +// - headObjectInput *s3.HeadObjectInput +// - waiterOptions ...request.WaiterOption +func (_e *S3API_Expecter) WaitUntilObjectNotExistsWithContext(v interface{}, headObjectInput interface{}, waiterOptions ...interface{}) *S3API_WaitUntilObjectNotExistsWithContext_Call { + return &S3API_WaitUntilObjectNotExistsWithContext_Call{Call: _e.mock.On("WaitUntilObjectNotExistsWithContext", + append([]interface{}{v, headObjectInput}, waiterOptions...)...)} +} + +func (_c *S3API_WaitUntilObjectNotExistsWithContext_Call) Run(run func(v aws.Context, headObjectInput *s3.HeadObjectInput, waiterOptions ...request.WaiterOption)) *S3API_WaitUntilObjectNotExistsWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.HeadObjectInput + if args[1] != nil { + arg1 = args[1].(*s3.HeadObjectInput) + } + var arg2 []request.WaiterOption + var variadicArgs []request.WaiterOption + if len(args) > 2 { + variadicArgs = args[2].([]request.WaiterOption) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_WaitUntilObjectNotExistsWithContext_Call) Return(err error) *S3API_WaitUntilObjectNotExistsWithContext_Call { + _c.Call.Return(err) + return _c +} + +func (_c *S3API_WaitUntilObjectNotExistsWithContext_Call) RunAndReturn(run func(v aws.Context, headObjectInput *s3.HeadObjectInput, waiterOptions ...request.WaiterOption) error) *S3API_WaitUntilObjectNotExistsWithContext_Call { + _c.Call.Return(run) + return _c +} + +// WriteGetObjectResponse provides a mock function for the type S3API +func (_mock *S3API) WriteGetObjectResponse(writeGetObjectResponseInput *s3.WriteGetObjectResponseInput) (*s3.WriteGetObjectResponseOutput, error) { + ret := _mock.Called(writeGetObjectResponseInput) + + if len(ret) == 0 { + panic("no return value specified for WriteGetObjectResponse") + } var r0 *s3.WriteGetObjectResponseOutput var r1 error - if rf, ok := ret.Get(0).(func(*s3.WriteGetObjectResponseInput) (*s3.WriteGetObjectResponseOutput, error)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.WriteGetObjectResponseInput) (*s3.WriteGetObjectResponseOutput, error)); ok { + return returnFunc(writeGetObjectResponseInput) } - if rf, ok := ret.Get(0).(func(*s3.WriteGetObjectResponseInput) *s3.WriteGetObjectResponseOutput); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.WriteGetObjectResponseInput) *s3.WriteGetObjectResponseOutput); ok { + r0 = returnFunc(writeGetObjectResponseInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.WriteGetObjectResponseOutput) } } - - if rf, ok := ret.Get(1).(func(*s3.WriteGetObjectResponseInput) error); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.WriteGetObjectResponseInput) error); ok { + r1 = returnFunc(writeGetObjectResponseInput) } else { r1 = ret.Error(1) } - return r0, r1 } -// WriteGetObjectResponseRequest provides a mock function with given fields: _a0 -func (_m *S3API) WriteGetObjectResponseRequest(_a0 *s3.WriteGetObjectResponseInput) (*request.Request, *s3.WriteGetObjectResponseOutput) { - ret := _m.Called(_a0) +// S3API_WriteGetObjectResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteGetObjectResponse' +type S3API_WriteGetObjectResponse_Call struct { + *mock.Call +} + +// WriteGetObjectResponse is a helper method to define mock.On call +// - writeGetObjectResponseInput *s3.WriteGetObjectResponseInput +func (_e *S3API_Expecter) WriteGetObjectResponse(writeGetObjectResponseInput interface{}) *S3API_WriteGetObjectResponse_Call { + return &S3API_WriteGetObjectResponse_Call{Call: _e.mock.On("WriteGetObjectResponse", writeGetObjectResponseInput)} +} + +func (_c *S3API_WriteGetObjectResponse_Call) Run(run func(writeGetObjectResponseInput *s3.WriteGetObjectResponseInput)) *S3API_WriteGetObjectResponse_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.WriteGetObjectResponseInput + if args[0] != nil { + arg0 = args[0].(*s3.WriteGetObjectResponseInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_WriteGetObjectResponse_Call) Return(writeGetObjectResponseOutput *s3.WriteGetObjectResponseOutput, err error) *S3API_WriteGetObjectResponse_Call { + _c.Call.Return(writeGetObjectResponseOutput, err) + return _c +} + +func (_c *S3API_WriteGetObjectResponse_Call) RunAndReturn(run func(writeGetObjectResponseInput *s3.WriteGetObjectResponseInput) (*s3.WriteGetObjectResponseOutput, error)) *S3API_WriteGetObjectResponse_Call { + _c.Call.Return(run) + return _c +} + +// WriteGetObjectResponseRequest provides a mock function for the type S3API +func (_mock *S3API) WriteGetObjectResponseRequest(writeGetObjectResponseInput *s3.WriteGetObjectResponseInput) (*request.Request, *s3.WriteGetObjectResponseOutput) { + ret := _mock.Called(writeGetObjectResponseInput) + + if len(ret) == 0 { + panic("no return value specified for WriteGetObjectResponseRequest") + } var r0 *request.Request var r1 *s3.WriteGetObjectResponseOutput - if rf, ok := ret.Get(0).(func(*s3.WriteGetObjectResponseInput) (*request.Request, *s3.WriteGetObjectResponseOutput)); ok { - return rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.WriteGetObjectResponseInput) (*request.Request, *s3.WriteGetObjectResponseOutput)); ok { + return returnFunc(writeGetObjectResponseInput) } - if rf, ok := ret.Get(0).(func(*s3.WriteGetObjectResponseInput) *request.Request); ok { - r0 = rf(_a0) + if returnFunc, ok := ret.Get(0).(func(*s3.WriteGetObjectResponseInput) *request.Request); ok { + r0 = returnFunc(writeGetObjectResponseInput) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*request.Request) } } - - if rf, ok := ret.Get(1).(func(*s3.WriteGetObjectResponseInput) *s3.WriteGetObjectResponseOutput); ok { - r1 = rf(_a0) + if returnFunc, ok := ret.Get(1).(func(*s3.WriteGetObjectResponseInput) *s3.WriteGetObjectResponseOutput); ok { + r1 = returnFunc(writeGetObjectResponseInput) } else { if ret.Get(1) != nil { r1 = ret.Get(1).(*s3.WriteGetObjectResponseOutput) } } - return r0, r1 } -// WriteGetObjectResponseWithContext provides a mock function with given fields: _a0, _a1, _a2 -func (_m *S3API) WriteGetObjectResponseWithContext(_a0 context.Context, _a1 *s3.WriteGetObjectResponseInput, _a2 ...request.Option) (*s3.WriteGetObjectResponseOutput, error) { - _va := make([]interface{}, len(_a2)) - for _i := range _a2 { - _va[_i] = _a2[_i] +// S3API_WriteGetObjectResponseRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteGetObjectResponseRequest' +type S3API_WriteGetObjectResponseRequest_Call struct { + *mock.Call +} + +// WriteGetObjectResponseRequest is a helper method to define mock.On call +// - writeGetObjectResponseInput *s3.WriteGetObjectResponseInput +func (_e *S3API_Expecter) WriteGetObjectResponseRequest(writeGetObjectResponseInput interface{}) *S3API_WriteGetObjectResponseRequest_Call { + return &S3API_WriteGetObjectResponseRequest_Call{Call: _e.mock.On("WriteGetObjectResponseRequest", writeGetObjectResponseInput)} +} + +func (_c *S3API_WriteGetObjectResponseRequest_Call) Run(run func(writeGetObjectResponseInput *s3.WriteGetObjectResponseInput)) *S3API_WriteGetObjectResponseRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *s3.WriteGetObjectResponseInput + if args[0] != nil { + arg0 = args[0].(*s3.WriteGetObjectResponseInput) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *S3API_WriteGetObjectResponseRequest_Call) Return(request1 *request.Request, writeGetObjectResponseOutput *s3.WriteGetObjectResponseOutput) *S3API_WriteGetObjectResponseRequest_Call { + _c.Call.Return(request1, writeGetObjectResponseOutput) + return _c +} + +func (_c *S3API_WriteGetObjectResponseRequest_Call) RunAndReturn(run func(writeGetObjectResponseInput *s3.WriteGetObjectResponseInput) (*request.Request, *s3.WriteGetObjectResponseOutput)) *S3API_WriteGetObjectResponseRequest_Call { + _c.Call.Return(run) + return _c +} + +// WriteGetObjectResponseWithContext provides a mock function for the type S3API +func (_mock *S3API) WriteGetObjectResponseWithContext(v aws.Context, writeGetObjectResponseInput *s3.WriteGetObjectResponseInput, options ...request.Option) (*s3.WriteGetObjectResponseOutput, error) { + var tmpRet mock.Arguments + if len(options) > 0 { + tmpRet = _mock.Called(v, writeGetObjectResponseInput, options) + } else { + tmpRet = _mock.Called(v, writeGetObjectResponseInput) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for WriteGetObjectResponseWithContext") } - var _ca []interface{} - _ca = append(_ca, _a0, _a1) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 *s3.WriteGetObjectResponseOutput var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *s3.WriteGetObjectResponseInput, ...request.Option) (*s3.WriteGetObjectResponseOutput, error)); ok { - return rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.WriteGetObjectResponseInput, ...request.Option) (*s3.WriteGetObjectResponseOutput, error)); ok { + return returnFunc(v, writeGetObjectResponseInput, options...) } - if rf, ok := ret.Get(0).(func(context.Context, *s3.WriteGetObjectResponseInput, ...request.Option) *s3.WriteGetObjectResponseOutput); ok { - r0 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(0).(func(aws.Context, *s3.WriteGetObjectResponseInput, ...request.Option) *s3.WriteGetObjectResponseOutput); ok { + r0 = returnFunc(v, writeGetObjectResponseInput, options...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*s3.WriteGetObjectResponseOutput) } } - - if rf, ok := ret.Get(1).(func(context.Context, *s3.WriteGetObjectResponseInput, ...request.Option) error); ok { - r1 = rf(_a0, _a1, _a2...) + if returnFunc, ok := ret.Get(1).(func(aws.Context, *s3.WriteGetObjectResponseInput, ...request.Option) error); ok { + r1 = returnFunc(v, writeGetObjectResponseInput, options...) } else { r1 = ret.Error(1) } - return r0, r1 } -// NewS3API creates a new instance of S3API. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewS3API(t interface { - mock.TestingT - Cleanup(func()) -}) *S3API { - mock := &S3API{} - mock.Mock.Test(t) +// S3API_WriteGetObjectResponseWithContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteGetObjectResponseWithContext' +type S3API_WriteGetObjectResponseWithContext_Call struct { + *mock.Call +} - t.Cleanup(func() { mock.AssertExpectations(t) }) +// WriteGetObjectResponseWithContext is a helper method to define mock.On call +// - v aws.Context +// - writeGetObjectResponseInput *s3.WriteGetObjectResponseInput +// - options ...request.Option +func (_e *S3API_Expecter) WriteGetObjectResponseWithContext(v interface{}, writeGetObjectResponseInput interface{}, options ...interface{}) *S3API_WriteGetObjectResponseWithContext_Call { + return &S3API_WriteGetObjectResponseWithContext_Call{Call: _e.mock.On("WriteGetObjectResponseWithContext", + append([]interface{}{v, writeGetObjectResponseInput}, options...)...)} +} - return mock +func (_c *S3API_WriteGetObjectResponseWithContext_Call) Run(run func(v aws.Context, writeGetObjectResponseInput *s3.WriteGetObjectResponseInput, options ...request.Option)) *S3API_WriteGetObjectResponseWithContext_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 aws.Context + if args[0] != nil { + arg0 = args[0].(aws.Context) + } + var arg1 *s3.WriteGetObjectResponseInput + if args[1] != nil { + arg1 = args[1].(*s3.WriteGetObjectResponseInput) + } + var arg2 []request.Option + var variadicArgs []request.Option + if len(args) > 2 { + variadicArgs = args[2].([]request.Option) + } + arg2 = variadicArgs + run( + arg0, + arg1, + arg2..., + ) + }) + return _c +} + +func (_c *S3API_WriteGetObjectResponseWithContext_Call) Return(writeGetObjectResponseOutput *s3.WriteGetObjectResponseOutput, err error) *S3API_WriteGetObjectResponseWithContext_Call { + _c.Call.Return(writeGetObjectResponseOutput, err) + return _c +} + +func (_c *S3API_WriteGetObjectResponseWithContext_Call) RunAndReturn(run func(v aws.Context, writeGetObjectResponseInput *s3.WriteGetObjectResponseInput, options ...request.Option) (*s3.WriteGetObjectResponseOutput, error)) *S3API_WriteGetObjectResponseWithContext_Call { + _c.Call.Return(run) + return _c } diff --git a/common/elasticsearch/bulk/mocks/GenericBulkProcessor.go b/common/elasticsearch/bulk/mocks/GenericBulkProcessor.go index 53947df3900..a749159eee3 100644 --- a/common/elasticsearch/bulk/mocks/GenericBulkProcessor.go +++ b/common/elasticsearch/bulk/mocks/GenericBulkProcessor.go @@ -1,99 +1,263 @@ -// The MIT License (MIT) - -// Copyright (c) 2017-2020 Uber Technologies Inc. - -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. - -// Code generated by mockery v0.0.0-dev. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - context "context" + "context" mock "github.com/stretchr/testify/mock" - bulk "github.com/uber/cadence/common/elasticsearch/bulk" + "github.com/uber/cadence/common/elasticsearch/bulk" ) +// NewGenericBulkProcessor creates a new instance of GenericBulkProcessor. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewGenericBulkProcessor(t interface { + mock.TestingT + Cleanup(func()) +}) *GenericBulkProcessor { + mock := &GenericBulkProcessor{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // GenericBulkProcessor is an autogenerated mock type for the GenericBulkProcessor type type GenericBulkProcessor struct { mock.Mock } -// Add provides a mock function with given fields: request -func (_m *GenericBulkProcessor) Add(request *bulk.GenericBulkableAddRequest) { - _m.Called(request) +type GenericBulkProcessor_Expecter struct { + mock *mock.Mock +} + +func (_m *GenericBulkProcessor) EXPECT() *GenericBulkProcessor_Expecter { + return &GenericBulkProcessor_Expecter{mock: &_m.Mock} +} + +// Add provides a mock function for the type GenericBulkProcessor +func (_mock *GenericBulkProcessor) Add(request *bulk.GenericBulkableAddRequest) { + _mock.Called(request) + return +} + +// GenericBulkProcessor_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add' +type GenericBulkProcessor_Add_Call struct { + *mock.Call +} + +// Add is a helper method to define mock.On call +// - request *bulk.GenericBulkableAddRequest +func (_e *GenericBulkProcessor_Expecter) Add(request interface{}) *GenericBulkProcessor_Add_Call { + return &GenericBulkProcessor_Add_Call{Call: _e.mock.On("Add", request)} +} + +func (_c *GenericBulkProcessor_Add_Call) Run(run func(request *bulk.GenericBulkableAddRequest)) *GenericBulkProcessor_Add_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 *bulk.GenericBulkableAddRequest + if args[0] != nil { + arg0 = args[0].(*bulk.GenericBulkableAddRequest) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *GenericBulkProcessor_Add_Call) Return() *GenericBulkProcessor_Add_Call { + _c.Call.Return() + return _c +} + +func (_c *GenericBulkProcessor_Add_Call) RunAndReturn(run func(request *bulk.GenericBulkableAddRequest)) *GenericBulkProcessor_Add_Call { + _c.Run(run) + return _c } -// Close provides a mock function with given fields: -func (_m *GenericBulkProcessor) Close() error { - ret := _m.Called() +// Close provides a mock function for the type GenericBulkProcessor +func (_mock *GenericBulkProcessor) Close() error { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Close") + } var r0 error - if rf, ok := ret.Get(0).(func() error); ok { - r0 = rf() + if returnFunc, ok := ret.Get(0).(func() error); ok { + r0 = returnFunc() } else { r0 = ret.Error(0) } - return r0 } -// Flush provides a mock function with given fields: -func (_m *GenericBulkProcessor) Flush() error { - ret := _m.Called() +// GenericBulkProcessor_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type GenericBulkProcessor_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *GenericBulkProcessor_Expecter) Close() *GenericBulkProcessor_Close_Call { + return &GenericBulkProcessor_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *GenericBulkProcessor_Close_Call) Run(run func()) *GenericBulkProcessor_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *GenericBulkProcessor_Close_Call) Return(err error) *GenericBulkProcessor_Close_Call { + _c.Call.Return(err) + return _c +} + +func (_c *GenericBulkProcessor_Close_Call) RunAndReturn(run func() error) *GenericBulkProcessor_Close_Call { + _c.Call.Return(run) + return _c +} + +// Flush provides a mock function for the type GenericBulkProcessor +func (_mock *GenericBulkProcessor) Flush() error { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Flush") + } var r0 error - if rf, ok := ret.Get(0).(func() error); ok { - r0 = rf() + if returnFunc, ok := ret.Get(0).(func() error); ok { + r0 = returnFunc() } else { r0 = ret.Error(0) } - return r0 } -// Start provides a mock function with given fields: ctx -func (_m *GenericBulkProcessor) Start(ctx context.Context) error { - ret := _m.Called(ctx) +// GenericBulkProcessor_Flush_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Flush' +type GenericBulkProcessor_Flush_Call struct { + *mock.Call +} + +// Flush is a helper method to define mock.On call +func (_e *GenericBulkProcessor_Expecter) Flush() *GenericBulkProcessor_Flush_Call { + return &GenericBulkProcessor_Flush_Call{Call: _e.mock.On("Flush")} +} + +func (_c *GenericBulkProcessor_Flush_Call) Run(run func()) *GenericBulkProcessor_Flush_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *GenericBulkProcessor_Flush_Call) Return(err error) *GenericBulkProcessor_Flush_Call { + _c.Call.Return(err) + return _c +} + +func (_c *GenericBulkProcessor_Flush_Call) RunAndReturn(run func() error) *GenericBulkProcessor_Flush_Call { + _c.Call.Return(run) + return _c +} + +// Start provides a mock function for the type GenericBulkProcessor +func (_mock *GenericBulkProcessor) Start(ctx context.Context) error { + ret := _mock.Called(ctx) + + if len(ret) == 0 { + panic("no return value specified for Start") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context) error); ok { - r0 = rf(ctx) + if returnFunc, ok := ret.Get(0).(func(context.Context) error); ok { + r0 = returnFunc(ctx) } else { r0 = ret.Error(0) } - return r0 } -// Stop provides a mock function with given fields: -func (_m *GenericBulkProcessor) Stop() error { - ret := _m.Called() +// GenericBulkProcessor_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start' +type GenericBulkProcessor_Start_Call struct { + *mock.Call +} + +// Start is a helper method to define mock.On call +// - ctx context.Context +func (_e *GenericBulkProcessor_Expecter) Start(ctx interface{}) *GenericBulkProcessor_Start_Call { + return &GenericBulkProcessor_Start_Call{Call: _e.mock.On("Start", ctx)} +} + +func (_c *GenericBulkProcessor_Start_Call) Run(run func(ctx context.Context)) *GenericBulkProcessor_Start_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *GenericBulkProcessor_Start_Call) Return(err error) *GenericBulkProcessor_Start_Call { + _c.Call.Return(err) + return _c +} + +func (_c *GenericBulkProcessor_Start_Call) RunAndReturn(run func(ctx context.Context) error) *GenericBulkProcessor_Start_Call { + _c.Call.Return(run) + return _c +} + +// Stop provides a mock function for the type GenericBulkProcessor +func (_mock *GenericBulkProcessor) Stop() error { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Stop") + } var r0 error - if rf, ok := ret.Get(0).(func() error); ok { - r0 = rf() + if returnFunc, ok := ret.Get(0).(func() error); ok { + r0 = returnFunc() } else { r0 = ret.Error(0) } - return r0 } + +// GenericBulkProcessor_Stop_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Stop' +type GenericBulkProcessor_Stop_Call struct { + *mock.Call +} + +// Stop is a helper method to define mock.On call +func (_e *GenericBulkProcessor_Expecter) Stop() *GenericBulkProcessor_Stop_Call { + return &GenericBulkProcessor_Stop_Call{Call: _e.mock.On("Stop")} +} + +func (_c *GenericBulkProcessor_Stop_Call) Run(run func()) *GenericBulkProcessor_Stop_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *GenericBulkProcessor_Stop_Call) Return(err error) *GenericBulkProcessor_Stop_Call { + _c.Call.Return(err) + return _c +} + +func (_c *GenericBulkProcessor_Stop_Call) RunAndReturn(run func() error) *GenericBulkProcessor_Stop_Call { + _c.Call.Return(run) + return _c +} diff --git a/common/elasticsearch/bulk/mocks/GenericBulkableRequest.go b/common/elasticsearch/bulk/mocks/GenericBulkableRequest.go index 381fd73acd6..6a5a897ed81 100644 --- a/common/elasticsearch/bulk/mocks/GenericBulkableRequest.go +++ b/common/elasticsearch/bulk/mocks/GenericBulkableRequest.go @@ -1,67 +1,135 @@ -// Copyright (c) 2020 Uber Technologies, Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -// Code generated by mockery v1.0.0. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks -import mock "github.com/stretchr/testify/mock" +import ( + mock "github.com/stretchr/testify/mock" +) + +// NewGenericBulkableRequest creates a new instance of GenericBulkableRequest. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewGenericBulkableRequest(t interface { + mock.TestingT + Cleanup(func()) +}) *GenericBulkableRequest { + mock := &GenericBulkableRequest{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} // GenericBulkableRequest is an autogenerated mock type for the GenericBulkableRequest type type GenericBulkableRequest struct { mock.Mock } -// Source provides a mock function with given fields: -func (_m *GenericBulkableRequest) Source() ([]string, error) { - ret := _m.Called() +type GenericBulkableRequest_Expecter struct { + mock *mock.Mock +} + +func (_m *GenericBulkableRequest) EXPECT() *GenericBulkableRequest_Expecter { + return &GenericBulkableRequest_Expecter{mock: &_m.Mock} +} + +// Source provides a mock function for the type GenericBulkableRequest +func (_mock *GenericBulkableRequest) Source() ([]string, error) { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Source") + } var r0 []string - if rf, ok := ret.Get(0).(func() []string); ok { - r0 = rf() + var r1 error + if returnFunc, ok := ret.Get(0).(func() ([]string, error)); ok { + return returnFunc() + } + if returnFunc, ok := ret.Get(0).(func() []string); ok { + r0 = returnFunc() } else { if ret.Get(0) != nil { r0 = ret.Get(0).([]string) } } - - var r1 error - if rf, ok := ret.Get(1).(func() error); ok { - r1 = rf() + if returnFunc, ok := ret.Get(1).(func() error); ok { + r1 = returnFunc() } else { r1 = ret.Error(1) } - return r0, r1 } -// String provides a mock function with given fields: -func (_m *GenericBulkableRequest) String() string { - ret := _m.Called() +// GenericBulkableRequest_Source_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Source' +type GenericBulkableRequest_Source_Call struct { + *mock.Call +} + +// Source is a helper method to define mock.On call +func (_e *GenericBulkableRequest_Expecter) Source() *GenericBulkableRequest_Source_Call { + return &GenericBulkableRequest_Source_Call{Call: _e.mock.On("Source")} +} + +func (_c *GenericBulkableRequest_Source_Call) Run(run func()) *GenericBulkableRequest_Source_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *GenericBulkableRequest_Source_Call) Return(strings []string, err error) *GenericBulkableRequest_Source_Call { + _c.Call.Return(strings, err) + return _c +} + +func (_c *GenericBulkableRequest_Source_Call) RunAndReturn(run func() ([]string, error)) *GenericBulkableRequest_Source_Call { + _c.Call.Return(run) + return _c +} + +// String provides a mock function for the type GenericBulkableRequest +func (_mock *GenericBulkableRequest) String() string { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for String") + } var r0 string - if rf, ok := ret.Get(0).(func() string); ok { - r0 = rf() + if returnFunc, ok := ret.Get(0).(func() string); ok { + r0 = returnFunc() } else { r0 = ret.Get(0).(string) } - return r0 } + +// GenericBulkableRequest_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type GenericBulkableRequest_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *GenericBulkableRequest_Expecter) String() *GenericBulkableRequest_String_Call { + return &GenericBulkableRequest_String_Call{Call: _e.mock.On("String")} +} + +func (_c *GenericBulkableRequest_String_Call) Run(run func()) *GenericBulkableRequest_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *GenericBulkableRequest_String_Call) Return(s string) *GenericBulkableRequest_String_Call { + _c.Call.Return(s) + return _c +} + +func (_c *GenericBulkableRequest_String_Call) RunAndReturn(run func() string) *GenericBulkableRequest_String_Call { + _c.Call.Return(run) + return _c +} diff --git a/common/elasticsearch/mocks/GenericClient.go b/common/elasticsearch/mocks/GenericClient.go index ba34a0c0780..422843f03ab 100644 --- a/common/elasticsearch/mocks/GenericClient.go +++ b/common/elasticsearch/mocks/GenericClient.go @@ -1,238 +1,716 @@ -// Copyright (c) 2020 Uber Technologies, Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. - -// Code generated by mockery v1.0.0. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - context "context" + "context" mock "github.com/stretchr/testify/mock" - elasticsearch "github.com/uber/cadence/common/elasticsearch" - bulk "github.com/uber/cadence/common/elasticsearch/bulk" - persistence "github.com/uber/cadence/common/persistence" + "github.com/uber/cadence/common/elasticsearch" + "github.com/uber/cadence/common/elasticsearch/bulk" ) +// NewGenericClient creates a new instance of GenericClient. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewGenericClient(t interface { + mock.TestingT + Cleanup(func()) +}) *GenericClient { + mock := &GenericClient{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // GenericClient is an autogenerated mock type for the GenericClient type type GenericClient struct { mock.Mock } -// CountByQuery provides a mock function with given fields: ctx, index, query -func (_m *GenericClient) CountByQuery(ctx context.Context, index string, query string) (int64, error) { - ret := _m.Called(ctx, index, query) +type GenericClient_Expecter struct { + mock *mock.Mock +} + +func (_m *GenericClient) EXPECT() *GenericClient_Expecter { + return &GenericClient_Expecter{mock: &_m.Mock} +} + +// CountByQuery provides a mock function for the type GenericClient +func (_mock *GenericClient) CountByQuery(ctx context.Context, index string, query string) (int64, error) { + ret := _mock.Called(ctx, index, query) + + if len(ret) == 0 { + panic("no return value specified for CountByQuery") + } var r0 int64 - if rf, ok := ret.Get(0).(func(context.Context, string, string) int64); ok { - r0 = rf(ctx, index, query) + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (int64, error)); ok { + return returnFunc(ctx, index, query) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) int64); ok { + r0 = returnFunc(ctx, index, query) } else { r0 = ret.Get(0).(int64) } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok { - r1 = rf(ctx, index, query) + if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok { + r1 = returnFunc(ctx, index, query) } else { r1 = ret.Error(1) } - return r0, r1 } -// CreateIndex provides a mock function with given fields: ctx, index -func (_m *GenericClient) CreateIndex(ctx context.Context, index string) error { - ret := _m.Called(ctx, index) +// GenericClient_CountByQuery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountByQuery' +type GenericClient_CountByQuery_Call struct { + *mock.Call +} + +// CountByQuery is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - query string +func (_e *GenericClient_Expecter) CountByQuery(ctx interface{}, index interface{}, query interface{}) *GenericClient_CountByQuery_Call { + return &GenericClient_CountByQuery_Call{Call: _e.mock.On("CountByQuery", ctx, index, query)} +} + +func (_c *GenericClient_CountByQuery_Call) Run(run func(ctx context.Context, index string, query string)) *GenericClient_CountByQuery_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *GenericClient_CountByQuery_Call) Return(n int64, err error) *GenericClient_CountByQuery_Call { + _c.Call.Return(n, err) + return _c +} + +func (_c *GenericClient_CountByQuery_Call) RunAndReturn(run func(ctx context.Context, index string, query string) (int64, error)) *GenericClient_CountByQuery_Call { + _c.Call.Return(run) + return _c +} + +// CreateIndex provides a mock function for the type GenericClient +func (_mock *GenericClient) CreateIndex(ctx context.Context, index string) error { + ret := _mock.Called(ctx, index) + + if len(ret) == 0 { + panic("no return value specified for CreateIndex") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, string) error); ok { - r0 = rf(ctx, index) + if returnFunc, ok := ret.Get(0).(func(context.Context, string) error); ok { + r0 = returnFunc(ctx, index) } else { r0 = ret.Error(0) } - return r0 } -// IsNotFoundError provides a mock function with given fields: err -func (_m *GenericClient) IsNotFoundError(err error) bool { - ret := _m.Called(err) +// GenericClient_CreateIndex_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateIndex' +type GenericClient_CreateIndex_Call struct { + *mock.Call +} + +// CreateIndex is a helper method to define mock.On call +// - ctx context.Context +// - index string +func (_e *GenericClient_Expecter) CreateIndex(ctx interface{}, index interface{}) *GenericClient_CreateIndex_Call { + return &GenericClient_CreateIndex_Call{Call: _e.mock.On("CreateIndex", ctx, index)} +} + +func (_c *GenericClient_CreateIndex_Call) Run(run func(ctx context.Context, index string)) *GenericClient_CreateIndex_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *GenericClient_CreateIndex_Call) Return(err error) *GenericClient_CreateIndex_Call { + _c.Call.Return(err) + return _c +} + +func (_c *GenericClient_CreateIndex_Call) RunAndReturn(run func(ctx context.Context, index string) error) *GenericClient_CreateIndex_Call { + _c.Call.Return(run) + return _c +} + +// IsNotFoundError provides a mock function for the type GenericClient +func (_mock *GenericClient) IsNotFoundError(err error) bool { + ret := _mock.Called(err) + + if len(ret) == 0 { + panic("no return value specified for IsNotFoundError") + } var r0 bool - if rf, ok := ret.Get(0).(func(error) bool); ok { - r0 = rf(err) + if returnFunc, ok := ret.Get(0).(func(error) bool); ok { + r0 = returnFunc(err) } else { r0 = ret.Get(0).(bool) } - return r0 } -// PutMapping provides a mock function with given fields: ctx, index, root, key, valueType -func (_m *GenericClient) PutMapping(ctx context.Context, index string, root string, key string, valueType string) error { - ret := _m.Called(ctx, index, root, key, valueType) +// GenericClient_IsNotFoundError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsNotFoundError' +type GenericClient_IsNotFoundError_Call struct { + *mock.Call +} + +// IsNotFoundError is a helper method to define mock.On call +// - err error +func (_e *GenericClient_Expecter) IsNotFoundError(err interface{}) *GenericClient_IsNotFoundError_Call { + return &GenericClient_IsNotFoundError_Call{Call: _e.mock.On("IsNotFoundError", err)} +} + +func (_c *GenericClient_IsNotFoundError_Call) Run(run func(err error)) *GenericClient_IsNotFoundError_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 error + if args[0] != nil { + arg0 = args[0].(error) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *GenericClient_IsNotFoundError_Call) Return(b bool) *GenericClient_IsNotFoundError_Call { + _c.Call.Return(b) + return _c +} + +func (_c *GenericClient_IsNotFoundError_Call) RunAndReturn(run func(err error) bool) *GenericClient_IsNotFoundError_Call { + _c.Call.Return(run) + return _c +} + +// PutMapping provides a mock function for the type GenericClient +func (_mock *GenericClient) PutMapping(ctx context.Context, index string, root string, key string, valueType string) error { + ret := _mock.Called(ctx, index, root, key, valueType) + + if len(ret) == 0 { + panic("no return value specified for PutMapping") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, string, string, string, string) error); ok { - r0 = rf(ctx, index, root, key, valueType) + if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string, string) error); ok { + r0 = returnFunc(ctx, index, root, key, valueType) } else { r0 = ret.Error(0) } - return r0 } -// RunBulkProcessor provides a mock function with given fields: ctx, p -func (_m *GenericClient) RunBulkProcessor(ctx context.Context, p *bulk.BulkProcessorParameters) (bulk.GenericBulkProcessor, error) { - ret := _m.Called(ctx, p) +// GenericClient_PutMapping_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutMapping' +type GenericClient_PutMapping_Call struct { + *mock.Call +} + +// PutMapping is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - root string +// - key string +// - valueType string +func (_e *GenericClient_Expecter) PutMapping(ctx interface{}, index interface{}, root interface{}, key interface{}, valueType interface{}) *GenericClient_PutMapping_Call { + return &GenericClient_PutMapping_Call{Call: _e.mock.On("PutMapping", ctx, index, root, key, valueType)} +} + +func (_c *GenericClient_PutMapping_Call) Run(run func(ctx context.Context, index string, root string, key string, valueType string)) *GenericClient_PutMapping_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + var arg4 string + if args[4] != nil { + arg4 = args[4].(string) + } + run( + arg0, + arg1, + arg2, + arg3, + arg4, + ) + }) + return _c +} + +func (_c *GenericClient_PutMapping_Call) Return(err error) *GenericClient_PutMapping_Call { + _c.Call.Return(err) + return _c +} + +func (_c *GenericClient_PutMapping_Call) RunAndReturn(run func(ctx context.Context, index string, root string, key string, valueType string) error) *GenericClient_PutMapping_Call { + _c.Call.Return(run) + return _c +} + +// RunBulkProcessor provides a mock function for the type GenericClient +func (_mock *GenericClient) RunBulkProcessor(ctx context.Context, p *bulk.BulkProcessorParameters) (bulk.GenericBulkProcessor, error) { + ret := _mock.Called(ctx, p) + + if len(ret) == 0 { + panic("no return value specified for RunBulkProcessor") + } var r0 bulk.GenericBulkProcessor - if rf, ok := ret.Get(0).(func(context.Context, *bulk.BulkProcessorParameters) bulk.GenericBulkProcessor); ok { - r0 = rf(ctx, p) + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *bulk.BulkProcessorParameters) (bulk.GenericBulkProcessor, error)); ok { + return returnFunc(ctx, p) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *bulk.BulkProcessorParameters) bulk.GenericBulkProcessor); ok { + r0 = returnFunc(ctx, p) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(bulk.GenericBulkProcessor) } } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *bulk.BulkProcessorParameters) error); ok { - r1 = rf(ctx, p) + if returnFunc, ok := ret.Get(1).(func(context.Context, *bulk.BulkProcessorParameters) error); ok { + r1 = returnFunc(ctx, p) } else { r1 = ret.Error(1) } - return r0, r1 } -// ScanByQuery provides a mock function with given fields: ctx, request -func (_m *GenericClient) ScanByQuery(ctx context.Context, request *elasticsearch.ScanByQueryRequest) (*persistence.InternalListWorkflowExecutionsResponse, error) { - ret := _m.Called(ctx, request) +// GenericClient_RunBulkProcessor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RunBulkProcessor' +type GenericClient_RunBulkProcessor_Call struct { + *mock.Call +} - var r0 *persistence.InternalListWorkflowExecutionsResponse - if rf, ok := ret.Get(0).(func(context.Context, *elasticsearch.ScanByQueryRequest) *persistence.InternalListWorkflowExecutionsResponse); ok { - r0 = rf(ctx, request) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*persistence.InternalListWorkflowExecutionsResponse) +// RunBulkProcessor is a helper method to define mock.On call +// - ctx context.Context +// - p *bulk.BulkProcessorParameters +func (_e *GenericClient_Expecter) RunBulkProcessor(ctx interface{}, p interface{}) *GenericClient_RunBulkProcessor_Call { + return &GenericClient_RunBulkProcessor_Call{Call: _e.mock.On("RunBulkProcessor", ctx, p)} +} + +func (_c *GenericClient_RunBulkProcessor_Call) Run(run func(ctx context.Context, p *bulk.BulkProcessorParameters)) *GenericClient_RunBulkProcessor_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *bulk.BulkProcessorParameters + if args[1] != nil { + arg1 = args[1].(*bulk.BulkProcessorParameters) } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *GenericClient_RunBulkProcessor_Call) Return(genericBulkProcessor bulk.GenericBulkProcessor, err error) *GenericClient_RunBulkProcessor_Call { + _c.Call.Return(genericBulkProcessor, err) + return _c +} + +func (_c *GenericClient_RunBulkProcessor_Call) RunAndReturn(run func(ctx context.Context, p *bulk.BulkProcessorParameters) (bulk.GenericBulkProcessor, error)) *GenericClient_RunBulkProcessor_Call { + _c.Call.Return(run) + return _c +} + +// ScanByQuery provides a mock function for the type GenericClient +func (_mock *GenericClient) ScanByQuery(ctx context.Context, request *elasticsearch.ScanByQueryRequest) (*elasticsearch.SearchResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for ScanByQuery") } + var r0 *elasticsearch.SearchResponse var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *elasticsearch.ScanByQueryRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *elasticsearch.ScanByQueryRequest) (*elasticsearch.SearchResponse, error)); ok { + return returnFunc(ctx, request) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *elasticsearch.ScanByQueryRequest) *elasticsearch.SearchResponse); ok { + r0 = returnFunc(ctx, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*elasticsearch.SearchResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *elasticsearch.ScanByQueryRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// Search provides a mock function with given fields: ctx, request -func (_m *GenericClient) Search(ctx context.Context, request *elasticsearch.SearchRequest) (*persistence.InternalListWorkflowExecutionsResponse, error) { - ret := _m.Called(ctx, request) +// GenericClient_ScanByQuery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScanByQuery' +type GenericClient_ScanByQuery_Call struct { + *mock.Call +} - var r0 *persistence.InternalListWorkflowExecutionsResponse - if rf, ok := ret.Get(0).(func(context.Context, *elasticsearch.SearchRequest) *persistence.InternalListWorkflowExecutionsResponse); ok { - r0 = rf(ctx, request) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*persistence.InternalListWorkflowExecutionsResponse) +// ScanByQuery is a helper method to define mock.On call +// - ctx context.Context +// - request *elasticsearch.ScanByQueryRequest +func (_e *GenericClient_Expecter) ScanByQuery(ctx interface{}, request interface{}) *GenericClient_ScanByQuery_Call { + return &GenericClient_ScanByQuery_Call{Call: _e.mock.On("ScanByQuery", ctx, request)} +} + +func (_c *GenericClient_ScanByQuery_Call) Run(run func(ctx context.Context, request *elasticsearch.ScanByQueryRequest)) *GenericClient_ScanByQuery_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *elasticsearch.ScanByQueryRequest + if args[1] != nil { + arg1 = args[1].(*elasticsearch.ScanByQueryRequest) } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *GenericClient_ScanByQuery_Call) Return(v *elasticsearch.SearchResponse, err error) *GenericClient_ScanByQuery_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *GenericClient_ScanByQuery_Call) RunAndReturn(run func(ctx context.Context, request *elasticsearch.ScanByQueryRequest) (*elasticsearch.SearchResponse, error)) *GenericClient_ScanByQuery_Call { + _c.Call.Return(run) + return _c +} + +// Search provides a mock function for the type GenericClient +func (_mock *GenericClient) Search(ctx context.Context, request *elasticsearch.SearchRequest) (*elasticsearch.SearchResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for Search") } + var r0 *elasticsearch.SearchResponse var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *elasticsearch.SearchRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *elasticsearch.SearchRequest) (*elasticsearch.SearchResponse, error)); ok { + return returnFunc(ctx, request) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *elasticsearch.SearchRequest) *elasticsearch.SearchResponse); ok { + r0 = returnFunc(ctx, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*elasticsearch.SearchResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *elasticsearch.SearchRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -func (_m *GenericClient) SearchRaw(ctx context.Context, index string, query string) (*elasticsearch.RawResponse, error) { - ret := _m.Called(ctx, index, query) +// GenericClient_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search' +type GenericClient_Search_Call struct { + *mock.Call +} - var r0 *elasticsearch.RawResponse - if rf, ok := ret.Get(0).(func(context.Context, string, string) *elasticsearch.RawResponse); ok { - r0 = rf(ctx, index, query) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*elasticsearch.RawResponse) +// Search is a helper method to define mock.On call +// - ctx context.Context +// - request *elasticsearch.SearchRequest +func (_e *GenericClient_Expecter) Search(ctx interface{}, request interface{}) *GenericClient_Search_Call { + return &GenericClient_Search_Call{Call: _e.mock.On("Search", ctx, request)} +} + +func (_c *GenericClient_Search_Call) Run(run func(ctx context.Context, request *elasticsearch.SearchRequest)) *GenericClient_Search_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *elasticsearch.SearchRequest + if args[1] != nil { + arg1 = args[1].(*elasticsearch.SearchRequest) } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *GenericClient_Search_Call) Return(v *elasticsearch.SearchResponse, err error) *GenericClient_Search_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *GenericClient_Search_Call) RunAndReturn(run func(ctx context.Context, request *elasticsearch.SearchRequest) (*elasticsearch.SearchResponse, error)) *GenericClient_Search_Call { + _c.Call.Return(run) + return _c +} + +// SearchByQuery provides a mock function for the type GenericClient +func (_mock *GenericClient) SearchByQuery(ctx context.Context, request *elasticsearch.SearchByQueryRequest) (*elasticsearch.SearchResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for SearchByQuery") } + var r0 *elasticsearch.SearchResponse var r1 error - if rf, ok := ret.Get(1).(func(context.Context, string, string) error); ok { - r1 = rf(ctx, index, query) + if returnFunc, ok := ret.Get(0).(func(context.Context, *elasticsearch.SearchByQueryRequest) (*elasticsearch.SearchResponse, error)); ok { + return returnFunc(ctx, request) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *elasticsearch.SearchByQueryRequest) *elasticsearch.SearchResponse); ok { + r0 = returnFunc(ctx, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*elasticsearch.SearchResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, *elasticsearch.SearchByQueryRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// SearchByQuery provides a mock function with given fields: ctx, request -func (_m *GenericClient) SearchByQuery(ctx context.Context, request *elasticsearch.SearchByQueryRequest) (*persistence.InternalListWorkflowExecutionsResponse, error) { - ret := _m.Called(ctx, request) +// GenericClient_SearchByQuery_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchByQuery' +type GenericClient_SearchByQuery_Call struct { + *mock.Call +} - var r0 *persistence.InternalListWorkflowExecutionsResponse - if rf, ok := ret.Get(0).(func(context.Context, *elasticsearch.SearchByQueryRequest) *persistence.InternalListWorkflowExecutionsResponse); ok { - r0 = rf(ctx, request) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*persistence.InternalListWorkflowExecutionsResponse) +// SearchByQuery is a helper method to define mock.On call +// - ctx context.Context +// - request *elasticsearch.SearchByQueryRequest +func (_e *GenericClient_Expecter) SearchByQuery(ctx interface{}, request interface{}) *GenericClient_SearchByQuery_Call { + return &GenericClient_SearchByQuery_Call{Call: _e.mock.On("SearchByQuery", ctx, request)} +} + +func (_c *GenericClient_SearchByQuery_Call) Run(run func(ctx context.Context, request *elasticsearch.SearchByQueryRequest)) *GenericClient_SearchByQuery_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *elasticsearch.SearchByQueryRequest + if args[1] != nil { + arg1 = args[1].(*elasticsearch.SearchByQueryRequest) } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *GenericClient_SearchByQuery_Call) Return(v *elasticsearch.SearchResponse, err error) *GenericClient_SearchByQuery_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *GenericClient_SearchByQuery_Call) RunAndReturn(run func(ctx context.Context, request *elasticsearch.SearchByQueryRequest) (*elasticsearch.SearchResponse, error)) *GenericClient_SearchByQuery_Call { + _c.Call.Return(run) + return _c +} + +// SearchForOneClosedExecution provides a mock function for the type GenericClient +func (_mock *GenericClient) SearchForOneClosedExecution(ctx context.Context, index string, request *elasticsearch.SearchForOneClosedExecutionRequest) (*elasticsearch.SearchForOneClosedExecutionResponse, error) { + ret := _mock.Called(ctx, index, request) + + if len(ret) == 0 { + panic("no return value specified for SearchForOneClosedExecution") } + var r0 *elasticsearch.SearchForOneClosedExecutionResponse var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *elasticsearch.SearchByQueryRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, string, *elasticsearch.SearchForOneClosedExecutionRequest) (*elasticsearch.SearchForOneClosedExecutionResponse, error)); ok { + return returnFunc(ctx, index, request) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string, *elasticsearch.SearchForOneClosedExecutionRequest) *elasticsearch.SearchForOneClosedExecutionResponse); ok { + r0 = returnFunc(ctx, index, request) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*elasticsearch.SearchForOneClosedExecutionResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string, *elasticsearch.SearchForOneClosedExecutionRequest) error); ok { + r1 = returnFunc(ctx, index, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// SearchForOneClosedExecution provides a mock function with given fields: ctx, index, request -func (_m *GenericClient) SearchForOneClosedExecution(ctx context.Context, index string, request *persistence.InternalGetClosedWorkflowExecutionRequest) (*persistence.InternalGetClosedWorkflowExecutionResponse, error) { - ret := _m.Called(ctx, index, request) +// GenericClient_SearchForOneClosedExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchForOneClosedExecution' +type GenericClient_SearchForOneClosedExecution_Call struct { + *mock.Call +} - var r0 *persistence.InternalGetClosedWorkflowExecutionResponse - if rf, ok := ret.Get(0).(func(context.Context, string, *persistence.InternalGetClosedWorkflowExecutionRequest) *persistence.InternalGetClosedWorkflowExecutionResponse); ok { - r0 = rf(ctx, index, request) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*persistence.InternalGetClosedWorkflowExecutionResponse) +// SearchForOneClosedExecution is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - request *elasticsearch.SearchForOneClosedExecutionRequest +func (_e *GenericClient_Expecter) SearchForOneClosedExecution(ctx interface{}, index interface{}, request interface{}) *GenericClient_SearchForOneClosedExecution_Call { + return &GenericClient_SearchForOneClosedExecution_Call{Call: _e.mock.On("SearchForOneClosedExecution", ctx, index, request)} +} + +func (_c *GenericClient_SearchForOneClosedExecution_Call) Run(run func(ctx context.Context, index string, request *elasticsearch.SearchForOneClosedExecutionRequest)) *GenericClient_SearchForOneClosedExecution_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 *elasticsearch.SearchForOneClosedExecutionRequest + if args[2] != nil { + arg2 = args[2].(*elasticsearch.SearchForOneClosedExecutionRequest) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *GenericClient_SearchForOneClosedExecution_Call) Return(v *elasticsearch.SearchForOneClosedExecutionResponse, err error) *GenericClient_SearchForOneClosedExecution_Call { + _c.Call.Return(v, err) + return _c +} + +func (_c *GenericClient_SearchForOneClosedExecution_Call) RunAndReturn(run func(ctx context.Context, index string, request *elasticsearch.SearchForOneClosedExecutionRequest) (*elasticsearch.SearchForOneClosedExecutionResponse, error)) *GenericClient_SearchForOneClosedExecution_Call { + _c.Call.Return(run) + return _c +} + +// SearchRaw provides a mock function for the type GenericClient +func (_mock *GenericClient) SearchRaw(ctx context.Context, index string, query string) (*elasticsearch.RawResponse, error) { + ret := _mock.Called(ctx, index, query) + + if len(ret) == 0 { + panic("no return value specified for SearchRaw") } + var r0 *elasticsearch.RawResponse var r1 error - if rf, ok := ret.Get(1).(func(context.Context, string, *persistence.InternalGetClosedWorkflowExecutionRequest) error); ok { - r1 = rf(ctx, index, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) (*elasticsearch.RawResponse, error)); ok { + return returnFunc(ctx, index, query) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string, string) *elasticsearch.RawResponse); ok { + r0 = returnFunc(ctx, index, query) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*elasticsearch.RawResponse) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string, string) error); ok { + r1 = returnFunc(ctx, index, query) } else { r1 = ret.Error(1) } - return r0, r1 } + +// GenericClient_SearchRaw_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchRaw' +type GenericClient_SearchRaw_Call struct { + *mock.Call +} + +// SearchRaw is a helper method to define mock.On call +// - ctx context.Context +// - index string +// - query string +func (_e *GenericClient_Expecter) SearchRaw(ctx interface{}, index interface{}, query interface{}) *GenericClient_SearchRaw_Call { + return &GenericClient_SearchRaw_Call{Call: _e.mock.On("SearchRaw", ctx, index, query)} +} + +func (_c *GenericClient_SearchRaw_Call) Run(run func(ctx context.Context, index string, query string)) *GenericClient_SearchRaw_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *GenericClient_SearchRaw_Call) Return(rawResponse *elasticsearch.RawResponse, err error) *GenericClient_SearchRaw_Call { + _c.Call.Return(rawResponse, err) + return _c +} + +func (_c *GenericClient_SearchRaw_Call) RunAndReturn(run func(ctx context.Context, index string, query string) (*elasticsearch.RawResponse, error)) *GenericClient_SearchRaw_Call { + _c.Call.Return(run) + return _c +} diff --git a/common/messaging/metrics_producer_test.go b/common/messaging/metrics_producer_test.go index cfa6b3188e7..73eb7292514 100644 --- a/common/messaging/metrics_producer_test.go +++ b/common/messaging/metrics_producer_test.go @@ -48,7 +48,7 @@ func TestPublish(t *testing.T) { metricsClient := &mocks.Client{} metricsScope := &mocks.Scope{} metricsClient. - On("Scope", metrics.MessagingClientPublishScope, metrics.TopicTag("test-topic-1")). + On("Scope", metrics.MessagingClientPublishScope, []metrics.Tag{metrics.TopicTag("test-topic-1")}). Return(metricsScope). Once() metricsScope.On("IncCounter", metrics.CadenceClientRequests).Once() @@ -68,7 +68,7 @@ func TestPublish(t *testing.T) { metricsClient := &mocks.Client{} metricsScope := &mocks.Scope{} metricsClient. - On("Scope", metrics.MessagingClientPublishScope, metrics.TopicTag("test-topic-2")). + On("Scope", metrics.MessagingClientPublishScope, []metrics.Tag{metrics.TopicTag("test-topic-2")}). Return(metricsScope). Once() metricsScope.On("IncCounter", metrics.CadenceClientRequests).Once() diff --git a/common/metrics/histograms_test.go b/common/metrics/histograms_test.go index 444fb1a5b89..a6c11f6afc1 100644 --- a/common/metrics/histograms_test.go +++ b/common/metrics/histograms_test.go @@ -167,7 +167,7 @@ func checkHistogram[T any](t *testing.T, h histogrammy[T], expected string) { var buf strings.Builder h.print(func(s string, a ...any) { str := fmt.Sprintf(s, a...) - t.Logf(str) + t.Log(str) buf.WriteString(str) }) if strings.TrimSpace(expected) != strings.TrimSpace(buf.String()) { diff --git a/common/metrics/mocks/Client.go b/common/metrics/mocks/Client.go index bfbc3a00ca5..3505176a08a 100644 --- a/common/metrics/mocks/Client.go +++ b/common/metrics/mocks/Client.go @@ -1,98 +1,420 @@ -// Copyright (c) 2017 Uber Technologies, Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. -// Code generated by mockery 2.7.4. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - time "time" + "time" mock "github.com/stretchr/testify/mock" - tally "github.com/uber-go/tally" + "github.com/uber-go/tally" - metrics "github.com/uber/cadence/common/metrics" + "github.com/uber/cadence/common/metrics" ) +// NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewClient(t interface { + mock.TestingT + Cleanup(func()) +}) *Client { + mock := &Client{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // Client is an autogenerated mock type for the Client type type Client struct { mock.Mock } -// AddCounter provides a mock function with given fields: scope, counter, delta -func (_m *Client) AddCounter(scope metrics.ScopeIdx, counter metrics.MetricIdx, delta int64) { - _m.Called(scope, counter, delta) +type Client_Expecter struct { + mock *mock.Mock +} + +func (_m *Client) EXPECT() *Client_Expecter { + return &Client_Expecter{mock: &_m.Mock} +} + +// AddCounter provides a mock function for the type Client +func (_mock *Client) AddCounter(scope metrics.ScopeIdx, counter metrics.MetricIdx, delta int64) { + _mock.Called(scope, counter, delta) + return +} + +// Client_AddCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCounter' +type Client_AddCounter_Call struct { + *mock.Call +} + +// AddCounter is a helper method to define mock.On call +// - scope metrics.ScopeIdx +// - counter metrics.MetricIdx +// - delta int64 +func (_e *Client_Expecter) AddCounter(scope interface{}, counter interface{}, delta interface{}) *Client_AddCounter_Call { + return &Client_AddCounter_Call{Call: _e.mock.On("AddCounter", scope, counter, delta)} +} + +func (_c *Client_AddCounter_Call) Run(run func(scope metrics.ScopeIdx, counter metrics.MetricIdx, delta int64)) *Client_AddCounter_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.ScopeIdx + if args[0] != nil { + arg0 = args[0].(metrics.ScopeIdx) + } + var arg1 metrics.MetricIdx + if args[1] != nil { + arg1 = args[1].(metrics.MetricIdx) + } + var arg2 int64 + if args[2] != nil { + arg2 = args[2].(int64) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Client_AddCounter_Call) Return() *Client_AddCounter_Call { + _c.Call.Return() + return _c +} + +func (_c *Client_AddCounter_Call) RunAndReturn(run func(scope metrics.ScopeIdx, counter metrics.MetricIdx, delta int64)) *Client_AddCounter_Call { + _c.Run(run) + return _c +} + +// IncCounter provides a mock function for the type Client +func (_mock *Client) IncCounter(scope metrics.ScopeIdx, counter metrics.MetricIdx) { + _mock.Called(scope, counter) + return +} + +// Client_IncCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IncCounter' +type Client_IncCounter_Call struct { + *mock.Call +} + +// IncCounter is a helper method to define mock.On call +// - scope metrics.ScopeIdx +// - counter metrics.MetricIdx +func (_e *Client_Expecter) IncCounter(scope interface{}, counter interface{}) *Client_IncCounter_Call { + return &Client_IncCounter_Call{Call: _e.mock.On("IncCounter", scope, counter)} +} + +func (_c *Client_IncCounter_Call) Run(run func(scope metrics.ScopeIdx, counter metrics.MetricIdx)) *Client_IncCounter_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.ScopeIdx + if args[0] != nil { + arg0 = args[0].(metrics.ScopeIdx) + } + var arg1 metrics.MetricIdx + if args[1] != nil { + arg1 = args[1].(metrics.MetricIdx) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Client_IncCounter_Call) Return() *Client_IncCounter_Call { + _c.Call.Return() + return _c +} + +func (_c *Client_IncCounter_Call) RunAndReturn(run func(scope metrics.ScopeIdx, counter metrics.MetricIdx)) *Client_IncCounter_Call { + _c.Run(run) + return _c +} + +// RecordHistogramDuration provides a mock function for the type Client +func (_mock *Client) RecordHistogramDuration(scope metrics.ScopeIdx, timer metrics.MetricIdx, d time.Duration) { + _mock.Called(scope, timer, d) + return +} + +// Client_RecordHistogramDuration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordHistogramDuration' +type Client_RecordHistogramDuration_Call struct { + *mock.Call } -// IncCounter provides a mock function with given fields: scope, counter -func (_m *Client) IncCounter(scope metrics.ScopeIdx, counter metrics.MetricIdx) { - _m.Called(scope, counter) +// RecordHistogramDuration is a helper method to define mock.On call +// - scope metrics.ScopeIdx +// - timer metrics.MetricIdx +// - d time.Duration +func (_e *Client_Expecter) RecordHistogramDuration(scope interface{}, timer interface{}, d interface{}) *Client_RecordHistogramDuration_Call { + return &Client_RecordHistogramDuration_Call{Call: _e.mock.On("RecordHistogramDuration", scope, timer, d)} } -// RecordHistogramDuration provides a mock function with given fields: scope, timer, d -func (_m *Client) RecordHistogramDuration(scope metrics.ScopeIdx, timer metrics.MetricIdx, d time.Duration) { - _m.Called(scope, timer, d) +func (_c *Client_RecordHistogramDuration_Call) Run(run func(scope metrics.ScopeIdx, timer metrics.MetricIdx, d time.Duration)) *Client_RecordHistogramDuration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.ScopeIdx + if args[0] != nil { + arg0 = args[0].(metrics.ScopeIdx) + } + var arg1 metrics.MetricIdx + if args[1] != nil { + arg1 = args[1].(metrics.MetricIdx) + } + var arg2 time.Duration + if args[2] != nil { + arg2 = args[2].(time.Duration) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Client_RecordHistogramDuration_Call) Return() *Client_RecordHistogramDuration_Call { + _c.Call.Return() + return _c +} + +func (_c *Client_RecordHistogramDuration_Call) RunAndReturn(run func(scope metrics.ScopeIdx, timer metrics.MetricIdx, d time.Duration)) *Client_RecordHistogramDuration_Call { + _c.Run(run) + return _c } -// RecordTimer provides a mock function with given fields: scope, timer, d -func (_m *Client) RecordTimer(scope metrics.ScopeIdx, timer metrics.MetricIdx, d time.Duration) { - _m.Called(scope, timer, d) +// RecordTimer provides a mock function for the type Client +func (_mock *Client) RecordTimer(scope metrics.ScopeIdx, timer metrics.MetricIdx, d time.Duration) { + _mock.Called(scope, timer, d) + return } -// Scope provides a mock function with given fields: scope, tags -func (_m *Client) Scope(scope metrics.ScopeIdx, tags ...metrics.Tag) metrics.Scope { - _va := make([]interface{}, len(tags)) - for _i := range tags { - _va[_i] = tags[_i] +// Client_RecordTimer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordTimer' +type Client_RecordTimer_Call struct { + *mock.Call +} + +// RecordTimer is a helper method to define mock.On call +// - scope metrics.ScopeIdx +// - timer metrics.MetricIdx +// - d time.Duration +func (_e *Client_Expecter) RecordTimer(scope interface{}, timer interface{}, d interface{}) *Client_RecordTimer_Call { + return &Client_RecordTimer_Call{Call: _e.mock.On("RecordTimer", scope, timer, d)} +} + +func (_c *Client_RecordTimer_Call) Run(run func(scope metrics.ScopeIdx, timer metrics.MetricIdx, d time.Duration)) *Client_RecordTimer_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.ScopeIdx + if args[0] != nil { + arg0 = args[0].(metrics.ScopeIdx) + } + var arg1 metrics.MetricIdx + if args[1] != nil { + arg1 = args[1].(metrics.MetricIdx) + } + var arg2 time.Duration + if args[2] != nil { + arg2 = args[2].(time.Duration) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Client_RecordTimer_Call) Return() *Client_RecordTimer_Call { + _c.Call.Return() + return _c +} + +func (_c *Client_RecordTimer_Call) RunAndReturn(run func(scope metrics.ScopeIdx, timer metrics.MetricIdx, d time.Duration)) *Client_RecordTimer_Call { + _c.Run(run) + return _c +} + +// Scope provides a mock function for the type Client +func (_mock *Client) Scope(scope metrics.ScopeIdx, tags ...metrics.Tag) metrics.Scope { + var tmpRet mock.Arguments + if len(tags) > 0 { + tmpRet = _mock.Called(scope, tags) + } else { + tmpRet = _mock.Called(scope) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for Scope") } - var _ca []interface{} - _ca = append(_ca, scope) - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 metrics.Scope - if rf, ok := ret.Get(0).(func(metrics.ScopeIdx, ...metrics.Tag) metrics.Scope); ok { - r0 = rf(scope, tags...) + if returnFunc, ok := ret.Get(0).(func(metrics.ScopeIdx, ...metrics.Tag) metrics.Scope); ok { + r0 = returnFunc(scope, tags...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(metrics.Scope) } } - return r0 } -// StartTimer provides a mock function with given fields: scope, timer -func (_m *Client) StartTimer(scope metrics.ScopeIdx, timer metrics.MetricIdx) tally.Stopwatch { - ret := _m.Called(scope, timer) +// Client_Scope_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Scope' +type Client_Scope_Call struct { + *mock.Call +} + +// Scope is a helper method to define mock.On call +// - scope metrics.ScopeIdx +// - tags ...metrics.Tag +func (_e *Client_Expecter) Scope(scope interface{}, tags ...interface{}) *Client_Scope_Call { + return &Client_Scope_Call{Call: _e.mock.On("Scope", + append([]interface{}{scope}, tags...)...)} +} + +func (_c *Client_Scope_Call) Run(run func(scope metrics.ScopeIdx, tags ...metrics.Tag)) *Client_Scope_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.ScopeIdx + if args[0] != nil { + arg0 = args[0].(metrics.ScopeIdx) + } + var arg1 []metrics.Tag + var variadicArgs []metrics.Tag + if len(args) > 1 { + variadicArgs = args[1].([]metrics.Tag) + } + arg1 = variadicArgs + run( + arg0, + arg1..., + ) + }) + return _c +} + +func (_c *Client_Scope_Call) Return(scope1 metrics.Scope) *Client_Scope_Call { + _c.Call.Return(scope1) + return _c +} + +func (_c *Client_Scope_Call) RunAndReturn(run func(scope metrics.ScopeIdx, tags ...metrics.Tag) metrics.Scope) *Client_Scope_Call { + _c.Call.Return(run) + return _c +} + +// StartTimer provides a mock function for the type Client +func (_mock *Client) StartTimer(scope metrics.ScopeIdx, timer metrics.MetricIdx) tally.Stopwatch { + ret := _mock.Called(scope, timer) + + if len(ret) == 0 { + panic("no return value specified for StartTimer") + } var r0 tally.Stopwatch - if rf, ok := ret.Get(0).(func(metrics.ScopeIdx, metrics.MetricIdx) tally.Stopwatch); ok { - r0 = rf(scope, timer) + if returnFunc, ok := ret.Get(0).(func(metrics.ScopeIdx, metrics.MetricIdx) tally.Stopwatch); ok { + r0 = returnFunc(scope, timer) } else { r0 = ret.Get(0).(tally.Stopwatch) } - return r0 } -// UpdateGauge provides a mock function with given fields: scope, gauge, value -func (_m *Client) UpdateGauge(scope metrics.ScopeIdx, gauge metrics.MetricIdx, value float64) { - _m.Called(scope, gauge, value) +// Client_StartTimer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartTimer' +type Client_StartTimer_Call struct { + *mock.Call +} + +// StartTimer is a helper method to define mock.On call +// - scope metrics.ScopeIdx +// - timer metrics.MetricIdx +func (_e *Client_Expecter) StartTimer(scope interface{}, timer interface{}) *Client_StartTimer_Call { + return &Client_StartTimer_Call{Call: _e.mock.On("StartTimer", scope, timer)} +} + +func (_c *Client_StartTimer_Call) Run(run func(scope metrics.ScopeIdx, timer metrics.MetricIdx)) *Client_StartTimer_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.ScopeIdx + if args[0] != nil { + arg0 = args[0].(metrics.ScopeIdx) + } + var arg1 metrics.MetricIdx + if args[1] != nil { + arg1 = args[1].(metrics.MetricIdx) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Client_StartTimer_Call) Return(stopwatch tally.Stopwatch) *Client_StartTimer_Call { + _c.Call.Return(stopwatch) + return _c +} + +func (_c *Client_StartTimer_Call) RunAndReturn(run func(scope metrics.ScopeIdx, timer metrics.MetricIdx) tally.Stopwatch) *Client_StartTimer_Call { + _c.Call.Return(run) + return _c +} + +// UpdateGauge provides a mock function for the type Client +func (_mock *Client) UpdateGauge(scope metrics.ScopeIdx, gauge metrics.MetricIdx, value float64) { + _mock.Called(scope, gauge, value) + return +} + +// Client_UpdateGauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateGauge' +type Client_UpdateGauge_Call struct { + *mock.Call +} + +// UpdateGauge is a helper method to define mock.On call +// - scope metrics.ScopeIdx +// - gauge metrics.MetricIdx +// - value float64 +func (_e *Client_Expecter) UpdateGauge(scope interface{}, gauge interface{}, value interface{}) *Client_UpdateGauge_Call { + return &Client_UpdateGauge_Call{Call: _e.mock.On("UpdateGauge", scope, gauge, value)} +} + +func (_c *Client_UpdateGauge_Call) Run(run func(scope metrics.ScopeIdx, gauge metrics.MetricIdx, value float64)) *Client_UpdateGauge_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.ScopeIdx + if args[0] != nil { + arg0 = args[0].(metrics.ScopeIdx) + } + var arg1 metrics.MetricIdx + if args[1] != nil { + arg1 = args[1].(metrics.MetricIdx) + } + var arg2 float64 + if args[2] != nil { + arg2 = args[2].(float64) + } + run( + arg0, + arg1, + arg2, + ) + }) + return _c +} + +func (_c *Client_UpdateGauge_Call) Return() *Client_UpdateGauge_Call { + _c.Call.Return() + return _c +} + +func (_c *Client_UpdateGauge_Call) RunAndReturn(run func(scope metrics.ScopeIdx, gauge metrics.MetricIdx, value float64)) *Client_UpdateGauge_Call { + _c.Run(run) + return _c } diff --git a/common/metrics/mocks/Scope.go b/common/metrics/mocks/Scope.go index d689645f6fe..9d7f46c9810 100644 --- a/common/metrics/mocks/Scope.go +++ b/common/metrics/mocks/Scope.go @@ -1,109 +1,515 @@ -// Copyright (c) 2017 Uber Technologies, Inc. -// -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in -// all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -// THE SOFTWARE. -// Code generated by mockery v1.0.0. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - time "time" + "time" mock "github.com/stretchr/testify/mock" - metrics "github.com/uber/cadence/common/metrics" + "github.com/uber/cadence/common/metrics" ) +// NewScope creates a new instance of Scope. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewScope(t interface { + mock.TestingT + Cleanup(func()) +}) *Scope { + mock := &Scope{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // Scope is an autogenerated mock type for the Scope type type Scope struct { mock.Mock } -// AddCounter provides a mock function with given fields: counter, delta -func (_m *Scope) AddCounter(counter metrics.MetricIdx, delta int64) { - _m.Called(counter, delta) +type Scope_Expecter struct { + mock *mock.Mock +} + +func (_m *Scope) EXPECT() *Scope_Expecter { + return &Scope_Expecter{mock: &_m.Mock} +} + +// AddCounter provides a mock function for the type Scope +func (_mock *Scope) AddCounter(counter metrics.MetricIdx, delta int64) { + _mock.Called(counter, delta) + return +} + +// Scope_AddCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCounter' +type Scope_AddCounter_Call struct { + *mock.Call +} + +// AddCounter is a helper method to define mock.On call +// - counter metrics.MetricIdx +// - delta int64 +func (_e *Scope_Expecter) AddCounter(counter interface{}, delta interface{}) *Scope_AddCounter_Call { + return &Scope_AddCounter_Call{Call: _e.mock.On("AddCounter", counter, delta)} +} + +func (_c *Scope_AddCounter_Call) Run(run func(counter metrics.MetricIdx, delta int64)) *Scope_AddCounter_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.MetricIdx + if args[0] != nil { + arg0 = args[0].(metrics.MetricIdx) + } + var arg1 int64 + if args[1] != nil { + arg1 = args[1].(int64) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Scope_AddCounter_Call) Return() *Scope_AddCounter_Call { + _c.Call.Return() + return _c +} + +func (_c *Scope_AddCounter_Call) RunAndReturn(run func(counter metrics.MetricIdx, delta int64)) *Scope_AddCounter_Call { + _c.Run(run) + return _c +} + +// ExponentialHistogram provides a mock function for the type Scope +func (_mock *Scope) ExponentialHistogram(hist metrics.MetricIdx, d time.Duration) { + _mock.Called(hist, d) + return +} + +// Scope_ExponentialHistogram_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExponentialHistogram' +type Scope_ExponentialHistogram_Call struct { + *mock.Call +} + +// ExponentialHistogram is a helper method to define mock.On call +// - hist metrics.MetricIdx +// - d time.Duration +func (_e *Scope_Expecter) ExponentialHistogram(hist interface{}, d interface{}) *Scope_ExponentialHistogram_Call { + return &Scope_ExponentialHistogram_Call{Call: _e.mock.On("ExponentialHistogram", hist, d)} +} + +func (_c *Scope_ExponentialHistogram_Call) Run(run func(hist metrics.MetricIdx, d time.Duration)) *Scope_ExponentialHistogram_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.MetricIdx + if args[0] != nil { + arg0 = args[0].(metrics.MetricIdx) + } + var arg1 time.Duration + if args[1] != nil { + arg1 = args[1].(time.Duration) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Scope_ExponentialHistogram_Call) Return() *Scope_ExponentialHistogram_Call { + _c.Call.Return() + return _c +} + +func (_c *Scope_ExponentialHistogram_Call) RunAndReturn(run func(hist metrics.MetricIdx, d time.Duration)) *Scope_ExponentialHistogram_Call { + _c.Run(run) + return _c +} + +// IncCounter provides a mock function for the type Scope +func (_mock *Scope) IncCounter(counter metrics.MetricIdx) { + _mock.Called(counter) + return +} + +// Scope_IncCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IncCounter' +type Scope_IncCounter_Call struct { + *mock.Call +} + +// IncCounter is a helper method to define mock.On call +// - counter metrics.MetricIdx +func (_e *Scope_Expecter) IncCounter(counter interface{}) *Scope_IncCounter_Call { + return &Scope_IncCounter_Call{Call: _e.mock.On("IncCounter", counter)} +} + +func (_c *Scope_IncCounter_Call) Run(run func(counter metrics.MetricIdx)) *Scope_IncCounter_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.MetricIdx + if args[0] != nil { + arg0 = args[0].(metrics.MetricIdx) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *Scope_IncCounter_Call) Return() *Scope_IncCounter_Call { + _c.Call.Return() + return _c +} + +func (_c *Scope_IncCounter_Call) RunAndReturn(run func(counter metrics.MetricIdx)) *Scope_IncCounter_Call { + _c.Run(run) + return _c +} + +// IntExponentialHistogram provides a mock function for the type Scope +func (_mock *Scope) IntExponentialHistogram(hist metrics.MetricIdx, value int) { + _mock.Called(hist, value) + return +} + +// Scope_IntExponentialHistogram_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IntExponentialHistogram' +type Scope_IntExponentialHistogram_Call struct { + *mock.Call +} + +// IntExponentialHistogram is a helper method to define mock.On call +// - hist metrics.MetricIdx +// - value int +func (_e *Scope_Expecter) IntExponentialHistogram(hist interface{}, value interface{}) *Scope_IntExponentialHistogram_Call { + return &Scope_IntExponentialHistogram_Call{Call: _e.mock.On("IntExponentialHistogram", hist, value)} +} + +func (_c *Scope_IntExponentialHistogram_Call) Run(run func(hist metrics.MetricIdx, value int)) *Scope_IntExponentialHistogram_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.MetricIdx + if args[0] != nil { + arg0 = args[0].(metrics.MetricIdx) + } + var arg1 int + if args[1] != nil { + arg1 = args[1].(int) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Scope_IntExponentialHistogram_Call) Return() *Scope_IntExponentialHistogram_Call { + _c.Call.Return() + return _c +} + +func (_c *Scope_IntExponentialHistogram_Call) RunAndReturn(run func(hist metrics.MetricIdx, value int)) *Scope_IntExponentialHistogram_Call { + _c.Run(run) + return _c +} + +// RecordHistogramDuration provides a mock function for the type Scope +func (_mock *Scope) RecordHistogramDuration(timer metrics.MetricIdx, d time.Duration) { + _mock.Called(timer, d) + return +} + +// Scope_RecordHistogramDuration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordHistogramDuration' +type Scope_RecordHistogramDuration_Call struct { + *mock.Call +} + +// RecordHistogramDuration is a helper method to define mock.On call +// - timer metrics.MetricIdx +// - d time.Duration +func (_e *Scope_Expecter) RecordHistogramDuration(timer interface{}, d interface{}) *Scope_RecordHistogramDuration_Call { + return &Scope_RecordHistogramDuration_Call{Call: _e.mock.On("RecordHistogramDuration", timer, d)} } -// IncCounter provides a mock function with given fields: counter -func (_m *Scope) IncCounter(counter metrics.MetricIdx) { - _m.Called(counter) +func (_c *Scope_RecordHistogramDuration_Call) Run(run func(timer metrics.MetricIdx, d time.Duration)) *Scope_RecordHistogramDuration_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.MetricIdx + if args[0] != nil { + arg0 = args[0].(metrics.MetricIdx) + } + var arg1 time.Duration + if args[1] != nil { + arg1 = args[1].(time.Duration) + } + run( + arg0, + arg1, + ) + }) + return _c } -// RecordHistogramDuration provides a mock function with given fields: timer, d -func (_m *Scope) RecordHistogramDuration(timer metrics.MetricIdx, d time.Duration) { - _m.Called(timer, d) +func (_c *Scope_RecordHistogramDuration_Call) Return() *Scope_RecordHistogramDuration_Call { + _c.Call.Return() + return _c } -// RecordHistogramValue provides a mock function with given fields: timer, value -func (_m *Scope) RecordHistogramValue(timer metrics.MetricIdx, value float64) { - _m.Called(timer, value) +func (_c *Scope_RecordHistogramDuration_Call) RunAndReturn(run func(timer metrics.MetricIdx, d time.Duration)) *Scope_RecordHistogramDuration_Call { + _c.Run(run) + return _c } -func (_m *Scope) ExponentialHistogram(hist metrics.MetricIdx, d time.Duration) { - _m.Called(hist, d) +// RecordHistogramValue provides a mock function for the type Scope +func (_mock *Scope) RecordHistogramValue(timer metrics.MetricIdx, value float64) { + _mock.Called(timer, value) + return } -func (_m *Scope) IntExponentialHistogram(hist metrics.MetricIdx, value int) { - _m.Called(hist, value) +// Scope_RecordHistogramValue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordHistogramValue' +type Scope_RecordHistogramValue_Call struct { + *mock.Call } -// RecordTimer provides a mock function with given fields: timer, d -func (_m *Scope) RecordTimer(timer metrics.MetricIdx, d time.Duration) { - _m.Called(timer, d) +// RecordHistogramValue is a helper method to define mock.On call +// - timer metrics.MetricIdx +// - value float64 +func (_e *Scope_Expecter) RecordHistogramValue(timer interface{}, value interface{}) *Scope_RecordHistogramValue_Call { + return &Scope_RecordHistogramValue_Call{Call: _e.mock.On("RecordHistogramValue", timer, value)} } -// StartTimer provides a mock function with given fields: timer -func (_m *Scope) StartTimer(timer metrics.MetricIdx) metrics.Stopwatch { - ret := _m.Called(timer) +func (_c *Scope_RecordHistogramValue_Call) Run(run func(timer metrics.MetricIdx, value float64)) *Scope_RecordHistogramValue_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.MetricIdx + if args[0] != nil { + arg0 = args[0].(metrics.MetricIdx) + } + var arg1 float64 + if args[1] != nil { + arg1 = args[1].(float64) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Scope_RecordHistogramValue_Call) Return() *Scope_RecordHistogramValue_Call { + _c.Call.Return() + return _c +} + +func (_c *Scope_RecordHistogramValue_Call) RunAndReturn(run func(timer metrics.MetricIdx, value float64)) *Scope_RecordHistogramValue_Call { + _c.Run(run) + return _c +} + +// RecordTimer provides a mock function for the type Scope +func (_mock *Scope) RecordTimer(timer metrics.MetricIdx, d time.Duration) { + _mock.Called(timer, d) + return +} + +// Scope_RecordTimer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordTimer' +type Scope_RecordTimer_Call struct { + *mock.Call +} + +// RecordTimer is a helper method to define mock.On call +// - timer metrics.MetricIdx +// - d time.Duration +func (_e *Scope_Expecter) RecordTimer(timer interface{}, d interface{}) *Scope_RecordTimer_Call { + return &Scope_RecordTimer_Call{Call: _e.mock.On("RecordTimer", timer, d)} +} + +func (_c *Scope_RecordTimer_Call) Run(run func(timer metrics.MetricIdx, d time.Duration)) *Scope_RecordTimer_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.MetricIdx + if args[0] != nil { + arg0 = args[0].(metrics.MetricIdx) + } + var arg1 time.Duration + if args[1] != nil { + arg1 = args[1].(time.Duration) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Scope_RecordTimer_Call) Return() *Scope_RecordTimer_Call { + _c.Call.Return() + return _c +} + +func (_c *Scope_RecordTimer_Call) RunAndReturn(run func(timer metrics.MetricIdx, d time.Duration)) *Scope_RecordTimer_Call { + _c.Run(run) + return _c +} + +// StartTimer provides a mock function for the type Scope +func (_mock *Scope) StartTimer(timer metrics.MetricIdx) metrics.Stopwatch { + ret := _mock.Called(timer) + + if len(ret) == 0 { + panic("no return value specified for StartTimer") + } var r0 metrics.Stopwatch - if rf, ok := ret.Get(0).(func(idx metrics.MetricIdx) metrics.Stopwatch); ok { - r0 = rf(timer) + if returnFunc, ok := ret.Get(0).(func(metrics.MetricIdx) metrics.Stopwatch); ok { + r0 = returnFunc(timer) } else { r0 = ret.Get(0).(metrics.Stopwatch) } - return r0 } -// Tagged provides a mock function with given fields: tags -func (_m *Scope) Tagged(tags ...metrics.Tag) metrics.Scope { - _va := make([]interface{}, len(tags)) - for _i := range tags { - _va[_i] = tags[_i] +// Scope_StartTimer_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartTimer' +type Scope_StartTimer_Call struct { + *mock.Call +} + +// StartTimer is a helper method to define mock.On call +// - timer metrics.MetricIdx +func (_e *Scope_Expecter) StartTimer(timer interface{}) *Scope_StartTimer_Call { + return &Scope_StartTimer_Call{Call: _e.mock.On("StartTimer", timer)} +} + +func (_c *Scope_StartTimer_Call) Run(run func(timer metrics.MetricIdx)) *Scope_StartTimer_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.MetricIdx + if args[0] != nil { + arg0 = args[0].(metrics.MetricIdx) + } + run( + arg0, + ) + }) + return _c +} + +func (_c *Scope_StartTimer_Call) Return(stopwatch metrics.Stopwatch) *Scope_StartTimer_Call { + _c.Call.Return(stopwatch) + return _c +} + +func (_c *Scope_StartTimer_Call) RunAndReturn(run func(timer metrics.MetricIdx) metrics.Stopwatch) *Scope_StartTimer_Call { + _c.Call.Return(run) + return _c +} + +// Tagged provides a mock function for the type Scope +func (_mock *Scope) Tagged(tags ...metrics.Tag) metrics.Scope { + var tmpRet mock.Arguments + if len(tags) > 0 { + tmpRet = _mock.Called(tags) + } else { + tmpRet = _mock.Called() + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for Tagged") } - var _ca []interface{} - _ca = append(_ca, _va...) - ret := _m.Called(_ca...) var r0 metrics.Scope - if rf, ok := ret.Get(0).(func(...metrics.Tag) metrics.Scope); ok { - r0 = rf(tags...) + if returnFunc, ok := ret.Get(0).(func(...metrics.Tag) metrics.Scope); ok { + r0 = returnFunc(tags...) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(metrics.Scope) } } - return r0 } -// UpdateGauge provides a mock function with given fields: gauge, value -func (_m *Scope) UpdateGauge(gauge metrics.MetricIdx, value float64) { - _m.Called(gauge, value) +// Scope_Tagged_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Tagged' +type Scope_Tagged_Call struct { + *mock.Call +} + +// Tagged is a helper method to define mock.On call +// - tags ...metrics.Tag +func (_e *Scope_Expecter) Tagged(tags ...interface{}) *Scope_Tagged_Call { + return &Scope_Tagged_Call{Call: _e.mock.On("Tagged", + append([]interface{}{}, tags...)...)} +} + +func (_c *Scope_Tagged_Call) Run(run func(tags ...metrics.Tag)) *Scope_Tagged_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 []metrics.Tag + var variadicArgs []metrics.Tag + if len(args) > 0 { + variadicArgs = args[0].([]metrics.Tag) + } + arg0 = variadicArgs + run( + arg0..., + ) + }) + return _c +} + +func (_c *Scope_Tagged_Call) Return(scope metrics.Scope) *Scope_Tagged_Call { + _c.Call.Return(scope) + return _c +} + +func (_c *Scope_Tagged_Call) RunAndReturn(run func(tags ...metrics.Tag) metrics.Scope) *Scope_Tagged_Call { + _c.Call.Return(run) + return _c +} + +// UpdateGauge provides a mock function for the type Scope +func (_mock *Scope) UpdateGauge(gauge metrics.MetricIdx, value float64) { + _mock.Called(gauge, value) + return +} + +// Scope_UpdateGauge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateGauge' +type Scope_UpdateGauge_Call struct { + *mock.Call +} + +// UpdateGauge is a helper method to define mock.On call +// - gauge metrics.MetricIdx +// - value float64 +func (_e *Scope_Expecter) UpdateGauge(gauge interface{}, value interface{}) *Scope_UpdateGauge_Call { + return &Scope_UpdateGauge_Call{Call: _e.mock.On("UpdateGauge", gauge, value)} +} + +func (_c *Scope_UpdateGauge_Call) Run(run func(gauge metrics.MetricIdx, value float64)) *Scope_UpdateGauge_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 metrics.MetricIdx + if args[0] != nil { + arg0 = args[0].(metrics.MetricIdx) + } + var arg1 float64 + if args[1] != nil { + arg1 = args[1].(float64) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *Scope_UpdateGauge_Call) Return() *Scope_UpdateGauge_Call { + _c.Call.Return() + return _c +} + +func (_c *Scope_UpdateGauge_Call) RunAndReturn(run func(gauge metrics.MetricIdx, value float64)) *Scope_UpdateGauge_Call { + _c.Run(run) + return _c } diff --git a/common/mocks/ExecutionManager.go b/common/mocks/ExecutionManager.go index 04c1754e00f..900fd274426 100644 --- a/common/mocks/ExecutionManager.go +++ b/common/mocks/ExecutionManager.go @@ -1,548 +1,1537 @@ -// The MIT License (MIT) - -// Copyright (c) 2017-2020 Uber Technologies Inc. - -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. - -// Code generated by mockery v2.32.0. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - context "context" + "context" mock "github.com/stretchr/testify/mock" - persistence "github.com/uber/cadence/common/persistence" - types "github.com/uber/cadence/common/types" + "github.com/uber/cadence/common/persistence" + "github.com/uber/cadence/common/types" ) +// NewExecutionManager creates a new instance of ExecutionManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewExecutionManager(t interface { + mock.TestingT + Cleanup(func()) +}) *ExecutionManager { + mock := &ExecutionManager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // ExecutionManager is an autogenerated mock type for the ExecutionManager type type ExecutionManager struct { mock.Mock } -// Close provides a mock function with given fields: -func (_m *ExecutionManager) Close() { - _m.Called() +type ExecutionManager_Expecter struct { + mock *mock.Mock } -// CompleteHistoryTask provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) CompleteHistoryTask(ctx context.Context, request *persistence.CompleteHistoryTaskRequest) error { - ret := _m.Called(ctx, request) +func (_m *ExecutionManager) EXPECT() *ExecutionManager_Expecter { + return &ExecutionManager_Expecter{mock: &_m.Mock} +} + +// Close provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) Close() { + _mock.Called() + return +} + +// ExecutionManager_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type ExecutionManager_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *ExecutionManager_Expecter) Close() *ExecutionManager_Close_Call { + return &ExecutionManager_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *ExecutionManager_Close_Call) Run(run func()) *ExecutionManager_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ExecutionManager_Close_Call) Return() *ExecutionManager_Close_Call { + _c.Call.Return() + return _c +} + +func (_c *ExecutionManager_Close_Call) RunAndReturn(run func()) *ExecutionManager_Close_Call { + _c.Run(run) + return _c +} + +// CompleteHistoryTask provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) CompleteHistoryTask(ctx context.Context, request *persistence.CompleteHistoryTaskRequest) error { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for CompleteHistoryTask") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.CompleteHistoryTaskRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.CompleteHistoryTaskRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } - return r0 } -// ConflictResolveWorkflowExecution provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) ConflictResolveWorkflowExecution(ctx context.Context, request *persistence.ConflictResolveWorkflowExecutionRequest) (*persistence.ConflictResolveWorkflowExecutionResponse, error) { - ret := _m.Called(ctx, request) +// ExecutionManager_CompleteHistoryTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteHistoryTask' +type ExecutionManager_CompleteHistoryTask_Call struct { + *mock.Call +} + +// CompleteHistoryTask is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.CompleteHistoryTaskRequest +func (_e *ExecutionManager_Expecter) CompleteHistoryTask(ctx interface{}, request interface{}) *ExecutionManager_CompleteHistoryTask_Call { + return &ExecutionManager_CompleteHistoryTask_Call{Call: _e.mock.On("CompleteHistoryTask", ctx, request)} +} + +func (_c *ExecutionManager_CompleteHistoryTask_Call) Run(run func(ctx context.Context, request *persistence.CompleteHistoryTaskRequest)) *ExecutionManager_CompleteHistoryTask_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.CompleteHistoryTaskRequest + if args[1] != nil { + arg1 = args[1].(*persistence.CompleteHistoryTaskRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_CompleteHistoryTask_Call) Return(err error) *ExecutionManager_CompleteHistoryTask_Call { + _c.Call.Return(err) + return _c +} + +func (_c *ExecutionManager_CompleteHistoryTask_Call) RunAndReturn(run func(ctx context.Context, request *persistence.CompleteHistoryTaskRequest) error) *ExecutionManager_CompleteHistoryTask_Call { + _c.Call.Return(run) + return _c +} + +// ConflictResolveWorkflowExecution provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) ConflictResolveWorkflowExecution(ctx context.Context, request *persistence.ConflictResolveWorkflowExecutionRequest) (*persistence.ConflictResolveWorkflowExecutionResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for ConflictResolveWorkflowExecution") + } var r0 *persistence.ConflictResolveWorkflowExecutionResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ConflictResolveWorkflowExecutionRequest) (*persistence.ConflictResolveWorkflowExecutionResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ConflictResolveWorkflowExecutionRequest) (*persistence.ConflictResolveWorkflowExecutionResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ConflictResolveWorkflowExecutionRequest) *persistence.ConflictResolveWorkflowExecutionResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ConflictResolveWorkflowExecutionRequest) *persistence.ConflictResolveWorkflowExecutionResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.ConflictResolveWorkflowExecutionResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.ConflictResolveWorkflowExecutionRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.ConflictResolveWorkflowExecutionRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// CreateFailoverMarkerTasks provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) CreateFailoverMarkerTasks(ctx context.Context, request *persistence.CreateFailoverMarkersRequest) error { - ret := _m.Called(ctx, request) +// ExecutionManager_ConflictResolveWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConflictResolveWorkflowExecution' +type ExecutionManager_ConflictResolveWorkflowExecution_Call struct { + *mock.Call +} + +// ConflictResolveWorkflowExecution is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.ConflictResolveWorkflowExecutionRequest +func (_e *ExecutionManager_Expecter) ConflictResolveWorkflowExecution(ctx interface{}, request interface{}) *ExecutionManager_ConflictResolveWorkflowExecution_Call { + return &ExecutionManager_ConflictResolveWorkflowExecution_Call{Call: _e.mock.On("ConflictResolveWorkflowExecution", ctx, request)} +} + +func (_c *ExecutionManager_ConflictResolveWorkflowExecution_Call) Run(run func(ctx context.Context, request *persistence.ConflictResolveWorkflowExecutionRequest)) *ExecutionManager_ConflictResolveWorkflowExecution_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.ConflictResolveWorkflowExecutionRequest + if args[1] != nil { + arg1 = args[1].(*persistence.ConflictResolveWorkflowExecutionRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_ConflictResolveWorkflowExecution_Call) Return(conflictResolveWorkflowExecutionResponse *persistence.ConflictResolveWorkflowExecutionResponse, err error) *ExecutionManager_ConflictResolveWorkflowExecution_Call { + _c.Call.Return(conflictResolveWorkflowExecutionResponse, err) + return _c +} + +func (_c *ExecutionManager_ConflictResolveWorkflowExecution_Call) RunAndReturn(run func(ctx context.Context, request *persistence.ConflictResolveWorkflowExecutionRequest) (*persistence.ConflictResolveWorkflowExecutionResponse, error)) *ExecutionManager_ConflictResolveWorkflowExecution_Call { + _c.Call.Return(run) + return _c +} + +// CreateFailoverMarkerTasks provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) CreateFailoverMarkerTasks(ctx context.Context, request *persistence.CreateFailoverMarkersRequest) error { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for CreateFailoverMarkerTasks") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.CreateFailoverMarkersRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.CreateFailoverMarkersRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } - return r0 } -// CreateWorkflowExecution provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) CreateWorkflowExecution(ctx context.Context, request *persistence.CreateWorkflowExecutionRequest) (*persistence.CreateWorkflowExecutionResponse, error) { - ret := _m.Called(ctx, request) +// ExecutionManager_CreateFailoverMarkerTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateFailoverMarkerTasks' +type ExecutionManager_CreateFailoverMarkerTasks_Call struct { + *mock.Call +} + +// CreateFailoverMarkerTasks is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.CreateFailoverMarkersRequest +func (_e *ExecutionManager_Expecter) CreateFailoverMarkerTasks(ctx interface{}, request interface{}) *ExecutionManager_CreateFailoverMarkerTasks_Call { + return &ExecutionManager_CreateFailoverMarkerTasks_Call{Call: _e.mock.On("CreateFailoverMarkerTasks", ctx, request)} +} + +func (_c *ExecutionManager_CreateFailoverMarkerTasks_Call) Run(run func(ctx context.Context, request *persistence.CreateFailoverMarkersRequest)) *ExecutionManager_CreateFailoverMarkerTasks_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.CreateFailoverMarkersRequest + if args[1] != nil { + arg1 = args[1].(*persistence.CreateFailoverMarkersRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_CreateFailoverMarkerTasks_Call) Return(err error) *ExecutionManager_CreateFailoverMarkerTasks_Call { + _c.Call.Return(err) + return _c +} + +func (_c *ExecutionManager_CreateFailoverMarkerTasks_Call) RunAndReturn(run func(ctx context.Context, request *persistence.CreateFailoverMarkersRequest) error) *ExecutionManager_CreateFailoverMarkerTasks_Call { + _c.Call.Return(run) + return _c +} + +// CreateWorkflowExecution provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) CreateWorkflowExecution(ctx context.Context, request *persistence.CreateWorkflowExecutionRequest) (*persistence.CreateWorkflowExecutionResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for CreateWorkflowExecution") + } var r0 *persistence.CreateWorkflowExecutionResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.CreateWorkflowExecutionRequest) (*persistence.CreateWorkflowExecutionResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.CreateWorkflowExecutionRequest) (*persistence.CreateWorkflowExecutionResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.CreateWorkflowExecutionRequest) *persistence.CreateWorkflowExecutionResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.CreateWorkflowExecutionRequest) *persistence.CreateWorkflowExecutionResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.CreateWorkflowExecutionResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.CreateWorkflowExecutionRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.CreateWorkflowExecutionRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteCurrentWorkflowExecution provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) DeleteCurrentWorkflowExecution(ctx context.Context, request *persistence.DeleteCurrentWorkflowExecutionRequest) error { - ret := _m.Called(ctx, request) +// ExecutionManager_CreateWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateWorkflowExecution' +type ExecutionManager_CreateWorkflowExecution_Call struct { + *mock.Call +} + +// CreateWorkflowExecution is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.CreateWorkflowExecutionRequest +func (_e *ExecutionManager_Expecter) CreateWorkflowExecution(ctx interface{}, request interface{}) *ExecutionManager_CreateWorkflowExecution_Call { + return &ExecutionManager_CreateWorkflowExecution_Call{Call: _e.mock.On("CreateWorkflowExecution", ctx, request)} +} + +func (_c *ExecutionManager_CreateWorkflowExecution_Call) Run(run func(ctx context.Context, request *persistence.CreateWorkflowExecutionRequest)) *ExecutionManager_CreateWorkflowExecution_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.CreateWorkflowExecutionRequest + if args[1] != nil { + arg1 = args[1].(*persistence.CreateWorkflowExecutionRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_CreateWorkflowExecution_Call) Return(createWorkflowExecutionResponse *persistence.CreateWorkflowExecutionResponse, err error) *ExecutionManager_CreateWorkflowExecution_Call { + _c.Call.Return(createWorkflowExecutionResponse, err) + return _c +} + +func (_c *ExecutionManager_CreateWorkflowExecution_Call) RunAndReturn(run func(ctx context.Context, request *persistence.CreateWorkflowExecutionRequest) (*persistence.CreateWorkflowExecutionResponse, error)) *ExecutionManager_CreateWorkflowExecution_Call { + _c.Call.Return(run) + return _c +} + +// DeleteActiveClusterSelectionPolicy provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) DeleteActiveClusterSelectionPolicy(ctx context.Context, domainID string, workflowID string, runID string) error { + ret := _mock.Called(ctx, domainID, workflowID, runID) + + if len(ret) == 0 { + panic("no return value specified for DeleteActiveClusterSelectionPolicy") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.DeleteCurrentWorkflowExecutionRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok { + r0 = returnFunc(ctx, domainID, workflowID, runID) } else { r0 = ret.Error(0) } - return r0 } -// DeleteReplicationTaskFromDLQ provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) DeleteReplicationTaskFromDLQ(ctx context.Context, request *persistence.DeleteReplicationTaskFromDLQRequest) error { - ret := _m.Called(ctx, request) +// ExecutionManager_DeleteActiveClusterSelectionPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteActiveClusterSelectionPolicy' +type ExecutionManager_DeleteActiveClusterSelectionPolicy_Call struct { + *mock.Call +} + +// DeleteActiveClusterSelectionPolicy is a helper method to define mock.On call +// - ctx context.Context +// - domainID string +// - workflowID string +// - runID string +func (_e *ExecutionManager_Expecter) DeleteActiveClusterSelectionPolicy(ctx interface{}, domainID interface{}, workflowID interface{}, runID interface{}) *ExecutionManager_DeleteActiveClusterSelectionPolicy_Call { + return &ExecutionManager_DeleteActiveClusterSelectionPolicy_Call{Call: _e.mock.On("DeleteActiveClusterSelectionPolicy", ctx, domainID, workflowID, runID)} +} + +func (_c *ExecutionManager_DeleteActiveClusterSelectionPolicy_Call) Run(run func(ctx context.Context, domainID string, workflowID string, runID string)) *ExecutionManager_DeleteActiveClusterSelectionPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *ExecutionManager_DeleteActiveClusterSelectionPolicy_Call) Return(err error) *ExecutionManager_DeleteActiveClusterSelectionPolicy_Call { + _c.Call.Return(err) + return _c +} + +func (_c *ExecutionManager_DeleteActiveClusterSelectionPolicy_Call) RunAndReturn(run func(ctx context.Context, domainID string, workflowID string, runID string) error) *ExecutionManager_DeleteActiveClusterSelectionPolicy_Call { + _c.Call.Return(run) + return _c +} + +// DeleteCurrentWorkflowExecution provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) DeleteCurrentWorkflowExecution(ctx context.Context, request *persistence.DeleteCurrentWorkflowExecutionRequest) error { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for DeleteCurrentWorkflowExecution") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.DeleteReplicationTaskFromDLQRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.DeleteCurrentWorkflowExecutionRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } - return r0 } -// DeleteWorkflowExecution provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) DeleteWorkflowExecution(ctx context.Context, request *persistence.DeleteWorkflowExecutionRequest) error { - ret := _m.Called(ctx, request) +// ExecutionManager_DeleteCurrentWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteCurrentWorkflowExecution' +type ExecutionManager_DeleteCurrentWorkflowExecution_Call struct { + *mock.Call +} + +// DeleteCurrentWorkflowExecution is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.DeleteCurrentWorkflowExecutionRequest +func (_e *ExecutionManager_Expecter) DeleteCurrentWorkflowExecution(ctx interface{}, request interface{}) *ExecutionManager_DeleteCurrentWorkflowExecution_Call { + return &ExecutionManager_DeleteCurrentWorkflowExecution_Call{Call: _e.mock.On("DeleteCurrentWorkflowExecution", ctx, request)} +} + +func (_c *ExecutionManager_DeleteCurrentWorkflowExecution_Call) Run(run func(ctx context.Context, request *persistence.DeleteCurrentWorkflowExecutionRequest)) *ExecutionManager_DeleteCurrentWorkflowExecution_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.DeleteCurrentWorkflowExecutionRequest + if args[1] != nil { + arg1 = args[1].(*persistence.DeleteCurrentWorkflowExecutionRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_DeleteCurrentWorkflowExecution_Call) Return(err error) *ExecutionManager_DeleteCurrentWorkflowExecution_Call { + _c.Call.Return(err) + return _c +} + +func (_c *ExecutionManager_DeleteCurrentWorkflowExecution_Call) RunAndReturn(run func(ctx context.Context, request *persistence.DeleteCurrentWorkflowExecutionRequest) error) *ExecutionManager_DeleteCurrentWorkflowExecution_Call { + _c.Call.Return(run) + return _c +} + +// DeleteReplicationTaskFromDLQ provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) DeleteReplicationTaskFromDLQ(ctx context.Context, request *persistence.DeleteReplicationTaskFromDLQRequest) error { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for DeleteReplicationTaskFromDLQ") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.DeleteWorkflowExecutionRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.DeleteReplicationTaskFromDLQRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } + return r0 +} +// ExecutionManager_DeleteReplicationTaskFromDLQ_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteReplicationTaskFromDLQ' +type ExecutionManager_DeleteReplicationTaskFromDLQ_Call struct { + *mock.Call +} + +// DeleteReplicationTaskFromDLQ is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.DeleteReplicationTaskFromDLQRequest +func (_e *ExecutionManager_Expecter) DeleteReplicationTaskFromDLQ(ctx interface{}, request interface{}) *ExecutionManager_DeleteReplicationTaskFromDLQ_Call { + return &ExecutionManager_DeleteReplicationTaskFromDLQ_Call{Call: _e.mock.On("DeleteReplicationTaskFromDLQ", ctx, request)} +} + +func (_c *ExecutionManager_DeleteReplicationTaskFromDLQ_Call) Run(run func(ctx context.Context, request *persistence.DeleteReplicationTaskFromDLQRequest)) *ExecutionManager_DeleteReplicationTaskFromDLQ_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.DeleteReplicationTaskFromDLQRequest + if args[1] != nil { + arg1 = args[1].(*persistence.DeleteReplicationTaskFromDLQRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_DeleteReplicationTaskFromDLQ_Call) Return(err error) *ExecutionManager_DeleteReplicationTaskFromDLQ_Call { + _c.Call.Return(err) + return _c +} + +func (_c *ExecutionManager_DeleteReplicationTaskFromDLQ_Call) RunAndReturn(run func(ctx context.Context, request *persistence.DeleteReplicationTaskFromDLQRequest) error) *ExecutionManager_DeleteReplicationTaskFromDLQ_Call { + _c.Call.Return(run) + return _c +} + +// DeleteWorkflowExecution provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) DeleteWorkflowExecution(ctx context.Context, request *persistence.DeleteWorkflowExecutionRequest) error { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for DeleteWorkflowExecution") + } + + var r0 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.DeleteWorkflowExecutionRequest) error); ok { + r0 = returnFunc(ctx, request) + } else { + r0 = ret.Error(0) + } return r0 } -// GetCurrentExecution provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) GetCurrentExecution(ctx context.Context, request *persistence.GetCurrentExecutionRequest) (*persistence.GetCurrentExecutionResponse, error) { - ret := _m.Called(ctx, request) +// ExecutionManager_DeleteWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteWorkflowExecution' +type ExecutionManager_DeleteWorkflowExecution_Call struct { + *mock.Call +} + +// DeleteWorkflowExecution is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.DeleteWorkflowExecutionRequest +func (_e *ExecutionManager_Expecter) DeleteWorkflowExecution(ctx interface{}, request interface{}) *ExecutionManager_DeleteWorkflowExecution_Call { + return &ExecutionManager_DeleteWorkflowExecution_Call{Call: _e.mock.On("DeleteWorkflowExecution", ctx, request)} +} + +func (_c *ExecutionManager_DeleteWorkflowExecution_Call) Run(run func(ctx context.Context, request *persistence.DeleteWorkflowExecutionRequest)) *ExecutionManager_DeleteWorkflowExecution_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.DeleteWorkflowExecutionRequest + if args[1] != nil { + arg1 = args[1].(*persistence.DeleteWorkflowExecutionRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_DeleteWorkflowExecution_Call) Return(err error) *ExecutionManager_DeleteWorkflowExecution_Call { + _c.Call.Return(err) + return _c +} + +func (_c *ExecutionManager_DeleteWorkflowExecution_Call) RunAndReturn(run func(ctx context.Context, request *persistence.DeleteWorkflowExecutionRequest) error) *ExecutionManager_DeleteWorkflowExecution_Call { + _c.Call.Return(run) + return _c +} + +// GetActiveClusterSelectionPolicy provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) GetActiveClusterSelectionPolicy(ctx context.Context, domainID string, wfID string, rID string) (*types.ActiveClusterSelectionPolicy, error) { + ret := _mock.Called(ctx, domainID, wfID, rID) + + if len(ret) == 0 { + panic("no return value specified for GetActiveClusterSelectionPolicy") + } + + var r0 *types.ActiveClusterSelectionPolicy + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) (*types.ActiveClusterSelectionPolicy, error)); ok { + return returnFunc(ctx, domainID, wfID, rID) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, string, string, string) *types.ActiveClusterSelectionPolicy); ok { + r0 = returnFunc(ctx, domainID, wfID, rID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*types.ActiveClusterSelectionPolicy) + } + } + if returnFunc, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok { + r1 = returnFunc(ctx, domainID, wfID, rID) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + +// ExecutionManager_GetActiveClusterSelectionPolicy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetActiveClusterSelectionPolicy' +type ExecutionManager_GetActiveClusterSelectionPolicy_Call struct { + *mock.Call +} + +// GetActiveClusterSelectionPolicy is a helper method to define mock.On call +// - ctx context.Context +// - domainID string +// - wfID string +// - rID string +func (_e *ExecutionManager_Expecter) GetActiveClusterSelectionPolicy(ctx interface{}, domainID interface{}, wfID interface{}, rID interface{}) *ExecutionManager_GetActiveClusterSelectionPolicy_Call { + return &ExecutionManager_GetActiveClusterSelectionPolicy_Call{Call: _e.mock.On("GetActiveClusterSelectionPolicy", ctx, domainID, wfID, rID)} +} + +func (_c *ExecutionManager_GetActiveClusterSelectionPolicy_Call) Run(run func(ctx context.Context, domainID string, wfID string, rID string)) *ExecutionManager_GetActiveClusterSelectionPolicy_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 string + if args[1] != nil { + arg1 = args[1].(string) + } + var arg2 string + if args[2] != nil { + arg2 = args[2].(string) + } + var arg3 string + if args[3] != nil { + arg3 = args[3].(string) + } + run( + arg0, + arg1, + arg2, + arg3, + ) + }) + return _c +} + +func (_c *ExecutionManager_GetActiveClusterSelectionPolicy_Call) Return(activeClusterSelectionPolicy *types.ActiveClusterSelectionPolicy, err error) *ExecutionManager_GetActiveClusterSelectionPolicy_Call { + _c.Call.Return(activeClusterSelectionPolicy, err) + return _c +} + +func (_c *ExecutionManager_GetActiveClusterSelectionPolicy_Call) RunAndReturn(run func(ctx context.Context, domainID string, wfID string, rID string) (*types.ActiveClusterSelectionPolicy, error)) *ExecutionManager_GetActiveClusterSelectionPolicy_Call { + _c.Call.Return(run) + return _c +} + +// GetCurrentExecution provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) GetCurrentExecution(ctx context.Context, request *persistence.GetCurrentExecutionRequest) (*persistence.GetCurrentExecutionResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for GetCurrentExecution") + } var r0 *persistence.GetCurrentExecutionResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetCurrentExecutionRequest) (*persistence.GetCurrentExecutionResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetCurrentExecutionRequest) (*persistence.GetCurrentExecutionResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetCurrentExecutionRequest) *persistence.GetCurrentExecutionResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetCurrentExecutionRequest) *persistence.GetCurrentExecutionResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.GetCurrentExecutionResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.GetCurrentExecutionRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.GetCurrentExecutionRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetHistoryTasks provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) GetHistoryTasks(ctx context.Context, request *persistence.GetHistoryTasksRequest) (*persistence.GetHistoryTasksResponse, error) { - ret := _m.Called(ctx, request) +// ExecutionManager_GetCurrentExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCurrentExecution' +type ExecutionManager_GetCurrentExecution_Call struct { + *mock.Call +} + +// GetCurrentExecution is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.GetCurrentExecutionRequest +func (_e *ExecutionManager_Expecter) GetCurrentExecution(ctx interface{}, request interface{}) *ExecutionManager_GetCurrentExecution_Call { + return &ExecutionManager_GetCurrentExecution_Call{Call: _e.mock.On("GetCurrentExecution", ctx, request)} +} + +func (_c *ExecutionManager_GetCurrentExecution_Call) Run(run func(ctx context.Context, request *persistence.GetCurrentExecutionRequest)) *ExecutionManager_GetCurrentExecution_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.GetCurrentExecutionRequest + if args[1] != nil { + arg1 = args[1].(*persistence.GetCurrentExecutionRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_GetCurrentExecution_Call) Return(getCurrentExecutionResponse *persistence.GetCurrentExecutionResponse, err error) *ExecutionManager_GetCurrentExecution_Call { + _c.Call.Return(getCurrentExecutionResponse, err) + return _c +} + +func (_c *ExecutionManager_GetCurrentExecution_Call) RunAndReturn(run func(ctx context.Context, request *persistence.GetCurrentExecutionRequest) (*persistence.GetCurrentExecutionResponse, error)) *ExecutionManager_GetCurrentExecution_Call { + _c.Call.Return(run) + return _c +} + +// GetHistoryTasks provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) GetHistoryTasks(ctx context.Context, request *persistence.GetHistoryTasksRequest) (*persistence.GetHistoryTasksResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for GetHistoryTasks") + } var r0 *persistence.GetHistoryTasksResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetHistoryTasksRequest) (*persistence.GetHistoryTasksResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetHistoryTasksRequest) (*persistence.GetHistoryTasksResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetHistoryTasksRequest) *persistence.GetHistoryTasksResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetHistoryTasksRequest) *persistence.GetHistoryTasksResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.GetHistoryTasksResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.GetHistoryTasksRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.GetHistoryTasksRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetName provides a mock function with given fields: -func (_m *ExecutionManager) GetName() string { - ret := _m.Called() +// ExecutionManager_GetHistoryTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHistoryTasks' +type ExecutionManager_GetHistoryTasks_Call struct { + *mock.Call +} + +// GetHistoryTasks is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.GetHistoryTasksRequest +func (_e *ExecutionManager_Expecter) GetHistoryTasks(ctx interface{}, request interface{}) *ExecutionManager_GetHistoryTasks_Call { + return &ExecutionManager_GetHistoryTasks_Call{Call: _e.mock.On("GetHistoryTasks", ctx, request)} +} + +func (_c *ExecutionManager_GetHistoryTasks_Call) Run(run func(ctx context.Context, request *persistence.GetHistoryTasksRequest)) *ExecutionManager_GetHistoryTasks_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.GetHistoryTasksRequest + if args[1] != nil { + arg1 = args[1].(*persistence.GetHistoryTasksRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_GetHistoryTasks_Call) Return(getHistoryTasksResponse *persistence.GetHistoryTasksResponse, err error) *ExecutionManager_GetHistoryTasks_Call { + _c.Call.Return(getHistoryTasksResponse, err) + return _c +} + +func (_c *ExecutionManager_GetHistoryTasks_Call) RunAndReturn(run func(ctx context.Context, request *persistence.GetHistoryTasksRequest) (*persistence.GetHistoryTasksResponse, error)) *ExecutionManager_GetHistoryTasks_Call { + _c.Call.Return(run) + return _c +} + +// GetName provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) GetName() string { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for GetName") + } var r0 string - if rf, ok := ret.Get(0).(func() string); ok { - r0 = rf() + if returnFunc, ok := ret.Get(0).(func() string); ok { + r0 = returnFunc() } else { r0 = ret.Get(0).(string) } - return r0 } -// GetReplicationDLQSize provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) GetReplicationDLQSize(ctx context.Context, request *persistence.GetReplicationDLQSizeRequest) (*persistence.GetReplicationDLQSizeResponse, error) { - ret := _m.Called(ctx, request) +// ExecutionManager_GetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetName' +type ExecutionManager_GetName_Call struct { + *mock.Call +} + +// GetName is a helper method to define mock.On call +func (_e *ExecutionManager_Expecter) GetName() *ExecutionManager_GetName_Call { + return &ExecutionManager_GetName_Call{Call: _e.mock.On("GetName")} +} + +func (_c *ExecutionManager_GetName_Call) Run(run func()) *ExecutionManager_GetName_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ExecutionManager_GetName_Call) Return(s string) *ExecutionManager_GetName_Call { + _c.Call.Return(s) + return _c +} + +func (_c *ExecutionManager_GetName_Call) RunAndReturn(run func() string) *ExecutionManager_GetName_Call { + _c.Call.Return(run) + return _c +} + +// GetReplicationDLQSize provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) GetReplicationDLQSize(ctx context.Context, request *persistence.GetReplicationDLQSizeRequest) (*persistence.GetReplicationDLQSizeResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for GetReplicationDLQSize") + } var r0 *persistence.GetReplicationDLQSizeResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetReplicationDLQSizeRequest) (*persistence.GetReplicationDLQSizeResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetReplicationDLQSizeRequest) (*persistence.GetReplicationDLQSizeResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetReplicationDLQSizeRequest) *persistence.GetReplicationDLQSizeResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetReplicationDLQSizeRequest) *persistence.GetReplicationDLQSizeResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.GetReplicationDLQSizeResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.GetReplicationDLQSizeRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.GetReplicationDLQSizeRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetReplicationTasksFromDLQ provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) GetReplicationTasksFromDLQ(ctx context.Context, request *persistence.GetReplicationTasksFromDLQRequest) (*persistence.GetHistoryTasksResponse, error) { - ret := _m.Called(ctx, request) +// ExecutionManager_GetReplicationDLQSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReplicationDLQSize' +type ExecutionManager_GetReplicationDLQSize_Call struct { + *mock.Call +} + +// GetReplicationDLQSize is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.GetReplicationDLQSizeRequest +func (_e *ExecutionManager_Expecter) GetReplicationDLQSize(ctx interface{}, request interface{}) *ExecutionManager_GetReplicationDLQSize_Call { + return &ExecutionManager_GetReplicationDLQSize_Call{Call: _e.mock.On("GetReplicationDLQSize", ctx, request)} +} + +func (_c *ExecutionManager_GetReplicationDLQSize_Call) Run(run func(ctx context.Context, request *persistence.GetReplicationDLQSizeRequest)) *ExecutionManager_GetReplicationDLQSize_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.GetReplicationDLQSizeRequest + if args[1] != nil { + arg1 = args[1].(*persistence.GetReplicationDLQSizeRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_GetReplicationDLQSize_Call) Return(getReplicationDLQSizeResponse *persistence.GetReplicationDLQSizeResponse, err error) *ExecutionManager_GetReplicationDLQSize_Call { + _c.Call.Return(getReplicationDLQSizeResponse, err) + return _c +} + +func (_c *ExecutionManager_GetReplicationDLQSize_Call) RunAndReturn(run func(ctx context.Context, request *persistence.GetReplicationDLQSizeRequest) (*persistence.GetReplicationDLQSizeResponse, error)) *ExecutionManager_GetReplicationDLQSize_Call { + _c.Call.Return(run) + return _c +} + +// GetReplicationTasksFromDLQ provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) GetReplicationTasksFromDLQ(ctx context.Context, request *persistence.GetReplicationTasksFromDLQRequest) (*persistence.GetHistoryTasksResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for GetReplicationTasksFromDLQ") + } var r0 *persistence.GetHistoryTasksResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetReplicationTasksFromDLQRequest) (*persistence.GetHistoryTasksResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetReplicationTasksFromDLQRequest) (*persistence.GetHistoryTasksResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetReplicationTasksFromDLQRequest) *persistence.GetHistoryTasksResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetReplicationTasksFromDLQRequest) *persistence.GetHistoryTasksResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.GetHistoryTasksResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.GetReplicationTasksFromDLQRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.GetReplicationTasksFromDLQRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetShardID provides a mock function with given fields: -func (_m *ExecutionManager) GetShardID() int { - ret := _m.Called() +// ExecutionManager_GetReplicationTasksFromDLQ_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReplicationTasksFromDLQ' +type ExecutionManager_GetReplicationTasksFromDLQ_Call struct { + *mock.Call +} + +// GetReplicationTasksFromDLQ is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.GetReplicationTasksFromDLQRequest +func (_e *ExecutionManager_Expecter) GetReplicationTasksFromDLQ(ctx interface{}, request interface{}) *ExecutionManager_GetReplicationTasksFromDLQ_Call { + return &ExecutionManager_GetReplicationTasksFromDLQ_Call{Call: _e.mock.On("GetReplicationTasksFromDLQ", ctx, request)} +} + +func (_c *ExecutionManager_GetReplicationTasksFromDLQ_Call) Run(run func(ctx context.Context, request *persistence.GetReplicationTasksFromDLQRequest)) *ExecutionManager_GetReplicationTasksFromDLQ_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.GetReplicationTasksFromDLQRequest + if args[1] != nil { + arg1 = args[1].(*persistence.GetReplicationTasksFromDLQRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_GetReplicationTasksFromDLQ_Call) Return(getHistoryTasksResponse *persistence.GetHistoryTasksResponse, err error) *ExecutionManager_GetReplicationTasksFromDLQ_Call { + _c.Call.Return(getHistoryTasksResponse, err) + return _c +} + +func (_c *ExecutionManager_GetReplicationTasksFromDLQ_Call) RunAndReturn(run func(ctx context.Context, request *persistence.GetReplicationTasksFromDLQRequest) (*persistence.GetHistoryTasksResponse, error)) *ExecutionManager_GetReplicationTasksFromDLQ_Call { + _c.Call.Return(run) + return _c +} + +// GetShardID provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) GetShardID() int { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for GetShardID") + } var r0 int - if rf, ok := ret.Get(0).(func() int); ok { - r0 = rf() + if returnFunc, ok := ret.Get(0).(func() int); ok { + r0 = returnFunc() } else { r0 = ret.Get(0).(int) } - return r0 } -// GetWorkflowExecution provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) GetWorkflowExecution(ctx context.Context, request *persistence.GetWorkflowExecutionRequest) (*persistence.GetWorkflowExecutionResponse, error) { - ret := _m.Called(ctx, request) +// ExecutionManager_GetShardID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShardID' +type ExecutionManager_GetShardID_Call struct { + *mock.Call +} + +// GetShardID is a helper method to define mock.On call +func (_e *ExecutionManager_Expecter) GetShardID() *ExecutionManager_GetShardID_Call { + return &ExecutionManager_GetShardID_Call{Call: _e.mock.On("GetShardID")} +} + +func (_c *ExecutionManager_GetShardID_Call) Run(run func()) *ExecutionManager_GetShardID_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ExecutionManager_GetShardID_Call) Return(n int) *ExecutionManager_GetShardID_Call { + _c.Call.Return(n) + return _c +} + +func (_c *ExecutionManager_GetShardID_Call) RunAndReturn(run func() int) *ExecutionManager_GetShardID_Call { + _c.Call.Return(run) + return _c +} + +// GetWorkflowExecution provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) GetWorkflowExecution(ctx context.Context, request *persistence.GetWorkflowExecutionRequest) (*persistence.GetWorkflowExecutionResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for GetWorkflowExecution") + } var r0 *persistence.GetWorkflowExecutionResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetWorkflowExecutionRequest) (*persistence.GetWorkflowExecutionResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetWorkflowExecutionRequest) (*persistence.GetWorkflowExecutionResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetWorkflowExecutionRequest) *persistence.GetWorkflowExecutionResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetWorkflowExecutionRequest) *persistence.GetWorkflowExecutionResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.GetWorkflowExecutionResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.GetWorkflowExecutionRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.GetWorkflowExecutionRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// IsWorkflowExecutionExists provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) IsWorkflowExecutionExists(ctx context.Context, request *persistence.IsWorkflowExecutionExistsRequest) (*persistence.IsWorkflowExecutionExistsResponse, error) { - ret := _m.Called(ctx, request) +// ExecutionManager_GetWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWorkflowExecution' +type ExecutionManager_GetWorkflowExecution_Call struct { + *mock.Call +} + +// GetWorkflowExecution is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.GetWorkflowExecutionRequest +func (_e *ExecutionManager_Expecter) GetWorkflowExecution(ctx interface{}, request interface{}) *ExecutionManager_GetWorkflowExecution_Call { + return &ExecutionManager_GetWorkflowExecution_Call{Call: _e.mock.On("GetWorkflowExecution", ctx, request)} +} + +func (_c *ExecutionManager_GetWorkflowExecution_Call) Run(run func(ctx context.Context, request *persistence.GetWorkflowExecutionRequest)) *ExecutionManager_GetWorkflowExecution_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.GetWorkflowExecutionRequest + if args[1] != nil { + arg1 = args[1].(*persistence.GetWorkflowExecutionRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_GetWorkflowExecution_Call) Return(getWorkflowExecutionResponse *persistence.GetWorkflowExecutionResponse, err error) *ExecutionManager_GetWorkflowExecution_Call { + _c.Call.Return(getWorkflowExecutionResponse, err) + return _c +} + +func (_c *ExecutionManager_GetWorkflowExecution_Call) RunAndReturn(run func(ctx context.Context, request *persistence.GetWorkflowExecutionRequest) (*persistence.GetWorkflowExecutionResponse, error)) *ExecutionManager_GetWorkflowExecution_Call { + _c.Call.Return(run) + return _c +} + +// IsWorkflowExecutionExists provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) IsWorkflowExecutionExists(ctx context.Context, request *persistence.IsWorkflowExecutionExistsRequest) (*persistence.IsWorkflowExecutionExistsResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for IsWorkflowExecutionExists") + } var r0 *persistence.IsWorkflowExecutionExistsResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.IsWorkflowExecutionExistsRequest) (*persistence.IsWorkflowExecutionExistsResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.IsWorkflowExecutionExistsRequest) (*persistence.IsWorkflowExecutionExistsResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.IsWorkflowExecutionExistsRequest) *persistence.IsWorkflowExecutionExistsResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.IsWorkflowExecutionExistsRequest) *persistence.IsWorkflowExecutionExistsResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.IsWorkflowExecutionExistsResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.IsWorkflowExecutionExistsRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.IsWorkflowExecutionExistsRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListConcreteExecutions provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) ListConcreteExecutions(ctx context.Context, request *persistence.ListConcreteExecutionsRequest) (*persistence.ListConcreteExecutionsResponse, error) { - ret := _m.Called(ctx, request) +// ExecutionManager_IsWorkflowExecutionExists_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsWorkflowExecutionExists' +type ExecutionManager_IsWorkflowExecutionExists_Call struct { + *mock.Call +} + +// IsWorkflowExecutionExists is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.IsWorkflowExecutionExistsRequest +func (_e *ExecutionManager_Expecter) IsWorkflowExecutionExists(ctx interface{}, request interface{}) *ExecutionManager_IsWorkflowExecutionExists_Call { + return &ExecutionManager_IsWorkflowExecutionExists_Call{Call: _e.mock.On("IsWorkflowExecutionExists", ctx, request)} +} + +func (_c *ExecutionManager_IsWorkflowExecutionExists_Call) Run(run func(ctx context.Context, request *persistence.IsWorkflowExecutionExistsRequest)) *ExecutionManager_IsWorkflowExecutionExists_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.IsWorkflowExecutionExistsRequest + if args[1] != nil { + arg1 = args[1].(*persistence.IsWorkflowExecutionExistsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_IsWorkflowExecutionExists_Call) Return(isWorkflowExecutionExistsResponse *persistence.IsWorkflowExecutionExistsResponse, err error) *ExecutionManager_IsWorkflowExecutionExists_Call { + _c.Call.Return(isWorkflowExecutionExistsResponse, err) + return _c +} + +func (_c *ExecutionManager_IsWorkflowExecutionExists_Call) RunAndReturn(run func(ctx context.Context, request *persistence.IsWorkflowExecutionExistsRequest) (*persistence.IsWorkflowExecutionExistsResponse, error)) *ExecutionManager_IsWorkflowExecutionExists_Call { + _c.Call.Return(run) + return _c +} + +// ListConcreteExecutions provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) ListConcreteExecutions(ctx context.Context, request *persistence.ListConcreteExecutionsRequest) (*persistence.ListConcreteExecutionsResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for ListConcreteExecutions") + } var r0 *persistence.ListConcreteExecutionsResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListConcreteExecutionsRequest) (*persistence.ListConcreteExecutionsResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListConcreteExecutionsRequest) (*persistence.ListConcreteExecutionsResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListConcreteExecutionsRequest) *persistence.ListConcreteExecutionsResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListConcreteExecutionsRequest) *persistence.ListConcreteExecutionsResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.ListConcreteExecutionsResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.ListConcreteExecutionsRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.ListConcreteExecutionsRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListCurrentExecutions provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) ListCurrentExecutions(ctx context.Context, request *persistence.ListCurrentExecutionsRequest) (*persistence.ListCurrentExecutionsResponse, error) { - ret := _m.Called(ctx, request) +// ExecutionManager_ListConcreteExecutions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListConcreteExecutions' +type ExecutionManager_ListConcreteExecutions_Call struct { + *mock.Call +} + +// ListConcreteExecutions is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.ListConcreteExecutionsRequest +func (_e *ExecutionManager_Expecter) ListConcreteExecutions(ctx interface{}, request interface{}) *ExecutionManager_ListConcreteExecutions_Call { + return &ExecutionManager_ListConcreteExecutions_Call{Call: _e.mock.On("ListConcreteExecutions", ctx, request)} +} + +func (_c *ExecutionManager_ListConcreteExecutions_Call) Run(run func(ctx context.Context, request *persistence.ListConcreteExecutionsRequest)) *ExecutionManager_ListConcreteExecutions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.ListConcreteExecutionsRequest + if args[1] != nil { + arg1 = args[1].(*persistence.ListConcreteExecutionsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_ListConcreteExecutions_Call) Return(listConcreteExecutionsResponse *persistence.ListConcreteExecutionsResponse, err error) *ExecutionManager_ListConcreteExecutions_Call { + _c.Call.Return(listConcreteExecutionsResponse, err) + return _c +} + +func (_c *ExecutionManager_ListConcreteExecutions_Call) RunAndReturn(run func(ctx context.Context, request *persistence.ListConcreteExecutionsRequest) (*persistence.ListConcreteExecutionsResponse, error)) *ExecutionManager_ListConcreteExecutions_Call { + _c.Call.Return(run) + return _c +} + +// ListCurrentExecutions provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) ListCurrentExecutions(ctx context.Context, request *persistence.ListCurrentExecutionsRequest) (*persistence.ListCurrentExecutionsResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for ListCurrentExecutions") + } var r0 *persistence.ListCurrentExecutionsResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListCurrentExecutionsRequest) (*persistence.ListCurrentExecutionsResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListCurrentExecutionsRequest) (*persistence.ListCurrentExecutionsResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListCurrentExecutionsRequest) *persistence.ListCurrentExecutionsResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListCurrentExecutionsRequest) *persistence.ListCurrentExecutionsResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.ListCurrentExecutionsResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.ListCurrentExecutionsRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.ListCurrentExecutionsRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// PutReplicationTaskToDLQ provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) PutReplicationTaskToDLQ(ctx context.Context, request *persistence.PutReplicationTaskToDLQRequest) error { - ret := _m.Called(ctx, request) +// ExecutionManager_ListCurrentExecutions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListCurrentExecutions' +type ExecutionManager_ListCurrentExecutions_Call struct { + *mock.Call +} + +// ListCurrentExecutions is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.ListCurrentExecutionsRequest +func (_e *ExecutionManager_Expecter) ListCurrentExecutions(ctx interface{}, request interface{}) *ExecutionManager_ListCurrentExecutions_Call { + return &ExecutionManager_ListCurrentExecutions_Call{Call: _e.mock.On("ListCurrentExecutions", ctx, request)} +} + +func (_c *ExecutionManager_ListCurrentExecutions_Call) Run(run func(ctx context.Context, request *persistence.ListCurrentExecutionsRequest)) *ExecutionManager_ListCurrentExecutions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.ListCurrentExecutionsRequest + if args[1] != nil { + arg1 = args[1].(*persistence.ListCurrentExecutionsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_ListCurrentExecutions_Call) Return(listCurrentExecutionsResponse *persistence.ListCurrentExecutionsResponse, err error) *ExecutionManager_ListCurrentExecutions_Call { + _c.Call.Return(listCurrentExecutionsResponse, err) + return _c +} + +func (_c *ExecutionManager_ListCurrentExecutions_Call) RunAndReturn(run func(ctx context.Context, request *persistence.ListCurrentExecutionsRequest) (*persistence.ListCurrentExecutionsResponse, error)) *ExecutionManager_ListCurrentExecutions_Call { + _c.Call.Return(run) + return _c +} + +// PutReplicationTaskToDLQ provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) PutReplicationTaskToDLQ(ctx context.Context, request *persistence.PutReplicationTaskToDLQRequest) error { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for PutReplicationTaskToDLQ") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.PutReplicationTaskToDLQRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.PutReplicationTaskToDLQRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } - return r0 } -// RangeCompleteHistoryTask provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) RangeCompleteHistoryTask(ctx context.Context, request *persistence.RangeCompleteHistoryTaskRequest) (*persistence.RangeCompleteHistoryTaskResponse, error) { - ret := _m.Called(ctx, request) +// ExecutionManager_PutReplicationTaskToDLQ_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PutReplicationTaskToDLQ' +type ExecutionManager_PutReplicationTaskToDLQ_Call struct { + *mock.Call +} + +// PutReplicationTaskToDLQ is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.PutReplicationTaskToDLQRequest +func (_e *ExecutionManager_Expecter) PutReplicationTaskToDLQ(ctx interface{}, request interface{}) *ExecutionManager_PutReplicationTaskToDLQ_Call { + return &ExecutionManager_PutReplicationTaskToDLQ_Call{Call: _e.mock.On("PutReplicationTaskToDLQ", ctx, request)} +} + +func (_c *ExecutionManager_PutReplicationTaskToDLQ_Call) Run(run func(ctx context.Context, request *persistence.PutReplicationTaskToDLQRequest)) *ExecutionManager_PutReplicationTaskToDLQ_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.PutReplicationTaskToDLQRequest + if args[1] != nil { + arg1 = args[1].(*persistence.PutReplicationTaskToDLQRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_PutReplicationTaskToDLQ_Call) Return(err error) *ExecutionManager_PutReplicationTaskToDLQ_Call { + _c.Call.Return(err) + return _c +} + +func (_c *ExecutionManager_PutReplicationTaskToDLQ_Call) RunAndReturn(run func(ctx context.Context, request *persistence.PutReplicationTaskToDLQRequest) error) *ExecutionManager_PutReplicationTaskToDLQ_Call { + _c.Call.Return(run) + return _c +} + +// RangeCompleteHistoryTask provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) RangeCompleteHistoryTask(ctx context.Context, request *persistence.RangeCompleteHistoryTaskRequest) (*persistence.RangeCompleteHistoryTaskResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for RangeCompleteHistoryTask") + } var r0 *persistence.RangeCompleteHistoryTaskResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.RangeCompleteHistoryTaskRequest) (*persistence.RangeCompleteHistoryTaskResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.RangeCompleteHistoryTaskRequest) (*persistence.RangeCompleteHistoryTaskResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.RangeCompleteHistoryTaskRequest) *persistence.RangeCompleteHistoryTaskResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.RangeCompleteHistoryTaskRequest) *persistence.RangeCompleteHistoryTaskResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.RangeCompleteHistoryTaskResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.RangeCompleteHistoryTaskRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.RangeCompleteHistoryTaskRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// RangeDeleteReplicationTaskFromDLQ provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) RangeDeleteReplicationTaskFromDLQ(ctx context.Context, request *persistence.RangeDeleteReplicationTaskFromDLQRequest) (*persistence.RangeDeleteReplicationTaskFromDLQResponse, error) { - ret := _m.Called(ctx, request) +// ExecutionManager_RangeCompleteHistoryTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RangeCompleteHistoryTask' +type ExecutionManager_RangeCompleteHistoryTask_Call struct { + *mock.Call +} + +// RangeCompleteHistoryTask is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.RangeCompleteHistoryTaskRequest +func (_e *ExecutionManager_Expecter) RangeCompleteHistoryTask(ctx interface{}, request interface{}) *ExecutionManager_RangeCompleteHistoryTask_Call { + return &ExecutionManager_RangeCompleteHistoryTask_Call{Call: _e.mock.On("RangeCompleteHistoryTask", ctx, request)} +} + +func (_c *ExecutionManager_RangeCompleteHistoryTask_Call) Run(run func(ctx context.Context, request *persistence.RangeCompleteHistoryTaskRequest)) *ExecutionManager_RangeCompleteHistoryTask_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.RangeCompleteHistoryTaskRequest + if args[1] != nil { + arg1 = args[1].(*persistence.RangeCompleteHistoryTaskRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ExecutionManager_RangeCompleteHistoryTask_Call) Return(rangeCompleteHistoryTaskResponse *persistence.RangeCompleteHistoryTaskResponse, err error) *ExecutionManager_RangeCompleteHistoryTask_Call { + _c.Call.Return(rangeCompleteHistoryTaskResponse, err) + return _c +} + +func (_c *ExecutionManager_RangeCompleteHistoryTask_Call) RunAndReturn(run func(ctx context.Context, request *persistence.RangeCompleteHistoryTaskRequest) (*persistence.RangeCompleteHistoryTaskResponse, error)) *ExecutionManager_RangeCompleteHistoryTask_Call { + _c.Call.Return(run) + return _c +} + +// RangeDeleteReplicationTaskFromDLQ provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) RangeDeleteReplicationTaskFromDLQ(ctx context.Context, request *persistence.RangeDeleteReplicationTaskFromDLQRequest) (*persistence.RangeDeleteReplicationTaskFromDLQResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for RangeDeleteReplicationTaskFromDLQ") + } var r0 *persistence.RangeDeleteReplicationTaskFromDLQResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.RangeDeleteReplicationTaskFromDLQRequest) (*persistence.RangeDeleteReplicationTaskFromDLQResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.RangeDeleteReplicationTaskFromDLQRequest) (*persistence.RangeDeleteReplicationTaskFromDLQResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.RangeDeleteReplicationTaskFromDLQRequest) *persistence.RangeDeleteReplicationTaskFromDLQResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.RangeDeleteReplicationTaskFromDLQRequest) *persistence.RangeDeleteReplicationTaskFromDLQResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.RangeDeleteReplicationTaskFromDLQResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.RangeDeleteReplicationTaskFromDLQRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.RangeDeleteReplicationTaskFromDLQRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// UpdateWorkflowExecution provides a mock function with given fields: ctx, request -func (_m *ExecutionManager) UpdateWorkflowExecution(ctx context.Context, request *persistence.UpdateWorkflowExecutionRequest) (*persistence.UpdateWorkflowExecutionResponse, error) { - ret := _m.Called(ctx, request) +// ExecutionManager_RangeDeleteReplicationTaskFromDLQ_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RangeDeleteReplicationTaskFromDLQ' +type ExecutionManager_RangeDeleteReplicationTaskFromDLQ_Call struct { + *mock.Call +} - var r0 *persistence.UpdateWorkflowExecutionResponse - var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.UpdateWorkflowExecutionRequest) (*persistence.UpdateWorkflowExecutionResponse, error)); ok { - return rf(ctx, request) - } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.UpdateWorkflowExecutionRequest) *persistence.UpdateWorkflowExecutionResponse); ok { - r0 = rf(ctx, request) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*persistence.UpdateWorkflowExecutionResponse) +// RangeDeleteReplicationTaskFromDLQ is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.RangeDeleteReplicationTaskFromDLQRequest +func (_e *ExecutionManager_Expecter) RangeDeleteReplicationTaskFromDLQ(ctx interface{}, request interface{}) *ExecutionManager_RangeDeleteReplicationTaskFromDLQ_Call { + return &ExecutionManager_RangeDeleteReplicationTaskFromDLQ_Call{Call: _e.mock.On("RangeDeleteReplicationTaskFromDLQ", ctx, request)} +} + +func (_c *ExecutionManager_RangeDeleteReplicationTaskFromDLQ_Call) Run(run func(ctx context.Context, request *persistence.RangeDeleteReplicationTaskFromDLQRequest)) *ExecutionManager_RangeDeleteReplicationTaskFromDLQ_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) } - } + var arg1 *persistence.RangeDeleteReplicationTaskFromDLQRequest + if args[1] != nil { + arg1 = args[1].(*persistence.RangeDeleteReplicationTaskFromDLQRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} - if rf, ok := ret.Get(1).(func(context.Context, *persistence.UpdateWorkflowExecutionRequest) error); ok { - r1 = rf(ctx, request) - } else { - r1 = ret.Error(1) - } +func (_c *ExecutionManager_RangeDeleteReplicationTaskFromDLQ_Call) Return(rangeDeleteReplicationTaskFromDLQResponse *persistence.RangeDeleteReplicationTaskFromDLQResponse, err error) *ExecutionManager_RangeDeleteReplicationTaskFromDLQ_Call { + _c.Call.Return(rangeDeleteReplicationTaskFromDLQResponse, err) + return _c +} - return r0, r1 +func (_c *ExecutionManager_RangeDeleteReplicationTaskFromDLQ_Call) RunAndReturn(run func(ctx context.Context, request *persistence.RangeDeleteReplicationTaskFromDLQRequest) (*persistence.RangeDeleteReplicationTaskFromDLQResponse, error)) *ExecutionManager_RangeDeleteReplicationTaskFromDLQ_Call { + _c.Call.Return(run) + return _c } -// GetActiveClusterSelectionPolicy provides a mock function with given fields: ctx, domainID, wfID, rID -func (_m *ExecutionManager) GetActiveClusterSelectionPolicy(ctx context.Context, domainID, wfID, rID string) (*types.ActiveClusterSelectionPolicy, error) { - ret := _m.Called(ctx, domainID, wfID, rID) +// UpdateWorkflowExecution provides a mock function for the type ExecutionManager +func (_mock *ExecutionManager) UpdateWorkflowExecution(ctx context.Context, request *persistence.UpdateWorkflowExecutionRequest) (*persistence.UpdateWorkflowExecutionResponse, error) { + ret := _mock.Called(ctx, request) - var r0 *types.ActiveClusterSelectionPolicy + if len(ret) == 0 { + panic("no return value specified for UpdateWorkflowExecution") + } + + var r0 *persistence.UpdateWorkflowExecutionResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, string, string, string) (*types.ActiveClusterSelectionPolicy, error)); ok { - return rf(ctx, domainID, wfID, rID) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.UpdateWorkflowExecutionRequest) (*persistence.UpdateWorkflowExecutionResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, string, string, string) *types.ActiveClusterSelectionPolicy); ok { - r0 = rf(ctx, domainID, wfID, rID) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.UpdateWorkflowExecutionRequest) *persistence.UpdateWorkflowExecutionResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*types.ActiveClusterSelectionPolicy) + r0 = ret.Get(0).(*persistence.UpdateWorkflowExecutionResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, string, string, string) error); ok { - r1 = rf(ctx, domainID, wfID, rID) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.UpdateWorkflowExecutionRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteActiveClusterSelectionPolicy provides a mock function with given fields: ctx, domainID, wfID, rID -func (_m *ExecutionManager) DeleteActiveClusterSelectionPolicy(ctx context.Context, domainID, wfID, rID string) error { - ret := _m.Called(ctx, domainID, wfID, rID) - - var r0 error - if rf, ok := ret.Get(0).(func(context.Context, string, string, string) error); ok { - r0 = rf(ctx, domainID, wfID, rID) - } else { - r0 = ret.Error(0) - } +// ExecutionManager_UpdateWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateWorkflowExecution' +type ExecutionManager_UpdateWorkflowExecution_Call struct { + *mock.Call +} - return r0 +// UpdateWorkflowExecution is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.UpdateWorkflowExecutionRequest +func (_e *ExecutionManager_Expecter) UpdateWorkflowExecution(ctx interface{}, request interface{}) *ExecutionManager_UpdateWorkflowExecution_Call { + return &ExecutionManager_UpdateWorkflowExecution_Call{Call: _e.mock.On("UpdateWorkflowExecution", ctx, request)} } -// NewExecutionManager creates a new instance of ExecutionManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewExecutionManager(t interface { - mock.TestingT - Cleanup(func()) -}) *ExecutionManager { - mock := &ExecutionManager{} - mock.Mock.Test(t) +func (_c *ExecutionManager_UpdateWorkflowExecution_Call) Run(run func(ctx context.Context, request *persistence.UpdateWorkflowExecutionRequest)) *ExecutionManager_UpdateWorkflowExecution_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.UpdateWorkflowExecutionRequest + if args[1] != nil { + arg1 = args[1].(*persistence.UpdateWorkflowExecutionRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} - t.Cleanup(func() { mock.AssertExpectations(t) }) +func (_c *ExecutionManager_UpdateWorkflowExecution_Call) Return(updateWorkflowExecutionResponse *persistence.UpdateWorkflowExecutionResponse, err error) *ExecutionManager_UpdateWorkflowExecution_Call { + _c.Call.Return(updateWorkflowExecutionResponse, err) + return _c +} - return mock +func (_c *ExecutionManager_UpdateWorkflowExecution_Call) RunAndReturn(run func(ctx context.Context, request *persistence.UpdateWorkflowExecutionRequest) (*persistence.UpdateWorkflowExecutionResponse, error)) *ExecutionManager_UpdateWorkflowExecution_Call { + _c.Call.Return(run) + return _c } diff --git a/common/mocks/ShardManager.go b/common/mocks/ShardManager.go index 1611988c0c9..af09afe37b8 100644 --- a/common/mocks/ShardManager.go +++ b/common/mocks/ShardManager.go @@ -1,106 +1,299 @@ -// Copyright (c) 2017-2020 Uber Technologies Inc. - -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: - -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. - -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. - -// Code generated by mockery v2.2.1. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - context "context" + "context" mock "github.com/stretchr/testify/mock" - persistence "github.com/uber/cadence/common/persistence" + "github.com/uber/cadence/common/persistence" ) +// NewShardManager creates a new instance of ShardManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewShardManager(t interface { + mock.TestingT + Cleanup(func()) +}) *ShardManager { + mock := &ShardManager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // ShardManager is an autogenerated mock type for the ShardManager type type ShardManager struct { mock.Mock } -// Close provides a mock function with given fields: -func (_m *ShardManager) Close() { - _m.Called() +type ShardManager_Expecter struct { + mock *mock.Mock +} + +func (_m *ShardManager) EXPECT() *ShardManager_Expecter { + return &ShardManager_Expecter{mock: &_m.Mock} +} + +// Close provides a mock function for the type ShardManager +func (_mock *ShardManager) Close() { + _mock.Called() + return +} + +// ShardManager_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type ShardManager_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *ShardManager_Expecter) Close() *ShardManager_Close_Call { + return &ShardManager_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *ShardManager_Close_Call) Run(run func()) *ShardManager_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ShardManager_Close_Call) Return() *ShardManager_Close_Call { + _c.Call.Return() + return _c +} + +func (_c *ShardManager_Close_Call) RunAndReturn(run func()) *ShardManager_Close_Call { + _c.Run(run) + return _c } -// CreateShard provides a mock function with given fields: ctx, request -func (_m *ShardManager) CreateShard(ctx context.Context, request *persistence.CreateShardRequest) error { - ret := _m.Called(ctx, request) +// CreateShard provides a mock function for the type ShardManager +func (_mock *ShardManager) CreateShard(ctx context.Context, request *persistence.CreateShardRequest) error { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for CreateShard") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.CreateShardRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.CreateShardRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } - return r0 } -// GetName provides a mock function with given fields: -func (_m *ShardManager) GetName() string { - ret := _m.Called() +// ShardManager_CreateShard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateShard' +type ShardManager_CreateShard_Call struct { + *mock.Call +} + +// CreateShard is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.CreateShardRequest +func (_e *ShardManager_Expecter) CreateShard(ctx interface{}, request interface{}) *ShardManager_CreateShard_Call { + return &ShardManager_CreateShard_Call{Call: _e.mock.On("CreateShard", ctx, request)} +} + +func (_c *ShardManager_CreateShard_Call) Run(run func(ctx context.Context, request *persistence.CreateShardRequest)) *ShardManager_CreateShard_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.CreateShardRequest + if args[1] != nil { + arg1 = args[1].(*persistence.CreateShardRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ShardManager_CreateShard_Call) Return(err error) *ShardManager_CreateShard_Call { + _c.Call.Return(err) + return _c +} + +func (_c *ShardManager_CreateShard_Call) RunAndReturn(run func(ctx context.Context, request *persistence.CreateShardRequest) error) *ShardManager_CreateShard_Call { + _c.Call.Return(run) + return _c +} + +// GetName provides a mock function for the type ShardManager +func (_mock *ShardManager) GetName() string { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for GetName") + } var r0 string - if rf, ok := ret.Get(0).(func() string); ok { - r0 = rf() + if returnFunc, ok := ret.Get(0).(func() string); ok { + r0 = returnFunc() } else { r0 = ret.Get(0).(string) } - return r0 } -// GetShard provides a mock function with given fields: ctx, request -func (_m *ShardManager) GetShard(ctx context.Context, request *persistence.GetShardRequest) (*persistence.GetShardResponse, error) { - ret := _m.Called(ctx, request) +// ShardManager_GetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetName' +type ShardManager_GetName_Call struct { + *mock.Call +} + +// GetName is a helper method to define mock.On call +func (_e *ShardManager_Expecter) GetName() *ShardManager_GetName_Call { + return &ShardManager_GetName_Call{Call: _e.mock.On("GetName")} +} + +func (_c *ShardManager_GetName_Call) Run(run func()) *ShardManager_GetName_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *ShardManager_GetName_Call) Return(s string) *ShardManager_GetName_Call { + _c.Call.Return(s) + return _c +} + +func (_c *ShardManager_GetName_Call) RunAndReturn(run func() string) *ShardManager_GetName_Call { + _c.Call.Return(run) + return _c +} + +// GetShard provides a mock function for the type ShardManager +func (_mock *ShardManager) GetShard(ctx context.Context, request *persistence.GetShardRequest) (*persistence.GetShardResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for GetShard") + } var r0 *persistence.GetShardResponse - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetShardRequest) *persistence.GetShardResponse); ok { - r0 = rf(ctx, request) + var r1 error + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetShardRequest) (*persistence.GetShardResponse, error)); ok { + return returnFunc(ctx, request) + } + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetShardRequest) *persistence.GetShardResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.GetShardResponse) } } - - var r1 error - if rf, ok := ret.Get(1).(func(context.Context, *persistence.GetShardRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.GetShardRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// UpdateShard provides a mock function with given fields: ctx, request -func (_m *ShardManager) UpdateShard(ctx context.Context, request *persistence.UpdateShardRequest) error { - ret := _m.Called(ctx, request) +// ShardManager_GetShard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetShard' +type ShardManager_GetShard_Call struct { + *mock.Call +} + +// GetShard is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.GetShardRequest +func (_e *ShardManager_Expecter) GetShard(ctx interface{}, request interface{}) *ShardManager_GetShard_Call { + return &ShardManager_GetShard_Call{Call: _e.mock.On("GetShard", ctx, request)} +} + +func (_c *ShardManager_GetShard_Call) Run(run func(ctx context.Context, request *persistence.GetShardRequest)) *ShardManager_GetShard_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.GetShardRequest + if args[1] != nil { + arg1 = args[1].(*persistence.GetShardRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ShardManager_GetShard_Call) Return(getShardResponse *persistence.GetShardResponse, err error) *ShardManager_GetShard_Call { + _c.Call.Return(getShardResponse, err) + return _c +} + +func (_c *ShardManager_GetShard_Call) RunAndReturn(run func(ctx context.Context, request *persistence.GetShardRequest) (*persistence.GetShardResponse, error)) *ShardManager_GetShard_Call { + _c.Call.Return(run) + return _c +} + +// UpdateShard provides a mock function for the type ShardManager +func (_mock *ShardManager) UpdateShard(ctx context.Context, request *persistence.UpdateShardRequest) error { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for UpdateShard") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.UpdateShardRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.UpdateShardRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } - return r0 } + +// ShardManager_UpdateShard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateShard' +type ShardManager_UpdateShard_Call struct { + *mock.Call +} + +// UpdateShard is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.UpdateShardRequest +func (_e *ShardManager_Expecter) UpdateShard(ctx interface{}, request interface{}) *ShardManager_UpdateShard_Call { + return &ShardManager_UpdateShard_Call{Call: _e.mock.On("UpdateShard", ctx, request)} +} + +func (_c *ShardManager_UpdateShard_Call) Run(run func(ctx context.Context, request *persistence.UpdateShardRequest)) *ShardManager_UpdateShard_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.UpdateShardRequest + if args[1] != nil { + arg1 = args[1].(*persistence.UpdateShardRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *ShardManager_UpdateShard_Call) Return(err error) *ShardManager_UpdateShard_Call { + _c.Call.Return(err) + return _c +} + +func (_c *ShardManager_UpdateShard_Call) RunAndReturn(run func(ctx context.Context, request *persistence.UpdateShardRequest) error) *ShardManager_UpdateShard_Call { + _c.Call.Return(run) + return _c +} diff --git a/common/mocks/TaskManager.go b/common/mocks/TaskManager.go index 0005436c4d5..a529f3839c5 100644 --- a/common/mocks/TaskManager.go +++ b/common/mocks/TaskManager.go @@ -1,333 +1,843 @@ -// The MIT License (MIT) - -// Copyright (c) 2017-2020 Uber Technologies Inc. - -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. - -// Code generated by mockery v2.32.0. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - context "context" + "context" mock "github.com/stretchr/testify/mock" - persistence "github.com/uber/cadence/common/persistence" + "github.com/uber/cadence/common/persistence" ) +// NewTaskManager creates a new instance of TaskManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewTaskManager(t interface { + mock.TestingT + Cleanup(func()) +}) *TaskManager { + mock := &TaskManager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // TaskManager is an autogenerated mock type for the TaskManager type type TaskManager struct { mock.Mock } -// Close provides a mock function with given fields: -func (_m *TaskManager) Close() { - _m.Called() +type TaskManager_Expecter struct { + mock *mock.Mock +} + +func (_m *TaskManager) EXPECT() *TaskManager_Expecter { + return &TaskManager_Expecter{mock: &_m.Mock} +} + +// Close provides a mock function for the type TaskManager +func (_mock *TaskManager) Close() { + _mock.Called() + return +} + +// TaskManager_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type TaskManager_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *TaskManager_Expecter) Close() *TaskManager_Close_Call { + return &TaskManager_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *TaskManager_Close_Call) Run(run func()) *TaskManager_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskManager_Close_Call) Return() *TaskManager_Close_Call { + _c.Call.Return() + return _c +} + +func (_c *TaskManager_Close_Call) RunAndReturn(run func()) *TaskManager_Close_Call { + _c.Run(run) + return _c } -// CompleteTask provides a mock function with given fields: ctx, request -func (_m *TaskManager) CompleteTask(ctx context.Context, request *persistence.CompleteTaskRequest) error { - ret := _m.Called(ctx, request) +// CompleteTask provides a mock function for the type TaskManager +func (_mock *TaskManager) CompleteTask(ctx context.Context, request *persistence.CompleteTaskRequest) error { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for CompleteTask") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.CompleteTaskRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.CompleteTaskRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } - return r0 } -// CompleteTasksLessThan provides a mock function with given fields: ctx, request -func (_m *TaskManager) CompleteTasksLessThan(ctx context.Context, request *persistence.CompleteTasksLessThanRequest) (*persistence.CompleteTasksLessThanResponse, error) { - ret := _m.Called(ctx, request) +// TaskManager_CompleteTask_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteTask' +type TaskManager_CompleteTask_Call struct { + *mock.Call +} + +// CompleteTask is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.CompleteTaskRequest +func (_e *TaskManager_Expecter) CompleteTask(ctx interface{}, request interface{}) *TaskManager_CompleteTask_Call { + return &TaskManager_CompleteTask_Call{Call: _e.mock.On("CompleteTask", ctx, request)} +} + +func (_c *TaskManager_CompleteTask_Call) Run(run func(ctx context.Context, request *persistence.CompleteTaskRequest)) *TaskManager_CompleteTask_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.CompleteTaskRequest + if args[1] != nil { + arg1 = args[1].(*persistence.CompleteTaskRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *TaskManager_CompleteTask_Call) Return(err error) *TaskManager_CompleteTask_Call { + _c.Call.Return(err) + return _c +} + +func (_c *TaskManager_CompleteTask_Call) RunAndReturn(run func(ctx context.Context, request *persistence.CompleteTaskRequest) error) *TaskManager_CompleteTask_Call { + _c.Call.Return(run) + return _c +} + +// CompleteTasksLessThan provides a mock function for the type TaskManager +func (_mock *TaskManager) CompleteTasksLessThan(ctx context.Context, request *persistence.CompleteTasksLessThanRequest) (*persistence.CompleteTasksLessThanResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for CompleteTasksLessThan") + } var r0 *persistence.CompleteTasksLessThanResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.CompleteTasksLessThanRequest) (*persistence.CompleteTasksLessThanResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.CompleteTasksLessThanRequest) (*persistence.CompleteTasksLessThanResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.CompleteTasksLessThanRequest) *persistence.CompleteTasksLessThanResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.CompleteTasksLessThanRequest) *persistence.CompleteTasksLessThanResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.CompleteTasksLessThanResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.CompleteTasksLessThanRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.CompleteTasksLessThanRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// CreateTasks provides a mock function with given fields: ctx, request -func (_m *TaskManager) CreateTasks(ctx context.Context, request *persistence.CreateTasksRequest) (*persistence.CreateTasksResponse, error) { - ret := _m.Called(ctx, request) +// TaskManager_CompleteTasksLessThan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CompleteTasksLessThan' +type TaskManager_CompleteTasksLessThan_Call struct { + *mock.Call +} + +// CompleteTasksLessThan is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.CompleteTasksLessThanRequest +func (_e *TaskManager_Expecter) CompleteTasksLessThan(ctx interface{}, request interface{}) *TaskManager_CompleteTasksLessThan_Call { + return &TaskManager_CompleteTasksLessThan_Call{Call: _e.mock.On("CompleteTasksLessThan", ctx, request)} +} + +func (_c *TaskManager_CompleteTasksLessThan_Call) Run(run func(ctx context.Context, request *persistence.CompleteTasksLessThanRequest)) *TaskManager_CompleteTasksLessThan_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.CompleteTasksLessThanRequest + if args[1] != nil { + arg1 = args[1].(*persistence.CompleteTasksLessThanRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *TaskManager_CompleteTasksLessThan_Call) Return(completeTasksLessThanResponse *persistence.CompleteTasksLessThanResponse, err error) *TaskManager_CompleteTasksLessThan_Call { + _c.Call.Return(completeTasksLessThanResponse, err) + return _c +} + +func (_c *TaskManager_CompleteTasksLessThan_Call) RunAndReturn(run func(ctx context.Context, request *persistence.CompleteTasksLessThanRequest) (*persistence.CompleteTasksLessThanResponse, error)) *TaskManager_CompleteTasksLessThan_Call { + _c.Call.Return(run) + return _c +} + +// CreateTasks provides a mock function for the type TaskManager +func (_mock *TaskManager) CreateTasks(ctx context.Context, request *persistence.CreateTasksRequest) (*persistence.CreateTasksResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for CreateTasks") + } var r0 *persistence.CreateTasksResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.CreateTasksRequest) (*persistence.CreateTasksResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.CreateTasksRequest) (*persistence.CreateTasksResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.CreateTasksRequest) *persistence.CreateTasksResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.CreateTasksRequest) *persistence.CreateTasksResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.CreateTasksResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.CreateTasksRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.CreateTasksRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteTaskList provides a mock function with given fields: ctx, request -func (_m *TaskManager) DeleteTaskList(ctx context.Context, request *persistence.DeleteTaskListRequest) error { - ret := _m.Called(ctx, request) +// TaskManager_CreateTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateTasks' +type TaskManager_CreateTasks_Call struct { + *mock.Call +} + +// CreateTasks is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.CreateTasksRequest +func (_e *TaskManager_Expecter) CreateTasks(ctx interface{}, request interface{}) *TaskManager_CreateTasks_Call { + return &TaskManager_CreateTasks_Call{Call: _e.mock.On("CreateTasks", ctx, request)} +} + +func (_c *TaskManager_CreateTasks_Call) Run(run func(ctx context.Context, request *persistence.CreateTasksRequest)) *TaskManager_CreateTasks_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.CreateTasksRequest + if args[1] != nil { + arg1 = args[1].(*persistence.CreateTasksRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *TaskManager_CreateTasks_Call) Return(createTasksResponse *persistence.CreateTasksResponse, err error) *TaskManager_CreateTasks_Call { + _c.Call.Return(createTasksResponse, err) + return _c +} + +func (_c *TaskManager_CreateTasks_Call) RunAndReturn(run func(ctx context.Context, request *persistence.CreateTasksRequest) (*persistence.CreateTasksResponse, error)) *TaskManager_CreateTasks_Call { + _c.Call.Return(run) + return _c +} + +// DeleteTaskList provides a mock function for the type TaskManager +func (_mock *TaskManager) DeleteTaskList(ctx context.Context, request *persistence.DeleteTaskListRequest) error { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for DeleteTaskList") + } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.DeleteTaskListRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.DeleteTaskListRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } - return r0 } -// GetName provides a mock function with given fields: -func (_m *TaskManager) GetName() string { - ret := _m.Called() +// TaskManager_DeleteTaskList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteTaskList' +type TaskManager_DeleteTaskList_Call struct { + *mock.Call +} + +// DeleteTaskList is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.DeleteTaskListRequest +func (_e *TaskManager_Expecter) DeleteTaskList(ctx interface{}, request interface{}) *TaskManager_DeleteTaskList_Call { + return &TaskManager_DeleteTaskList_Call{Call: _e.mock.On("DeleteTaskList", ctx, request)} +} + +func (_c *TaskManager_DeleteTaskList_Call) Run(run func(ctx context.Context, request *persistence.DeleteTaskListRequest)) *TaskManager_DeleteTaskList_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.DeleteTaskListRequest + if args[1] != nil { + arg1 = args[1].(*persistence.DeleteTaskListRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *TaskManager_DeleteTaskList_Call) Return(err error) *TaskManager_DeleteTaskList_Call { + _c.Call.Return(err) + return _c +} + +func (_c *TaskManager_DeleteTaskList_Call) RunAndReturn(run func(ctx context.Context, request *persistence.DeleteTaskListRequest) error) *TaskManager_DeleteTaskList_Call { + _c.Call.Return(run) + return _c +} + +// GetName provides a mock function for the type TaskManager +func (_mock *TaskManager) GetName() string { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for GetName") + } var r0 string - if rf, ok := ret.Get(0).(func() string); ok { - r0 = rf() + if returnFunc, ok := ret.Get(0).(func() string); ok { + r0 = returnFunc() } else { r0 = ret.Get(0).(string) } - return r0 } -// GetOrphanTasks provides a mock function with given fields: ctx, request -func (_m *TaskManager) GetOrphanTasks(ctx context.Context, request *persistence.GetOrphanTasksRequest) (*persistence.GetOrphanTasksResponse, error) { - ret := _m.Called(ctx, request) +// TaskManager_GetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetName' +type TaskManager_GetName_Call struct { + *mock.Call +} + +// GetName is a helper method to define mock.On call +func (_e *TaskManager_Expecter) GetName() *TaskManager_GetName_Call { + return &TaskManager_GetName_Call{Call: _e.mock.On("GetName")} +} + +func (_c *TaskManager_GetName_Call) Run(run func()) *TaskManager_GetName_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *TaskManager_GetName_Call) Return(s string) *TaskManager_GetName_Call { + _c.Call.Return(s) + return _c +} + +func (_c *TaskManager_GetName_Call) RunAndReturn(run func() string) *TaskManager_GetName_Call { + _c.Call.Return(run) + return _c +} + +// GetOrphanTasks provides a mock function for the type TaskManager +func (_mock *TaskManager) GetOrphanTasks(ctx context.Context, request *persistence.GetOrphanTasksRequest) (*persistence.GetOrphanTasksResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for GetOrphanTasks") + } var r0 *persistence.GetOrphanTasksResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetOrphanTasksRequest) (*persistence.GetOrphanTasksResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetOrphanTasksRequest) (*persistence.GetOrphanTasksResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetOrphanTasksRequest) *persistence.GetOrphanTasksResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetOrphanTasksRequest) *persistence.GetOrphanTasksResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.GetOrphanTasksResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.GetOrphanTasksRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.GetOrphanTasksRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetTaskList provides a mock function with given fields: ctx, request -func (_m *TaskManager) GetTaskList(ctx context.Context, request *persistence.GetTaskListRequest) (*persistence.GetTaskListResponse, error) { - ret := _m.Called(ctx, request) +// TaskManager_GetOrphanTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrphanTasks' +type TaskManager_GetOrphanTasks_Call struct { + *mock.Call +} + +// GetOrphanTasks is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.GetOrphanTasksRequest +func (_e *TaskManager_Expecter) GetOrphanTasks(ctx interface{}, request interface{}) *TaskManager_GetOrphanTasks_Call { + return &TaskManager_GetOrphanTasks_Call{Call: _e.mock.On("GetOrphanTasks", ctx, request)} +} + +func (_c *TaskManager_GetOrphanTasks_Call) Run(run func(ctx context.Context, request *persistence.GetOrphanTasksRequest)) *TaskManager_GetOrphanTasks_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.GetOrphanTasksRequest + if args[1] != nil { + arg1 = args[1].(*persistence.GetOrphanTasksRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *TaskManager_GetOrphanTasks_Call) Return(getOrphanTasksResponse *persistence.GetOrphanTasksResponse, err error) *TaskManager_GetOrphanTasks_Call { + _c.Call.Return(getOrphanTasksResponse, err) + return _c +} + +func (_c *TaskManager_GetOrphanTasks_Call) RunAndReturn(run func(ctx context.Context, request *persistence.GetOrphanTasksRequest) (*persistence.GetOrphanTasksResponse, error)) *TaskManager_GetOrphanTasks_Call { + _c.Call.Return(run) + return _c +} + +// GetTaskList provides a mock function for the type TaskManager +func (_mock *TaskManager) GetTaskList(ctx context.Context, request *persistence.GetTaskListRequest) (*persistence.GetTaskListResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for GetTaskList") + } var r0 *persistence.GetTaskListResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetTaskListRequest) (*persistence.GetTaskListResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetTaskListRequest) (*persistence.GetTaskListResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetTaskListRequest) *persistence.GetTaskListResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetTaskListRequest) *persistence.GetTaskListResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.GetTaskListResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.GetTaskListRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.GetTaskListRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetTaskListSize provides a mock function with given fields: ctx, request -func (_m *TaskManager) GetTaskListSize(ctx context.Context, request *persistence.GetTaskListSizeRequest) (*persistence.GetTaskListSizeResponse, error) { - ret := _m.Called(ctx, request) +// TaskManager_GetTaskList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTaskList' +type TaskManager_GetTaskList_Call struct { + *mock.Call +} + +// GetTaskList is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.GetTaskListRequest +func (_e *TaskManager_Expecter) GetTaskList(ctx interface{}, request interface{}) *TaskManager_GetTaskList_Call { + return &TaskManager_GetTaskList_Call{Call: _e.mock.On("GetTaskList", ctx, request)} +} + +func (_c *TaskManager_GetTaskList_Call) Run(run func(ctx context.Context, request *persistence.GetTaskListRequest)) *TaskManager_GetTaskList_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.GetTaskListRequest + if args[1] != nil { + arg1 = args[1].(*persistence.GetTaskListRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *TaskManager_GetTaskList_Call) Return(getTaskListResponse *persistence.GetTaskListResponse, err error) *TaskManager_GetTaskList_Call { + _c.Call.Return(getTaskListResponse, err) + return _c +} + +func (_c *TaskManager_GetTaskList_Call) RunAndReturn(run func(ctx context.Context, request *persistence.GetTaskListRequest) (*persistence.GetTaskListResponse, error)) *TaskManager_GetTaskList_Call { + _c.Call.Return(run) + return _c +} + +// GetTaskListSize provides a mock function for the type TaskManager +func (_mock *TaskManager) GetTaskListSize(ctx context.Context, request *persistence.GetTaskListSizeRequest) (*persistence.GetTaskListSizeResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for GetTaskListSize") + } var r0 *persistence.GetTaskListSizeResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetTaskListSizeRequest) (*persistence.GetTaskListSizeResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetTaskListSizeRequest) (*persistence.GetTaskListSizeResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetTaskListSizeRequest) *persistence.GetTaskListSizeResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetTaskListSizeRequest) *persistence.GetTaskListSizeResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.GetTaskListSizeResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.GetTaskListSizeRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.GetTaskListSizeRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetTasks provides a mock function with given fields: ctx, request -func (_m *TaskManager) GetTasks(ctx context.Context, request *persistence.GetTasksRequest) (*persistence.GetTasksResponse, error) { - ret := _m.Called(ctx, request) +// TaskManager_GetTaskListSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTaskListSize' +type TaskManager_GetTaskListSize_Call struct { + *mock.Call +} + +// GetTaskListSize is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.GetTaskListSizeRequest +func (_e *TaskManager_Expecter) GetTaskListSize(ctx interface{}, request interface{}) *TaskManager_GetTaskListSize_Call { + return &TaskManager_GetTaskListSize_Call{Call: _e.mock.On("GetTaskListSize", ctx, request)} +} + +func (_c *TaskManager_GetTaskListSize_Call) Run(run func(ctx context.Context, request *persistence.GetTaskListSizeRequest)) *TaskManager_GetTaskListSize_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.GetTaskListSizeRequest + if args[1] != nil { + arg1 = args[1].(*persistence.GetTaskListSizeRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *TaskManager_GetTaskListSize_Call) Return(getTaskListSizeResponse *persistence.GetTaskListSizeResponse, err error) *TaskManager_GetTaskListSize_Call { + _c.Call.Return(getTaskListSizeResponse, err) + return _c +} + +func (_c *TaskManager_GetTaskListSize_Call) RunAndReturn(run func(ctx context.Context, request *persistence.GetTaskListSizeRequest) (*persistence.GetTaskListSizeResponse, error)) *TaskManager_GetTaskListSize_Call { + _c.Call.Return(run) + return _c +} + +// GetTasks provides a mock function for the type TaskManager +func (_mock *TaskManager) GetTasks(ctx context.Context, request *persistence.GetTasksRequest) (*persistence.GetTasksResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for GetTasks") + } var r0 *persistence.GetTasksResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetTasksRequest) (*persistence.GetTasksResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetTasksRequest) (*persistence.GetTasksResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetTasksRequest) *persistence.GetTasksResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetTasksRequest) *persistence.GetTasksResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.GetTasksResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.GetTasksRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.GetTasksRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// LeaseTaskList provides a mock function with given fields: ctx, request -func (_m *TaskManager) LeaseTaskList(ctx context.Context, request *persistence.LeaseTaskListRequest) (*persistence.LeaseTaskListResponse, error) { - ret := _m.Called(ctx, request) +// TaskManager_GetTasks_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTasks' +type TaskManager_GetTasks_Call struct { + *mock.Call +} + +// GetTasks is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.GetTasksRequest +func (_e *TaskManager_Expecter) GetTasks(ctx interface{}, request interface{}) *TaskManager_GetTasks_Call { + return &TaskManager_GetTasks_Call{Call: _e.mock.On("GetTasks", ctx, request)} +} + +func (_c *TaskManager_GetTasks_Call) Run(run func(ctx context.Context, request *persistence.GetTasksRequest)) *TaskManager_GetTasks_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.GetTasksRequest + if args[1] != nil { + arg1 = args[1].(*persistence.GetTasksRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *TaskManager_GetTasks_Call) Return(getTasksResponse *persistence.GetTasksResponse, err error) *TaskManager_GetTasks_Call { + _c.Call.Return(getTasksResponse, err) + return _c +} + +func (_c *TaskManager_GetTasks_Call) RunAndReturn(run func(ctx context.Context, request *persistence.GetTasksRequest) (*persistence.GetTasksResponse, error)) *TaskManager_GetTasks_Call { + _c.Call.Return(run) + return _c +} + +// LeaseTaskList provides a mock function for the type TaskManager +func (_mock *TaskManager) LeaseTaskList(ctx context.Context, request *persistence.LeaseTaskListRequest) (*persistence.LeaseTaskListResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for LeaseTaskList") + } var r0 *persistence.LeaseTaskListResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.LeaseTaskListRequest) (*persistence.LeaseTaskListResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.LeaseTaskListRequest) (*persistence.LeaseTaskListResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.LeaseTaskListRequest) *persistence.LeaseTaskListResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.LeaseTaskListRequest) *persistence.LeaseTaskListResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.LeaseTaskListResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.LeaseTaskListRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.LeaseTaskListRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListTaskList provides a mock function with given fields: ctx, request -func (_m *TaskManager) ListTaskList(ctx context.Context, request *persistence.ListTaskListRequest) (*persistence.ListTaskListResponse, error) { - ret := _m.Called(ctx, request) +// TaskManager_LeaseTaskList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LeaseTaskList' +type TaskManager_LeaseTaskList_Call struct { + *mock.Call +} + +// LeaseTaskList is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.LeaseTaskListRequest +func (_e *TaskManager_Expecter) LeaseTaskList(ctx interface{}, request interface{}) *TaskManager_LeaseTaskList_Call { + return &TaskManager_LeaseTaskList_Call{Call: _e.mock.On("LeaseTaskList", ctx, request)} +} + +func (_c *TaskManager_LeaseTaskList_Call) Run(run func(ctx context.Context, request *persistence.LeaseTaskListRequest)) *TaskManager_LeaseTaskList_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.LeaseTaskListRequest + if args[1] != nil { + arg1 = args[1].(*persistence.LeaseTaskListRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *TaskManager_LeaseTaskList_Call) Return(leaseTaskListResponse *persistence.LeaseTaskListResponse, err error) *TaskManager_LeaseTaskList_Call { + _c.Call.Return(leaseTaskListResponse, err) + return _c +} + +func (_c *TaskManager_LeaseTaskList_Call) RunAndReturn(run func(ctx context.Context, request *persistence.LeaseTaskListRequest) (*persistence.LeaseTaskListResponse, error)) *TaskManager_LeaseTaskList_Call { + _c.Call.Return(run) + return _c +} + +// ListTaskList provides a mock function for the type TaskManager +func (_mock *TaskManager) ListTaskList(ctx context.Context, request *persistence.ListTaskListRequest) (*persistence.ListTaskListResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for ListTaskList") + } var r0 *persistence.ListTaskListResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListTaskListRequest) (*persistence.ListTaskListResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListTaskListRequest) (*persistence.ListTaskListResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListTaskListRequest) *persistence.ListTaskListResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListTaskListRequest) *persistence.ListTaskListResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.ListTaskListResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.ListTaskListRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.ListTaskListRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// UpdateTaskList provides a mock function with given fields: ctx, request -func (_m *TaskManager) UpdateTaskList(ctx context.Context, request *persistence.UpdateTaskListRequest) (*persistence.UpdateTaskListResponse, error) { - ret := _m.Called(ctx, request) +// TaskManager_ListTaskList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListTaskList' +type TaskManager_ListTaskList_Call struct { + *mock.Call +} + +// ListTaskList is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.ListTaskListRequest +func (_e *TaskManager_Expecter) ListTaskList(ctx interface{}, request interface{}) *TaskManager_ListTaskList_Call { + return &TaskManager_ListTaskList_Call{Call: _e.mock.On("ListTaskList", ctx, request)} +} + +func (_c *TaskManager_ListTaskList_Call) Run(run func(ctx context.Context, request *persistence.ListTaskListRequest)) *TaskManager_ListTaskList_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.ListTaskListRequest + if args[1] != nil { + arg1 = args[1].(*persistence.ListTaskListRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *TaskManager_ListTaskList_Call) Return(listTaskListResponse *persistence.ListTaskListResponse, err error) *TaskManager_ListTaskList_Call { + _c.Call.Return(listTaskListResponse, err) + return _c +} + +func (_c *TaskManager_ListTaskList_Call) RunAndReturn(run func(ctx context.Context, request *persistence.ListTaskListRequest) (*persistence.ListTaskListResponse, error)) *TaskManager_ListTaskList_Call { + _c.Call.Return(run) + return _c +} + +// UpdateTaskList provides a mock function for the type TaskManager +func (_mock *TaskManager) UpdateTaskList(ctx context.Context, request *persistence.UpdateTaskListRequest) (*persistence.UpdateTaskListResponse, error) { + ret := _mock.Called(ctx, request) + + if len(ret) == 0 { + panic("no return value specified for UpdateTaskList") + } var r0 *persistence.UpdateTaskListResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.UpdateTaskListRequest) (*persistence.UpdateTaskListResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.UpdateTaskListRequest) (*persistence.UpdateTaskListResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.UpdateTaskListRequest) *persistence.UpdateTaskListResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.UpdateTaskListRequest) *persistence.UpdateTaskListResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.UpdateTaskListResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.UpdateTaskListRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.UpdateTaskListRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// NewTaskManager creates a new instance of TaskManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewTaskManager(t interface { - mock.TestingT - Cleanup(func()) -}) *TaskManager { - mock := &TaskManager{} - mock.Mock.Test(t) +// TaskManager_UpdateTaskList_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTaskList' +type TaskManager_UpdateTaskList_Call struct { + *mock.Call +} - t.Cleanup(func() { mock.AssertExpectations(t) }) +// UpdateTaskList is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.UpdateTaskListRequest +func (_e *TaskManager_Expecter) UpdateTaskList(ctx interface{}, request interface{}) *TaskManager_UpdateTaskList_Call { + return &TaskManager_UpdateTaskList_Call{Call: _e.mock.On("UpdateTaskList", ctx, request)} +} - return mock +func (_c *TaskManager_UpdateTaskList_Call) Run(run func(ctx context.Context, request *persistence.UpdateTaskListRequest)) *TaskManager_UpdateTaskList_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.UpdateTaskListRequest + if args[1] != nil { + arg1 = args[1].(*persistence.UpdateTaskListRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *TaskManager_UpdateTaskList_Call) Return(updateTaskListResponse *persistence.UpdateTaskListResponse, err error) *TaskManager_UpdateTaskList_Call { + _c.Call.Return(updateTaskListResponse, err) + return _c +} + +func (_c *TaskManager_UpdateTaskList_Call) RunAndReturn(run func(ctx context.Context, request *persistence.UpdateTaskListRequest) (*persistence.UpdateTaskListResponse, error)) *TaskManager_UpdateTaskList_Call { + _c.Call.Return(run) + return _c } diff --git a/common/mocks/VisibilityManager.go b/common/mocks/VisibilityManager.go index e45c4f4aad0..a14147f54a1 100644 --- a/common/mocks/VisibilityManager.go +++ b/common/mocks/VisibilityManager.go @@ -1,50 +1,80 @@ -// The MIT License (MIT) - -// Copyright (c) 2017-2020 Uber Technologies Inc. - -// Permission is hereby granted, free of charge, to any person obtaining a copy -// of this software and associated documentation files (the "Software"), to deal -// in the Software without restriction, including without limitation the rights -// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -// copies of the Software, and to permit persons to whom the Software is -// furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included in all -// copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -// SOFTWARE. - -// Code generated by mockery v2.43.1. DO NOT EDIT. +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: testify package mocks import ( - context "context" + "context" mock "github.com/stretchr/testify/mock" - persistence "github.com/uber/cadence/common/persistence" + "github.com/uber/cadence/common/persistence" ) +// NewVisibilityManager creates a new instance of VisibilityManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewVisibilityManager(t interface { + mock.TestingT + Cleanup(func()) +}) *VisibilityManager { + mock := &VisibilityManager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + // VisibilityManager is an autogenerated mock type for the VisibilityManager type type VisibilityManager struct { mock.Mock } -// Close provides a mock function with given fields: -func (_m *VisibilityManager) Close() { - _m.Called() +type VisibilityManager_Expecter struct { + mock *mock.Mock } -// CountWorkflowExecutions provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) CountWorkflowExecutions(ctx context.Context, request *persistence.CountWorkflowExecutionsRequest) (*persistence.CountWorkflowExecutionsResponse, error) { - ret := _m.Called(ctx, request) +func (_m *VisibilityManager) EXPECT() *VisibilityManager_Expecter { + return &VisibilityManager_Expecter{mock: &_m.Mock} +} + +// Close provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) Close() { + _mock.Called() + return +} + +// VisibilityManager_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close' +type VisibilityManager_Close_Call struct { + *mock.Call +} + +// Close is a helper method to define mock.On call +func (_e *VisibilityManager_Expecter) Close() *VisibilityManager_Close_Call { + return &VisibilityManager_Close_Call{Call: _e.mock.On("Close")} +} + +func (_c *VisibilityManager_Close_Call) Run(run func()) *VisibilityManager_Close_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *VisibilityManager_Close_Call) Return() *VisibilityManager_Close_Call { + _c.Call.Return() + return _c +} + +func (_c *VisibilityManager_Close_Call) RunAndReturn(run func()) *VisibilityManager_Close_Call { + _c.Run(run) + return _c +} + +// CountWorkflowExecutions provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) CountWorkflowExecutions(ctx context.Context, request *persistence.CountWorkflowExecutionsRequest) (*persistence.CountWorkflowExecutionsResponse, error) { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for CountWorkflowExecutions") @@ -52,65 +82,181 @@ func (_m *VisibilityManager) CountWorkflowExecutions(ctx context.Context, reques var r0 *persistence.CountWorkflowExecutionsResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.CountWorkflowExecutionsRequest) (*persistence.CountWorkflowExecutionsResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.CountWorkflowExecutionsRequest) (*persistence.CountWorkflowExecutionsResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.CountWorkflowExecutionsRequest) *persistence.CountWorkflowExecutionsResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.CountWorkflowExecutionsRequest) *persistence.CountWorkflowExecutionsResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.CountWorkflowExecutionsResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.CountWorkflowExecutionsRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.CountWorkflowExecutionsRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// DeleteUninitializedWorkflowExecution provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) DeleteUninitializedWorkflowExecution(ctx context.Context, request *persistence.VisibilityDeleteWorkflowExecutionRequest) error { - ret := _m.Called(ctx, request) +// VisibilityManager_CountWorkflowExecutions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CountWorkflowExecutions' +type VisibilityManager_CountWorkflowExecutions_Call struct { + *mock.Call +} + +// CountWorkflowExecutions is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.CountWorkflowExecutionsRequest +func (_e *VisibilityManager_Expecter) CountWorkflowExecutions(ctx interface{}, request interface{}) *VisibilityManager_CountWorkflowExecutions_Call { + return &VisibilityManager_CountWorkflowExecutions_Call{Call: _e.mock.On("CountWorkflowExecutions", ctx, request)} +} + +func (_c *VisibilityManager_CountWorkflowExecutions_Call) Run(run func(ctx context.Context, request *persistence.CountWorkflowExecutionsRequest)) *VisibilityManager_CountWorkflowExecutions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.CountWorkflowExecutionsRequest + if args[1] != nil { + arg1 = args[1].(*persistence.CountWorkflowExecutionsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_CountWorkflowExecutions_Call) Return(countWorkflowExecutionsResponse *persistence.CountWorkflowExecutionsResponse, err error) *VisibilityManager_CountWorkflowExecutions_Call { + _c.Call.Return(countWorkflowExecutionsResponse, err) + return _c +} + +func (_c *VisibilityManager_CountWorkflowExecutions_Call) RunAndReturn(run func(ctx context.Context, request *persistence.CountWorkflowExecutionsRequest) (*persistence.CountWorkflowExecutionsResponse, error)) *VisibilityManager_CountWorkflowExecutions_Call { + _c.Call.Return(run) + return _c +} + +// DeleteUninitializedWorkflowExecution provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) DeleteUninitializedWorkflowExecution(ctx context.Context, request *persistence.VisibilityDeleteWorkflowExecutionRequest) error { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for DeleteUninitializedWorkflowExecution") } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.VisibilityDeleteWorkflowExecutionRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.VisibilityDeleteWorkflowExecutionRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } - return r0 } -// DeleteWorkflowExecution provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) DeleteWorkflowExecution(ctx context.Context, request *persistence.VisibilityDeleteWorkflowExecutionRequest) error { - ret := _m.Called(ctx, request) +// VisibilityManager_DeleteUninitializedWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUninitializedWorkflowExecution' +type VisibilityManager_DeleteUninitializedWorkflowExecution_Call struct { + *mock.Call +} + +// DeleteUninitializedWorkflowExecution is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.VisibilityDeleteWorkflowExecutionRequest +func (_e *VisibilityManager_Expecter) DeleteUninitializedWorkflowExecution(ctx interface{}, request interface{}) *VisibilityManager_DeleteUninitializedWorkflowExecution_Call { + return &VisibilityManager_DeleteUninitializedWorkflowExecution_Call{Call: _e.mock.On("DeleteUninitializedWorkflowExecution", ctx, request)} +} + +func (_c *VisibilityManager_DeleteUninitializedWorkflowExecution_Call) Run(run func(ctx context.Context, request *persistence.VisibilityDeleteWorkflowExecutionRequest)) *VisibilityManager_DeleteUninitializedWorkflowExecution_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.VisibilityDeleteWorkflowExecutionRequest + if args[1] != nil { + arg1 = args[1].(*persistence.VisibilityDeleteWorkflowExecutionRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_DeleteUninitializedWorkflowExecution_Call) Return(err error) *VisibilityManager_DeleteUninitializedWorkflowExecution_Call { + _c.Call.Return(err) + return _c +} + +func (_c *VisibilityManager_DeleteUninitializedWorkflowExecution_Call) RunAndReturn(run func(ctx context.Context, request *persistence.VisibilityDeleteWorkflowExecutionRequest) error) *VisibilityManager_DeleteUninitializedWorkflowExecution_Call { + _c.Call.Return(run) + return _c +} + +// DeleteWorkflowExecution provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) DeleteWorkflowExecution(ctx context.Context, request *persistence.VisibilityDeleteWorkflowExecutionRequest) error { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for DeleteWorkflowExecution") } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.VisibilityDeleteWorkflowExecutionRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.VisibilityDeleteWorkflowExecutionRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } - return r0 } -// GetClosedWorkflowExecution provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) GetClosedWorkflowExecution(ctx context.Context, request *persistence.GetClosedWorkflowExecutionRequest) (*persistence.GetClosedWorkflowExecutionResponse, error) { - ret := _m.Called(ctx, request) +// VisibilityManager_DeleteWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteWorkflowExecution' +type VisibilityManager_DeleteWorkflowExecution_Call struct { + *mock.Call +} + +// DeleteWorkflowExecution is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.VisibilityDeleteWorkflowExecutionRequest +func (_e *VisibilityManager_Expecter) DeleteWorkflowExecution(ctx interface{}, request interface{}) *VisibilityManager_DeleteWorkflowExecution_Call { + return &VisibilityManager_DeleteWorkflowExecution_Call{Call: _e.mock.On("DeleteWorkflowExecution", ctx, request)} +} + +func (_c *VisibilityManager_DeleteWorkflowExecution_Call) Run(run func(ctx context.Context, request *persistence.VisibilityDeleteWorkflowExecutionRequest)) *VisibilityManager_DeleteWorkflowExecution_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.VisibilityDeleteWorkflowExecutionRequest + if args[1] != nil { + arg1 = args[1].(*persistence.VisibilityDeleteWorkflowExecutionRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_DeleteWorkflowExecution_Call) Return(err error) *VisibilityManager_DeleteWorkflowExecution_Call { + _c.Call.Return(err) + return _c +} + +func (_c *VisibilityManager_DeleteWorkflowExecution_Call) RunAndReturn(run func(ctx context.Context, request *persistence.VisibilityDeleteWorkflowExecutionRequest) error) *VisibilityManager_DeleteWorkflowExecution_Call { + _c.Call.Return(run) + return _c +} + +// GetClosedWorkflowExecution provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) GetClosedWorkflowExecution(ctx context.Context, request *persistence.GetClosedWorkflowExecutionRequest) (*persistence.GetClosedWorkflowExecutionResponse, error) { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for GetClosedWorkflowExecution") @@ -118,47 +264,111 @@ func (_m *VisibilityManager) GetClosedWorkflowExecution(ctx context.Context, req var r0 *persistence.GetClosedWorkflowExecutionResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetClosedWorkflowExecutionRequest) (*persistence.GetClosedWorkflowExecutionResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetClosedWorkflowExecutionRequest) (*persistence.GetClosedWorkflowExecutionResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.GetClosedWorkflowExecutionRequest) *persistence.GetClosedWorkflowExecutionResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.GetClosedWorkflowExecutionRequest) *persistence.GetClosedWorkflowExecutionResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.GetClosedWorkflowExecutionResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.GetClosedWorkflowExecutionRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.GetClosedWorkflowExecutionRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// GetName provides a mock function with given fields: -func (_m *VisibilityManager) GetName() string { - ret := _m.Called() +// VisibilityManager_GetClosedWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetClosedWorkflowExecution' +type VisibilityManager_GetClosedWorkflowExecution_Call struct { + *mock.Call +} + +// GetClosedWorkflowExecution is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.GetClosedWorkflowExecutionRequest +func (_e *VisibilityManager_Expecter) GetClosedWorkflowExecution(ctx interface{}, request interface{}) *VisibilityManager_GetClosedWorkflowExecution_Call { + return &VisibilityManager_GetClosedWorkflowExecution_Call{Call: _e.mock.On("GetClosedWorkflowExecution", ctx, request)} +} + +func (_c *VisibilityManager_GetClosedWorkflowExecution_Call) Run(run func(ctx context.Context, request *persistence.GetClosedWorkflowExecutionRequest)) *VisibilityManager_GetClosedWorkflowExecution_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.GetClosedWorkflowExecutionRequest + if args[1] != nil { + arg1 = args[1].(*persistence.GetClosedWorkflowExecutionRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_GetClosedWorkflowExecution_Call) Return(getClosedWorkflowExecutionResponse *persistence.GetClosedWorkflowExecutionResponse, err error) *VisibilityManager_GetClosedWorkflowExecution_Call { + _c.Call.Return(getClosedWorkflowExecutionResponse, err) + return _c +} + +func (_c *VisibilityManager_GetClosedWorkflowExecution_Call) RunAndReturn(run func(ctx context.Context, request *persistence.GetClosedWorkflowExecutionRequest) (*persistence.GetClosedWorkflowExecutionResponse, error)) *VisibilityManager_GetClosedWorkflowExecution_Call { + _c.Call.Return(run) + return _c +} + +// GetName provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) GetName() string { + ret := _mock.Called() if len(ret) == 0 { panic("no return value specified for GetName") } var r0 string - if rf, ok := ret.Get(0).(func() string); ok { - r0 = rf() + if returnFunc, ok := ret.Get(0).(func() string); ok { + r0 = returnFunc() } else { r0 = ret.Get(0).(string) } - return r0 } -// ListClosedWorkflowExecutions provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) ListClosedWorkflowExecutions(ctx context.Context, request *persistence.ListWorkflowExecutionsRequest) (*persistence.ListWorkflowExecutionsResponse, error) { - ret := _m.Called(ctx, request) +// VisibilityManager_GetName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetName' +type VisibilityManager_GetName_Call struct { + *mock.Call +} + +// GetName is a helper method to define mock.On call +func (_e *VisibilityManager_Expecter) GetName() *VisibilityManager_GetName_Call { + return &VisibilityManager_GetName_Call{Call: _e.mock.On("GetName")} +} + +func (_c *VisibilityManager_GetName_Call) Run(run func()) *VisibilityManager_GetName_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *VisibilityManager_GetName_Call) Return(s string) *VisibilityManager_GetName_Call { + _c.Call.Return(s) + return _c +} + +func (_c *VisibilityManager_GetName_Call) RunAndReturn(run func() string) *VisibilityManager_GetName_Call { + _c.Call.Return(run) + return _c +} + +// ListClosedWorkflowExecutions provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) ListClosedWorkflowExecutions(ctx context.Context, request *persistence.ListWorkflowExecutionsRequest) (*persistence.ListWorkflowExecutionsResponse, error) { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for ListClosedWorkflowExecutions") @@ -166,29 +376,67 @@ func (_m *VisibilityManager) ListClosedWorkflowExecutions(ctx context.Context, r var r0 *persistence.ListWorkflowExecutionsResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsRequest) *persistence.ListWorkflowExecutionsResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsRequest) *persistence.ListWorkflowExecutionsResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.ListWorkflowExecutionsResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListClosedWorkflowExecutionsByStatus provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) ListClosedWorkflowExecutionsByStatus(ctx context.Context, request *persistence.ListClosedWorkflowExecutionsByStatusRequest) (*persistence.ListWorkflowExecutionsResponse, error) { - ret := _m.Called(ctx, request) +// VisibilityManager_ListClosedWorkflowExecutions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClosedWorkflowExecutions' +type VisibilityManager_ListClosedWorkflowExecutions_Call struct { + *mock.Call +} + +// ListClosedWorkflowExecutions is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.ListWorkflowExecutionsRequest +func (_e *VisibilityManager_Expecter) ListClosedWorkflowExecutions(ctx interface{}, request interface{}) *VisibilityManager_ListClosedWorkflowExecutions_Call { + return &VisibilityManager_ListClosedWorkflowExecutions_Call{Call: _e.mock.On("ListClosedWorkflowExecutions", ctx, request)} +} + +func (_c *VisibilityManager_ListClosedWorkflowExecutions_Call) Run(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsRequest)) *VisibilityManager_ListClosedWorkflowExecutions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.ListWorkflowExecutionsRequest + if args[1] != nil { + arg1 = args[1].(*persistence.ListWorkflowExecutionsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_ListClosedWorkflowExecutions_Call) Return(listWorkflowExecutionsResponse *persistence.ListWorkflowExecutionsResponse, err error) *VisibilityManager_ListClosedWorkflowExecutions_Call { + _c.Call.Return(listWorkflowExecutionsResponse, err) + return _c +} + +func (_c *VisibilityManager_ListClosedWorkflowExecutions_Call) RunAndReturn(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsRequest) (*persistence.ListWorkflowExecutionsResponse, error)) *VisibilityManager_ListClosedWorkflowExecutions_Call { + _c.Call.Return(run) + return _c +} + +// ListClosedWorkflowExecutionsByStatus provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) ListClosedWorkflowExecutionsByStatus(ctx context.Context, request *persistence.ListClosedWorkflowExecutionsByStatusRequest) (*persistence.ListWorkflowExecutionsResponse, error) { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for ListClosedWorkflowExecutionsByStatus") @@ -196,29 +444,67 @@ func (_m *VisibilityManager) ListClosedWorkflowExecutionsByStatus(ctx context.Co var r0 *persistence.ListWorkflowExecutionsResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListClosedWorkflowExecutionsByStatusRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListClosedWorkflowExecutionsByStatusRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListClosedWorkflowExecutionsByStatusRequest) *persistence.ListWorkflowExecutionsResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListClosedWorkflowExecutionsByStatusRequest) *persistence.ListWorkflowExecutionsResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.ListWorkflowExecutionsResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.ListClosedWorkflowExecutionsByStatusRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.ListClosedWorkflowExecutionsByStatusRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListClosedWorkflowExecutionsByType provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) ListClosedWorkflowExecutionsByType(ctx context.Context, request *persistence.ListWorkflowExecutionsByTypeRequest) (*persistence.ListWorkflowExecutionsResponse, error) { - ret := _m.Called(ctx, request) +// VisibilityManager_ListClosedWorkflowExecutionsByStatus_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClosedWorkflowExecutionsByStatus' +type VisibilityManager_ListClosedWorkflowExecutionsByStatus_Call struct { + *mock.Call +} + +// ListClosedWorkflowExecutionsByStatus is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.ListClosedWorkflowExecutionsByStatusRequest +func (_e *VisibilityManager_Expecter) ListClosedWorkflowExecutionsByStatus(ctx interface{}, request interface{}) *VisibilityManager_ListClosedWorkflowExecutionsByStatus_Call { + return &VisibilityManager_ListClosedWorkflowExecutionsByStatus_Call{Call: _e.mock.On("ListClosedWorkflowExecutionsByStatus", ctx, request)} +} + +func (_c *VisibilityManager_ListClosedWorkflowExecutionsByStatus_Call) Run(run func(ctx context.Context, request *persistence.ListClosedWorkflowExecutionsByStatusRequest)) *VisibilityManager_ListClosedWorkflowExecutionsByStatus_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.ListClosedWorkflowExecutionsByStatusRequest + if args[1] != nil { + arg1 = args[1].(*persistence.ListClosedWorkflowExecutionsByStatusRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_ListClosedWorkflowExecutionsByStatus_Call) Return(listWorkflowExecutionsResponse *persistence.ListWorkflowExecutionsResponse, err error) *VisibilityManager_ListClosedWorkflowExecutionsByStatus_Call { + _c.Call.Return(listWorkflowExecutionsResponse, err) + return _c +} + +func (_c *VisibilityManager_ListClosedWorkflowExecutionsByStatus_Call) RunAndReturn(run func(ctx context.Context, request *persistence.ListClosedWorkflowExecutionsByStatusRequest) (*persistence.ListWorkflowExecutionsResponse, error)) *VisibilityManager_ListClosedWorkflowExecutionsByStatus_Call { + _c.Call.Return(run) + return _c +} + +// ListClosedWorkflowExecutionsByType provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) ListClosedWorkflowExecutionsByType(ctx context.Context, request *persistence.ListWorkflowExecutionsByTypeRequest) (*persistence.ListWorkflowExecutionsResponse, error) { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for ListClosedWorkflowExecutionsByType") @@ -226,29 +512,67 @@ func (_m *VisibilityManager) ListClosedWorkflowExecutionsByType(ctx context.Cont var r0 *persistence.ListWorkflowExecutionsResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByTypeRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByTypeRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByTypeRequest) *persistence.ListWorkflowExecutionsResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByTypeRequest) *persistence.ListWorkflowExecutionsResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.ListWorkflowExecutionsResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsByTypeRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsByTypeRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListClosedWorkflowExecutionsByWorkflowID provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) ListClosedWorkflowExecutionsByWorkflowID(ctx context.Context, request *persistence.ListWorkflowExecutionsByWorkflowIDRequest) (*persistence.ListWorkflowExecutionsResponse, error) { - ret := _m.Called(ctx, request) +// VisibilityManager_ListClosedWorkflowExecutionsByType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClosedWorkflowExecutionsByType' +type VisibilityManager_ListClosedWorkflowExecutionsByType_Call struct { + *mock.Call +} + +// ListClosedWorkflowExecutionsByType is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.ListWorkflowExecutionsByTypeRequest +func (_e *VisibilityManager_Expecter) ListClosedWorkflowExecutionsByType(ctx interface{}, request interface{}) *VisibilityManager_ListClosedWorkflowExecutionsByType_Call { + return &VisibilityManager_ListClosedWorkflowExecutionsByType_Call{Call: _e.mock.On("ListClosedWorkflowExecutionsByType", ctx, request)} +} + +func (_c *VisibilityManager_ListClosedWorkflowExecutionsByType_Call) Run(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsByTypeRequest)) *VisibilityManager_ListClosedWorkflowExecutionsByType_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.ListWorkflowExecutionsByTypeRequest + if args[1] != nil { + arg1 = args[1].(*persistence.ListWorkflowExecutionsByTypeRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_ListClosedWorkflowExecutionsByType_Call) Return(listWorkflowExecutionsResponse *persistence.ListWorkflowExecutionsResponse, err error) *VisibilityManager_ListClosedWorkflowExecutionsByType_Call { + _c.Call.Return(listWorkflowExecutionsResponse, err) + return _c +} + +func (_c *VisibilityManager_ListClosedWorkflowExecutionsByType_Call) RunAndReturn(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsByTypeRequest) (*persistence.ListWorkflowExecutionsResponse, error)) *VisibilityManager_ListClosedWorkflowExecutionsByType_Call { + _c.Call.Return(run) + return _c +} + +// ListClosedWorkflowExecutionsByWorkflowID provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) ListClosedWorkflowExecutionsByWorkflowID(ctx context.Context, request *persistence.ListWorkflowExecutionsByWorkflowIDRequest) (*persistence.ListWorkflowExecutionsResponse, error) { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for ListClosedWorkflowExecutionsByWorkflowID") @@ -256,29 +580,67 @@ func (_m *VisibilityManager) ListClosedWorkflowExecutionsByWorkflowID(ctx contex var r0 *persistence.ListWorkflowExecutionsResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByWorkflowIDRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByWorkflowIDRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByWorkflowIDRequest) *persistence.ListWorkflowExecutionsResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByWorkflowIDRequest) *persistence.ListWorkflowExecutionsResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.ListWorkflowExecutionsResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsByWorkflowIDRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsByWorkflowIDRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListOpenWorkflowExecutions provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) ListOpenWorkflowExecutions(ctx context.Context, request *persistence.ListWorkflowExecutionsRequest) (*persistence.ListWorkflowExecutionsResponse, error) { - ret := _m.Called(ctx, request) +// VisibilityManager_ListClosedWorkflowExecutionsByWorkflowID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListClosedWorkflowExecutionsByWorkflowID' +type VisibilityManager_ListClosedWorkflowExecutionsByWorkflowID_Call struct { + *mock.Call +} + +// ListClosedWorkflowExecutionsByWorkflowID is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.ListWorkflowExecutionsByWorkflowIDRequest +func (_e *VisibilityManager_Expecter) ListClosedWorkflowExecutionsByWorkflowID(ctx interface{}, request interface{}) *VisibilityManager_ListClosedWorkflowExecutionsByWorkflowID_Call { + return &VisibilityManager_ListClosedWorkflowExecutionsByWorkflowID_Call{Call: _e.mock.On("ListClosedWorkflowExecutionsByWorkflowID", ctx, request)} +} + +func (_c *VisibilityManager_ListClosedWorkflowExecutionsByWorkflowID_Call) Run(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsByWorkflowIDRequest)) *VisibilityManager_ListClosedWorkflowExecutionsByWorkflowID_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.ListWorkflowExecutionsByWorkflowIDRequest + if args[1] != nil { + arg1 = args[1].(*persistence.ListWorkflowExecutionsByWorkflowIDRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_ListClosedWorkflowExecutionsByWorkflowID_Call) Return(listWorkflowExecutionsResponse *persistence.ListWorkflowExecutionsResponse, err error) *VisibilityManager_ListClosedWorkflowExecutionsByWorkflowID_Call { + _c.Call.Return(listWorkflowExecutionsResponse, err) + return _c +} + +func (_c *VisibilityManager_ListClosedWorkflowExecutionsByWorkflowID_Call) RunAndReturn(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsByWorkflowIDRequest) (*persistence.ListWorkflowExecutionsResponse, error)) *VisibilityManager_ListClosedWorkflowExecutionsByWorkflowID_Call { + _c.Call.Return(run) + return _c +} + +// ListOpenWorkflowExecutions provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) ListOpenWorkflowExecutions(ctx context.Context, request *persistence.ListWorkflowExecutionsRequest) (*persistence.ListWorkflowExecutionsResponse, error) { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for ListOpenWorkflowExecutions") @@ -286,29 +648,67 @@ func (_m *VisibilityManager) ListOpenWorkflowExecutions(ctx context.Context, req var r0 *persistence.ListWorkflowExecutionsResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsRequest) *persistence.ListWorkflowExecutionsResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsRequest) *persistence.ListWorkflowExecutionsResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.ListWorkflowExecutionsResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListOpenWorkflowExecutionsByType provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) ListOpenWorkflowExecutionsByType(ctx context.Context, request *persistence.ListWorkflowExecutionsByTypeRequest) (*persistence.ListWorkflowExecutionsResponse, error) { - ret := _m.Called(ctx, request) +// VisibilityManager_ListOpenWorkflowExecutions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOpenWorkflowExecutions' +type VisibilityManager_ListOpenWorkflowExecutions_Call struct { + *mock.Call +} + +// ListOpenWorkflowExecutions is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.ListWorkflowExecutionsRequest +func (_e *VisibilityManager_Expecter) ListOpenWorkflowExecutions(ctx interface{}, request interface{}) *VisibilityManager_ListOpenWorkflowExecutions_Call { + return &VisibilityManager_ListOpenWorkflowExecutions_Call{Call: _e.mock.On("ListOpenWorkflowExecutions", ctx, request)} +} + +func (_c *VisibilityManager_ListOpenWorkflowExecutions_Call) Run(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsRequest)) *VisibilityManager_ListOpenWorkflowExecutions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.ListWorkflowExecutionsRequest + if args[1] != nil { + arg1 = args[1].(*persistence.ListWorkflowExecutionsRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_ListOpenWorkflowExecutions_Call) Return(listWorkflowExecutionsResponse *persistence.ListWorkflowExecutionsResponse, err error) *VisibilityManager_ListOpenWorkflowExecutions_Call { + _c.Call.Return(listWorkflowExecutionsResponse, err) + return _c +} + +func (_c *VisibilityManager_ListOpenWorkflowExecutions_Call) RunAndReturn(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsRequest) (*persistence.ListWorkflowExecutionsResponse, error)) *VisibilityManager_ListOpenWorkflowExecutions_Call { + _c.Call.Return(run) + return _c +} + +// ListOpenWorkflowExecutionsByType provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) ListOpenWorkflowExecutionsByType(ctx context.Context, request *persistence.ListWorkflowExecutionsByTypeRequest) (*persistence.ListWorkflowExecutionsResponse, error) { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for ListOpenWorkflowExecutionsByType") @@ -316,29 +716,67 @@ func (_m *VisibilityManager) ListOpenWorkflowExecutionsByType(ctx context.Contex var r0 *persistence.ListWorkflowExecutionsResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByTypeRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByTypeRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByTypeRequest) *persistence.ListWorkflowExecutionsResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByTypeRequest) *persistence.ListWorkflowExecutionsResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.ListWorkflowExecutionsResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsByTypeRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsByTypeRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListOpenWorkflowExecutionsByWorkflowID provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) ListOpenWorkflowExecutionsByWorkflowID(ctx context.Context, request *persistence.ListWorkflowExecutionsByWorkflowIDRequest) (*persistence.ListWorkflowExecutionsResponse, error) { - ret := _m.Called(ctx, request) +// VisibilityManager_ListOpenWorkflowExecutionsByType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOpenWorkflowExecutionsByType' +type VisibilityManager_ListOpenWorkflowExecutionsByType_Call struct { + *mock.Call +} + +// ListOpenWorkflowExecutionsByType is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.ListWorkflowExecutionsByTypeRequest +func (_e *VisibilityManager_Expecter) ListOpenWorkflowExecutionsByType(ctx interface{}, request interface{}) *VisibilityManager_ListOpenWorkflowExecutionsByType_Call { + return &VisibilityManager_ListOpenWorkflowExecutionsByType_Call{Call: _e.mock.On("ListOpenWorkflowExecutionsByType", ctx, request)} +} + +func (_c *VisibilityManager_ListOpenWorkflowExecutionsByType_Call) Run(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsByTypeRequest)) *VisibilityManager_ListOpenWorkflowExecutionsByType_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.ListWorkflowExecutionsByTypeRequest + if args[1] != nil { + arg1 = args[1].(*persistence.ListWorkflowExecutionsByTypeRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_ListOpenWorkflowExecutionsByType_Call) Return(listWorkflowExecutionsResponse *persistence.ListWorkflowExecutionsResponse, err error) *VisibilityManager_ListOpenWorkflowExecutionsByType_Call { + _c.Call.Return(listWorkflowExecutionsResponse, err) + return _c +} + +func (_c *VisibilityManager_ListOpenWorkflowExecutionsByType_Call) RunAndReturn(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsByTypeRequest) (*persistence.ListWorkflowExecutionsResponse, error)) *VisibilityManager_ListOpenWorkflowExecutionsByType_Call { + _c.Call.Return(run) + return _c +} + +// ListOpenWorkflowExecutionsByWorkflowID provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) ListOpenWorkflowExecutionsByWorkflowID(ctx context.Context, request *persistence.ListWorkflowExecutionsByWorkflowIDRequest) (*persistence.ListWorkflowExecutionsResponse, error) { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for ListOpenWorkflowExecutionsByWorkflowID") @@ -346,29 +784,67 @@ func (_m *VisibilityManager) ListOpenWorkflowExecutionsByWorkflowID(ctx context. var r0 *persistence.ListWorkflowExecutionsResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByWorkflowIDRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByWorkflowIDRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByWorkflowIDRequest) *persistence.ListWorkflowExecutionsResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByWorkflowIDRequest) *persistence.ListWorkflowExecutionsResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.ListWorkflowExecutionsResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsByWorkflowIDRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsByWorkflowIDRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// ListWorkflowExecutions provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) ListWorkflowExecutions(ctx context.Context, request *persistence.ListWorkflowExecutionsByQueryRequest) (*persistence.ListWorkflowExecutionsResponse, error) { - ret := _m.Called(ctx, request) +// VisibilityManager_ListOpenWorkflowExecutionsByWorkflowID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListOpenWorkflowExecutionsByWorkflowID' +type VisibilityManager_ListOpenWorkflowExecutionsByWorkflowID_Call struct { + *mock.Call +} + +// ListOpenWorkflowExecutionsByWorkflowID is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.ListWorkflowExecutionsByWorkflowIDRequest +func (_e *VisibilityManager_Expecter) ListOpenWorkflowExecutionsByWorkflowID(ctx interface{}, request interface{}) *VisibilityManager_ListOpenWorkflowExecutionsByWorkflowID_Call { + return &VisibilityManager_ListOpenWorkflowExecutionsByWorkflowID_Call{Call: _e.mock.On("ListOpenWorkflowExecutionsByWorkflowID", ctx, request)} +} + +func (_c *VisibilityManager_ListOpenWorkflowExecutionsByWorkflowID_Call) Run(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsByWorkflowIDRequest)) *VisibilityManager_ListOpenWorkflowExecutionsByWorkflowID_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.ListWorkflowExecutionsByWorkflowIDRequest + if args[1] != nil { + arg1 = args[1].(*persistence.ListWorkflowExecutionsByWorkflowIDRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_ListOpenWorkflowExecutionsByWorkflowID_Call) Return(listWorkflowExecutionsResponse *persistence.ListWorkflowExecutionsResponse, err error) *VisibilityManager_ListOpenWorkflowExecutionsByWorkflowID_Call { + _c.Call.Return(listWorkflowExecutionsResponse, err) + return _c +} + +func (_c *VisibilityManager_ListOpenWorkflowExecutionsByWorkflowID_Call) RunAndReturn(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsByWorkflowIDRequest) (*persistence.ListWorkflowExecutionsResponse, error)) *VisibilityManager_ListOpenWorkflowExecutionsByWorkflowID_Call { + _c.Call.Return(run) + return _c +} + +// ListWorkflowExecutions provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) ListWorkflowExecutions(ctx context.Context, request *persistence.ListWorkflowExecutionsByQueryRequest) (*persistence.ListWorkflowExecutionsResponse, error) { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for ListWorkflowExecutions") @@ -376,83 +852,238 @@ func (_m *VisibilityManager) ListWorkflowExecutions(ctx context.Context, request var r0 *persistence.ListWorkflowExecutionsResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByQueryRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByQueryRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByQueryRequest) *persistence.ListWorkflowExecutionsResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByQueryRequest) *persistence.ListWorkflowExecutionsResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.ListWorkflowExecutionsResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsByQueryRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsByQueryRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// RecordWorkflowExecutionClosed provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) RecordWorkflowExecutionClosed(ctx context.Context, request *persistence.RecordWorkflowExecutionClosedRequest) error { - ret := _m.Called(ctx, request) +// VisibilityManager_ListWorkflowExecutions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListWorkflowExecutions' +type VisibilityManager_ListWorkflowExecutions_Call struct { + *mock.Call +} + +// ListWorkflowExecutions is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.ListWorkflowExecutionsByQueryRequest +func (_e *VisibilityManager_Expecter) ListWorkflowExecutions(ctx interface{}, request interface{}) *VisibilityManager_ListWorkflowExecutions_Call { + return &VisibilityManager_ListWorkflowExecutions_Call{Call: _e.mock.On("ListWorkflowExecutions", ctx, request)} +} + +func (_c *VisibilityManager_ListWorkflowExecutions_Call) Run(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsByQueryRequest)) *VisibilityManager_ListWorkflowExecutions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.ListWorkflowExecutionsByQueryRequest + if args[1] != nil { + arg1 = args[1].(*persistence.ListWorkflowExecutionsByQueryRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_ListWorkflowExecutions_Call) Return(listWorkflowExecutionsResponse *persistence.ListWorkflowExecutionsResponse, err error) *VisibilityManager_ListWorkflowExecutions_Call { + _c.Call.Return(listWorkflowExecutionsResponse, err) + return _c +} + +func (_c *VisibilityManager_ListWorkflowExecutions_Call) RunAndReturn(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsByQueryRequest) (*persistence.ListWorkflowExecutionsResponse, error)) *VisibilityManager_ListWorkflowExecutions_Call { + _c.Call.Return(run) + return _c +} + +// RecordWorkflowExecutionClosed provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) RecordWorkflowExecutionClosed(ctx context.Context, request *persistence.RecordWorkflowExecutionClosedRequest) error { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for RecordWorkflowExecutionClosed") } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.RecordWorkflowExecutionClosedRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.RecordWorkflowExecutionClosedRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } - return r0 } -// RecordWorkflowExecutionStarted provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) RecordWorkflowExecutionStarted(ctx context.Context, request *persistence.RecordWorkflowExecutionStartedRequest) error { - ret := _m.Called(ctx, request) +// VisibilityManager_RecordWorkflowExecutionClosed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordWorkflowExecutionClosed' +type VisibilityManager_RecordWorkflowExecutionClosed_Call struct { + *mock.Call +} + +// RecordWorkflowExecutionClosed is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.RecordWorkflowExecutionClosedRequest +func (_e *VisibilityManager_Expecter) RecordWorkflowExecutionClosed(ctx interface{}, request interface{}) *VisibilityManager_RecordWorkflowExecutionClosed_Call { + return &VisibilityManager_RecordWorkflowExecutionClosed_Call{Call: _e.mock.On("RecordWorkflowExecutionClosed", ctx, request)} +} + +func (_c *VisibilityManager_RecordWorkflowExecutionClosed_Call) Run(run func(ctx context.Context, request *persistence.RecordWorkflowExecutionClosedRequest)) *VisibilityManager_RecordWorkflowExecutionClosed_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.RecordWorkflowExecutionClosedRequest + if args[1] != nil { + arg1 = args[1].(*persistence.RecordWorkflowExecutionClosedRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_RecordWorkflowExecutionClosed_Call) Return(err error) *VisibilityManager_RecordWorkflowExecutionClosed_Call { + _c.Call.Return(err) + return _c +} + +func (_c *VisibilityManager_RecordWorkflowExecutionClosed_Call) RunAndReturn(run func(ctx context.Context, request *persistence.RecordWorkflowExecutionClosedRequest) error) *VisibilityManager_RecordWorkflowExecutionClosed_Call { + _c.Call.Return(run) + return _c +} + +// RecordWorkflowExecutionStarted provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) RecordWorkflowExecutionStarted(ctx context.Context, request *persistence.RecordWorkflowExecutionStartedRequest) error { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for RecordWorkflowExecutionStarted") } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.RecordWorkflowExecutionStartedRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.RecordWorkflowExecutionStartedRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } - return r0 } -// RecordWorkflowExecutionUninitialized provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) RecordWorkflowExecutionUninitialized(ctx context.Context, request *persistence.RecordWorkflowExecutionUninitializedRequest) error { - ret := _m.Called(ctx, request) +// VisibilityManager_RecordWorkflowExecutionStarted_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordWorkflowExecutionStarted' +type VisibilityManager_RecordWorkflowExecutionStarted_Call struct { + *mock.Call +} + +// RecordWorkflowExecutionStarted is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.RecordWorkflowExecutionStartedRequest +func (_e *VisibilityManager_Expecter) RecordWorkflowExecutionStarted(ctx interface{}, request interface{}) *VisibilityManager_RecordWorkflowExecutionStarted_Call { + return &VisibilityManager_RecordWorkflowExecutionStarted_Call{Call: _e.mock.On("RecordWorkflowExecutionStarted", ctx, request)} +} + +func (_c *VisibilityManager_RecordWorkflowExecutionStarted_Call) Run(run func(ctx context.Context, request *persistence.RecordWorkflowExecutionStartedRequest)) *VisibilityManager_RecordWorkflowExecutionStarted_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.RecordWorkflowExecutionStartedRequest + if args[1] != nil { + arg1 = args[1].(*persistence.RecordWorkflowExecutionStartedRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_RecordWorkflowExecutionStarted_Call) Return(err error) *VisibilityManager_RecordWorkflowExecutionStarted_Call { + _c.Call.Return(err) + return _c +} + +func (_c *VisibilityManager_RecordWorkflowExecutionStarted_Call) RunAndReturn(run func(ctx context.Context, request *persistence.RecordWorkflowExecutionStartedRequest) error) *VisibilityManager_RecordWorkflowExecutionStarted_Call { + _c.Call.Return(run) + return _c +} + +// RecordWorkflowExecutionUninitialized provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) RecordWorkflowExecutionUninitialized(ctx context.Context, request *persistence.RecordWorkflowExecutionUninitializedRequest) error { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for RecordWorkflowExecutionUninitialized") } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.RecordWorkflowExecutionUninitializedRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.RecordWorkflowExecutionUninitializedRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } - return r0 } -// ScanWorkflowExecutions provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) ScanWorkflowExecutions(ctx context.Context, request *persistence.ListWorkflowExecutionsByQueryRequest) (*persistence.ListWorkflowExecutionsResponse, error) { - ret := _m.Called(ctx, request) +// VisibilityManager_RecordWorkflowExecutionUninitialized_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RecordWorkflowExecutionUninitialized' +type VisibilityManager_RecordWorkflowExecutionUninitialized_Call struct { + *mock.Call +} + +// RecordWorkflowExecutionUninitialized is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.RecordWorkflowExecutionUninitializedRequest +func (_e *VisibilityManager_Expecter) RecordWorkflowExecutionUninitialized(ctx interface{}, request interface{}) *VisibilityManager_RecordWorkflowExecutionUninitialized_Call { + return &VisibilityManager_RecordWorkflowExecutionUninitialized_Call{Call: _e.mock.On("RecordWorkflowExecutionUninitialized", ctx, request)} +} + +func (_c *VisibilityManager_RecordWorkflowExecutionUninitialized_Call) Run(run func(ctx context.Context, request *persistence.RecordWorkflowExecutionUninitializedRequest)) *VisibilityManager_RecordWorkflowExecutionUninitialized_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.RecordWorkflowExecutionUninitializedRequest + if args[1] != nil { + arg1 = args[1].(*persistence.RecordWorkflowExecutionUninitializedRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_RecordWorkflowExecutionUninitialized_Call) Return(err error) *VisibilityManager_RecordWorkflowExecutionUninitialized_Call { + _c.Call.Return(err) + return _c +} + +func (_c *VisibilityManager_RecordWorkflowExecutionUninitialized_Call) RunAndReturn(run func(ctx context.Context, request *persistence.RecordWorkflowExecutionUninitializedRequest) error) *VisibilityManager_RecordWorkflowExecutionUninitialized_Call { + _c.Call.Return(run) + return _c +} + +// ScanWorkflowExecutions provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) ScanWorkflowExecutions(ctx context.Context, request *persistence.ListWorkflowExecutionsByQueryRequest) (*persistence.ListWorkflowExecutionsResponse, error) { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for ScanWorkflowExecutions") @@ -460,54 +1091,117 @@ func (_m *VisibilityManager) ScanWorkflowExecutions(ctx context.Context, request var r0 *persistence.ListWorkflowExecutionsResponse var r1 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByQueryRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { - return rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByQueryRequest) (*persistence.ListWorkflowExecutionsResponse, error)); ok { + return returnFunc(ctx, request) } - if rf, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByQueryRequest) *persistence.ListWorkflowExecutionsResponse); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.ListWorkflowExecutionsByQueryRequest) *persistence.ListWorkflowExecutionsResponse); ok { + r0 = returnFunc(ctx, request) } else { if ret.Get(0) != nil { r0 = ret.Get(0).(*persistence.ListWorkflowExecutionsResponse) } } - - if rf, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsByQueryRequest) error); ok { - r1 = rf(ctx, request) + if returnFunc, ok := ret.Get(1).(func(context.Context, *persistence.ListWorkflowExecutionsByQueryRequest) error); ok { + r1 = returnFunc(ctx, request) } else { r1 = ret.Error(1) } - return r0, r1 } -// UpsertWorkflowExecution provides a mock function with given fields: ctx, request -func (_m *VisibilityManager) UpsertWorkflowExecution(ctx context.Context, request *persistence.UpsertWorkflowExecutionRequest) error { - ret := _m.Called(ctx, request) +// VisibilityManager_ScanWorkflowExecutions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScanWorkflowExecutions' +type VisibilityManager_ScanWorkflowExecutions_Call struct { + *mock.Call +} + +// ScanWorkflowExecutions is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.ListWorkflowExecutionsByQueryRequest +func (_e *VisibilityManager_Expecter) ScanWorkflowExecutions(ctx interface{}, request interface{}) *VisibilityManager_ScanWorkflowExecutions_Call { + return &VisibilityManager_ScanWorkflowExecutions_Call{Call: _e.mock.On("ScanWorkflowExecutions", ctx, request)} +} + +func (_c *VisibilityManager_ScanWorkflowExecutions_Call) Run(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsByQueryRequest)) *VisibilityManager_ScanWorkflowExecutions_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.ListWorkflowExecutionsByQueryRequest + if args[1] != nil { + arg1 = args[1].(*persistence.ListWorkflowExecutionsByQueryRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_ScanWorkflowExecutions_Call) Return(listWorkflowExecutionsResponse *persistence.ListWorkflowExecutionsResponse, err error) *VisibilityManager_ScanWorkflowExecutions_Call { + _c.Call.Return(listWorkflowExecutionsResponse, err) + return _c +} + +func (_c *VisibilityManager_ScanWorkflowExecutions_Call) RunAndReturn(run func(ctx context.Context, request *persistence.ListWorkflowExecutionsByQueryRequest) (*persistence.ListWorkflowExecutionsResponse, error)) *VisibilityManager_ScanWorkflowExecutions_Call { + _c.Call.Return(run) + return _c +} + +// UpsertWorkflowExecution provides a mock function for the type VisibilityManager +func (_mock *VisibilityManager) UpsertWorkflowExecution(ctx context.Context, request *persistence.UpsertWorkflowExecutionRequest) error { + ret := _mock.Called(ctx, request) if len(ret) == 0 { panic("no return value specified for UpsertWorkflowExecution") } var r0 error - if rf, ok := ret.Get(0).(func(context.Context, *persistence.UpsertWorkflowExecutionRequest) error); ok { - r0 = rf(ctx, request) + if returnFunc, ok := ret.Get(0).(func(context.Context, *persistence.UpsertWorkflowExecutionRequest) error); ok { + r0 = returnFunc(ctx, request) } else { r0 = ret.Error(0) } - return r0 } -// NewVisibilityManager creates a new instance of VisibilityManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewVisibilityManager(t interface { - mock.TestingT - Cleanup(func()) -}) *VisibilityManager { - mock := &VisibilityManager{} - mock.Mock.Test(t) +// VisibilityManager_UpsertWorkflowExecution_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertWorkflowExecution' +type VisibilityManager_UpsertWorkflowExecution_Call struct { + *mock.Call +} - t.Cleanup(func() { mock.AssertExpectations(t) }) +// UpsertWorkflowExecution is a helper method to define mock.On call +// - ctx context.Context +// - request *persistence.UpsertWorkflowExecutionRequest +func (_e *VisibilityManager_Expecter) UpsertWorkflowExecution(ctx interface{}, request interface{}) *VisibilityManager_UpsertWorkflowExecution_Call { + return &VisibilityManager_UpsertWorkflowExecution_Call{Call: _e.mock.On("UpsertWorkflowExecution", ctx, request)} +} - return mock +func (_c *VisibilityManager_UpsertWorkflowExecution_Call) Run(run func(ctx context.Context, request *persistence.UpsertWorkflowExecutionRequest)) *VisibilityManager_UpsertWorkflowExecution_Call { + _c.Call.Run(func(args mock.Arguments) { + var arg0 context.Context + if args[0] != nil { + arg0 = args[0].(context.Context) + } + var arg1 *persistence.UpsertWorkflowExecutionRequest + if args[1] != nil { + arg1 = args[1].(*persistence.UpsertWorkflowExecutionRequest) + } + run( + arg0, + arg1, + ) + }) + return _c +} + +func (_c *VisibilityManager_UpsertWorkflowExecution_Call) Return(err error) *VisibilityManager_UpsertWorkflowExecution_Call { + _c.Call.Return(err) + return _c +} + +func (_c *VisibilityManager_UpsertWorkflowExecution_Call) RunAndReturn(run func(ctx context.Context, request *persistence.UpsertWorkflowExecutionRequest) error) *VisibilityManager_UpsertWorkflowExecution_Call { + _c.Call.Return(run) + return _c } diff --git a/common/reconciliation/invariant/stale_workflow.go b/common/reconciliation/invariant/stale_workflow.go index 6fcb56b5fb6..e7d7d7e3dd2 100644 --- a/common/reconciliation/invariant/stale_workflow.go +++ b/common/reconciliation/invariant/stale_workflow.go @@ -125,7 +125,7 @@ func (c *staleWorkflowCheck) check( }, }) if err != nil { - return false, c.failed("failed to get concrete execution record", err.Error()) + return false, c.failed("failed to get concrete execution record", "%v", err) } pastExpiration, checkresult := c.CheckAge(concreteWorkflow) @@ -331,7 +331,7 @@ func (c *staleWorkflowCheck) checkTimeInSaneRange(t time.Time, kind string) (ok // something screwed up, time is outside sane bounds return false, c.failed( fmt.Sprintf("calculated %v seems insane, failing", kind), - fmt.Sprintf("expected %v to be within range: %q < actual %q < %q", kind, impossiblyOld, t, impossiblyFuture)) + "expected %v to be within range: %q < actual %q < %q", kind, impossiblyOld, t, impossiblyFuture) } return true, result } @@ -513,7 +513,7 @@ func (c *staleWorkflowCheck) closeEventTime(workflow *persistence.GetWorkflowExe } last, err := c.getLastEvent(branchToken, domainName) if err != nil { - return when, false, c.failed("failed to get last event", err.Error()) + return when, false, c.failed("failed to get last event", "%v", err) } if last == nil { return when, false, c.failed("empty last event, should be impossible", "") // successful totally-empty history seems impossible diff --git a/common/resource/resource_mock.go b/common/resource/resource_mock.go index 58127259301..2e0bca6f136 100644 --- a/common/resource/resource_mock.go +++ b/common/resource/resource_mock.go @@ -541,33 +541,33 @@ func (mr *MockResourceMockRecorder) GetRatelimiterAggregatorsClient() *gomock.Ca } // GetRemoteAdminClient mocks base method. -func (m *MockResource) GetRemoteAdminClient(cluster string) (admin.Client, error) { +func (m *MockResource) GetRemoteAdminClient(arg0 string) (admin.Client, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRemoteAdminClient", cluster) + ret := m.ctrl.Call(m, "GetRemoteAdminClient", arg0) ret0, _ := ret[0].(admin.Client) ret1, _ := ret[1].(error) return ret0, ret1 } // GetRemoteAdminClient indicates an expected call of GetRemoteAdminClient. -func (mr *MockResourceMockRecorder) GetRemoteAdminClient(cluster any) *gomock.Call { +func (mr *MockResourceMockRecorder) GetRemoteAdminClient(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteAdminClient", reflect.TypeOf((*MockResource)(nil).GetRemoteAdminClient), cluster) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteAdminClient", reflect.TypeOf((*MockResource)(nil).GetRemoteAdminClient), arg0) } // GetRemoteFrontendClient mocks base method. -func (m *MockResource) GetRemoteFrontendClient(cluster string) (frontend.Client, error) { +func (m *MockResource) GetRemoteFrontendClient(arg0 string) (frontend.Client, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRemoteFrontendClient", cluster) + ret := m.ctrl.Call(m, "GetRemoteFrontendClient", arg0) ret0, _ := ret[0].(frontend.Client) ret1, _ := ret[1].(error) return ret0, ret1 } // GetRemoteFrontendClient indicates an expected call of GetRemoteFrontendClient. -func (mr *MockResourceMockRecorder) GetRemoteFrontendClient(cluster any) *gomock.Call { +func (mr *MockResourceMockRecorder) GetRemoteFrontendClient(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteFrontendClient", reflect.TypeOf((*MockResource)(nil).GetRemoteFrontendClient), cluster) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteFrontendClient", reflect.TypeOf((*MockResource)(nil).GetRemoteFrontendClient), arg0) } // GetSDKClient mocks base method. diff --git a/common/rpc/peer_chooser_mock.go b/common/rpc/peer_chooser_mock.go index 710831fb4c7..c65e6f9a359 100644 --- a/common/rpc/peer_chooser_mock.go +++ b/common/rpc/peer_chooser_mock.go @@ -45,18 +45,18 @@ func (m *MockPeerChooserFactory) EXPECT() *MockPeerChooserFactoryMockRecorder { } // CreatePeerChooser mocks base method. -func (m *MockPeerChooserFactory) CreatePeerChooser(transport peer.Transport, opts PeerChooserOptions) (PeerChooser, error) { +func (m *MockPeerChooserFactory) CreatePeerChooser(arg0 peer.Transport, opts PeerChooserOptions) (PeerChooser, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "CreatePeerChooser", transport, opts) + ret := m.ctrl.Call(m, "CreatePeerChooser", arg0, opts) ret0, _ := ret[0].(PeerChooser) ret1, _ := ret[1].(error) return ret0, ret1 } // CreatePeerChooser indicates an expected call of CreatePeerChooser. -func (mr *MockPeerChooserFactoryMockRecorder) CreatePeerChooser(transport, opts any) *gomock.Call { +func (mr *MockPeerChooserFactoryMockRecorder) CreatePeerChooser(arg0, opts any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePeerChooser", reflect.TypeOf((*MockPeerChooserFactory)(nil).CreatePeerChooser), transport, opts) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePeerChooser", reflect.TypeOf((*MockPeerChooserFactory)(nil).CreatePeerChooser), arg0, opts) } // MockPeerChooser is a mock of PeerChooser interface. diff --git a/common/util.go b/common/util.go index 857b2c89f48..e55f98a68df 100644 --- a/common/util.go +++ b/common/util.go @@ -282,7 +282,7 @@ func ToServiceTransientError(err error) error { if err == nil || IsServiceTransientError(err) { return err } - return yarpcerrors.Newf(yarpcerrors.CodeUnavailable, err.Error()) + return yarpcerrors.Newf(yarpcerrors.CodeUnavailable, "%v", err) } // HistoryRetryFuncFrontendExceptions checks if an error should be retried diff --git a/docker/github_actions/Dockerfile b/docker/github_actions/Dockerfile index fb0dab2a545..564f400fe6d 100644 --- a/docker/github_actions/Dockerfile +++ b/docker/github_actions/Dockerfile @@ -1,4 +1,4 @@ -FROM golang:1.23.4-bullseye +FROM golang:1.24.7-bookworm # Tried to set Python to ignore warnings due to the instructions at this link: # https://github.com/yaml/pyyaml/wiki/PyYAML-yaml.load(input)-Deprecation @@ -11,12 +11,12 @@ RUN apt-get update && apt-get install -y --no-install-recommends \ gettext-base \ libyaml-dev \ python3-pip \ - python-setuptools \ + python3-setuptools \ time \ unzip \ && rm -rf /var/lib/apt/lists/* -RUN pip install cqlsh +RUN pip install cqlsh --break-system-packages # verbose test output from `make`, can be disabled with V=0 ENV V=0 diff --git a/go.mod b/go.mod index 7d8993148b0..fbcaea4217e 100644 --- a/go.mod +++ b/go.mod @@ -1,8 +1,8 @@ module github.com/uber/cadence -go 1.23.0 +go 1.24 -toolchain go1.23.4 +toolchain go1.24.7 require ( github.com/MicahParks/keyfunc/v2 v2.1.0 @@ -56,10 +56,10 @@ require ( go.uber.org/yarpc v1.70.3 go.uber.org/zap v1.26.0 golang.org/x/exp v0.0.0-20231226003508-02704c960a9b - golang.org/x/net v0.40.0 - golang.org/x/sync v0.14.0 + golang.org/x/net v0.43.0 + golang.org/x/sync v0.16.0 golang.org/x/time v0.5.0 - golang.org/x/tools v0.22.0 + golang.org/x/tools v0.36.0 gonum.org/v1/gonum v0.7.0 google.golang.org/grpc v1.59.0 gopkg.in/validator.v2 v2.0.0-20180514200540-135c24b11c19 @@ -72,10 +72,10 @@ require ( github.com/flynn/go-shlex v0.0.0-20150515145356-3f9db97f8568 github.com/google/gofuzz v1.0.0 github.com/mark3labs/mcp-go v0.18.0 - github.com/ncruces/go-sqlite3 v0.22.0 + github.com/ncruces/go-sqlite3 v0.23.3 github.com/opensearch-project/opensearch-go/v4 v4.1.0 github.com/robfig/cron/v3 v3.0.1 - go.uber.org/mock v0.5.0 + go.uber.org/mock v0.6.0 ) require ( @@ -83,9 +83,10 @@ require ( github.com/pierrec/lz4/v4 v4.1.22 // indirect github.com/robfig/cron v1.2.0 // indirect github.com/rogpeppe/go-internal v1.6.1 // indirect - github.com/tetratelabs/wazero v1.8.2 // indirect + github.com/tetratelabs/wazero v1.9.0 // indirect github.com/xrash/smetrics v0.0.0-20240521201337-686a1a2994c1 // indirect github.com/yosida95/uritemplate/v3 v3.0.2 // indirect + golang.org/x/tools/go/expect v0.1.1-deprecated // indirect ) require ( @@ -149,12 +150,12 @@ require ( go.uber.org/dig v1.18.0 // indirect go.uber.org/goleak v1.2.0 go.uber.org/net/metrics v1.3.0 // indirect - golang.org/x/crypto v0.38.0 // indirect + golang.org/x/crypto v0.41.0 // indirect golang.org/x/exp/typeparams v0.0.0-20220218215828-6cf2b201936e // indirect golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 // indirect - golang.org/x/mod v0.18.0 - golang.org/x/sys v0.33.0 // indirect - golang.org/x/text v0.25.0 // indirect + golang.org/x/mod v0.27.0 + golang.org/x/sys v0.35.0 // indirect + golang.org/x/text v0.28.0 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20231030173426-d783a09b4405 // indirect google.golang.org/protobuf v1.31.0 // indirect gopkg.in/inf.v0 v0.9.1 // indirect diff --git a/go.sum b/go.sum index abd1c9dd600..eab03b72225 100644 --- a/go.sum +++ b/go.sum @@ -307,8 +307,8 @@ github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3Rllmb github.com/montanaflynn/stats v0.0.0-20171201202039-1bf9dbcd8cbe/go.mod h1:wL8QJuTMNUDYhXwkmfOly8iTdp5TEcJFWZD2D7SIkUc= github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= -github.com/ncruces/go-sqlite3 v0.22.0 h1:FkGSBhd0TY6e66k1LVhyEpA+RnG/8QkQNed5pjIk4cs= -github.com/ncruces/go-sqlite3 v0.22.0/go.mod h1:ueXOZXYZS2OFQirCU3mHneDwJm5fGKHrtccYBeGEV7M= +github.com/ncruces/go-sqlite3 v0.23.3 h1:RHaQPjd5hPhhVXuS2B4z07rqhV/3SuAsBbDCk23fyMw= +github.com/ncruces/go-sqlite3 v0.23.3/go.mod h1:WvU8gwMpK1rNG3JqJ7QZGRXNVNeIAwuButtr/Ze3iso= github.com/ncruces/julianday v1.0.0 h1:fH0OKwa7NWvniGQtxdJRxAgkBMolni2BjDHaWTxqt7M= github.com/ncruces/julianday v1.0.0/go.mod h1:Dusn2KvZrrovOMJuOt0TNXL6tB7U2E8kvza5fFc9G7g= github.com/olekukonko/tablewriter v0.0.4 h1:vHD/YYe1Wolo78koG299f7V/VAS08c6IpCLn+Ejf/w8= @@ -424,8 +424,8 @@ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= -github.com/tetratelabs/wazero v1.8.2 h1:yIgLR/b2bN31bjxwXHD8a3d+BogigR952csSDdLYEv4= -github.com/tetratelabs/wazero v1.8.2/go.mod h1:yAI0XTsMBhREkM/YDAK/zNou3GoiAce1P6+rp/wQhjs= +github.com/tetratelabs/wazero v1.9.0 h1:IcZ56OuxrtaEz8UYNRHBrUa9bYeX9oVY93KspZZBf/I= +github.com/tetratelabs/wazero v1.9.0/go.mod h1:TSbcXCfFP0L2FGkRPxHphadXPjo1T6W+CseNNY7EkjM= github.com/tidwall/gjson v1.17.1 h1:wlYEnwqAHgzmhNUFfw7Xalt2JzQvsMx2Se4PcoFCT/U= github.com/tidwall/gjson v1.17.1/go.mod h1:/wbyibRr2FHMks5tjHJ5F8dMZh3AcwJEMf5vlfC0lxk= github.com/tidwall/match v1.1.1 h1:+Ho715JplO36QYgwN9PGYNhgZvoUSc9X2c80KVTi+GA= @@ -511,8 +511,8 @@ go.uber.org/goleak v0.10.0/go.mod h1:VCZuO8V8mFPlL0F5J5GK1rtHV3DrFcQ1R8ryq7FK0aI go.uber.org/goleak v1.0.0/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk= go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo= -go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU= -go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM= +go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= +go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= go.uber.org/multierr v1.4.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= @@ -543,8 +543,8 @@ golang.org/x/crypto v0.0.0-20200302210943-78000ba7a073/go.mod h1:LzIPMQfyMNhhGPh golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.6.0/go.mod h1:OFC/31mSvZgRz0V1QTNCzfAI1aIRzbiufJtkMIlEp58= -golang.org/x/crypto v0.38.0 h1:jt+WWG8IZlBnVbomuhg2Mdq0+BBQaHbtqHEFEigjUV8= -golang.org/x/crypto v0.38.0/go.mod h1:MvrbAqul58NNYPKnOra203SB9vpuZW0e+RRZV+Ggqjw= +golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4= +golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc= golang.org/x/exp v0.0.0-20180321215751-8460e604b9de/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20180807140117-3d87b88a115f/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= @@ -568,8 +568,8 @@ golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0= -golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ= +golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -591,8 +591,8 @@ golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qx golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c= golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= golang.org/x/net v0.7.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs= -golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY= -golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds= +golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE= +golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -607,8 +607,8 @@ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ= -golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw= +golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180903190138-2b024373dcd9/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -644,8 +644,8 @@ golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= -golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI= +golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k= @@ -657,8 +657,8 @@ golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8= -golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4= -golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA= +golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng= +golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU= golang.org/x/time v0.0.0-20170927054726-6dc17368e09b/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= @@ -695,8 +695,10 @@ golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.11-0.20220513221640-090b14e8501f/go.mod h1:SgwaegtQh8clINPpECJMqnxLv9I09HLqnW3RMqW0CA4= golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc= -golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA= -golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c= +golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg= +golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s= +golang.org/x/tools/go/expect v0.1.1-deprecated h1:jpBZDwmgPhXsKZC6WhL20P4b/wmnpsEAGHaNy0n/rJM= +golang.org/x/tools/go/expect v0.1.1-deprecated/go.mod h1:eihoPOH+FgIqa3FpoTwguz/bVUSGBlGQU67vpBeOrBY= 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= diff --git a/go.work b/go.work index 89341fd292b..d62b36a5ca6 100644 --- a/go.work +++ b/go.work @@ -1,4 +1,4 @@ -go 1.23.0 +go 1.24 // This file is primarily for gopls and IDEs it supports, as it does not // understand submodules correctly without it. @@ -31,4 +31,4 @@ use ( // Go version used to build within this workspace only, it does not affect dependencies. // but note that it needs to be a version that docker + mac + linux all support, as // they all must be in sync. -toolchain go1.23.4 +toolchain go1.24.7 diff --git a/go.work.sum b/go.work.sum index 2b1625d8c7d..ff5b3daf0ca 100644 --- a/go.work.sum +++ b/go.work.sum @@ -558,6 +558,8 @@ github.com/mwitkow/go-conntrack v0.0.0-20190716064945-2f068394615f h1:KUppIJq7/+ github.com/mwitkow/go-proto-validators v0.2.0 h1:F6LFfmgVnfULfaRsQWBbe7F7ocuHCr9+7m+GAeDzNbQ= github.com/ncruces/sort v0.1.2 h1:zKQ9CA4fpHPF6xsUhRTfi5EEryspuBpe/QA4VWQOV1U= github.com/ncruces/sort v0.1.2/go.mod h1:vEJUTBJtebIuCMmXD18GKo5GJGhsay+xZFOoBEIXFmE= +github.com/ncruces/sort v0.1.5 h1:fiFWXXAqKI8QckPf/6hu/bGFwcEPrirIOFaJqWujs4k= +github.com/ncruces/sort v0.1.5/go.mod h1:obJToO4rYr6VWP0Uw5FYymgYGt3Br4RXcs/JdKaXAPk= github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/oklog/ulid v1.3.1 h1:EGfNDEx6MqHz8B3uNV6QAib1UR2Lm97sHi3ocA6ESJ4= @@ -618,6 +620,7 @@ github.com/spf13/cobra v0.0.3 h1:ZlrZ4XsMRm04Fr5pSFxBgfND2EBVa1nLpiy1stUsX/8= github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg= github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= +github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/taylanisikdemir/cadence-idl v0.0.0-20250604205405-c829a7dc2e0c h1:EtJglCmzRnUbKX67v9svqAnYlrgPwCE+PUnG1kB2ooY= github.com/taylanisikdemir/cadence-idl v0.0.0-20250604205405-c829a7dc2e0c/go.mod h1:oyUK7GCNCRHCCyWyzifSzXpVrRYVBbAMHAzF5dXiKws= github.com/timl3136/cadence-idl v0.0.0-20240716221550-3529a2618736 h1:UoaE2FX56QyLA0VGMJ16cll3haA5aZaFnfw5ZFDBzVU= @@ -681,6 +684,7 @@ go.opentelemetry.io/proto/otlp v0.7.0 h1:rwOQPCuKAKmwGKq2aVNnYIibI6wnV7EvzgfTCzc go.opentelemetry.io/proto/otlp v0.19.0 h1:IVN6GR+mhC4s5yfcTbmzHYODqvWAp3ZedA2SJPI1Nnw= go.opentelemetry.io/proto/otlp v0.19.0/go.mod h1:H7XAot3MsfNsj7EXtrA2q5xSNQ10UqI405h3+duxN4U= go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= +go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM= go.uber.org/thriftrw v1.29.1/go.mod h1:YcjXveberDd28/Bs34SwHy3yu85x/jB4UA2gIcz/Eo0= golang.org/x/arch v0.0.0-20180920145803-b19384d3c130 h1:Vsc61gop4hfHdzQNolo6Fi/sw7TnJ2yl3ZR4i7bYirs= golang.org/x/crypto v0.9.0/go.mod h1:yrmDGqONDYtNj3tH8X9dzUun2m2lzPa9ngI6/RUPGR0= @@ -688,11 +692,14 @@ golang.org/x/crypto v0.10.0/go.mod h1:o4eNf7Ede1fv+hwOwZsTHl9EsPFO6q6ZvYR8vYfY45 golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw= golang.org/x/crypto v0.14.0/go.mod h1:MVFd36DqK4CsrnJYDkBA3VC4m2GkXAM0PvzMCn4JQf4= golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM= +golang.org/x/crypto v0.33.0/go.mod h1:bVdXmD7IV/4GdElGPozy6U7lWdRXA4qyRVGJV57uQ5M= golang.org/x/image v0.0.0-20180708004352-c73c2afc3b81 h1:00VmoueYNlNz/aHIilyyQz/MHSqGoWJzpFv/HW8xpzI= golang.org/x/image v0.0.0-20190802002840-cff245a6509b h1:+qEpEAPhDZ1o0x3tHzZTQDArnOixOzGD9HUJfcg0mb4= golang.org/x/mobile v0.0.0-20200801112145-973feb4309de h1:OVJ6QQUBAesB8CZijKDSsXX7xYVtUhrkY0gwMfbi4p4= golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs= golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.26.0/go.mod h1:/j6NAhSk8iQ723BGAUyoAcn7SlD7s15Dp9Nd/SfeaFQ= golang.org/x/net v0.0.0-20190628185345-da137c7871d7/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.8.0/go.mod h1:QVkue5JL9kW//ek3r6jTKnTFis1tRmNAW2P1shuFdJc= golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg= @@ -700,11 +707,13 @@ golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI= golang.org/x/net v0.17.0/go.mod h1:NxSsAGuq816PNPmqtQdLE42eU2Fs7NoRIZrHJAlaCOE= golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44= golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE= +golang.org/x/net v0.42.0/go.mod h1:FF1RA5d3u7nAYA4z2TkclSCKh68eSXtiFwcWQpPXdt8= golang.org/x/oauth2 v0.6.0/go.mod h1:ycmewcwgD4Rpr3eZJLSB4Kyyljb3qDh40vJ8STE5HKw= golang.org/x/oauth2 v0.8.0/go.mod h1:yr7u4HXZRm1R1kBWqr/xKNqewf0plRYoB7sla+BCIXE= golang.org/x/sync v0.2.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y= golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= @@ -712,8 +721,13 @@ golang.org/x/sys v0.9.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.13.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/telemetry v0.0.0-20240521205824-bda55230c457 h1:zf5N6UOrA487eEFacMePxjXAJctxKmyjKUsjA11Uzuk= golang.org/x/telemetry v0.0.0-20240521205824-bda55230c457/go.mod h1:pRgIJT+bRLFKnoM1ldnzKoxTIn14Yxz928LQRYYgIN0= +golang.org/x/telemetry v0.0.0-20250710130107-8d8967aff50b h1:DU+gwOBXU+6bO0sEyO7o/NeMlxZxCZEvI7v+J4a1zRQ= +golang.org/x/telemetry v0.0.0-20250710130107-8d8967aff50b/go.mod h1:4ZwOYna0/zsOKwuR5X/m0QFOJpSZvAxFfkQT+Erd9D4= +golang.org/x/telemetry v0.0.0-20250807160809-1a19826ec488 h1:3doPGa+Gg4snce233aCWnbZVFsyFMo/dR40KK/6skyE= +golang.org/x/telemetry v0.0.0-20250807160809-1a19826ec488/go.mod h1:fGb/2+tgXXjhjHsTNdVEEMZNWA0quBnfrO+AfoDSAKw= golang.org/x/term v0.15.0 h1:y/Oo/a/q3IXu26lQgl04j/gjuBDOBlx7X6Om1j2CPW4= golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0= golang.org/x/term v0.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA= @@ -724,14 +738,20 @@ golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y= golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g= golang.org/x/term v0.32.0 h1:DR4lr0TjUs3epypdhTOkMmuF5CDFJ/8pOnbzMZPQ7bg= golang.org/x/term v0.32.0/go.mod h1:uZG1FhGx848Sqfsq4/DlJr3xGGsYMu/L5GW4abiaEPQ= +golang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4= +golang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw= golang.org/x/text v0.8.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8= golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE= golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI= +golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY= golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU= golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58= golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk= +golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c= +golang.org/x/tools v0.34.0/go.mod h1:pAP9OwEaY1CAW3HOmg3hLZC5Z0CCmzjAF2UQMSqNARg= +golang.org/x/tools v0.35.0/go.mod h1:NKdj5HkL/73byiZSJjqJgKn3ep7KjFkBOkR/Hps3VPw= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE= gonum.org/v1/plot v0.0.0-20190515093506-e2840ee46a6b h1:Qh4dB5D/WpoUUp3lSod7qgoyEHbDGPUWjIbnqdqqe1k= google.golang.org/api v0.139.0 h1:A1TrCPgMmOiYu0AiNkvQIpIx+D8blHTDcJ5EogkP7LI= diff --git a/internal/tools/go.mod b/internal/tools/go.mod index 06016e100d8..ee000214d73 100644 --- a/internal/tools/go.mod +++ b/internal/tools/go.mod @@ -1,8 +1,8 @@ module github.com/uber/cadence/internal/tools -go 1.22 +go 1.24 -toolchain go1.23.4 +toolchain go1.24.7 require ( github.com/daixiang0/gci v0.12.0 @@ -10,11 +10,11 @@ require ( github.com/gogo/protobuf v1.3.2 github.com/hexdigest/gowrap v1.2.5 github.com/mgechev/revive v1.3.2 - github.com/vektra/mockery/v2 v2.32.0 - go.uber.org/mock v0.5.0 + github.com/vektra/mockery/v3 v3.5.4 + go.uber.org/mock v0.6.0 go.uber.org/thriftrw v1.29.2 go.uber.org/yarpc v1.70.3 - golang.org/x/tools v0.22.0 + golang.org/x/tools v0.36.0 ) require ( @@ -66,6 +66,7 @@ require ( github.com/bombsimon/wsl/v3 v3.3.0 // indirect github.com/breml/bidichk v0.2.3 // indirect github.com/breml/errchkjson v0.3.0 // indirect + github.com/brunoga/deep v1.2.4 // indirect github.com/butuzov/ireturn v0.1.1 // indirect github.com/caarlos0/ctrlc v1.0.0 // indirect github.com/caarlos0/env/v6 v6.6.2 // indirect @@ -76,9 +77,8 @@ require ( github.com/cespare/xxhash/v2 v2.2.0 // indirect github.com/charithe/durationcheck v0.0.9 // indirect github.com/chavacava/garif v0.0.0-20230227094218-b8c73b2037b8 // indirect - github.com/chigopher/pathlib v0.15.0 // indirect - github.com/cpuguy83/go-md2man/v2 v2.0.2 // indirect - github.com/davecgh/go-spew v1.1.1 // indirect + github.com/cpuguy83/go-md2man/v2 v2.0.4 // indirect + github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/denis-tingaikin/go-header v0.4.3 // indirect github.com/dghubble/go-twitter v0.0.0-20201011215211-4b180d0cc78d // indirect github.com/dghubble/oauth1 v0.7.0 // indirect @@ -88,10 +88,12 @@ require ( github.com/esimonov/ifshort v1.0.4 // indirect github.com/ettle/strcase v0.1.1 // indirect github.com/fatih/color v1.15.0 // indirect + github.com/fatih/structs v1.1.0 // indirect github.com/fatih/structtag v1.2.0 // indirect github.com/firefart/nonamedreturns v1.0.1 // indirect github.com/form3tech-oss/jwt-go v3.2.2+incompatible // indirect - github.com/fsnotify/fsnotify v1.6.0 // indirect + github.com/frankban/quicktest v1.14.4 // indirect + github.com/fsnotify/fsnotify v1.8.0 // indirect github.com/fzipp/gocyclo v0.5.1 // indirect github.com/go-critic/go-critic v0.6.3 // indirect github.com/go-git/gcfg v1.5.0 // indirect @@ -104,6 +106,7 @@ require ( github.com/go-toolsmith/astp v1.0.0 // indirect github.com/go-toolsmith/strparse v1.0.0 // indirect github.com/go-toolsmith/typep v1.0.2 // indirect + github.com/go-viper/mapstructure/v2 v2.3.0 // indirect github.com/go-xmlfmt/xmlfmt v0.0.0-20191208150333-d5b6f63a941b // indirect github.com/gobwas/glob v0.2.3 // indirect github.com/gofrs/flock v0.8.1 // indirect @@ -143,15 +146,14 @@ require ( github.com/hashicorp/go-version v1.4.0 // indirect github.com/hashicorp/hcl v1.0.0 // indirect github.com/hexops/gotextdiff v1.0.3 // indirect - github.com/huandu/xstrings v1.3.2 // indirect - github.com/iancoleman/strcase v0.2.0 // indirect + github.com/huandu/xstrings v1.5.0 // indirect github.com/imdario/mergo v0.3.15 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 // indirect + github.com/jedib0t/go-pretty/v6 v6.6.7 // indirect github.com/jessevdk/go-flags v1.5.0 // indirect github.com/jgautheron/goconst v1.5.1 // indirect github.com/jingyugao/rowserrcheck v1.1.1 // indirect - github.com/jinzhu/copier v0.3.5 // indirect github.com/jirfag/go-printf-func-name v0.0.0-20200119135958-7558a9eaa5af // indirect github.com/jmespath/go-jmespath v0.4.0 // indirect github.com/julz/importas v0.1.0 // indirect @@ -160,6 +162,13 @@ require ( github.com/kisielk/gotool v1.0.0 // indirect github.com/klauspost/compress v1.16.5 // indirect github.com/klauspost/pgzip v1.2.6 // indirect + github.com/knadh/koanf/maps v0.1.2 // indirect + github.com/knadh/koanf/parsers/yaml v0.1.0 // indirect + github.com/knadh/koanf/providers/env v1.0.0 // indirect + github.com/knadh/koanf/providers/file v1.1.2 // indirect + github.com/knadh/koanf/providers/posflag v0.1.0 // indirect + github.com/knadh/koanf/providers/structs v0.1.0 // indirect + github.com/knadh/koanf/v2 v2.2.1 // indirect github.com/kulti/thelper v0.6.2 // indirect github.com/kunwardeep/paralleltest v1.0.3 // indirect github.com/kyoh86/exportloopref v0.1.8 // indirect @@ -172,8 +181,8 @@ require ( github.com/matoous/godox v0.0.0-20210227103229-6504466cf951 // indirect github.com/mattn/go-colorable v0.1.13 // indirect github.com/mattn/go-ieproxy v0.0.1 // indirect - github.com/mattn/go-isatty v0.0.17 // indirect - github.com/mattn/go-runewidth v0.0.9 // indirect + github.com/mattn/go-isatty v0.0.20 // indirect + github.com/mattn/go-runewidth v0.0.16 // indirect github.com/matttproud/golang_protobuf_extensions v1.0.2-0.20181231171920-c182affec369 // indirect github.com/mbilski/exhaustivestruct v1.2.0 // indirect github.com/mgechev/dots v0.0.0-20210922191527-e955255bf517 // indirect @@ -192,7 +201,7 @@ require ( github.com/pelletier/go-toml/v2 v2.0.6 // indirect github.com/phayes/checkstyle v0.0.0-20170904204023-bfd46e6a821d // indirect github.com/pkg/errors v0.9.1 // indirect - github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/polyfloyd/go-errorlint v1.0.0 // indirect github.com/prometheus/client_golang v1.12.1 // indirect github.com/prometheus/client_model v0.2.0 // indirect @@ -202,7 +211,8 @@ require ( github.com/quasilyte/gogrep v0.0.0-20220120141003-628d8b3623b5 // indirect github.com/quasilyte/regex/syntax v0.0.0-20200407221936-30656e2c4a95 // indirect github.com/quasilyte/stdinfo v0.0.0-20220114132959-f7386bf02567 // indirect - github.com/rs/zerolog v1.29.0 // indirect + github.com/rivo/uniseg v0.4.7 // indirect + github.com/rs/zerolog v1.33.0 // indirect github.com/russross/blackfriday/v2 v2.1.0 // indirect github.com/ryancurrah/gomodguard v1.2.3 // indirect github.com/ryanrolds/sqlclosecheck v0.3.0 // indirect @@ -218,14 +228,14 @@ require ( github.com/sourcegraph/go-diff v0.6.1 // indirect github.com/spf13/afero v1.9.3 // indirect github.com/spf13/cast v1.5.0 // indirect - github.com/spf13/cobra v1.7.0 // indirect + github.com/spf13/cobra v1.8.1 // indirect github.com/spf13/jwalterweatherman v1.1.0 // indirect github.com/spf13/pflag v1.0.5 // indirect github.com/spf13/viper v1.15.0 // indirect github.com/ssgreg/nlreturn/v2 v2.2.1 // indirect github.com/stbenjam/no-sprintf-host-port v0.1.1 // indirect github.com/stretchr/objx v0.5.2 // indirect - github.com/stretchr/testify v1.9.0 // indirect + github.com/stretchr/testify v1.10.0 // indirect github.com/subosito/gotenv v1.4.2 // indirect github.com/sylvia7788/contextcheck v1.0.4 // indirect github.com/tdakkota/asciicheck v0.1.1 // indirect @@ -239,6 +249,9 @@ require ( github.com/uudashr/gocognit v1.0.5 // indirect github.com/xanzy/go-gitlab v0.50.0 // indirect github.com/xanzy/ssh-agent v0.3.1 // indirect + github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f // indirect + github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect + github.com/xeipuuv/gojsonschema v1.2.0 // indirect github.com/yagipy/maintidx v1.0.0 // indirect github.com/yeya24/promlinter v0.2.0 // indirect gitlab.com/bosi/decorder v0.2.1 // indirect @@ -249,16 +262,19 @@ require ( go.uber.org/multierr v1.11.0 // indirect go.uber.org/zap v1.24.0 // indirect gocloud.dev v0.23.0 // indirect - golang.org/x/crypto v0.24.0 // indirect + golang.org/x/crypto v0.41.0 // indirect + golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 // indirect golang.org/x/exp/typeparams v0.0.0-20220218215828-6cf2b201936e // indirect - golang.org/x/mod v0.18.0 // indirect - golang.org/x/net v0.26.0 // indirect + golang.org/x/mod v0.27.0 // indirect + golang.org/x/net v0.43.0 // indirect golang.org/x/oauth2 v0.7.0 // indirect - golang.org/x/sync v0.7.0 // indirect - golang.org/x/sys v0.21.0 // indirect - golang.org/x/term v0.21.0 // indirect - golang.org/x/text v0.16.0 // indirect + golang.org/x/sync v0.16.0 // indirect + golang.org/x/sys v0.35.0 // indirect + golang.org/x/term v0.34.0 // indirect + golang.org/x/text v0.28.0 // indirect golang.org/x/time v0.1.0 // indirect + golang.org/x/tools/go/expect v0.1.1-deprecated // indirect + golang.org/x/tools/go/packages/packagestest v0.1.1-deprecated // indirect golang.org/x/xerrors v0.0.0-20220907171357-04be3eba64a2 // indirect google.golang.org/api v0.114.0 // indirect google.golang.org/appengine v1.6.7 // indirect diff --git a/internal/tools/go.sum b/internal/tools/go.sum index a95619a6621..f0b6c2b1594 100644 --- a/internal/tools/go.sum +++ b/internal/tools/go.sum @@ -240,6 +240,8 @@ github.com/breml/bidichk v0.2.3 h1:qe6ggxpTfA8E75hdjWPZ581sY3a2lnl0IRxLQFelECI= github.com/breml/bidichk v0.2.3/go.mod h1:8u2C6DnAy0g2cEq+k/A2+tr9O1s+vHGxWn0LTc70T2A= github.com/breml/errchkjson v0.3.0 h1:YdDqhfqMT+I1vIxPSas44P+9Z9HzJwCeAzjB8PxP1xw= github.com/breml/errchkjson v0.3.0/go.mod h1:9Cogkyv9gcT8HREpzi3TiqBxCqDzo8awa92zSDFcofU= +github.com/brunoga/deep v1.2.4 h1:Aj9E9oUbE+ccbyh35VC/NHlzzjfIVU69BXu2mt2LmL8= +github.com/brunoga/deep v1.2.4/go.mod h1:GDV6dnXqn80ezsLSZ5Wlv1PdKAWAO4L5PnKYtv2dgaI= github.com/butuzov/ireturn v0.1.1 h1:QvrO2QF2+/Cx1WA/vETCIYBKtRjc30vesdoPUNo1EbY= github.com/butuzov/ireturn v0.1.1/go.mod h1:Wh6Zl3IMtTpaIKbmwzqi6olnM9ptYQxxVacMsOEFPoc= github.com/caarlos0/ctrlc v1.0.0 h1:2DtF8GSIcajgffDFJzyG15vO+1PuBWOMUdFut7NnXhw= @@ -272,8 +274,6 @@ github.com/charithe/durationcheck v0.0.9 h1:mPP4ucLrf/rKZiIG/a9IPXHGlh8p4CzgpyTy github.com/charithe/durationcheck v0.0.9/go.mod h1:SSbRIBVfMjCi/kEB6K65XEA83D6prSM8ap1UCpNKtgg= github.com/chavacava/garif v0.0.0-20230227094218-b8c73b2037b8 h1:W9o46d2kbNL06lq7UNDPV0zYLzkrde/bjIqO02eoll0= github.com/chavacava/garif v0.0.0-20230227094218-b8c73b2037b8/go.mod h1:gakxgyXaaPkxvLw1XQxNGK4I37ys9iBRzNUx/B7pUCo= -github.com/chigopher/pathlib v0.15.0 h1:1pg96WL3iC1/YyWV4UJSl3E0GBf4B+h5amBtsbAAieY= -github.com/chigopher/pathlib v0.15.0/go.mod h1:3+YPPV21mU9vyw8Mjp+F33CyCfE6iOzinpiqBcccv7I= github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI= github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI= github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU= @@ -301,22 +301,23 @@ github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7 github.com/coreos/go-systemd v0.0.0-20190620071333-e64a0ec8b42a/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= github.com/coreos/go-systemd/v22 v22.3.1/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= github.com/coreos/go-systemd/v22 v22.3.2/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= -github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= +github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc= github.com/coreos/pkg v0.0.0-20160727233714-3ac0863d7acf/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA= github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA= github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE= github.com/cpuguy83/go-md2man/v2 v2.0.0-20190314233015-f79a8a8ca69d/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= github.com/cpuguy83/go-md2man/v2 v2.0.0/go.mod h1:maD7wRr/U5Z6m/iR4s+kqSMx2CaBsrgA7czyZG/E6dU= -github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w= -github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= +github.com/cpuguy83/go-md2man/v2 v2.0.4 h1:wfIWP927BUkWJb2NmU/kNDYIBTh/ziUX91+lVfRxZq4= +github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o= github.com/creack/pty v1.1.7/go.mod h1:lj5s0c3V2DBrqTV7llrYr5NG6My20zk30Fl46Y7DoTY= github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/daixiang0/gci v0.12.0 h1:EQTG7FfKPlO4Ste+oN0kvz+gP4XswKx29D4fLrmwbiU= github.com/daixiang0/gci v0.12.0/go.mod h1:xtHP9N7AHdNvtRNfcx9gwTDfw7FRJx4bZUsiEfiNNAI= github.com/davecgh/go-spew v0.0.0-20161028175848-04cdfd42973b/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= 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= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= +github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/denis-tingaikin/go-header v0.4.3 h1:tEaZKAlqql6SKCY++utLmkPLd6K8IBM20Ha7UVm+mtU= github.com/denis-tingaikin/go-header v0.4.3/go.mod h1:0wOCWuN71D5qIgE2nz9KrKmuYBAC2Mra5RassOIQ2/c= github.com/denisenkom/go-mssqldb v0.9.0/go.mod h1:xbL0rPBG9cCiLr28tMa8zpbdarY27NDyej4t/EjAShU= @@ -360,6 +361,8 @@ github.com/fatih/color v1.12.0/go.mod h1:ELkj/draVOlAH/xkhN6mQ50Qd0MPOk5AAr3maGE github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk= github.com/fatih/color v1.15.0 h1:kOqh6YHBtK8aywxGerMG2Eq3H6Qgoqeo13Bk2Mv/nBs= github.com/fatih/color v1.15.0/go.mod h1:0h5ZqXfHYED7Bhv2ZJamyIOUej9KtShiJESRwBDUSsw= +github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo= +github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M= github.com/fatih/structtag v1.0.0/go.mod h1:IKitwq45uXL/yqi5mYghiD3w9H6eTOvI9vnk8tXMphA= github.com/fatih/structtag v1.2.0 h1:/OdNE99OxoI/PqaW/SuSK9uxxT3f/tcSZgon/ssNSx4= github.com/fatih/structtag v1.2.0/go.mod h1:mBJUNpUnHmRKrKlQQlmCrh5PuhftFbNv8Ys4/aAZl94= @@ -376,8 +379,8 @@ github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMo github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= github.com/fsnotify/fsnotify v1.5.1/go.mod h1:T3375wBYaZdLLcVNkcVbzGHY7f1l/uK5T5Ai1i3InKU= github.com/fsnotify/fsnotify v1.5.4/go.mod h1:OVB6XrOHzAwXMpEM7uPOzcehqUV2UqJxmVXmkdnm1bU= -github.com/fsnotify/fsnotify v1.6.0 h1:n+5WquG0fcWoWp6xPWfHdbskMCQaFnG6PfBrh1Ky4HY= -github.com/fsnotify/fsnotify v1.6.0/go.mod h1:sl3t1tCWJFWoRz9R8WJCbQihKKwmorjAbSClcnxKAGw= +github.com/fsnotify/fsnotify v1.8.0 h1:dAwr6QBTBZIkG8roQaJjGof0pp0EeF+tNV7YBP3F/8M= +github.com/fsnotify/fsnotify v1.8.0/go.mod h1:8jBTzvmWwFyi3Pb8djgCCO5IBqzKJ/Jwo8TRcHyHii0= github.com/fullstorydev/grpcurl v1.6.0/go.mod h1:ZQ+ayqbKMJNhzLmbpCiurTVlaK2M/3nqZCxaQ2Ze/sM= github.com/fzipp/gocyclo v0.5.1 h1:L66amyuYogbxl0j2U+vGqJXusPF2IkduvXLnYD5TFgw= github.com/fzipp/gocyclo v0.5.1/go.mod h1:rXPyn8fnlpa0R2csP/31uerbiVBugk5whMdlyaLkLoA= @@ -436,6 +439,8 @@ github.com/go-toolsmith/strparse v1.0.0 h1:Vcw78DnpCAKlM20kSbAyO4mPfJn/lyYA4BJUD github.com/go-toolsmith/strparse v1.0.0/go.mod h1:YI2nUKP9YGZnL/L1/DLFBfixrcjslWct4wyljWhSRy8= github.com/go-toolsmith/typep v1.0.2 h1:8xdsa1+FSIH/RhEkgnD1j2CJOy5mNllW1Q9tRiYwvlk= github.com/go-toolsmith/typep v1.0.2/go.mod h1:JSQCQMUPdRlMZFswiq3TGpNp1GMktqkR2Ns5AIQkATU= +github.com/go-viper/mapstructure/v2 v2.3.0 h1:27XbWsHIqhbdR5TIC911OfYvgSaW93HM+dX7970Q7jk= +github.com/go-viper/mapstructure/v2 v2.3.0/go.mod h1:oJDH3BJKyqBA2TXFhDsKDGDTlndYOZ6rGS0BRZIxGhM= github.com/go-xmlfmt/xmlfmt v0.0.0-20191208150333-d5b6f63a941b h1:khEcpUM4yFcxg4/FHQWkvVRmgijNXRfzkIDHh23ggEo= github.com/go-xmlfmt/xmlfmt v0.0.0-20191208150333-d5b6f63a941b/go.mod h1:aUCEOzzezBEjDBbFBoSiya/gduyIiWYRP6CnSFIV8AM= github.com/gobwas/glob v0.2.3 h1:A4xDbljILXROh+kObIiy5kIaPYD8e96x1tgBhUI5J+Y= @@ -538,6 +543,7 @@ github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/ github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.5.7/go.mod h1:n+brtR0CgQNWTVd5ZUFpTBC8YFBDLK/h/bpaJ8/DtOE= +github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/google/go-github/v35 v35.2.0 h1:s/soW8jauhjUC3rh8JI0FePuocj0DEI9DNBg/bVplE8= @@ -702,10 +708,9 @@ github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpO github.com/huandu/xstrings v1.0.0/go.mod h1:4qWG/gcEcfX4z/mBDHJ++3ReCw9ibxbsNJbcucJdbSo= github.com/huandu/xstrings v1.2.0/go.mod h1:DvyZB1rfVYsBIigL8HwpZgxHwXozlTgGqn63UyNX5k4= github.com/huandu/xstrings v1.3.1/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= -github.com/huandu/xstrings v1.3.2 h1:L18LIDzqlW6xN2rEkpdV8+oL/IXWJ1APd+vsdYy4Wdw= github.com/huandu/xstrings v1.3.2/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= -github.com/iancoleman/strcase v0.2.0 h1:05I4QRnGpI0m37iZQRuskXh+w77mr6Z41lwQzuHLwW0= -github.com/iancoleman/strcase v0.2.0/go.mod h1:iwCmte+B7n89clKwxIoIXy/HfoL7AsD47ZCWhYzw7ho= +github.com/huandu/xstrings v1.5.0 h1:2ag3IFq9ZDANvthTwTiqSSZLjDc+BedvHPAp5tJy2TI= +github.com/huandu/xstrings v1.5.0/go.mod h1:y5/lhBue+AyNmUVz9RLU9xbLR0o4KIIExikq4ovT0aE= github.com/ianlancetaylor/demangle v0.0.0-20181102032728-5e5cf60278f6/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/ianlancetaylor/demangle v0.0.0-20200824232613-28f6c0f3b639/go.mod h1:aSSvb/t6k1mPoxDqO4vJh6VOCGPwU4O0C2/Eqndh1Sc= github.com/imdario/mergo v0.3.4/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA= @@ -722,6 +727,8 @@ github.com/jarcoal/httpmock v1.0.8 h1:8kI16SoO6LQKgPE7PvQuV+YuD/inwHd7fOOe2zMbo4 github.com/jarcoal/httpmock v1.0.8/go.mod h1:ATjnClrvW/3tijVmpL/va5Z3aAyGvqU3gCT8nX0Txik= github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99 h1:BQSFePA1RWJOlocH6Fxy8MmwDt+yVQYULKfN0RoTN8A= github.com/jbenet/go-context v0.0.0-20150711004518-d14ea06fba99/go.mod h1:1lJo3i6rXxKeerYnT8Nvf0QmHCRC1n8sfWVwXF2Frvo= +github.com/jedib0t/go-pretty/v6 v6.6.7 h1:m+LbHpm0aIAPLzLbMfn8dc3Ht8MW7lsSO4MPItz/Uuo= +github.com/jedib0t/go-pretty/v6 v6.6.7/go.mod h1:YwC5CE4fJ1HFUDeivSV1r//AmANFHyqczZk+U6BDALU= github.com/jessevdk/go-flags v1.4.0/go.mod h1:4FA24M0QyGHXBuZZK/XkWh8h0e1EYbRYJSGM75WSRxI= github.com/jessevdk/go-flags v1.5.0 h1:1jKYvbxEjfUl0fmqTCOfonvskHHXMjBySTLW4y9LFvc= github.com/jessevdk/go-flags v1.5.0/go.mod h1:Fw0T6WPc1dYxT4mKEZRfG5kJhaTDP9pj1c2EWnYs/m4= @@ -730,8 +737,6 @@ github.com/jgautheron/goconst v1.5.1/go.mod h1:aAosetZ5zaeC/2EfMeRswtxUFBpe2Hr7H github.com/jhump/protoreflect v1.6.1/go.mod h1:RZQ/lnuN+zqeRVpQigTwO6o0AJUkxbnSnpuG7toUTG4= github.com/jingyugao/rowserrcheck v1.1.1 h1:zibz55j/MJtLsjP1OF4bSdgXxwL1b+Vn7Tjzq7gFzUs= github.com/jingyugao/rowserrcheck v1.1.1/go.mod h1:4yvlZSDb3IyDTUZJUmpZfm2Hwok+Dtp+nu2qOq+er9c= -github.com/jinzhu/copier v0.3.5 h1:GlvfUwHk62RokgqVNvYsku0TATCF7bAHVwEXoBh3iJg= -github.com/jinzhu/copier v0.3.5/go.mod h1:DfbEm0FYsaqBcKcFuvmOZb218JkPGtvSHsKg8S8hyyg= github.com/jirfag/go-printf-func-name v0.0.0-20200119135958-7558a9eaa5af h1:KA9BjwUk7KlCh6S9EAGWBt1oExIUv9WyNCiRz5amv48= github.com/jirfag/go-printf-func-name v0.0.0-20200119135958-7558a9eaa5af/go.mod h1:HEWGJkRDzjJY2sqdDwxccsGicWEf9BQOZsq2tV+xzM0= github.com/jmespath/go-jmespath v0.0.0-20160202185014-0b12d6b521d8/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k= @@ -780,6 +785,20 @@ github.com/klauspost/compress v1.16.5 h1:IFV2oUNUzZaz+XyusxpLzpzS8Pt5rh0Z16For/d github.com/klauspost/compress v1.16.5/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/knadh/koanf/maps v0.1.2 h1:RBfmAW5CnZT+PJ1CVc1QSJKf4Xu9kxfQgYVQSu8hpbo= +github.com/knadh/koanf/maps v0.1.2/go.mod h1:npD/QZY3V6ghQDdcQzl1W4ICNVTkohC8E73eI2xW4yI= +github.com/knadh/koanf/parsers/yaml v0.1.0 h1:ZZ8/iGfRLvKSaMEECEBPM1HQslrZADk8fP1XFUxVI5w= +github.com/knadh/koanf/parsers/yaml v0.1.0/go.mod h1:cvbUDC7AL23pImuQP0oRw/hPuccrNBS2bps8asS0CwY= +github.com/knadh/koanf/providers/env v1.0.0 h1:ufePaI9BnWH+ajuxGGiJ8pdTG0uLEUWC7/HDDPGLah0= +github.com/knadh/koanf/providers/env v1.0.0/go.mod h1:mzFyRZueYhb37oPmC1HAv/oGEEuyvJDA98r3XAa8Gak= +github.com/knadh/koanf/providers/file v1.1.2 h1:aCC36YGOgV5lTtAFz2qkgtWdeQsgfxUkxDOe+2nQY3w= +github.com/knadh/koanf/providers/file v1.1.2/go.mod h1:/faSBcv2mxPVjFrXck95qeoyoZ5myJ6uxN8OOVNJJCI= +github.com/knadh/koanf/providers/posflag v0.1.0 h1:mKJlLrKPcAP7Ootf4pBZWJ6J+4wHYujwipe7Ie3qW6U= +github.com/knadh/koanf/providers/posflag v0.1.0/go.mod h1:SYg03v/t8ISBNrMBRMlojH8OsKowbkXV7giIbBVgbz0= +github.com/knadh/koanf/providers/structs v0.1.0 h1:wJRteCNn1qvLtE5h8KQBvLJovidSdntfdyIbbCzEyE0= +github.com/knadh/koanf/providers/structs v0.1.0/go.mod h1:sw2YZ3txUcqA3Z27gPlmmBzWn1h8Nt9O6EP/91MkcWE= +github.com/knadh/koanf/v2 v2.2.1 h1:jaleChtw85y3UdBnI0wCqcg1sj1gPoz6D3caGNHtrNE= +github.com/knadh/koanf/v2 v2.2.1/go.mod h1:PSFru3ufQgTsI7IF+95rf9s8XA1+aHxKuO/W+dPoHEY= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= @@ -788,8 +807,8 @@ github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFB github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= -github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0= -github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= +github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= +github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= @@ -850,13 +869,15 @@ github.com/mattn/go-isatty v0.0.11/go.mod h1:PhnuNfih5lzO57/f3n+odYbM4JtupLOxQOA github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU= github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94= github.com/mattn/go-isatty v0.0.16/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= -github.com/mattn/go-isatty v0.0.17 h1:BTarxUcIeDqL27Mc+vyvdWYSL28zpIhv3RoTdsLMPng= -github.com/mattn/go-isatty v0.0.17/go.mod h1:kYGgaQfpe5nmfYZH+SKPsOc2e4SrIfOl2e/yFXSvRLM= +github.com/mattn/go-isatty v0.0.19/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= +github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY= +github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y= github.com/mattn/go-runewidth v0.0.2/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.4/go.mod h1:LwmH8dsx7+W8Uxz3IHJYH5QSwggIsqBzpuz5H//U1FU= github.com/mattn/go-runewidth v0.0.6/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= -github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0= github.com/mattn/go-runewidth v0.0.9/go.mod h1:H031xJmbD/WCDINGzjvQ9THkh0rPKHF+m2gUSrubnMI= +github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc= +github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w= github.com/mattn/go-shellwords v1.0.10/go.mod h1:EZzvwXDESEeg03EKmM+RmDnNOPKG4lLtQsUlTZDWQ8Y= github.com/mattn/go-sqlite3 v1.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= @@ -978,8 +999,9 @@ github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE github.com/pkg/sftp v1.10.1/go.mod h1:lYOWFsE0bwd1+KfKJaKeuokY15vzFx25BLbzYYoAxZI= github.com/pkg/sftp v1.13.1/go.mod h1:3HaPG6Dq1ILlpPZRO0HVMrsydcdLt6HRDccSgb87qRg= github.com/pmezard/go-difflib v0.0.0-20151028094244-d8ed2627bdf0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= +github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/polyfloyd/go-errorlint v1.0.0 h1:pDrQG0lrh68e602Wfp68BlUTRFoHn8PZYAjLgt2LFsM= github.com/polyfloyd/go-errorlint v1.0.0/go.mod h1:KZy4xxPJyy88/gldCe5OdW6OQRtNO3EZE7hXzmnebgA= github.com/posener/complete v1.1.1/go.mod h1:em0nMJCgc9GFtwrmVmEMR/ZL6WyhyjMBndrE9hABlRI= @@ -1036,16 +1058,21 @@ github.com/quasilyte/regex/syntax v0.0.0-20200407221936-30656e2c4a95 h1:L8QM9bvf github.com/quasilyte/regex/syntax v0.0.0-20200407221936-30656e2c4a95/go.mod h1:rlzQ04UMyJXu/aOvhd8qT+hvDrFpiwqp8MRXDY9szc0= github.com/quasilyte/stdinfo v0.0.0-20220114132959-f7386bf02567 h1:M8mH9eK4OUR4lu7Gd+PU1fV2/qnDNfzT635KRSObncs= github.com/quasilyte/stdinfo v0.0.0-20220114132959-f7386bf02567/go.mod h1:DWNGW8A4Y+GyBgPuaQJuWiy0XYftx4Xm/y5Jqk9I6VQ= +github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc= +github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ= +github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88= github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg= github.com/rogpeppe/fastuuid v1.1.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ= github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= -github.com/rogpeppe/go-internal v1.8.1 h1:geMPLpDpQOgVyCg5z5GoRwLHepNdb71NXb67XFkP+Eg= github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o= +github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= +github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M= +github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA= github.com/rs/cors v1.7.0/go.mod h1:gFx+x8UowdsKA9AchylcLynDq+nNFfI8FkUZdN/jGCU= -github.com/rs/xid v1.4.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= -github.com/rs/zerolog v1.29.0 h1:Zes4hju04hjbvkVkOhdl2HpZa+0PmVwigmo8XoORE5w= -github.com/rs/zerolog v1.29.0/go.mod h1:NILgTygv/Uej1ra5XxGf82ZFSLk58MFGAUS2o6usyD0= +github.com/rs/xid v1.5.0/go.mod h1:trrq9SKmegXys3aeAKXMUTdJsYXVwGY3RLcfgqegfbg= +github.com/rs/zerolog v1.33.0 h1:1cU2KZkvPxNyfgEmhHAz/1A9Bz+llsdYzklWFzgp0r8= +github.com/rs/zerolog v1.33.0/go.mod h1:/7mN4D5sKwJLZQ2b/znpjC3/GQWY/xaDXUM0kKWRHss= github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g= github.com/russross/blackfriday/v2 v2.0.1/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM= github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk= @@ -1114,8 +1141,8 @@ github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3 github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU= github.com/spf13/cobra v1.1.1/go.mod h1:WnodtKOvamDL/PwE2M4iKs8aMDBZ5Q5klgD3qfVJQMI= github.com/spf13/cobra v1.1.3/go.mod h1:pGADOWyqRD/YMrPZigI/zbliZ2wVD/23d+is3pSWzOo= -github.com/spf13/cobra v1.7.0 h1:hyqWnYt1ZQShIddO5kBpj3vu05/++x6tJ6dg8EC572I= -github.com/spf13/cobra v1.7.0/go.mod h1:uLxZILRyS/50WlhOIKD7W6V5bgeIt+4sICxh6uRMrb0= +github.com/spf13/cobra v1.8.1 h1:e5/vxKd/rZsfSJMUX1agtjeTDf+qv1/JdBF8gg5k9ZM= +github.com/spf13/cobra v1.8.1/go.mod h1:wHxEcudfqmLYa8iTfL+OuZPbBZkmvliBWKIezN3kD9Y= github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk= github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= @@ -1153,8 +1180,8 @@ github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/ github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= github.com/stretchr/testify v1.8.2/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4= -github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= -github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= +github.com/stretchr/testify v1.10.0 h1:Xv5erBjTwe/5IxqUQTdXv5kgmIvbHo3QQyRwhJsOfJA= +github.com/stretchr/testify v1.10.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/subosito/gotenv v1.2.0/go.mod h1:N0PQaV/YGNqwC0u51sEeR/aUtSLEXKX9iv69rRypqCw= github.com/subosito/gotenv v1.4.2 h1:X1TuBLAMDFbaTAChgCBLu3DU3UPyELpnF2jjJ2cz/S8= github.com/subosito/gotenv v1.4.2/go.mod h1:ayKnFf/c6rvx/2iiLrJUk1e6plDbT3edrFNGqEflhK0= @@ -1214,8 +1241,8 @@ github.com/urfave/cli v1.20.0/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijb github.com/urfave/cli v1.22.1/go.mod h1:Gos4lmkARVdJ6EkW0WaNv/tZAAMe9V7XWyB60NtXRu0= github.com/uudashr/gocognit v1.0.5 h1:rrSex7oHr3/pPLQ0xoWq108XMU8s678FJcQ+aSfOHa4= github.com/uudashr/gocognit v1.0.5/go.mod h1:wgYz0mitoKOTysqxTDMOUXg+Jb5SvtihkfmugIZYpEA= -github.com/vektra/mockery/v2 v2.32.0 h1:IXUoQ3s5VxJPpi95DECUmkRUXZ44I1spQ3YatEypIF4= -github.com/vektra/mockery/v2 v2.32.0/go.mod h1:9lREs4VEeQiUS3rizYQx1saxHu2JiIhThP0q9+fDegM= +github.com/vektra/mockery/v3 v3.5.4 h1:AqbLKhw+H3U5OBqEAcUilxRIcLwHfFKzTbLlyfEqx9o= +github.com/vektra/mockery/v3 v3.5.4/go.mod h1:6rmlzyACJQig1UFoUYyLMS/O+2aGz6BgKAO9C8t9/v0= github.com/viki-org/dnscache v0.0.0-20130720023526-c70c1f23c5d8/go.mod h1:dniwbG03GafCjFohMDmz6Zc6oCuiqgH6tGNyXTkHzXE= github.com/xanzy/go-gitlab v0.50.0 h1:t7IoYTrnLSbdEZN7d8X/5zcr+ZM4TZQ2mXa8MqWlAZQ= github.com/xanzy/go-gitlab v0.50.0/go.mod h1:Q+hQhV508bDPoBijv7YjK/Lvlb4PhVhJdKqXVQrUoAE= @@ -1223,6 +1250,12 @@ github.com/xanzy/ssh-agent v0.2.1/go.mod h1:mLlQY/MoOhWBj+gOGMQkOeiEvkx+8pJSI+0B github.com/xanzy/ssh-agent v0.3.0/go.mod h1:3s9xbODqPuuhK9JV1R321M/FlMZSBvE5aY6eAcqrDh0= github.com/xanzy/ssh-agent v0.3.1 h1:AmzO1SSWxw73zxFZPRwaMN1MohDw8UyHnmuxyceTEGo= github.com/xanzy/ssh-agent v0.3.1/go.mod h1:QIE4lCeL7nkC25x+yA3LBIYfwCc1TFziCtG7cBAac6w= +github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f h1:J9EGpcZtP0E/raorCMxlFGSTBrsSlaDGf3jU/qvAE2c= +github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU= +github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0= +github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= +github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74= +github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8 h1:nIPpBwaJSVYIxUFsDv3M8ofmx9yWTog9BfvIu0q41lo= github.com/xi2/xz v0.0.0-20171230120015-48954b6210f8/go.mod h1:HUYIGzjTL3rfEspMxjDjgmT5uz5wzYJKVo23qUhYTos= github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= @@ -1283,8 +1316,8 @@ go.uber.org/goleak v0.10.0/go.mod h1:VCZuO8V8mFPlL0F5J5GK1rtHV3DrFcQ1R8ryq7FK0aI go.uber.org/goleak v1.0.0/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= go.uber.org/goleak v1.1.11 h1:wy28qYRKZgnJTxGxvye5/wgWr1EKjmUDGYox5mGlRlI= go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= -go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU= -go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM= +go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= +go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= go.uber.org/multierr v1.4.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= @@ -1336,8 +1369,8 @@ golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5y golang.org/x/crypto v0.0.0-20211108221036-ceb1ce70b4fa/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc= golang.org/x/crypto v0.0.0-20220313003712-b769efc7c000/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= golang.org/x/crypto v0.0.0-20220411220226-7b82a4e95df4/go.mod h1:IxCIyHEi3zRg3s0A5j5BB6A9Jmi73HwBIUl50j+osU4= -golang.org/x/crypto v0.24.0 h1:mnl8DM0o513X8fdIkmyFE/5hTYxbwYOjDS/+rK6qpRI= -golang.org/x/crypto v0.24.0/go.mod h1:Z1PMYSOR5nyMcyAVAIQSKCDwalqy85Aqn1x3Ws4L5DM= +golang.org/x/crypto v0.41.0 h1:WKYxWedPGCTVVl5+WHSSrOBT0O8lx32+zxmHxijgXp4= +golang.org/x/crypto v0.41.0/go.mod h1:pO5AFd7FA68rFak7rOAGVuygIISepHftHnr8dr6+sUc= golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190306152737-a1d7652674e8/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA= golang.org/x/exp v0.0.0-20190510132918-efd6b22b2522/go.mod h1:ZjyILWgesfNpC6sMxTJOJm9Kp84zZh5NQWvqDGG3Qr8= @@ -1350,6 +1383,8 @@ golang.org/x/exp v0.0.0-20200119233911-0405dc783f0a/go.mod h1:2RIsYlXP63K8oxa1u0 golang.org/x/exp v0.0.0-20200207192155-f17229e696bd/go.mod h1:J/WKrq2StrnmMY6+EHIKF9dgMWnmCNThgcyBT1FY9mM= golang.org/x/exp v0.0.0-20200224162631-6cc2880d07d6/go.mod h1:3jZMyOhIsHpP37uCMkUooju7aAi5cS1Q23tOzKc+0MU= golang.org/x/exp v0.0.0-20200331195152-e8c3332aa8e5/go.mod h1:4M0jN8W1tt0AVLNr8HDosyJCDCDuyL9N9+3m7wDWgKw= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56 h1:2dVuKD2vS7b0QIHQbpyTISPd0LeHDbnYEryqj5Q1ug8= +golang.org/x/exp v0.0.0-20240719175910-8a7402abbf56/go.mod h1:M4RDyNAINzryxdtnbRXRL/OHtkFuWGRjvuhBJpk2IlY= golang.org/x/exp/typeparams v0.0.0-20220218215828-6cf2b201936e h1:qyrTQ++p1afMkO4DPEeLGq/3oTsdlvdH4vqZUBWzUKM= golang.org/x/exp/typeparams v0.0.0-20220218215828-6cf2b201936e/go.mod h1:AbB0pIl9nAr9wVwH+Z2ZpaocVmF5I4GyWCDIsVjR0bk= golang.org/x/image v0.0.0-20190227222117-0694c2d4d067/go.mod h1:kZ7UVZpmo3dzQBMxlp+ypCbDeSB+sBbTgSJuh5dn5js= @@ -1383,8 +1418,8 @@ golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0= -golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ= +golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -1446,8 +1481,8 @@ golang.org/x/net v0.0.0-20220127200216-cd36cc0744dd/go.mod h1:CfG3xpIq0wQ8r1q4Su golang.org/x/net v0.0.0-20220225172249-27dd8689420f/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220325170049-de3da57026de/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= golang.org/x/net v0.0.0-20220412020605-290c469a71a5/go.mod h1:CfG3xpIq0wQ8r1q4Su4UZFWDARRcnwPjda9FqA0JpMk= -golang.org/x/net v0.26.0 h1:soB7SVo0PWrY4vPW/+ay0jKDNScG2X9wFeYlXIvJsOQ= -golang.org/x/net v0.26.0/go.mod h1:5YKkiSynbBIh3p6iOc/vibscux0x38BZDkn8sCUPxHE= +golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE= +golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20181106182150-f42d05182288/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -1485,8 +1520,8 @@ golang.org/x/sync v0.0.0-20200625203802-6e8e738ad208/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.7.0 h1:YsImfSBoP9QPYL0xyKJPq0gcaJdG3rInoqxTWbfQu9M= -golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk= +golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw= +golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= golang.org/x/sys v0.0.0-20180823144017-11551d06cbcc/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -1594,14 +1629,15 @@ golang.org/x/sys v0.0.0-20220328115105-d36c6a25d886/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20220412211240-33da011f77ad/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220422013727-9388b58f7150/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.0.0-20220908164124-27713097b956/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.21.0 h1:rF+pYz3DAGSQAxAu1CbC7catZg4ebC4UIeIhKxBZvws= -golang.org/x/sys v0.21.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= +golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI= +golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= golang.org/x/term v0.0.0-20201117132131-f5c789dd3221/go.mod h1:Nr5EML6q2oocZ2LXRh80K7BxOlk5/8JxuGnuhpl+muw= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8= -golang.org/x/term v0.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA= -golang.org/x/term v0.21.0/go.mod h1:ooXLefLobQVslOqselCNF4SxFAaoS6KujMbsGzSDmX0= +golang.org/x/term v0.34.0 h1:O/2T7POpk0ZZ7MAzMeWFSg6S5IpWd/RXDlM9hgM3DR4= +golang.org/x/term v0.34.0/go.mod h1:5jC53AEywhIVebHgPVeg0mj8OD3VO9OzclacVrqpaAw= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -1611,8 +1647,8 @@ golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.16.0 h1:a94ExnEXNtEwYLGJSIUxnWoxoRz/ZcCsV63ROupILh4= -golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI= +golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng= +golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU= golang.org/x/time v0.0.0-20180412165947-fbb02b2291d2/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= @@ -1727,8 +1763,12 @@ golang.org/x/tools v0.1.9-0.20211228192929-ee1ca4ffc4da/go.mod h1:nABZi5QlRsZVlz golang.org/x/tools v0.1.9/go.mod h1:nABZi5QlRsZVlzPpHl034qft6wpY4eDcsTt5AaioBiU= golang.org/x/tools v0.1.10/go.mod h1:Uh6Zz+xoGYZom868N8YTex3t7RhtHDBrE8Gzo9bV56E= golang.org/x/tools v0.1.11-0.20220513221640-090b14e8501f/go.mod h1:SgwaegtQh8clINPpECJMqnxLv9I09HLqnW3RMqW0CA4= -golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA= -golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c= +golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg= +golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s= +golang.org/x/tools/go/expect v0.1.1-deprecated h1:jpBZDwmgPhXsKZC6WhL20P4b/wmnpsEAGHaNy0n/rJM= +golang.org/x/tools/go/expect v0.1.1-deprecated/go.mod h1:eihoPOH+FgIqa3FpoTwguz/bVUSGBlGQU67vpBeOrBY= +golang.org/x/tools/go/packages/packagestest v0.1.1-deprecated h1:1h2MnaIAIXISqTFKdENegdpAgUXz6NrPEsbIeWaBRvM= +golang.org/x/tools/go/packages/packagestest v0.1.1-deprecated/go.mod h1:RVAQXBGNv1ib0J382/DPCRS/BPnsGebyM1Gj5VSDpG8= 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= diff --git a/internal/tools/go.work b/internal/tools/go.work index faccf112027..6989e98e602 100644 --- a/internal/tools/go.work +++ b/internal/tools/go.work @@ -1,6 +1,4 @@ -go 1.22 - -toolchain go1.23.4 +go 1.24 // this go.work file ensures that the root go.work DOES NOT // automatically include dependencies in tools, as otherwise it tries diff --git a/internal/tools/go.work.sum b/internal/tools/go.work.sum index a65cfb62d41..a362e4830f5 100644 --- a/internal/tools/go.work.sum +++ b/internal/tools/go.work.sum @@ -124,7 +124,6 @@ cloud.google.com/go/lifesciences v0.8.0 h1:uWrMjWTsGjLZpCTWEAzYvyXj+7fhiZST45u9A cloud.google.com/go/lifesciences v0.8.0/go.mod h1:lFxiEOMqII6XggGbOnKiyZ7IBwoIqA84ClvoezaA/bo= cloud.google.com/go/logging v1.7.0 h1:CJYxlNNNNAMkHp9em/YEXcfJg+rPDg7YfwoRpMU+t5I= cloud.google.com/go/logging v1.7.0/go.mod h1:3xjP2CjkM3ZkO73aj4ASA5wRPGGCRrPIAeNqVNkzY8M= -cloud.google.com/go/longrunning v0.4.1/go.mod h1:4iWDqhBZ70CvZ6BfETbvam3T8FMvLK+eFj0E6AaRQTo= cloud.google.com/go/managedidentities v1.5.0 h1:ZRQ4k21/jAhrHBVKl/AY7SjgzeJwG1iZa+mJ82P+VNg= cloud.google.com/go/managedidentities v1.5.0/go.mod h1:+dWcZ0JlUmpuxpIDfyP5pP5y0bLdRwOS4Lp7gMni/LA= cloud.google.com/go/maps v0.7.0 h1:mv9YaczD4oZBZkM5XJl6fXQ984IkJNHPwkc8MUsdkBo= @@ -242,10 +241,8 @@ github.com/Azure/azure-service-bus-go v0.10.11 h1:GBg2mcLQA3af+w+ZuYhiAv58OWSVmQ github.com/Azure/go-amqp v0.13.7 h1:ukcCtx138ZmOfHbdALuh9yoJhGtOY3+yaKApfzNvhSk= github.com/BurntSushi/xgb v0.0.0-20160522181843-27f122750802 h1:1BDTz0u9nC3//pOCMdNH+CiXJVYJh5UQNCOBG7jbELc= github.com/DataDog/datadog-go v3.2.0+incompatible h1:qSG2N4FghB1He/r2mFrWKCaL7dXCilEuNEeAn20fdD4= -github.com/DataDog/zstd v1.4.5/go.mod h1:1jcaCB/ufaK+sKp1NBhlGmpz41jOoPQ35bpF36t7BBo= github.com/GoogleCloudPlatform/cloudsql-proxy v1.22.0 h1:aTDBS16pX1X4ZR/GFsC2NcOCYJ1hDJwJm3WmKRA905Q= github.com/OneOfOne/xxhash v1.2.2 h1:KMrpdQIwFcEqXDklaen+P1axHaj9BSKzvpUUfnHldSE= -github.com/ProtonMail/gopenpgp/v2 v2.2.2/go.mod h1:ajUlBGvxMH1UBZnaYO3d1FSVzjiC6kK9XlZYGiDCvpM= github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751 h1:JYp7IbQjafoB+tBA3gMyHYHrpOtNuDiK/uB5uXxq5wM= github.com/alecthomas/units v0.0.0-20190924025748-f65c72e2690d h1:UQZhZ2O0vMHr2cI+DC1Mbh0TJxzA3RcLoMsFw+aXw7E= github.com/antihax/optional v1.0.0 h1:xK2lYat7ZLaVVcIuj82J8kIro4V6kDe0AUDFboUCwcg= @@ -260,11 +257,9 @@ github.com/armon/go-metrics v0.4.0 h1:yCQqn7dwca4ITXb+CbubHmedzaQYHhNhrEXLYUeEe8 github.com/armon/go-metrics v0.4.0/go.mod h1:E6amYzXo6aW1tqzoZGT755KkbgrJsSdpwZ+3JqfkOG4= github.com/armon/go-radix v1.0.0 h1:F4z6KzEeeQIMeLFa97iZU6vupzoecKdU5TX24SNppXI= github.com/aybabtme/rgbterm v0.0.0-20170906152045-cc83f3b3ce59 h1:WWB576BN5zNSZc/M9d/10pqEx5VHNhaQ/yOVAkmj5Yo= -github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA= github.com/bgentry/speakeasy v0.1.0 h1:ByYyxL9InA1OWqxJqqp2A5pYHUrCiAL6K3J+LKSsQkY= github.com/bketelsen/crypt v0.0.3-0.20200106085610-5cbc8cc4026c h1:+0HFd5KSZ/mm3JmhmrDukiId5iR6w4+BdFtfSy4yWIc= github.com/bmizerany/perks v0.0.0-20141205001514-d9a9656a3a4b h1:AP/Y7sqYicnjGDfD5VcY4CIfh1hRXBUavxrvELjTiOE= -github.com/caarlos0/go-rpmutils v0.2.1-0.20211112020245-2cd62ff89b11/go.mod h1:je2KZ+LxaCNvCoKg32jtOIULcFogJKcL1ZWUaIBjKj0= github.com/cactus/go-statsd-client/statsd v0.0.0-20191106001114-12b4e2b38748 h1:bXxS5/Z3/dfc8iFniQfgogNBomo0u+1//9eP+jl8GVo= github.com/cavaliercoder/go-cpio v0.0.0-20180626203310-925f9528c45e h1:hHg27A0RSSp2Om9lubZpiMgVbvn39bsUmW9U5h0twqc= github.com/census-instrumentation/opencensus-proto v0.4.1 h1:iKLQ0xPNFxR/2hzXZMrBo8f1j86j5WHzznCCQxV/b8g= @@ -288,6 +283,7 @@ github.com/coreos/go-etcd v2.0.0+incompatible h1:bXhRBIXoTm9BYHS3gE0TtQuyNZyeEMu github.com/coreos/go-semver v0.3.0 h1:wkHLiw0WNATZnSG7epLsujiMCgPAc9xhjJ4tgnAxmfM= github.com/coreos/go-systemd v0.0.0-20190620071333-e64a0ec8b42a h1:W8b4lQ4tFF21aspRGoBuCNV6V2fFJBF+pm1J6OY8Lys= github.com/coreos/go-systemd/v22 v22.3.3-0.20220203105225-a9a7ef127534 h1:rtAn27wIbmOGUs7RIbVgPEjb31ehTVniDwPGXyMxm5U= +github.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs= github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f h1:lBNOc5arjvs8E5mO2tbpBpLoyyu8B6e44T7hJy6potg= github.com/cpuguy83/go-md2man v1.0.10 h1:BSKMNlYxDvnunlTymqtgONjNnaRV1sTpcovwwjF22jk= github.com/creack/pty v1.1.9 h1:uDmaGzcdjhF4i/plgjmEsriH11Y0o7RKapEf/LDaM3w= @@ -303,8 +299,9 @@ github.com/envoyproxy/go-control-plane v0.11.1-0.20230524094728-9239064ad72f h1: github.com/envoyproxy/go-control-plane v0.11.1-0.20230524094728-9239064ad72f/go.mod h1:sfYdkwUW4BA3PbKjySwjJy+O4Pu0h62rlqCMHNk+K+Q= github.com/envoyproxy/protoc-gen-validate v0.10.1 h1:c0g45+xCJhdgFGw7a5QAfdS4byAbud7miNWJ1WwEVf8= github.com/envoyproxy/protoc-gen-validate v0.10.1/go.mod h1:DRjgyB0I43LtJapqN6NiRwroiAU2PaFuvk/vjgh61ss= +github.com/felixge/fgprof v0.9.5 h1:8+vR6yu2vvSKn08urWyEuxx75NWPEvybbkBirEpsbVY= +github.com/felixge/fgprof v0.9.5/go.mod h1:yKl+ERSa++RYOs32d8K6WEXCB4uXdLls4ZaZPpayhMM= github.com/fortytw2/leaktest v1.3.0 h1:u8491cBMTQ8ft8aeV+adlcytMZylmA5nnwwkRZjI8vw= -github.com/frankban/quicktest v1.14.4/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0= github.com/fullstorydev/grpcurl v1.6.0 h1:p8BB6VZF8O7w6MxGr3KJ9E6EVKaswCevSALK6FBtMzA= github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk= github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE= @@ -337,10 +334,10 @@ github.com/golang/glog v1.1.0/go.mod h1:pfYeQZ3JWZoXTV5sFc986z3HTpwQs9At6P4ImfuP github.com/golang/snappy v0.0.3 h1:fHPg5GQYlCeLIPB9BZqMVR5nR9A+IM5zcgeTdjMYmLA= github.com/google/btree v1.0.0 h1:0udJVsspx3VBr5FwtLhQQtuAsVc79tTq0ocGIPAU6qo= github.com/google/certificate-transparency-go v1.1.1 h1:6JHXZhXEvilMcTjR4MGZn5KV0IRkcFl4CJx5iHVhjFE= -github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= github.com/google/gofuzz v1.0.0 h1:A8PeW59pxE9IoFRqBp37U+mSNaQoZ46F1f0f863XSXw= -github.com/google/martian/v3 v3.3.2/go.mod h1:oBOf6HBosgwRXnUGWUB05QECsc6uvmMiJ3+6W4l/CUk= github.com/google/pprof v0.0.0-20210720184732-4bb14d4b1be1 h1:K6RDEckDVWvDI9JAJYCmNdQXq6neHJOYx3V6jnqNEec= +github.com/google/pprof v0.0.0-20240227163752-401108e1b7e7 h1:y3N7Bm7Y9/CtpiVkw/ZWj6lSlDF3F74SfKwfTCer72Q= +github.com/google/pprof v0.0.0-20240227163752-401108e1b7e7/go.mod h1:czg5+yv1E0ZGTi6S6vVK1mke0fV+FaUhNGcd6VRS9Ik= github.com/google/renameio v0.1.0 h1:GOZbcHa3HfsPKPlmyPyN2KEohoMXOhdMbHrvbpl2QaA= github.com/google/rpmpack v0.0.0-20210410105602-e20c988a6f5a h1:XC048Fc/OB2rUl/BxruopEl2u/EP6cJNFveVxI1cvdk= github.com/google/subcommands v1.0.1 h1:/eqq+otEXm5vhfBrbREPCSVQbvofip6kIz+mX5TUH7k= @@ -350,7 +347,6 @@ github.com/gookit/color v1.5.0 h1:1Opow3+BWDwqor78DcJkJCIwnkviFi+rrOANki9BUFw= github.com/gorhill/cronexpr v0.0.0-20180427100037-88b0669f7d75 h1:f0n1xnMSmBLzVfsMMvriDyA75NB/oBgILX2GcHXIQzY= github.com/gorilla/mux v1.8.0 h1:i40aqfkR1h2SlN9hojwV5ZA91wcXFOvkdNIeFDP5koI= github.com/gorilla/websocket v1.4.2 h1:+/TMaTYc4QFitKJxsQ7Yye35DkWvkdLcvGKqM+x0Ufc= -github.com/gostaticanalysis/testutil v0.4.0/go.mod h1:bLIoPefWXrRi/ssLFWX1dx7Repi5x3CuviD3dgAZaBU= github.com/gregjones/httpcache v0.0.0-20190611155906-901d90724c79 h1:+ngKgrYPPJrOjhax5N+uePQ0Fh1Z7PheYoUI/0nzkPA= github.com/grpc-ecosystem/go-grpc-middleware v1.2.2 h1:FlFbCRLd5Jr4iYXZufAvgWN6Ao0JrI5chLINnUXDDr0= github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0 h1:Ovs26xHkKqVztRpIrF/92BcuyuQ/YW4NSIpoGtfXNho= @@ -434,6 +430,8 @@ github.com/pascaldekloe/goe v0.1.0 h1:cBOtyMzM9HTpWjXfbbunk26uA6nG3a8n06Wieeh0Mw github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8= github.com/peterbourgon/diskv v2.0.1+incompatible h1:UBdAOUP5p4RWqPBg048CAvpKN+vxiaj6gdUUzhl4XmI= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e h1:aoZm08cpOy4WuID//EZDgcC4zIxODThtZNPirFr42+A= +github.com/pkg/profile v1.7.0 h1:hnbDkaNWPCLMO9wGLdBFTIZvzDrDfBM2072E1S9gJkA= +github.com/pkg/profile v1.7.0/go.mod h1:8Uer0jas47ZQMJ7VD+OHknK4YDY07LPUC6dEvqDjvNo= github.com/pkg/sftp v1.13.1 h1:I2qBYMChEhIjOgazfJmV3/mZM256btk6wkCDRmW7JYs= github.com/posener/complete v1.2.3 h1:NP0eAhjcjImqslEwo/1hq7gpajME0fTLTezBKDqfXqo= github.com/power-devops/perfstat v0.0.0-20210106213030-5aafc221ea8c h1:ncq/mPwQF4JjgDlrVEn3C11VoGHZN7m8qihwgMEtzYw= @@ -454,6 +452,7 @@ github.com/remyoudompheng/go-misc v0.0.0-20190427085024-2d6ac652a50e/go.mod h1:8 github.com/rogpeppe/fastuuid v1.2.0 h1:Ppwyp6VYCF1nvBTXL3trRso7mXMlRrw9ooo375wvi2s= github.com/rs/cors v1.7.0 h1:+88SsELBHx5r+hZ8TCkggzSstaWNbDvThkVK8H6f9ik= github.com/rs/xid v1.4.0 h1:qd7wPTDkN6KQx2VmMBLrpHkiyQwgFXRnkOLacUiaSNY= +github.com/rs/xid v1.5.0 h1:mKX4bl4iPYJtEIxp6CYiUuLQ/8DYMoz0PUdtGgMFRVc= github.com/russross/blackfriday v1.5.2 h1:HyvC0ARfnZBqnXwABFeSZHpKvJHJJfPz81GNueLj0oo= github.com/ryanuber/columnize v0.0.0-20160712163229-9b3edd62028f h1:UFr9zpz4xgTnIE5yIMtWAMngCdZ9p/+q6lTbgelo80M= github.com/sagikazarmark/crypt v0.9.0 h1:fipzMFW34hFUEc4D7fsLQFtE7yElkpgyS2zruedRdZk= @@ -466,14 +465,11 @@ github.com/shirou/gopsutil/v3 v3.22.4/go.mod h1:D01hZJ4pVHPpCTZ3m3T2+wDF2YAGfd+H github.com/shurcooL/go v0.0.0-20180423040247-9e1955d9fb6e h1:MZM7FHLqUHYI0Y/mQAt3d2aYa0SiNms/hFqC9qJYolM= github.com/shurcooL/go-goon v0.0.0-20170922171312-37c2f522c041 h1:llrF3Fs4018ePo4+G/HV/uQUqEI1HMDjCeOf2V6puPc= github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo= -github.com/smartystreets/assertions v1.2.0/go.mod h1:tcbTF8ujkAEcZ8TElKY+i30BzYlVhC/LOxJk7iOWnoo= github.com/smartystreets/go-aws-auth v0.0.0-20180515143844-0c1422d1fdb9 h1:hp2CYQUINdZMHdvTdXtPOY2ainKl4IoMcpAXEf2xj3Q= -github.com/smartystreets/goconvey v1.7.2/go.mod h1:Vw0tHAZW6lzCRk3xgdin6fKYcG+G3Pg9vgXWeJpQFMM= github.com/smartystreets/gunit v1.0.0 h1:RyPDUFcJbvtXlhJPk7v+wnxZRY2EUokhEYl2EJOPToI= github.com/soheilhy/cmux v0.1.4 h1:0HKaf1o97UwFjHH9o5XsHUOF+tqmdA7KEzXLpiyaw0E= github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72 h1:qLC7fQah7D6K1B0ujays3HV9gkFtllcxhzImRR7ArPQ= github.com/streadway/quantile v0.0.0-20150917103942-b0c588724d25 h1:7z3LSn867ex6VSaahyKadf4WtSsJIgne6A1WLOAGM8A= -github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY= github.com/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= github.com/tj/go-buffer v1.1.0 h1:Lo2OsPHlIxXF24zApe15AbK3bJLAOvkkxEA6Ux4c47M= github.com/tj/go-elastic v0.0.0-20171221160941-36157cbbebc2 h1:eGaGNxrtoZf/mBURsnNQKDR7u50Klgcf2eFDQEnc8Bc= @@ -525,7 +521,8 @@ go.opentelemetry.io/otel v1.0.1/go.mod h1:OPEOD4jIT2SlZPMmwT6FqZz2C0ZNdQqiWcoK6M go.opentelemetry.io/otel/trace v1.0.1 h1:StTeIH6Q3G4r0Fiw34LTokUFESZgIDUr0qIJ7mKmAfw= go.opentelemetry.io/otel/trace v1.0.1/go.mod h1:5g4i4fKLaX2BQpSBsxw8YYcgKpMMSW3x7ZTuYBr3sUk= go.opentelemetry.io/proto/otlp v0.7.0 h1:rwOQPCuKAKmwGKq2aVNnYIibI6wnV7EvzgfTCzcdGg8= -go.uber.org/goleak v1.1.11/go.mod h1:cwTWslyiVhfpKIDGSZEM2HlOvcqm+tG4zioyIeLoqMQ= +go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU= +go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM= go.uber.org/tools v0.0.0-20190618225709-2cfd321de3ee h1:0mgffUl7nfd+FpvXMVz4IDEaUSmT1ysygQC7qYo7sG4= golang.org/x/crypto v0.17.0 h1:r8bRNjWL3GshPW3gkd+RpvzWrZAwPS49OmTGZ/uhM4k= golang.org/x/crypto v0.17.0/go.mod h1:gCAAfMLgwOJRpTjQ2zCCt2OcSfYMTeZVSRtQlPC7Nq4= @@ -548,6 +545,8 @@ golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2 h1:IRJeR9r1pYWsHKTRe/I golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE= golang.org/x/telemetry v0.0.0-20240521205824-bda55230c457 h1:zf5N6UOrA487eEFacMePxjXAJctxKmyjKUsjA11Uzuk= golang.org/x/telemetry v0.0.0-20240521205824-bda55230c457/go.mod h1:pRgIJT+bRLFKnoM1ldnzKoxTIn14Yxz928LQRYYgIN0= +golang.org/x/telemetry v0.0.0-20250807160809-1a19826ec488 h1:3doPGa+Gg4snce233aCWnbZVFsyFMo/dR40KK/6skyE= +golang.org/x/telemetry v0.0.0-20250807160809-1a19826ec488/go.mod h1:fGb/2+tgXXjhjHsTNdVEEMZNWA0quBnfrO+AfoDSAKw= golang.org/x/term v0.15.0 h1:y/Oo/a/q3IXu26lQgl04j/gjuBDOBlx7X6Om1j2CPW4= golang.org/x/term v0.15.0/go.mod h1:BDl952bC7+uMoWR75FIrCDx79TPU9oHkTZ9yRbYOrX0= golang.org/x/term v0.21.0 h1:WVXCp+/EBEHOj53Rvu+7KiT/iElMrO8ACK16SMZ3jaA= diff --git a/internal/tools/tools.go b/internal/tools/tools.go index aa8dfc8204b..43ac796fc3e 100644 --- a/internal/tools/tools.go +++ b/internal/tools/tools.go @@ -35,7 +35,7 @@ import ( // replaces golint - configurable and much faster _ "github.com/mgechev/revive" // mockery for generating mocks - _ "github.com/vektra/mockery/v2" + _ "github.com/vektra/mockery/v3" // mockgen for generating mocks _ "go.uber.org/mock/mockgen" // thriftrw code gen diff --git a/service/history/engine/interface_mock.go b/service/history/engine/interface_mock.go index 586e4fc3f85..d60f4f9ff51 100644 --- a/service/history/engine/interface_mock.go +++ b/service/history/engine/interface_mock.go @@ -287,17 +287,17 @@ func (mr *MockEngineMockRecorder) ReadDLQMessages(ctx, messagesRequest any) *gom } // ReapplyEvents mocks base method. -func (m *MockEngine) ReapplyEvents(ctx context.Context, domainUUID, workflowID, runID string, events []*types.HistoryEvent) error { +func (m *MockEngine) ReapplyEvents(ctx context.Context, domainUUID, workflowID, runID string, arg4 []*types.HistoryEvent) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "ReapplyEvents", ctx, domainUUID, workflowID, runID, events) + ret := m.ctrl.Call(m, "ReapplyEvents", ctx, domainUUID, workflowID, runID, arg4) ret0, _ := ret[0].(error) return ret0 } // ReapplyEvents indicates an expected call of ReapplyEvents. -func (mr *MockEngineMockRecorder) ReapplyEvents(ctx, domainUUID, workflowID, runID, events any) *gomock.Call { +func (mr *MockEngineMockRecorder) ReapplyEvents(ctx, domainUUID, workflowID, runID, arg4 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReapplyEvents", reflect.TypeOf((*MockEngine)(nil).ReapplyEvents), ctx, domainUUID, workflowID, runID, events) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReapplyEvents", reflect.TypeOf((*MockEngine)(nil).ReapplyEvents), ctx, domainUUID, workflowID, runID, arg4) } // RecordActivityTaskHeartbeat mocks base method. diff --git a/service/history/execution/mutable_state_task_generator_test.go b/service/history/execution/mutable_state_task_generator_test.go index 659b3b8f3db..92e7a785f15 100644 --- a/service/history/execution/mutable_state_task_generator_test.go +++ b/service/history/execution/mutable_state_task_generator_test.go @@ -23,7 +23,7 @@ package execution import ( "errors" "fmt" - "math/rand" + "reflect" "testing" "time" @@ -654,9 +654,36 @@ func (s *mutableStateTaskGeneratorSuite) TestGenerateDecisionScheduleTasks() { } } +type ignoreVisibilityTime struct { + task *persistence.DecisionTimeoutTask +} + +func (i ignoreVisibilityTime) Matches(x any) bool { + other, ok := x.(*persistence.DecisionTimeoutTask) + if !ok { + return false + } + if i.task == nil && other == nil { + return true + } + if (i.task == nil) != (other == nil) { + return false + } + + // both present, erase time and compare + medup, otherdup := *i.task, *other + medup.TaskData.VisibilityTimestamp = time.Time{} + otherdup.TaskData.VisibilityTimestamp = time.Time{} + return reflect.DeepEqual(medup, otherdup) +} + +func (i ignoreVisibilityTime) String() string { + return fmt.Sprintf("%#v", i.task) +} + +var _ gomock.Matcher = ignoreVisibilityTime{} + func (s *mutableStateTaskGeneratorSuite) TestGenerateDecisionStartTasks() { - seed := int64(1) - rand.Seed(seed) decisionScheduleID := int64(123) getDecision := func() *DecisionInfo { return &DecisionInfo{ @@ -687,21 +714,20 @@ func (s *mutableStateTaskGeneratorSuite) TestGenerateDecisionStartTasks() { startToCloseTimeout := getNextDecisionTimeout(decision.Attempt, time.Duration(defaultStartToCloseTimeout)*time.Second) decision.DecisionTimeout = int32(startToCloseTimeout.Seconds()) s.mockMutableState.EXPECT().UpdateDecision(decision).Times(1) - s.mockMutableState.EXPECT().AddTimerTasks(&persistence.DecisionTimeoutTask{ + s.mockMutableState.EXPECT().AddTimerTasks(ignoreVisibilityTime{&persistence.DecisionTimeoutTask{ WorkflowIdentifier: persistence.WorkflowIdentifier{ DomainID: "domain-id", WorkflowID: "wf-id", RunID: "rid", }, TaskData: persistence.TaskData{ - VisibilityTimestamp: time.Unix(0, decision.StartedTimestamp).Add(startToCloseTimeout), + VisibilityTimestamp: time.Time{}, // ignored Version: decision.Version, }, TimeoutType: int(TimerTypeStartToClose), EventID: decision.ScheduleID, ScheduleAttempt: decision.Attempt, - }) - rand.Seed(seed) + }}) }, }, { @@ -715,20 +741,20 @@ func (s *mutableStateTaskGeneratorSuite) TestGenerateDecisionStartTasks() { RunID: "rid", }) s.mockMutableState.EXPECT().GetDecisionInfo(decisionScheduleID).Return(decision, true).Times(1) - s.mockMutableState.EXPECT().AddTimerTasks(&persistence.DecisionTimeoutTask{ + s.mockMutableState.EXPECT().AddTimerTasks(ignoreVisibilityTime{&persistence.DecisionTimeoutTask{ WorkflowIdentifier: persistence.WorkflowIdentifier{ DomainID: "domain-id", WorkflowID: "wf-id", RunID: "rid", }, TaskData: persistence.TaskData{ - VisibilityTimestamp: time.Unix(0, decision.StartedTimestamp).Add(time.Duration(decision.DecisionTimeout) * time.Second), + VisibilityTimestamp: time.Time{}, // ignored Version: decision.Version, }, TimeoutType: int(TimerTypeStartToClose), EventID: decision.ScheduleID, ScheduleAttempt: decision.Attempt, - }) + }}) }, }, { diff --git a/service/history/resource/resource_mock.go b/service/history/resource/resource_mock.go index 184fa60e971..1a674efb1f2 100644 --- a/service/history/resource/resource_mock.go +++ b/service/history/resource/resource_mock.go @@ -546,33 +546,33 @@ func (mr *MockResourceMockRecorder) GetRatelimiterAlgorithm() *gomock.Call { } // GetRemoteAdminClient mocks base method. -func (m *MockResource) GetRemoteAdminClient(cluster string) (admin.Client, error) { +func (m *MockResource) GetRemoteAdminClient(arg0 string) (admin.Client, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRemoteAdminClient", cluster) + ret := m.ctrl.Call(m, "GetRemoteAdminClient", arg0) ret0, _ := ret[0].(admin.Client) ret1, _ := ret[1].(error) return ret0, ret1 } // GetRemoteAdminClient indicates an expected call of GetRemoteAdminClient. -func (mr *MockResourceMockRecorder) GetRemoteAdminClient(cluster any) *gomock.Call { +func (mr *MockResourceMockRecorder) GetRemoteAdminClient(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteAdminClient", reflect.TypeOf((*MockResource)(nil).GetRemoteAdminClient), cluster) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteAdminClient", reflect.TypeOf((*MockResource)(nil).GetRemoteAdminClient), arg0) } // GetRemoteFrontendClient mocks base method. -func (m *MockResource) GetRemoteFrontendClient(cluster string) (frontend.Client, error) { +func (m *MockResource) GetRemoteFrontendClient(arg0 string) (frontend.Client, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetRemoteFrontendClient", cluster) + ret := m.ctrl.Call(m, "GetRemoteFrontendClient", arg0) ret0, _ := ret[0].(frontend.Client) ret1, _ := ret[1].(error) return ret0, ret1 } // GetRemoteFrontendClient indicates an expected call of GetRemoteFrontendClient. -func (mr *MockResourceMockRecorder) GetRemoteFrontendClient(cluster any) *gomock.Call { +func (mr *MockResourceMockRecorder) GetRemoteFrontendClient(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteFrontendClient", reflect.TypeOf((*MockResource)(nil).GetRemoteFrontendClient), cluster) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRemoteFrontendClient", reflect.TypeOf((*MockResource)(nil).GetRemoteFrontendClient), arg0) } // GetSDKClient mocks base method. diff --git a/service/history/shard/context_mock.go b/service/history/shard/context_mock.go index dc774b2a714..726c83e9d82 100644 --- a/service/history/shard/context_mock.go +++ b/service/history/shard/context_mock.go @@ -214,17 +214,17 @@ func (mr *MockContextMockRecorder) GetConfig() *gomock.Call { } // GetCurrentTime mocks base method. -func (m *MockContext) GetCurrentTime(cluster string) time.Time { +func (m *MockContext) GetCurrentTime(arg0 string) time.Time { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetCurrentTime", cluster) + ret := m.ctrl.Call(m, "GetCurrentTime", arg0) ret0, _ := ret[0].(time.Time) return ret0 } // GetCurrentTime indicates an expected call of GetCurrentTime. -func (mr *MockContextMockRecorder) GetCurrentTime(cluster any) *gomock.Call { +func (mr *MockContextMockRecorder) GetCurrentTime(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentTime", reflect.TypeOf((*MockContext)(nil).GetCurrentTime), cluster) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentTime", reflect.TypeOf((*MockContext)(nil).GetCurrentTime), arg0) } // GetDomainCache mocks base method. @@ -368,17 +368,17 @@ func (mr *MockContextMockRecorder) GetQueueAckLevel(category any) *gomock.Call { } // GetQueueClusterAckLevel mocks base method. -func (m *MockContext) GetQueueClusterAckLevel(category persistence.HistoryTaskCategory, cluster string) persistence.HistoryTaskKey { +func (m *MockContext) GetQueueClusterAckLevel(category persistence.HistoryTaskCategory, arg1 string) persistence.HistoryTaskKey { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetQueueClusterAckLevel", category, cluster) + ret := m.ctrl.Call(m, "GetQueueClusterAckLevel", category, arg1) ret0, _ := ret[0].(persistence.HistoryTaskKey) return ret0 } // GetQueueClusterAckLevel indicates an expected call of GetQueueClusterAckLevel. -func (mr *MockContextMockRecorder) GetQueueClusterAckLevel(category, cluster any) *gomock.Call { +func (mr *MockContextMockRecorder) GetQueueClusterAckLevel(category, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueClusterAckLevel", reflect.TypeOf((*MockContext)(nil).GetQueueClusterAckLevel), category, cluster) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetQueueClusterAckLevel", reflect.TypeOf((*MockContext)(nil).GetQueueClusterAckLevel), category, arg1) } // GetQueueState mocks base method. @@ -453,31 +453,31 @@ func (mr *MockContextMockRecorder) GetTimeSource() *gomock.Call { } // GetTimerProcessingQueueStates mocks base method. -func (m *MockContext) GetTimerProcessingQueueStates(cluster string) []*types.ProcessingQueueState { +func (m *MockContext) GetTimerProcessingQueueStates(arg0 string) []*types.ProcessingQueueState { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTimerProcessingQueueStates", cluster) + ret := m.ctrl.Call(m, "GetTimerProcessingQueueStates", arg0) ret0, _ := ret[0].([]*types.ProcessingQueueState) return ret0 } // GetTimerProcessingQueueStates indicates an expected call of GetTimerProcessingQueueStates. -func (mr *MockContextMockRecorder) GetTimerProcessingQueueStates(cluster any) *gomock.Call { +func (mr *MockContextMockRecorder) GetTimerProcessingQueueStates(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimerProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).GetTimerProcessingQueueStates), cluster) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimerProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).GetTimerProcessingQueueStates), arg0) } // GetTransferProcessingQueueStates mocks base method. -func (m *MockContext) GetTransferProcessingQueueStates(cluster string) []*types.ProcessingQueueState { +func (m *MockContext) GetTransferProcessingQueueStates(arg0 string) []*types.ProcessingQueueState { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "GetTransferProcessingQueueStates", cluster) + ret := m.ctrl.Call(m, "GetTransferProcessingQueueStates", arg0) ret0, _ := ret[0].([]*types.ProcessingQueueState) return ret0 } // GetTransferProcessingQueueStates indicates an expected call of GetTransferProcessingQueueStates. -func (mr *MockContextMockRecorder) GetTransferProcessingQueueStates(cluster any) *gomock.Call { +func (mr *MockContextMockRecorder) GetTransferProcessingQueueStates(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransferProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).GetTransferProcessingQueueStates), cluster) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTransferProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).GetTransferProcessingQueueStates), arg0) } // GetWorkflowExecution mocks base method. @@ -524,15 +524,15 @@ func (mr *MockContextMockRecorder) ReplicateFailoverMarkers(ctx, markers any) *g } // SetCurrentTime mocks base method. -func (m *MockContext) SetCurrentTime(cluster string, currentTime time.Time) { +func (m *MockContext) SetCurrentTime(arg0 string, currentTime time.Time) { m.ctrl.T.Helper() - m.ctrl.Call(m, "SetCurrentTime", cluster, currentTime) + m.ctrl.Call(m, "SetCurrentTime", arg0, currentTime) } // SetCurrentTime indicates an expected call of SetCurrentTime. -func (mr *MockContextMockRecorder) SetCurrentTime(cluster, currentTime any) *gomock.Call { +func (mr *MockContextMockRecorder) SetCurrentTime(arg0, currentTime any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentTime", reflect.TypeOf((*MockContext)(nil).SetCurrentTime), cluster, currentTime) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCurrentTime", reflect.TypeOf((*MockContext)(nil).SetCurrentTime), arg0, currentTime) } // SetEngine mocks base method. @@ -576,17 +576,17 @@ func (mr *MockContextMockRecorder) UpdateFailoverLevel(category, failoverID, lev } // UpdateIfNeededAndGetQueueMaxReadLevel mocks base method. -func (m *MockContext) UpdateIfNeededAndGetQueueMaxReadLevel(category persistence.HistoryTaskCategory, cluster string) persistence.HistoryTaskKey { +func (m *MockContext) UpdateIfNeededAndGetQueueMaxReadLevel(category persistence.HistoryTaskCategory, arg1 string) persistence.HistoryTaskKey { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateIfNeededAndGetQueueMaxReadLevel", category, cluster) + ret := m.ctrl.Call(m, "UpdateIfNeededAndGetQueueMaxReadLevel", category, arg1) ret0, _ := ret[0].(persistence.HistoryTaskKey) return ret0 } // UpdateIfNeededAndGetQueueMaxReadLevel indicates an expected call of UpdateIfNeededAndGetQueueMaxReadLevel. -func (mr *MockContextMockRecorder) UpdateIfNeededAndGetQueueMaxReadLevel(category, cluster any) *gomock.Call { +func (mr *MockContextMockRecorder) UpdateIfNeededAndGetQueueMaxReadLevel(category, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIfNeededAndGetQueueMaxReadLevel", reflect.TypeOf((*MockContext)(nil).UpdateIfNeededAndGetQueueMaxReadLevel), category, cluster) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateIfNeededAndGetQueueMaxReadLevel", reflect.TypeOf((*MockContext)(nil).UpdateIfNeededAndGetQueueMaxReadLevel), category, arg1) } // UpdateQueueAckLevel mocks base method. @@ -604,17 +604,17 @@ func (mr *MockContextMockRecorder) UpdateQueueAckLevel(category, ackLevel any) * } // UpdateQueueClusterAckLevel mocks base method. -func (m *MockContext) UpdateQueueClusterAckLevel(category persistence.HistoryTaskCategory, cluster string, ackLevel persistence.HistoryTaskKey) error { +func (m *MockContext) UpdateQueueClusterAckLevel(category persistence.HistoryTaskCategory, arg1 string, ackLevel persistence.HistoryTaskKey) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateQueueClusterAckLevel", category, cluster, ackLevel) + ret := m.ctrl.Call(m, "UpdateQueueClusterAckLevel", category, arg1, ackLevel) ret0, _ := ret[0].(error) return ret0 } // UpdateQueueClusterAckLevel indicates an expected call of UpdateQueueClusterAckLevel. -func (mr *MockContextMockRecorder) UpdateQueueClusterAckLevel(category, cluster, ackLevel any) *gomock.Call { +func (mr *MockContextMockRecorder) UpdateQueueClusterAckLevel(category, arg1, ackLevel any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateQueueClusterAckLevel", reflect.TypeOf((*MockContext)(nil).UpdateQueueClusterAckLevel), category, cluster, ackLevel) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateQueueClusterAckLevel", reflect.TypeOf((*MockContext)(nil).UpdateQueueClusterAckLevel), category, arg1, ackLevel) } // UpdateQueueState mocks base method. @@ -632,31 +632,31 @@ func (mr *MockContextMockRecorder) UpdateQueueState(category, state any) *gomock } // UpdateTimerProcessingQueueStates mocks base method. -func (m *MockContext) UpdateTimerProcessingQueueStates(cluster string, states []*types.ProcessingQueueState) error { +func (m *MockContext) UpdateTimerProcessingQueueStates(arg0 string, states []*types.ProcessingQueueState) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateTimerProcessingQueueStates", cluster, states) + ret := m.ctrl.Call(m, "UpdateTimerProcessingQueueStates", arg0, states) ret0, _ := ret[0].(error) return ret0 } // UpdateTimerProcessingQueueStates indicates an expected call of UpdateTimerProcessingQueueStates. -func (mr *MockContextMockRecorder) UpdateTimerProcessingQueueStates(cluster, states any) *gomock.Call { +func (mr *MockContextMockRecorder) UpdateTimerProcessingQueueStates(arg0, states any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTimerProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).UpdateTimerProcessingQueueStates), cluster, states) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTimerProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).UpdateTimerProcessingQueueStates), arg0, states) } // UpdateTransferProcessingQueueStates mocks base method. -func (m *MockContext) UpdateTransferProcessingQueueStates(cluster string, states []*types.ProcessingQueueState) error { +func (m *MockContext) UpdateTransferProcessingQueueStates(arg0 string, states []*types.ProcessingQueueState) error { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "UpdateTransferProcessingQueueStates", cluster, states) + ret := m.ctrl.Call(m, "UpdateTransferProcessingQueueStates", arg0, states) ret0, _ := ret[0].(error) return ret0 } // UpdateTransferProcessingQueueStates indicates an expected call of UpdateTransferProcessingQueueStates. -func (mr *MockContextMockRecorder) UpdateTransferProcessingQueueStates(cluster, states any) *gomock.Call { +func (mr *MockContextMockRecorder) UpdateTransferProcessingQueueStates(arg0, states any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTransferProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).UpdateTransferProcessingQueueStates), cluster, states) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateTransferProcessingQueueStates", reflect.TypeOf((*MockContext)(nil).UpdateTransferProcessingQueueStates), arg0, states) } // UpdateWorkflowExecution mocks base method. diff --git a/service/history/task/interface_mock.go b/service/history/task/interface_mock.go index 21d3c30b0b3..ba239f4b336 100644 --- a/service/history/task/interface_mock.go +++ b/service/history/task/interface_mock.go @@ -1004,18 +1004,18 @@ func (m *MockExecutor) EXPECT() *MockExecutorMockRecorder { } // Execute mocks base method. -func (m *MockExecutor) Execute(task Task) (ExecuteResponse, error) { +func (m *MockExecutor) Execute(arg0 Task) (ExecuteResponse, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Execute", task) + ret := m.ctrl.Call(m, "Execute", arg0) ret0, _ := ret[0].(ExecuteResponse) ret1, _ := ret[1].(error) return ret0, ret1 } // Execute indicates an expected call of Execute. -func (mr *MockExecutorMockRecorder) Execute(task any) *gomock.Call { +func (mr *MockExecutorMockRecorder) Execute(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Execute", reflect.TypeOf((*MockExecutor)(nil).Execute), task) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Execute", reflect.TypeOf((*MockExecutor)(nil).Execute), arg0) } // Stop mocks base method. diff --git a/service/sharddistributor/store/etcd/go.mod b/service/sharddistributor/store/etcd/go.mod index fd0fb24493d..0ea836a4004 100644 --- a/service/sharddistributor/store/etcd/go.mod +++ b/service/sharddistributor/store/etcd/go.mod @@ -1,8 +1,8 @@ module github.com/uber/cadence/service/sharddistributor/store/etcd -go 1.23.0 +go 1.24 -toolchain go1.23.4 +toolchain go1.24.7 replace github.com/uber/cadence => ../../../.. @@ -34,6 +34,7 @@ require ( github.com/golang-jwt/jwt/v5 v5.2.0 // indirect github.com/golang/mock v1.6.0 // indirect github.com/golang/protobuf v1.5.4 // indirect + github.com/google/gofuzz v1.0.0 // indirect github.com/google/uuid v1.6.0 // indirect github.com/jmespath/go-jmespath v0.4.0 // indirect github.com/jonboulle/clockwork v0.5.0 // indirect @@ -66,7 +67,7 @@ require ( go.uber.org/cadence v0.19.0 // indirect go.uber.org/config v1.4.0 // indirect go.uber.org/dig v1.18.0 // indirect - go.uber.org/mock v0.5.0 // indirect + go.uber.org/mock v0.6.0 // indirect go.uber.org/multierr v1.10.0 // indirect go.uber.org/net/metrics v1.3.0 // indirect go.uber.org/thriftrw v1.29.2 // indirect @@ -74,13 +75,13 @@ require ( go.uber.org/zap v1.26.0 // indirect golang.org/x/exp/typeparams v0.0.0-20220218215828-6cf2b201936e // indirect golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 // indirect - golang.org/x/mod v0.18.0 // indirect - golang.org/x/net v0.40.0 // indirect - golang.org/x/sync v0.14.0 // indirect - golang.org/x/sys v0.33.0 // indirect - golang.org/x/text v0.25.0 // indirect + golang.org/x/mod v0.27.0 // indirect + golang.org/x/net v0.43.0 // indirect + golang.org/x/sync v0.16.0 // indirect + golang.org/x/sys v0.35.0 // indirect + golang.org/x/text v0.28.0 // indirect golang.org/x/time v0.5.0 // indirect - golang.org/x/tools v0.22.0 // indirect + golang.org/x/tools v0.36.0 // indirect google.golang.org/genproto v0.0.0-20231016165738-49dd2c1f3d0b // indirect google.golang.org/genproto/googleapis/api v0.0.0-20231012201019-e917dd12ba7a // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20231030173426-d783a09b4405 // indirect diff --git a/service/sharddistributor/store/etcd/go.sum b/service/sharddistributor/store/etcd/go.sum index 38f11abe75a..79fed5fa241 100644 --- a/service/sharddistributor/store/etcd/go.sum +++ b/service/sharddistributor/store/etcd/go.sum @@ -301,8 +301,8 @@ go.uber.org/goleak v0.10.0/go.mod h1:VCZuO8V8mFPlL0F5J5GK1rtHV3DrFcQ1R8ryq7FK0aI go.uber.org/goleak v1.0.0/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A= go.uber.org/goleak v1.2.0 h1:xqgm/S+aQvhWFTtR0XK3Jvg7z8kGV8P4X14IzwN3Eqk= go.uber.org/goleak v1.2.0/go.mod h1:XJYK+MuIchqpmGmUSAzotztawfKvYLUIgg7guXrwVUo= -go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU= -go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM= +go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= +go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= go.uber.org/multierr v1.3.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= go.uber.org/multierr v1.4.0/go.mod h1:VgVr7evmIr6uPjLBxg28wmKNXyqE9akIJ5XnfpiKl+4= @@ -349,8 +349,8 @@ golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.4.2/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4= -golang.org/x/mod v0.18.0 h1:5+9lSbEzPSdWkH32vYPBwEpX8KwDbM52Ud9xBUvNlb0= -golang.org/x/mod v0.18.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c= +golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ= +golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc= golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= @@ -368,8 +368,8 @@ golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwY golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg= golang.org/x/net v0.0.0-20210405180319-a5a99cb37ef4/go.mod h1:p54w0d4576C0XHj96bSt6lcn1PtDYWL6XObtHCRCNQM= golang.org/x/net v0.0.0-20211015210444-4f30a5c0130f/go.mod h1:9nx3DQGgdP8bBQD5qxJ1jj9UTztislL4KSBs9R2vV5Y= -golang.org/x/net v0.40.0 h1:79Xs7wF06Gbdcg4kdCCIQArK11Z1hr5POQ6+fIYHNuY= -golang.org/x/net v0.40.0/go.mod h1:y0hY0exeL2Pku80/zKK7tpntoX23cqL3Oa6njdgRtds= +golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE= +golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw= @@ -382,8 +382,8 @@ golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJ golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201207232520-09787c993a3a/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= -golang.org/x/sync v0.14.0 h1:woo0S4Yywslg6hp4eUFjTVOyKt0RookbpAHG4c1HmhQ= -golang.org/x/sync v0.14.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sync v0.16.0 h1:ycBJEhp9p4vXvUZNszeOq0kGTPghopOL8q0fq3vstxw= +golang.org/x/sync v0.16.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -409,8 +409,8 @@ golang.org/x/sys v0.0.0-20210603081109-ebe580a85c40/go.mod h1:oPkhp1MJrh7nUepCBc golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20211019181941-9d821ace8654/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.33.0 h1:q3i8TbbEz+JRD9ywIRlyRAQbM0qF7hu24q3teo2hbuw= -golang.org/x/sys v0.33.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/sys v0.35.0 h1:vz1N37gP5bs89s7He8XuIYXpyY0+QlsKmzipCbUtyxI= +golang.org/x/sys v0.35.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo= golang.org/x/text v0.0.0-20170915032832-14c0d48ead0c/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= @@ -419,8 +419,8 @@ golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ= -golang.org/x/text v0.25.0 h1:qVyWApTSYLk/drJRO5mDlNYskwQznZmkpV2c8q9zls4= -golang.org/x/text v0.25.0/go.mod h1:WEdwpYrmk1qmdHvhkSTNPm3app7v4rsT8F2UD6+VHIA= +golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng= +golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU= golang.org/x/time v0.0.0-20170927054726-6dc17368e09b/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.5.0 h1:o7cqy6amK/52YcAKIPlM3a+Fpj35zvRj2TP+e1xFSfk= golang.org/x/time v0.5.0/go.mod h1:3BpzKBy/shNhVucY/MWOyx10tF3SFh9QdLuxbVysPQM= @@ -450,8 +450,10 @@ golang.org/x/tools v0.1.1/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.2/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.5/go.mod h1:o0xws9oXOQQZyjljx8fwUC0k7L1pTE6eaCbjGeHmOkk= golang.org/x/tools v0.1.11-0.20220513221640-090b14e8501f/go.mod h1:SgwaegtQh8clINPpECJMqnxLv9I09HLqnW3RMqW0CA4= -golang.org/x/tools v0.22.0 h1:gqSGLZqv+AI9lIQzniJ0nZDRG5GBPsSi+DRNHWNz6yA= -golang.org/x/tools v0.22.0/go.mod h1:aCwcsjqvq7Yqt6TNyX7QMU2enbQ/Gt0bo6krSeEri+c= +golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg= +golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s= +golang.org/x/tools/go/expect v0.1.1-deprecated h1:jpBZDwmgPhXsKZC6WhL20P4b/wmnpsEAGHaNy0n/rJM= +golang.org/x/tools/go/expect v0.1.1-deprecated/go.mod h1:eihoPOH+FgIqa3FpoTwguz/bVUSGBlGQU67vpBeOrBY= 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= diff --git a/service/worker/archiver/activities_test.go b/service/worker/archiver/activities_test.go index badb85decf2..c05a2e6f8d8 100644 --- a/service/worker/archiver/activities_test.go +++ b/service/worker/archiver/activities_test.go @@ -96,7 +96,7 @@ func (s *activitiesSuite) TearDownTest() { } func (s *activitiesSuite) TestUploadHistory_Fail_InvalidURI() { - s.metricsClient.On("Scope", metrics.ArchiverUploadHistoryActivityScope, metrics.DomainTag(testDomainName)).Return(s.metricsScope).Once() + s.metricsClient.On("Scope", metrics.ArchiverUploadHistoryActivityScope, []metrics.Tag{metrics.DomainTag(testDomainName)}).Return(s.metricsScope).Once() s.metricsScope.On("IncCounter", metrics.ArchiverNonRetryableErrorCount).Once() container := &BootstrapContainer{ Logger: s.logger, @@ -124,7 +124,7 @@ func (s *activitiesSuite) TestUploadHistory_Fail_InvalidURI() { } func (s *activitiesSuite) TestUploadHistory_Fail_GetArchiverError() { - s.metricsClient.On("Scope", metrics.ArchiverUploadHistoryActivityScope, metrics.DomainTag(testDomainName)).Return(s.metricsScope).Once() + s.metricsClient.On("Scope", metrics.ArchiverUploadHistoryActivityScope, []metrics.Tag{metrics.DomainTag(testDomainName)}).Return(s.metricsScope).Once() s.metricsScope.On("IncCounter", metrics.ArchiverNonRetryableErrorCount).Once() s.archiverProvider.EXPECT().GetHistoryArchiver(gomock.Any(), service.Worker).Return(nil, errors.New("failed to get archiver")) container := &BootstrapContainer{ @@ -154,7 +154,7 @@ func (s *activitiesSuite) TestUploadHistory_Fail_GetArchiverError() { } func (s *activitiesSuite) TestUploadHistory_Fail_ArchiveNonRetriableError() { - s.metricsClient.On("Scope", metrics.ArchiverUploadHistoryActivityScope, metrics.DomainTag(testDomainName)).Return(s.metricsScope).Once() + s.metricsClient.On("Scope", metrics.ArchiverUploadHistoryActivityScope, []metrics.Tag{metrics.DomainTag(testDomainName)}).Return(s.metricsScope).Once() s.metricsScope.On("IncCounter", metrics.ArchiverNonRetryableErrorCount).Once() s.historyArchiver.On("Archive", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errUploadNonRetriable) s.archiverProvider.EXPECT().GetHistoryArchiver(gomock.Any(), service.Worker).Return(s.historyArchiver, nil) @@ -185,7 +185,7 @@ func (s *activitiesSuite) TestUploadHistory_Fail_ArchiveNonRetriableError() { } func (s *activitiesSuite) TestUploadHistory_Fail_ArchiveRetriableError() { - s.metricsClient.On("Scope", metrics.ArchiverUploadHistoryActivityScope, metrics.DomainTag(testDomainName)).Return(s.metricsScope).Once() + s.metricsClient.On("Scope", metrics.ArchiverUploadHistoryActivityScope, []metrics.Tag{metrics.DomainTag(testDomainName)}).Return(s.metricsScope).Once() testArchiveErr := errors.New("some transient error") s.historyArchiver.On("Archive", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(testArchiveErr) s.archiverProvider.EXPECT().GetHistoryArchiver(gomock.Any(), service.Worker).Return(s.historyArchiver, nil) @@ -216,7 +216,7 @@ func (s *activitiesSuite) TestUploadHistory_Fail_ArchiveRetriableError() { } func (s *activitiesSuite) TestUploadHistory_Success() { - s.metricsClient.On("Scope", metrics.ArchiverUploadHistoryActivityScope, metrics.DomainTag(testDomainName)).Return(s.metricsScope).Once() + s.metricsClient.On("Scope", metrics.ArchiverUploadHistoryActivityScope, []metrics.Tag{metrics.DomainTag(testDomainName)}).Return(s.metricsScope).Once() s.historyArchiver.On("Archive", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) s.archiverProvider.EXPECT().GetHistoryArchiver(gomock.Any(), service.Worker).Return(s.historyArchiver, nil) container := &BootstrapContainer{ @@ -246,7 +246,7 @@ func (s *activitiesSuite) TestUploadHistory_Success() { } func (s *activitiesSuite) TestDeleteHistoryActivity_Fail_DeleteFromV2NonRetryableError() { - s.metricsClient.On("Scope", metrics.ArchiverDeleteHistoryActivityScope, metrics.DomainTag(testDomainName)).Return(s.metricsScope).Once() + s.metricsClient.On("Scope", metrics.ArchiverDeleteHistoryActivityScope, []metrics.Tag{metrics.DomainTag(testDomainName)}).Return(s.metricsScope).Once() s.metricsScope.On("IncCounter", metrics.ArchiverNonRetryableErrorCount).Once() mockHistoryV2Manager := &mocks.HistoryV2Manager{} mockHistoryV2Manager.On("DeleteHistoryBranch", mock.Anything, mock.Anything).Return(errPersistenceNonRetryable) @@ -277,7 +277,7 @@ func (s *activitiesSuite) TestDeleteHistoryActivity_Fail_DeleteFromV2NonRetryabl } func (s *activitiesSuite) TestArchiveVisibilityActivity_Fail_InvalidURI() { - s.metricsClient.On("Scope", metrics.ArchiverArchiveVisibilityActivityScope, metrics.DomainTag(testDomainName)).Return(s.metricsScope).Once() + s.metricsClient.On("Scope", metrics.ArchiverArchiveVisibilityActivityScope, []metrics.Tag{metrics.DomainTag(testDomainName)}).Return(s.metricsScope).Once() s.metricsScope.On("IncCounter", metrics.ArchiverNonRetryableErrorCount).Once() container := &BootstrapContainer{ Logger: s.logger, @@ -302,7 +302,7 @@ func (s *activitiesSuite) TestArchiveVisibilityActivity_Fail_InvalidURI() { } func (s *activitiesSuite) TestArchiveVisibilityActivity_Fail_GetArchiverError() { - s.metricsClient.On("Scope", metrics.ArchiverArchiveVisibilityActivityScope, metrics.DomainTag(testDomainName)).Return(s.metricsScope).Once() + s.metricsClient.On("Scope", metrics.ArchiverArchiveVisibilityActivityScope, []metrics.Tag{metrics.DomainTag(testDomainName)}).Return(s.metricsScope).Once() s.metricsScope.On("IncCounter", metrics.ArchiverNonRetryableErrorCount).Once() s.archiverProvider.EXPECT().GetVisibilityArchiver(gomock.Any(), service.Worker).Return(nil, errors.New("failed to get archiver")) container := &BootstrapContainer{ @@ -329,7 +329,7 @@ func (s *activitiesSuite) TestArchiveVisibilityActivity_Fail_GetArchiverError() } func (s *activitiesSuite) TestArchiveVisibilityActivity_Fail_ArchiveNonRetriableError() { - s.metricsClient.On("Scope", metrics.ArchiverArchiveVisibilityActivityScope, metrics.DomainTag(testDomainName)).Return(s.metricsScope).Once() + s.metricsClient.On("Scope", metrics.ArchiverArchiveVisibilityActivityScope, []metrics.Tag{metrics.DomainTag(testDomainName)}).Return(s.metricsScope).Once() s.metricsScope.On("IncCounter", metrics.ArchiverNonRetryableErrorCount).Once() s.visibilityArchiver.On("Archive", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(errArchiveVisibilityNonRetriable) s.archiverProvider.EXPECT().GetVisibilityArchiver(gomock.Any(), service.Worker).Return(s.visibilityArchiver, nil) @@ -357,7 +357,7 @@ func (s *activitiesSuite) TestArchiveVisibilityActivity_Fail_ArchiveNonRetriable } func (s *activitiesSuite) TestArchiveVisibilityActivity_Fail_ArchiveRetriableError() { - s.metricsClient.On("Scope", metrics.ArchiverArchiveVisibilityActivityScope, metrics.DomainTag(testDomainName)).Return(s.metricsScope).Once() + s.metricsClient.On("Scope", metrics.ArchiverArchiveVisibilityActivityScope, []metrics.Tag{metrics.DomainTag(testDomainName)}).Return(s.metricsScope).Once() testArchiveErr := errors.New("some transient error") s.visibilityArchiver.On("Archive", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(testArchiveErr) s.archiverProvider.EXPECT().GetVisibilityArchiver(gomock.Any(), service.Worker).Return(s.visibilityArchiver, nil) @@ -385,7 +385,7 @@ func (s *activitiesSuite) TestArchiveVisibilityActivity_Fail_ArchiveRetriableErr } func (s *activitiesSuite) TestArchiveVisibilityActivity_Success() { - s.metricsClient.On("Scope", metrics.ArchiverArchiveVisibilityActivityScope, metrics.DomainTag(testDomainName)).Return(s.metricsScope).Once() + s.metricsClient.On("Scope", metrics.ArchiverArchiveVisibilityActivityScope, []metrics.Tag{metrics.DomainTag(testDomainName)}).Return(s.metricsScope).Once() s.visibilityArchiver.On("Archive", mock.Anything, mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(nil) s.archiverProvider.EXPECT().GetVisibilityArchiver(gomock.Any(), service.Worker).Return(s.visibilityArchiver, nil) container := &BootstrapContainer{ diff --git a/service/worker/worker/worker_mock.go b/service/worker/worker/worker_mock.go index 11ad6b6a894..5d429ba46ba 100644 --- a/service/worker/worker/worker_mock.go +++ b/service/worker/worker/worker_mock.go @@ -42,51 +42,51 @@ func (m *MockWorker) EXPECT() *MockWorkerMockRecorder { } // RegisterActivity mocks base method. -func (m *MockWorker) RegisterActivity(activity any) { +func (m *MockWorker) RegisterActivity(arg0 any) { m.ctrl.T.Helper() - m.ctrl.Call(m, "RegisterActivity", activity) + m.ctrl.Call(m, "RegisterActivity", arg0) } // RegisterActivity indicates an expected call of RegisterActivity. -func (mr *MockWorkerMockRecorder) RegisterActivity(activity any) *gomock.Call { +func (mr *MockWorkerMockRecorder) RegisterActivity(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActivity", reflect.TypeOf((*MockWorker)(nil).RegisterActivity), activity) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActivity", reflect.TypeOf((*MockWorker)(nil).RegisterActivity), arg0) } // RegisterActivityWithOptions mocks base method. -func (m *MockWorker) RegisterActivityWithOptions(activity any, options activity.RegisterOptions) { +func (m *MockWorker) RegisterActivityWithOptions(arg0 any, options activity.RegisterOptions) { m.ctrl.T.Helper() - m.ctrl.Call(m, "RegisterActivityWithOptions", activity, options) + m.ctrl.Call(m, "RegisterActivityWithOptions", arg0, options) } // RegisterActivityWithOptions indicates an expected call of RegisterActivityWithOptions. -func (mr *MockWorkerMockRecorder) RegisterActivityWithOptions(activity, options any) *gomock.Call { +func (mr *MockWorkerMockRecorder) RegisterActivityWithOptions(arg0, options any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActivityWithOptions", reflect.TypeOf((*MockWorker)(nil).RegisterActivityWithOptions), activity, options) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterActivityWithOptions", reflect.TypeOf((*MockWorker)(nil).RegisterActivityWithOptions), arg0, options) } // RegisterWorkflow mocks base method. -func (m *MockWorker) RegisterWorkflow(workflow any) { +func (m *MockWorker) RegisterWorkflow(arg0 any) { m.ctrl.T.Helper() - m.ctrl.Call(m, "RegisterWorkflow", workflow) + m.ctrl.Call(m, "RegisterWorkflow", arg0) } // RegisterWorkflow indicates an expected call of RegisterWorkflow. -func (mr *MockWorkerMockRecorder) RegisterWorkflow(workflow any) *gomock.Call { +func (mr *MockWorkerMockRecorder) RegisterWorkflow(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkflow", reflect.TypeOf((*MockWorker)(nil).RegisterWorkflow), workflow) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkflow", reflect.TypeOf((*MockWorker)(nil).RegisterWorkflow), arg0) } // RegisterWorkflowWithOptions mocks base method. -func (m *MockWorker) RegisterWorkflowWithOptions(workflow any, options workflow.RegisterOptions) { +func (m *MockWorker) RegisterWorkflowWithOptions(arg0 any, options workflow.RegisterOptions) { m.ctrl.T.Helper() - m.ctrl.Call(m, "RegisterWorkflowWithOptions", workflow, options) + m.ctrl.Call(m, "RegisterWorkflowWithOptions", arg0, options) } // RegisterWorkflowWithOptions indicates an expected call of RegisterWorkflowWithOptions. -func (mr *MockWorkerMockRecorder) RegisterWorkflowWithOptions(workflow, options any) *gomock.Call { +func (mr *MockWorkerMockRecorder) RegisterWorkflowWithOptions(arg0, options any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkflowWithOptions", reflect.TypeOf((*MockWorker)(nil).RegisterWorkflowWithOptions), workflow, options) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RegisterWorkflowWithOptions", reflect.TypeOf((*MockWorker)(nil).RegisterWorkflowWithOptions), arg0, options) } // Run mocks base method.