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

package mocks

import (
	errors "github.com/pingcap/test-infra/common/errors"
	core "github.com/pingcap/test-infra/sdk/core"

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

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

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

	resource "github.com/pingcap/test-infra/common/model/resource"

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

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

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

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

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

	return r0
}

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

	var r0 *response.CheckTestbedResponse
	if rf, ok := ret.Get(0).(func(utils.Context, string) *response.CheckTestbedResponse); ok {
		r0 = rf(ctx, testbedName)
	} 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, testbedName)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*errors.StatusError)
		}
	}

	return r0, r1
}

// CreateCredential provides a mock function with given fields: ctx, user, req
func (_m *Interface) CreateCredential(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
}

// CreateResource provides a mock function with given fields: ctx, _a1
func (_m *Interface) CreateResource(ctx utils.Context, _a1 model.TestBedItem) (core.Resource, *errors.StatusError) {
	ret := _m.Called(ctx, _a1)

	var r0 core.Resource
	if rf, ok := ret.Get(0).(func(utils.Context, model.TestBedItem) core.Resource); ok {
		r0 = rf(ctx, _a1)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(core.Resource)
		}
	}

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

	return r0, r1
}

// CreateTestbed provides a mock function with given fields: ctx, testbedReq
func (_m *Interface) CreateTestbed(ctx utils.Context, testbedReq request.CreateTestbedRequest) (*resource.TestBed, *errors.StatusError) {
	ret := _m.Called(ctx, testbedReq)

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

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

	return r0, r1
}

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

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

	return r0
}

// GetLease provides a mock function with given fields: ctx, testbed
func (_m *Interface) 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
}

// GetResource provides a mock function with given fields: ctx, _a1, withDetail
func (_m *Interface) GetResource(ctx utils.Context, _a1 resource.ResourceHandle, withDetail bool) (response.TestbedResponseItem, *errors.StatusError) {
	ret := _m.Called(ctx, _a1, withDetail)

	var r0 response.TestbedResponseItem
	if rf, ok := ret.Get(0).(func(utils.Context, resource.ResourceHandle, bool) response.TestbedResponseItem); ok {
		r0 = rf(ctx, _a1, withDetail)
	} else {
		r0 = ret.Get(0).(response.TestbedResponseItem)
	}

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

	return r0, r1
}

// GetRestoredMonitorInfo provides a mock function with given fields: ctx, restoredTestbed
func (_m *Interface) GetRestoredMonitorInfo(ctx utils.Context, restoredTestbed string) (*response.RestoreMonitorResponse, *errors.StatusError) {
	ret := _m.Called(ctx, restoredTestbed)

	var r0 *response.RestoreMonitorResponse
	if rf, ok := ret.Get(0).(func(utils.Context, string) *response.RestoreMonitorResponse); ok {
		r0 = rf(ctx, restoredTestbed)
	} 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, string) *errors.StatusError); ok {
		r1 = rf(ctx, restoredTestbed)
	} 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 *Interface) 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
}

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

	var r0 *response.GetTestbedResponse
	if rf, ok := ret.Get(0).(func(utils.Context, string, bool) *response.GetTestbedResponse); ok {
		r0 = rf(ctx, testbedName, 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, testbedName, 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 *Interface) 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 *Interface) 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 *Interface) 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 *Interface) 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
}

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

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

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

	return mock
}