// Code generated by MockGen. DO NOT EDIT.
// Source: node.go

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

import (
	context "context"
	reflect "reflect"

	gomock "github.com/golang/mock/gomock"
)

// MockNode is a mock of Node interface.
type MockNode struct {
	ctrl     *gomock.Controller
	recorder *MockNodeMockRecorder
}

// MockNodeMockRecorder is the mock recorder for MockNode.
type MockNodeMockRecorder struct {
	mock *MockNode
}

// NewMockNode creates a new mock instance.
func NewMockNode(ctrl *gomock.Controller) *MockNode {
	mock := &MockNode{ctrl: ctrl}
	mock.recorder = &MockNodeMockRecorder{mock}
	return mock
}

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

// DeriveEdges mocks base method.
func (m *MockNode) DeriveEdges(goCtx context.Context, graph *Graph) ([]Edge, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeriveEdges", goCtx, graph)
	ret0, _ := ret[0].([]Edge)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// DeriveEdges indicates an expected call of DeriveEdges.
func (mr *MockNodeMockRecorder) DeriveEdges(goCtx, graph interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeriveEdges", reflect.TypeOf((*MockNode)(nil).DeriveEdges), goCtx, graph)
}

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

// GetEffects indicates an expected call of GetEffects.
func (mr *MockNodeMockRecorder) GetEffects(goCtx interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetEffects", reflect.TypeOf((*MockNode)(nil).GetEffects), goCtx)
}

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

// Prepare indicates an expected call of Prepare.
func (mr *MockNodeMockRecorder) Prepare(goCtx, ctx, graph interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Prepare", reflect.TypeOf((*MockNode)(nil).Prepare), goCtx, ctx, graph)
}

// MockEdge is a mock of Edge interface.
type MockEdge struct {
	ctrl     *gomock.Controller
	recorder *MockEdgeMockRecorder
}

// MockEdgeMockRecorder is the mock recorder for MockEdge.
type MockEdgeMockRecorder struct {
	mock *MockEdge
}

// NewMockEdge creates a new mock instance.
func NewMockEdge(ctrl *gomock.Controller) *MockEdge {
	mock := &MockEdge{ctrl: ctrl}
	mock.recorder = &MockEdgeMockRecorder{mock}
	return mock
}

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

// Instantiate mocks base method.
func (m *MockEdge) Instantiate(goCtx context.Context, ctx *Context, graph *Graph, input interface{}) (Node, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "Instantiate", goCtx, ctx, graph, input)
	ret0, _ := ret[0].(Node)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// Instantiate indicates an expected call of Instantiate.
func (mr *MockEdgeMockRecorder) Instantiate(goCtx, ctx, graph, input interface{}) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Instantiate", reflect.TypeOf((*MockEdge)(nil).Instantiate), goCtx, ctx, graph, input)
}
