jacob-mathison/query-orchestration
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Activity

openapi changes

Browse Source
This commit is contained in:
jay brown
2025-04-07 14:10:39 -07:00
parent 9b8101dea1
commit 73709878d9
7 changed files with 1685 additions and 60 deletions
Download Patch File Download Diff File Expand all files Collapse all files
mocks/queryapi/mock_ClientInterface.go
+293
View File
@@ -622,6 +622,79 @@ func (_c *MockClientInterface_GetDocument_Call) RunAndReturn(run func(context.Co
return _c
}
// GetHomePage provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientInterface) GetHomePage(ctx context.Context, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
for _i := range reqEditors {
_va[_i] = reqEditors[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for GetHomePage")
}
var r0 *http.Response
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
return rf(ctx, reqEditors...)
}
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) *http.Response); ok {
r0 = rf(ctx, reqEditors...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*http.Response)
}
}
if rf, ok := ret.Get(1).(func(context.Context, ...queryapi.RequestEditorFn) error); ok {
r1 = rf(ctx, reqEditors...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockClientInterface_GetHomePage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHomePage'
type MockClientInterface_GetHomePage_Call struct {
*mock.Call
}
// GetHomePage is a helper method to define mock.On call
// - ctx context.Context
// - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) GetHomePage(ctx interface{}, reqEditors ...interface{}) *MockClientInterface_GetHomePage_Call {
return &MockClientInterface_GetHomePage_Call{Call: _e.mock.On("GetHomePage",
append([]interface{}{ctx}, reqEditors...)...)}
}
func (_c *MockClientInterface_GetHomePage_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_GetHomePage_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-1)
for i, a := range args[1:] {
if a != nil {
variadicArgs[i] = a.(queryapi.RequestEditorFn)
}
}
run(args[0].(context.Context), variadicArgs...)
})
return _c
}
func (_c *MockClientInterface_GetHomePage_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_GetHomePage_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockClientInterface_GetHomePage_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_GetHomePage_Call {
_c.Call.Return(run)
return _c
}
// GetQuery provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientInterface) GetQuery(ctx context.Context, id uuid.UUID, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
@@ -917,6 +990,226 @@ func (_c *MockClientInterface_ListQueries_Call) RunAndReturn(run func(context.Co
return _c
}
// Login provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientInterface) Login(ctx context.Context, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
for _i := range reqEditors {
_va[_i] = reqEditors[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for Login")
}
var r0 *http.Response
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
return rf(ctx, reqEditors...)
}
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) *http.Response); ok {
r0 = rf(ctx, reqEditors...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*http.Response)
}
}
if rf, ok := ret.Get(1).(func(context.Context, ...queryapi.RequestEditorFn) error); ok {
r1 = rf(ctx, reqEditors...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockClientInterface_Login_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Login'
type MockClientInterface_Login_Call struct {
*mock.Call
}
// Login is a helper method to define mock.On call
// - ctx context.Context
// - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) Login(ctx interface{}, reqEditors ...interface{}) *MockClientInterface_Login_Call {
return &MockClientInterface_Login_Call{Call: _e.mock.On("Login",
append([]interface{}{ctx}, reqEditors...)...)}
}
func (_c *MockClientInterface_Login_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_Login_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-1)
for i, a := range args[1:] {
if a != nil {
variadicArgs[i] = a.(queryapi.RequestEditorFn)
}
}
run(args[0].(context.Context), variadicArgs...)
})
return _c
}
func (_c *MockClientInterface_Login_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_Login_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockClientInterface_Login_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_Login_Call {
_c.Call.Return(run)
return _c
}
// LoginCallback provides a mock function with given fields: ctx, params, reqEditors
func (_m *MockClientInterface) LoginCallback(ctx context.Context, params *queryapi.LoginCallbackParams, reqEditors ...queryapi.RequestEditorFn) (*http.Response, 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 LoginCallback")
}
var r0 *http.Response
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *queryapi.LoginCallbackParams, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
return rf(ctx, params, reqEditors...)
}
if rf, ok := ret.Get(0).(func(context.Context, *queryapi.LoginCallbackParams, ...queryapi.RequestEditorFn) *http.Response); ok {
r0 = rf(ctx, params, reqEditors...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*http.Response)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *queryapi.LoginCallbackParams, ...queryapi.RequestEditorFn) error); ok {
r1 = rf(ctx, params, reqEditors...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockClientInterface_LoginCallback_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoginCallback'
type MockClientInterface_LoginCallback_Call struct {
*mock.Call
}
// LoginCallback is a helper method to define mock.On call
// - ctx context.Context
// - params *queryapi.LoginCallbackParams
// - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) LoginCallback(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClientInterface_LoginCallback_Call {
return &MockClientInterface_LoginCallback_Call{Call: _e.mock.On("LoginCallback",
append([]interface{}{ctx, params}, reqEditors...)...)}
}
func (_c *MockClientInterface_LoginCallback_Call) Run(run func(ctx context.Context, params *queryapi.LoginCallbackParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_LoginCallback_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.LoginCallbackParams), variadicArgs...)
})
return _c
}
func (_c *MockClientInterface_LoginCallback_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_LoginCallback_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockClientInterface_LoginCallback_Call) RunAndReturn(run func(context.Context, *queryapi.LoginCallbackParams, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_LoginCallback_Call {
_c.Call.Return(run)
return _c
}
// Logout provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientInterface) Logout(ctx context.Context, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
for _i := range reqEditors {
_va[_i] = reqEditors[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for Logout")
}
var r0 *http.Response
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) (*http.Response, error)); ok {
return rf(ctx, reqEditors...)
}
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) *http.Response); ok {
r0 = rf(ctx, reqEditors...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*http.Response)
}
}
if rf, ok := ret.Get(1).(func(context.Context, ...queryapi.RequestEditorFn) error); ok {
r1 = rf(ctx, reqEditors...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockClientInterface_Logout_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Logout'
type MockClientInterface_Logout_Call struct {
*mock.Call
}
// Logout is a helper method to define mock.On call
// - ctx context.Context
// - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientInterface_Expecter) Logout(ctx interface{}, reqEditors ...interface{}) *MockClientInterface_Logout_Call {
return &MockClientInterface_Logout_Call{Call: _e.mock.On("Logout",
append([]interface{}{ctx}, reqEditors...)...)}
}
func (_c *MockClientInterface_Logout_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientInterface_Logout_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-1)
for i, a := range args[1:] {
if a != nil {
variadicArgs[i] = a.(queryapi.RequestEditorFn)
}
}
run(args[0].(context.Context), variadicArgs...)
})
return _c
}
func (_c *MockClientInterface_Logout_Call) Return(_a0 *http.Response, _a1 error) *MockClientInterface_Logout_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockClientInterface_Logout_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*http.Response, error)) *MockClientInterface_Logout_Call {
_c.Call.Return(run)
return _c
}
// SetCollectorByClientId provides a mock function with given fields: ctx, id, body, reqEditors
func (_m *MockClientInterface) SetCollectorByClientId(ctx context.Context, id string, body queryapi.CollectorSet, reqEditors ...queryapi.RequestEditorFn) (*http.Response, error) {
_va := make([]interface{}, len(reqEditors))
mocks/queryapi/mock_ClientWithResponsesInterface.go
+293
View File
@@ -620,6 +620,79 @@ func (_c *MockClientWithResponsesInterface_GetDocumentWithResponse_Call) RunAndR
return _c
}
// GetHomePageWithResponse provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientWithResponsesInterface) GetHomePageWithResponse(ctx context.Context, reqEditors ...queryapi.RequestEditorFn) (*queryapi.GetHomePageResponse, error) {
_va := make([]interface{}, len(reqEditors))
for _i := range reqEditors {
_va[_i] = reqEditors[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for GetHomePageWithResponse")
}
var r0 *queryapi.GetHomePageResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) (*queryapi.GetHomePageResponse, error)); ok {
return rf(ctx, reqEditors...)
}
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) *queryapi.GetHomePageResponse); ok {
r0 = rf(ctx, reqEditors...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*queryapi.GetHomePageResponse)
}
}
if rf, ok := ret.Get(1).(func(context.Context, ...queryapi.RequestEditorFn) error); ok {
r1 = rf(ctx, reqEditors...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockClientWithResponsesInterface_GetHomePageWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetHomePageWithResponse'
type MockClientWithResponsesInterface_GetHomePageWithResponse_Call struct {
*mock.Call
}
// GetHomePageWithResponse is a helper method to define mock.On call
// - ctx context.Context
// - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) GetHomePageWithResponse(ctx interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_GetHomePageWithResponse_Call {
return &MockClientWithResponsesInterface_GetHomePageWithResponse_Call{Call: _e.mock.On("GetHomePageWithResponse",
append([]interface{}{ctx}, reqEditors...)...)}
}
func (_c *MockClientWithResponsesInterface_GetHomePageWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_GetHomePageWithResponse_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-1)
for i, a := range args[1:] {
if a != nil {
variadicArgs[i] = a.(queryapi.RequestEditorFn)
}
}
run(args[0].(context.Context), variadicArgs...)
})
return _c
}
func (_c *MockClientWithResponsesInterface_GetHomePageWithResponse_Call) Return(_a0 *queryapi.GetHomePageResponse, _a1 error) *MockClientWithResponsesInterface_GetHomePageWithResponse_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockClientWithResponsesInterface_GetHomePageWithResponse_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*queryapi.GetHomePageResponse, error)) *MockClientWithResponsesInterface_GetHomePageWithResponse_Call {
_c.Call.Return(run)
return _c
}
// GetQueryWithResponse provides a mock function with given fields: ctx, id, reqEditors
func (_m *MockClientWithResponsesInterface) GetQueryWithResponse(ctx context.Context, id uuid.UUID, reqEditors ...queryapi.RequestEditorFn) (*queryapi.GetQueryResponse, error) {
_va := make([]interface{}, len(reqEditors))
@@ -915,6 +988,226 @@ func (_c *MockClientWithResponsesInterface_ListQueriesWithResponse_Call) RunAndR
return _c
}
// LoginCallbackWithResponse provides a mock function with given fields: ctx, params, reqEditors
func (_m *MockClientWithResponsesInterface) LoginCallbackWithResponse(ctx context.Context, params *queryapi.LoginCallbackParams, reqEditors ...queryapi.RequestEditorFn) (*queryapi.LoginCallbackResponse, 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 LoginCallbackWithResponse")
}
var r0 *queryapi.LoginCallbackResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, *queryapi.LoginCallbackParams, ...queryapi.RequestEditorFn) (*queryapi.LoginCallbackResponse, error)); ok {
return rf(ctx, params, reqEditors...)
}
if rf, ok := ret.Get(0).(func(context.Context, *queryapi.LoginCallbackParams, ...queryapi.RequestEditorFn) *queryapi.LoginCallbackResponse); ok {
r0 = rf(ctx, params, reqEditors...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*queryapi.LoginCallbackResponse)
}
}
if rf, ok := ret.Get(1).(func(context.Context, *queryapi.LoginCallbackParams, ...queryapi.RequestEditorFn) error); ok {
r1 = rf(ctx, params, reqEditors...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockClientWithResponsesInterface_LoginCallbackWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoginCallbackWithResponse'
type MockClientWithResponsesInterface_LoginCallbackWithResponse_Call struct {
*mock.Call
}
// LoginCallbackWithResponse is a helper method to define mock.On call
// - ctx context.Context
// - params *queryapi.LoginCallbackParams
// - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) LoginCallbackWithResponse(ctx interface{}, params interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_LoginCallbackWithResponse_Call {
return &MockClientWithResponsesInterface_LoginCallbackWithResponse_Call{Call: _e.mock.On("LoginCallbackWithResponse",
append([]interface{}{ctx, params}, reqEditors...)...)}
}
func (_c *MockClientWithResponsesInterface_LoginCallbackWithResponse_Call) Run(run func(ctx context.Context, params *queryapi.LoginCallbackParams, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_LoginCallbackWithResponse_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.LoginCallbackParams), variadicArgs...)
})
return _c
}
func (_c *MockClientWithResponsesInterface_LoginCallbackWithResponse_Call) Return(_a0 *queryapi.LoginCallbackResponse, _a1 error) *MockClientWithResponsesInterface_LoginCallbackWithResponse_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockClientWithResponsesInterface_LoginCallbackWithResponse_Call) RunAndReturn(run func(context.Context, *queryapi.LoginCallbackParams, ...queryapi.RequestEditorFn) (*queryapi.LoginCallbackResponse, error)) *MockClientWithResponsesInterface_LoginCallbackWithResponse_Call {
_c.Call.Return(run)
return _c
}
// LoginWithResponse provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientWithResponsesInterface) LoginWithResponse(ctx context.Context, reqEditors ...queryapi.RequestEditorFn) (*queryapi.LoginResponse, error) {
_va := make([]interface{}, len(reqEditors))
for _i := range reqEditors {
_va[_i] = reqEditors[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for LoginWithResponse")
}
var r0 *queryapi.LoginResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) (*queryapi.LoginResponse, error)); ok {
return rf(ctx, reqEditors...)
}
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) *queryapi.LoginResponse); ok {
r0 = rf(ctx, reqEditors...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*queryapi.LoginResponse)
}
}
if rf, ok := ret.Get(1).(func(context.Context, ...queryapi.RequestEditorFn) error); ok {
r1 = rf(ctx, reqEditors...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockClientWithResponsesInterface_LoginWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoginWithResponse'
type MockClientWithResponsesInterface_LoginWithResponse_Call struct {
*mock.Call
}
// LoginWithResponse is a helper method to define mock.On call
// - ctx context.Context
// - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) LoginWithResponse(ctx interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_LoginWithResponse_Call {
return &MockClientWithResponsesInterface_LoginWithResponse_Call{Call: _e.mock.On("LoginWithResponse",
append([]interface{}{ctx}, reqEditors...)...)}
}
func (_c *MockClientWithResponsesInterface_LoginWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_LoginWithResponse_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-1)
for i, a := range args[1:] {
if a != nil {
variadicArgs[i] = a.(queryapi.RequestEditorFn)
}
}
run(args[0].(context.Context), variadicArgs...)
})
return _c
}
func (_c *MockClientWithResponsesInterface_LoginWithResponse_Call) Return(_a0 *queryapi.LoginResponse, _a1 error) *MockClientWithResponsesInterface_LoginWithResponse_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockClientWithResponsesInterface_LoginWithResponse_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*queryapi.LoginResponse, error)) *MockClientWithResponsesInterface_LoginWithResponse_Call {
_c.Call.Return(run)
return _c
}
// LogoutWithResponse provides a mock function with given fields: ctx, reqEditors
func (_m *MockClientWithResponsesInterface) LogoutWithResponse(ctx context.Context, reqEditors ...queryapi.RequestEditorFn) (*queryapi.LogoutResponse, error) {
_va := make([]interface{}, len(reqEditors))
for _i := range reqEditors {
_va[_i] = reqEditors[_i]
}
var _ca []interface{}
_ca = append(_ca, ctx)
_ca = append(_ca, _va...)
ret := _m.Called(_ca...)
if len(ret) == 0 {
panic("no return value specified for LogoutWithResponse")
}
var r0 *queryapi.LogoutResponse
var r1 error
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) (*queryapi.LogoutResponse, error)); ok {
return rf(ctx, reqEditors...)
}
if rf, ok := ret.Get(0).(func(context.Context, ...queryapi.RequestEditorFn) *queryapi.LogoutResponse); ok {
r0 = rf(ctx, reqEditors...)
} else {
if ret.Get(0) != nil {
r0 = ret.Get(0).(*queryapi.LogoutResponse)
}
}
if rf, ok := ret.Get(1).(func(context.Context, ...queryapi.RequestEditorFn) error); ok {
r1 = rf(ctx, reqEditors...)
} else {
r1 = ret.Error(1)
}
return r0, r1
}
// MockClientWithResponsesInterface_LogoutWithResponse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LogoutWithResponse'
type MockClientWithResponsesInterface_LogoutWithResponse_Call struct {
*mock.Call
}
// LogoutWithResponse is a helper method to define mock.On call
// - ctx context.Context
// - reqEditors ...queryapi.RequestEditorFn
func (_e *MockClientWithResponsesInterface_Expecter) LogoutWithResponse(ctx interface{}, reqEditors ...interface{}) *MockClientWithResponsesInterface_LogoutWithResponse_Call {
return &MockClientWithResponsesInterface_LogoutWithResponse_Call{Call: _e.mock.On("LogoutWithResponse",
append([]interface{}{ctx}, reqEditors...)...)}
}
func (_c *MockClientWithResponsesInterface_LogoutWithResponse_Call) Run(run func(ctx context.Context, reqEditors ...queryapi.RequestEditorFn)) *MockClientWithResponsesInterface_LogoutWithResponse_Call {
_c.Call.Run(func(args mock.Arguments) {
variadicArgs := make([]queryapi.RequestEditorFn, len(args)-1)
for i, a := range args[1:] {
if a != nil {
variadicArgs[i] = a.(queryapi.RequestEditorFn)
}
}
run(args[0].(context.Context), variadicArgs...)
})
return _c
}
func (_c *MockClientWithResponsesInterface_LogoutWithResponse_Call) Return(_a0 *queryapi.LogoutResponse, _a1 error) *MockClientWithResponsesInterface_LogoutWithResponse_Call {
_c.Call.Return(_a0, _a1)
return _c
}
func (_c *MockClientWithResponsesInterface_LogoutWithResponse_Call) RunAndReturn(run func(context.Context, ...queryapi.RequestEditorFn) (*queryapi.LogoutResponse, error)) *MockClientWithResponsesInterface_LogoutWithResponse_Call {
_c.Call.Return(run)
return _c
}
// SetCollectorByClientIdWithBodyWithResponse provides a mock function with given fields: ctx, id, contentType, body, reqEditors
func (_m *MockClientWithResponsesInterface) SetCollectorByClientIdWithBodyWithResponse(ctx context.Context, id string, contentType string, body io.Reader, reqEditors ...queryapi.RequestEditorFn) (*queryapi.SetCollectorByClientIdResponse, error) {
_va := make([]interface{}, len(reqEditors))