// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/runtime/interface.go
//
// Generated by this command:
//
//	mockgen -source=pkg/runtime/interface.go -destination=internal/testutils/mocks/runtime_gen.go -package=mocks
//

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

import (
	context "context"
	runtime "gordon/pkg/runtime"
	io "io"
	reflect "reflect"

	gomock "go.uber.org/mock/gomock"
)

// MockRuntime is a mock of Runtime interface.
type MockRuntime struct {
	ctrl     *gomock.Controller
	recorder *MockRuntimeMockRecorder
	isgomock struct{}
}

// MockRuntimeMockRecorder is the mock recorder for MockRuntime.
type MockRuntimeMockRecorder struct {
	mock *MockRuntime
}

// NewMockRuntime creates a new mock instance.
func NewMockRuntime(ctrl *gomock.Controller) *MockRuntime {
	mock := &MockRuntime{ctrl: ctrl}
	mock.recorder = &MockRuntimeMockRecorder{mock}
	return mock
}

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

// ConnectContainerToNetwork mocks base method.
func (m *MockRuntime) ConnectContainerToNetwork(ctx context.Context, containerName, networkName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ConnectContainerToNetwork", ctx, containerName, networkName)
	ret0, _ := ret[0].(error)
	return ret0
}

// ConnectContainerToNetwork indicates an expected call of ConnectContainerToNetwork.
func (mr *MockRuntimeMockRecorder) ConnectContainerToNetwork(ctx, containerName, networkName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConnectContainerToNetwork", reflect.TypeOf((*MockRuntime)(nil).ConnectContainerToNetwork), ctx, containerName, networkName)
}

// CreateContainer mocks base method.
func (m *MockRuntime) CreateContainer(ctx context.Context, config *runtime.ContainerConfig) (*runtime.Container, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateContainer", ctx, config)
	ret0, _ := ret[0].(*runtime.Container)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// CreateContainer indicates an expected call of CreateContainer.
func (mr *MockRuntimeMockRecorder) CreateContainer(ctx, config any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateContainer", reflect.TypeOf((*MockRuntime)(nil).CreateContainer), ctx, config)
}

// CreateNetwork mocks base method.
func (m *MockRuntime) CreateNetwork(ctx context.Context, name string, options map[string]string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateNetwork", ctx, name, options)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateNetwork indicates an expected call of CreateNetwork.
func (mr *MockRuntimeMockRecorder) CreateNetwork(ctx, name, options any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateNetwork", reflect.TypeOf((*MockRuntime)(nil).CreateNetwork), ctx, name, options)
}

// CreateVolume mocks base method.
func (m *MockRuntime) CreateVolume(ctx context.Context, volumeName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "CreateVolume", ctx, volumeName)
	ret0, _ := ret[0].(error)
	return ret0
}

// CreateVolume indicates an expected call of CreateVolume.
func (mr *MockRuntimeMockRecorder) CreateVolume(ctx, volumeName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateVolume", reflect.TypeOf((*MockRuntime)(nil).CreateVolume), ctx, volumeName)
}

// DisconnectContainerFromNetwork mocks base method.
func (m *MockRuntime) DisconnectContainerFromNetwork(ctx context.Context, containerName, networkName string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DisconnectContainerFromNetwork", ctx, containerName, networkName)
	ret0, _ := ret[0].(error)
	return ret0
}

// DisconnectContainerFromNetwork indicates an expected call of DisconnectContainerFromNetwork.
func (mr *MockRuntimeMockRecorder) DisconnectContainerFromNetwork(ctx, containerName, networkName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DisconnectContainerFromNetwork", reflect.TypeOf((*MockRuntime)(nil).DisconnectContainerFromNetwork), ctx, containerName, networkName)
}

// GetContainerExposedPorts mocks base method.
func (m *MockRuntime) GetContainerExposedPorts(ctx context.Context, containerID string) ([]int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContainerExposedPorts", ctx, containerID)
	ret0, _ := ret[0].([]int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContainerExposedPorts indicates an expected call of GetContainerExposedPorts.
func (mr *MockRuntimeMockRecorder) GetContainerExposedPorts(ctx, containerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerExposedPorts", reflect.TypeOf((*MockRuntime)(nil).GetContainerExposedPorts), ctx, containerID)
}

// GetContainerLogs mocks base method.
func (m *MockRuntime) GetContainerLogs(ctx context.Context, containerID string, follow bool) (io.ReadCloser, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContainerLogs", ctx, containerID, follow)
	ret0, _ := ret[0].(io.ReadCloser)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContainerLogs indicates an expected call of GetContainerLogs.
func (mr *MockRuntimeMockRecorder) GetContainerLogs(ctx, containerID, follow any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerLogs", reflect.TypeOf((*MockRuntime)(nil).GetContainerLogs), ctx, containerID, follow)
}

// GetContainerNetworkInfo mocks base method.
func (m *MockRuntime) GetContainerNetworkInfo(ctx context.Context, containerID string) (string, int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContainerNetworkInfo", ctx, containerID)
	ret0, _ := ret[0].(string)
	ret1, _ := ret[1].(int)
	ret2, _ := ret[2].(error)
	return ret0, ret1, ret2
}

// GetContainerNetworkInfo indicates an expected call of GetContainerNetworkInfo.
func (mr *MockRuntimeMockRecorder) GetContainerNetworkInfo(ctx, containerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerNetworkInfo", reflect.TypeOf((*MockRuntime)(nil).GetContainerNetworkInfo), ctx, containerID)
}

// GetContainerPort mocks base method.
func (m *MockRuntime) GetContainerPort(ctx context.Context, containerID string, internalPort int) (int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetContainerPort", ctx, containerID, internalPort)
	ret0, _ := ret[0].(int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetContainerPort indicates an expected call of GetContainerPort.
func (mr *MockRuntimeMockRecorder) GetContainerPort(ctx, containerID, internalPort any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetContainerPort", reflect.TypeOf((*MockRuntime)(nil).GetContainerPort), ctx, containerID, internalPort)
}

// GetImageExposedPorts mocks base method.
func (m *MockRuntime) GetImageExposedPorts(ctx context.Context, imageRef string) ([]int, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetImageExposedPorts", ctx, imageRef)
	ret0, _ := ret[0].([]int)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// GetImageExposedPorts indicates an expected call of GetImageExposedPorts.
func (mr *MockRuntimeMockRecorder) GetImageExposedPorts(ctx, imageRef any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetImageExposedPorts", reflect.TypeOf((*MockRuntime)(nil).GetImageExposedPorts), ctx, imageRef)
}

// InspectContainer mocks base method.
func (m *MockRuntime) InspectContainer(ctx context.Context, containerID string) (*runtime.Container, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InspectContainer", ctx, containerID)
	ret0, _ := ret[0].(*runtime.Container)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InspectContainer indicates an expected call of InspectContainer.
func (mr *MockRuntimeMockRecorder) InspectContainer(ctx, containerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectContainer", reflect.TypeOf((*MockRuntime)(nil).InspectContainer), ctx, containerID)
}

// InspectImageEnv mocks base method.
func (m *MockRuntime) InspectImageEnv(ctx context.Context, imageRef string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InspectImageEnv", ctx, imageRef)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InspectImageEnv indicates an expected call of InspectImageEnv.
func (mr *MockRuntimeMockRecorder) InspectImageEnv(ctx, imageRef any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectImageEnv", reflect.TypeOf((*MockRuntime)(nil).InspectImageEnv), ctx, imageRef)
}

// InspectImageVolumes mocks base method.
func (m *MockRuntime) InspectImageVolumes(ctx context.Context, imageRef string) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InspectImageVolumes", ctx, imageRef)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// InspectImageVolumes indicates an expected call of InspectImageVolumes.
func (mr *MockRuntimeMockRecorder) InspectImageVolumes(ctx, imageRef any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InspectImageVolumes", reflect.TypeOf((*MockRuntime)(nil).InspectImageVolumes), ctx, imageRef)
}

// IsContainerRunning mocks base method.
func (m *MockRuntime) IsContainerRunning(ctx context.Context, containerID string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "IsContainerRunning", ctx, containerID)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// IsContainerRunning indicates an expected call of IsContainerRunning.
func (mr *MockRuntimeMockRecorder) IsContainerRunning(ctx, containerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsContainerRunning", reflect.TypeOf((*MockRuntime)(nil).IsContainerRunning), ctx, containerID)
}

// ListContainers mocks base method.
func (m *MockRuntime) ListContainers(ctx context.Context, all bool) ([]*runtime.Container, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListContainers", ctx, all)
	ret0, _ := ret[0].([]*runtime.Container)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListContainers indicates an expected call of ListContainers.
func (mr *MockRuntimeMockRecorder) ListContainers(ctx, all any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListContainers", reflect.TypeOf((*MockRuntime)(nil).ListContainers), ctx, all)
}

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

// ListImages indicates an expected call of ListImages.
func (mr *MockRuntimeMockRecorder) ListImages(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListImages", reflect.TypeOf((*MockRuntime)(nil).ListImages), ctx)
}

// ListNetworks mocks base method.
func (m *MockRuntime) ListNetworks(ctx context.Context) ([]*runtime.NetworkInfo, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ListNetworks", ctx)
	ret0, _ := ret[0].([]*runtime.NetworkInfo)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ListNetworks indicates an expected call of ListNetworks.
func (mr *MockRuntimeMockRecorder) ListNetworks(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListNetworks", reflect.TypeOf((*MockRuntime)(nil).ListNetworks), ctx)
}

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

// NetworkExists indicates an expected call of NetworkExists.
func (mr *MockRuntimeMockRecorder) NetworkExists(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NetworkExists", reflect.TypeOf((*MockRuntime)(nil).NetworkExists), ctx, name)
}

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

// Ping indicates an expected call of Ping.
func (mr *MockRuntimeMockRecorder) Ping(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Ping", reflect.TypeOf((*MockRuntime)(nil).Ping), ctx)
}

// PullImage mocks base method.
func (m *MockRuntime) PullImage(ctx context.Context, image string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PullImage", ctx, image)
	ret0, _ := ret[0].(error)
	return ret0
}

// PullImage indicates an expected call of PullImage.
func (mr *MockRuntimeMockRecorder) PullImage(ctx, image any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImage", reflect.TypeOf((*MockRuntime)(nil).PullImage), ctx, image)
}

// PullImageWithAuth mocks base method.
func (m *MockRuntime) PullImageWithAuth(ctx context.Context, image, username, password string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "PullImageWithAuth", ctx, image, username, password)
	ret0, _ := ret[0].(error)
	return ret0
}

// PullImageWithAuth indicates an expected call of PullImageWithAuth.
func (mr *MockRuntimeMockRecorder) PullImageWithAuth(ctx, image, username, password any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PullImageWithAuth", reflect.TypeOf((*MockRuntime)(nil).PullImageWithAuth), ctx, image, username, password)
}

// RemoveContainer mocks base method.
func (m *MockRuntime) RemoveContainer(ctx context.Context, containerID string, force bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveContainer", ctx, containerID, force)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveContainer indicates an expected call of RemoveContainer.
func (mr *MockRuntimeMockRecorder) RemoveContainer(ctx, containerID, force any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveContainer", reflect.TypeOf((*MockRuntime)(nil).RemoveContainer), ctx, containerID, force)
}

// RemoveImage mocks base method.
func (m *MockRuntime) RemoveImage(ctx context.Context, image string, force bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveImage", ctx, image, force)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveImage indicates an expected call of RemoveImage.
func (mr *MockRuntimeMockRecorder) RemoveImage(ctx, image, force any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveImage", reflect.TypeOf((*MockRuntime)(nil).RemoveImage), ctx, image, force)
}

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

// RemoveNetwork indicates an expected call of RemoveNetwork.
func (mr *MockRuntimeMockRecorder) RemoveNetwork(ctx, name any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveNetwork", reflect.TypeOf((*MockRuntime)(nil).RemoveNetwork), ctx, name)
}

// RemoveVolume mocks base method.
func (m *MockRuntime) RemoveVolume(ctx context.Context, volumeName string, force bool) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RemoveVolume", ctx, volumeName, force)
	ret0, _ := ret[0].(error)
	return ret0
}

// RemoveVolume indicates an expected call of RemoveVolume.
func (mr *MockRuntimeMockRecorder) RemoveVolume(ctx, volumeName, force any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RemoveVolume", reflect.TypeOf((*MockRuntime)(nil).RemoveVolume), ctx, volumeName, force)
}

// RestartContainer mocks base method.
func (m *MockRuntime) RestartContainer(ctx context.Context, containerID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RestartContainer", ctx, containerID)
	ret0, _ := ret[0].(error)
	return ret0
}

// RestartContainer indicates an expected call of RestartContainer.
func (mr *MockRuntimeMockRecorder) RestartContainer(ctx, containerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RestartContainer", reflect.TypeOf((*MockRuntime)(nil).RestartContainer), ctx, containerID)
}

// StartContainer mocks base method.
func (m *MockRuntime) StartContainer(ctx context.Context, containerID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StartContainer", ctx, containerID)
	ret0, _ := ret[0].(error)
	return ret0
}

// StartContainer indicates an expected call of StartContainer.
func (mr *MockRuntimeMockRecorder) StartContainer(ctx, containerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StartContainer", reflect.TypeOf((*MockRuntime)(nil).StartContainer), ctx, containerID)
}

// StopContainer mocks base method.
func (m *MockRuntime) StopContainer(ctx context.Context, containerID string) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "StopContainer", ctx, containerID)
	ret0, _ := ret[0].(error)
	return ret0
}

// StopContainer indicates an expected call of StopContainer.
func (mr *MockRuntimeMockRecorder) StopContainer(ctx, containerID any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StopContainer", reflect.TypeOf((*MockRuntime)(nil).StopContainer), ctx, containerID)
}

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

// Version indicates an expected call of Version.
func (mr *MockRuntimeMockRecorder) Version(ctx any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Version", reflect.TypeOf((*MockRuntime)(nil).Version), ctx)
}

// VolumeExists mocks base method.
func (m *MockRuntime) VolumeExists(ctx context.Context, volumeName string) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "VolumeExists", ctx, volumeName)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// VolumeExists indicates an expected call of VolumeExists.
func (mr *MockRuntimeMockRecorder) VolumeExists(ctx, volumeName any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VolumeExists", reflect.TypeOf((*MockRuntime)(nil).VolumeExists), ctx, volumeName)
}