github.com/kubeshop/testkube@v1.17.23/pkg/tcl/testworkflowstcl/testworkflowprocessor/mock_container.go

// Code generated by MockGen. DO NOT EDIT.
// Source: github.com/kubeshop/testkube/pkg/tcl/testworkflowstcl/testworkflowprocessor (interfaces: Container)

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

import (
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
	v1 "github.com/kubeshop/testkube-operator/api/testworkflows/v1"
	imageinspector "github.com/kubeshop/testkube/pkg/imageinspector"
	expressionstcl "github.com/kubeshop/testkube/pkg/tcl/expressionstcl"
	v10 "k8s.io/api/core/v1"
)

// 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
}

// AppendEnv mocks base method.
func (m *MockContainer) AppendEnv(arg0 ...v10.EnvVar) Container {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AppendEnv", varargs...)
	ret0, _ := ret[0].(Container)
	return ret0
}

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

// AppendEnvFrom mocks base method.
func (m *MockContainer) AppendEnvFrom(arg0 ...v10.EnvFromSource) Container {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AppendEnvFrom", varargs...)
	ret0, _ := ret[0].(Container)
	return ret0
}

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

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

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

// AppendVolumeMounts mocks base method.
func (m *MockContainer) AppendVolumeMounts(arg0 ...v10.VolumeMount) Container {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "AppendVolumeMounts", varargs...)
	ret0, _ := ret[0].(Container)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SetArgs mocks base method.
func (m *MockContainer) SetArgs(arg0 ...string) Container {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetArgs", varargs...)
	ret0, _ := ret[0].(Container)
	return ret0
}

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

// SetCommand mocks base method.
func (m *MockContainer) SetCommand(arg0 ...string) Container {
	m.ctrl.T.Helper()
	varargs := []interface{}{}
	for _, a := range arg0 {
		varargs = append(varargs, a)
	}
	ret := m.ctrl.Call(m, "SetCommand", varargs...)
	ret0, _ := ret[0].(Container)
	return ret0
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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