client_delegate_mock.go

// The MIT License
//
// Copyright (c) 2020 Temporal Technologies Inc.  All rights reserved.
//
// 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 MockGen. DO NOT EDIT.
// Source: client_delegate.go

// Package connector is a generated GoMock package.
package connector

import (
	context "context"
	reflect "reflect"

	storage "cloud.google.com/go/storage"
	gomock "github.com/golang/mock/gomock"
)

// MockGcloudStorageClient is a mock of GcloudStorageClient interface.
type MockGcloudStorageClient struct {
	ctrl     *gomock.Controller
	recorder *MockGcloudStorageClientMockRecorder
}

// MockGcloudStorageClientMockRecorder is the mock recorder for MockGcloudStorageClient.
type MockGcloudStorageClientMockRecorder struct {
	mock *MockGcloudStorageClient
}

// NewMockGcloudStorageClient creates a new mock instance.
func NewMockGcloudStorageClient(ctrl *gomock.Controller) *MockGcloudStorageClient {
	mock := &MockGcloudStorageClient{ctrl: ctrl}
	mock.recorder = &MockGcloudStorageClientMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockGcloudStorageClient) EXPECT() *MockGcloudStorageClientMockRecorder {
	return m.recorder
}

// Bucket mocks base method.
func (m *MockGcloudStorageClient) Bucket(URI string) BucketHandleWrapper {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Bucket", URI)
	ret0, _ := ret[0].(BucketHandleWrapper)
	return ret0
}

// Bucket indicates an expected call of Bucket.
func (mr *MockGcloudStorageClientMockRecorder) Bucket(URI interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Bucket", reflect.TypeOf((*MockGcloudStorageClient)(nil).Bucket), URI)
}

// MockBucketHandleWrapper is a mock of BucketHandleWrapper interface.
type MockBucketHandleWrapper struct {
	ctrl     *gomock.Controller
	recorder *MockBucketHandleWrapperMockRecorder
}

// MockBucketHandleWrapperMockRecorder is the mock recorder for MockBucketHandleWrapper.
type MockBucketHandleWrapperMockRecorder struct {
	mock *MockBucketHandleWrapper
}

// NewMockBucketHandleWrapper creates a new mock instance.
func NewMockBucketHandleWrapper(ctrl *gomock.Controller) *MockBucketHandleWrapper {
	mock := &MockBucketHandleWrapper{ctrl: ctrl}
	mock.recorder = &MockBucketHandleWrapperMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockBucketHandleWrapper) EXPECT() *MockBucketHandleWrapperMockRecorder {
	return m.recorder
}

// Attrs mocks base method.
func (m *MockBucketHandleWrapper) Attrs(ctx context.Context) (*storage.BucketAttrs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Attrs", ctx)
	ret0, _ := ret[0].(*storage.BucketAttrs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Attrs indicates an expected call of Attrs.
func (mr *MockBucketHandleWrapperMockRecorder) Attrs(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Attrs", reflect.TypeOf((*MockBucketHandleWrapper)(nil).Attrs), ctx)
}

// Object mocks base method.
func (m *MockBucketHandleWrapper) Object(name string) ObjectHandleWrapper {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Object", name)
	ret0, _ := ret[0].(ObjectHandleWrapper)
	return ret0
}

// Object indicates an expected call of Object.
func (mr *MockBucketHandleWrapperMockRecorder) Object(name interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Object", reflect.TypeOf((*MockBucketHandleWrapper)(nil).Object), name)
}

// Objects mocks base method.
func (m *MockBucketHandleWrapper) Objects(ctx context.Context, q *storage.Query) ObjectIteratorWrapper {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Objects", ctx, q)
	ret0, _ := ret[0].(ObjectIteratorWrapper)
	return ret0
}

// Objects indicates an expected call of Objects.
func (mr *MockBucketHandleWrapperMockRecorder) Objects(ctx, q interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Objects", reflect.TypeOf((*MockBucketHandleWrapper)(nil).Objects), ctx, q)
}

// MockObjectHandleWrapper is a mock of ObjectHandleWrapper interface.
type MockObjectHandleWrapper struct {
	ctrl     *gomock.Controller
	recorder *MockObjectHandleWrapperMockRecorder
}

// MockObjectHandleWrapperMockRecorder is the mock recorder for MockObjectHandleWrapper.
type MockObjectHandleWrapperMockRecorder struct {
	mock *MockObjectHandleWrapper
}

// NewMockObjectHandleWrapper creates a new mock instance.
func NewMockObjectHandleWrapper(ctrl *gomock.Controller) *MockObjectHandleWrapper {
	mock := &MockObjectHandleWrapper{ctrl: ctrl}
	mock.recorder = &MockObjectHandleWrapperMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockObjectHandleWrapper) EXPECT() *MockObjectHandleWrapperMockRecorder {
	return m.recorder
}

// Attrs mocks base method.
func (m *MockObjectHandleWrapper) Attrs(ctx context.Context) (*storage.ObjectAttrs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Attrs", ctx)
	ret0, _ := ret[0].(*storage.ObjectAttrs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Attrs indicates an expected call of Attrs.
func (mr *MockObjectHandleWrapperMockRecorder) Attrs(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Attrs", reflect.TypeOf((*MockObjectHandleWrapper)(nil).Attrs), ctx)
}

// NewReader mocks base method.
func (m *MockObjectHandleWrapper) NewReader(ctx context.Context) (ReaderWrapper, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewReader", ctx)
	ret0, _ := ret[0].(ReaderWrapper)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewReader indicates an expected call of NewReader.
func (mr *MockObjectHandleWrapperMockRecorder) NewReader(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewReader", reflect.TypeOf((*MockObjectHandleWrapper)(nil).NewReader), ctx)
}

// NewWriter mocks base method.
func (m *MockObjectHandleWrapper) NewWriter(ctx context.Context) WriterWrapper {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewWriter", ctx)
	ret0, _ := ret[0].(WriterWrapper)
	return ret0
}

// NewWriter indicates an expected call of NewWriter.
func (mr *MockObjectHandleWrapperMockRecorder) NewWriter(ctx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewWriter", reflect.TypeOf((*MockObjectHandleWrapper)(nil).NewWriter), ctx)
}

// MockWriterWrapper is a mock of WriterWrapper interface.
type MockWriterWrapper struct {
	ctrl     *gomock.Controller
	recorder *MockWriterWrapperMockRecorder
}

// MockWriterWrapperMockRecorder is the mock recorder for MockWriterWrapper.
type MockWriterWrapperMockRecorder struct {
	mock *MockWriterWrapper
}

// NewMockWriterWrapper creates a new mock instance.
func NewMockWriterWrapper(ctrl *gomock.Controller) *MockWriterWrapper {
	mock := &MockWriterWrapper{ctrl: ctrl}
	mock.recorder = &MockWriterWrapperMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockWriterWrapper) EXPECT() *MockWriterWrapperMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockWriterWrapper) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close.
func (mr *MockWriterWrapperMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockWriterWrapper)(nil).Close))
}

// CloseWithError mocks base method.
func (m *MockWriterWrapper) CloseWithError(err error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CloseWithError", err)
	ret0, _ := ret[0].(error)
	return ret0
}

// CloseWithError indicates an expected call of CloseWithError.
func (mr *MockWriterWrapperMockRecorder) CloseWithError(err interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CloseWithError", reflect.TypeOf((*MockWriterWrapper)(nil).CloseWithError), err)
}

// Write mocks base method.
func (m *MockWriterWrapper) Write(p []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Write", p)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Write indicates an expected call of Write.
func (mr *MockWriterWrapperMockRecorder) Write(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*MockWriterWrapper)(nil).Write), p)
}

// MockReaderWrapper is a mock of ReaderWrapper interface.
type MockReaderWrapper struct {
	ctrl     *gomock.Controller
	recorder *MockReaderWrapperMockRecorder
}

// MockReaderWrapperMockRecorder is the mock recorder for MockReaderWrapper.
type MockReaderWrapperMockRecorder struct {
	mock *MockReaderWrapper
}

// NewMockReaderWrapper creates a new mock instance.
func NewMockReaderWrapper(ctrl *gomock.Controller) *MockReaderWrapper {
	mock := &MockReaderWrapper{ctrl: ctrl}
	mock.recorder = &MockReaderWrapperMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockReaderWrapper) EXPECT() *MockReaderWrapperMockRecorder {
	return m.recorder
}

// Close mocks base method.
func (m *MockReaderWrapper) Close() error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Close")
	ret0, _ := ret[0].(error)
	return ret0
}

// Close indicates an expected call of Close.
func (mr *MockReaderWrapperMockRecorder) Close() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockReaderWrapper)(nil).Close))
}

// Read mocks base method.
func (m *MockReaderWrapper) Read(p []byte) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Read", p)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Read indicates an expected call of Read.
func (mr *MockReaderWrapperMockRecorder) Read(p interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*MockReaderWrapper)(nil).Read), p)
}

// MockObjectIteratorWrapper is a mock of ObjectIteratorWrapper interface.
type MockObjectIteratorWrapper struct {
	ctrl     *gomock.Controller
	recorder *MockObjectIteratorWrapperMockRecorder
}

// MockObjectIteratorWrapperMockRecorder is the mock recorder for MockObjectIteratorWrapper.
type MockObjectIteratorWrapperMockRecorder struct {
	mock *MockObjectIteratorWrapper
}

// NewMockObjectIteratorWrapper creates a new mock instance.
func NewMockObjectIteratorWrapper(ctrl *gomock.Controller) *MockObjectIteratorWrapper {
	mock := &MockObjectIteratorWrapper{ctrl: ctrl}
	mock.recorder = &MockObjectIteratorWrapperMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockObjectIteratorWrapper) EXPECT() *MockObjectIteratorWrapperMockRecorder {
	return m.recorder
}

// Next mocks base method.
func (m *MockObjectIteratorWrapper) Next() (*storage.ObjectAttrs, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Next")
	ret0, _ := ret[0].(*storage.ObjectAttrs)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Next indicates an expected call of Next.
func (mr *MockObjectIteratorWrapperMockRecorder) Next() *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Next", reflect.TypeOf((*MockObjectIteratorWrapper)(nil).Next))
}