Merged in feature/admin-api (pull request #191)
admin api and associated tools * in progress admin api started and permit.io setup tool started * docs * build fix * integration tests passing * new permit variables * fix permit * fix delete regex * fix delete response * docs * docs
This commit is contained in:
Jay Brown
@@ -99,6 +99,229 @@ func (_c *MockClientWithResponsesInterface_CancelDocumentBatchWithResponse_Call)
|
||||
return _c
|
||||
}
|
||||
|
||||
// CheckAdminUserExistsWithResponse provides a mock function with given fields: ctx, email, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) CheckAdminUserExistsWithResponse(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn) (*queryapi.CheckAdminUserExistsResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
for _i := range reqEditors {
|
||||
_va[_i] = reqEditors[_i]
|
||||
}
|
||||
var _ca []interface{}
|
||||
_ca = append(_ca, ctx, email)
|
||||
_ca = append(_ca, _va...)
|
||||
ret := _m.Called(_ca...)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for CheckAdminUserExistsWithResponse")
|
||||
}
|
||||
|
||||
var r0 *queryapi.CheckAdminUserExistsResponse
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*queryapi.CheckAdminUserExistsResponse, error)); ok {
|
||||
return rf(ctx, email, reqEditors...)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) *queryapi.CheckAdminUserExistsResponse); ok {
|
||||
r0 = rf(ctx, email, reqEditors...)
|
||||
} else {
|
||||
if ret.Get(0) != nil {
|
||||
r0 = ret.Get(0).(*queryapi.CheckAdminUserExistsResponse)
|
||||
}
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) error); ok {
|
||||
r1 = rf(ctx, email, reqEditors...)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// MockClientWithResponsesInterface_CheckAdminUserExistsWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CheckAdminUserExistsWithResponse'
|
||||
type MockClientWithResponsesInterface_CheckAdminUserExistsWithResponse_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// CheckAdminUserExistsWithResponse is a helper method to define mock.On call
|
||||
// - ctx context.Context
|
||||
// - email queryapi.UserEmail
|
||||
// - reqEditors ...queryapi.RequestEditorFn
|
||||
func (_e *MockClientWithResponsesInterface_Expecter) CheckAdminUserExistsWithResponse(ctx interface{}, email interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_CheckAdminUserExistsWithResponse_Call {
|
||||
return &MockClientWithResponsesInterface_CheckAdminUserExistsWithResponse_Call{Call: _e.mock.On("CheckAdminUserExistsWithResponse",
|
||||
append([]interface{}{ctx, email}, reqEditors...)...)}
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_CheckAdminUserExistsWithResponse_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CheckAdminUserExistsWithResponse_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
|
||||
for i, a := range args[2:] {
|
||||
if a != nil {
|
||||
variadicArgs[i] = a.(queryapi.RequestEditorFn)
|
||||
}
|
||||
}
|
||||
run(args[0].(context.Context), args[1].(queryapi.UserEmail), variadicArgs...)
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_CheckAdminUserExistsWithResponse_Call) Return(_a0 *queryapi.CheckAdminUserExistsResponse, _a1 error) *MockClientWithResponsesInterface_CheckAdminUserExistsWithResponse_Call {
|
||||
_c.Call.Return(_a0, _a1)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_CheckAdminUserExistsWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*queryapi.CheckAdminUserExistsResponse, error)) *MockClientWithResponsesInterface_CheckAdminUserExistsWithResponse_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// CreateAdminUserWithBodyWithResponse provides a mock function with given fields: ctx, contentType, body, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) CreateAdminUserWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*queryapi.CreateAdminUserResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
for _i := range reqEditors {
|
||||
_va[_i] = reqEditors[_i]
|
||||
}
|
||||
var _ca []interface{}
|
||||
_ca = append(_ca, ctx, contentType, body)
|
||||
_ca = append(_ca, _va...)
|
||||
ret := _m.Called(_ca...)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for CreateAdminUserWithBodyWithResponse")
|
||||
}
|
||||
|
||||
var r0 *queryapi.CreateAdminUserResponse
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.CreateAdminUserResponse, error)); ok {
|
||||
return rf(ctx, contentType, body, reqEditors...)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) *queryapi.CreateAdminUserResponse); ok {
|
||||
r0 = rf(ctx, contentType, body, reqEditors...)
|
||||
} else {
|
||||
if ret.Get(0) != nil {
|
||||
r0 = ret.Get(0).(*queryapi.CreateAdminUserResponse)
|
||||
}
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
|
||||
r1 = rf(ctx, contentType, body, reqEditors...)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// MockClientWithResponsesInterface_CreateAdminUserWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAdminUserWithBodyWithResponse'
|
||||
type MockClientWithResponsesInterface_CreateAdminUserWithBodyWithResponse_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// CreateAdminUserWithBodyWithResponse is a helper method to define mock.On call
|
||||
// - ctx context.Context
|
||||
// - contentType string
|
||||
// - body io.Reader
|
||||
// - reqEditors ...queryapi.RequestEditorFn
|
||||
func (_e *MockClientWithResponsesInterface_Expecter) CreateAdminUserWithBodyWithResponse(ctx interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_CreateAdminUserWithBodyWithResponse_Call {
|
||||
return &MockClientWithResponsesInterface_CreateAdminUserWithBodyWithResponse_Call{Call: _e.mock.On("CreateAdminUserWithBodyWithResponse",
|
||||
append([]interface{}{ctx, contentType, body}, reqEditors...)...)}
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_CreateAdminUserWithBodyWithResponse_Call) Run(run func(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CreateAdminUserWithBodyWithResponse_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
|
||||
for i, a := range args[3:] {
|
||||
if a != nil {
|
||||
variadicArgs[i] = a.(queryapi.RequestEditorFn)
|
||||
}
|
||||
}
|
||||
run(args[0].(context.Context), args[1].(string), args[2].(io.Reader), variadicArgs...)
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_CreateAdminUserWithBodyWithResponse_Call) Return(_a0 *queryapi.CreateAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_CreateAdminUserWithBodyWithResponse_Call {
|
||||
_c.Call.Return(_a0, _a1)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_CreateAdminUserWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.CreateAdminUserResponse, error)) *MockClientWithResponsesInterface_CreateAdminUserWithBodyWithResponse_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// CreateAdminUserWithResponse provides a mock function with given fields: ctx, body, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) CreateAdminUserWithResponse(ctx context.Context, body queryapi.CreateAdminUserJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*queryapi.CreateAdminUserResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
for _i := range reqEditors {
|
||||
_va[_i] = reqEditors[_i]
|
||||
}
|
||||
var _ca []interface{}
|
||||
_ca = append(_ca, ctx, body)
|
||||
_ca = append(_ca, _va...)
|
||||
ret := _m.Called(_ca...)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for CreateAdminUserWithResponse")
|
||||
}
|
||||
|
||||
var r0 *queryapi.CreateAdminUserResponse
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.CreateAdminUserResponse, error)); ok {
|
||||
return rf(ctx, body, reqEditors...)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.CreateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) *queryapi.CreateAdminUserResponse); ok {
|
||||
r0 = rf(ctx, body, reqEditors...)
|
||||
} else {
|
||||
if ret.Get(0) != nil {
|
||||
r0 = ret.Get(0).(*queryapi.CreateAdminUserResponse)
|
||||
}
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(context.Context, queryapi.CreateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) error); ok {
|
||||
r1 = rf(ctx, body, reqEditors...)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// MockClientWithResponsesInterface_CreateAdminUserWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAdminUserWithResponse'
|
||||
type MockClientWithResponsesInterface_CreateAdminUserWithResponse_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// CreateAdminUserWithResponse is a helper method to define mock.On call
|
||||
// - ctx context.Context
|
||||
// - body queryapi.CreateAdminUserJSONRequestBody
|
||||
// - reqEditors ...queryapi.RequestEditorFn
|
||||
func (_e *MockClientWithResponsesInterface_Expecter) CreateAdminUserWithResponse(ctx interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_CreateAdminUserWithResponse_Call {
|
||||
return &MockClientWithResponsesInterface_CreateAdminUserWithResponse_Call{Call: _e.mock.On("CreateAdminUserWithResponse",
|
||||
append([]interface{}{ctx, body}, reqEditors...)...)}
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_CreateAdminUserWithResponse_Call) Run(run func(ctx context.Context, body queryapi.CreateAdminUserJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_CreateAdminUserWithResponse_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
|
||||
for i, a := range args[2:] {
|
||||
if a != nil {
|
||||
variadicArgs[i] = a.(queryapi.RequestEditorFn)
|
||||
}
|
||||
}
|
||||
run(args[0].(context.Context), args[1].(queryapi.CreateAdminUserJSONRequestBody), variadicArgs...)
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_CreateAdminUserWithResponse_Call) Return(_a0 *queryapi.CreateAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_CreateAdminUserWithResponse_Call {
|
||||
_c.Call.Return(_a0, _a1)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_CreateAdminUserWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.CreateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.CreateAdminUserResponse, error)) *MockClientWithResponsesInterface_CreateAdminUserWithResponse_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// CreateClientWithBodyWithResponse provides a mock function with given fields: ctx, contentType, body, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) CreateClientWithBodyWithResponse(ctx context.Context, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*queryapi.CreateClientResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
@@ -397,6 +620,229 @@ func (_c *MockClientWithResponsesInterface_CreateQueryWithResponse_Call) RunAndR
|
||||
return _c
|
||||
}
|
||||
|
||||
// DeleteAdminUserWithResponse provides a mock function with given fields: ctx, email, params, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) DeleteAdminUserWithResponse(ctx context.Context, email queryapi.UserEmail, params *queryapi.DeleteAdminUserParams, reqEditors ...queryapi.RequestEditorFn) (*queryapi.DeleteAdminUserResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
for _i := range reqEditors {
|
||||
_va[_i] = reqEditors[_i]
|
||||
}
|
||||
var _ca []interface{}
|
||||
_ca = append(_ca, ctx, email, params)
|
||||
_ca = append(_ca, _va...)
|
||||
ret := _m.Called(_ca...)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for DeleteAdminUserWithResponse")
|
||||
}
|
||||
|
||||
var r0 *queryapi.DeleteAdminUserResponse
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, *queryapi.DeleteAdminUserParams, ...queryapi.RequestEditorFn) (*queryapi.DeleteAdminUserResponse, error)); ok {
|
||||
return rf(ctx, email, params, reqEditors...)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, *queryapi.DeleteAdminUserParams, ...queryapi.RequestEditorFn) *queryapi.DeleteAdminUserResponse); ok {
|
||||
r0 = rf(ctx, email, params, reqEditors...)
|
||||
} else {
|
||||
if ret.Get(0) != nil {
|
||||
r0 = ret.Get(0).(*queryapi.DeleteAdminUserResponse)
|
||||
}
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(context.Context, queryapi.UserEmail, *queryapi.DeleteAdminUserParams, ...queryapi.RequestEditorFn) error); ok {
|
||||
r1 = rf(ctx, email, params, reqEditors...)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// MockClientWithResponsesInterface_DeleteAdminUserWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAdminUserWithResponse'
|
||||
type MockClientWithResponsesInterface_DeleteAdminUserWithResponse_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// DeleteAdminUserWithResponse is a helper method to define mock.On call
|
||||
// - ctx context.Context
|
||||
// - email queryapi.UserEmail
|
||||
// - params *queryapi.DeleteAdminUserParams
|
||||
// - reqEditors ...queryapi.RequestEditorFn
|
||||
func (_e *MockClientWithResponsesInterface_Expecter) DeleteAdminUserWithResponse(ctx interface{}, email interface{}, params interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_DeleteAdminUserWithResponse_Call {
|
||||
return &MockClientWithResponsesInterface_DeleteAdminUserWithResponse_Call{Call: _e.mock.On("DeleteAdminUserWithResponse",
|
||||
append([]interface{}{ctx, email, params}, reqEditors...)...)}
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_DeleteAdminUserWithResponse_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, params *queryapi.DeleteAdminUserParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_DeleteAdminUserWithResponse_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
|
||||
for i, a := range args[3:] {
|
||||
if a != nil {
|
||||
variadicArgs[i] = a.(queryapi.RequestEditorFn)
|
||||
}
|
||||
}
|
||||
run(args[0].(context.Context), args[1].(queryapi.UserEmail), args[2].(*queryapi.DeleteAdminUserParams), variadicArgs...)
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_DeleteAdminUserWithResponse_Call) Return(_a0 *queryapi.DeleteAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_DeleteAdminUserWithResponse_Call {
|
||||
_c.Call.Return(_a0, _a1)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_DeleteAdminUserWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, *queryapi.DeleteAdminUserParams, ...queryapi.RequestEditorFn) (*queryapi.DeleteAdminUserResponse, error)) *MockClientWithResponsesInterface_DeleteAdminUserWithResponse_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// DisableAdminUserWithResponse provides a mock function with given fields: ctx, email, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) DisableAdminUserWithResponse(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn) (*queryapi.DisableAdminUserResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
for _i := range reqEditors {
|
||||
_va[_i] = reqEditors[_i]
|
||||
}
|
||||
var _ca []interface{}
|
||||
_ca = append(_ca, ctx, email)
|
||||
_ca = append(_ca, _va...)
|
||||
ret := _m.Called(_ca...)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for DisableAdminUserWithResponse")
|
||||
}
|
||||
|
||||
var r0 *queryapi.DisableAdminUserResponse
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*queryapi.DisableAdminUserResponse, error)); ok {
|
||||
return rf(ctx, email, reqEditors...)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) *queryapi.DisableAdminUserResponse); ok {
|
||||
r0 = rf(ctx, email, reqEditors...)
|
||||
} else {
|
||||
if ret.Get(0) != nil {
|
||||
r0 = ret.Get(0).(*queryapi.DisableAdminUserResponse)
|
||||
}
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) error); ok {
|
||||
r1 = rf(ctx, email, reqEditors...)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// MockClientWithResponsesInterface_DisableAdminUserWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DisableAdminUserWithResponse'
|
||||
type MockClientWithResponsesInterface_DisableAdminUserWithResponse_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// DisableAdminUserWithResponse is a helper method to define mock.On call
|
||||
// - ctx context.Context
|
||||
// - email queryapi.UserEmail
|
||||
// - reqEditors ...queryapi.RequestEditorFn
|
||||
func (_e *MockClientWithResponsesInterface_Expecter) DisableAdminUserWithResponse(ctx interface{}, email interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_DisableAdminUserWithResponse_Call {
|
||||
return &MockClientWithResponsesInterface_DisableAdminUserWithResponse_Call{Call: _e.mock.On("DisableAdminUserWithResponse",
|
||||
append([]interface{}{ctx, email}, reqEditors...)...)}
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_DisableAdminUserWithResponse_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_DisableAdminUserWithResponse_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
|
||||
for i, a := range args[2:] {
|
||||
if a != nil {
|
||||
variadicArgs[i] = a.(queryapi.RequestEditorFn)
|
||||
}
|
||||
}
|
||||
run(args[0].(context.Context), args[1].(queryapi.UserEmail), variadicArgs...)
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_DisableAdminUserWithResponse_Call) Return(_a0 *queryapi.DisableAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_DisableAdminUserWithResponse_Call {
|
||||
_c.Call.Return(_a0, _a1)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_DisableAdminUserWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*queryapi.DisableAdminUserResponse, error)) *MockClientWithResponsesInterface_DisableAdminUserWithResponse_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// EnableAdminUserWithResponse provides a mock function with given fields: ctx, email, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) EnableAdminUserWithResponse(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn) (*queryapi.EnableAdminUserResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
for _i := range reqEditors {
|
||||
_va[_i] = reqEditors[_i]
|
||||
}
|
||||
var _ca []interface{}
|
||||
_ca = append(_ca, ctx, email)
|
||||
_ca = append(_ca, _va...)
|
||||
ret := _m.Called(_ca...)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for EnableAdminUserWithResponse")
|
||||
}
|
||||
|
||||
var r0 *queryapi.EnableAdminUserResponse
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*queryapi.EnableAdminUserResponse, error)); ok {
|
||||
return rf(ctx, email, reqEditors...)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) *queryapi.EnableAdminUserResponse); ok {
|
||||
r0 = rf(ctx, email, reqEditors...)
|
||||
} else {
|
||||
if ret.Get(0) != nil {
|
||||
r0 = ret.Get(0).(*queryapi.EnableAdminUserResponse)
|
||||
}
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) error); ok {
|
||||
r1 = rf(ctx, email, reqEditors...)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// MockClientWithResponsesInterface_EnableAdminUserWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnableAdminUserWithResponse'
|
||||
type MockClientWithResponsesInterface_EnableAdminUserWithResponse_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// EnableAdminUserWithResponse is a helper method to define mock.On call
|
||||
// - ctx context.Context
|
||||
// - email queryapi.UserEmail
|
||||
// - reqEditors ...queryapi.RequestEditorFn
|
||||
func (_e *MockClientWithResponsesInterface_Expecter) EnableAdminUserWithResponse(ctx interface{}, email interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_EnableAdminUserWithResponse_Call {
|
||||
return &MockClientWithResponsesInterface_EnableAdminUserWithResponse_Call{Call: _e.mock.On("EnableAdminUserWithResponse",
|
||||
append([]interface{}{ctx, email}, reqEditors...)...)}
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_EnableAdminUserWithResponse_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_EnableAdminUserWithResponse_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
|
||||
for i, a := range args[2:] {
|
||||
if a != nil {
|
||||
variadicArgs[i] = a.(queryapi.RequestEditorFn)
|
||||
}
|
||||
}
|
||||
run(args[0].(context.Context), args[1].(queryapi.UserEmail), variadicArgs...)
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_EnableAdminUserWithResponse_Call) Return(_a0 *queryapi.EnableAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_EnableAdminUserWithResponse_Call {
|
||||
_c.Call.Return(_a0, _a1)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_EnableAdminUserWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*queryapi.EnableAdminUserResponse, error)) *MockClientWithResponsesInterface_EnableAdminUserWithResponse_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// ExportStateWithResponse provides a mock function with given fields: ctx, id, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) ExportStateWithResponse(ctx context.Context, id queryapi.ExportID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.ExportStateResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
@@ -471,6 +917,80 @@ func (_c *MockClientWithResponsesInterface_ExportStateWithResponse_Call) RunAndR
|
||||
return _c
|
||||
}
|
||||
|
||||
// GetAdminUserWithResponse provides a mock function with given fields: ctx, email, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) GetAdminUserWithResponse(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn) (*queryapi.GetAdminUserResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
for _i := range reqEditors {
|
||||
_va[_i] = reqEditors[_i]
|
||||
}
|
||||
var _ca []interface{}
|
||||
_ca = append(_ca, ctx, email)
|
||||
_ca = append(_ca, _va...)
|
||||
ret := _m.Called(_ca...)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for GetAdminUserWithResponse")
|
||||
}
|
||||
|
||||
var r0 *queryapi.GetAdminUserResponse
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*queryapi.GetAdminUserResponse, error)); ok {
|
||||
return rf(ctx, email, reqEditors...)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) *queryapi.GetAdminUserResponse); ok {
|
||||
r0 = rf(ctx, email, reqEditors...)
|
||||
} else {
|
||||
if ret.Get(0) != nil {
|
||||
r0 = ret.Get(0).(*queryapi.GetAdminUserResponse)
|
||||
}
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) error); ok {
|
||||
r1 = rf(ctx, email, reqEditors...)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// MockClientWithResponsesInterface_GetAdminUserWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAdminUserWithResponse'
|
||||
type MockClientWithResponsesInterface_GetAdminUserWithResponse_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// GetAdminUserWithResponse is a helper method to define mock.On call
|
||||
// - ctx context.Context
|
||||
// - email queryapi.UserEmail
|
||||
// - reqEditors ...queryapi.RequestEditorFn
|
||||
func (_e *MockClientWithResponsesInterface_Expecter) GetAdminUserWithResponse(ctx interface{}, email interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_GetAdminUserWithResponse_Call {
|
||||
return &MockClientWithResponsesInterface_GetAdminUserWithResponse_Call{Call: _e.mock.On("GetAdminUserWithResponse",
|
||||
append([]interface{}{ctx, email}, reqEditors...)...)}
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_GetAdminUserWithResponse_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetAdminUserWithResponse_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
|
||||
for i, a := range args[2:] {
|
||||
if a != nil {
|
||||
variadicArgs[i] = a.(queryapi.RequestEditorFn)
|
||||
}
|
||||
}
|
||||
run(args[0].(context.Context), args[1].(queryapi.UserEmail), variadicArgs...)
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_GetAdminUserWithResponse_Call) Return(_a0 *queryapi.GetAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_GetAdminUserWithResponse_Call {
|
||||
_c.Call.Return(_a0, _a1)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_GetAdminUserWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, ...queryapi.RequestEditorFn) (*queryapi.GetAdminUserResponse, error)) *MockClientWithResponsesInterface_GetAdminUserWithResponse_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// GetClientWithResponse provides a mock function with given fields: ctx, id, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) GetClientWithResponse(ctx context.Context, id queryapi.ClientID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.GetClientResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
@@ -989,6 +1509,80 @@ func (_c *MockClientWithResponsesInterface_GetStatusByClientIdWithResponse_Call)
|
||||
return _c
|
||||
}
|
||||
|
||||
// ListAdminUsersWithResponse provides a mock function with given fields: ctx, params, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) ListAdminUsersWithResponse(ctx context.Context, params *queryapi.ListAdminUsersParams, reqEditors ...queryapi.RequestEditorFn) (*queryapi.ListAdminUsersResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
for _i := range reqEditors {
|
||||
_va[_i] = reqEditors[_i]
|
||||
}
|
||||
var _ca []interface{}
|
||||
_ca = append(_ca, ctx, params)
|
||||
_ca = append(_ca, _va...)
|
||||
ret := _m.Called(_ca...)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for ListAdminUsersWithResponse")
|
||||
}
|
||||
|
||||
var r0 *queryapi.ListAdminUsersResponse
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(context.Context, *queryapi.ListAdminUsersParams, ...queryapi.RequestEditorFn) (*queryapi.ListAdminUsersResponse, error)); ok {
|
||||
return rf(ctx, params, reqEditors...)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(context.Context, *queryapi.ListAdminUsersParams, ...queryapi.RequestEditorFn) *queryapi.ListAdminUsersResponse); ok {
|
||||
r0 = rf(ctx, params, reqEditors...)
|
||||
} else {
|
||||
if ret.Get(0) != nil {
|
||||
r0 = ret.Get(0).(*queryapi.ListAdminUsersResponse)
|
||||
}
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(context.Context, *queryapi.ListAdminUsersParams, ...queryapi.RequestEditorFn) error); ok {
|
||||
r1 = rf(ctx, params, reqEditors...)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// MockClientWithResponsesInterface_ListAdminUsersWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ListAdminUsersWithResponse'
|
||||
type MockClientWithResponsesInterface_ListAdminUsersWithResponse_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// ListAdminUsersWithResponse is a helper method to define mock.On call
|
||||
// - ctx context.Context
|
||||
// - params *queryapi.ListAdminUsersParams
|
||||
// - reqEditors ...queryapi.RequestEditorFn
|
||||
func (_e *MockClientWithResponsesInterface_Expecter) ListAdminUsersWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_ListAdminUsersWithResponse_Call {
|
||||
return &MockClientWithResponsesInterface_ListAdminUsersWithResponse_Call{Call: _e.mock.On("ListAdminUsersWithResponse",
|
||||
append([]interface{}{ctx, params}, reqEditors...)...)}
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_ListAdminUsersWithResponse_Call) Run(run func(ctx context.Context, params *queryapi.ListAdminUsersParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_ListAdminUsersWithResponse_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-2)
|
||||
for i, a := range args[2:] {
|
||||
if a != nil {
|
||||
variadicArgs[i] = a.(queryapi.RequestEditorFn)
|
||||
}
|
||||
}
|
||||
run(args[0].(context.Context), args[1].(*queryapi.ListAdminUsersParams), variadicArgs...)
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_ListAdminUsersWithResponse_Call) Return(_a0 *queryapi.ListAdminUsersResponse, _a1 error) *MockClientWithResponsesInterface_ListAdminUsersWithResponse_Call {
|
||||
_c.Call.Return(_a0, _a1)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_ListAdminUsersWithResponse_Call) RunAndReturn(run func(context.Context, *queryapi.ListAdminUsersParams, ...queryapi.RequestEditorFn) (*queryapi.ListAdminUsersResponse, error)) *MockClientWithResponsesInterface_ListAdminUsersWithResponse_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// ListDocumentBatchesWithResponse provides a mock function with given fields: ctx, id, params, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) ListDocumentBatchesWithResponse(ctx context.Context, id queryapi.ClientID, params *queryapi.ListDocumentBatchesParams, reqEditors ...queryapi.RequestEditorFn) (*queryapi.ListDocumentBatchesResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
@@ -1884,6 +2478,157 @@ func (_c *MockClientWithResponsesInterface_TriggerExportWithResponse_Call) RunAn
|
||||
return _c
|
||||
}
|
||||
|
||||
// UpdateAdminUserWithBodyWithResponse provides a mock function with given fields: ctx, email, contentType, body, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) UpdateAdminUserWithBodyWithResponse(ctx context.Context, email queryapi.UserEmail, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*queryapi.UpdateAdminUserResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
for _i := range reqEditors {
|
||||
_va[_i] = reqEditors[_i]
|
||||
}
|
||||
var _ca []interface{}
|
||||
_ca = append(_ca, ctx, email, contentType, body)
|
||||
_ca = append(_ca, _va...)
|
||||
ret := _m.Called(_ca...)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for UpdateAdminUserWithBodyWithResponse")
|
||||
}
|
||||
|
||||
var r0 *queryapi.UpdateAdminUserResponse
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.UpdateAdminUserResponse, error)); ok {
|
||||
return rf(ctx, email, contentType, body, reqEditors...)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, string, io.Reader, ...queryapi.RequestEditorFn) *queryapi.UpdateAdminUserResponse); ok {
|
||||
r0 = rf(ctx, email, contentType, body, reqEditors...)
|
||||
} else {
|
||||
if ret.Get(0) != nil {
|
||||
r0 = ret.Get(0).(*queryapi.UpdateAdminUserResponse)
|
||||
}
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(context.Context, queryapi.UserEmail, string, io.Reader, ...queryapi.RequestEditorFn) error); ok {
|
||||
r1 = rf(ctx, email, contentType, body, reqEditors...)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAdminUserWithBodyWithResponse'
|
||||
type MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// UpdateAdminUserWithBodyWithResponse is a helper method to define mock.On call
|
||||
// - ctx context.Context
|
||||
// - email queryapi.UserEmail
|
||||
// - contentType string
|
||||
// - body io.Reader
|
||||
// - reqEditors ...queryapi.RequestEditorFn
|
||||
func (_e *MockClientWithResponsesInterface_Expecter) UpdateAdminUserWithBodyWithResponse(ctx interface{}, email interface{}, contentType interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call {
|
||||
return &MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call{Call: _e.mock.On("UpdateAdminUserWithBodyWithResponse",
|
||||
append([]interface{}{ctx, email, contentType, body}, reqEditors...)...)}
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-4)
|
||||
for i, a := range args[4:] {
|
||||
if a != nil {
|
||||
variadicArgs[i] = a.(queryapi.RequestEditorFn)
|
||||
}
|
||||
}
|
||||
run(args[0].(context.Context), args[1].(queryapi.UserEmail), args[2].(string), args[3].(io.Reader), variadicArgs...)
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call) Return(_a0 *queryapi.UpdateAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call {
|
||||
_c.Call.Return(_a0, _a1)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, string, io.Reader, ...queryapi.RequestEditorFn) (*queryapi.UpdateAdminUserResponse, error)) *MockClientWithResponsesInterface_UpdateAdminUserWithBodyWithResponse_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// UpdateAdminUserWithResponse provides a mock function with given fields: ctx, email, body, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) UpdateAdminUserWithResponse(ctx context.Context, email queryapi.UserEmail, body queryapi.UpdateAdminUserJSONRequestBody, reqEditors ...queryapi.RequestEditorFn) (*queryapi.UpdateAdminUserResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
for _i := range reqEditors {
|
||||
_va[_i] = reqEditors[_i]
|
||||
}
|
||||
var _ca []interface{}
|
||||
_ca = append(_ca, ctx, email, body)
|
||||
_ca = append(_ca, _va...)
|
||||
ret := _m.Called(_ca...)
|
||||
|
||||
if len(ret) == 0 {
|
||||
panic("no return value specified for UpdateAdminUserWithResponse")
|
||||
}
|
||||
|
||||
var r0 *queryapi.UpdateAdminUserResponse
|
||||
var r1 error
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, queryapi.UpdateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.UpdateAdminUserResponse, error)); ok {
|
||||
return rf(ctx, email, body, reqEditors...)
|
||||
}
|
||||
if rf, ok := ret.Get(0).(func(context.Context, queryapi.UserEmail, queryapi.UpdateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) *queryapi.UpdateAdminUserResponse); ok {
|
||||
r0 = rf(ctx, email, body, reqEditors...)
|
||||
} else {
|
||||
if ret.Get(0) != nil {
|
||||
r0 = ret.Get(0).(*queryapi.UpdateAdminUserResponse)
|
||||
}
|
||||
}
|
||||
|
||||
if rf, ok := ret.Get(1).(func(context.Context, queryapi.UserEmail, queryapi.UpdateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) error); ok {
|
||||
r1 = rf(ctx, email, body, reqEditors...)
|
||||
} else {
|
||||
r1 = ret.Error(1)
|
||||
}
|
||||
|
||||
return r0, r1
|
||||
}
|
||||
|
||||
// MockClientWithResponsesInterface_UpdateAdminUserWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateAdminUserWithResponse'
|
||||
type MockClientWithResponsesInterface_UpdateAdminUserWithResponse_Call struct {
|
||||
*mock.Call
|
||||
}
|
||||
|
||||
// UpdateAdminUserWithResponse is a helper method to define mock.On call
|
||||
// - ctx context.Context
|
||||
// - email queryapi.UserEmail
|
||||
// - body queryapi.UpdateAdminUserJSONRequestBody
|
||||
// - reqEditors ...queryapi.RequestEditorFn
|
||||
func (_e *MockClientWithResponsesInterface_Expecter) UpdateAdminUserWithResponse(ctx interface{}, email interface{}, body interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_UpdateAdminUserWithResponse_Call {
|
||||
return &MockClientWithResponsesInterface_UpdateAdminUserWithResponse_Call{Call: _e.mock.On("UpdateAdminUserWithResponse",
|
||||
append([]interface{}{ctx, email, body}, reqEditors...)...)}
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_UpdateAdminUserWithResponse_Call) Run(run func(ctx context.Context, email queryapi.UserEmail, body queryapi.UpdateAdminUserJSONRequestBody, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_UpdateAdminUserWithResponse_Call {
|
||||
_c.Call.Run(func(args mock.Arguments) {
|
||||
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-3)
|
||||
for i, a := range args[3:] {
|
||||
if a != nil {
|
||||
variadicArgs[i] = a.(queryapi.RequestEditorFn)
|
||||
}
|
||||
}
|
||||
run(args[0].(context.Context), args[1].(queryapi.UserEmail), args[2].(queryapi.UpdateAdminUserJSONRequestBody), variadicArgs...)
|
||||
})
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_UpdateAdminUserWithResponse_Call) Return(_a0 *queryapi.UpdateAdminUserResponse, _a1 error) *MockClientWithResponsesInterface_UpdateAdminUserWithResponse_Call {
|
||||
_c.Call.Return(_a0, _a1)
|
||||
return _c
|
||||
}
|
||||
|
||||
func (_c *MockClientWithResponsesInterface_UpdateAdminUserWithResponse_Call) RunAndReturn(run func(context.Context, queryapi.UserEmail, queryapi.UpdateAdminUserJSONRequestBody, ...queryapi.RequestEditorFn) (*queryapi.UpdateAdminUserResponse, error)) *MockClientWithResponsesInterface_UpdateAdminUserWithResponse_Call {
|
||||
_c.Call.Return(run)
|
||||
return _c
|
||||
}
|
||||
|
||||
// UpdateClientWithBodyWithResponse provides a mock function with given fields: ctx, id, contentType, body, reqEditors
|
||||
func (_m *MockClientWithResponsesInterface) UpdateClientWithBodyWithResponse(ctx context.Context, id queryapi.ClientID, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*queryapi.UpdateClientResponse, error) {
|
||||
_va := make([]interface{}, len(reqEditors))
|
||||
|
||||
Reference in New Issue
Block a user