netbird/client/internal/statemanager/mocks/manager.go

// Code generated by MockGen. DO NOT EDIT.
// Source: client/internal/statemanager/manager.go
//
// Generated by this command:
//
//	mockgen -source client/internal/statemanager/manager.go -destination lient/internal/statemanager/manager_mock.go Manager
//

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

import (
	context "context"
	reflect "reflect"

	statemanager "github.com/netbirdio/netbird/client/internal/statemanager"
	gomock "go.uber.org/mock/gomock"
)

// MockState is a mock of State interface.
type MockState struct {
	ctrl     *gomock.Controller
	recorder *MockStateMockRecorder
	isgomock struct{}
}

// MockStateMockRecorder is the mock recorder for MockState.
type MockStateMockRecorder struct {
	mock *MockState
}

// NewMockState creates a new mock instance.
func NewMockState(ctrl *gomock.Controller) *MockState {
	mock := &MockState{ctrl: ctrl}
	mock.recorder = &MockStateMockRecorder{mock}
	return mock
}

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

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

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

// MockCleanableState is a mock of CleanableState interface.
type MockCleanableState struct {
	ctrl     *gomock.Controller
	recorder *MockCleanableStateMockRecorder
	isgomock struct{}
}

// MockCleanableStateMockRecorder is the mock recorder for MockCleanableState.
type MockCleanableStateMockRecorder struct {
	mock *MockCleanableState
}

// NewMockCleanableState creates a new mock instance.
func NewMockCleanableState(ctrl *gomock.Controller) *MockCleanableState {
	mock := &MockCleanableState{ctrl: ctrl}
	mock.recorder = &MockCleanableStateMockRecorder{mock}
	return mock
}

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

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

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

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

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

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

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

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

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

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

// DeleteState mocks base method.
func (m *MockManager) DeleteState(state statemanager.State) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "DeleteState", state)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

// GetState mocks base method.
func (m *MockManager) GetState(state statemanager.State) statemanager.State {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "GetState", state)
	ret0, _ := ret[0].(statemanager.State)
	return ret0
}

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

// LoadState mocks base method.
func (m *MockManager) LoadState(state statemanager.State) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "LoadState", state)
	ret0, _ := ret[0].(error)
	return ret0
}

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

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

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

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

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

// RegisterState mocks base method.
func (m *MockManager) RegisterState(state statemanager.State) {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "RegisterState", state)
}

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

// Start mocks base method.
func (m *MockManager) Start() {
	m.ctrl.T.Helper()
	m.ctrl.Call(m, "Start")
}

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

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

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

// UpdateState mocks base method.
func (m *MockManager) UpdateState(state statemanager.State) error {
	m.ctrl.T.Helper()
	ret := m.ctrl.Call(m, "UpdateState", state)
	ret0, _ := ret[0].(error)
	return ret0
}

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