Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

mocks

package

Go to main page

Versions in this module

v1

v1.0.0

Dec 6, 2023

v0

v0.0.2

Dec 2, 2023

v0.0.1

Nov 10, 2023

Changes in this version

+ type Client struct

+ func NewClient(t interface{ ... }) *Client

+ func (_m *Client) AddRoute(topic string, callback mqtt.MessageHandler)

+ func (_m *Client) Connect() mqtt.Token

+ func (_m *Client) Disconnect(quiesce uint)

+ func (_m *Client) EXPECT() *Client_Expecter

+ func (_m *Client) IsConnected() bool

+ func (_m *Client) IsConnectionOpen() bool

+ func (_m *Client) OptionsReader() mqtt.ClientOptionsReader

+ func (_m *Client) Publish(topic string, qos byte, retained bool, payload interface{}) mqtt.Token

+ func (_m *Client) Subscribe(topic string, qos byte, callback mqtt.MessageHandler) mqtt.Token

+ func (_m *Client) SubscribeMultiple(filters map[string]byte, callback mqtt.MessageHandler) mqtt.Token

+ func (_m *Client) Unsubscribe(topics ...string) mqtt.Token

+ type Client_AddRoute_Call struct

+ func (_c *Client_AddRoute_Call) Return() *Client_AddRoute_Call

+ func (_c *Client_AddRoute_Call) Run(run func(topic string, callback mqtt.MessageHandler)) *Client_AddRoute_Call

+ func (_c *Client_AddRoute_Call) RunAndReturn(run func(string, mqtt.MessageHandler)) *Client_AddRoute_Call

+ type Client_Connect_Call struct

+ func (_c *Client_Connect_Call) Return(_a0 mqtt.Token) *Client_Connect_Call

+ func (_c *Client_Connect_Call) Run(run func()) *Client_Connect_Call

+ func (_c *Client_Connect_Call) RunAndReturn(run func() mqtt.Token) *Client_Connect_Call

+ type Client_Disconnect_Call struct

+ func (_c *Client_Disconnect_Call) Return() *Client_Disconnect_Call

+ func (_c *Client_Disconnect_Call) Run(run func(quiesce uint)) *Client_Disconnect_Call

+ func (_c *Client_Disconnect_Call) RunAndReturn(run func(uint)) *Client_Disconnect_Call

+ type Client_Expecter struct

+ func (_e *Client_Expecter) AddRoute(topic interface{}, callback interface{}) *Client_AddRoute_Call

+ func (_e *Client_Expecter) Connect() *Client_Connect_Call

+ func (_e *Client_Expecter) Disconnect(quiesce interface{}) *Client_Disconnect_Call

+ func (_e *Client_Expecter) IsConnected() *Client_IsConnected_Call

+ func (_e *Client_Expecter) IsConnectionOpen() *Client_IsConnectionOpen_Call

+ func (_e *Client_Expecter) OptionsReader() *Client_OptionsReader_Call

+ func (_e *Client_Expecter) Publish(topic interface{}, qos interface{}, retained interface{}, payload interface{}) *Client_Publish_Call

+ func (_e *Client_Expecter) Subscribe(topic interface{}, qos interface{}, callback interface{}) *Client_Subscribe_Call

+ func (_e *Client_Expecter) SubscribeMultiple(filters interface{}, callback interface{}) *Client_SubscribeMultiple_Call

+ func (_e *Client_Expecter) Unsubscribe(topics ...interface{}) *Client_Unsubscribe_Call

+ type Client_IsConnected_Call struct

+ func (_c *Client_IsConnected_Call) Return(_a0 bool) *Client_IsConnected_Call

+ func (_c *Client_IsConnected_Call) Run(run func()) *Client_IsConnected_Call

+ func (_c *Client_IsConnected_Call) RunAndReturn(run func() bool) *Client_IsConnected_Call

+ type Client_IsConnectionOpen_Call struct

+ func (_c *Client_IsConnectionOpen_Call) Return(_a0 bool) *Client_IsConnectionOpen_Call

+ func (_c *Client_IsConnectionOpen_Call) Run(run func()) *Client_IsConnectionOpen_Call

+ func (_c *Client_IsConnectionOpen_Call) RunAndReturn(run func() bool) *Client_IsConnectionOpen_Call

+ type Client_OptionsReader_Call struct

+ func (_c *Client_OptionsReader_Call) Return(_a0 mqtt.ClientOptionsReader) *Client_OptionsReader_Call

+ func (_c *Client_OptionsReader_Call) Run(run func()) *Client_OptionsReader_Call

+ func (_c *Client_OptionsReader_Call) RunAndReturn(run func() mqtt.ClientOptionsReader) *Client_OptionsReader_Call

+ type Client_Publish_Call struct

+ func (_c *Client_Publish_Call) Return(_a0 mqtt.Token) *Client_Publish_Call

+ func (_c *Client_Publish_Call) Run(run func(topic string, qos byte, retained bool, payload interface{})) *Client_Publish_Call

+ func (_c *Client_Publish_Call) RunAndReturn(run func(string, byte, bool, interface{}) mqtt.Token) *Client_Publish_Call

+ type Client_SubscribeMultiple_Call struct

+ func (_c *Client_SubscribeMultiple_Call) Return(_a0 mqtt.Token) *Client_SubscribeMultiple_Call

+ func (_c *Client_SubscribeMultiple_Call) Run(run func(filters map[string]byte, callback mqtt.MessageHandler)) *Client_SubscribeMultiple_Call

+ func (_c *Client_SubscribeMultiple_Call) RunAndReturn(run func(map[string]byte, mqtt.MessageHandler) mqtt.Token) *Client_SubscribeMultiple_Call

+ type Client_Subscribe_Call struct

+ func (_c *Client_Subscribe_Call) Return(_a0 mqtt.Token) *Client_Subscribe_Call

+ func (_c *Client_Subscribe_Call) Run(run func(topic string, qos byte, callback mqtt.MessageHandler)) *Client_Subscribe_Call

+ func (_c *Client_Subscribe_Call) RunAndReturn(run func(string, byte, mqtt.MessageHandler) mqtt.Token) *Client_Subscribe_Call

+ type Client_Unsubscribe_Call struct

+ func (_c *Client_Unsubscribe_Call) Return(_a0 mqtt.Token) *Client_Unsubscribe_Call

+ func (_c *Client_Unsubscribe_Call) Run(run func(topics ...string)) *Client_Unsubscribe_Call

+ func (_c *Client_Unsubscribe_Call) RunAndReturn(run func(...string) mqtt.Token) *Client_Unsubscribe_Call

+ type GDO struct

+ func NewGDO(t interface{ ... }) *GDO

+ func (_m *GDO) EXPECT() *GDO_Expecter

+ func (_m *GDO) ProcessShutdown()

+ func (_m *GDO) SetGarageDoor(action string) error

+ type GDO_Expecter struct

+ func (_e *GDO_Expecter) ProcessShutdown() *GDO_ProcessShutdown_Call

+ func (_e *GDO_Expecter) SetGarageDoor(action interface{}) *GDO_SetGarageDoor_Call

+ type GDO_ProcessShutdown_Call struct

+ func (_c *GDO_ProcessShutdown_Call) Return() *GDO_ProcessShutdown_Call

+ func (_c *GDO_ProcessShutdown_Call) Run(run func()) *GDO_ProcessShutdown_Call

+ func (_c *GDO_ProcessShutdown_Call) RunAndReturn(run func()) *GDO_ProcessShutdown_Call

+ type GDO_SetGarageDoor_Call struct

+ func (_c *GDO_SetGarageDoor_Call) Return(err error) *GDO_SetGarageDoor_Call

+ func (_c *GDO_SetGarageDoor_Call) Run(run func(action string)) *GDO_SetGarageDoor_Call

+ func (_c *GDO_SetGarageDoor_Call) RunAndReturn(run func(string) error) *GDO_SetGarageDoor_Call

+ type MyqSessionInterface struct

+ func NewMyqSessionInterface(t interface{ ... }) *MyqSessionInterface

+ func (_m *MyqSessionInterface) DeviceState(serialNumber string) (string, error)

+ func (_m *MyqSessionInterface) EXPECT() *MyqSessionInterface_Expecter

+ func (_m *MyqSessionInterface) GetToken() string

+ func (_m *MyqSessionInterface) Login() error

+ func (_m *MyqSessionInterface) New()

+ func (_m *MyqSessionInterface) SetDoorState(serialNumber string, action string) error

+ func (_m *MyqSessionInterface) SetPassword(_a0 string)

+ func (_m *MyqSessionInterface) SetToken(_a0 string)

+ func (_m *MyqSessionInterface) SetUsername(_a0 string)

+ type MyqSessionInterface_DeviceState_Call struct

+ func (_c *MyqSessionInterface_DeviceState_Call) Return(_a0 string, _a1 error) *MyqSessionInterface_DeviceState_Call

+ func (_c *MyqSessionInterface_DeviceState_Call) Run(run func(serialNumber string)) *MyqSessionInterface_DeviceState_Call

+ func (_c *MyqSessionInterface_DeviceState_Call) RunAndReturn(run func(string) (string, error)) *MyqSessionInterface_DeviceState_Call

+ type MyqSessionInterface_Expecter struct

+ func (_e *MyqSessionInterface_Expecter) DeviceState(serialNumber interface{}) *MyqSessionInterface_DeviceState_Call

+ func (_e *MyqSessionInterface_Expecter) GetToken() *MyqSessionInterface_GetToken_Call

+ func (_e *MyqSessionInterface_Expecter) Login() *MyqSessionInterface_Login_Call

+ func (_e *MyqSessionInterface_Expecter) New() *MyqSessionInterface_New_Call

+ func (_e *MyqSessionInterface_Expecter) SetDoorState(serialNumber interface{}, action interface{}) *MyqSessionInterface_SetDoorState_Call

+ func (_e *MyqSessionInterface_Expecter) SetPassword(_a0 interface{}) *MyqSessionInterface_SetPassword_Call

+ func (_e *MyqSessionInterface_Expecter) SetToken(_a0 interface{}) *MyqSessionInterface_SetToken_Call

+ func (_e *MyqSessionInterface_Expecter) SetUsername(_a0 interface{}) *MyqSessionInterface_SetUsername_Call

+ type MyqSessionInterface_GetToken_Call struct

+ func (_c *MyqSessionInterface_GetToken_Call) Return(_a0 string) *MyqSessionInterface_GetToken_Call

+ func (_c *MyqSessionInterface_GetToken_Call) Run(run func()) *MyqSessionInterface_GetToken_Call

+ func (_c *MyqSessionInterface_GetToken_Call) RunAndReturn(run func() string) *MyqSessionInterface_GetToken_Call

+ type MyqSessionInterface_Login_Call struct

+ func (_c *MyqSessionInterface_Login_Call) Return(_a0 error) *MyqSessionInterface_Login_Call

+ func (_c *MyqSessionInterface_Login_Call) Run(run func()) *MyqSessionInterface_Login_Call

+ func (_c *MyqSessionInterface_Login_Call) RunAndReturn(run func() error) *MyqSessionInterface_Login_Call

+ type MyqSessionInterface_New_Call struct

+ func (_c *MyqSessionInterface_New_Call) Return() *MyqSessionInterface_New_Call

+ func (_c *MyqSessionInterface_New_Call) Run(run func()) *MyqSessionInterface_New_Call

+ func (_c *MyqSessionInterface_New_Call) RunAndReturn(run func()) *MyqSessionInterface_New_Call

+ type MyqSessionInterface_SetDoorState_Call struct

+ func (_c *MyqSessionInterface_SetDoorState_Call) Return(_a0 error) *MyqSessionInterface_SetDoorState_Call

+ func (_c *MyqSessionInterface_SetDoorState_Call) Run(run func(serialNumber string, action string)) *MyqSessionInterface_SetDoorState_Call

+ func (_c *MyqSessionInterface_SetDoorState_Call) RunAndReturn(run func(string, string) error) *MyqSessionInterface_SetDoorState_Call

+ type MyqSessionInterface_SetPassword_Call struct

+ func (_c *MyqSessionInterface_SetPassword_Call) Return() *MyqSessionInterface_SetPassword_Call

+ func (_c *MyqSessionInterface_SetPassword_Call) Run(run func(_a0 string)) *MyqSessionInterface_SetPassword_Call

+ func (_c *MyqSessionInterface_SetPassword_Call) RunAndReturn(run func(string)) *MyqSessionInterface_SetPassword_Call

+ type MyqSessionInterface_SetToken_Call struct

+ func (_c *MyqSessionInterface_SetToken_Call) Return() *MyqSessionInterface_SetToken_Call

+ func (_c *MyqSessionInterface_SetToken_Call) Run(run func(_a0 string)) *MyqSessionInterface_SetToken_Call

+ func (_c *MyqSessionInterface_SetToken_Call) RunAndReturn(run func(string)) *MyqSessionInterface_SetToken_Call

+ type MyqSessionInterface_SetUsername_Call struct

+ func (_c *MyqSessionInterface_SetUsername_Call) Return() *MyqSessionInterface_SetUsername_Call

+ func (_c *MyqSessionInterface_SetUsername_Call) Run(run func(_a0 string)) *MyqSessionInterface_SetUsername_Call

+ func (_c *MyqSessionInterface_SetUsername_Call) RunAndReturn(run func(string)) *MyqSessionInterface_SetUsername_Call

+ type Token struct

+ func NewToken(t interface{ ... }) *Token

+ func (_m *Token) Done() <-chan struct{}

+ func (_m *Token) EXPECT() *Token_Expecter

+ func (_m *Token) Error() error

+ func (_m *Token) Wait() bool

+ func (_m *Token) WaitTimeout(_a0 time.Duration) bool

+ type Token_Done_Call struct

+ func (_c *Token_Done_Call) Return(_a0 <-chan struct{}) *Token_Done_Call

+ func (_c *Token_Done_Call) Run(run func()) *Token_Done_Call

+ func (_c *Token_Done_Call) RunAndReturn(run func() <-chan struct{}) *Token_Done_Call

+ type Token_Error_Call struct

+ func (_c *Token_Error_Call) Return(_a0 error) *Token_Error_Call

+ func (_c *Token_Error_Call) Run(run func()) *Token_Error_Call

+ func (_c *Token_Error_Call) RunAndReturn(run func() error) *Token_Error_Call

+ type Token_Expecter struct

+ func (_e *Token_Expecter) Done() *Token_Done_Call

+ func (_e *Token_Expecter) Error() *Token_Error_Call

+ func (_e *Token_Expecter) Wait() *Token_Wait_Call

+ func (_e *Token_Expecter) WaitTimeout(_a0 interface{}) *Token_WaitTimeout_Call

+ type Token_WaitTimeout_Call struct

+ func (_c *Token_WaitTimeout_Call) Return(_a0 bool) *Token_WaitTimeout_Call

+ func (_c *Token_WaitTimeout_Call) Run(run func(_a0 time.Duration)) *Token_WaitTimeout_Call

+ func (_c *Token_WaitTimeout_Call) RunAndReturn(run func(time.Duration) bool) *Token_WaitTimeout_Call

+ type Token_Wait_Call struct

+ func (_c *Token_Wait_Call) Return(_a0 bool) *Token_Wait_Call

+ func (_c *Token_Wait_Call) Run(run func()) *Token_Wait_Call

+ func (_c *Token_Wait_Call) RunAndReturn(run func() bool) *Token_Wait_Call