mirror of
https://github.com/owncloud/ocis
synced 2026-04-25 17:25:21 +02:00
da5e63dfe3
feat: bump mockery to v2.53.5 feat: bump govulncheck feat: bump bingo to v0.10.0 force go-1.25.7 update thumbnail images for test bump reva to latest
1412 lines
51 KiB
Go
1412 lines
51 KiB
Go
// Code generated by mockery v2.53.5. DO NOT EDIT.
|
|
|
|
package mocks
|
|
|
|
import (
|
|
context "context"
|
|
|
|
libregraph "github.com/owncloud/libre-graph-api-go"
|
|
|
|
mock "github.com/stretchr/testify/mock"
|
|
)
|
|
|
|
// EducationBackend is an autogenerated mock type for the EducationBackend type
|
|
type EducationBackend struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type EducationBackend_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *EducationBackend) EXPECT() *EducationBackend_Expecter {
|
|
return &EducationBackend_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// AddClassesToEducationSchool provides a mock function with given fields: ctx, schoolNumberOrID, memberIDs
|
|
func (_m *EducationBackend) AddClassesToEducationSchool(ctx context.Context, schoolNumberOrID string, memberIDs []string) error {
|
|
ret := _m.Called(ctx, schoolNumberOrID, memberIDs)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AddClassesToEducationSchool")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, []string) error); ok {
|
|
r0 = rf(ctx, schoolNumberOrID, memberIDs)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// EducationBackend_AddClassesToEducationSchool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddClassesToEducationSchool'
|
|
type EducationBackend_AddClassesToEducationSchool_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AddClassesToEducationSchool is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - schoolNumberOrID string
|
|
// - memberIDs []string
|
|
func (_e *EducationBackend_Expecter) AddClassesToEducationSchool(ctx interface{}, schoolNumberOrID interface{}, memberIDs interface{}) *EducationBackend_AddClassesToEducationSchool_Call {
|
|
return &EducationBackend_AddClassesToEducationSchool_Call{Call: _e.mock.On("AddClassesToEducationSchool", ctx, schoolNumberOrID, memberIDs)}
|
|
}
|
|
|
|
func (_c *EducationBackend_AddClassesToEducationSchool_Call) Run(run func(ctx context.Context, schoolNumberOrID string, memberIDs []string)) *EducationBackend_AddClassesToEducationSchool_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].([]string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_AddClassesToEducationSchool_Call) Return(_a0 error) *EducationBackend_AddClassesToEducationSchool_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_AddClassesToEducationSchool_Call) RunAndReturn(run func(context.Context, string, []string) error) *EducationBackend_AddClassesToEducationSchool_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// AddTeacherToEducationClass provides a mock function with given fields: ctx, classID, teacherID
|
|
func (_m *EducationBackend) AddTeacherToEducationClass(ctx context.Context, classID string, teacherID string) error {
|
|
ret := _m.Called(ctx, classID, teacherID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AddTeacherToEducationClass")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
|
|
r0 = rf(ctx, classID, teacherID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// EducationBackend_AddTeacherToEducationClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTeacherToEducationClass'
|
|
type EducationBackend_AddTeacherToEducationClass_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AddTeacherToEducationClass is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - classID string
|
|
// - teacherID string
|
|
func (_e *EducationBackend_Expecter) AddTeacherToEducationClass(ctx interface{}, classID interface{}, teacherID interface{}) *EducationBackend_AddTeacherToEducationClass_Call {
|
|
return &EducationBackend_AddTeacherToEducationClass_Call{Call: _e.mock.On("AddTeacherToEducationClass", ctx, classID, teacherID)}
|
|
}
|
|
|
|
func (_c *EducationBackend_AddTeacherToEducationClass_Call) Run(run func(ctx context.Context, classID string, teacherID string)) *EducationBackend_AddTeacherToEducationClass_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_AddTeacherToEducationClass_Call) Return(_a0 error) *EducationBackend_AddTeacherToEducationClass_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_AddTeacherToEducationClass_Call) RunAndReturn(run func(context.Context, string, string) error) *EducationBackend_AddTeacherToEducationClass_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// AddUsersToEducationSchool provides a mock function with given fields: ctx, schoolID, memberID
|
|
func (_m *EducationBackend) AddUsersToEducationSchool(ctx context.Context, schoolID string, memberID []string) error {
|
|
ret := _m.Called(ctx, schoolID, memberID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AddUsersToEducationSchool")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, []string) error); ok {
|
|
r0 = rf(ctx, schoolID, memberID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// EducationBackend_AddUsersToEducationSchool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUsersToEducationSchool'
|
|
type EducationBackend_AddUsersToEducationSchool_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AddUsersToEducationSchool is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - schoolID string
|
|
// - memberID []string
|
|
func (_e *EducationBackend_Expecter) AddUsersToEducationSchool(ctx interface{}, schoolID interface{}, memberID interface{}) *EducationBackend_AddUsersToEducationSchool_Call {
|
|
return &EducationBackend_AddUsersToEducationSchool_Call{Call: _e.mock.On("AddUsersToEducationSchool", ctx, schoolID, memberID)}
|
|
}
|
|
|
|
func (_c *EducationBackend_AddUsersToEducationSchool_Call) Run(run func(ctx context.Context, schoolID string, memberID []string)) *EducationBackend_AddUsersToEducationSchool_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].([]string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_AddUsersToEducationSchool_Call) Return(_a0 error) *EducationBackend_AddUsersToEducationSchool_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_AddUsersToEducationSchool_Call) RunAndReturn(run func(context.Context, string, []string) error) *EducationBackend_AddUsersToEducationSchool_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateEducationClass provides a mock function with given fields: ctx, class
|
|
func (_m *EducationBackend) CreateEducationClass(ctx context.Context, class libregraph.EducationClass) (*libregraph.EducationClass, error) {
|
|
ret := _m.Called(ctx, class)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateEducationClass")
|
|
}
|
|
|
|
var r0 *libregraph.EducationClass
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, libregraph.EducationClass) (*libregraph.EducationClass, error)); ok {
|
|
return rf(ctx, class)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, libregraph.EducationClass) *libregraph.EducationClass); ok {
|
|
r0 = rf(ctx, class)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*libregraph.EducationClass)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, libregraph.EducationClass) error); ok {
|
|
r1 = rf(ctx, class)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_CreateEducationClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateEducationClass'
|
|
type EducationBackend_CreateEducationClass_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateEducationClass is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - class libregraph.EducationClass
|
|
func (_e *EducationBackend_Expecter) CreateEducationClass(ctx interface{}, class interface{}) *EducationBackend_CreateEducationClass_Call {
|
|
return &EducationBackend_CreateEducationClass_Call{Call: _e.mock.On("CreateEducationClass", ctx, class)}
|
|
}
|
|
|
|
func (_c *EducationBackend_CreateEducationClass_Call) Run(run func(ctx context.Context, class libregraph.EducationClass)) *EducationBackend_CreateEducationClass_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(libregraph.EducationClass))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_CreateEducationClass_Call) Return(_a0 *libregraph.EducationClass, _a1 error) *EducationBackend_CreateEducationClass_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_CreateEducationClass_Call) RunAndReturn(run func(context.Context, libregraph.EducationClass) (*libregraph.EducationClass, error)) *EducationBackend_CreateEducationClass_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateEducationSchool provides a mock function with given fields: ctx, group
|
|
func (_m *EducationBackend) CreateEducationSchool(ctx context.Context, group libregraph.EducationSchool) (*libregraph.EducationSchool, error) {
|
|
ret := _m.Called(ctx, group)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateEducationSchool")
|
|
}
|
|
|
|
var r0 *libregraph.EducationSchool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, libregraph.EducationSchool) (*libregraph.EducationSchool, error)); ok {
|
|
return rf(ctx, group)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, libregraph.EducationSchool) *libregraph.EducationSchool); ok {
|
|
r0 = rf(ctx, group)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*libregraph.EducationSchool)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, libregraph.EducationSchool) error); ok {
|
|
r1 = rf(ctx, group)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_CreateEducationSchool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateEducationSchool'
|
|
type EducationBackend_CreateEducationSchool_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateEducationSchool is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - group libregraph.EducationSchool
|
|
func (_e *EducationBackend_Expecter) CreateEducationSchool(ctx interface{}, group interface{}) *EducationBackend_CreateEducationSchool_Call {
|
|
return &EducationBackend_CreateEducationSchool_Call{Call: _e.mock.On("CreateEducationSchool", ctx, group)}
|
|
}
|
|
|
|
func (_c *EducationBackend_CreateEducationSchool_Call) Run(run func(ctx context.Context, group libregraph.EducationSchool)) *EducationBackend_CreateEducationSchool_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(libregraph.EducationSchool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_CreateEducationSchool_Call) Return(_a0 *libregraph.EducationSchool, _a1 error) *EducationBackend_CreateEducationSchool_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_CreateEducationSchool_Call) RunAndReturn(run func(context.Context, libregraph.EducationSchool) (*libregraph.EducationSchool, error)) *EducationBackend_CreateEducationSchool_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateEducationUser provides a mock function with given fields: ctx, user
|
|
func (_m *EducationBackend) CreateEducationUser(ctx context.Context, user libregraph.EducationUser) (*libregraph.EducationUser, error) {
|
|
ret := _m.Called(ctx, user)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateEducationUser")
|
|
}
|
|
|
|
var r0 *libregraph.EducationUser
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, libregraph.EducationUser) (*libregraph.EducationUser, error)); ok {
|
|
return rf(ctx, user)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, libregraph.EducationUser) *libregraph.EducationUser); ok {
|
|
r0 = rf(ctx, user)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*libregraph.EducationUser)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, libregraph.EducationUser) error); ok {
|
|
r1 = rf(ctx, user)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_CreateEducationUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateEducationUser'
|
|
type EducationBackend_CreateEducationUser_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateEducationUser is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - user libregraph.EducationUser
|
|
func (_e *EducationBackend_Expecter) CreateEducationUser(ctx interface{}, user interface{}) *EducationBackend_CreateEducationUser_Call {
|
|
return &EducationBackend_CreateEducationUser_Call{Call: _e.mock.On("CreateEducationUser", ctx, user)}
|
|
}
|
|
|
|
func (_c *EducationBackend_CreateEducationUser_Call) Run(run func(ctx context.Context, user libregraph.EducationUser)) *EducationBackend_CreateEducationUser_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(libregraph.EducationUser))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_CreateEducationUser_Call) Return(_a0 *libregraph.EducationUser, _a1 error) *EducationBackend_CreateEducationUser_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_CreateEducationUser_Call) RunAndReturn(run func(context.Context, libregraph.EducationUser) (*libregraph.EducationUser, error)) *EducationBackend_CreateEducationUser_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteEducationClass provides a mock function with given fields: ctx, nameOrID
|
|
func (_m *EducationBackend) DeleteEducationClass(ctx context.Context, nameOrID string) error {
|
|
ret := _m.Called(ctx, nameOrID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteEducationClass")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, nameOrID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// EducationBackend_DeleteEducationClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteEducationClass'
|
|
type EducationBackend_DeleteEducationClass_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteEducationClass is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - nameOrID string
|
|
func (_e *EducationBackend_Expecter) DeleteEducationClass(ctx interface{}, nameOrID interface{}) *EducationBackend_DeleteEducationClass_Call {
|
|
return &EducationBackend_DeleteEducationClass_Call{Call: _e.mock.On("DeleteEducationClass", ctx, nameOrID)}
|
|
}
|
|
|
|
func (_c *EducationBackend_DeleteEducationClass_Call) Run(run func(ctx context.Context, nameOrID string)) *EducationBackend_DeleteEducationClass_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_DeleteEducationClass_Call) Return(_a0 error) *EducationBackend_DeleteEducationClass_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_DeleteEducationClass_Call) RunAndReturn(run func(context.Context, string) error) *EducationBackend_DeleteEducationClass_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteEducationSchool provides a mock function with given fields: ctx, id
|
|
func (_m *EducationBackend) DeleteEducationSchool(ctx context.Context, id string) error {
|
|
ret := _m.Called(ctx, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteEducationSchool")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, id)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// EducationBackend_DeleteEducationSchool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteEducationSchool'
|
|
type EducationBackend_DeleteEducationSchool_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteEducationSchool is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - id string
|
|
func (_e *EducationBackend_Expecter) DeleteEducationSchool(ctx interface{}, id interface{}) *EducationBackend_DeleteEducationSchool_Call {
|
|
return &EducationBackend_DeleteEducationSchool_Call{Call: _e.mock.On("DeleteEducationSchool", ctx, id)}
|
|
}
|
|
|
|
func (_c *EducationBackend_DeleteEducationSchool_Call) Run(run func(ctx context.Context, id string)) *EducationBackend_DeleteEducationSchool_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_DeleteEducationSchool_Call) Return(_a0 error) *EducationBackend_DeleteEducationSchool_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_DeleteEducationSchool_Call) RunAndReturn(run func(context.Context, string) error) *EducationBackend_DeleteEducationSchool_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteEducationUser provides a mock function with given fields: ctx, nameOrID
|
|
func (_m *EducationBackend) DeleteEducationUser(ctx context.Context, nameOrID string) error {
|
|
ret := _m.Called(ctx, nameOrID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteEducationUser")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, nameOrID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// EducationBackend_DeleteEducationUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteEducationUser'
|
|
type EducationBackend_DeleteEducationUser_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteEducationUser is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - nameOrID string
|
|
func (_e *EducationBackend_Expecter) DeleteEducationUser(ctx interface{}, nameOrID interface{}) *EducationBackend_DeleteEducationUser_Call {
|
|
return &EducationBackend_DeleteEducationUser_Call{Call: _e.mock.On("DeleteEducationUser", ctx, nameOrID)}
|
|
}
|
|
|
|
func (_c *EducationBackend_DeleteEducationUser_Call) Run(run func(ctx context.Context, nameOrID string)) *EducationBackend_DeleteEducationUser_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_DeleteEducationUser_Call) Return(_a0 error) *EducationBackend_DeleteEducationUser_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_DeleteEducationUser_Call) RunAndReturn(run func(context.Context, string) error) *EducationBackend_DeleteEducationUser_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetEducationClass provides a mock function with given fields: ctx, namedOrID
|
|
func (_m *EducationBackend) GetEducationClass(ctx context.Context, namedOrID string) (*libregraph.EducationClass, error) {
|
|
ret := _m.Called(ctx, namedOrID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEducationClass")
|
|
}
|
|
|
|
var r0 *libregraph.EducationClass
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (*libregraph.EducationClass, error)); ok {
|
|
return rf(ctx, namedOrID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) *libregraph.EducationClass); ok {
|
|
r0 = rf(ctx, namedOrID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*libregraph.EducationClass)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, namedOrID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_GetEducationClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEducationClass'
|
|
type EducationBackend_GetEducationClass_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetEducationClass is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - namedOrID string
|
|
func (_e *EducationBackend_Expecter) GetEducationClass(ctx interface{}, namedOrID interface{}) *EducationBackend_GetEducationClass_Call {
|
|
return &EducationBackend_GetEducationClass_Call{Call: _e.mock.On("GetEducationClass", ctx, namedOrID)}
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationClass_Call) Run(run func(ctx context.Context, namedOrID string)) *EducationBackend_GetEducationClass_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationClass_Call) Return(_a0 *libregraph.EducationClass, _a1 error) *EducationBackend_GetEducationClass_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationClass_Call) RunAndReturn(run func(context.Context, string) (*libregraph.EducationClass, error)) *EducationBackend_GetEducationClass_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetEducationClassMembers provides a mock function with given fields: ctx, nameOrID
|
|
func (_m *EducationBackend) GetEducationClassMembers(ctx context.Context, nameOrID string) ([]*libregraph.EducationUser, error) {
|
|
ret := _m.Called(ctx, nameOrID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEducationClassMembers")
|
|
}
|
|
|
|
var r0 []*libregraph.EducationUser
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) ([]*libregraph.EducationUser, error)); ok {
|
|
return rf(ctx, nameOrID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) []*libregraph.EducationUser); ok {
|
|
r0 = rf(ctx, nameOrID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*libregraph.EducationUser)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, nameOrID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_GetEducationClassMembers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEducationClassMembers'
|
|
type EducationBackend_GetEducationClassMembers_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetEducationClassMembers is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - nameOrID string
|
|
func (_e *EducationBackend_Expecter) GetEducationClassMembers(ctx interface{}, nameOrID interface{}) *EducationBackend_GetEducationClassMembers_Call {
|
|
return &EducationBackend_GetEducationClassMembers_Call{Call: _e.mock.On("GetEducationClassMembers", ctx, nameOrID)}
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationClassMembers_Call) Run(run func(ctx context.Context, nameOrID string)) *EducationBackend_GetEducationClassMembers_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationClassMembers_Call) Return(_a0 []*libregraph.EducationUser, _a1 error) *EducationBackend_GetEducationClassMembers_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationClassMembers_Call) RunAndReturn(run func(context.Context, string) ([]*libregraph.EducationUser, error)) *EducationBackend_GetEducationClassMembers_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetEducationClassTeachers provides a mock function with given fields: ctx, classID
|
|
func (_m *EducationBackend) GetEducationClassTeachers(ctx context.Context, classID string) ([]*libregraph.EducationUser, error) {
|
|
ret := _m.Called(ctx, classID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEducationClassTeachers")
|
|
}
|
|
|
|
var r0 []*libregraph.EducationUser
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) ([]*libregraph.EducationUser, error)); ok {
|
|
return rf(ctx, classID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) []*libregraph.EducationUser); ok {
|
|
r0 = rf(ctx, classID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*libregraph.EducationUser)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, classID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_GetEducationClassTeachers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEducationClassTeachers'
|
|
type EducationBackend_GetEducationClassTeachers_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetEducationClassTeachers is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - classID string
|
|
func (_e *EducationBackend_Expecter) GetEducationClassTeachers(ctx interface{}, classID interface{}) *EducationBackend_GetEducationClassTeachers_Call {
|
|
return &EducationBackend_GetEducationClassTeachers_Call{Call: _e.mock.On("GetEducationClassTeachers", ctx, classID)}
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationClassTeachers_Call) Run(run func(ctx context.Context, classID string)) *EducationBackend_GetEducationClassTeachers_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationClassTeachers_Call) Return(_a0 []*libregraph.EducationUser, _a1 error) *EducationBackend_GetEducationClassTeachers_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationClassTeachers_Call) RunAndReturn(run func(context.Context, string) ([]*libregraph.EducationUser, error)) *EducationBackend_GetEducationClassTeachers_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetEducationClasses provides a mock function with given fields: ctx
|
|
func (_m *EducationBackend) GetEducationClasses(ctx context.Context) ([]*libregraph.EducationClass, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEducationClasses")
|
|
}
|
|
|
|
var r0 []*libregraph.EducationClass
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]*libregraph.EducationClass, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []*libregraph.EducationClass); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*libregraph.EducationClass)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_GetEducationClasses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEducationClasses'
|
|
type EducationBackend_GetEducationClasses_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetEducationClasses is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *EducationBackend_Expecter) GetEducationClasses(ctx interface{}) *EducationBackend_GetEducationClasses_Call {
|
|
return &EducationBackend_GetEducationClasses_Call{Call: _e.mock.On("GetEducationClasses", ctx)}
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationClasses_Call) Run(run func(ctx context.Context)) *EducationBackend_GetEducationClasses_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationClasses_Call) Return(_a0 []*libregraph.EducationClass, _a1 error) *EducationBackend_GetEducationClasses_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationClasses_Call) RunAndReturn(run func(context.Context) ([]*libregraph.EducationClass, error)) *EducationBackend_GetEducationClasses_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetEducationSchool provides a mock function with given fields: ctx, nameOrID
|
|
func (_m *EducationBackend) GetEducationSchool(ctx context.Context, nameOrID string) (*libregraph.EducationSchool, error) {
|
|
ret := _m.Called(ctx, nameOrID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEducationSchool")
|
|
}
|
|
|
|
var r0 *libregraph.EducationSchool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (*libregraph.EducationSchool, error)); ok {
|
|
return rf(ctx, nameOrID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) *libregraph.EducationSchool); ok {
|
|
r0 = rf(ctx, nameOrID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*libregraph.EducationSchool)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, nameOrID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_GetEducationSchool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEducationSchool'
|
|
type EducationBackend_GetEducationSchool_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetEducationSchool is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - nameOrID string
|
|
func (_e *EducationBackend_Expecter) GetEducationSchool(ctx interface{}, nameOrID interface{}) *EducationBackend_GetEducationSchool_Call {
|
|
return &EducationBackend_GetEducationSchool_Call{Call: _e.mock.On("GetEducationSchool", ctx, nameOrID)}
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationSchool_Call) Run(run func(ctx context.Context, nameOrID string)) *EducationBackend_GetEducationSchool_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationSchool_Call) Return(_a0 *libregraph.EducationSchool, _a1 error) *EducationBackend_GetEducationSchool_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationSchool_Call) RunAndReturn(run func(context.Context, string) (*libregraph.EducationSchool, error)) *EducationBackend_GetEducationSchool_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetEducationSchoolClasses provides a mock function with given fields: ctx, schoolNumberOrID
|
|
func (_m *EducationBackend) GetEducationSchoolClasses(ctx context.Context, schoolNumberOrID string) ([]*libregraph.EducationClass, error) {
|
|
ret := _m.Called(ctx, schoolNumberOrID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEducationSchoolClasses")
|
|
}
|
|
|
|
var r0 []*libregraph.EducationClass
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) ([]*libregraph.EducationClass, error)); ok {
|
|
return rf(ctx, schoolNumberOrID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) []*libregraph.EducationClass); ok {
|
|
r0 = rf(ctx, schoolNumberOrID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*libregraph.EducationClass)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, schoolNumberOrID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_GetEducationSchoolClasses_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEducationSchoolClasses'
|
|
type EducationBackend_GetEducationSchoolClasses_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetEducationSchoolClasses is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - schoolNumberOrID string
|
|
func (_e *EducationBackend_Expecter) GetEducationSchoolClasses(ctx interface{}, schoolNumberOrID interface{}) *EducationBackend_GetEducationSchoolClasses_Call {
|
|
return &EducationBackend_GetEducationSchoolClasses_Call{Call: _e.mock.On("GetEducationSchoolClasses", ctx, schoolNumberOrID)}
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationSchoolClasses_Call) Run(run func(ctx context.Context, schoolNumberOrID string)) *EducationBackend_GetEducationSchoolClasses_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationSchoolClasses_Call) Return(_a0 []*libregraph.EducationClass, _a1 error) *EducationBackend_GetEducationSchoolClasses_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationSchoolClasses_Call) RunAndReturn(run func(context.Context, string) ([]*libregraph.EducationClass, error)) *EducationBackend_GetEducationSchoolClasses_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetEducationSchoolUsers provides a mock function with given fields: ctx, id
|
|
func (_m *EducationBackend) GetEducationSchoolUsers(ctx context.Context, id string) ([]*libregraph.EducationUser, error) {
|
|
ret := _m.Called(ctx, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEducationSchoolUsers")
|
|
}
|
|
|
|
var r0 []*libregraph.EducationUser
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) ([]*libregraph.EducationUser, error)); ok {
|
|
return rf(ctx, id)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) []*libregraph.EducationUser); ok {
|
|
r0 = rf(ctx, id)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*libregraph.EducationUser)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, id)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_GetEducationSchoolUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEducationSchoolUsers'
|
|
type EducationBackend_GetEducationSchoolUsers_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetEducationSchoolUsers is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - id string
|
|
func (_e *EducationBackend_Expecter) GetEducationSchoolUsers(ctx interface{}, id interface{}) *EducationBackend_GetEducationSchoolUsers_Call {
|
|
return &EducationBackend_GetEducationSchoolUsers_Call{Call: _e.mock.On("GetEducationSchoolUsers", ctx, id)}
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationSchoolUsers_Call) Run(run func(ctx context.Context, id string)) *EducationBackend_GetEducationSchoolUsers_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationSchoolUsers_Call) Return(_a0 []*libregraph.EducationUser, _a1 error) *EducationBackend_GetEducationSchoolUsers_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationSchoolUsers_Call) RunAndReturn(run func(context.Context, string) ([]*libregraph.EducationUser, error)) *EducationBackend_GetEducationSchoolUsers_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetEducationSchools provides a mock function with given fields: ctx
|
|
func (_m *EducationBackend) GetEducationSchools(ctx context.Context) ([]*libregraph.EducationSchool, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEducationSchools")
|
|
}
|
|
|
|
var r0 []*libregraph.EducationSchool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]*libregraph.EducationSchool, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []*libregraph.EducationSchool); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*libregraph.EducationSchool)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_GetEducationSchools_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEducationSchools'
|
|
type EducationBackend_GetEducationSchools_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetEducationSchools is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *EducationBackend_Expecter) GetEducationSchools(ctx interface{}) *EducationBackend_GetEducationSchools_Call {
|
|
return &EducationBackend_GetEducationSchools_Call{Call: _e.mock.On("GetEducationSchools", ctx)}
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationSchools_Call) Run(run func(ctx context.Context)) *EducationBackend_GetEducationSchools_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationSchools_Call) Return(_a0 []*libregraph.EducationSchool, _a1 error) *EducationBackend_GetEducationSchools_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationSchools_Call) RunAndReturn(run func(context.Context) ([]*libregraph.EducationSchool, error)) *EducationBackend_GetEducationSchools_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetEducationUser provides a mock function with given fields: ctx, nameOrID
|
|
func (_m *EducationBackend) GetEducationUser(ctx context.Context, nameOrID string) (*libregraph.EducationUser, error) {
|
|
ret := _m.Called(ctx, nameOrID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEducationUser")
|
|
}
|
|
|
|
var r0 *libregraph.EducationUser
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (*libregraph.EducationUser, error)); ok {
|
|
return rf(ctx, nameOrID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) *libregraph.EducationUser); ok {
|
|
r0 = rf(ctx, nameOrID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*libregraph.EducationUser)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, nameOrID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_GetEducationUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEducationUser'
|
|
type EducationBackend_GetEducationUser_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetEducationUser is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - nameOrID string
|
|
func (_e *EducationBackend_Expecter) GetEducationUser(ctx interface{}, nameOrID interface{}) *EducationBackend_GetEducationUser_Call {
|
|
return &EducationBackend_GetEducationUser_Call{Call: _e.mock.On("GetEducationUser", ctx, nameOrID)}
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationUser_Call) Run(run func(ctx context.Context, nameOrID string)) *EducationBackend_GetEducationUser_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationUser_Call) Return(_a0 *libregraph.EducationUser, _a1 error) *EducationBackend_GetEducationUser_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationUser_Call) RunAndReturn(run func(context.Context, string) (*libregraph.EducationUser, error)) *EducationBackend_GetEducationUser_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetEducationUsers provides a mock function with given fields: ctx
|
|
func (_m *EducationBackend) GetEducationUsers(ctx context.Context) ([]*libregraph.EducationUser, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetEducationUsers")
|
|
}
|
|
|
|
var r0 []*libregraph.EducationUser
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]*libregraph.EducationUser, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []*libregraph.EducationUser); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]*libregraph.EducationUser)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_GetEducationUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetEducationUsers'
|
|
type EducationBackend_GetEducationUsers_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetEducationUsers is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *EducationBackend_Expecter) GetEducationUsers(ctx interface{}) *EducationBackend_GetEducationUsers_Call {
|
|
return &EducationBackend_GetEducationUsers_Call{Call: _e.mock.On("GetEducationUsers", ctx)}
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationUsers_Call) Run(run func(ctx context.Context)) *EducationBackend_GetEducationUsers_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationUsers_Call) Return(_a0 []*libregraph.EducationUser, _a1 error) *EducationBackend_GetEducationUsers_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_GetEducationUsers_Call) RunAndReturn(run func(context.Context) ([]*libregraph.EducationUser, error)) *EducationBackend_GetEducationUsers_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RemoveClassFromEducationSchool provides a mock function with given fields: ctx, schoolNumberOrID, memberID
|
|
func (_m *EducationBackend) RemoveClassFromEducationSchool(ctx context.Context, schoolNumberOrID string, memberID string) error {
|
|
ret := _m.Called(ctx, schoolNumberOrID, memberID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RemoveClassFromEducationSchool")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
|
|
r0 = rf(ctx, schoolNumberOrID, memberID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// EducationBackend_RemoveClassFromEducationSchool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveClassFromEducationSchool'
|
|
type EducationBackend_RemoveClassFromEducationSchool_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RemoveClassFromEducationSchool is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - schoolNumberOrID string
|
|
// - memberID string
|
|
func (_e *EducationBackend_Expecter) RemoveClassFromEducationSchool(ctx interface{}, schoolNumberOrID interface{}, memberID interface{}) *EducationBackend_RemoveClassFromEducationSchool_Call {
|
|
return &EducationBackend_RemoveClassFromEducationSchool_Call{Call: _e.mock.On("RemoveClassFromEducationSchool", ctx, schoolNumberOrID, memberID)}
|
|
}
|
|
|
|
func (_c *EducationBackend_RemoveClassFromEducationSchool_Call) Run(run func(ctx context.Context, schoolNumberOrID string, memberID string)) *EducationBackend_RemoveClassFromEducationSchool_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_RemoveClassFromEducationSchool_Call) Return(_a0 error) *EducationBackend_RemoveClassFromEducationSchool_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_RemoveClassFromEducationSchool_Call) RunAndReturn(run func(context.Context, string, string) error) *EducationBackend_RemoveClassFromEducationSchool_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RemoveTeacherFromEducationClass provides a mock function with given fields: ctx, classID, teacherID
|
|
func (_m *EducationBackend) RemoveTeacherFromEducationClass(ctx context.Context, classID string, teacherID string) error {
|
|
ret := _m.Called(ctx, classID, teacherID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RemoveTeacherFromEducationClass")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
|
|
r0 = rf(ctx, classID, teacherID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// EducationBackend_RemoveTeacherFromEducationClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveTeacherFromEducationClass'
|
|
type EducationBackend_RemoveTeacherFromEducationClass_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RemoveTeacherFromEducationClass is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - classID string
|
|
// - teacherID string
|
|
func (_e *EducationBackend_Expecter) RemoveTeacherFromEducationClass(ctx interface{}, classID interface{}, teacherID interface{}) *EducationBackend_RemoveTeacherFromEducationClass_Call {
|
|
return &EducationBackend_RemoveTeacherFromEducationClass_Call{Call: _e.mock.On("RemoveTeacherFromEducationClass", ctx, classID, teacherID)}
|
|
}
|
|
|
|
func (_c *EducationBackend_RemoveTeacherFromEducationClass_Call) Run(run func(ctx context.Context, classID string, teacherID string)) *EducationBackend_RemoveTeacherFromEducationClass_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_RemoveTeacherFromEducationClass_Call) Return(_a0 error) *EducationBackend_RemoveTeacherFromEducationClass_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_RemoveTeacherFromEducationClass_Call) RunAndReturn(run func(context.Context, string, string) error) *EducationBackend_RemoveTeacherFromEducationClass_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// RemoveUserFromEducationSchool provides a mock function with given fields: ctx, schoolID, memberID
|
|
func (_m *EducationBackend) RemoveUserFromEducationSchool(ctx context.Context, schoolID string, memberID string) error {
|
|
ret := _m.Called(ctx, schoolID, memberID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for RemoveUserFromEducationSchool")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
|
|
r0 = rf(ctx, schoolID, memberID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// EducationBackend_RemoveUserFromEducationSchool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveUserFromEducationSchool'
|
|
type EducationBackend_RemoveUserFromEducationSchool_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// RemoveUserFromEducationSchool is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - schoolID string
|
|
// - memberID string
|
|
func (_e *EducationBackend_Expecter) RemoveUserFromEducationSchool(ctx interface{}, schoolID interface{}, memberID interface{}) *EducationBackend_RemoveUserFromEducationSchool_Call {
|
|
return &EducationBackend_RemoveUserFromEducationSchool_Call{Call: _e.mock.On("RemoveUserFromEducationSchool", ctx, schoolID, memberID)}
|
|
}
|
|
|
|
func (_c *EducationBackend_RemoveUserFromEducationSchool_Call) Run(run func(ctx context.Context, schoolID string, memberID string)) *EducationBackend_RemoveUserFromEducationSchool_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_RemoveUserFromEducationSchool_Call) Return(_a0 error) *EducationBackend_RemoveUserFromEducationSchool_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_RemoveUserFromEducationSchool_Call) RunAndReturn(run func(context.Context, string, string) error) *EducationBackend_RemoveUserFromEducationSchool_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateEducationClass provides a mock function with given fields: ctx, id, class
|
|
func (_m *EducationBackend) UpdateEducationClass(ctx context.Context, id string, class libregraph.EducationClass) (*libregraph.EducationClass, error) {
|
|
ret := _m.Called(ctx, id, class)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateEducationClass")
|
|
}
|
|
|
|
var r0 *libregraph.EducationClass
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, libregraph.EducationClass) (*libregraph.EducationClass, error)); ok {
|
|
return rf(ctx, id, class)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, libregraph.EducationClass) *libregraph.EducationClass); ok {
|
|
r0 = rf(ctx, id, class)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*libregraph.EducationClass)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, libregraph.EducationClass) error); ok {
|
|
r1 = rf(ctx, id, class)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_UpdateEducationClass_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateEducationClass'
|
|
type EducationBackend_UpdateEducationClass_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateEducationClass is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - id string
|
|
// - class libregraph.EducationClass
|
|
func (_e *EducationBackend_Expecter) UpdateEducationClass(ctx interface{}, id interface{}, class interface{}) *EducationBackend_UpdateEducationClass_Call {
|
|
return &EducationBackend_UpdateEducationClass_Call{Call: _e.mock.On("UpdateEducationClass", ctx, id, class)}
|
|
}
|
|
|
|
func (_c *EducationBackend_UpdateEducationClass_Call) Run(run func(ctx context.Context, id string, class libregraph.EducationClass)) *EducationBackend_UpdateEducationClass_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(libregraph.EducationClass))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_UpdateEducationClass_Call) Return(_a0 *libregraph.EducationClass, _a1 error) *EducationBackend_UpdateEducationClass_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_UpdateEducationClass_Call) RunAndReturn(run func(context.Context, string, libregraph.EducationClass) (*libregraph.EducationClass, error)) *EducationBackend_UpdateEducationClass_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateEducationSchool provides a mock function with given fields: ctx, numberOrID, school
|
|
func (_m *EducationBackend) UpdateEducationSchool(ctx context.Context, numberOrID string, school libregraph.EducationSchool) (*libregraph.EducationSchool, error) {
|
|
ret := _m.Called(ctx, numberOrID, school)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateEducationSchool")
|
|
}
|
|
|
|
var r0 *libregraph.EducationSchool
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, libregraph.EducationSchool) (*libregraph.EducationSchool, error)); ok {
|
|
return rf(ctx, numberOrID, school)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, libregraph.EducationSchool) *libregraph.EducationSchool); ok {
|
|
r0 = rf(ctx, numberOrID, school)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*libregraph.EducationSchool)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, libregraph.EducationSchool) error); ok {
|
|
r1 = rf(ctx, numberOrID, school)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_UpdateEducationSchool_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateEducationSchool'
|
|
type EducationBackend_UpdateEducationSchool_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateEducationSchool is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - numberOrID string
|
|
// - school libregraph.EducationSchool
|
|
func (_e *EducationBackend_Expecter) UpdateEducationSchool(ctx interface{}, numberOrID interface{}, school interface{}) *EducationBackend_UpdateEducationSchool_Call {
|
|
return &EducationBackend_UpdateEducationSchool_Call{Call: _e.mock.On("UpdateEducationSchool", ctx, numberOrID, school)}
|
|
}
|
|
|
|
func (_c *EducationBackend_UpdateEducationSchool_Call) Run(run func(ctx context.Context, numberOrID string, school libregraph.EducationSchool)) *EducationBackend_UpdateEducationSchool_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(libregraph.EducationSchool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_UpdateEducationSchool_Call) Return(_a0 *libregraph.EducationSchool, _a1 error) *EducationBackend_UpdateEducationSchool_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_UpdateEducationSchool_Call) RunAndReturn(run func(context.Context, string, libregraph.EducationSchool) (*libregraph.EducationSchool, error)) *EducationBackend_UpdateEducationSchool_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateEducationUser provides a mock function with given fields: ctx, nameOrID, user
|
|
func (_m *EducationBackend) UpdateEducationUser(ctx context.Context, nameOrID string, user libregraph.EducationUser) (*libregraph.EducationUser, error) {
|
|
ret := _m.Called(ctx, nameOrID, user)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateEducationUser")
|
|
}
|
|
|
|
var r0 *libregraph.EducationUser
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, libregraph.EducationUser) (*libregraph.EducationUser, error)); ok {
|
|
return rf(ctx, nameOrID, user)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, libregraph.EducationUser) *libregraph.EducationUser); ok {
|
|
r0 = rf(ctx, nameOrID, user)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*libregraph.EducationUser)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string, libregraph.EducationUser) error); ok {
|
|
r1 = rf(ctx, nameOrID, user)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// EducationBackend_UpdateEducationUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateEducationUser'
|
|
type EducationBackend_UpdateEducationUser_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateEducationUser is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - nameOrID string
|
|
// - user libregraph.EducationUser
|
|
func (_e *EducationBackend_Expecter) UpdateEducationUser(ctx interface{}, nameOrID interface{}, user interface{}) *EducationBackend_UpdateEducationUser_Call {
|
|
return &EducationBackend_UpdateEducationUser_Call{Call: _e.mock.On("UpdateEducationUser", ctx, nameOrID, user)}
|
|
}
|
|
|
|
func (_c *EducationBackend_UpdateEducationUser_Call) Run(run func(ctx context.Context, nameOrID string, user libregraph.EducationUser)) *EducationBackend_UpdateEducationUser_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(libregraph.EducationUser))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_UpdateEducationUser_Call) Return(_a0 *libregraph.EducationUser, _a1 error) *EducationBackend_UpdateEducationUser_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *EducationBackend_UpdateEducationUser_Call) RunAndReturn(run func(context.Context, string, libregraph.EducationUser) (*libregraph.EducationUser, error)) *EducationBackend_UpdateEducationUser_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewEducationBackend creates a new instance of EducationBackend. 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 NewEducationBackend(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *EducationBackend {
|
|
mock := &EducationBackend{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|