kubernetes-operator/pkg/controller/jenkins/client/mockgen.go

// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/controller/jenkins/client/jenkins.go

// Package mock_client is a generated GoMock package.
package client

import (
	"github.com/bndr/gojenkins"
	"github.com/golang/mock/gomock"
	"reflect"
)

// MockJenkins is a mock of Jenkins interface
type MockJenkins struct {
	ctrl     *gomock.Controller
	recorder *MockJenkinsMockRecorder
}

// MockJenkinsMockRecorder is the mock recorder for MockJenkins
type MockJenkinsMockRecorder struct {
	mock *MockJenkins
}

// NewMockJenkins creates a new mock instance
func NewMockJenkins(ctrl *gomock.Controller) *MockJenkins {
	mock := &MockJenkins{ctrl: ctrl}
	mock.recorder = &MockJenkinsMockRecorder{mock}
	return mock
}

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

// GenerateToken mocks base method
func (m *MockJenkins) GenerateToken(userName, tokenName string) (*UserToken, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GenerateToken", userName, tokenName)
	ret0, _ := ret[0].(*UserToken)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GenerateToken indicates an expected call of GenerateToken
func (mr *MockJenkinsMockRecorder) GenerateToken(userName, tokenName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenerateToken", reflect.TypeOf((*MockJenkins)(nil).GenerateToken), userName, tokenName)
}

// Info mocks base method
func (m *MockJenkins) Info() (*gojenkins.ExecutorResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Info")
	ret0, _ := ret[0].(*gojenkins.ExecutorResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// CreateNode mocks base method
func (m *MockJenkins) CreateNode(name string, numExecutors int, description, remoteFS, label string, options ...interface{}) (*gojenkins.Node, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name, numExecutors, description, remoteFS, label}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateNode", varargs...)
	ret0, _ := ret[0].(*gojenkins.Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateNode indicates an expected call of CreateNode
func (mr *MockJenkinsMockRecorder) CreateNode(name, numExecutors, description, remoteFS, label interface{}, options ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name, numExecutors, description, remoteFS, label}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNode", reflect.TypeOf((*MockJenkins)(nil).CreateNode), varargs...)
}

// DeleteNode mocks base method
func (m *MockJenkins) DeleteNode(name string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteNode", name)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateFolder mocks base method
func (m *MockJenkins) CreateFolder(name string, parents ...string) (*gojenkins.Folder, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range parents {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateFolder", varargs...)
	ret0, _ := ret[0].(*gojenkins.Folder)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateFolder indicates an expected call of CreateFolder
func (mr *MockJenkinsMockRecorder) CreateFolder(name interface{}, parents ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, parents...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateFolder", reflect.TypeOf((*MockJenkins)(nil).CreateFolder), varargs...)
}

// CreateJobInFolder mocks base method
func (m *MockJenkins) CreateJobInFolder(config, jobName string, parentIDs ...string) (*gojenkins.Job, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{config, jobName}
	for _, a := range parentIDs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateJobInFolder", varargs...)
	ret0, _ := ret[0].(*gojenkins.Job)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateJobInFolder indicates an expected call of CreateJobInFolder
func (mr *MockJenkinsMockRecorder) CreateJobInFolder(config, jobName interface{}, parentIDs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{config, jobName}, parentIDs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateJobInFolder", reflect.TypeOf((*MockJenkins)(nil).CreateJobInFolder), varargs...)
}

// CreateJob mocks base method
func (m *MockJenkins) CreateJob(config string, options ...interface{}) (*gojenkins.Job, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{config}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "CreateJob", varargs...)
	ret0, _ := ret[0].(*gojenkins.Job)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateJob indicates an expected call of CreateJob
func (mr *MockJenkinsMockRecorder) CreateJob(config interface{}, options ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{config}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateJob", reflect.TypeOf((*MockJenkins)(nil).CreateJob), varargs...)
}

// CreateOrUpdateJob mocks base method
func (m *MockJenkins) CreateOrUpdateJob(config, jobName string) (*gojenkins.Job, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateOrUpdateJob", config, jobName)
	ret0, _ := ret[0].(*gojenkins.Job)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// CreateOrUpdateJob indicates an expected call of CreateOrUpdateJob
func (mr *MockJenkinsMockRecorder) CreateOrUpdateJob(config, jobName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateOrUpdateJob", reflect.TypeOf((*MockJenkins)(nil).CreateOrUpdateJob), config, jobName)
}

// RenameJob mocks base method
func (m *MockJenkins) RenameJob(job, name string) *gojenkins.Job {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RenameJob", job, name)
	ret0, _ := ret[0].(*gojenkins.Job)
	return ret0
}

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

// CopyJob mocks base method
func (m *MockJenkins) CopyJob(copyFrom, newName string) (*gojenkins.Job, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CopyJob", copyFrom, newName)
	ret0, _ := ret[0].(*gojenkins.Job)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CopyJob indicates an expected call of CopyJob
func (mr *MockJenkinsMockRecorder) CopyJob(copyFrom, newName interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyJob", reflect.TypeOf((*MockJenkins)(nil).CopyJob), copyFrom, newName)
}

// DeleteJob mocks base method
func (m *MockJenkins) DeleteJob(name string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteJob", name)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// BuildJob mocks base method
func (m *MockJenkins) BuildJob(name string, options ...interface{}) (int64, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{name}
	for _, a := range options {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "BuildJob", varargs...)
	ret0, _ := ret[0].(int64)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// BuildJob indicates an expected call of BuildJob
func (mr *MockJenkinsMockRecorder) BuildJob(name interface{}, options ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{name}, options...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildJob", reflect.TypeOf((*MockJenkins)(nil).BuildJob), varargs...)
}

// GetNode mocks base method
func (m *MockJenkins) GetNode(name string) (*gojenkins.Node, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetNode", name)
	ret0, _ := ret[0].(*gojenkins.Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetLabel mocks base method
func (m *MockJenkins) GetLabel(name string) (*gojenkins.Label, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetLabel", name)
	ret0, _ := ret[0].(*gojenkins.Label)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetBuild mocks base method
func (m *MockJenkins) GetBuild(jobName string, number int64) (*gojenkins.Build, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetBuild", jobName, number)
	ret0, _ := ret[0].(*gojenkins.Build)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetBuild indicates an expected call of GetBuild
func (mr *MockJenkinsMockRecorder) GetBuild(jobName, number interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetBuild", reflect.TypeOf((*MockJenkins)(nil).GetBuild), jobName, number)
}

// GetJob mocks base method
func (m *MockJenkins) GetJob(id string, parentIDs ...string) (*gojenkins.Job, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{id}
	for _, a := range parentIDs {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetJob", varargs...)
	ret0, _ := ret[0].(*gojenkins.Job)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetJob indicates an expected call of GetJob
func (mr *MockJenkinsMockRecorder) GetJob(id interface{}, parentIDs ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{id}, parentIDs...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetJob", reflect.TypeOf((*MockJenkins)(nil).GetJob), varargs...)
}

// GetSubJob mocks base method
func (m *MockJenkins) GetSubJob(parentID, childID string) (*gojenkins.Job, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetSubJob", parentID, childID)
	ret0, _ := ret[0].(*gojenkins.Job)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetSubJob indicates an expected call of GetSubJob
func (mr *MockJenkinsMockRecorder) GetSubJob(parentID, childID interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSubJob", reflect.TypeOf((*MockJenkins)(nil).GetSubJob), parentID, childID)
}

// GetFolder mocks base method
func (m *MockJenkins) GetFolder(id string, parents ...string) (*gojenkins.Folder, error) {
	m.ctrl.T.Helper()
	varargs := []interface{}{id}
	for _, a := range parents {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "GetFolder", varargs...)
	ret0, _ := ret[0].(*gojenkins.Folder)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetFolder indicates an expected call of GetFolder
func (mr *MockJenkinsMockRecorder) GetFolder(id interface{}, parents ...interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	varargs := append([]interface{}{id}, parents...)
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFolder", reflect.TypeOf((*MockJenkins)(nil).GetFolder), varargs...)
}

// GetAllNodes mocks base method
func (m *MockJenkins) GetAllNodes() ([]*gojenkins.Node, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllNodes")
	ret0, _ := ret[0].([]*gojenkins.Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAllBuildIds mocks base method
func (m *MockJenkins) GetAllBuildIds(job string) ([]gojenkins.JobBuild, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllBuildIds", job)
	ret0, _ := ret[0].([]gojenkins.JobBuild)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetAllBuildIds indicates an expected call of GetAllBuildIds
func (mr *MockJenkinsMockRecorder) GetAllBuildIds(job interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllBuildIds", reflect.TypeOf((*MockJenkins)(nil).GetAllBuildIds), job)
}

// GetAllJobNames mocks base method
func (m *MockJenkins) GetAllJobNames() ([]gojenkins.InnerJob, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllJobNames")
	ret0, _ := ret[0].([]gojenkins.InnerJob)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAllJobs mocks base method
func (m *MockJenkins) GetAllJobs() ([]*gojenkins.Job, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllJobs")
	ret0, _ := ret[0].([]*gojenkins.Job)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetQueue mocks base method
func (m *MockJenkins) GetQueue() (*gojenkins.Queue, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueue")
	ret0, _ := ret[0].(*gojenkins.Queue)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// GetQueueItem mocks base method
func (m *MockJenkins) GetQueueItem(id int64) (*gojenkins.Task, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetQueueItem", id)
	ret0, _ := ret[0].(*gojenkins.Task)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetArtifactData mocks base method
func (m *MockJenkins) GetArtifactData(id string) (*gojenkins.FingerPrintResponse, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetArtifactData", id)
	ret0, _ := ret[0].(*gojenkins.FingerPrintResponse)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetPlugins mocks base method
func (m *MockJenkins) GetPlugins(depth int) (*gojenkins.Plugins, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetPlugins", depth)
	ret0, _ := ret[0].(*gojenkins.Plugins)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetPlugins indicates an expected call of GetPlugins
func (mr *MockJenkinsMockRecorder) GetPlugins(depth interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPlugins", reflect.TypeOf((*MockJenkins)(nil).GetPlugins), depth)
}

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

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

// HasPlugin mocks base method
func (m *MockJenkins) HasPlugin(name string) (*gojenkins.Plugin, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HasPlugin", name)
	ret0, _ := ret[0].(*gojenkins.Plugin)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

// ValidateFingerPrint mocks base method
func (m *MockJenkins) ValidateFingerPrint(id string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ValidateFingerPrint", id)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetView mocks base method
func (m *MockJenkins) GetView(name string) (*gojenkins.View, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetView", name)
	ret0, _ := ret[0].(*gojenkins.View)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// GetAllViews mocks base method
func (m *MockJenkins) GetAllViews() ([]*gojenkins.View, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetAllViews")
	ret0, _ := ret[0].([]*gojenkins.View)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

// CreateView mocks base method
func (m *MockJenkins) CreateView(name, viewType string) (*gojenkins.View, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateView", name, viewType)
	ret0, _ := ret[0].(*gojenkins.View)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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