1835 lines
58 KiB
Go
1835 lines
58 KiB
Go
// Code generated by mockery v2.47.0. DO NOT EDIT.
|
|
|
|
package mocks
|
|
|
|
import (
|
|
context "context"
|
|
|
|
database "dynatron.me/x/stillbox/pkg/database"
|
|
mock "github.com/stretchr/testify/mock"
|
|
|
|
pgtype "github.com/jackc/pgx/v5/pgtype"
|
|
|
|
pgx "github.com/jackc/pgx/v5"
|
|
|
|
uuid "github.com/google/uuid"
|
|
)
|
|
|
|
// Store is an autogenerated mock type for the Store type
|
|
type Store struct {
|
|
mock.Mock
|
|
}
|
|
|
|
type Store_Expecter struct {
|
|
mock *mock.Mock
|
|
}
|
|
|
|
func (_m *Store) EXPECT() *Store_Expecter {
|
|
return &Store_Expecter{mock: &_m.Mock}
|
|
}
|
|
|
|
// AddAlert provides a mock function with given fields: ctx, arg
|
|
func (_m *Store) AddAlert(ctx context.Context, arg database.AddAlertParams) error {
|
|
ret := _m.Called(ctx, arg)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AddAlert")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, database.AddAlertParams) error); ok {
|
|
r0 = rf(ctx, arg)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Store_AddAlert_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddAlert'
|
|
type Store_AddAlert_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AddAlert is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - arg database.AddAlertParams
|
|
func (_e *Store_Expecter) AddAlert(ctx interface{}, arg interface{}) *Store_AddAlert_Call {
|
|
return &Store_AddAlert_Call{Call: _e.mock.On("AddAlert", ctx, arg)}
|
|
}
|
|
|
|
func (_c *Store_AddAlert_Call) Run(run func(ctx context.Context, arg database.AddAlertParams)) *Store_AddAlert_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(database.AddAlertParams))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_AddAlert_Call) Return(_a0 error) *Store_AddAlert_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_AddAlert_Call) RunAndReturn(run func(context.Context, database.AddAlertParams) error) *Store_AddAlert_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// AddCall provides a mock function with given fields: ctx, arg
|
|
func (_m *Store) AddCall(ctx context.Context, arg database.AddCallParams) error {
|
|
ret := _m.Called(ctx, arg)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AddCall")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, database.AddCallParams) error); ok {
|
|
r0 = rf(ctx, arg)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Store_AddCall_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddCall'
|
|
type Store_AddCall_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AddCall is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - arg database.AddCallParams
|
|
func (_e *Store_Expecter) AddCall(ctx interface{}, arg interface{}) *Store_AddCall_Call {
|
|
return &Store_AddCall_Call{Call: _e.mock.On("AddCall", ctx, arg)}
|
|
}
|
|
|
|
func (_c *Store_AddCall_Call) Run(run func(ctx context.Context, arg database.AddCallParams)) *Store_AddCall_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(database.AddCallParams))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_AddCall_Call) Return(_a0 error) *Store_AddCall_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_AddCall_Call) RunAndReturn(run func(context.Context, database.AddCallParams) error) *Store_AddCall_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// AddLearnedTalkgroup provides a mock function with given fields: ctx, arg
|
|
func (_m *Store) AddLearnedTalkgroup(ctx context.Context, arg database.AddLearnedTalkgroupParams) (int, error) {
|
|
ret := _m.Called(ctx, arg)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AddLearnedTalkgroup")
|
|
}
|
|
|
|
var r0 int
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, database.AddLearnedTalkgroupParams) (int, error)); ok {
|
|
return rf(ctx, arg)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, database.AddLearnedTalkgroupParams) int); ok {
|
|
r0 = rf(ctx, arg)
|
|
} else {
|
|
r0 = ret.Get(0).(int)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, database.AddLearnedTalkgroupParams) error); ok {
|
|
r1 = rf(ctx, arg)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_AddLearnedTalkgroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddLearnedTalkgroup'
|
|
type Store_AddLearnedTalkgroup_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AddLearnedTalkgroup is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - arg database.AddLearnedTalkgroupParams
|
|
func (_e *Store_Expecter) AddLearnedTalkgroup(ctx interface{}, arg interface{}) *Store_AddLearnedTalkgroup_Call {
|
|
return &Store_AddLearnedTalkgroup_Call{Call: _e.mock.On("AddLearnedTalkgroup", ctx, arg)}
|
|
}
|
|
|
|
func (_c *Store_AddLearnedTalkgroup_Call) Run(run func(ctx context.Context, arg database.AddLearnedTalkgroupParams)) *Store_AddLearnedTalkgroup_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(database.AddLearnedTalkgroupParams))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_AddLearnedTalkgroup_Call) Return(_a0 int, _a1 error) *Store_AddLearnedTalkgroup_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_AddLearnedTalkgroup_Call) RunAndReturn(run func(context.Context, database.AddLearnedTalkgroupParams) (int, error)) *Store_AddLearnedTalkgroup_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// AddTalkgroupWithLearnedFlag provides a mock function with given fields: ctx, systemID, tGID
|
|
func (_m *Store) AddTalkgroupWithLearnedFlag(ctx context.Context, systemID int32, tGID int32) error {
|
|
ret := _m.Called(ctx, systemID, tGID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for AddTalkgroupWithLearnedFlag")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int32, int32) error); ok {
|
|
r0 = rf(ctx, systemID, tGID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Store_AddTalkgroupWithLearnedFlag_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddTalkgroupWithLearnedFlag'
|
|
type Store_AddTalkgroupWithLearnedFlag_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// AddTalkgroupWithLearnedFlag is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - systemID int32
|
|
// - tGID int32
|
|
func (_e *Store_Expecter) AddTalkgroupWithLearnedFlag(ctx interface{}, systemID interface{}, tGID interface{}) *Store_AddTalkgroupWithLearnedFlag_Call {
|
|
return &Store_AddTalkgroupWithLearnedFlag_Call{Call: _e.mock.On("AddTalkgroupWithLearnedFlag", ctx, systemID, tGID)}
|
|
}
|
|
|
|
func (_c *Store_AddTalkgroupWithLearnedFlag_Call) Run(run func(ctx context.Context, systemID int32, tGID int32)) *Store_AddTalkgroupWithLearnedFlag_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int32), args[2].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_AddTalkgroupWithLearnedFlag_Call) Return(_a0 error) *Store_AddTalkgroupWithLearnedFlag_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_AddTalkgroupWithLearnedFlag_Call) RunAndReturn(run func(context.Context, int32, int32) error) *Store_AddTalkgroupWithLearnedFlag_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// BulkSetTalkgroupTags provides a mock function with given fields: ctx, tgs, tags
|
|
func (_m *Store) BulkSetTalkgroupTags(ctx context.Context, tgs database.TGTuples, tags []string) error {
|
|
ret := _m.Called(ctx, tgs, tags)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for BulkSetTalkgroupTags")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, database.TGTuples, []string) error); ok {
|
|
r0 = rf(ctx, tgs, tags)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Store_BulkSetTalkgroupTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BulkSetTalkgroupTags'
|
|
type Store_BulkSetTalkgroupTags_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// BulkSetTalkgroupTags is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - tgs database.TGTuples
|
|
// - tags []string
|
|
func (_e *Store_Expecter) BulkSetTalkgroupTags(ctx interface{}, tgs interface{}, tags interface{}) *Store_BulkSetTalkgroupTags_Call {
|
|
return &Store_BulkSetTalkgroupTags_Call{Call: _e.mock.On("BulkSetTalkgroupTags", ctx, tgs, tags)}
|
|
}
|
|
|
|
func (_c *Store_BulkSetTalkgroupTags_Call) Run(run func(ctx context.Context, tgs database.TGTuples, tags []string)) *Store_BulkSetTalkgroupTags_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(database.TGTuples), args[2].([]string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_BulkSetTalkgroupTags_Call) Return(_a0 error) *Store_BulkSetTalkgroupTags_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_BulkSetTalkgroupTags_Call) RunAndReturn(run func(context.Context, database.TGTuples, []string) error) *Store_BulkSetTalkgroupTags_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateAPIKey provides a mock function with given fields: ctx, owner, expires, disabled
|
|
func (_m *Store) CreateAPIKey(ctx context.Context, owner int, expires pgtype.Timestamp, disabled *bool) (database.ApiKey, error) {
|
|
ret := _m.Called(ctx, owner, expires, disabled)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateAPIKey")
|
|
}
|
|
|
|
var r0 database.ApiKey
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int, pgtype.Timestamp, *bool) (database.ApiKey, error)); ok {
|
|
return rf(ctx, owner, expires, disabled)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, int, pgtype.Timestamp, *bool) database.ApiKey); ok {
|
|
r0 = rf(ctx, owner, expires, disabled)
|
|
} else {
|
|
r0 = ret.Get(0).(database.ApiKey)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, int, pgtype.Timestamp, *bool) error); ok {
|
|
r1 = rf(ctx, owner, expires, disabled)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_CreateAPIKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateAPIKey'
|
|
type Store_CreateAPIKey_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateAPIKey is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - owner int
|
|
// - expires pgtype.Timestamp
|
|
// - disabled *bool
|
|
func (_e *Store_Expecter) CreateAPIKey(ctx interface{}, owner interface{}, expires interface{}, disabled interface{}) *Store_CreateAPIKey_Call {
|
|
return &Store_CreateAPIKey_Call{Call: _e.mock.On("CreateAPIKey", ctx, owner, expires, disabled)}
|
|
}
|
|
|
|
func (_c *Store_CreateAPIKey_Call) Run(run func(ctx context.Context, owner int, expires pgtype.Timestamp, disabled *bool)) *Store_CreateAPIKey_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int), args[2].(pgtype.Timestamp), args[3].(*bool))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_CreateAPIKey_Call) Return(_a0 database.ApiKey, _a1 error) *Store_CreateAPIKey_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_CreateAPIKey_Call) RunAndReturn(run func(context.Context, int, pgtype.Timestamp, *bool) (database.ApiKey, error)) *Store_CreateAPIKey_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// CreateUser provides a mock function with given fields: ctx, arg
|
|
func (_m *Store) CreateUser(ctx context.Context, arg database.CreateUserParams) (database.User, error) {
|
|
ret := _m.Called(ctx, arg)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for CreateUser")
|
|
}
|
|
|
|
var r0 database.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, database.CreateUserParams) (database.User, error)); ok {
|
|
return rf(ctx, arg)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, database.CreateUserParams) database.User); ok {
|
|
r0 = rf(ctx, arg)
|
|
} else {
|
|
r0 = ret.Get(0).(database.User)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, database.CreateUserParams) error); ok {
|
|
r1 = rf(ctx, arg)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_CreateUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CreateUser'
|
|
type Store_CreateUser_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// CreateUser is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - arg database.CreateUserParams
|
|
func (_e *Store_Expecter) CreateUser(ctx interface{}, arg interface{}) *Store_CreateUser_Call {
|
|
return &Store_CreateUser_Call{Call: _e.mock.On("CreateUser", ctx, arg)}
|
|
}
|
|
|
|
func (_c *Store_CreateUser_Call) Run(run func(ctx context.Context, arg database.CreateUserParams)) *Store_CreateUser_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(database.CreateUserParams))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_CreateUser_Call) Return(_a0 database.User, _a1 error) *Store_CreateUser_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_CreateUser_Call) RunAndReturn(run func(context.Context, database.CreateUserParams) (database.User, error)) *Store_CreateUser_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DB provides a mock function with given fields:
|
|
func (_m *Store) DB() *database.Database {
|
|
ret := _m.Called()
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DB")
|
|
}
|
|
|
|
var r0 *database.Database
|
|
if rf, ok := ret.Get(0).(func() *database.Database); ok {
|
|
r0 = rf()
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*database.Database)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Store_DB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DB'
|
|
type Store_DB_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DB is a helper method to define mock.On call
|
|
func (_e *Store_Expecter) DB() *Store_DB_Call {
|
|
return &Store_DB_Call{Call: _e.mock.On("DB")}
|
|
}
|
|
|
|
func (_c *Store_DB_Call) Run(run func()) *Store_DB_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run()
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_DB_Call) Return(_a0 *database.Database) *Store_DB_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_DB_Call) RunAndReturn(run func() *database.Database) *Store_DB_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteAPIKey provides a mock function with given fields: ctx, apiKey
|
|
func (_m *Store) DeleteAPIKey(ctx context.Context, apiKey string) error {
|
|
ret := _m.Called(ctx, apiKey)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteAPIKey")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, apiKey)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Store_DeleteAPIKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteAPIKey'
|
|
type Store_DeleteAPIKey_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteAPIKey is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - apiKey string
|
|
func (_e *Store_Expecter) DeleteAPIKey(ctx interface{}, apiKey interface{}) *Store_DeleteAPIKey_Call {
|
|
return &Store_DeleteAPIKey_Call{Call: _e.mock.On("DeleteAPIKey", ctx, apiKey)}
|
|
}
|
|
|
|
func (_c *Store_DeleteAPIKey_Call) Run(run func(ctx context.Context, apiKey string)) *Store_DeleteAPIKey_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_DeleteAPIKey_Call) Return(_a0 error) *Store_DeleteAPIKey_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_DeleteAPIKey_Call) RunAndReturn(run func(context.Context, string) error) *Store_DeleteAPIKey_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// DeleteUser provides a mock function with given fields: ctx, username
|
|
func (_m *Store) DeleteUser(ctx context.Context, username string) error {
|
|
ret := _m.Called(ctx, username)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for DeleteUser")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) error); ok {
|
|
r0 = rf(ctx, username)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Store_DeleteUser_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeleteUser'
|
|
type Store_DeleteUser_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// DeleteUser is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - username string
|
|
func (_e *Store_Expecter) DeleteUser(ctx interface{}, username interface{}) *Store_DeleteUser_Call {
|
|
return &Store_DeleteUser_Call{Call: _e.mock.On("DeleteUser", ctx, username)}
|
|
}
|
|
|
|
func (_c *Store_DeleteUser_Call) Run(run func(ctx context.Context, username string)) *Store_DeleteUser_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_DeleteUser_Call) Return(_a0 error) *Store_DeleteUser_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_DeleteUser_Call) RunAndReturn(run func(context.Context, string) error) *Store_DeleteUser_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetAPIKey provides a mock function with given fields: ctx, apiKey
|
|
func (_m *Store) GetAPIKey(ctx context.Context, apiKey string) (database.ApiKey, error) {
|
|
ret := _m.Called(ctx, apiKey)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetAPIKey")
|
|
}
|
|
|
|
var r0 database.ApiKey
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (database.ApiKey, error)); ok {
|
|
return rf(ctx, apiKey)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) database.ApiKey); ok {
|
|
r0 = rf(ctx, apiKey)
|
|
} else {
|
|
r0 = ret.Get(0).(database.ApiKey)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, apiKey)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetAPIKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetAPIKey'
|
|
type Store_GetAPIKey_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetAPIKey is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - apiKey string
|
|
func (_e *Store_Expecter) GetAPIKey(ctx interface{}, apiKey interface{}) *Store_GetAPIKey_Call {
|
|
return &Store_GetAPIKey_Call{Call: _e.mock.On("GetAPIKey", ctx, apiKey)}
|
|
}
|
|
|
|
func (_c *Store_GetAPIKey_Call) Run(run func(ctx context.Context, apiKey string)) *Store_GetAPIKey_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetAPIKey_Call) Return(_a0 database.ApiKey, _a1 error) *Store_GetAPIKey_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetAPIKey_Call) RunAndReturn(run func(context.Context, string) (database.ApiKey, error)) *Store_GetAPIKey_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetDatabaseSize provides a mock function with given fields: ctx
|
|
func (_m *Store) GetDatabaseSize(ctx context.Context) (string, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetDatabaseSize")
|
|
}
|
|
|
|
var r0 string
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) (string, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) string); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetDatabaseSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDatabaseSize'
|
|
type Store_GetDatabaseSize_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetDatabaseSize is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *Store_Expecter) GetDatabaseSize(ctx interface{}) *Store_GetDatabaseSize_Call {
|
|
return &Store_GetDatabaseSize_Call{Call: _e.mock.On("GetDatabaseSize", ctx)}
|
|
}
|
|
|
|
func (_c *Store_GetDatabaseSize_Call) Run(run func(ctx context.Context)) *Store_GetDatabaseSize_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetDatabaseSize_Call) Return(_a0 string, _a1 error) *Store_GetDatabaseSize_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetDatabaseSize_Call) RunAndReturn(run func(context.Context) (string, error)) *Store_GetDatabaseSize_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetSystemName provides a mock function with given fields: ctx, systemID
|
|
func (_m *Store) GetSystemName(ctx context.Context, systemID int) (string, error) {
|
|
ret := _m.Called(ctx, systemID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetSystemName")
|
|
}
|
|
|
|
var r0 string
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int) (string, error)); ok {
|
|
return rf(ctx, systemID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, int) string); ok {
|
|
r0 = rf(ctx, systemID)
|
|
} else {
|
|
r0 = ret.Get(0).(string)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, int) error); ok {
|
|
r1 = rf(ctx, systemID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetSystemName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetSystemName'
|
|
type Store_GetSystemName_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetSystemName is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - systemID int
|
|
func (_e *Store_Expecter) GetSystemName(ctx interface{}, systemID interface{}) *Store_GetSystemName_Call {
|
|
return &Store_GetSystemName_Call{Call: _e.mock.On("GetSystemName", ctx, systemID)}
|
|
}
|
|
|
|
func (_c *Store_GetSystemName_Call) Run(run func(ctx context.Context, systemID int)) *Store_GetSystemName_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetSystemName_Call) Return(_a0 string, _a1 error) *Store_GetSystemName_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetSystemName_Call) RunAndReturn(run func(context.Context, int) (string, error)) *Store_GetSystemName_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetTalkgroup provides a mock function with given fields: ctx, systemID, tGID
|
|
func (_m *Store) GetTalkgroup(ctx context.Context, systemID int32, tGID int32) (database.GetTalkgroupRow, error) {
|
|
ret := _m.Called(ctx, systemID, tGID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetTalkgroup")
|
|
}
|
|
|
|
var r0 database.GetTalkgroupRow
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int32, int32) (database.GetTalkgroupRow, error)); ok {
|
|
return rf(ctx, systemID, tGID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, int32, int32) database.GetTalkgroupRow); ok {
|
|
r0 = rf(ctx, systemID, tGID)
|
|
} else {
|
|
r0 = ret.Get(0).(database.GetTalkgroupRow)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, int32, int32) error); ok {
|
|
r1 = rf(ctx, systemID, tGID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetTalkgroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTalkgroup'
|
|
type Store_GetTalkgroup_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetTalkgroup is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - systemID int32
|
|
// - tGID int32
|
|
func (_e *Store_Expecter) GetTalkgroup(ctx interface{}, systemID interface{}, tGID interface{}) *Store_GetTalkgroup_Call {
|
|
return &Store_GetTalkgroup_Call{Call: _e.mock.On("GetTalkgroup", ctx, systemID, tGID)}
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroup_Call) Run(run func(ctx context.Context, systemID int32, tGID int32)) *Store_GetTalkgroup_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int32), args[2].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroup_Call) Return(_a0 database.GetTalkgroupRow, _a1 error) *Store_GetTalkgroup_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroup_Call) RunAndReturn(run func(context.Context, int32, int32) (database.GetTalkgroupRow, error)) *Store_GetTalkgroup_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetTalkgroupIDsByTags provides a mock function with given fields: ctx, anyTags, allTags, notTags
|
|
func (_m *Store) GetTalkgroupIDsByTags(ctx context.Context, anyTags []string, allTags []string, notTags []string) ([]database.GetTalkgroupIDsByTagsRow, error) {
|
|
ret := _m.Called(ctx, anyTags, allTags, notTags)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetTalkgroupIDsByTags")
|
|
}
|
|
|
|
var r0 []database.GetTalkgroupIDsByTagsRow
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, []string, []string, []string) ([]database.GetTalkgroupIDsByTagsRow, error)); ok {
|
|
return rf(ctx, anyTags, allTags, notTags)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, []string, []string, []string) []database.GetTalkgroupIDsByTagsRow); ok {
|
|
r0 = rf(ctx, anyTags, allTags, notTags)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]database.GetTalkgroupIDsByTagsRow)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, []string, []string, []string) error); ok {
|
|
r1 = rf(ctx, anyTags, allTags, notTags)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetTalkgroupIDsByTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTalkgroupIDsByTags'
|
|
type Store_GetTalkgroupIDsByTags_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetTalkgroupIDsByTags is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - anyTags []string
|
|
// - allTags []string
|
|
// - notTags []string
|
|
func (_e *Store_Expecter) GetTalkgroupIDsByTags(ctx interface{}, anyTags interface{}, allTags interface{}, notTags interface{}) *Store_GetTalkgroupIDsByTags_Call {
|
|
return &Store_GetTalkgroupIDsByTags_Call{Call: _e.mock.On("GetTalkgroupIDsByTags", ctx, anyTags, allTags, notTags)}
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupIDsByTags_Call) Run(run func(ctx context.Context, anyTags []string, allTags []string, notTags []string)) *Store_GetTalkgroupIDsByTags_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].([]string), args[2].([]string), args[3].([]string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupIDsByTags_Call) Return(_a0 []database.GetTalkgroupIDsByTagsRow, _a1 error) *Store_GetTalkgroupIDsByTags_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupIDsByTags_Call) RunAndReturn(run func(context.Context, []string, []string, []string) ([]database.GetTalkgroupIDsByTagsRow, error)) *Store_GetTalkgroupIDsByTags_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetTalkgroupTags provides a mock function with given fields: ctx, systemID, tGID
|
|
func (_m *Store) GetTalkgroupTags(ctx context.Context, systemID int32, tGID int32) ([]string, error) {
|
|
ret := _m.Called(ctx, systemID, tGID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetTalkgroupTags")
|
|
}
|
|
|
|
var r0 []string
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int32, int32) ([]string, error)); ok {
|
|
return rf(ctx, systemID, tGID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, int32, int32) []string); ok {
|
|
r0 = rf(ctx, systemID, tGID)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]string)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, int32, int32) error); ok {
|
|
r1 = rf(ctx, systemID, tGID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetTalkgroupTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTalkgroupTags'
|
|
type Store_GetTalkgroupTags_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetTalkgroupTags is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - systemID int32
|
|
// - tGID int32
|
|
func (_e *Store_Expecter) GetTalkgroupTags(ctx interface{}, systemID interface{}, tGID interface{}) *Store_GetTalkgroupTags_Call {
|
|
return &Store_GetTalkgroupTags_Call{Call: _e.mock.On("GetTalkgroupTags", ctx, systemID, tGID)}
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupTags_Call) Run(run func(ctx context.Context, systemID int32, tGID int32)) *Store_GetTalkgroupTags_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int32), args[2].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupTags_Call) Return(_a0 []string, _a1 error) *Store_GetTalkgroupTags_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupTags_Call) RunAndReturn(run func(context.Context, int32, int32) ([]string, error)) *Store_GetTalkgroupTags_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetTalkgroupWithLearned provides a mock function with given fields: ctx, systemID, tGID
|
|
func (_m *Store) GetTalkgroupWithLearned(ctx context.Context, systemID int32, tGID int32) (database.GetTalkgroupWithLearnedRow, error) {
|
|
ret := _m.Called(ctx, systemID, tGID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetTalkgroupWithLearned")
|
|
}
|
|
|
|
var r0 database.GetTalkgroupWithLearnedRow
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int32, int32) (database.GetTalkgroupWithLearnedRow, error)); ok {
|
|
return rf(ctx, systemID, tGID)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, int32, int32) database.GetTalkgroupWithLearnedRow); ok {
|
|
r0 = rf(ctx, systemID, tGID)
|
|
} else {
|
|
r0 = ret.Get(0).(database.GetTalkgroupWithLearnedRow)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, int32, int32) error); ok {
|
|
r1 = rf(ctx, systemID, tGID)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetTalkgroupWithLearned_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTalkgroupWithLearned'
|
|
type Store_GetTalkgroupWithLearned_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetTalkgroupWithLearned is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - systemID int32
|
|
// - tGID int32
|
|
func (_e *Store_Expecter) GetTalkgroupWithLearned(ctx interface{}, systemID interface{}, tGID interface{}) *Store_GetTalkgroupWithLearned_Call {
|
|
return &Store_GetTalkgroupWithLearned_Call{Call: _e.mock.On("GetTalkgroupWithLearned", ctx, systemID, tGID)}
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupWithLearned_Call) Run(run func(ctx context.Context, systemID int32, tGID int32)) *Store_GetTalkgroupWithLearned_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int32), args[2].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupWithLearned_Call) Return(_a0 database.GetTalkgroupWithLearnedRow, _a1 error) *Store_GetTalkgroupWithLearned_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupWithLearned_Call) RunAndReturn(run func(context.Context, int32, int32) (database.GetTalkgroupWithLearnedRow, error)) *Store_GetTalkgroupWithLearned_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetTalkgroupsBySysTGID provides a mock function with given fields: ctx, ids
|
|
func (_m *Store) GetTalkgroupsBySysTGID(ctx context.Context, ids database.TGTuples) ([]database.GetTalkgroupsRow, error) {
|
|
ret := _m.Called(ctx, ids)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetTalkgroupsBySysTGID")
|
|
}
|
|
|
|
var r0 []database.GetTalkgroupsRow
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, database.TGTuples) ([]database.GetTalkgroupsRow, error)); ok {
|
|
return rf(ctx, ids)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, database.TGTuples) []database.GetTalkgroupsRow); ok {
|
|
r0 = rf(ctx, ids)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]database.GetTalkgroupsRow)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, database.TGTuples) error); ok {
|
|
r1 = rf(ctx, ids)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetTalkgroupsBySysTGID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTalkgroupsBySysTGID'
|
|
type Store_GetTalkgroupsBySysTGID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetTalkgroupsBySysTGID is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - ids database.TGTuples
|
|
func (_e *Store_Expecter) GetTalkgroupsBySysTGID(ctx interface{}, ids interface{}) *Store_GetTalkgroupsBySysTGID_Call {
|
|
return &Store_GetTalkgroupsBySysTGID_Call{Call: _e.mock.On("GetTalkgroupsBySysTGID", ctx, ids)}
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsBySysTGID_Call) Run(run func(ctx context.Context, ids database.TGTuples)) *Store_GetTalkgroupsBySysTGID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(database.TGTuples))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsBySysTGID_Call) Return(_a0 []database.GetTalkgroupsRow, _a1 error) *Store_GetTalkgroupsBySysTGID_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsBySysTGID_Call) RunAndReturn(run func(context.Context, database.TGTuples) ([]database.GetTalkgroupsRow, error)) *Store_GetTalkgroupsBySysTGID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetTalkgroupsWithAllTags provides a mock function with given fields: ctx, tags
|
|
func (_m *Store) GetTalkgroupsWithAllTags(ctx context.Context, tags []string) ([]database.GetTalkgroupsWithAllTagsRow, error) {
|
|
ret := _m.Called(ctx, tags)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetTalkgroupsWithAllTags")
|
|
}
|
|
|
|
var r0 []database.GetTalkgroupsWithAllTagsRow
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, []string) ([]database.GetTalkgroupsWithAllTagsRow, error)); ok {
|
|
return rf(ctx, tags)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, []string) []database.GetTalkgroupsWithAllTagsRow); ok {
|
|
r0 = rf(ctx, tags)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]database.GetTalkgroupsWithAllTagsRow)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, []string) error); ok {
|
|
r1 = rf(ctx, tags)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetTalkgroupsWithAllTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTalkgroupsWithAllTags'
|
|
type Store_GetTalkgroupsWithAllTags_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetTalkgroupsWithAllTags is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - tags []string
|
|
func (_e *Store_Expecter) GetTalkgroupsWithAllTags(ctx interface{}, tags interface{}) *Store_GetTalkgroupsWithAllTags_Call {
|
|
return &Store_GetTalkgroupsWithAllTags_Call{Call: _e.mock.On("GetTalkgroupsWithAllTags", ctx, tags)}
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithAllTags_Call) Run(run func(ctx context.Context, tags []string)) *Store_GetTalkgroupsWithAllTags_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].([]string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithAllTags_Call) Return(_a0 []database.GetTalkgroupsWithAllTagsRow, _a1 error) *Store_GetTalkgroupsWithAllTags_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithAllTags_Call) RunAndReturn(run func(context.Context, []string) ([]database.GetTalkgroupsWithAllTagsRow, error)) *Store_GetTalkgroupsWithAllTags_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetTalkgroupsWithAnyTags provides a mock function with given fields: ctx, tags
|
|
func (_m *Store) GetTalkgroupsWithAnyTags(ctx context.Context, tags []string) ([]database.GetTalkgroupsWithAnyTagsRow, error) {
|
|
ret := _m.Called(ctx, tags)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetTalkgroupsWithAnyTags")
|
|
}
|
|
|
|
var r0 []database.GetTalkgroupsWithAnyTagsRow
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, []string) ([]database.GetTalkgroupsWithAnyTagsRow, error)); ok {
|
|
return rf(ctx, tags)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, []string) []database.GetTalkgroupsWithAnyTagsRow); ok {
|
|
r0 = rf(ctx, tags)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]database.GetTalkgroupsWithAnyTagsRow)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, []string) error); ok {
|
|
r1 = rf(ctx, tags)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetTalkgroupsWithAnyTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTalkgroupsWithAnyTags'
|
|
type Store_GetTalkgroupsWithAnyTags_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetTalkgroupsWithAnyTags is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - tags []string
|
|
func (_e *Store_Expecter) GetTalkgroupsWithAnyTags(ctx interface{}, tags interface{}) *Store_GetTalkgroupsWithAnyTags_Call {
|
|
return &Store_GetTalkgroupsWithAnyTags_Call{Call: _e.mock.On("GetTalkgroupsWithAnyTags", ctx, tags)}
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithAnyTags_Call) Run(run func(ctx context.Context, tags []string)) *Store_GetTalkgroupsWithAnyTags_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].([]string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithAnyTags_Call) Return(_a0 []database.GetTalkgroupsWithAnyTagsRow, _a1 error) *Store_GetTalkgroupsWithAnyTags_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithAnyTags_Call) RunAndReturn(run func(context.Context, []string) ([]database.GetTalkgroupsWithAnyTagsRow, error)) *Store_GetTalkgroupsWithAnyTags_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetTalkgroupsWithLearned provides a mock function with given fields: ctx
|
|
func (_m *Store) GetTalkgroupsWithLearned(ctx context.Context) ([]database.GetTalkgroupsWithLearnedRow, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetTalkgroupsWithLearned")
|
|
}
|
|
|
|
var r0 []database.GetTalkgroupsWithLearnedRow
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]database.GetTalkgroupsWithLearnedRow, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []database.GetTalkgroupsWithLearnedRow); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]database.GetTalkgroupsWithLearnedRow)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetTalkgroupsWithLearned_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTalkgroupsWithLearned'
|
|
type Store_GetTalkgroupsWithLearned_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetTalkgroupsWithLearned is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *Store_Expecter) GetTalkgroupsWithLearned(ctx interface{}) *Store_GetTalkgroupsWithLearned_Call {
|
|
return &Store_GetTalkgroupsWithLearned_Call{Call: _e.mock.On("GetTalkgroupsWithLearned", ctx)}
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithLearned_Call) Run(run func(ctx context.Context)) *Store_GetTalkgroupsWithLearned_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithLearned_Call) Return(_a0 []database.GetTalkgroupsWithLearnedRow, _a1 error) *Store_GetTalkgroupsWithLearned_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithLearned_Call) RunAndReturn(run func(context.Context) ([]database.GetTalkgroupsWithLearnedRow, error)) *Store_GetTalkgroupsWithLearned_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetTalkgroupsWithLearnedBySysTGID provides a mock function with given fields: ctx, ids
|
|
func (_m *Store) GetTalkgroupsWithLearnedBySysTGID(ctx context.Context, ids database.TGTuples) ([]database.GetTalkgroupsRow, error) {
|
|
ret := _m.Called(ctx, ids)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetTalkgroupsWithLearnedBySysTGID")
|
|
}
|
|
|
|
var r0 []database.GetTalkgroupsRow
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, database.TGTuples) ([]database.GetTalkgroupsRow, error)); ok {
|
|
return rf(ctx, ids)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, database.TGTuples) []database.GetTalkgroupsRow); ok {
|
|
r0 = rf(ctx, ids)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]database.GetTalkgroupsRow)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, database.TGTuples) error); ok {
|
|
r1 = rf(ctx, ids)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetTalkgroupsWithLearnedBySysTGID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTalkgroupsWithLearnedBySysTGID'
|
|
type Store_GetTalkgroupsWithLearnedBySysTGID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetTalkgroupsWithLearnedBySysTGID is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - ids database.TGTuples
|
|
func (_e *Store_Expecter) GetTalkgroupsWithLearnedBySysTGID(ctx interface{}, ids interface{}) *Store_GetTalkgroupsWithLearnedBySysTGID_Call {
|
|
return &Store_GetTalkgroupsWithLearnedBySysTGID_Call{Call: _e.mock.On("GetTalkgroupsWithLearnedBySysTGID", ctx, ids)}
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithLearnedBySysTGID_Call) Run(run func(ctx context.Context, ids database.TGTuples)) *Store_GetTalkgroupsWithLearnedBySysTGID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(database.TGTuples))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithLearnedBySysTGID_Call) Return(_a0 []database.GetTalkgroupsRow, _a1 error) *Store_GetTalkgroupsWithLearnedBySysTGID_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithLearnedBySysTGID_Call) RunAndReturn(run func(context.Context, database.TGTuples) ([]database.GetTalkgroupsRow, error)) *Store_GetTalkgroupsWithLearnedBySysTGID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetTalkgroupsWithLearnedBySystem provides a mock function with given fields: ctx, system
|
|
func (_m *Store) GetTalkgroupsWithLearnedBySystem(ctx context.Context, system int32) ([]database.GetTalkgroupsWithLearnedBySystemRow, error) {
|
|
ret := _m.Called(ctx, system)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetTalkgroupsWithLearnedBySystem")
|
|
}
|
|
|
|
var r0 []database.GetTalkgroupsWithLearnedBySystemRow
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int32) ([]database.GetTalkgroupsWithLearnedBySystemRow, error)); ok {
|
|
return rf(ctx, system)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, int32) []database.GetTalkgroupsWithLearnedBySystemRow); ok {
|
|
r0 = rf(ctx, system)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]database.GetTalkgroupsWithLearnedBySystemRow)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, int32) error); ok {
|
|
r1 = rf(ctx, system)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetTalkgroupsWithLearnedBySystem_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetTalkgroupsWithLearnedBySystem'
|
|
type Store_GetTalkgroupsWithLearnedBySystem_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetTalkgroupsWithLearnedBySystem is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - system int32
|
|
func (_e *Store_Expecter) GetTalkgroupsWithLearnedBySystem(ctx interface{}, system interface{}) *Store_GetTalkgroupsWithLearnedBySystem_Call {
|
|
return &Store_GetTalkgroupsWithLearnedBySystem_Call{Call: _e.mock.On("GetTalkgroupsWithLearnedBySystem", ctx, system)}
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithLearnedBySystem_Call) Run(run func(ctx context.Context, system int32)) *Store_GetTalkgroupsWithLearnedBySystem_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithLearnedBySystem_Call) Return(_a0 []database.GetTalkgroupsWithLearnedBySystemRow, _a1 error) *Store_GetTalkgroupsWithLearnedBySystem_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetTalkgroupsWithLearnedBySystem_Call) RunAndReturn(run func(context.Context, int32) ([]database.GetTalkgroupsWithLearnedBySystemRow, error)) *Store_GetTalkgroupsWithLearnedBySystem_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetUserByID provides a mock function with given fields: ctx, id
|
|
func (_m *Store) GetUserByID(ctx context.Context, id int) (database.User, error) {
|
|
ret := _m.Called(ctx, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUserByID")
|
|
}
|
|
|
|
var r0 database.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int) (database.User, error)); ok {
|
|
return rf(ctx, id)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, int) database.User); ok {
|
|
r0 = rf(ctx, id)
|
|
} else {
|
|
r0 = ret.Get(0).(database.User)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, int) error); ok {
|
|
r1 = rf(ctx, id)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetUserByID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByID'
|
|
type Store_GetUserByID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetUserByID is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - id int
|
|
func (_e *Store_Expecter) GetUserByID(ctx interface{}, id interface{}) *Store_GetUserByID_Call {
|
|
return &Store_GetUserByID_Call{Call: _e.mock.On("GetUserByID", ctx, id)}
|
|
}
|
|
|
|
func (_c *Store_GetUserByID_Call) Run(run func(ctx context.Context, id int)) *Store_GetUserByID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetUserByID_Call) Return(_a0 database.User, _a1 error) *Store_GetUserByID_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetUserByID_Call) RunAndReturn(run func(context.Context, int) (database.User, error)) *Store_GetUserByID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetUserByUID provides a mock function with given fields: ctx, id
|
|
func (_m *Store) GetUserByUID(ctx context.Context, id int) (database.User, error) {
|
|
ret := _m.Called(ctx, id)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUserByUID")
|
|
}
|
|
|
|
var r0 database.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, int) (database.User, error)); ok {
|
|
return rf(ctx, id)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, int) database.User); ok {
|
|
r0 = rf(ctx, id)
|
|
} else {
|
|
r0 = ret.Get(0).(database.User)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, int) error); ok {
|
|
r1 = rf(ctx, id)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetUserByUID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByUID'
|
|
type Store_GetUserByUID_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetUserByUID is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - id int
|
|
func (_e *Store_Expecter) GetUserByUID(ctx interface{}, id interface{}) *Store_GetUserByUID_Call {
|
|
return &Store_GetUserByUID_Call{Call: _e.mock.On("GetUserByUID", ctx, id)}
|
|
}
|
|
|
|
func (_c *Store_GetUserByUID_Call) Run(run func(ctx context.Context, id int)) *Store_GetUserByUID_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(int))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetUserByUID_Call) Return(_a0 database.User, _a1 error) *Store_GetUserByUID_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetUserByUID_Call) RunAndReturn(run func(context.Context, int) (database.User, error)) *Store_GetUserByUID_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetUserByUsername provides a mock function with given fields: ctx, username
|
|
func (_m *Store) GetUserByUsername(ctx context.Context, username string) (database.User, error) {
|
|
ret := _m.Called(ctx, username)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUserByUsername")
|
|
}
|
|
|
|
var r0 database.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) (database.User, error)); ok {
|
|
return rf(ctx, username)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, string) database.User); ok {
|
|
r0 = rf(ctx, username)
|
|
} else {
|
|
r0 = ret.Get(0).(database.User)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, string) error); ok {
|
|
r1 = rf(ctx, username)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetUserByUsername_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUserByUsername'
|
|
type Store_GetUserByUsername_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetUserByUsername is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - username string
|
|
func (_e *Store_Expecter) GetUserByUsername(ctx interface{}, username interface{}) *Store_GetUserByUsername_Call {
|
|
return &Store_GetUserByUsername_Call{Call: _e.mock.On("GetUserByUsername", ctx, username)}
|
|
}
|
|
|
|
func (_c *Store_GetUserByUsername_Call) Run(run func(ctx context.Context, username string)) *Store_GetUserByUsername_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetUserByUsername_Call) Return(_a0 database.User, _a1 error) *Store_GetUserByUsername_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetUserByUsername_Call) RunAndReturn(run func(context.Context, string) (database.User, error)) *Store_GetUserByUsername_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// GetUsers provides a mock function with given fields: ctx
|
|
func (_m *Store) GetUsers(ctx context.Context) ([]database.User, error) {
|
|
ret := _m.Called(ctx)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for GetUsers")
|
|
}
|
|
|
|
var r0 []database.User
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context) ([]database.User, error)); ok {
|
|
return rf(ctx)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context) []database.User); ok {
|
|
r0 = rf(ctx)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).([]database.User)
|
|
}
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context) error); ok {
|
|
r1 = rf(ctx)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_GetUsers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetUsers'
|
|
type Store_GetUsers_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// GetUsers is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
func (_e *Store_Expecter) GetUsers(ctx interface{}) *Store_GetUsers_Call {
|
|
return &Store_GetUsers_Call{Call: _e.mock.On("GetUsers", ctx)}
|
|
}
|
|
|
|
func (_c *Store_GetUsers_Call) Run(run func(ctx context.Context)) *Store_GetUsers_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetUsers_Call) Return(_a0 []database.User, _a1 error) *Store_GetUsers_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_GetUsers_Call) RunAndReturn(run func(context.Context) ([]database.User, error)) *Store_GetUsers_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// InTx provides a mock function with given fields: _a0, _a1, _a2
|
|
func (_m *Store) InTx(_a0 context.Context, _a1 func(database.Store) error, _a2 pgx.TxOptions) error {
|
|
ret := _m.Called(_a0, _a1, _a2)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for InTx")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, func(database.Store) error, pgx.TxOptions) error); ok {
|
|
r0 = rf(_a0, _a1, _a2)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Store_InTx_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'InTx'
|
|
type Store_InTx_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// InTx is a helper method to define mock.On call
|
|
// - _a0 context.Context
|
|
// - _a1 func(database.Store) error
|
|
// - _a2 pgx.TxOptions
|
|
func (_e *Store_Expecter) InTx(_a0 interface{}, _a1 interface{}, _a2 interface{}) *Store_InTx_Call {
|
|
return &Store_InTx_Call{Call: _e.mock.On("InTx", _a0, _a1, _a2)}
|
|
}
|
|
|
|
func (_c *Store_InTx_Call) Run(run func(_a0 context.Context, _a1 func(database.Store) error, _a2 pgx.TxOptions)) *Store_InTx_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(func(database.Store) error), args[2].(pgx.TxOptions))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_InTx_Call) Return(_a0 error) *Store_InTx_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_InTx_Call) RunAndReturn(run func(context.Context, func(database.Store) error, pgx.TxOptions) error) *Store_InTx_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetCallTranscript provides a mock function with given fields: ctx, iD, transcript
|
|
func (_m *Store) SetCallTranscript(ctx context.Context, iD uuid.UUID, transcript *string) error {
|
|
ret := _m.Called(ctx, iD, transcript)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetCallTranscript")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, uuid.UUID, *string) error); ok {
|
|
r0 = rf(ctx, iD, transcript)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Store_SetCallTranscript_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetCallTranscript'
|
|
type Store_SetCallTranscript_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetCallTranscript is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - iD uuid.UUID
|
|
// - transcript *string
|
|
func (_e *Store_Expecter) SetCallTranscript(ctx interface{}, iD interface{}, transcript interface{}) *Store_SetCallTranscript_Call {
|
|
return &Store_SetCallTranscript_Call{Call: _e.mock.On("SetCallTranscript", ctx, iD, transcript)}
|
|
}
|
|
|
|
func (_c *Store_SetCallTranscript_Call) Run(run func(ctx context.Context, iD uuid.UUID, transcript *string)) *Store_SetCallTranscript_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(uuid.UUID), args[2].(*string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_SetCallTranscript_Call) Return(_a0 error) *Store_SetCallTranscript_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_SetCallTranscript_Call) RunAndReturn(run func(context.Context, uuid.UUID, *string) error) *Store_SetCallTranscript_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// SetTalkgroupTags provides a mock function with given fields: ctx, tags, systemID, tGID
|
|
func (_m *Store) SetTalkgroupTags(ctx context.Context, tags []string, systemID int32, tGID int32) error {
|
|
ret := _m.Called(ctx, tags, systemID, tGID)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for SetTalkgroupTags")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, []string, int32, int32) error); ok {
|
|
r0 = rf(ctx, tags, systemID, tGID)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Store_SetTalkgroupTags_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetTalkgroupTags'
|
|
type Store_SetTalkgroupTags_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// SetTalkgroupTags is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - tags []string
|
|
// - systemID int32
|
|
// - tGID int32
|
|
func (_e *Store_Expecter) SetTalkgroupTags(ctx interface{}, tags interface{}, systemID interface{}, tGID interface{}) *Store_SetTalkgroupTags_Call {
|
|
return &Store_SetTalkgroupTags_Call{Call: _e.mock.On("SetTalkgroupTags", ctx, tags, systemID, tGID)}
|
|
}
|
|
|
|
func (_c *Store_SetTalkgroupTags_Call) Run(run func(ctx context.Context, tags []string, systemID int32, tGID int32)) *Store_SetTalkgroupTags_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].([]string), args[2].(int32), args[3].(int32))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_SetTalkgroupTags_Call) Return(_a0 error) *Store_SetTalkgroupTags_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_SetTalkgroupTags_Call) RunAndReturn(run func(context.Context, []string, int32, int32) error) *Store_SetTalkgroupTags_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdatePassword provides a mock function with given fields: ctx, username, password
|
|
func (_m *Store) UpdatePassword(ctx context.Context, username string, password string) error {
|
|
ret := _m.Called(ctx, username, password)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdatePassword")
|
|
}
|
|
|
|
var r0 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, string, string) error); ok {
|
|
r0 = rf(ctx, username, password)
|
|
} else {
|
|
r0 = ret.Error(0)
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Store_UpdatePassword_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdatePassword'
|
|
type Store_UpdatePassword_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdatePassword is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - username string
|
|
// - password string
|
|
func (_e *Store_Expecter) UpdatePassword(ctx interface{}, username interface{}, password interface{}) *Store_UpdatePassword_Call {
|
|
return &Store_UpdatePassword_Call{Call: _e.mock.On("UpdatePassword", ctx, username, password)}
|
|
}
|
|
|
|
func (_c *Store_UpdatePassword_Call) Run(run func(ctx context.Context, username string, password string)) *Store_UpdatePassword_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(string), args[2].(string))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_UpdatePassword_Call) Return(_a0 error) *Store_UpdatePassword_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_UpdatePassword_Call) RunAndReturn(run func(context.Context, string, string) error) *Store_UpdatePassword_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpdateTalkgroup provides a mock function with given fields: ctx, arg
|
|
func (_m *Store) UpdateTalkgroup(ctx context.Context, arg database.UpdateTalkgroupParams) (database.Talkgroup, error) {
|
|
ret := _m.Called(ctx, arg)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpdateTalkgroup")
|
|
}
|
|
|
|
var r0 database.Talkgroup
|
|
var r1 error
|
|
if rf, ok := ret.Get(0).(func(context.Context, database.UpdateTalkgroupParams) (database.Talkgroup, error)); ok {
|
|
return rf(ctx, arg)
|
|
}
|
|
if rf, ok := ret.Get(0).(func(context.Context, database.UpdateTalkgroupParams) database.Talkgroup); ok {
|
|
r0 = rf(ctx, arg)
|
|
} else {
|
|
r0 = ret.Get(0).(database.Talkgroup)
|
|
}
|
|
|
|
if rf, ok := ret.Get(1).(func(context.Context, database.UpdateTalkgroupParams) error); ok {
|
|
r1 = rf(ctx, arg)
|
|
} else {
|
|
r1 = ret.Error(1)
|
|
}
|
|
|
|
return r0, r1
|
|
}
|
|
|
|
// Store_UpdateTalkgroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateTalkgroup'
|
|
type Store_UpdateTalkgroup_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpdateTalkgroup is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - arg database.UpdateTalkgroupParams
|
|
func (_e *Store_Expecter) UpdateTalkgroup(ctx interface{}, arg interface{}) *Store_UpdateTalkgroup_Call {
|
|
return &Store_UpdateTalkgroup_Call{Call: _e.mock.On("UpdateTalkgroup", ctx, arg)}
|
|
}
|
|
|
|
func (_c *Store_UpdateTalkgroup_Call) Run(run func(ctx context.Context, arg database.UpdateTalkgroupParams)) *Store_UpdateTalkgroup_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].(database.UpdateTalkgroupParams))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_UpdateTalkgroup_Call) Return(_a0 database.Talkgroup, _a1 error) *Store_UpdateTalkgroup_Call {
|
|
_c.Call.Return(_a0, _a1)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_UpdateTalkgroup_Call) RunAndReturn(run func(context.Context, database.UpdateTalkgroupParams) (database.Talkgroup, error)) *Store_UpdateTalkgroup_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// UpsertTalkgroup provides a mock function with given fields: ctx, arg
|
|
func (_m *Store) UpsertTalkgroup(ctx context.Context, arg []database.UpsertTalkgroupParams) *database.UpsertTalkgroupBatchResults {
|
|
ret := _m.Called(ctx, arg)
|
|
|
|
if len(ret) == 0 {
|
|
panic("no return value specified for UpsertTalkgroup")
|
|
}
|
|
|
|
var r0 *database.UpsertTalkgroupBatchResults
|
|
if rf, ok := ret.Get(0).(func(context.Context, []database.UpsertTalkgroupParams) *database.UpsertTalkgroupBatchResults); ok {
|
|
r0 = rf(ctx, arg)
|
|
} else {
|
|
if ret.Get(0) != nil {
|
|
r0 = ret.Get(0).(*database.UpsertTalkgroupBatchResults)
|
|
}
|
|
}
|
|
|
|
return r0
|
|
}
|
|
|
|
// Store_UpsertTalkgroup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpsertTalkgroup'
|
|
type Store_UpsertTalkgroup_Call struct {
|
|
*mock.Call
|
|
}
|
|
|
|
// UpsertTalkgroup is a helper method to define mock.On call
|
|
// - ctx context.Context
|
|
// - arg []database.UpsertTalkgroupParams
|
|
func (_e *Store_Expecter) UpsertTalkgroup(ctx interface{}, arg interface{}) *Store_UpsertTalkgroup_Call {
|
|
return &Store_UpsertTalkgroup_Call{Call: _e.mock.On("UpsertTalkgroup", ctx, arg)}
|
|
}
|
|
|
|
func (_c *Store_UpsertTalkgroup_Call) Run(run func(ctx context.Context, arg []database.UpsertTalkgroupParams)) *Store_UpsertTalkgroup_Call {
|
|
_c.Call.Run(func(args mock.Arguments) {
|
|
run(args[0].(context.Context), args[1].([]database.UpsertTalkgroupParams))
|
|
})
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_UpsertTalkgroup_Call) Return(_a0 *database.UpsertTalkgroupBatchResults) *Store_UpsertTalkgroup_Call {
|
|
_c.Call.Return(_a0)
|
|
return _c
|
|
}
|
|
|
|
func (_c *Store_UpsertTalkgroup_Call) RunAndReturn(run func(context.Context, []database.UpsertTalkgroupParams) *database.UpsertTalkgroupBatchResults) *Store_UpsertTalkgroup_Call {
|
|
_c.Call.Return(run)
|
|
return _c
|
|
}
|
|
|
|
// NewStore creates a new instance of Store. 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 NewStore(t interface {
|
|
mock.TestingT
|
|
Cleanup(func())
|
|
}) *Store {
|
|
mock := &Store{}
|
|
mock.Mock.Test(t)
|
|
|
|
t.Cleanup(func() { mock.AssertExpectations(t) })
|
|
|
|
return mock
|
|
}
|