github.com/release-engineering/exodus-rsync@v1.11.2/internal/gw/mock.go

// Code generated by MockGen. DO NOT EDIT.
// Source: gw.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	conf "github.com/release-engineering/exodus-rsync/internal/conf"
	walk "github.com/release-engineering/exodus-rsync/internal/walk"
)

// MockInterface is a mock of Interface interface.
type MockInterface struct {
	ctrl     *gomock.Controller
	recorder *MockInterfaceMockRecorder
}

// MockInterfaceMockRecorder is the mock recorder for MockInterface.
type MockInterfaceMockRecorder struct {
	mock *MockInterface
}

// NewMockInterface creates a new mock instance.
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
	mock := &MockInterface{ctrl: ctrl}
	mock.recorder = &MockInterfaceMockRecorder{mock}
	return mock
}

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

// NewClient mocks base method.
func (m *MockInterface) NewClient(arg0 context.Context, arg1 conf.Config) (Client, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewClient", arg0, arg1)
	ret0, _ := ret[0].(Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewClient indicates an expected call of NewClient.
func (mr *MockInterfaceMockRecorder) NewClient(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewClient", reflect.TypeOf((*MockInterface)(nil).NewClient), arg0, arg1)
}

// NewDryRunClient mocks base method.
func (m *MockInterface) NewDryRunClient(arg0 context.Context, arg1 conf.Config) (Client, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "NewDryRunClient", arg0, arg1)
	ret0, _ := ret[0].(Client)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// NewDryRunClient indicates an expected call of NewDryRunClient.
func (mr *MockInterfaceMockRecorder) NewDryRunClient(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewDryRunClient", reflect.TypeOf((*MockInterface)(nil).NewDryRunClient), arg0, arg1)
}

// MockClient is a mock of Client interface.
type MockClient struct {
	ctrl     *gomock.Controller
	recorder *MockClientMockRecorder
}

// MockClientMockRecorder is the mock recorder for MockClient.
type MockClientMockRecorder struct {
	mock *MockClient
}

// NewMockClient creates a new mock instance.
func NewMockClient(ctrl *gomock.Controller) *MockClient {
	mock := &MockClient{ctrl: ctrl}
	mock.recorder = &MockClientMockRecorder{mock}
	return mock
}

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

// EnsureUploaded mocks base method.
func (m *MockClient) EnsureUploaded(ctx context.Context, items []walk.SyncItem, onUploaded, onPresent, onDuplicate func(walk.SyncItem) error) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnsureUploaded", ctx, items, onUploaded, onPresent, onDuplicate)
	ret0, _ := ret[0].(error)
	return ret0
}

// EnsureUploaded indicates an expected call of EnsureUploaded.
func (mr *MockClientMockRecorder) EnsureUploaded(ctx, items, onUploaded, onPresent, onDuplicate interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "EnsureUploaded", reflect.TypeOf((*MockClient)(nil).EnsureUploaded), ctx, items, onUploaded, onPresent, onDuplicate)
}

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

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

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

// NewPublish indicates an expected call of NewPublish.
func (mr *MockClientMockRecorder) NewPublish(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewPublish", reflect.TypeOf((*MockClient)(nil).NewPublish), arg0)
}

// WhoAmI mocks base method.
func (m *MockClient) WhoAmI(arg0 context.Context) (map[string]interface{}, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WhoAmI", arg0)
	ret0, _ := ret[0].(map[string]interface{})
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WhoAmI indicates an expected call of WhoAmI.
func (mr *MockClientMockRecorder) WhoAmI(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WhoAmI", reflect.TypeOf((*MockClient)(nil).WhoAmI), arg0)
}

// MockPublish is a mock of Publish interface.
type MockPublish struct {
	ctrl     *gomock.Controller
	recorder *MockPublishMockRecorder
}

// MockPublishMockRecorder is the mock recorder for MockPublish.
type MockPublishMockRecorder struct {
	mock *MockPublish
}

// NewMockPublish creates a new mock instance.
func NewMockPublish(ctrl *gomock.Controller) *MockPublish {
	mock := &MockPublish{ctrl: ctrl}
	mock.recorder = &MockPublishMockRecorder{mock}
	return mock
}

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

// AddItems mocks base method.
func (m *MockPublish) AddItems(arg0 context.Context, arg1 []ItemInput) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AddItems", arg0, arg1)
	ret0, _ := ret[0].(error)
	return ret0
}

// AddItems indicates an expected call of AddItems.
func (mr *MockPublishMockRecorder) AddItems(arg0, arg1 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddItems", reflect.TypeOf((*MockPublish)(nil).AddItems), arg0, arg1)
}

// Commit mocks base method.
func (m *MockPublish) Commit(ctx context.Context, mode string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Commit", ctx, mode)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

// MockTask is a mock of Task interface.
type MockTask struct {
	ctrl     *gomock.Controller
	recorder *MockTaskMockRecorder
}

// MockTaskMockRecorder is the mock recorder for MockTask.
type MockTaskMockRecorder struct {
	mock *MockTask
}

// NewMockTask creates a new mock instance.
func NewMockTask(ctrl *gomock.Controller) *MockTask {
	mock := &MockTask{ctrl: ctrl}
	mock.recorder = &MockTaskMockRecorder{mock}
	return mock
}

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

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

// Await indicates an expected call of Await.
func (mr *MockTaskMockRecorder) Await(arg0 interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Await", reflect.TypeOf((*MockTask)(nil).Await), arg0)
}

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

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