Help us shape the future of Go! Take the 2026 Go Developer Survey

notification

package
v1.20.0-alpha.1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 29, 2026 License: MIT Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Channel 

type Channel struct {
	mock.Mock
}

Channel is an autogenerated mock type for the Channel type

func NewChannel 

func NewChannel(t interface {
	mock.TestingT
	Cleanup(func())
}) *Channel

NewChannel creates a new instance of Channel. 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 (*Channel) EXPECT 

func (_m *Channel) EXPECT() *Channel_Expecter

func (*Channel) Name 

func (_m *Channel) Name() string

Name provides a mock function with no fields

func (*Channel) Send 

func (_m *Channel) Send(notifiable notification.Notifiable, _a1 notification.Notification) error

Send provides a mock function with given fields: notifiable, _a1

type Channel_Expecter 

type Channel_Expecter struct {
	// contains filtered or unexported fields
}

func (*Channel_Expecter) Name 

func (_e *Channel_Expecter) Name() *Channel_Name_Call

Name is a helper method to define mock.On call

func (*Channel_Expecter) Send 

func (_e *Channel_Expecter) Send(notifiable interface{}, _a1 interface{}) *Channel_Send_Call

Send is a helper method to define mock.On call

  • notifiable notification.Notifiable
  • _a1 notification.Notification

type Channel_Name_Call 

type Channel_Name_Call struct {
	*mock.Call
}

Channel_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name'

func (*Channel_Name_Call) Return 

func (_c *Channel_Name_Call) Return(_a0 string) *Channel_Name_Call

func (*Channel_Name_Call) Run 

func (_c *Channel_Name_Call) Run(run func()) *Channel_Name_Call

func (*Channel_Name_Call) RunAndReturn 

func (_c *Channel_Name_Call) RunAndReturn(run func() string) *Channel_Name_Call

type Channel_Send_Call 

type Channel_Send_Call struct {
	*mock.Call
}

Channel_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'

func (*Channel_Send_Call) Return 

func (_c *Channel_Send_Call) Return(_a0 error) *Channel_Send_Call

func (*Channel_Send_Call) Run 

func (_c *Channel_Send_Call) Run(run func(notifiable notification.Notifiable, _a1 notification.Notification)) *Channel_Send_Call

func (*Channel_Send_Call) RunAndReturn 

func (_c *Channel_Send_Call) RunAndReturn(run func(notification.Notifiable, notification.Notification) error) *Channel_Send_Call

type DatabaseNotification 

type DatabaseNotification struct {
	mock.Mock
}

DatabaseNotification is an autogenerated mock type for the DatabaseNotification type

func NewDatabaseNotification 

func NewDatabaseNotification(t interface {
	mock.TestingT
	Cleanup(func())
}) *DatabaseNotification

NewDatabaseNotification creates a new instance of DatabaseNotification. 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 (*DatabaseNotification) EXPECT 

func (_m *DatabaseNotification) EXPECT() *DatabaseNotification_Expecter

func (*DatabaseNotification) ToDatabase 

func (_m *DatabaseNotification) ToDatabase(notifiable notification.Notifiable) map[string]interface{}

ToDatabase provides a mock function with given fields: notifiable

func (*DatabaseNotification) Via 

func (_m *DatabaseNotification) Via(notifiable notification.Notifiable) []string

Via provides a mock function with given fields: notifiable

type DatabaseNotification_Expecter 

type DatabaseNotification_Expecter struct {
	// contains filtered or unexported fields
}

func (*DatabaseNotification_Expecter) ToDatabase 

func (_e *DatabaseNotification_Expecter) ToDatabase(notifiable interface{}) *DatabaseNotification_ToDatabase_Call

ToDatabase is a helper method to define mock.On call

  • notifiable notification.Notifiable

func (*DatabaseNotification_Expecter) Via 

func (_e *DatabaseNotification_Expecter) Via(notifiable interface{}) *DatabaseNotification_Via_Call

Via is a helper method to define mock.On call

  • notifiable notification.Notifiable

type DatabaseNotification_ToDatabase_Call 

type DatabaseNotification_ToDatabase_Call struct {
	*mock.Call
}

DatabaseNotification_ToDatabase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToDatabase'

func (*DatabaseNotification_ToDatabase_Call) Return 

func (_c *DatabaseNotification_ToDatabase_Call) Return(_a0 map[string]interface{}) *DatabaseNotification_ToDatabase_Call

func (*DatabaseNotification_ToDatabase_Call) Run 

func (_c *DatabaseNotification_ToDatabase_Call) Run(run func(notifiable notification.Notifiable)) *DatabaseNotification_ToDatabase_Call

func (*DatabaseNotification_ToDatabase_Call) RunAndReturn 

func (_c *DatabaseNotification_ToDatabase_Call) RunAndReturn(run func(notification.Notifiable) map[string]interface{}) *DatabaseNotification_ToDatabase_Call

type DatabaseNotification_Via_Call 

type DatabaseNotification_Via_Call struct {
	*mock.Call
}

DatabaseNotification_Via_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Via'

func (*DatabaseNotification_Via_Call) Return 

func (_c *DatabaseNotification_Via_Call) Return(_a0 []string) *DatabaseNotification_Via_Call

func (*DatabaseNotification_Via_Call) Run 

func (_c *DatabaseNotification_Via_Call) Run(run func(notifiable notification.Notifiable)) *DatabaseNotification_Via_Call

func (*DatabaseNotification_Via_Call) RunAndReturn 

func (_c *DatabaseNotification_Via_Call) RunAndReturn(run func(notification.Notifiable) []string) *DatabaseNotification_Via_Call

type DatabaseRoutable 

type DatabaseRoutable struct {
	mock.Mock
}

DatabaseRoutable is an autogenerated mock type for the DatabaseRoutable type

func NewDatabaseRoutable 

func NewDatabaseRoutable(t interface {
	mock.TestingT
	Cleanup(func())
}) *DatabaseRoutable

NewDatabaseRoutable creates a new instance of DatabaseRoutable. 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 (*DatabaseRoutable) EXPECT 

func (_m *DatabaseRoutable) EXPECT() *DatabaseRoutable_Expecter

func (*DatabaseRoutable) RouteNotificationForDatabase 

func (_m *DatabaseRoutable) RouteNotificationForDatabase() string

RouteNotificationForDatabase provides a mock function with no fields

type DatabaseRoutable_Expecter 

type DatabaseRoutable_Expecter struct {
	// contains filtered or unexported fields
}

func (*DatabaseRoutable_Expecter) RouteNotificationForDatabase 

func (_e *DatabaseRoutable_Expecter) RouteNotificationForDatabase() *DatabaseRoutable_RouteNotificationForDatabase_Call

RouteNotificationForDatabase is a helper method to define mock.On call

type DatabaseRoutable_RouteNotificationForDatabase_Call 

type DatabaseRoutable_RouteNotificationForDatabase_Call struct {
	*mock.Call
}

DatabaseRoutable_RouteNotificationForDatabase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RouteNotificationForDatabase'

func (*DatabaseRoutable_RouteNotificationForDatabase_Call) Return 

func (_c *DatabaseRoutable_RouteNotificationForDatabase_Call) Return(_a0 string) *DatabaseRoutable_RouteNotificationForDatabase_Call

func (*DatabaseRoutable_RouteNotificationForDatabase_Call) Run 

func (_c *DatabaseRoutable_RouteNotificationForDatabase_Call) Run(run func()) *DatabaseRoutable_RouteNotificationForDatabase_Call

func (*DatabaseRoutable_RouteNotificationForDatabase_Call) RunAndReturn 

func (_c *DatabaseRoutable_RouteNotificationForDatabase_Call) RunAndReturn(run func() string) *DatabaseRoutable_RouteNotificationForDatabase_Call

type MailRoutable 

type MailRoutable struct {
	mock.Mock
}

MailRoutable is an autogenerated mock type for the MailRoutable type

func NewMailRoutable 

func NewMailRoutable(t interface {
	mock.TestingT
	Cleanup(func())
}) *MailRoutable

NewMailRoutable creates a new instance of MailRoutable. 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 (*MailRoutable) EXPECT 

func (_m *MailRoutable) EXPECT() *MailRoutable_Expecter

func (*MailRoutable) RouteNotificationForMail 

func (_m *MailRoutable) RouteNotificationForMail(_a0 notification.Notification) map[string]string

RouteNotificationForMail provides a mock function with given fields: _a0

type MailRoutable_Expecter 

type MailRoutable_Expecter struct {
	// contains filtered or unexported fields
}

func (*MailRoutable_Expecter) RouteNotificationForMail 

func (_e *MailRoutable_Expecter) RouteNotificationForMail(_a0 interface{}) *MailRoutable_RouteNotificationForMail_Call

RouteNotificationForMail is a helper method to define mock.On call

  • _a0 notification.Notification

type MailRoutable_RouteNotificationForMail_Call 

type MailRoutable_RouteNotificationForMail_Call struct {
	*mock.Call
}

MailRoutable_RouteNotificationForMail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RouteNotificationForMail'

func (*MailRoutable_RouteNotificationForMail_Call) Return 

func (_c *MailRoutable_RouteNotificationForMail_Call) Return(_a0 map[string]string) *MailRoutable_RouteNotificationForMail_Call

func (*MailRoutable_RouteNotificationForMail_Call) Run 

func (_c *MailRoutable_RouteNotificationForMail_Call) Run(run func(_a0 notification.Notification)) *MailRoutable_RouteNotificationForMail_Call

func (*MailRoutable_RouteNotificationForMail_Call) RunAndReturn 

func (_c *MailRoutable_RouteNotificationForMail_Call) RunAndReturn(run func(notification.Notification) map[string]string) *MailRoutable_RouteNotificationForMail_Call

type MailableNotification 

type MailableNotification struct {
	mock.Mock
}

MailableNotification is an autogenerated mock type for the MailableNotification type

func NewMailableNotification 

func NewMailableNotification(t interface {
	mock.TestingT
	Cleanup(func())
}) *MailableNotification

NewMailableNotification creates a new instance of MailableNotification. 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 (*MailableNotification) EXPECT 

func (_m *MailableNotification) EXPECT() *MailableNotification_Expecter

func (*MailableNotification) ToMail 

func (_m *MailableNotification) ToMail(notifiable notification.Notifiable) notification.MailMessage

ToMail provides a mock function with given fields: notifiable

func (*MailableNotification) Via 

func (_m *MailableNotification) Via(notifiable notification.Notifiable) []string

Via provides a mock function with given fields: notifiable

type MailableNotification_Expecter 

type MailableNotification_Expecter struct {
	// contains filtered or unexported fields
}

func (*MailableNotification_Expecter) ToMail 

func (_e *MailableNotification_Expecter) ToMail(notifiable interface{}) *MailableNotification_ToMail_Call

ToMail is a helper method to define mock.On call

  • notifiable notification.Notifiable

func (*MailableNotification_Expecter) Via 

func (_e *MailableNotification_Expecter) Via(notifiable interface{}) *MailableNotification_Via_Call

Via is a helper method to define mock.On call

  • notifiable notification.Notifiable

type MailableNotification_ToMail_Call 

type MailableNotification_ToMail_Call struct {
	*mock.Call
}

MailableNotification_ToMail_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ToMail'

func (*MailableNotification_ToMail_Call) Return 

func (_c *MailableNotification_ToMail_Call) Return(_a0 notification.MailMessage) *MailableNotification_ToMail_Call

func (*MailableNotification_ToMail_Call) Run 

func (_c *MailableNotification_ToMail_Call) Run(run func(notifiable notification.Notifiable)) *MailableNotification_ToMail_Call

func (*MailableNotification_ToMail_Call) RunAndReturn 

func (_c *MailableNotification_ToMail_Call) RunAndReturn(run func(notification.Notifiable) notification.MailMessage) *MailableNotification_ToMail_Call

type MailableNotification_Via_Call 

type MailableNotification_Via_Call struct {
	*mock.Call
}

MailableNotification_Via_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Via'

func (*MailableNotification_Via_Call) Return 

func (_c *MailableNotification_Via_Call) Return(_a0 []string) *MailableNotification_Via_Call

func (*MailableNotification_Via_Call) Run 

func (_c *MailableNotification_Via_Call) Run(run func(notifiable notification.Notifiable)) *MailableNotification_Via_Call

func (*MailableNotification_Via_Call) RunAndReturn 

func (_c *MailableNotification_Via_Call) RunAndReturn(run func(notification.Notifiable) []string) *MailableNotification_Via_Call

type Manager 

type Manager struct {
	mock.Mock
}

Manager is an autogenerated mock type for the Manager type

func NewManager 

func NewManager(t interface {
	mock.TestingT
	Cleanup(func())
}) *Manager

NewManager creates a new instance of Manager. 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 (*Manager) Channel 

func (_m *Manager) Channel(name string) notification.Channel

Channel provides a mock function with given fields: name

func (*Manager) EXPECT 

func (_m *Manager) EXPECT() *Manager_Expecter

func (*Manager) Extend 

func (_m *Manager) Extend(channel notification.Channel)

Extend provides a mock function with given fields: channel

func (*Manager) Route 

func (_m *Manager) Route(channel string, route interface{}) notification.OnDemandNotifiable

Route provides a mock function with given fields: channel, route

func (*Manager) Send 

func (_m *Manager) Send(notifiable notification.Notifiable, _a1 notification.Notification) error

Send provides a mock function with given fields: notifiable, _a1

func (*Manager) SendNow 

func (_m *Manager) SendNow(notifiable notification.Notifiable, _a1 notification.Notification) error

SendNow provides a mock function with given fields: notifiable, _a1

type Manager_Channel_Call 

type Manager_Channel_Call struct {
	*mock.Call
}

Manager_Channel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Channel'

func (*Manager_Channel_Call) Return 

func (_c *Manager_Channel_Call) Return(_a0 notification.Channel) *Manager_Channel_Call

func (*Manager_Channel_Call) Run 

func (_c *Manager_Channel_Call) Run(run func(name string)) *Manager_Channel_Call

func (*Manager_Channel_Call) RunAndReturn 

func (_c *Manager_Channel_Call) RunAndReturn(run func(string) notification.Channel) *Manager_Channel_Call

type Manager_Expecter 

type Manager_Expecter struct {
	// contains filtered or unexported fields
}

func (*Manager_Expecter) Channel 

func (_e *Manager_Expecter) Channel(name interface{}) *Manager_Channel_Call

Channel is a helper method to define mock.On call

  • name string

func (*Manager_Expecter) Extend 

func (_e *Manager_Expecter) Extend(channel interface{}) *Manager_Extend_Call

Extend is a helper method to define mock.On call

  • channel notification.Channel

func (*Manager_Expecter) Route 

func (_e *Manager_Expecter) Route(channel interface{}, route interface{}) *Manager_Route_Call

Route is a helper method to define mock.On call

  • channel string
  • route interface{}

func (*Manager_Expecter) Send 

func (_e *Manager_Expecter) Send(notifiable interface{}, _a1 interface{}) *Manager_Send_Call

Send is a helper method to define mock.On call

  • notifiable notification.Notifiable
  • _a1 notification.Notification

func (*Manager_Expecter) SendNow 

func (_e *Manager_Expecter) SendNow(notifiable interface{}, _a1 interface{}) *Manager_SendNow_Call

SendNow is a helper method to define mock.On call

  • notifiable notification.Notifiable
  • _a1 notification.Notification

type Manager_Extend_Call 

type Manager_Extend_Call struct {
	*mock.Call
}

Manager_Extend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Extend'

func (*Manager_Extend_Call) Return 

func (_c *Manager_Extend_Call) Return() *Manager_Extend_Call

func (*Manager_Extend_Call) Run 

func (_c *Manager_Extend_Call) Run(run func(channel notification.Channel)) *Manager_Extend_Call

func (*Manager_Extend_Call) RunAndReturn 

func (_c *Manager_Extend_Call) RunAndReturn(run func(notification.Channel)) *Manager_Extend_Call

type Manager_Route_Call 

type Manager_Route_Call struct {
	*mock.Call
}

Manager_Route_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Route'

func (*Manager_Route_Call) Return 

func (_c *Manager_Route_Call) Return(_a0 notification.OnDemandNotifiable) *Manager_Route_Call

func (*Manager_Route_Call) Run 

func (_c *Manager_Route_Call) Run(run func(channel string, route interface{})) *Manager_Route_Call

func (*Manager_Route_Call) RunAndReturn 

func (_c *Manager_Route_Call) RunAndReturn(run func(string, interface{}) notification.OnDemandNotifiable) *Manager_Route_Call

type Manager_SendNow_Call 

type Manager_SendNow_Call struct {
	*mock.Call
}

Manager_SendNow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SendNow'

func (*Manager_SendNow_Call) Return 

func (_c *Manager_SendNow_Call) Return(_a0 error) *Manager_SendNow_Call

func (*Manager_SendNow_Call) Run 

func (_c *Manager_SendNow_Call) Run(run func(notifiable notification.Notifiable, _a1 notification.Notification)) *Manager_SendNow_Call

func (*Manager_SendNow_Call) RunAndReturn 

func (_c *Manager_SendNow_Call) RunAndReturn(run func(notification.Notifiable, notification.Notification) error) *Manager_SendNow_Call

type Manager_Send_Call 

type Manager_Send_Call struct {
	*mock.Call
}

Manager_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'

func (*Manager_Send_Call) Return 

func (_c *Manager_Send_Call) Return(_a0 error) *Manager_Send_Call

func (*Manager_Send_Call) Run 

func (_c *Manager_Send_Call) Run(run func(notifiable notification.Notifiable, _a1 notification.Notification)) *Manager_Send_Call

func (*Manager_Send_Call) RunAndReturn 

func (_c *Manager_Send_Call) RunAndReturn(run func(notification.Notifiable, notification.Notification) error) *Manager_Send_Call

type Notifiable 

type Notifiable struct {
	mock.Mock
}

Notifiable is an autogenerated mock type for the Notifiable type

func NewNotifiable 

func NewNotifiable(t interface {
	mock.TestingT
	Cleanup(func())
}) *Notifiable

NewNotifiable creates a new instance of Notifiable. 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 (*Notifiable) EXPECT 

func (_m *Notifiable) EXPECT() *Notifiable_Expecter

func (*Notifiable) RouteNotificationFor 

func (_m *Notifiable) RouteNotificationFor(channel string) interface{}

RouteNotificationFor provides a mock function with given fields: channel

type Notifiable_Expecter 

type Notifiable_Expecter struct {
	// contains filtered or unexported fields
}

func (*Notifiable_Expecter) RouteNotificationFor 

func (_e *Notifiable_Expecter) RouteNotificationFor(channel interface{}) *Notifiable_RouteNotificationFor_Call

RouteNotificationFor is a helper method to define mock.On call

  • channel string

type Notifiable_RouteNotificationFor_Call 

type Notifiable_RouteNotificationFor_Call struct {
	*mock.Call
}

Notifiable_RouteNotificationFor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RouteNotificationFor'

func (*Notifiable_RouteNotificationFor_Call) Return 

func (_c *Notifiable_RouteNotificationFor_Call) Return(_a0 interface{}) *Notifiable_RouteNotificationFor_Call

func (*Notifiable_RouteNotificationFor_Call) Run 

func (_c *Notifiable_RouteNotificationFor_Call) Run(run func(channel string)) *Notifiable_RouteNotificationFor_Call

func (*Notifiable_RouteNotificationFor_Call) RunAndReturn 

func (_c *Notifiable_RouteNotificationFor_Call) RunAndReturn(run func(string) interface{}) *Notifiable_RouteNotificationFor_Call

type Notification 

type Notification struct {
	mock.Mock
}

Notification is an autogenerated mock type for the Notification type

func NewNotification 

func NewNotification(t interface {
	mock.TestingT
	Cleanup(func())
}) *Notification

NewNotification creates a new instance of Notification. 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 (*Notification) EXPECT 

func (_m *Notification) EXPECT() *Notification_Expecter

func (*Notification) Via 

func (_m *Notification) Via(notifiable notification.Notifiable) []string

Via provides a mock function with given fields: notifiable

type NotificationWithAfterSending 

type NotificationWithAfterSending struct {
	mock.Mock
}

NotificationWithAfterSending is an autogenerated mock type for the NotificationWithAfterSending type

func NewNotificationWithAfterSending 

func NewNotificationWithAfterSending(t interface {
	mock.TestingT
	Cleanup(func())
}) *NotificationWithAfterSending

NewNotificationWithAfterSending creates a new instance of NotificationWithAfterSending. 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 (*NotificationWithAfterSending) AfterSending 

func (_m *NotificationWithAfterSending) AfterSending(notifiable notification.Notifiable, channel string) error

AfterSending provides a mock function with given fields: notifiable, channel

func (*NotificationWithAfterSending) EXPECT 

func (_m *NotificationWithAfterSending) EXPECT() *NotificationWithAfterSending_Expecter

func (*NotificationWithAfterSending) Via 

func (_m *NotificationWithAfterSending) Via(notifiable notification.Notifiable) []string

Via provides a mock function with given fields: notifiable

type NotificationWithAfterSending_AfterSending_Call 

type NotificationWithAfterSending_AfterSending_Call struct {
	*mock.Call
}

NotificationWithAfterSending_AfterSending_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AfterSending'

func (*NotificationWithAfterSending_AfterSending_Call) Return 

func (_c *NotificationWithAfterSending_AfterSending_Call) Return(_a0 error) *NotificationWithAfterSending_AfterSending_Call

func (*NotificationWithAfterSending_AfterSending_Call) Run 

func (_c *NotificationWithAfterSending_AfterSending_Call) Run(run func(notifiable notification.Notifiable, channel string)) *NotificationWithAfterSending_AfterSending_Call

func (*NotificationWithAfterSending_AfterSending_Call) RunAndReturn 

func (_c *NotificationWithAfterSending_AfterSending_Call) RunAndReturn(run func(notification.Notifiable, string) error) *NotificationWithAfterSending_AfterSending_Call

type NotificationWithAfterSending_Expecter 

type NotificationWithAfterSending_Expecter struct {
	// contains filtered or unexported fields
}

func (*NotificationWithAfterSending_Expecter) AfterSending 

func (_e *NotificationWithAfterSending_Expecter) AfterSending(notifiable interface{}, channel interface{}) *NotificationWithAfterSending_AfterSending_Call

AfterSending is a helper method to define mock.On call

  • notifiable notification.Notifiable
  • channel string

func (*NotificationWithAfterSending_Expecter) Via 

func (_e *NotificationWithAfterSending_Expecter) Via(notifiable interface{}) *NotificationWithAfterSending_Via_Call

Via is a helper method to define mock.On call

  • notifiable notification.Notifiable

type NotificationWithAfterSending_Via_Call 

type NotificationWithAfterSending_Via_Call struct {
	*mock.Call
}

NotificationWithAfterSending_Via_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Via'

func (*NotificationWithAfterSending_Via_Call) Return 

func (_c *NotificationWithAfterSending_Via_Call) Return(_a0 []string) *NotificationWithAfterSending_Via_Call

func (*NotificationWithAfterSending_Via_Call) Run 

func (_c *NotificationWithAfterSending_Via_Call) Run(run func(notifiable notification.Notifiable)) *NotificationWithAfterSending_Via_Call

func (*NotificationWithAfterSending_Via_Call) RunAndReturn 

func (_c *NotificationWithAfterSending_Via_Call) RunAndReturn(run func(notification.Notifiable) []string) *NotificationWithAfterSending_Via_Call

type NotificationWithBackoff 

type NotificationWithBackoff struct {
	mock.Mock
}

NotificationWithBackoff is an autogenerated mock type for the NotificationWithBackoff type

func NewNotificationWithBackoff 

func NewNotificationWithBackoff(t interface {
	mock.TestingT
	Cleanup(func())
}) *NotificationWithBackoff

NewNotificationWithBackoff creates a new instance of NotificationWithBackoff. 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 (*NotificationWithBackoff) Backoff 

func (_m *NotificationWithBackoff) Backoff(channel string) []time.Duration

Backoff provides a mock function with given fields: channel

func (*NotificationWithBackoff) EXPECT 

func (_m *NotificationWithBackoff) EXPECT() *NotificationWithBackoff_Expecter

func (*NotificationWithBackoff) Via 

func (_m *NotificationWithBackoff) Via(notifiable notification.Notifiable) []string

Via provides a mock function with given fields: notifiable

type NotificationWithBackoff_Backoff_Call 

type NotificationWithBackoff_Backoff_Call struct {
	*mock.Call
}

NotificationWithBackoff_Backoff_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Backoff'

func (*NotificationWithBackoff_Backoff_Call) Return 

func (_c *NotificationWithBackoff_Backoff_Call) Return(_a0 []time.Duration) *NotificationWithBackoff_Backoff_Call

func (*NotificationWithBackoff_Backoff_Call) Run 

func (_c *NotificationWithBackoff_Backoff_Call) Run(run func(channel string)) *NotificationWithBackoff_Backoff_Call

func (*NotificationWithBackoff_Backoff_Call) RunAndReturn 

func (_c *NotificationWithBackoff_Backoff_Call) RunAndReturn(run func(string) []time.Duration) *NotificationWithBackoff_Backoff_Call

type NotificationWithBackoff_Expecter 

type NotificationWithBackoff_Expecter struct {
	// contains filtered or unexported fields
}

func (*NotificationWithBackoff_Expecter) Backoff 

func (_e *NotificationWithBackoff_Expecter) Backoff(channel interface{}) *NotificationWithBackoff_Backoff_Call

Backoff is a helper method to define mock.On call

  • channel string

func (*NotificationWithBackoff_Expecter) Via 

func (_e *NotificationWithBackoff_Expecter) Via(notifiable interface{}) *NotificationWithBackoff_Via_Call

Via is a helper method to define mock.On call

  • notifiable notification.Notifiable

type NotificationWithBackoff_Via_Call 

type NotificationWithBackoff_Via_Call struct {
	*mock.Call
}

NotificationWithBackoff_Via_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Via'

func (*NotificationWithBackoff_Via_Call) Return 

func (_c *NotificationWithBackoff_Via_Call) Return(_a0 []string) *NotificationWithBackoff_Via_Call

func (*NotificationWithBackoff_Via_Call) Run 

func (_c *NotificationWithBackoff_Via_Call) Run(run func(notifiable notification.Notifiable)) *NotificationWithBackoff_Via_Call

func (*NotificationWithBackoff_Via_Call) RunAndReturn 

func (_c *NotificationWithBackoff_Via_Call) RunAndReturn(run func(notification.Notifiable) []string) *NotificationWithBackoff_Via_Call

type NotificationWithDatabaseConnection 

type NotificationWithDatabaseConnection struct {
	mock.Mock
}

NotificationWithDatabaseConnection is an autogenerated mock type for the NotificationWithDatabaseConnection type

func NewNotificationWithDatabaseConnection 

func NewNotificationWithDatabaseConnection(t interface {
	mock.TestingT
	Cleanup(func())
}) *NotificationWithDatabaseConnection

NewNotificationWithDatabaseConnection creates a new instance of NotificationWithDatabaseConnection. 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 (*NotificationWithDatabaseConnection) DatabaseConnection 

func (_m *NotificationWithDatabaseConnection) DatabaseConnection() string

DatabaseConnection provides a mock function with no fields

func (*NotificationWithDatabaseConnection) EXPECT 

func (_m *NotificationWithDatabaseConnection) EXPECT() *NotificationWithDatabaseConnection_Expecter

func (*NotificationWithDatabaseConnection) Via 

func (_m *NotificationWithDatabaseConnection) Via(notifiable notification.Notifiable) []string

Via provides a mock function with given fields: notifiable

type NotificationWithDatabaseConnection_DatabaseConnection_Call 

type NotificationWithDatabaseConnection_DatabaseConnection_Call struct {
	*mock.Call
}

NotificationWithDatabaseConnection_DatabaseConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DatabaseConnection'

func (*NotificationWithDatabaseConnection_DatabaseConnection_Call) Return 

func (_c *NotificationWithDatabaseConnection_DatabaseConnection_Call) Return(_a0 string) *NotificationWithDatabaseConnection_DatabaseConnection_Call

func (*NotificationWithDatabaseConnection_DatabaseConnection_Call) Run 

func (_c *NotificationWithDatabaseConnection_DatabaseConnection_Call) Run(run func()) *NotificationWithDatabaseConnection_DatabaseConnection_Call

func (*NotificationWithDatabaseConnection_DatabaseConnection_Call) RunAndReturn 

func (_c *NotificationWithDatabaseConnection_DatabaseConnection_Call) RunAndReturn(run func() string) *NotificationWithDatabaseConnection_DatabaseConnection_Call

type NotificationWithDatabaseConnection_Expecter 

type NotificationWithDatabaseConnection_Expecter struct {
	// contains filtered or unexported fields
}

func (*NotificationWithDatabaseConnection_Expecter) DatabaseConnection 

func (_e *NotificationWithDatabaseConnection_Expecter) DatabaseConnection() *NotificationWithDatabaseConnection_DatabaseConnection_Call

DatabaseConnection is a helper method to define mock.On call

func (*NotificationWithDatabaseConnection_Expecter) Via 

func (_e *NotificationWithDatabaseConnection_Expecter) Via(notifiable interface{}) *NotificationWithDatabaseConnection_Via_Call

Via is a helper method to define mock.On call

  • notifiable notification.Notifiable

type NotificationWithDatabaseConnection_Via_Call 

type NotificationWithDatabaseConnection_Via_Call struct {
	*mock.Call
}

NotificationWithDatabaseConnection_Via_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Via'

func (*NotificationWithDatabaseConnection_Via_Call) Return 

func (_c *NotificationWithDatabaseConnection_Via_Call) Return(_a0 []string) *NotificationWithDatabaseConnection_Via_Call

func (*NotificationWithDatabaseConnection_Via_Call) Run 

func (_c *NotificationWithDatabaseConnection_Via_Call) Run(run func(notifiable notification.Notifiable)) *NotificationWithDatabaseConnection_Via_Call

func (*NotificationWithDatabaseConnection_Via_Call) RunAndReturn 

func (_c *NotificationWithDatabaseConnection_Via_Call) RunAndReturn(run func(notification.Notifiable) []string) *NotificationWithDatabaseConnection_Via_Call

type NotificationWithID 

type NotificationWithID struct {
	mock.Mock
}

NotificationWithID is an autogenerated mock type for the NotificationWithID type

func NewNotificationWithID 

func NewNotificationWithID(t interface {
	mock.TestingT
	Cleanup(func())
}) *NotificationWithID

NewNotificationWithID creates a new instance of NotificationWithID. 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 (*NotificationWithID) EXPECT 

func (_m *NotificationWithID) EXPECT() *NotificationWithID_Expecter

func (*NotificationWithID) ID 

func (_m *NotificationWithID) ID() string

ID provides a mock function with no fields

func (*NotificationWithID) Via 

func (_m *NotificationWithID) Via(notifiable notification.Notifiable) []string

Via provides a mock function with given fields: notifiable

type NotificationWithID_Expecter 

type NotificationWithID_Expecter struct {
	// contains filtered or unexported fields
}

func (*NotificationWithID_Expecter) ID 

func (_e *NotificationWithID_Expecter) ID() *NotificationWithID_ID_Call

ID is a helper method to define mock.On call

func (*NotificationWithID_Expecter) Via 

func (_e *NotificationWithID_Expecter) Via(notifiable interface{}) *NotificationWithID_Via_Call

Via is a helper method to define mock.On call

  • notifiable notification.Notifiable

type NotificationWithID_ID_Call 

type NotificationWithID_ID_Call struct {
	*mock.Call
}

NotificationWithID_ID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ID'

func (*NotificationWithID_ID_Call) Return 

func (_c *NotificationWithID_ID_Call) Return(_a0 string) *NotificationWithID_ID_Call

func (*NotificationWithID_ID_Call) Run 

func (_c *NotificationWithID_ID_Call) Run(run func()) *NotificationWithID_ID_Call

func (*NotificationWithID_ID_Call) RunAndReturn 

func (_c *NotificationWithID_ID_Call) RunAndReturn(run func() string) *NotificationWithID_ID_Call

type NotificationWithID_Via_Call 

type NotificationWithID_Via_Call struct {
	*mock.Call
}

NotificationWithID_Via_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Via'

func (*NotificationWithID_Via_Call) Return 

func (_c *NotificationWithID_Via_Call) Return(_a0 []string) *NotificationWithID_Via_Call

func (*NotificationWithID_Via_Call) Run 

func (_c *NotificationWithID_Via_Call) Run(run func(notifiable notification.Notifiable)) *NotificationWithID_Via_Call

func (*NotificationWithID_Via_Call) RunAndReturn 

func (_c *NotificationWithID_Via_Call) RunAndReturn(run func(notification.Notifiable) []string) *NotificationWithID_Via_Call

type NotificationWithShouldSend 

type NotificationWithShouldSend struct {
	mock.Mock
}

NotificationWithShouldSend is an autogenerated mock type for the NotificationWithShouldSend type

func NewNotificationWithShouldSend 

func NewNotificationWithShouldSend(t interface {
	mock.TestingT
	Cleanup(func())
}) *NotificationWithShouldSend

NewNotificationWithShouldSend creates a new instance of NotificationWithShouldSend. 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 (*NotificationWithShouldSend) EXPECT 

func (_m *NotificationWithShouldSend) EXPECT() *NotificationWithShouldSend_Expecter

func (*NotificationWithShouldSend) ShouldSend 

func (_m *NotificationWithShouldSend) ShouldSend(notifiable notification.Notifiable, channel string) bool

ShouldSend provides a mock function with given fields: notifiable, channel

func (*NotificationWithShouldSend) Via 

func (_m *NotificationWithShouldSend) Via(notifiable notification.Notifiable) []string

Via provides a mock function with given fields: notifiable

type NotificationWithShouldSend_Expecter 

type NotificationWithShouldSend_Expecter struct {
	// contains filtered or unexported fields
}

func (*NotificationWithShouldSend_Expecter) ShouldSend 

func (_e *NotificationWithShouldSend_Expecter) ShouldSend(notifiable interface{}, channel interface{}) *NotificationWithShouldSend_ShouldSend_Call

ShouldSend is a helper method to define mock.On call

  • notifiable notification.Notifiable
  • channel string

func (*NotificationWithShouldSend_Expecter) Via 

func (_e *NotificationWithShouldSend_Expecter) Via(notifiable interface{}) *NotificationWithShouldSend_Via_Call

Via is a helper method to define mock.On call

  • notifiable notification.Notifiable

type NotificationWithShouldSend_ShouldSend_Call 

type NotificationWithShouldSend_ShouldSend_Call struct {
	*mock.Call
}

NotificationWithShouldSend_ShouldSend_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ShouldSend'

func (*NotificationWithShouldSend_ShouldSend_Call) Return 

func (_c *NotificationWithShouldSend_ShouldSend_Call) Return(_a0 bool) *NotificationWithShouldSend_ShouldSend_Call

func (*NotificationWithShouldSend_ShouldSend_Call) Run 

func (_c *NotificationWithShouldSend_ShouldSend_Call) Run(run func(notifiable notification.Notifiable, channel string)) *NotificationWithShouldSend_ShouldSend_Call

func (*NotificationWithShouldSend_ShouldSend_Call) RunAndReturn 

func (_c *NotificationWithShouldSend_ShouldSend_Call) RunAndReturn(run func(notification.Notifiable, string) bool) *NotificationWithShouldSend_ShouldSend_Call

type NotificationWithShouldSend_Via_Call 

type NotificationWithShouldSend_Via_Call struct {
	*mock.Call
}

NotificationWithShouldSend_Via_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Via'

func (*NotificationWithShouldSend_Via_Call) Return 

func (_c *NotificationWithShouldSend_Via_Call) Return(_a0 []string) *NotificationWithShouldSend_Via_Call

func (*NotificationWithShouldSend_Via_Call) Run 

func (_c *NotificationWithShouldSend_Via_Call) Run(run func(notifiable notification.Notifiable)) *NotificationWithShouldSend_Via_Call

func (*NotificationWithShouldSend_Via_Call) RunAndReturn 

func (_c *NotificationWithShouldSend_Via_Call) RunAndReturn(run func(notification.Notifiable) []string) *NotificationWithShouldSend_Via_Call

type NotificationWithTries 

type NotificationWithTries struct {
	mock.Mock
}

NotificationWithTries is an autogenerated mock type for the NotificationWithTries type

func NewNotificationWithTries 

func NewNotificationWithTries(t interface {
	mock.TestingT
	Cleanup(func())
}) *NotificationWithTries

NewNotificationWithTries creates a new instance of NotificationWithTries. 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 (*NotificationWithTries) EXPECT 

func (_m *NotificationWithTries) EXPECT() *NotificationWithTries_Expecter

func (*NotificationWithTries) Tries 

func (_m *NotificationWithTries) Tries(channel string) int

Tries provides a mock function with given fields: channel

func (*NotificationWithTries) Via 

func (_m *NotificationWithTries) Via(notifiable notification.Notifiable) []string

Via provides a mock function with given fields: notifiable

type NotificationWithTries_Expecter 

type NotificationWithTries_Expecter struct {
	// contains filtered or unexported fields
}

func (*NotificationWithTries_Expecter) Tries 

func (_e *NotificationWithTries_Expecter) Tries(channel interface{}) *NotificationWithTries_Tries_Call

Tries is a helper method to define mock.On call

  • channel string

func (*NotificationWithTries_Expecter) Via 

func (_e *NotificationWithTries_Expecter) Via(notifiable interface{}) *NotificationWithTries_Via_Call

Via is a helper method to define mock.On call

  • notifiable notification.Notifiable

type NotificationWithTries_Tries_Call 

type NotificationWithTries_Tries_Call struct {
	*mock.Call
}

NotificationWithTries_Tries_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Tries'

func (*NotificationWithTries_Tries_Call) Return 

func (_c *NotificationWithTries_Tries_Call) Return(_a0 int) *NotificationWithTries_Tries_Call

func (*NotificationWithTries_Tries_Call) Run 

func (_c *NotificationWithTries_Tries_Call) Run(run func(channel string)) *NotificationWithTries_Tries_Call

func (*NotificationWithTries_Tries_Call) RunAndReturn 

func (_c *NotificationWithTries_Tries_Call) RunAndReturn(run func(string) int) *NotificationWithTries_Tries_Call

type NotificationWithTries_Via_Call 

type NotificationWithTries_Via_Call struct {
	*mock.Call
}

NotificationWithTries_Via_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Via'

func (*NotificationWithTries_Via_Call) Return 

func (_c *NotificationWithTries_Via_Call) Return(_a0 []string) *NotificationWithTries_Via_Call

func (*NotificationWithTries_Via_Call) Run 

func (_c *NotificationWithTries_Via_Call) Run(run func(notifiable notification.Notifiable)) *NotificationWithTries_Via_Call

func (*NotificationWithTries_Via_Call) RunAndReturn 

func (_c *NotificationWithTries_Via_Call) RunAndReturn(run func(notification.Notifiable) []string) *NotificationWithTries_Via_Call

type Notification_Expecter 

type Notification_Expecter struct {
	// contains filtered or unexported fields
}

func (*Notification_Expecter) Via 

func (_e *Notification_Expecter) Via(notifiable interface{}) *Notification_Via_Call

Via is a helper method to define mock.On call

  • notifiable notification.Notifiable

type Notification_Via_Call 

type Notification_Via_Call struct {
	*mock.Call
}

Notification_Via_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Via'

func (*Notification_Via_Call) Return 

func (_c *Notification_Via_Call) Return(_a0 []string) *Notification_Via_Call

func (*Notification_Via_Call) Run 

func (_c *Notification_Via_Call) Run(run func(notifiable notification.Notifiable)) *Notification_Via_Call

func (*Notification_Via_Call) RunAndReturn 

func (_c *Notification_Via_Call) RunAndReturn(run func(notification.Notifiable) []string) *Notification_Via_Call

type OnDemandNotifiable 

type OnDemandNotifiable struct {
	mock.Mock
}

OnDemandNotifiable is an autogenerated mock type for the OnDemandNotifiable type

func NewOnDemandNotifiable 

func NewOnDemandNotifiable(t interface {
	mock.TestingT
	Cleanup(func())
}) *OnDemandNotifiable

NewOnDemandNotifiable creates a new instance of OnDemandNotifiable. 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 (*OnDemandNotifiable) EXPECT 

func (_m *OnDemandNotifiable) EXPECT() *OnDemandNotifiable_Expecter

func (*OnDemandNotifiable) Notify 

func (_m *OnDemandNotifiable) Notify(_a0 notification.Notification) error

Notify provides a mock function with given fields: _a0

func (*OnDemandNotifiable) NotifyNow 

func (_m *OnDemandNotifiable) NotifyNow(_a0 notification.Notification) error

NotifyNow provides a mock function with given fields: _a0

func (*OnDemandNotifiable) Route 

func (_m *OnDemandNotifiable) Route(channel string, route interface{}) notification.OnDemandNotifiable

Route provides a mock function with given fields: channel, route

func (*OnDemandNotifiable) RouteNotificationFor 

func (_m *OnDemandNotifiable) RouteNotificationFor(channel string) interface{}

RouteNotificationFor provides a mock function with given fields: channel

type OnDemandNotifiable_Expecter 

type OnDemandNotifiable_Expecter struct {
	// contains filtered or unexported fields
}

func (*OnDemandNotifiable_Expecter) Notify 

func (_e *OnDemandNotifiable_Expecter) Notify(_a0 interface{}) *OnDemandNotifiable_Notify_Call

Notify is a helper method to define mock.On call

  • _a0 notification.Notification

func (*OnDemandNotifiable_Expecter) NotifyNow 

func (_e *OnDemandNotifiable_Expecter) NotifyNow(_a0 interface{}) *OnDemandNotifiable_NotifyNow_Call

NotifyNow is a helper method to define mock.On call

  • _a0 notification.Notification

func (*OnDemandNotifiable_Expecter) Route 

func (_e *OnDemandNotifiable_Expecter) Route(channel interface{}, route interface{}) *OnDemandNotifiable_Route_Call

Route is a helper method to define mock.On call

  • channel string
  • route interface{}

func (*OnDemandNotifiable_Expecter) RouteNotificationFor 

func (_e *OnDemandNotifiable_Expecter) RouteNotificationFor(channel interface{}) *OnDemandNotifiable_RouteNotificationFor_Call

RouteNotificationFor is a helper method to define mock.On call

  • channel string

type OnDemandNotifiable_NotifyNow_Call 

type OnDemandNotifiable_NotifyNow_Call struct {
	*mock.Call
}

OnDemandNotifiable_NotifyNow_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotifyNow'

func (*OnDemandNotifiable_NotifyNow_Call) Return 

func (_c *OnDemandNotifiable_NotifyNow_Call) Return(_a0 error) *OnDemandNotifiable_NotifyNow_Call

func (*OnDemandNotifiable_NotifyNow_Call) Run 

func (_c *OnDemandNotifiable_NotifyNow_Call) Run(run func(_a0 notification.Notification)) *OnDemandNotifiable_NotifyNow_Call

func (*OnDemandNotifiable_NotifyNow_Call) RunAndReturn 

func (_c *OnDemandNotifiable_NotifyNow_Call) RunAndReturn(run func(notification.Notification) error) *OnDemandNotifiable_NotifyNow_Call

type OnDemandNotifiable_Notify_Call 

type OnDemandNotifiable_Notify_Call struct {
	*mock.Call
}

OnDemandNotifiable_Notify_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Notify'

func (*OnDemandNotifiable_Notify_Call) Return 

func (_c *OnDemandNotifiable_Notify_Call) Return(_a0 error) *OnDemandNotifiable_Notify_Call

func (*OnDemandNotifiable_Notify_Call) Run 

func (_c *OnDemandNotifiable_Notify_Call) Run(run func(_a0 notification.Notification)) *OnDemandNotifiable_Notify_Call

func (*OnDemandNotifiable_Notify_Call) RunAndReturn 

func (_c *OnDemandNotifiable_Notify_Call) RunAndReturn(run func(notification.Notification) error) *OnDemandNotifiable_Notify_Call

type OnDemandNotifiable_RouteNotificationFor_Call 

type OnDemandNotifiable_RouteNotificationFor_Call struct {
	*mock.Call
}

OnDemandNotifiable_RouteNotificationFor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RouteNotificationFor'

func (*OnDemandNotifiable_RouteNotificationFor_Call) Return 

func (_c *OnDemandNotifiable_RouteNotificationFor_Call) Return(_a0 interface{}) *OnDemandNotifiable_RouteNotificationFor_Call

func (*OnDemandNotifiable_RouteNotificationFor_Call) Run 

func (_c *OnDemandNotifiable_RouteNotificationFor_Call) Run(run func(channel string)) *OnDemandNotifiable_RouteNotificationFor_Call

func (*OnDemandNotifiable_RouteNotificationFor_Call) RunAndReturn 

func (_c *OnDemandNotifiable_RouteNotificationFor_Call) RunAndReturn(run func(string) interface{}) *OnDemandNotifiable_RouteNotificationFor_Call

type OnDemandNotifiable_Route_Call 

type OnDemandNotifiable_Route_Call struct {
	*mock.Call
}

OnDemandNotifiable_Route_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Route'

func (*OnDemandNotifiable_Route_Call) Return 

func (_c *OnDemandNotifiable_Route_Call) Return(_a0 notification.OnDemandNotifiable) *OnDemandNotifiable_Route_Call

func (*OnDemandNotifiable_Route_Call) Run 

func (_c *OnDemandNotifiable_Route_Call) Run(run func(channel string, route interface{})) *OnDemandNotifiable_Route_Call

func (*OnDemandNotifiable_Route_Call) RunAndReturn 

func (_c *OnDemandNotifiable_Route_Call) RunAndReturn(run func(string, interface{}) notification.OnDemandNotifiable) *OnDemandNotifiable_Route_Call

type ResolvableChannel 

type ResolvableChannel struct {
	mock.Mock
}

ResolvableChannel is an autogenerated mock type for the ResolvableChannel type

func NewResolvableChannel 

func NewResolvableChannel(t interface {
	mock.TestingT
	Cleanup(func())
}) *ResolvableChannel

NewResolvableChannel creates a new instance of ResolvableChannel. 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 (*ResolvableChannel) Deliver 

func (_m *ResolvableChannel) Deliver(route string, payload []byte) error

Deliver provides a mock function with given fields: route, payload

func (*ResolvableChannel) EXPECT 

func (_m *ResolvableChannel) EXPECT() *ResolvableChannel_Expecter

func (*ResolvableChannel) Name 

func (_m *ResolvableChannel) Name() string

Name provides a mock function with no fields

func (*ResolvableChannel) Resolve 

func (_m *ResolvableChannel) Resolve(notifiable notification.Notifiable, _a1 notification.Notification) (string, []byte, error)

Resolve provides a mock function with given fields: notifiable, _a1

func (*ResolvableChannel) Send 

func (_m *ResolvableChannel) Send(notifiable notification.Notifiable, _a1 notification.Notification) error

Send provides a mock function with given fields: notifiable, _a1

type ResolvableChannel_Deliver_Call 

type ResolvableChannel_Deliver_Call struct {
	*mock.Call
}

ResolvableChannel_Deliver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Deliver'

func (*ResolvableChannel_Deliver_Call) Return 

func (_c *ResolvableChannel_Deliver_Call) Return(_a0 error) *ResolvableChannel_Deliver_Call

func (*ResolvableChannel_Deliver_Call) Run 

func (_c *ResolvableChannel_Deliver_Call) Run(run func(route string, payload []byte)) *ResolvableChannel_Deliver_Call

func (*ResolvableChannel_Deliver_Call) RunAndReturn 

func (_c *ResolvableChannel_Deliver_Call) RunAndReturn(run func(string, []byte) error) *ResolvableChannel_Deliver_Call

type ResolvableChannel_Expecter 

type ResolvableChannel_Expecter struct {
	// contains filtered or unexported fields
}

func (*ResolvableChannel_Expecter) Deliver 

func (_e *ResolvableChannel_Expecter) Deliver(route interface{}, payload interface{}) *ResolvableChannel_Deliver_Call

Deliver is a helper method to define mock.On call

  • route string
  • payload []byte

func (*ResolvableChannel_Expecter) Name 

func (_e *ResolvableChannel_Expecter) Name() *ResolvableChannel_Name_Call

Name is a helper method to define mock.On call

func (*ResolvableChannel_Expecter) Resolve 

func (_e *ResolvableChannel_Expecter) Resolve(notifiable interface{}, _a1 interface{}) *ResolvableChannel_Resolve_Call

Resolve is a helper method to define mock.On call

  • notifiable notification.Notifiable
  • _a1 notification.Notification

func (*ResolvableChannel_Expecter) Send 

func (_e *ResolvableChannel_Expecter) Send(notifiable interface{}, _a1 interface{}) *ResolvableChannel_Send_Call

Send is a helper method to define mock.On call

  • notifiable notification.Notifiable
  • _a1 notification.Notification

type ResolvableChannel_Name_Call 

type ResolvableChannel_Name_Call struct {
	*mock.Call
}

ResolvableChannel_Name_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Name'

func (*ResolvableChannel_Name_Call) Return 

func (_c *ResolvableChannel_Name_Call) Return(_a0 string) *ResolvableChannel_Name_Call

func (*ResolvableChannel_Name_Call) Run 

func (_c *ResolvableChannel_Name_Call) Run(run func()) *ResolvableChannel_Name_Call

func (*ResolvableChannel_Name_Call) RunAndReturn 

func (_c *ResolvableChannel_Name_Call) RunAndReturn(run func() string) *ResolvableChannel_Name_Call

type ResolvableChannel_Resolve_Call 

type ResolvableChannel_Resolve_Call struct {
	*mock.Call
}

ResolvableChannel_Resolve_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Resolve'

func (*ResolvableChannel_Resolve_Call) Return 

func (_c *ResolvableChannel_Resolve_Call) Return(route string, payload []byte, err error) *ResolvableChannel_Resolve_Call

func (*ResolvableChannel_Resolve_Call) Run 

func (_c *ResolvableChannel_Resolve_Call) Run(run func(notifiable notification.Notifiable, _a1 notification.Notification)) *ResolvableChannel_Resolve_Call

func (*ResolvableChannel_Resolve_Call) RunAndReturn 

func (_c *ResolvableChannel_Resolve_Call) RunAndReturn(run func(notification.Notifiable, notification.Notification) (string, []byte, error)) *ResolvableChannel_Resolve_Call

type ResolvableChannel_Send_Call 

type ResolvableChannel_Send_Call struct {
	*mock.Call
}

ResolvableChannel_Send_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Send'

func (*ResolvableChannel_Send_Call) Return 

func (_c *ResolvableChannel_Send_Call) Return(_a0 error) *ResolvableChannel_Send_Call

func (*ResolvableChannel_Send_Call) Run 

func (_c *ResolvableChannel_Send_Call) Run(run func(notifiable notification.Notifiable, _a1 notification.Notification)) *ResolvableChannel_Send_Call

func (*ResolvableChannel_Send_Call) RunAndReturn 

func (_c *ResolvableChannel_Send_Call) RunAndReturn(run func(notification.Notifiable, notification.Notification) error) *ResolvableChannel_Send_Call

type ShouldQueue 

type ShouldQueue struct {
	mock.Mock
}

ShouldQueue is an autogenerated mock type for the ShouldQueue type

func NewShouldQueue 

func NewShouldQueue(t interface {
	mock.TestingT
	Cleanup(func())
}) *ShouldQueue

NewShouldQueue creates a new instance of ShouldQueue. 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 (*ShouldQueue) EXPECT 

func (_m *ShouldQueue) EXPECT() *ShouldQueue_Expecter

func (*ShouldQueue) OnConnection 

func (_m *ShouldQueue) OnConnection() string

OnConnection provides a mock function with no fields

func (*ShouldQueue) OnQueue 

func (_m *ShouldQueue) OnQueue() string

OnQueue provides a mock function with no fields

type ShouldQueue_Expecter 

type ShouldQueue_Expecter struct {
	// contains filtered or unexported fields
}

func (*ShouldQueue_Expecter) OnConnection 

func (_e *ShouldQueue_Expecter) OnConnection() *ShouldQueue_OnConnection_Call

OnConnection is a helper method to define mock.On call

func (*ShouldQueue_Expecter) OnQueue 

func (_e *ShouldQueue_Expecter) OnQueue() *ShouldQueue_OnQueue_Call

OnQueue is a helper method to define mock.On call

type ShouldQueue_OnConnection_Call 

type ShouldQueue_OnConnection_Call struct {
	*mock.Call
}

ShouldQueue_OnConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnConnection'

func (*ShouldQueue_OnConnection_Call) Return 

func (_c *ShouldQueue_OnConnection_Call) Return(_a0 string) *ShouldQueue_OnConnection_Call

func (*ShouldQueue_OnConnection_Call) Run 

func (_c *ShouldQueue_OnConnection_Call) Run(run func()) *ShouldQueue_OnConnection_Call

func (*ShouldQueue_OnConnection_Call) RunAndReturn 

func (_c *ShouldQueue_OnConnection_Call) RunAndReturn(run func() string) *ShouldQueue_OnConnection_Call

type ShouldQueue_OnQueue_Call 

type ShouldQueue_OnQueue_Call struct {
	*mock.Call
}

ShouldQueue_OnQueue_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OnQueue'

func (*ShouldQueue_OnQueue_Call) Return 

func (_c *ShouldQueue_OnQueue_Call) Return(_a0 string) *ShouldQueue_OnQueue_Call

func (*ShouldQueue_OnQueue_Call) Run 

func (_c *ShouldQueue_OnQueue_Call) Run(run func()) *ShouldQueue_OnQueue_Call

func (*ShouldQueue_OnQueue_Call) RunAndReturn 

func (_c *ShouldQueue_OnQueue_Call) RunAndReturn(run func() string) *ShouldQueue_OnQueue_Call

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.