github.com/juju/juju@v0.0.0-20240430160146-1752b71fcf00/network/containerizer/bridgepolicy_mock_test.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/juju/juju/network/containerizer (interfaces: Container,Address,Subnet,LinkLayerDevice)
//
// Generated by this command:
//
//	mockgen -package containerizer -destination bridgepolicy_mock_test.go github.com/juju/juju/network/containerizer Container,Address,Subnet,LinkLayerDevice
//

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

import (
	reflect "reflect"

	set "github.com/juju/collections/set"
	constraints "github.com/juju/juju/core/constraints"
	instance "github.com/juju/juju/core/instance"
	network "github.com/juju/juju/core/network"
	state "github.com/juju/juju/state"
	gomock "go.uber.org/mock/gomock"
)

// MockContainer is a mock of Container interface.
type MockContainer struct {
	ctrl     *gomock.Controller
	recorder *MockContainerMockRecorder
}

// MockContainerMockRecorder is the mock recorder for MockContainer.
type MockContainerMockRecorder struct {
	mock *MockContainer
}

// NewMockContainer creates a new mock instance.
func NewMockContainer(ctrl *gomock.Controller) *MockContainer {
	mock := &MockContainer{ctrl: ctrl}
	mock.recorder = &MockContainerMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// Raw mocks base method.
func (m *MockContainer) Raw() *state.Machine {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Raw")
	ret0, _ := ret[0].(*state.Machine)
	return ret0
}

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

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

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

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

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

// SetDevicesAddresses mocks base method.
func (m *MockContainer) SetDevicesAddresses(arg0 ...state.LinkLayerDeviceAddress) error {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetDevicesAddresses", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// SetLinkLayerDevices mocks base method.
func (m *MockContainer) SetLinkLayerDevices(arg0 ...state.LinkLayerDeviceArgs) error {
	m.ctrl.T.Helper()
	varargs := []any{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetLinkLayerDevices", varargs...)
	ret0, _ := ret[0].(error)
	return ret0
}

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

// MockAddress is a mock of Address interface.
type MockAddress struct {
	ctrl     *gomock.Controller
	recorder *MockAddressMockRecorder
}

// MockAddressMockRecorder is the mock recorder for MockAddress.
type MockAddressMockRecorder struct {
	mock *MockAddress
}

// NewMockAddress creates a new mock instance.
func NewMockAddress(ctrl *gomock.Controller) *MockAddress {
	mock := &MockAddress{ctrl: ctrl}
	mock.recorder = &MockAddressMockRecorder{mock}
	return mock
}

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

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

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

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

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

// MockSubnet is a mock of Subnet interface.
type MockSubnet struct {
	ctrl     *gomock.Controller
	recorder *MockSubnetMockRecorder
}

// MockSubnetMockRecorder is the mock recorder for MockSubnet.
type MockSubnetMockRecorder struct {
	mock *MockSubnet
}

// NewMockSubnet creates a new mock instance.
func NewMockSubnet(ctrl *gomock.Controller) *MockSubnet {
	mock := &MockSubnet{ctrl: ctrl}
	mock.recorder = &MockSubnetMockRecorder{mock}
	return mock
}

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

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

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

// MockLinkLayerDevice is a mock of LinkLayerDevice interface.
type MockLinkLayerDevice struct {
	ctrl     *gomock.Controller
	recorder *MockLinkLayerDeviceMockRecorder
}

// MockLinkLayerDeviceMockRecorder is the mock recorder for MockLinkLayerDevice.
type MockLinkLayerDeviceMockRecorder struct {
	mock *MockLinkLayerDevice
}

// NewMockLinkLayerDevice creates a new mock instance.
func NewMockLinkLayerDevice(ctrl *gomock.Controller) *MockLinkLayerDevice {
	mock := &MockLinkLayerDevice{ctrl: ctrl}
	mock.recorder = &MockLinkLayerDeviceMockRecorder{mock}
	return mock
}

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

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

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

// EthernetDeviceForBridge mocks base method.
func (m *MockLinkLayerDevice) EthernetDeviceForBridge(arg0 string, arg1 bool) (network.InterfaceInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "EthernetDeviceForBridge", arg0, arg1)
	ret0, _ := ret[0].(network.InterfaceInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Type mocks base method.
func (m *MockLinkLayerDevice) Type() network.LinkLayerDeviceType {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Type")
	ret0, _ := ret[0].(network.LinkLayerDeviceType)
	return ret0
}

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

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

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