// Code generated by MockGen. DO NOT EDIT.
// Source: git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/contextgraph (interfaces: Manager,EntityServiceStorage)
//
// Generated by this command:
//
//	mockgen -destination=../../../mocks/lib/canopsis/contextgraph/contextgraph.go git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/contextgraph Manager,EntityServiceStorage
//

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

import (
	context "context"
	reflect "reflect"

	contextgraph "git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/contextgraph"
	entityservice "git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/entityservice"
	types "git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/canopsis/types"
	mongo "git.canopsis.net/canopsis/canopsis-community/community/go-engines-community/lib/mongo"
	gomock "go.uber.org/mock/gomock"
)

// MockManager is a mock of Manager interface.
type MockManager struct {
	ctrl     *gomock.Controller
	recorder *MockManagerMockRecorder
	isgomock struct{}
}

// MockManagerMockRecorder is the mock recorder for MockManager.
type MockManagerMockRecorder struct {
	mock *MockManager
}

// NewMockManager creates a new mock instance.
func NewMockManager(ctrl *gomock.Controller) *MockManager {
	mock := &MockManager{ctrl: ctrl}
	mock.recorder = &MockManagerMockRecorder{mock}
	return mock
}

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

// AssignServices mocks base method.
func (m *MockManager) AssignServices(eventEntity *types.Entity, commRegister mongo.CommandsRegister) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "AssignServices", eventEntity, commRegister)
}

// AssignServices indicates an expected call of AssignServices.
func (mr *MockManagerMockRecorder) AssignServices(eventEntity, commRegister any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignServices", reflect.TypeOf((*MockManager)(nil).AssignServices), eventEntity, commRegister)
}

// AssignStateSetting mocks base method.
func (m *MockManager) AssignStateSetting(ctx context.Context, entity *types.Entity, commRegister mongo.CommandsRegister) (bool, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "AssignStateSetting", ctx, entity, commRegister)
	ret0, _ := ret[0].(bool)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// AssignStateSetting indicates an expected call of AssignStateSetting.
func (mr *MockManagerMockRecorder) AssignStateSetting(ctx, entity, commRegister any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AssignStateSetting", reflect.TypeOf((*MockManager)(nil).AssignStateSetting), ctx, entity, commRegister)
}

// HandleComponent mocks base method.
func (m *MockManager) HandleComponent(ctx context.Context, event *types.Event, commRegister mongo.CommandsRegister) (contextgraph.Report, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleComponent", ctx, event, commRegister)
	ret0, _ := ret[0].(contextgraph.Report)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleComponent indicates an expected call of HandleComponent.
func (mr *MockManagerMockRecorder) HandleComponent(ctx, event, commRegister any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleComponent", reflect.TypeOf((*MockManager)(nil).HandleComponent), ctx, event, commRegister)
}

// HandleConnector mocks base method.
func (m *MockManager) HandleConnector(ctx context.Context, event *types.Event, commRegister mongo.CommandsRegister) (contextgraph.Report, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleConnector", ctx, event, commRegister)
	ret0, _ := ret[0].(contextgraph.Report)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleConnector indicates an expected call of HandleConnector.
func (mr *MockManagerMockRecorder) HandleConnector(ctx, event, commRegister any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleConnector", reflect.TypeOf((*MockManager)(nil).HandleConnector), ctx, event, commRegister)
}

// HandleResource mocks base method.
func (m *MockManager) HandleResource(ctx context.Context, event *types.Event, commRegister mongo.CommandsRegister) (contextgraph.Report, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleResource", ctx, event, commRegister)
	ret0, _ := ret[0].(contextgraph.Report)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleResource indicates an expected call of HandleResource.
func (mr *MockManagerMockRecorder) HandleResource(ctx, event, commRegister any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleResource", reflect.TypeOf((*MockManager)(nil).HandleResource), ctx, event, commRegister)
}

// HandleService mocks base method.
func (m *MockManager) HandleService(ctx context.Context, event *types.Event, commRegister mongo.CommandsRegister) (contextgraph.Report, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "HandleService", ctx, event, commRegister)
	ret0, _ := ret[0].(contextgraph.Report)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// HandleService indicates an expected call of HandleService.
func (mr *MockManagerMockRecorder) HandleService(ctx, event, commRegister any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleService", reflect.TypeOf((*MockManager)(nil).HandleService), ctx, event, commRegister)
}

// InheritComponentFields mocks base method.
func (m *MockManager) InheritComponentFields(resource, component *types.Entity, commRegister mongo.CommandsRegister) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "InheritComponentFields", resource, component, commRegister)
	ret0, _ := ret[0].(error)
	return ret0
}

// InheritComponentFields indicates an expected call of InheritComponentFields.
func (mr *MockManagerMockRecorder) InheritComponentFields(resource, component, commRegister any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InheritComponentFields", reflect.TypeOf((*MockManager)(nil).InheritComponentFields), resource, component, commRegister)
}

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

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

// ProcessComponentDependencies mocks base method.
func (m *MockManager) ProcessComponentDependencies(ctx context.Context, component *types.Entity, commRegister mongo.CommandsRegister) ([]string, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "ProcessComponentDependencies", ctx, component, commRegister)
	ret0, _ := ret[0].([]string)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// ProcessComponentDependencies indicates an expected call of ProcessComponentDependencies.
func (mr *MockManagerMockRecorder) ProcessComponentDependencies(ctx, component, commRegister any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ProcessComponentDependencies", reflect.TypeOf((*MockManager)(nil).ProcessComponentDependencies), ctx, component, commRegister)
}

// RecomputeService mocks base method.
func (m *MockManager) RecomputeService(ctx context.Context, serviceID string, commRegister mongo.CommandsRegister) (types.Entity, error) {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "RecomputeService", ctx, serviceID, commRegister)
	ret0, _ := ret[0].(types.Entity)
	ret1, _ := ret[1].(error)
	return ret0, ret1
}

// RecomputeService indicates an expected call of RecomputeService.
func (mr *MockManagerMockRecorder) RecomputeService(ctx, serviceID, commRegister any) *gomock.Call {
	mr.mock.ctrl.T.Helper()
	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RecomputeService", reflect.TypeOf((*MockManager)(nil).RecomputeService), ctx, serviceID, commRegister)
}

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

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

// MockEntityServiceStorage is a mock of EntityServiceStorage interface.
type MockEntityServiceStorage struct {
	ctrl     *gomock.Controller
	recorder *MockEntityServiceStorageMockRecorder
	isgomock struct{}
}

// MockEntityServiceStorageMockRecorder is the mock recorder for MockEntityServiceStorage.
type MockEntityServiceStorageMockRecorder struct {
	mock *MockEntityServiceStorage
}

// NewMockEntityServiceStorage creates a new mock instance.
func NewMockEntityServiceStorage(ctrl *gomock.Controller) *MockEntityServiceStorage {
	mock := &MockEntityServiceStorage{ctrl: ctrl}
	mock.recorder = &MockEntityServiceStorageMockRecorder{mock}
	return mock
}

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

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

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

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

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