mirror of
https://github.com/owncloud/ocis.git
synced 2025-04-18 23:44:07 +03:00
1323 lines
37 KiB
Go
1323 lines
37 KiB
Go
// Code generated by mockery v2.52.3. DO NOT EDIT.
|
|
|
|
package mocks
|
|
|
|
import (
|
|
context "context"
|
|
|
|
ldap "github.com/go-ldap/ldap/v3"
|
|
mock "github.com/stretchr/testify/mock"
|
|
|
|
time "time"
|
|
|
|
tls "crypto/tls"
|
|
)
|
|
|
|
// Client is an autogenerated mock type for the Client type
|
|
type Client struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type Client_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *Client) EXPECT() *Client_Expecter {
|
|
return &Client_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// Add provides a mock function with given fields: _a0
|
|
func (_m *Client) Add(_a0 *ldap.AddRequest) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Add")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*ldap.AddRequest) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_Add_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Add'
|
|
type Client_Add_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Add is a helper method to define mock.On call
|
|
// - _a0 *ldap.AddRequest
|
|
func (_e *Client_Expecter) Add(_a0 interface{}) *Client_Add_Call {
|
|
return &Client_Add_Call{Call: _e.mock.On("Add", _a0)}
|
|
}
|
|
|
|
func (_c *Client_Add_Call) Run(run func(_a0 *ldap.AddRequest)) *Client_Add_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*ldap.AddRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Add_Call) Return(_a0 error) *Client_Add_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Add_Call) RunAndReturn(run func(*ldap.AddRequest) error) *Client_Add_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Bind provides a mock function with given fields: username, password
|
|
func (_m *Client) Bind(username string, password string) error {
|
|
ret := _m.Called(username, password)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Bind")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, string) error); ok {
|
|
r0 = rf(username, password)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_Bind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bind'
|
|
type Client_Bind_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Bind is a helper method to define mock.On call
|
|
// - username string
|
|
// - password string
|
|
func (_e *Client_Expecter) Bind(username interface{}, password interface{}) *Client_Bind_Call {
|
|
return &Client_Bind_Call{Call: _e.mock.On("Bind", username, password)}
|
|
}
|
|
|
|
func (_c *Client_Bind_Call) Run(run func(username string, password string)) *Client_Bind_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Bind_Call) Return(_a0 error) *Client_Bind_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Bind_Call) RunAndReturn(run func(string, string) error) *Client_Bind_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Close provides a mock function with no fields
|
|
func (_m *Client) Close() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Close")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_Close_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Close'
|
|
type Client_Close_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Close is a helper method to define mock.On call
|
|
func (_e *Client_Expecter) Close() *Client_Close_Call {
|
|
return &Client_Close_Call{Call: _e.mock.On("Close")}
|
|
}
|
|
|
|
func (_c *Client_Close_Call) Run(run func()) *Client_Close_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Close_Call) Return(_a0 error) *Client_Close_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Close_Call) RunAndReturn(run func() error) *Client_Close_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Compare provides a mock function with given fields: dn, attribute, value
|
|
func (_m *Client) Compare(dn string, attribute string, value string) (bool, error) {
|
|
ret := _m.Called(dn, attribute, value)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Compare")
|
|
}
|
|
|
|
var r0 bool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(string, string, string) (bool, error)); ok {
|
|
return rf(dn, attribute, value)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(string, string, string) bool); ok {
|
|
r0 = rf(dn, attribute, value)
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(string, string, string) error); ok {
|
|
r1 = rf(dn, attribute, value)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Client_Compare_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Compare'
|
|
type Client_Compare_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Compare is a helper method to define mock.On call
|
|
// - dn string
|
|
// - attribute string
|
|
// - value string
|
|
func (_e *Client_Expecter) Compare(dn interface{}, attribute interface{}, value interface{}) *Client_Compare_Call {
|
|
return &Client_Compare_Call{Call: _e.mock.On("Compare", dn, attribute, value)}
|
|
}
|
|
|
|
func (_c *Client_Compare_Call) Run(run func(dn string, attribute string, value string)) *Client_Compare_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(string), args[2].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Compare_Call) Return(_a0 bool, _a1 error) *Client_Compare_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Compare_Call) RunAndReturn(run func(string, string, string) (bool, error)) *Client_Compare_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Del provides a mock function with given fields: _a0
|
|
func (_m *Client) Del(_a0 *ldap.DelRequest) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Del")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*ldap.DelRequest) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_Del_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Del'
|
|
type Client_Del_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Del is a helper method to define mock.On call
|
|
// - _a0 *ldap.DelRequest
|
|
func (_e *Client_Expecter) Del(_a0 interface{}) *Client_Del_Call {
|
|
return &Client_Del_Call{Call: _e.mock.On("Del", _a0)}
|
|
}
|
|
|
|
func (_c *Client_Del_Call) Run(run func(_a0 *ldap.DelRequest)) *Client_Del_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*ldap.DelRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Del_Call) Return(_a0 error) *Client_Del_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Del_Call) RunAndReturn(run func(*ldap.DelRequest) error) *Client_Del_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DirSync provides a mock function with given fields: searchRequest, flags, maxAttrCount, cookie
|
|
func (_m *Client) DirSync(searchRequest *ldap.SearchRequest, flags int64, maxAttrCount int64, cookie []byte) (*ldap.SearchResult, error) {
|
|
ret := _m.Called(searchRequest, flags, maxAttrCount, cookie)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DirSync")
|
|
}
|
|
|
|
var r0 *ldap.SearchResult
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*ldap.SearchRequest, int64, int64, []byte) (*ldap.SearchResult, error)); ok {
|
|
return rf(searchRequest, flags, maxAttrCount, cookie)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*ldap.SearchRequest, int64, int64, []byte) *ldap.SearchResult); ok {
|
|
r0 = rf(searchRequest, flags, maxAttrCount, cookie)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*ldap.SearchResult)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*ldap.SearchRequest, int64, int64, []byte) error); ok {
|
|
r1 = rf(searchRequest, flags, maxAttrCount, cookie)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Client_DirSync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DirSync'
|
|
type Client_DirSync_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DirSync is a helper method to define mock.On call
|
|
// - searchRequest *ldap.SearchRequest
|
|
// - flags int64
|
|
// - maxAttrCount int64
|
|
// - cookie []byte
|
|
func (_e *Client_Expecter) DirSync(searchRequest interface{}, flags interface{}, maxAttrCount interface{}, cookie interface{}) *Client_DirSync_Call {
|
|
return &Client_DirSync_Call{Call: _e.mock.On("DirSync", searchRequest, flags, maxAttrCount, cookie)}
|
|
}
|
|
|
|
func (_c *Client_DirSync_Call) Run(run func(searchRequest *ldap.SearchRequest, flags int64, maxAttrCount int64, cookie []byte)) *Client_DirSync_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*ldap.SearchRequest), args[1].(int64), args[2].(int64), args[3].([]byte))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_DirSync_Call) Return(_a0 *ldap.SearchResult, _a1 error) *Client_DirSync_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_DirSync_Call) RunAndReturn(run func(*ldap.SearchRequest, int64, int64, []byte) (*ldap.SearchResult, error)) *Client_DirSync_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DirSyncAsync provides a mock function with given fields: ctx, searchRequest, bufferSize, flags, maxAttrCount, cookie
|
|
func (_m *Client) DirSyncAsync(ctx context.Context, searchRequest *ldap.SearchRequest, bufferSize int, flags int64, maxAttrCount int64, cookie []byte) ldap.Response {
|
|
ret := _m.Called(ctx, searchRequest, bufferSize, flags, maxAttrCount, cookie)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DirSyncAsync")
|
|
}
|
|
|
|
var r0 ldap.Response
|
|
if rf, ok := ret.Get(0).(func(context.Context, *ldap.SearchRequest, int, int64, int64, []byte) ldap.Response); ok {
|
|
r0 = rf(ctx, searchRequest, bufferSize, flags, maxAttrCount, cookie)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(ldap.Response)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_DirSyncAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DirSyncAsync'
|
|
type Client_DirSyncAsync_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DirSyncAsync is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - searchRequest *ldap.SearchRequest
|
|
// - bufferSize int
|
|
// - flags int64
|
|
// - maxAttrCount int64
|
|
// - cookie []byte
|
|
func (_e *Client_Expecter) DirSyncAsync(ctx interface{}, searchRequest interface{}, bufferSize interface{}, flags interface{}, maxAttrCount interface{}, cookie interface{}) *Client_DirSyncAsync_Call {
|
|
return &Client_DirSyncAsync_Call{Call: _e.mock.On("DirSyncAsync", ctx, searchRequest, bufferSize, flags, maxAttrCount, cookie)}
|
|
}
|
|
|
|
func (_c *Client_DirSyncAsync_Call) Run(run func(ctx context.Context, searchRequest *ldap.SearchRequest, bufferSize int, flags int64, maxAttrCount int64, cookie []byte)) *Client_DirSyncAsync_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*ldap.SearchRequest), args[2].(int), args[3].(int64), args[4].(int64), args[5].([]byte))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_DirSyncAsync_Call) Return(_a0 ldap.Response) *Client_DirSyncAsync_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_DirSyncAsync_Call) RunAndReturn(run func(context.Context, *ldap.SearchRequest, int, int64, int64, []byte) ldap.Response) *Client_DirSyncAsync_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ExternalBind provides a mock function with no fields
|
|
func (_m *Client) ExternalBind() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ExternalBind")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_ExternalBind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ExternalBind'
|
|
type Client_ExternalBind_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ExternalBind is a helper method to define mock.On call
|
|
func (_e *Client_Expecter) ExternalBind() *Client_ExternalBind_Call {
|
|
return &Client_ExternalBind_Call{Call: _e.mock.On("ExternalBind")}
|
|
}
|
|
|
|
func (_c *Client_ExternalBind_Call) Run(run func()) *Client_ExternalBind_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_ExternalBind_Call) Return(_a0 error) *Client_ExternalBind_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_ExternalBind_Call) RunAndReturn(run func() error) *Client_ExternalBind_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetLastError provides a mock function with no fields
|
|
func (_m *Client) GetLastError() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetLastError")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_GetLastError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetLastError'
|
|
type Client_GetLastError_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetLastError is a helper method to define mock.On call
|
|
func (_e *Client_Expecter) GetLastError() *Client_GetLastError_Call {
|
|
return &Client_GetLastError_Call{Call: _e.mock.On("GetLastError")}
|
|
}
|
|
|
|
func (_c *Client_GetLastError_Call) Run(run func()) *Client_GetLastError_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_GetLastError_Call) Return(_a0 error) *Client_GetLastError_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_GetLastError_Call) RunAndReturn(run func() error) *Client_GetLastError_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// IsClosing provides a mock function with no fields
|
|
func (_m *Client) IsClosing() bool {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for IsClosing")
|
|
}
|
|
|
|
var r0 bool
|
|
if rf, ok := ret.Get(0).(func() bool); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(bool)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_IsClosing_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsClosing'
|
|
type Client_IsClosing_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// IsClosing is a helper method to define mock.On call
|
|
func (_e *Client_Expecter) IsClosing() *Client_IsClosing_Call {
|
|
return &Client_IsClosing_Call{Call: _e.mock.On("IsClosing")}
|
|
}
|
|
|
|
func (_c *Client_IsClosing_Call) Run(run func()) *Client_IsClosing_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_IsClosing_Call) Return(_a0 bool) *Client_IsClosing_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_IsClosing_Call) RunAndReturn(run func() bool) *Client_IsClosing_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Modify provides a mock function with given fields: _a0
|
|
func (_m *Client) Modify(_a0 *ldap.ModifyRequest) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Modify")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*ldap.ModifyRequest) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_Modify_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Modify'
|
|
type Client_Modify_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Modify is a helper method to define mock.On call
|
|
// - _a0 *ldap.ModifyRequest
|
|
func (_e *Client_Expecter) Modify(_a0 interface{}) *Client_Modify_Call {
|
|
return &Client_Modify_Call{Call: _e.mock.On("Modify", _a0)}
|
|
}
|
|
|
|
func (_c *Client_Modify_Call) Run(run func(_a0 *ldap.ModifyRequest)) *Client_Modify_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*ldap.ModifyRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Modify_Call) Return(_a0 error) *Client_Modify_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Modify_Call) RunAndReturn(run func(*ldap.ModifyRequest) error) *Client_Modify_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ModifyDN provides a mock function with given fields: _a0
|
|
func (_m *Client) ModifyDN(_a0 *ldap.ModifyDNRequest) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ModifyDN")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*ldap.ModifyDNRequest) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_ModifyDN_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyDN'
|
|
type Client_ModifyDN_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ModifyDN is a helper method to define mock.On call
|
|
// - _a0 *ldap.ModifyDNRequest
|
|
func (_e *Client_Expecter) ModifyDN(_a0 interface{}) *Client_ModifyDN_Call {
|
|
return &Client_ModifyDN_Call{Call: _e.mock.On("ModifyDN", _a0)}
|
|
}
|
|
|
|
func (_c *Client_ModifyDN_Call) Run(run func(_a0 *ldap.ModifyDNRequest)) *Client_ModifyDN_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*ldap.ModifyDNRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_ModifyDN_Call) Return(_a0 error) *Client_ModifyDN_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_ModifyDN_Call) RunAndReturn(run func(*ldap.ModifyDNRequest) error) *Client_ModifyDN_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// ModifyWithResult provides a mock function with given fields: _a0
|
|
func (_m *Client) ModifyWithResult(_a0 *ldap.ModifyRequest) (*ldap.ModifyResult, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for ModifyWithResult")
|
|
}
|
|
|
|
var r0 *ldap.ModifyResult
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*ldap.ModifyRequest) (*ldap.ModifyResult, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*ldap.ModifyRequest) *ldap.ModifyResult); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*ldap.ModifyResult)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*ldap.ModifyRequest) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Client_ModifyWithResult_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ModifyWithResult'
|
|
type Client_ModifyWithResult_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// ModifyWithResult is a helper method to define mock.On call
|
|
// - _a0 *ldap.ModifyRequest
|
|
func (_e *Client_Expecter) ModifyWithResult(_a0 interface{}) *Client_ModifyWithResult_Call {
|
|
return &Client_ModifyWithResult_Call{Call: _e.mock.On("ModifyWithResult", _a0)}
|
|
}
|
|
|
|
func (_c *Client_ModifyWithResult_Call) Run(run func(_a0 *ldap.ModifyRequest)) *Client_ModifyWithResult_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*ldap.ModifyRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_ModifyWithResult_Call) Return(_a0 *ldap.ModifyResult, _a1 error) *Client_ModifyWithResult_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_ModifyWithResult_Call) RunAndReturn(run func(*ldap.ModifyRequest) (*ldap.ModifyResult, error)) *Client_ModifyWithResult_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NTLMUnauthenticatedBind provides a mock function with given fields: domain, username
|
|
func (_m *Client) NTLMUnauthenticatedBind(domain string, username string) error {
|
|
ret := _m.Called(domain, username)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for NTLMUnauthenticatedBind")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string, string) error); ok {
|
|
r0 = rf(domain, username)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_NTLMUnauthenticatedBind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NTLMUnauthenticatedBind'
|
|
type Client_NTLMUnauthenticatedBind_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// NTLMUnauthenticatedBind is a helper method to define mock.On call
|
|
// - domain string
|
|
// - username string
|
|
func (_e *Client_Expecter) NTLMUnauthenticatedBind(domain interface{}, username interface{}) *Client_NTLMUnauthenticatedBind_Call {
|
|
return &Client_NTLMUnauthenticatedBind_Call{Call: _e.mock.On("NTLMUnauthenticatedBind", domain, username)}
|
|
}
|
|
|
|
func (_c *Client_NTLMUnauthenticatedBind_Call) Run(run func(domain string, username string)) *Client_NTLMUnauthenticatedBind_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_NTLMUnauthenticatedBind_Call) Return(_a0 error) *Client_NTLMUnauthenticatedBind_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_NTLMUnauthenticatedBind_Call) RunAndReturn(run func(string, string) error) *Client_NTLMUnauthenticatedBind_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// PasswordModify provides a mock function with given fields: _a0
|
|
func (_m *Client) PasswordModify(_a0 *ldap.PasswordModifyRequest) (*ldap.PasswordModifyResult, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for PasswordModify")
|
|
}
|
|
|
|
var r0 *ldap.PasswordModifyResult
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*ldap.PasswordModifyRequest) (*ldap.PasswordModifyResult, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*ldap.PasswordModifyRequest) *ldap.PasswordModifyResult); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*ldap.PasswordModifyResult)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*ldap.PasswordModifyRequest) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Client_PasswordModify_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PasswordModify'
|
|
type Client_PasswordModify_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// PasswordModify is a helper method to define mock.On call
|
|
// - _a0 *ldap.PasswordModifyRequest
|
|
func (_e *Client_Expecter) PasswordModify(_a0 interface{}) *Client_PasswordModify_Call {
|
|
return &Client_PasswordModify_Call{Call: _e.mock.On("PasswordModify", _a0)}
|
|
}
|
|
|
|
func (_c *Client_PasswordModify_Call) Run(run func(_a0 *ldap.PasswordModifyRequest)) *Client_PasswordModify_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*ldap.PasswordModifyRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_PasswordModify_Call) Return(_a0 *ldap.PasswordModifyResult, _a1 error) *Client_PasswordModify_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_PasswordModify_Call) RunAndReturn(run func(*ldap.PasswordModifyRequest) (*ldap.PasswordModifyResult, error)) *Client_PasswordModify_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Search provides a mock function with given fields: _a0
|
|
func (_m *Client) Search(_a0 *ldap.SearchRequest) (*ldap.SearchResult, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Search")
|
|
}
|
|
|
|
var r0 *ldap.SearchResult
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*ldap.SearchRequest) (*ldap.SearchResult, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*ldap.SearchRequest) *ldap.SearchResult); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*ldap.SearchResult)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*ldap.SearchRequest) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Client_Search_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Search'
|
|
type Client_Search_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Search is a helper method to define mock.On call
|
|
// - _a0 *ldap.SearchRequest
|
|
func (_e *Client_Expecter) Search(_a0 interface{}) *Client_Search_Call {
|
|
return &Client_Search_Call{Call: _e.mock.On("Search", _a0)}
|
|
}
|
|
|
|
func (_c *Client_Search_Call) Run(run func(_a0 *ldap.SearchRequest)) *Client_Search_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*ldap.SearchRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Search_Call) Return(_a0 *ldap.SearchResult, _a1 error) *Client_Search_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Search_Call) RunAndReturn(run func(*ldap.SearchRequest) (*ldap.SearchResult, error)) *Client_Search_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SearchAsync provides a mock function with given fields: ctx, searchRequest, bufferSize
|
|
func (_m *Client) SearchAsync(ctx context.Context, searchRequest *ldap.SearchRequest, bufferSize int) ldap.Response {
|
|
ret := _m.Called(ctx, searchRequest, bufferSize)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SearchAsync")
|
|
}
|
|
|
|
var r0 ldap.Response
|
|
if rf, ok := ret.Get(0).(func(context.Context, *ldap.SearchRequest, int) ldap.Response); ok {
|
|
r0 = rf(ctx, searchRequest, bufferSize)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(ldap.Response)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_SearchAsync_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchAsync'
|
|
type Client_SearchAsync_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SearchAsync is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - searchRequest *ldap.SearchRequest
|
|
// - bufferSize int
|
|
func (_e *Client_Expecter) SearchAsync(ctx interface{}, searchRequest interface{}, bufferSize interface{}) *Client_SearchAsync_Call {
|
|
return &Client_SearchAsync_Call{Call: _e.mock.On("SearchAsync", ctx, searchRequest, bufferSize)}
|
|
}
|
|
|
|
func (_c *Client_SearchAsync_Call) Run(run func(ctx context.Context, searchRequest *ldap.SearchRequest, bufferSize int)) *Client_SearchAsync_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*ldap.SearchRequest), args[2].(int))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_SearchAsync_Call) Return(_a0 ldap.Response) *Client_SearchAsync_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_SearchAsync_Call) RunAndReturn(run func(context.Context, *ldap.SearchRequest, int) ldap.Response) *Client_SearchAsync_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SearchWithPaging provides a mock function with given fields: searchRequest, pagingSize
|
|
func (_m *Client) SearchWithPaging(searchRequest *ldap.SearchRequest, pagingSize uint32) (*ldap.SearchResult, error) {
|
|
ret := _m.Called(searchRequest, pagingSize)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SearchWithPaging")
|
|
}
|
|
|
|
var r0 *ldap.SearchResult
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*ldap.SearchRequest, uint32) (*ldap.SearchResult, error)); ok {
|
|
return rf(searchRequest, pagingSize)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*ldap.SearchRequest, uint32) *ldap.SearchResult); ok {
|
|
r0 = rf(searchRequest, pagingSize)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*ldap.SearchResult)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*ldap.SearchRequest, uint32) error); ok {
|
|
r1 = rf(searchRequest, pagingSize)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Client_SearchWithPaging_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SearchWithPaging'
|
|
type Client_SearchWithPaging_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SearchWithPaging is a helper method to define mock.On call
|
|
// - searchRequest *ldap.SearchRequest
|
|
// - pagingSize uint32
|
|
func (_e *Client_Expecter) SearchWithPaging(searchRequest interface{}, pagingSize interface{}) *Client_SearchWithPaging_Call {
|
|
return &Client_SearchWithPaging_Call{Call: _e.mock.On("SearchWithPaging", searchRequest, pagingSize)}
|
|
}
|
|
|
|
func (_c *Client_SearchWithPaging_Call) Run(run func(searchRequest *ldap.SearchRequest, pagingSize uint32)) *Client_SearchWithPaging_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*ldap.SearchRequest), args[1].(uint32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_SearchWithPaging_Call) Return(_a0 *ldap.SearchResult, _a1 error) *Client_SearchWithPaging_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_SearchWithPaging_Call) RunAndReturn(run func(*ldap.SearchRequest, uint32) (*ldap.SearchResult, error)) *Client_SearchWithPaging_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetTimeout provides a mock function with given fields: _a0
|
|
func (_m *Client) SetTimeout(_a0 time.Duration) {
|
|
_m.Called(_a0)
|
|
}
|
|
|
|
// Client_SetTimeout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTimeout'
|
|
type Client_SetTimeout_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetTimeout is a helper method to define mock.On call
|
|
// - _a0 time.Duration
|
|
func (_e *Client_Expecter) SetTimeout(_a0 interface{}) *Client_SetTimeout_Call {
|
|
return &Client_SetTimeout_Call{Call: _e.mock.On("SetTimeout", _a0)}
|
|
}
|
|
|
|
func (_c *Client_SetTimeout_Call) Run(run func(_a0 time.Duration)) *Client_SetTimeout_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(time.Duration))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_SetTimeout_Call) Return() *Client_SetTimeout_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_SetTimeout_Call) RunAndReturn(run func(time.Duration)) *Client_SetTimeout_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// SimpleBind provides a mock function with given fields: _a0
|
|
func (_m *Client) SimpleBind(_a0 *ldap.SimpleBindRequest) (*ldap.SimpleBindResult, error) {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SimpleBind")
|
|
}
|
|
|
|
var r0 *ldap.SimpleBindResult
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(*ldap.SimpleBindRequest) (*ldap.SimpleBindResult, error)); ok {
|
|
return rf(_a0)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(*ldap.SimpleBindRequest) *ldap.SimpleBindResult); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*ldap.SimpleBindResult)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(*ldap.SimpleBindRequest) error); ok {
|
|
r1 = rf(_a0)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Client_SimpleBind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SimpleBind'
|
|
type Client_SimpleBind_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SimpleBind is a helper method to define mock.On call
|
|
// - _a0 *ldap.SimpleBindRequest
|
|
func (_e *Client_Expecter) SimpleBind(_a0 interface{}) *Client_SimpleBind_Call {
|
|
return &Client_SimpleBind_Call{Call: _e.mock.On("SimpleBind", _a0)}
|
|
}
|
|
|
|
func (_c *Client_SimpleBind_Call) Run(run func(_a0 *ldap.SimpleBindRequest)) *Client_SimpleBind_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*ldap.SimpleBindRequest))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_SimpleBind_Call) Return(_a0 *ldap.SimpleBindResult, _a1 error) *Client_SimpleBind_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_SimpleBind_Call) RunAndReturn(run func(*ldap.SimpleBindRequest) (*ldap.SimpleBindResult, error)) *Client_SimpleBind_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Start provides a mock function with no fields
|
|
func (_m *Client) Start() {
|
|
_m.Called()
|
|
}
|
|
|
|
// Client_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'
|
|
type Client_Start_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Start is a helper method to define mock.On call
|
|
func (_e *Client_Expecter) Start() *Client_Start_Call {
|
|
return &Client_Start_Call{Call: _e.mock.On("Start")}
|
|
}
|
|
|
|
func (_c *Client_Start_Call) Run(run func()) *Client_Start_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Start_Call) Return() *Client_Start_Call {
|
|
_c.Call.Return()
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Start_Call) RunAndReturn(run func()) *Client_Start_Call {
|
|
_c.Run(run)
|
|
return _c
|
|
}
|
|
|
|
// StartTLS provides a mock function with given fields: _a0
|
|
func (_m *Client) StartTLS(_a0 *tls.Config) error {
|
|
ret := _m.Called(_a0)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for StartTLS")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(*tls.Config) error); ok {
|
|
r0 = rf(_a0)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_StartTLS_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StartTLS'
|
|
type Client_StartTLS_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// StartTLS is a helper method to define mock.On call
|
|
// - _a0 *tls.Config
|
|
func (_e *Client_Expecter) StartTLS(_a0 interface{}) *Client_StartTLS_Call {
|
|
return &Client_StartTLS_Call{Call: _e.mock.On("StartTLS", _a0)}
|
|
}
|
|
|
|
func (_c *Client_StartTLS_Call) Run(run func(_a0 *tls.Config)) *Client_StartTLS_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(*tls.Config))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_StartTLS_Call) Return(_a0 error) *Client_StartTLS_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_StartTLS_Call) RunAndReturn(run func(*tls.Config) error) *Client_StartTLS_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Syncrepl provides a mock function with given fields: ctx, searchRequest, bufferSize, mode, cookie, reloadHint
|
|
func (_m *Client) Syncrepl(ctx context.Context, searchRequest *ldap.SearchRequest, bufferSize int, mode ldap.ControlSyncRequestMode, cookie []byte, reloadHint bool) ldap.Response {
|
|
ret := _m.Called(ctx, searchRequest, bufferSize, mode, cookie, reloadHint)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Syncrepl")
|
|
}
|
|
|
|
var r0 ldap.Response
|
|
if rf, ok := ret.Get(0).(func(context.Context, *ldap.SearchRequest, int, ldap.ControlSyncRequestMode, []byte, bool) ldap.Response); ok {
|
|
r0 = rf(ctx, searchRequest, bufferSize, mode, cookie, reloadHint)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(ldap.Response)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_Syncrepl_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Syncrepl'
|
|
type Client_Syncrepl_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Syncrepl is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - searchRequest *ldap.SearchRequest
|
|
// - bufferSize int
|
|
// - mode ldap.ControlSyncRequestMode
|
|
// - cookie []byte
|
|
// - reloadHint bool
|
|
func (_e *Client_Expecter) Syncrepl(ctx interface{}, searchRequest interface{}, bufferSize interface{}, mode interface{}, cookie interface{}, reloadHint interface{}) *Client_Syncrepl_Call {
|
|
return &Client_Syncrepl_Call{Call: _e.mock.On("Syncrepl", ctx, searchRequest, bufferSize, mode, cookie, reloadHint)}
|
|
}
|
|
|
|
func (_c *Client_Syncrepl_Call) Run(run func(ctx context.Context, searchRequest *ldap.SearchRequest, bufferSize int, mode ldap.ControlSyncRequestMode, cookie []byte, reloadHint bool)) *Client_Syncrepl_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(*ldap.SearchRequest), args[2].(int), args[3].(ldap.ControlSyncRequestMode), args[4].([]byte), args[5].(bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Syncrepl_Call) Return(_a0 ldap.Response) *Client_Syncrepl_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Syncrepl_Call) RunAndReturn(run func(context.Context, *ldap.SearchRequest, int, ldap.ControlSyncRequestMode, []byte, bool) ldap.Response) *Client_Syncrepl_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// TLSConnectionState provides a mock function with no fields
|
|
func (_m *Client) TLSConnectionState() (tls.ConnectionState, bool) {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for TLSConnectionState")
|
|
}
|
|
|
|
var r0 tls.ConnectionState
|
|
var r1 bool
|
|
if rf, ok := ret.Get(0).(func() (tls.ConnectionState, bool)); ok {
|
|
return rf()
|
|
}
|
|
if rf, ok := ret.Get(0).(func() tls.ConnectionState); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Get(0).(tls.ConnectionState)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func() bool); ok {
|
|
r1 = rf()
|
|
} else {
|
|
r1 = ret.Get(1).(bool)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Client_TLSConnectionState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TLSConnectionState'
|
|
type Client_TLSConnectionState_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// TLSConnectionState is a helper method to define mock.On call
|
|
func (_e *Client_Expecter) TLSConnectionState() *Client_TLSConnectionState_Call {
|
|
return &Client_TLSConnectionState_Call{Call: _e.mock.On("TLSConnectionState")}
|
|
}
|
|
|
|
func (_c *Client_TLSConnectionState_Call) Run(run func()) *Client_TLSConnectionState_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_TLSConnectionState_Call) Return(_a0 tls.ConnectionState, _a1 bool) *Client_TLSConnectionState_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_TLSConnectionState_Call) RunAndReturn(run func() (tls.ConnectionState, bool)) *Client_TLSConnectionState_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UnauthenticatedBind provides a mock function with given fields: username
|
|
func (_m *Client) UnauthenticatedBind(username string) error {
|
|
ret := _m.Called(username)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UnauthenticatedBind")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(string) error); ok {
|
|
r0 = rf(username)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_UnauthenticatedBind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UnauthenticatedBind'
|
|
type Client_UnauthenticatedBind_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UnauthenticatedBind is a helper method to define mock.On call
|
|
// - username string
|
|
func (_e *Client_Expecter) UnauthenticatedBind(username interface{}) *Client_UnauthenticatedBind_Call {
|
|
return &Client_UnauthenticatedBind_Call{Call: _e.mock.On("UnauthenticatedBind", username)}
|
|
}
|
|
|
|
func (_c *Client_UnauthenticatedBind_Call) Run(run func(username string)) *Client_UnauthenticatedBind_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_UnauthenticatedBind_Call) Return(_a0 error) *Client_UnauthenticatedBind_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_UnauthenticatedBind_Call) RunAndReturn(run func(string) error) *Client_UnauthenticatedBind_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// Unbind provides a mock function with no fields
|
|
func (_m *Client) Unbind() error {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for Unbind")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func() error); ok {
|
|
r0 = rf()
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Client_Unbind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unbind'
|
|
type Client_Unbind_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// Unbind is a helper method to define mock.On call
|
|
func (_e *Client_Expecter) Unbind() *Client_Unbind_Call {
|
|
return &Client_Unbind_Call{Call: _e.mock.On("Unbind")}
|
|
}
|
|
|
|
func (_c *Client_Unbind_Call) Run(run func()) *Client_Unbind_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Unbind_Call) Return(_a0 error) *Client_Unbind_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Client_Unbind_Call) RunAndReturn(run func() error) *Client_Unbind_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewClient creates a new instance of Client. 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 NewClient(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *Client {
|
|
mock := &Client{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|