// Code generated by mockery; DO NOT EDIT.
// github.com/vektra/mockery
// template: testify

package portsmocks

import (
	"github.com/bnema/neferwl/internal/ports"
	mock "github.com/stretchr/testify/mock"
)

// NewMockSessionSecurity creates a new instance of MockSessionSecurity. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockSessionSecurity(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSessionSecurity {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockSessionSecurity{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockSessionSecurity is an autogenerated mock type for the SessionSecurity type
type MockSessionSecurity struct {
	mock.Mock
}

type MockSessionSecurity_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSessionSecurity) EXPECT() *MockSessionSecurity_Expecter {
	return &MockSessionSecurity_Expecter{mock: &_m.Mock}
}

// Snapshot provides a mock function for the type MockSessionSecurity
func (_mock *MockSessionSecurity) Snapshot() ports.SecurityState {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for Snapshot")
	}

	var r0 ports.SecurityState
	if returnFunc, ok := ret.Get(0).(func() ports.SecurityState); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(ports.SecurityState)
	}
	return r0
}

// MockSessionSecurity_Snapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Snapshot'
type MockSessionSecurity_Snapshot_Call struct {
	*mock.Call
}

// Snapshot is a helper method to define mock.On call
func (_e *MockSessionSecurity_Expecter) Snapshot() *MockSessionSecurity_Snapshot_Call {
	return &MockSessionSecurity_Snapshot_Call{Call: _e.mock.On("Snapshot")}
}

func (_c *MockSessionSecurity_Snapshot_Call) Run(run func()) *MockSessionSecurity_Snapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSessionSecurity_Snapshot_Call) Return(securityState ports.SecurityState) *MockSessionSecurity_Snapshot_Call {
	_c.Call.Return(securityState)
	return _c
}

func (_c *MockSessionSecurity_Snapshot_Call) RunAndReturn(run func() ports.SecurityState) *MockSessionSecurity_Snapshot_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockSessionSecurityController creates a new instance of MockSessionSecurityController. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockSessionSecurityController(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSessionSecurityController {
	if helper, ok := t.(interface{ Helper() }); ok {
		helper.Helper()
	}

	mock := &MockSessionSecurityController{}
	mock.Mock.Test(t)

	t.Cleanup(func() {
		if helper, ok := t.(interface{ Helper() }); ok {
			helper.Helper()
		}
		mock.AssertExpectations(t)
	})

	return mock
}

// MockSessionSecurityController is an autogenerated mock type for the SessionSecurityController type
type MockSessionSecurityController struct {
	mock.Mock
}

type MockSessionSecurityController_Expecter struct {
	mock *mock.Mock
}

func (_m *MockSessionSecurityController) EXPECT() *MockSessionSecurityController_Expecter {
	return &MockSessionSecurityController_Expecter{mock: &_m.Mock}
}

// Engage provides a mock function for the type MockSessionSecurityController
func (_mock *MockSessionSecurityController) Engage() (ports.SecurityState, error) {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for Engage")
	}

	var r0 ports.SecurityState
	var r1 error
	if returnFunc, ok := ret.Get(0).(func() (ports.SecurityState, error)); ok {
		return returnFunc()
	}
	if returnFunc, ok := ret.Get(0).(func() ports.SecurityState); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(ports.SecurityState)
	}
	if returnFunc, ok := ret.Get(1).(func() error); ok {
		r1 = returnFunc()
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockSessionSecurityController_Engage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Engage'
type MockSessionSecurityController_Engage_Call struct {
	*mock.Call
}

// Engage is a helper method to define mock.On call
func (_e *MockSessionSecurityController_Expecter) Engage() *MockSessionSecurityController_Engage_Call {
	return &MockSessionSecurityController_Engage_Call{Call: _e.mock.On("Engage")}
}

func (_c *MockSessionSecurityController_Engage_Call) Run(run func()) *MockSessionSecurityController_Engage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSessionSecurityController_Engage_Call) Return(securityState ports.SecurityState, err error) *MockSessionSecurityController_Engage_Call {
	_c.Call.Return(securityState, err)
	return _c
}

func (_c *MockSessionSecurityController_Engage_Call) RunAndReturn(run func() (ports.SecurityState, error)) *MockSessionSecurityController_Engage_Call {
	_c.Call.Return(run)
	return _c
}

// Release provides a mock function for the type MockSessionSecurityController
func (_mock *MockSessionSecurityController) Release(expected ports.LockGeneration) (ports.SecurityState, error) {
	ret := _mock.Called(expected)

	if len(ret) == 0 {
		panic("no return value specified for Release")
	}

	var r0 ports.SecurityState
	var r1 error
	if returnFunc, ok := ret.Get(0).(func(ports.LockGeneration) (ports.SecurityState, error)); ok {
		return returnFunc(expected)
	}
	if returnFunc, ok := ret.Get(0).(func(ports.LockGeneration) ports.SecurityState); ok {
		r0 = returnFunc(expected)
	} else {
		r0 = ret.Get(0).(ports.SecurityState)
	}
	if returnFunc, ok := ret.Get(1).(func(ports.LockGeneration) error); ok {
		r1 = returnFunc(expected)
	} else {
		r1 = ret.Error(1)
	}
	return r0, r1
}

// MockSessionSecurityController_Release_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Release'
type MockSessionSecurityController_Release_Call struct {
	*mock.Call
}

// Release is a helper method to define mock.On call
//   - expected ports.LockGeneration
func (_e *MockSessionSecurityController_Expecter) Release(expected any) *MockSessionSecurityController_Release_Call {
	return &MockSessionSecurityController_Release_Call{Call: _e.mock.On("Release", expected)}
}

func (_c *MockSessionSecurityController_Release_Call) Run(run func(expected ports.LockGeneration)) *MockSessionSecurityController_Release_Call {
	_c.Call.Run(func(args mock.Arguments) {
		var arg0 ports.LockGeneration
		if args[0] != nil {
			arg0 = args[0].(ports.LockGeneration)
		}
		run(
			arg0,
		)
	})
	return _c
}

func (_c *MockSessionSecurityController_Release_Call) Return(securityState ports.SecurityState, err error) *MockSessionSecurityController_Release_Call {
	_c.Call.Return(securityState, err)
	return _c
}

func (_c *MockSessionSecurityController_Release_Call) RunAndReturn(run func(expected ports.LockGeneration) (ports.SecurityState, error)) *MockSessionSecurityController_Release_Call {
	_c.Call.Return(run)
	return _c
}

// Snapshot provides a mock function for the type MockSessionSecurityController
func (_mock *MockSessionSecurityController) Snapshot() ports.SecurityState {
	ret := _mock.Called()

	if len(ret) == 0 {
		panic("no return value specified for Snapshot")
	}

	var r0 ports.SecurityState
	if returnFunc, ok := ret.Get(0).(func() ports.SecurityState); ok {
		r0 = returnFunc()
	} else {
		r0 = ret.Get(0).(ports.SecurityState)
	}
	return r0
}

// MockSessionSecurityController_Snapshot_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Snapshot'
type MockSessionSecurityController_Snapshot_Call struct {
	*mock.Call
}

// Snapshot is a helper method to define mock.On call
func (_e *MockSessionSecurityController_Expecter) Snapshot() *MockSessionSecurityController_Snapshot_Call {
	return &MockSessionSecurityController_Snapshot_Call{Call: _e.mock.On("Snapshot")}
}

func (_c *MockSessionSecurityController_Snapshot_Call) Run(run func()) *MockSessionSecurityController_Snapshot_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockSessionSecurityController_Snapshot_Call) Return(securityState ports.SecurityState) *MockSessionSecurityController_Snapshot_Call {
	_c.Call.Return(securityState)
	return _c
}

func (_c *MockSessionSecurityController_Snapshot_Call) RunAndReturn(run func() ports.SecurityState) *MockSessionSecurityController_Snapshot_Call {
	_c.Call.Return(run)
	return _c
}