// Code generated by MockGen. DO NOT EDIT.
// Source: pkg/engine/interface.go

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

import (
	config "github.com/analogj/capsulecd/pkg/config"
	pipeline "github.com/analogj/capsulecd/pkg/pipeline"
	scm "github.com/analogj/capsulecd/pkg/scm"
	gomock "github.com/golang/mock/gomock"
	reflect "reflect"
)

// MockInterface is a mock of Interface interface
type MockInterface struct {
	ctrl     *gomock.Controller
	recorder *MockInterfaceMockRecorder
}

// MockInterfaceMockRecorder is the mock recorder for MockInterface
type MockInterfaceMockRecorder struct {
	mock *MockInterface
}

// NewMockInterface creates a new mock instance
func NewMockInterface(ctrl *gomock.Controller) *MockInterface {
	mock := &MockInterface{ctrl: ctrl}
	mock.recorder = &MockInterfaceMockRecorder{mock}
	return mock
}

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

// Init mocks base method
func (m *MockInterface) Init(pipelineData *pipeline.Data, config config.Interface, sourceScm scm.Interface) error {
	ret := m.ctrl.Call(m, "Init", pipelineData, config, sourceScm)
	ret0, _ := ret[0].(error)
	return ret0
}

// Init indicates an expected call of Init
func (mr *MockInterfaceMockRecorder) Init(pipelineData, config, sourceScm interface{}) *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Init", reflect.TypeOf((*MockInterface)(nil).Init), pipelineData, config, sourceScm)
}

// GetCurrentMetadata mocks base method
func (m *MockInterface) GetCurrentMetadata() interface{} {
	ret := m.ctrl.Call(m, "GetCurrentMetadata")
	ret0, _ := ret[0].(interface{})
	return ret0
}

// GetCurrentMetadata indicates an expected call of GetCurrentMetadata
func (mr *MockInterfaceMockRecorder) GetCurrentMetadata() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentMetadata", reflect.TypeOf((*MockInterface)(nil).GetCurrentMetadata))
}

// GetNextMetadata mocks base method
func (m *MockInterface) GetNextMetadata() interface{} {
	ret := m.ctrl.Call(m, "GetNextMetadata")
	ret0, _ := ret[0].(interface{})
	return ret0
}

// GetNextMetadata indicates an expected call of GetNextMetadata
func (mr *MockInterfaceMockRecorder) GetNextMetadata() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNextMetadata", reflect.TypeOf((*MockInterface)(nil).GetNextMetadata))
}

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

// ValidateTools indicates an expected call of ValidateTools
func (mr *MockInterfaceMockRecorder) ValidateTools() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateTools", reflect.TypeOf((*MockInterface)(nil).ValidateTools))
}

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

// AssembleStep indicates an expected call of AssembleStep
func (mr *MockInterfaceMockRecorder) AssembleStep() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssembleStep", reflect.TypeOf((*MockInterface)(nil).AssembleStep))
}

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

// CompileStep indicates an expected call of CompileStep
func (mr *MockInterfaceMockRecorder) CompileStep() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CompileStep", reflect.TypeOf((*MockInterface)(nil).CompileStep))
}

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

// TestStep indicates an expected call of TestStep
func (mr *MockInterfaceMockRecorder) TestStep() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TestStep", reflect.TypeOf((*MockInterface)(nil).TestStep))
}

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

// PackageStep indicates an expected call of PackageStep
func (mr *MockInterfaceMockRecorder) PackageStep() *gomock.Call {
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PackageStep", reflect.TypeOf((*MockInterface)(nil).PackageStep))
}
