// Code generated by mockery v2.12.3. DO NOT EDIT.

package mocks

import (
	errors "github.com/pingcap/test-infra/common/errors"
	config "github.com/pingcap/test-infra/services/rms/config"

	mock "github.com/stretchr/testify/mock"

	request "github.com/pingcap/test-infra/common/model/rms/request"

	response "github.com/pingcap/test-infra/common/model/rms/response"

	utils "github.com/pingcap/test-infra/services/rms/utils"
)

// ServiceInterface is an autogenerated mock type for the ServiceInterface type
type ServiceInterface struct {
	mock.Mock
}

// AuthTestbed provides a mock function with given fields: ctx, req
func (_m *ServiceInterface) AuthTestbed(ctx utils.Context, req request.AuthTestbedRequest) *errors.StatusError {
	ret := _m.Called(ctx, req)

	var r0 *errors.StatusError
	if rf, ok := ret.Get(0).(func(utils.Context, request.AuthTestbedRequest) *errors.StatusError); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*errors.StatusError)
		}
	}

	return r0
}

// CheckTestbed provides a mock function with given fields: ctx, testbed
func (_m *ServiceInterface) CheckTestbed(ctx utils.Context, testbed string) (*response.CheckTestbedResponse, *errors.StatusError) {
	ret := _m.Called(ctx, testbed)

	var r0 *response.CheckTestbedResponse
	if rf, ok := ret.Get(0).(func(utils.Context, string) *response.CheckTestbedResponse); ok {
		r0 = rf(ctx, testbed)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*response.CheckTestbedResponse)
		}
	}

	var r1 *errors.StatusError
	if rf, ok := ret.Get(1).(func(utils.Context, string) *errors.StatusError); ok {
		r1 = rf(ctx, testbed)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*errors.StatusError)
		}
	}

	return r0, r1
}

// CreateTestbed provides a mock function with given fields: ctx, req
func (_m *ServiceInterface) CreateTestbed(ctx utils.Context, req request.CreateTestbedRequest) (*response.CreateTestbedResponse, *errors.StatusError) {
	ret := _m.Called(ctx, req)

	var r0 *response.CreateTestbedResponse
	if rf, ok := ret.Get(0).(func(utils.Context, request.CreateTestbedRequest) *response.CreateTestbedResponse); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*response.CreateTestbedResponse)
		}
	}

	var r1 *errors.StatusError
	if rf, ok := ret.Get(1).(func(utils.Context, request.CreateTestbedRequest) *errors.StatusError); ok {
		r1 = rf(ctx, req)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*errors.StatusError)
		}
	}

	return r0, r1
}

// DeleteTestbed provides a mock function with given fields: ctx, testbed
func (_m *ServiceInterface) DeleteTestbed(ctx utils.Context, testbed string) *errors.StatusError {
	ret := _m.Called(ctx, testbed)

	var r0 *errors.StatusError
	if rf, ok := ret.Get(0).(func(utils.Context, string) *errors.StatusError); ok {
		r0 = rf(ctx, testbed)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*errors.StatusError)
		}
	}

	return r0
}

// GenerateCredential provides a mock function with given fields: ctx, user, req
func (_m *ServiceInterface) GenerateCredential(ctx utils.Context, user utils.User, req request.CredentialRequest) (*response.CredentialResponse, *errors.StatusError) {
	ret := _m.Called(ctx, user, req)

	var r0 *response.CredentialResponse
	if rf, ok := ret.Get(0).(func(utils.Context, utils.User, request.CredentialRequest) *response.CredentialResponse); ok {
		r0 = rf(ctx, user, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*response.CredentialResponse)
		}
	}

	var r1 *errors.StatusError
	if rf, ok := ret.Get(1).(func(utils.Context, utils.User, request.CredentialRequest) *errors.StatusError); ok {
		r1 = rf(ctx, user, req)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*errors.StatusError)
		}
	}

	return r0, r1
}

// GetLease provides a mock function with given fields: ctx, testbed
func (_m *ServiceInterface) GetLease(ctx utils.Context, testbed string) (*response.LeaseResponse, *errors.StatusError) {
	ret := _m.Called(ctx, testbed)

	var r0 *response.LeaseResponse
	if rf, ok := ret.Get(0).(func(utils.Context, string) *response.LeaseResponse); ok {
		r0 = rf(ctx, testbed)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*response.LeaseResponse)
		}
	}

	var r1 *errors.StatusError
	if rf, ok := ret.Get(1).(func(utils.Context, string) *errors.StatusError); ok {
		r1 = rf(ctx, testbed)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*errors.StatusError)
		}
	}

	return r0, r1
}

// GetLogLinks provides a mock function with given fields: ctx, testbed
func (_m *ServiceInterface) GetLogLinks(ctx utils.Context, testbed string) (*response.GetLogLinksResponse, *errors.StatusError) {
	ret := _m.Called(ctx, testbed)

	var r0 *response.GetLogLinksResponse
	if rf, ok := ret.Get(0).(func(utils.Context, string) *response.GetLogLinksResponse); ok {
		r0 = rf(ctx, testbed)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*response.GetLogLinksResponse)
		}
	}

	var r1 *errors.StatusError
	if rf, ok := ret.Get(1).(func(utils.Context, string) *errors.StatusError); ok {
		r1 = rf(ctx, testbed)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*errors.StatusError)
		}
	}

	return r0, r1
}

// GetProxy provides a mock function with given fields: ctx
func (_m *ServiceInterface) GetProxy(ctx utils.Context) (*config.ProxyConfig, *errors.StatusError) {
	ret := _m.Called(ctx)

	var r0 *config.ProxyConfig
	if rf, ok := ret.Get(0).(func(utils.Context) *config.ProxyConfig); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*config.ProxyConfig)
		}
	}

	var r1 *errors.StatusError
	if rf, ok := ret.Get(1).(func(utils.Context) *errors.StatusError); ok {
		r1 = rf(ctx)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*errors.StatusError)
		}
	}

	return r0, r1
}

// GetShootKubeConfig provides a mock function with given fields: ctx, req
func (_m *ServiceInterface) GetShootKubeConfig(ctx utils.Context, req request.GetShootKubeConfigRequest) (*response.GetShootKubeConfigResponse, *errors.StatusError) {
	ret := _m.Called(ctx, req)

	var r0 *response.GetShootKubeConfigResponse
	if rf, ok := ret.Get(0).(func(utils.Context, request.GetShootKubeConfigRequest) *response.GetShootKubeConfigResponse); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*response.GetShootKubeConfigResponse)
		}
	}

	var r1 *errors.StatusError
	if rf, ok := ret.Get(1).(func(utils.Context, request.GetShootKubeConfigRequest) *errors.StatusError); ok {
		r1 = rf(ctx, req)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*errors.StatusError)
		}
	}

	return r0, r1
}

// GetTemporaryECRImageSyncCredential provides a mock function with given fields: ctx
func (_m *ServiceInterface) GetTemporaryECRImageSyncCredential(ctx utils.Context) (*response.GetTemporaryECRImageSyncCredentialResponse, *errors.StatusError) {
	ret := _m.Called(ctx)

	var r0 *response.GetTemporaryECRImageSyncCredentialResponse
	if rf, ok := ret.Get(0).(func(utils.Context) *response.GetTemporaryECRImageSyncCredentialResponse); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*response.GetTemporaryECRImageSyncCredentialResponse)
		}
	}

	var r1 *errors.StatusError
	if rf, ok := ret.Get(1).(func(utils.Context) *errors.StatusError); ok {
		r1 = rf(ctx)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*errors.StatusError)
		}
	}

	return r0, r1
}

// GetTestbed provides a mock function with given fields: ctx, testbed, withDetails
func (_m *ServiceInterface) GetTestbed(ctx utils.Context, testbed string, withDetails bool) (*response.GetTestbedResponse, *errors.StatusError) {
	ret := _m.Called(ctx, testbed, withDetails)

	var r0 *response.GetTestbedResponse
	if rf, ok := ret.Get(0).(func(utils.Context, string, bool) *response.GetTestbedResponse); ok {
		r0 = rf(ctx, testbed, withDetails)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*response.GetTestbedResponse)
		}
	}

	var r1 *errors.StatusError
	if rf, ok := ret.Get(1).(func(utils.Context, string, bool) *errors.StatusError); ok {
		r1 = rf(ctx, testbed, withDetails)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*errors.StatusError)
		}
	}

	return r0, r1
}

// ListTestbed provides a mock function with given fields: ctx
func (_m *ServiceInterface) ListTestbed(ctx utils.Context) (*response.ListTestbedResponse, *errors.StatusError) {
	ret := _m.Called(ctx)

	var r0 *response.ListTestbedResponse
	if rf, ok := ret.Get(0).(func(utils.Context) *response.ListTestbedResponse); ok {
		r0 = rf(ctx)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*response.ListTestbedResponse)
		}
	}

	var r1 *errors.StatusError
	if rf, ok := ret.Get(1).(func(utils.Context) *errors.StatusError); ok {
		r1 = rf(ctx)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*errors.StatusError)
		}
	}

	return r0, r1
}

// OnCompletion provides a mock function with given fields: ctx, req
func (_m *ServiceInterface) OnCompletion(ctx utils.Context, req request.OnTestbedCompletionRequest) *errors.StatusError {
	ret := _m.Called(ctx, req)

	var r0 *errors.StatusError
	if rf, ok := ret.Get(0).(func(utils.Context, request.OnTestbedCompletionRequest) *errors.StatusError); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*errors.StatusError)
		}
	}

	return r0
}

// ReclaimTestbed provides a mock function with given fields:
func (_m *ServiceInterface) ReclaimTestbed() *errors.StatusError {
	ret := _m.Called()

	var r0 *errors.StatusError
	if rf, ok := ret.Get(0).(func() *errors.StatusError); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*errors.StatusError)
		}
	}

	return r0
}

// RenewLease provides a mock function with given fields: ctx, testbed, lease
func (_m *ServiceInterface) RenewLease(ctx utils.Context, testbed string, lease request.DurationStr) (*response.RenewalLeaseResponse, *errors.StatusError) {
	ret := _m.Called(ctx, testbed, lease)

	var r0 *response.RenewalLeaseResponse
	if rf, ok := ret.Get(0).(func(utils.Context, string, request.DurationStr) *response.RenewalLeaseResponse); ok {
		r0 = rf(ctx, testbed, lease)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*response.RenewalLeaseResponse)
		}
	}

	var r1 *errors.StatusError
	if rf, ok := ret.Get(1).(func(utils.Context, string, request.DurationStr) *errors.StatusError); ok {
		r1 = rf(ctx, testbed, lease)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*errors.StatusError)
		}
	}

	return r0, r1
}

// RestoreMonitor provides a mock function with given fields: ctx, req
func (_m *ServiceInterface) RestoreMonitor(ctx utils.Context, req request.RestoreMonitorRequest) (*response.RestoreMonitorResponse, *errors.StatusError) {
	ret := _m.Called(ctx, req)

	var r0 *response.RestoreMonitorResponse
	if rf, ok := ret.Get(0).(func(utils.Context, request.RestoreMonitorRequest) *response.RestoreMonitorResponse); ok {
		r0 = rf(ctx, req)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*response.RestoreMonitorResponse)
		}
	}

	var r1 *errors.StatusError
	if rf, ok := ret.Get(1).(func(utils.Context, request.RestoreMonitorRequest) *errors.StatusError); ok {
		r1 = rf(ctx, req)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*errors.StatusError)
		}
	}

	return r0, r1
}

type NewServiceInterfaceT interface {
	mock.TestingT
	Cleanup(func())
}

// NewServiceInterface creates a new instance of ServiceInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
func NewServiceInterface(t NewServiceInterfaceT) *ServiceInterface {
	mock := &ServiceInterface{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}