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

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

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

import (
	context "context"
	reflect "reflect"

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

// 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
}

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

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

// MockConfig is a mock of Config interface.
type MockConfig struct {
	ctrl     *gomock.Controller
	recorder *MockConfigMockRecorder
}

// MockConfigMockRecorder is the mock recorder for MockConfig.
type MockConfigMockRecorder struct {
	mock *MockConfig
}

// NewMockConfig creates a new mock instance.
func NewMockConfig(ctrl *gomock.Controller) *MockConfig {
	mock := &MockConfig{ctrl: ctrl}
	mock.recorder = &MockConfigMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockEnvironmentConfig is a mock of EnvironmentConfig interface.
type MockEnvironmentConfig struct {
	ctrl     *gomock.Controller
	recorder *MockEnvironmentConfigMockRecorder
}

// MockEnvironmentConfigMockRecorder is the mock recorder for MockEnvironmentConfig.
type MockEnvironmentConfigMockRecorder struct {
	mock *MockEnvironmentConfig
}

// NewMockEnvironmentConfig creates a new mock instance.
func NewMockEnvironmentConfig(ctrl *gomock.Controller) *MockEnvironmentConfig {
	mock := &MockEnvironmentConfig{ctrl: ctrl}
	mock.recorder = &MockEnvironmentConfigMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// MockGlobalConfig is a mock of GlobalConfig interface.
type MockGlobalConfig struct {
	ctrl     *gomock.Controller
	recorder *MockGlobalConfigMockRecorder
}

// MockGlobalConfigMockRecorder is the mock recorder for MockGlobalConfig.
type MockGlobalConfigMockRecorder struct {
	mock *MockGlobalConfig
}

// NewMockGlobalConfig creates a new mock instance.
func NewMockGlobalConfig(ctrl *gomock.Controller) *MockGlobalConfig {
	mock := &MockGlobalConfig{ctrl: ctrl}
	mock.recorder = &MockGlobalConfigMockRecorder{mock}
	return mock
}

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

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

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

// EnvironmentForDest mocks base method.
func (m *MockGlobalConfig) EnvironmentForDest(arg0 context.Context, arg1 string) EnvironmentConfig {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EnvironmentForDest", arg0, arg1)
	ret0, _ := ret[0].(EnvironmentConfig)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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