1372 lines
38 KiB
Go
1372 lines
38 KiB
Go
// Code generated by mockery v2.53.5. DO NOT EDIT.
|
|
|
|
package mocks_network
|
|
|
|
import (
|
|
network "github.com/AvengeMedia/danklinux/internal/server/network"
|
|
mock "github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// MockBackend is an autogenerated mock type for the Backend type
|
|
type MockBackend struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type MockBackend_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *MockBackend) EXPECT() *MockBackend_Expecter {
|
|
return &MockBackend_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// ActivateWiredConnection provides a mock function with given fields: uuid
|
|
func (_m *MockBackend) ActivateWiredConnection(uuid string) error {
|
|
ret := _m.Called(uuid)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ActivateWiredConnection")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(uuid)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_ActivateWiredConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ActivateWiredConnection'
|
|
type MockBackend_ActivateWiredConnection_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ActivateWiredConnection is a helper method to define mock.On call
|
|
// - uuid string
|
|
func (_e *MockBackend_Expecter) ActivateWiredConnection(uuid interface{}) *MockBackend_ActivateWiredConnection_Call {
|
|
return &MockBackend_ActivateWiredConnection_Call{Call: _e.mock.On("ActivateWiredConnection", uuid)}
|
|
}
|
|
|
|
func (_c *MockBackend_ActivateWiredConnection_Call) Run(run func(uuid string)) *MockBackend_ActivateWiredConnection_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ActivateWiredConnection_Call) Return(_a0 error) *MockBackend_ActivateWiredConnection_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ActivateWiredConnection_Call) RunAndReturn(run func(string) error) *MockBackend_ActivateWiredConnection_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CancelCredentials provides a mock function with given fields: token
|
|
func (_m *MockBackend) CancelCredentials(token string) error {
|
|
ret := _m.Called(token)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CancelCredentials")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(token)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_CancelCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CancelCredentials'
|
|
type MockBackend_CancelCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CancelCredentials is a helper method to define mock.On call
|
|
// - token string
|
|
func (_e *MockBackend_Expecter) CancelCredentials(token interface{}) *MockBackend_CancelCredentials_Call {
|
|
return &MockBackend_CancelCredentials_Call{Call: _e.mock.On("CancelCredentials", token)}
|
|
}
|
|
|
|
func (_c *MockBackend_CancelCredentials_Call) Run(run func(token string)) *MockBackend_CancelCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_CancelCredentials_Call) Return(_a0 error) *MockBackend_CancelCredentials_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_CancelCredentials_Call) RunAndReturn(run func(string) error) *MockBackend_CancelCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ClearVPNCredentials provides a mock function with given fields: uuidOrName
|
|
func (_m *MockBackend) ClearVPNCredentials(uuidOrName string) error {
|
|
ret := _m.Called(uuidOrName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ClearVPNCredentials")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(uuidOrName)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_ClearVPNCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ClearVPNCredentials'
|
|
type MockBackend_ClearVPNCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ClearVPNCredentials is a helper method to define mock.On call
|
|
// - uuidOrName string
|
|
func (_e *MockBackend_Expecter) ClearVPNCredentials(uuidOrName interface{}) *MockBackend_ClearVPNCredentials_Call {
|
|
return &MockBackend_ClearVPNCredentials_Call{Call: _e.mock.On("ClearVPNCredentials", uuidOrName)}
|
|
}
|
|
|
|
func (_c *MockBackend_ClearVPNCredentials_Call) Run(run func(uuidOrName string)) *MockBackend_ClearVPNCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ClearVPNCredentials_Call) Return(_a0 error) *MockBackend_ClearVPNCredentials_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ClearVPNCredentials_Call) RunAndReturn(run func(string) error) *MockBackend_ClearVPNCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Close provides a mock function with no fields
|
|
func (_m *MockBackend) Close() {
|
|
_m.Called()
|
|
}
|
|
|
|
// MockBackend_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
|
|
type MockBackend_Close_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Close is a helper method to define mock.On call
|
|
func (_e *MockBackend_Expecter) Close() *MockBackend_Close_Call {
|
|
return &MockBackend_Close_Call{Call: _e.mock.On("Close")}
|
|
}
|
|
|
|
func (_c *MockBackend_Close_Call) Run(run func()) *MockBackend_Close_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_Close_Call) Return() *MockBackend_Close_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_Close_Call) RunAndReturn(run func()) *MockBackend_Close_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// ConnectEthernet provides a mock function with no fields
|
|
func (_m *MockBackend) ConnectEthernet() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ConnectEthernet")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_ConnectEthernet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectEthernet'
|
|
type MockBackend_ConnectEthernet_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ConnectEthernet is a helper method to define mock.On call
|
|
func (_e *MockBackend_Expecter) ConnectEthernet() *MockBackend_ConnectEthernet_Call {
|
|
return &MockBackend_ConnectEthernet_Call{Call: _e.mock.On("ConnectEthernet")}
|
|
}
|
|
|
|
func (_c *MockBackend_ConnectEthernet_Call) Run(run func()) *MockBackend_ConnectEthernet_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ConnectEthernet_Call) Return(_a0 error) *MockBackend_ConnectEthernet_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ConnectEthernet_Call) RunAndReturn(run func() error) *MockBackend_ConnectEthernet_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ConnectVPN provides a mock function with given fields: uuidOrName, singleActive
|
|
func (_m *MockBackend) ConnectVPN(uuidOrName string, singleActive bool) error {
|
|
ret := _m.Called(uuidOrName, singleActive)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ConnectVPN")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, bool) error); ok {
|
|
r0 = rf(uuidOrName, singleActive)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_ConnectVPN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectVPN'
|
|
type MockBackend_ConnectVPN_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ConnectVPN is a helper method to define mock.On call
|
|
// - uuidOrName string
|
|
// - singleActive bool
|
|
func (_e *MockBackend_Expecter) ConnectVPN(uuidOrName interface{}, singleActive interface{}) *MockBackend_ConnectVPN_Call {
|
|
return &MockBackend_ConnectVPN_Call{Call: _e.mock.On("ConnectVPN", uuidOrName, singleActive)}
|
|
}
|
|
|
|
func (_c *MockBackend_ConnectVPN_Call) Run(run func(uuidOrName string, singleActive bool)) *MockBackend_ConnectVPN_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ConnectVPN_Call) Return(_a0 error) *MockBackend_ConnectVPN_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ConnectVPN_Call) RunAndReturn(run func(string, bool) error) *MockBackend_ConnectVPN_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ConnectWiFi provides a mock function with given fields: req
|
|
func (_m *MockBackend) ConnectWiFi(req network.ConnectionRequest) error {
|
|
ret := _m.Called(req)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ConnectWiFi")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(network.ConnectionRequest) error); ok {
|
|
r0 = rf(req)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_ConnectWiFi_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConnectWiFi'
|
|
type MockBackend_ConnectWiFi_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ConnectWiFi is a helper method to define mock.On call
|
|
// - req network.ConnectionRequest
|
|
func (_e *MockBackend_Expecter) ConnectWiFi(req interface{}) *MockBackend_ConnectWiFi_Call {
|
|
return &MockBackend_ConnectWiFi_Call{Call: _e.mock.On("ConnectWiFi", req)}
|
|
}
|
|
|
|
func (_c *MockBackend_ConnectWiFi_Call) Run(run func(req network.ConnectionRequest)) *MockBackend_ConnectWiFi_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(network.ConnectionRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ConnectWiFi_Call) Return(_a0 error) *MockBackend_ConnectWiFi_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ConnectWiFi_Call) RunAndReturn(run func(network.ConnectionRequest) error) *MockBackend_ConnectWiFi_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DisconnectAllVPN provides a mock function with no fields
|
|
func (_m *MockBackend) DisconnectAllVPN() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DisconnectAllVPN")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_DisconnectAllVPN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectAllVPN'
|
|
type MockBackend_DisconnectAllVPN_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DisconnectAllVPN is a helper method to define mock.On call
|
|
func (_e *MockBackend_Expecter) DisconnectAllVPN() *MockBackend_DisconnectAllVPN_Call {
|
|
return &MockBackend_DisconnectAllVPN_Call{Call: _e.mock.On("DisconnectAllVPN")}
|
|
}
|
|
|
|
func (_c *MockBackend_DisconnectAllVPN_Call) Run(run func()) *MockBackend_DisconnectAllVPN_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_DisconnectAllVPN_Call) Return(_a0 error) *MockBackend_DisconnectAllVPN_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_DisconnectAllVPN_Call) RunAndReturn(run func() error) *MockBackend_DisconnectAllVPN_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DisconnectEthernet provides a mock function with no fields
|
|
func (_m *MockBackend) DisconnectEthernet() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DisconnectEthernet")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_DisconnectEthernet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectEthernet'
|
|
type MockBackend_DisconnectEthernet_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DisconnectEthernet is a helper method to define mock.On call
|
|
func (_e *MockBackend_Expecter) DisconnectEthernet() *MockBackend_DisconnectEthernet_Call {
|
|
return &MockBackend_DisconnectEthernet_Call{Call: _e.mock.On("DisconnectEthernet")}
|
|
}
|
|
|
|
func (_c *MockBackend_DisconnectEthernet_Call) Run(run func()) *MockBackend_DisconnectEthernet_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_DisconnectEthernet_Call) Return(_a0 error) *MockBackend_DisconnectEthernet_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_DisconnectEthernet_Call) RunAndReturn(run func() error) *MockBackend_DisconnectEthernet_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DisconnectVPN provides a mock function with given fields: uuidOrName
|
|
func (_m *MockBackend) DisconnectVPN(uuidOrName string) error {
|
|
ret := _m.Called(uuidOrName)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DisconnectVPN")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(uuidOrName)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_DisconnectVPN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectVPN'
|
|
type MockBackend_DisconnectVPN_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DisconnectVPN is a helper method to define mock.On call
|
|
// - uuidOrName string
|
|
func (_e *MockBackend_Expecter) DisconnectVPN(uuidOrName interface{}) *MockBackend_DisconnectVPN_Call {
|
|
return &MockBackend_DisconnectVPN_Call{Call: _e.mock.On("DisconnectVPN", uuidOrName)}
|
|
}
|
|
|
|
func (_c *MockBackend_DisconnectVPN_Call) Run(run func(uuidOrName string)) *MockBackend_DisconnectVPN_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_DisconnectVPN_Call) Return(_a0 error) *MockBackend_DisconnectVPN_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_DisconnectVPN_Call) RunAndReturn(run func(string) error) *MockBackend_DisconnectVPN_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DisconnectWiFi provides a mock function with no fields
|
|
func (_m *MockBackend) DisconnectWiFi() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DisconnectWiFi")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_DisconnectWiFi_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisconnectWiFi'
|
|
type MockBackend_DisconnectWiFi_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DisconnectWiFi is a helper method to define mock.On call
|
|
func (_e *MockBackend_Expecter) DisconnectWiFi() *MockBackend_DisconnectWiFi_Call {
|
|
return &MockBackend_DisconnectWiFi_Call{Call: _e.mock.On("DisconnectWiFi")}
|
|
}
|
|
|
|
func (_c *MockBackend_DisconnectWiFi_Call) Run(run func()) *MockBackend_DisconnectWiFi_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_DisconnectWiFi_Call) Return(_a0 error) *MockBackend_DisconnectWiFi_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_DisconnectWiFi_Call) RunAndReturn(run func() error) *MockBackend_DisconnectWiFi_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ForgetWiFiNetwork provides a mock function with given fields: ssid
|
|
func (_m *MockBackend) ForgetWiFiNetwork(ssid string) error {
|
|
ret := _m.Called(ssid)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ForgetWiFiNetwork")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(ssid)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_ForgetWiFiNetwork_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ForgetWiFiNetwork'
|
|
type MockBackend_ForgetWiFiNetwork_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ForgetWiFiNetwork is a helper method to define mock.On call
|
|
// - ssid string
|
|
func (_e *MockBackend_Expecter) ForgetWiFiNetwork(ssid interface{}) *MockBackend_ForgetWiFiNetwork_Call {
|
|
return &MockBackend_ForgetWiFiNetwork_Call{Call: _e.mock.On("ForgetWiFiNetwork", ssid)}
|
|
}
|
|
|
|
func (_c *MockBackend_ForgetWiFiNetwork_Call) Run(run func(ssid string)) *MockBackend_ForgetWiFiNetwork_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ForgetWiFiNetwork_Call) Return(_a0 error) *MockBackend_ForgetWiFiNetwork_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ForgetWiFiNetwork_Call) RunAndReturn(run func(string) error) *MockBackend_ForgetWiFiNetwork_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetCurrentState provides a mock function with no fields
|
|
func (_m *MockBackend) GetCurrentState() (*network.BackendState, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetCurrentState")
|
|
}
|
|
|
|
var r0 *network.BackendState
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (*network.BackendState, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() *network.BackendState); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*network.BackendState)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockBackend_GetCurrentState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetCurrentState'
|
|
type MockBackend_GetCurrentState_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetCurrentState is a helper method to define mock.On call
|
|
func (_e *MockBackend_Expecter) GetCurrentState() *MockBackend_GetCurrentState_Call {
|
|
return &MockBackend_GetCurrentState_Call{Call: _e.mock.On("GetCurrentState")}
|
|
}
|
|
|
|
func (_c *MockBackend_GetCurrentState_Call) Run(run func()) *MockBackend_GetCurrentState_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_GetCurrentState_Call) Return(_a0 *network.BackendState, _a1 error) *MockBackend_GetCurrentState_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_GetCurrentState_Call) RunAndReturn(run func() (*network.BackendState, error)) *MockBackend_GetCurrentState_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetPromptBroker provides a mock function with no fields
|
|
func (_m *MockBackend) GetPromptBroker() network.PromptBroker {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetPromptBroker")
|
|
}
|
|
|
|
var r0 network.PromptBroker
|
|
if rf, ok := ret.Get(0).(func() network.PromptBroker); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(network.PromptBroker)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_GetPromptBroker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPromptBroker'
|
|
type MockBackend_GetPromptBroker_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetPromptBroker is a helper method to define mock.On call
|
|
func (_e *MockBackend_Expecter) GetPromptBroker() *MockBackend_GetPromptBroker_Call {
|
|
return &MockBackend_GetPromptBroker_Call{Call: _e.mock.On("GetPromptBroker")}
|
|
}
|
|
|
|
func (_c *MockBackend_GetPromptBroker_Call) Run(run func()) *MockBackend_GetPromptBroker_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_GetPromptBroker_Call) Return(_a0 network.PromptBroker) *MockBackend_GetPromptBroker_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_GetPromptBroker_Call) RunAndReturn(run func() network.PromptBroker) *MockBackend_GetPromptBroker_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetWiFiEnabled provides a mock function with no fields
|
|
func (_m *MockBackend) GetWiFiEnabled() (bool, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetWiFiEnabled")
|
|
}
|
|
|
|
var r0 bool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() (bool, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() bool); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockBackend_GetWiFiEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWiFiEnabled'
|
|
type MockBackend_GetWiFiEnabled_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetWiFiEnabled is a helper method to define mock.On call
|
|
func (_e *MockBackend_Expecter) GetWiFiEnabled() *MockBackend_GetWiFiEnabled_Call {
|
|
return &MockBackend_GetWiFiEnabled_Call{Call: _e.mock.On("GetWiFiEnabled")}
|
|
}
|
|
|
|
func (_c *MockBackend_GetWiFiEnabled_Call) Run(run func()) *MockBackend_GetWiFiEnabled_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_GetWiFiEnabled_Call) Return(_a0 bool, _a1 error) *MockBackend_GetWiFiEnabled_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_GetWiFiEnabled_Call) RunAndReturn(run func() (bool, error)) *MockBackend_GetWiFiEnabled_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetWiFiNetworkDetails provides a mock function with given fields: ssid
|
|
func (_m *MockBackend) GetWiFiNetworkDetails(ssid string) (*network.NetworkInfoResponse, error) {
|
|
ret := _m.Called(ssid)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetWiFiNetworkDetails")
|
|
}
|
|
|
|
var r0 *network.NetworkInfoResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string) (*network.NetworkInfoResponse, error)); ok {
|
|
return rf(ssid)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string) *network.NetworkInfoResponse); ok {
|
|
r0 = rf(ssid)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*network.NetworkInfoResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(ssid)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockBackend_GetWiFiNetworkDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWiFiNetworkDetails'
|
|
type MockBackend_GetWiFiNetworkDetails_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetWiFiNetworkDetails is a helper method to define mock.On call
|
|
// - ssid string
|
|
func (_e *MockBackend_Expecter) GetWiFiNetworkDetails(ssid interface{}) *MockBackend_GetWiFiNetworkDetails_Call {
|
|
return &MockBackend_GetWiFiNetworkDetails_Call{Call: _e.mock.On("GetWiFiNetworkDetails", ssid)}
|
|
}
|
|
|
|
func (_c *MockBackend_GetWiFiNetworkDetails_Call) Run(run func(ssid string)) *MockBackend_GetWiFiNetworkDetails_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_GetWiFiNetworkDetails_Call) Return(_a0 *network.NetworkInfoResponse, _a1 error) *MockBackend_GetWiFiNetworkDetails_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_GetWiFiNetworkDetails_Call) RunAndReturn(run func(string) (*network.NetworkInfoResponse, error)) *MockBackend_GetWiFiNetworkDetails_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetWiredConnections provides a mock function with no fields
|
|
func (_m *MockBackend) GetWiredConnections() ([]network.WiredConnection, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetWiredConnections")
|
|
}
|
|
|
|
var r0 []network.WiredConnection
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() ([]network.WiredConnection, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() []network.WiredConnection); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]network.WiredConnection)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockBackend_GetWiredConnections_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWiredConnections'
|
|
type MockBackend_GetWiredConnections_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetWiredConnections is a helper method to define mock.On call
|
|
func (_e *MockBackend_Expecter) GetWiredConnections() *MockBackend_GetWiredConnections_Call {
|
|
return &MockBackend_GetWiredConnections_Call{Call: _e.mock.On("GetWiredConnections")}
|
|
}
|
|
|
|
func (_c *MockBackend_GetWiredConnections_Call) Run(run func()) *MockBackend_GetWiredConnections_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_GetWiredConnections_Call) Return(_a0 []network.WiredConnection, _a1 error) *MockBackend_GetWiredConnections_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_GetWiredConnections_Call) RunAndReturn(run func() ([]network.WiredConnection, error)) *MockBackend_GetWiredConnections_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetWiredNetworkDetails provides a mock function with given fields: uuid
|
|
func (_m *MockBackend) GetWiredNetworkDetails(uuid string) (*network.WiredNetworkInfoResponse, error) {
|
|
ret := _m.Called(uuid)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetWiredNetworkDetails")
|
|
}
|
|
|
|
var r0 *network.WiredNetworkInfoResponse
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string) (*network.WiredNetworkInfoResponse, error)); ok {
|
|
return rf(uuid)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string) *network.WiredNetworkInfoResponse); ok {
|
|
r0 = rf(uuid)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*network.WiredNetworkInfoResponse)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string) error); ok {
|
|
r1 = rf(uuid)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockBackend_GetWiredNetworkDetails_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetWiredNetworkDetails'
|
|
type MockBackend_GetWiredNetworkDetails_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetWiredNetworkDetails is a helper method to define mock.On call
|
|
// - uuid string
|
|
func (_e *MockBackend_Expecter) GetWiredNetworkDetails(uuid interface{}) *MockBackend_GetWiredNetworkDetails_Call {
|
|
return &MockBackend_GetWiredNetworkDetails_Call{Call: _e.mock.On("GetWiredNetworkDetails", uuid)}
|
|
}
|
|
|
|
func (_c *MockBackend_GetWiredNetworkDetails_Call) Run(run func(uuid string)) *MockBackend_GetWiredNetworkDetails_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_GetWiredNetworkDetails_Call) Return(_a0 *network.WiredNetworkInfoResponse, _a1 error) *MockBackend_GetWiredNetworkDetails_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_GetWiredNetworkDetails_Call) RunAndReturn(run func(string) (*network.WiredNetworkInfoResponse, error)) *MockBackend_GetWiredNetworkDetails_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Initialize provides a mock function with no fields
|
|
func (_m *MockBackend) Initialize() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Initialize")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_Initialize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Initialize'
|
|
type MockBackend_Initialize_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Initialize is a helper method to define mock.On call
|
|
func (_e *MockBackend_Expecter) Initialize() *MockBackend_Initialize_Call {
|
|
return &MockBackend_Initialize_Call{Call: _e.mock.On("Initialize")}
|
|
}
|
|
|
|
func (_c *MockBackend_Initialize_Call) Run(run func()) *MockBackend_Initialize_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_Initialize_Call) Return(_a0 error) *MockBackend_Initialize_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_Initialize_Call) RunAndReturn(run func() error) *MockBackend_Initialize_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListActiveVPN provides a mock function with no fields
|
|
func (_m *MockBackend) ListActiveVPN() ([]network.VPNActive, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListActiveVPN")
|
|
}
|
|
|
|
var r0 []network.VPNActive
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() ([]network.VPNActive, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() []network.VPNActive); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]network.VPNActive)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockBackend_ListActiveVPN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListActiveVPN'
|
|
type MockBackend_ListActiveVPN_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListActiveVPN is a helper method to define mock.On call
|
|
func (_e *MockBackend_Expecter) ListActiveVPN() *MockBackend_ListActiveVPN_Call {
|
|
return &MockBackend_ListActiveVPN_Call{Call: _e.mock.On("ListActiveVPN")}
|
|
}
|
|
|
|
func (_c *MockBackend_ListActiveVPN_Call) Run(run func()) *MockBackend_ListActiveVPN_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ListActiveVPN_Call) Return(_a0 []network.VPNActive, _a1 error) *MockBackend_ListActiveVPN_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ListActiveVPN_Call) RunAndReturn(run func() ([]network.VPNActive, error)) *MockBackend_ListActiveVPN_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ListVPNProfiles provides a mock function with no fields
|
|
func (_m *MockBackend) ListVPNProfiles() ([]network.VPNProfile, error) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ListVPNProfiles")
|
|
}
|
|
|
|
var r0 []network.VPNProfile
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func() ([]network.VPNProfile, error)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() []network.VPNProfile); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]network.VPNProfile)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() error); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// MockBackend_ListVPNProfiles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListVPNProfiles'
|
|
type MockBackend_ListVPNProfiles_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ListVPNProfiles is a helper method to define mock.On call
|
|
func (_e *MockBackend_Expecter) ListVPNProfiles() *MockBackend_ListVPNProfiles_Call {
|
|
return &MockBackend_ListVPNProfiles_Call{Call: _e.mock.On("ListVPNProfiles")}
|
|
}
|
|
|
|
func (_c *MockBackend_ListVPNProfiles_Call) Run(run func()) *MockBackend_ListVPNProfiles_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ListVPNProfiles_Call) Return(_a0 []network.VPNProfile, _a1 error) *MockBackend_ListVPNProfiles_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ListVPNProfiles_Call) RunAndReturn(run func() ([]network.VPNProfile, error)) *MockBackend_ListVPNProfiles_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ScanWiFi provides a mock function with no fields
|
|
func (_m *MockBackend) ScanWiFi() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ScanWiFi")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_ScanWiFi_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ScanWiFi'
|
|
type MockBackend_ScanWiFi_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ScanWiFi is a helper method to define mock.On call
|
|
func (_e *MockBackend_Expecter) ScanWiFi() *MockBackend_ScanWiFi_Call {
|
|
return &MockBackend_ScanWiFi_Call{Call: _e.mock.On("ScanWiFi")}
|
|
}
|
|
|
|
func (_c *MockBackend_ScanWiFi_Call) Run(run func()) *MockBackend_ScanWiFi_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ScanWiFi_Call) Return(_a0 error) *MockBackend_ScanWiFi_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_ScanWiFi_Call) RunAndReturn(run func() error) *MockBackend_ScanWiFi_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetPromptBroker provides a mock function with given fields: broker
|
|
func (_m *MockBackend) SetPromptBroker(broker network.PromptBroker) error {
|
|
ret := _m.Called(broker)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetPromptBroker")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(network.PromptBroker) error); ok {
|
|
r0 = rf(broker)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_SetPromptBroker_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetPromptBroker'
|
|
type MockBackend_SetPromptBroker_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetPromptBroker is a helper method to define mock.On call
|
|
// - broker network.PromptBroker
|
|
func (_e *MockBackend_Expecter) SetPromptBroker(broker interface{}) *MockBackend_SetPromptBroker_Call {
|
|
return &MockBackend_SetPromptBroker_Call{Call: _e.mock.On("SetPromptBroker", broker)}
|
|
}
|
|
|
|
func (_c *MockBackend_SetPromptBroker_Call) Run(run func(broker network.PromptBroker)) *MockBackend_SetPromptBroker_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(network.PromptBroker))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_SetPromptBroker_Call) Return(_a0 error) *MockBackend_SetPromptBroker_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_SetPromptBroker_Call) RunAndReturn(run func(network.PromptBroker) error) *MockBackend_SetPromptBroker_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetWiFiAutoconnect provides a mock function with given fields: ssid, autoconnect
|
|
func (_m *MockBackend) SetWiFiAutoconnect(ssid string, autoconnect bool) error {
|
|
ret := _m.Called(ssid, autoconnect)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetWiFiAutoconnect")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, bool) error); ok {
|
|
r0 = rf(ssid, autoconnect)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_SetWiFiAutoconnect_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetWiFiAutoconnect'
|
|
type MockBackend_SetWiFiAutoconnect_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetWiFiAutoconnect is a helper method to define mock.On call
|
|
// - ssid string
|
|
// - autoconnect bool
|
|
func (_e *MockBackend_Expecter) SetWiFiAutoconnect(ssid interface{}, autoconnect interface{}) *MockBackend_SetWiFiAutoconnect_Call {
|
|
return &MockBackend_SetWiFiAutoconnect_Call{Call: _e.mock.On("SetWiFiAutoconnect", ssid, autoconnect)}
|
|
}
|
|
|
|
func (_c *MockBackend_SetWiFiAutoconnect_Call) Run(run func(ssid string, autoconnect bool)) *MockBackend_SetWiFiAutoconnect_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_SetWiFiAutoconnect_Call) Return(_a0 error) *MockBackend_SetWiFiAutoconnect_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_SetWiFiAutoconnect_Call) RunAndReturn(run func(string, bool) error) *MockBackend_SetWiFiAutoconnect_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetWiFiEnabled provides a mock function with given fields: enabled
|
|
func (_m *MockBackend) SetWiFiEnabled(enabled bool) error {
|
|
ret := _m.Called(enabled)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetWiFiEnabled")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(bool) error); ok {
|
|
r0 = rf(enabled)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_SetWiFiEnabled_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetWiFiEnabled'
|
|
type MockBackend_SetWiFiEnabled_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetWiFiEnabled is a helper method to define mock.On call
|
|
// - enabled bool
|
|
func (_e *MockBackend_Expecter) SetWiFiEnabled(enabled interface{}) *MockBackend_SetWiFiEnabled_Call {
|
|
return &MockBackend_SetWiFiEnabled_Call{Call: _e.mock.On("SetWiFiEnabled", enabled)}
|
|
}
|
|
|
|
func (_c *MockBackend_SetWiFiEnabled_Call) Run(run func(enabled bool)) *MockBackend_SetWiFiEnabled_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_SetWiFiEnabled_Call) Return(_a0 error) *MockBackend_SetWiFiEnabled_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_SetWiFiEnabled_Call) RunAndReturn(run func(bool) error) *MockBackend_SetWiFiEnabled_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// StartMonitoring provides a mock function with given fields: onStateChange
|
|
func (_m *MockBackend) StartMonitoring(onStateChange func()) error {
|
|
ret := _m.Called(onStateChange)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for StartMonitoring")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(func()) error); ok {
|
|
r0 = rf(onStateChange)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_StartMonitoring_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartMonitoring'
|
|
type MockBackend_StartMonitoring_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// StartMonitoring is a helper method to define mock.On call
|
|
// - onStateChange func()
|
|
func (_e *MockBackend_Expecter) StartMonitoring(onStateChange interface{}) *MockBackend_StartMonitoring_Call {
|
|
return &MockBackend_StartMonitoring_Call{Call: _e.mock.On("StartMonitoring", onStateChange)}
|
|
}
|
|
|
|
func (_c *MockBackend_StartMonitoring_Call) Run(run func(onStateChange func())) *MockBackend_StartMonitoring_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(func()))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_StartMonitoring_Call) Return(_a0 error) *MockBackend_StartMonitoring_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_StartMonitoring_Call) RunAndReturn(run func(func()) error) *MockBackend_StartMonitoring_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// StopMonitoring provides a mock function with no fields
|
|
func (_m *MockBackend) StopMonitoring() {
|
|
_m.Called()
|
|
}
|
|
|
|
// MockBackend_StopMonitoring_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StopMonitoring'
|
|
type MockBackend_StopMonitoring_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// StopMonitoring is a helper method to define mock.On call
|
|
func (_e *MockBackend_Expecter) StopMonitoring() *MockBackend_StopMonitoring_Call {
|
|
return &MockBackend_StopMonitoring_Call{Call: _e.mock.On("StopMonitoring")}
|
|
}
|
|
|
|
func (_c *MockBackend_StopMonitoring_Call) Run(run func()) *MockBackend_StopMonitoring_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_StopMonitoring_Call) Return() *MockBackend_StopMonitoring_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_StopMonitoring_Call) RunAndReturn(run func()) *MockBackend_StopMonitoring_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SubmitCredentials provides a mock function with given fields: token, secrets, save
|
|
func (_m *MockBackend) SubmitCredentials(token string, secrets map[string]string, save bool) error {
|
|
ret := _m.Called(token, secrets, save)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SubmitCredentials")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, map[string]string, bool) error); ok {
|
|
r0 = rf(token, secrets, save)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// MockBackend_SubmitCredentials_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubmitCredentials'
|
|
type MockBackend_SubmitCredentials_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SubmitCredentials is a helper method to define mock.On call
|
|
// - token string
|
|
// - secrets map[string]string
|
|
// - save bool
|
|
func (_e *MockBackend_Expecter) SubmitCredentials(token interface{}, secrets interface{}, save interface{}) *MockBackend_SubmitCredentials_Call {
|
|
return &MockBackend_SubmitCredentials_Call{Call: _e.mock.On("SubmitCredentials", token, secrets, save)}
|
|
}
|
|
|
|
func (_c *MockBackend_SubmitCredentials_Call) Run(run func(token string, secrets map[string]string, save bool)) *MockBackend_SubmitCredentials_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(map[string]string), args[2].(bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_SubmitCredentials_Call) Return(_a0 error) *MockBackend_SubmitCredentials_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *MockBackend_SubmitCredentials_Call) RunAndReturn(run func(string, map[string]string, bool) error) *MockBackend_SubmitCredentials_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewMockBackend creates a new instance of MockBackend. 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 NewMockBackend(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *MockBackend {
|
|
mock := &MockBackend{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|