github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/worker/provisioner/mocks/provisioner.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/juju/juju/worker/provisioner (interfaces: ContainerMachine,ContainerMachineGetter,TaskAPI)
//
// Generated by this command:
//
//	mockgen -package mocks -destination mocks/provisioner.go github.com/juju/juju/worker/provisioner ContainerMachine,ContainerMachineGetter,TaskAPI
//

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

import (
	reflect "reflect"

	provisioner "github.com/juju/juju/api/agent/provisioner"
	instance "github.com/juju/juju/core/instance"
	life "github.com/juju/juju/core/life"
	watcher "github.com/juju/juju/core/watcher"
	params "github.com/juju/juju/rpc/params"
	provisioner0 "github.com/juju/juju/worker/provisioner"
	names "github.com/juju/names/v5"
	gomock "go.uber.org/mock/gomock"
)

// MockContainerMachine is a mock of ContainerMachine interface.
type MockContainerMachine struct {
	ctrl     *gomock.Controller
	recorder *MockContainerMachineMockRecorder
}

// MockContainerMachineMockRecorder is the mock recorder for MockContainerMachine.
type MockContainerMachineMockRecorder struct {
	mock *MockContainerMachine
}

// NewMockContainerMachine creates a new mock instance.
func NewMockContainerMachine(ctrl *gomock.Controller) *MockContainerMachine {
	mock := &MockContainerMachine{ctrl: ctrl}
	mock.recorder = &MockContainerMachineMockRecorder{mock}
	return mock
}

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

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

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

// Life mocks base method.
func (m *MockContainerMachine) Life() life.Value {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Life")
	ret0, _ := ret[0].(life.Value)
	return ret0
}

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

// SupportedContainers mocks base method.
func (m *MockContainerMachine) SupportedContainers() ([]instance.ContainerType, bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "SupportedContainers")
	ret0, _ := ret[0].([]instance.ContainerType)
	ret1, _ := ret[1].(bool)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

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

// WatchContainers mocks base method.
func (m *MockContainerMachine) WatchContainers(arg0 instance.ContainerType) (watcher.StringsWatcher, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "WatchContainers", arg0)
	ret0, _ := ret[0].(watcher.StringsWatcher)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// WatchContainers indicates an expected call of WatchContainers.
func (mr *MockContainerMachineMockRecorder) WatchContainers(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WatchContainers", reflect.TypeOf((*MockContainerMachine)(nil).WatchContainers), arg0)
}

// MockContainerMachineGetter is a mock of ContainerMachineGetter interface.
type MockContainerMachineGetter struct {
	ctrl     *gomock.Controller
	recorder *MockContainerMachineGetterMockRecorder
}

// MockContainerMachineGetterMockRecorder is the mock recorder for MockContainerMachineGetter.
type MockContainerMachineGetterMockRecorder struct {
	mock *MockContainerMachineGetter
}

// NewMockContainerMachineGetter creates a new mock instance.
func NewMockContainerMachineGetter(ctrl *gomock.Controller) *MockContainerMachineGetter {
	mock := &MockContainerMachineGetter{ctrl: ctrl}
	mock.recorder = &MockContainerMachineGetterMockRecorder{mock}
	return mock
}

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

// Machines mocks base method.
func (m *MockContainerMachineGetter) Machines(arg0 ...names.MachineTag) ([]provisioner0.ContainerMachineResult, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Machines", varargs...)
	ret0, _ := ret[0].([]provisioner0.ContainerMachineResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Machines indicates an expected call of Machines.
func (mr *MockContainerMachineGetterMockRecorder) Machines(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Machines", reflect.TypeOf((*MockContainerMachineGetter)(nil).Machines), arg0...)
}

// MockTaskAPI is a mock of TaskAPI interface.
type MockTaskAPI struct {
	ctrl     *gomock.Controller
	recorder *MockTaskAPIMockRecorder
}

// MockTaskAPIMockRecorder is the mock recorder for MockTaskAPI.
type MockTaskAPIMockRecorder struct {
	mock *MockTaskAPI
}

// NewMockTaskAPI creates a new mock instance.
func NewMockTaskAPI(ctrl *gomock.Controller) *MockTaskAPI {
	mock := &MockTaskAPI{ctrl: ctrl}
	mock.recorder = &MockTaskAPIMockRecorder{mock}
	return mock
}

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

// Machines mocks base method.
func (m *MockTaskAPI) Machines(arg0 ...names.MachineTag) ([]provisioner.MachineResult, error) {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "Machines", varargs...)
	ret0, _ := ret[0].([]provisioner.MachineResult)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Machines indicates an expected call of Machines.
func (mr *MockTaskAPIMockRecorder) Machines(arg0 ...any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Machines", reflect.TypeOf((*MockTaskAPI)(nil).Machines), arg0...)
}

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

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

// ProvisioningInfo mocks base method.
func (m *MockTaskAPI) ProvisioningInfo(arg0 []names.MachineTag) (params.ProvisioningInfoResults, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProvisioningInfo", arg0)
	ret0, _ := ret[0].(params.ProvisioningInfoResults)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ProvisioningInfo indicates an expected call of ProvisioningInfo.
func (mr *MockTaskAPIMockRecorder) ProvisioningInfo(arg0 any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProvisioningInfo", reflect.TypeOf((*MockTaskAPI)(nil).ProvisioningInfo), arg0)
}