redis

package
v1.1.6 Latest Latest
Warning

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

 Go to latest Published: Sep 12, 2025 License: Apache-2.0 Imports: 16 Imported by: 1

Documentation

Index

Constants

View Source 
const (
	KeepTTL = redis.KeepTTL // Used to retain the existing TTL (time to live) of a key when modifying its value in Redis

)

Variables

View Source 
var (
	ErrFailToSetValue = newError("fail to set value")

	ErrUnsupportedInputType = newError("unsupported input type")
)

Functions

This section is empty.

Types

type ChannelOption added in v1.1.5 

type ChannelOption struct {
	ChannelSize         int
	HealthCheckInterval time.Duration
	SendTimeout         time.Duration
}

type Client 

type Client interface {
	Ping(ctx context.Context) error

	Do(ctx context.Context, cmd string, args ...interface{}) (interface{}, error)

	DoInBatch(ctx context.Context, fn func(cmder Commander) error) error

	Close() error

	Delete(ctx context.Context, key string) (int64, error)

	Expire(ctx context.Context, key string, expiration time.Duration) (bool, error)

	SetString(ctx context.Context, key string, value string, expiration time.Duration) error

	SetStringIfNotExist(ctx context.Context, key string, value string, expiration time.Duration) error

	SetStringIfExist(ctx context.Context, key string, value string, expiration time.Duration) error

	SetInt(ctx context.Context, key string, value int64, expiration time.Duration) error

	SetIntIfNotExist(ctx context.Context, key string, value int64, expiration time.Duration) error

	SetIntIfExist(ctx context.Context, key string, value int64, expiration time.Duration) error

	IncrementBy(ctx context.Context, key string, value int64) (int64, error)

	DecrementBy(ctx context.Context, key string, value int64) (int64, error)

	SetFloat(ctx context.Context, key string, value float64, expiration time.Duration) error

	SetFloatIfNotExist(ctx context.Context, key string, value float64, expiration time.Duration) error

	SetFloatIfExist(ctx context.Context, key string, value float64, expiration time.Duration) error

	IncrementFloatBy(ctx context.Context, key string, value float64) (float64, error)

	GetString(ctx context.Context, key string) (string, error)

	GetInt(ctx context.Context, key string) (int64, error)

	GetFloat(ctx context.Context, key string) (float64, error)

	HashSet(ctx context.Context, key string, value interface{}) error

	HashGetAll(ctx context.Context, key string, out interface{}) error

	HashGetField(ctx context.Context, key string, field string, out interface{}) error

	Publish(ctx context.Context, channel string, message interface{}) error

	Subscribe(ctx context.Context, channels []string, handler MessageHandler) Subscriber
}

Client represents redis client interface

func NewClient 

func NewClient(url string) (Client, error)

NewClient creates new redis client

Examples: 

client, err := NewClient("redis://user:password@localhost:6379/0?protocol=3")

func NewClientWithTLS 

func NewClientWithTLS(url string, tlsConfig *tls.Config) (Client, error)

NewClientWithTLS creates new redis client with TLS configuration

type Commander 

type Commander interface {
	Discard()

	Execute(ctx context.Context) error

	Delete(ctx context.Context, key string) (int64, error)

	Expire(ctx context.Context, key string, expiration time.Duration) (bool, error)

	SetString(ctx context.Context, key string, value string, expiration time.Duration) error

	SetStringIfNotExist(ctx context.Context, key string, value string, expiration time.Duration) error

	SetStringIfExist(ctx context.Context, key string, value string, expiration time.Duration) error

	GetString(ctx context.Context, key string) (string, error)

	SetInt(ctx context.Context, key string, value int64, expiration time.Duration) error

	SetIntIfNotExist(ctx context.Context, key string, value int64, expiration time.Duration) error

	SetIntIfExist(ctx context.Context, key string, value int64, expiration time.Duration) error

	IncrementBy(ctx context.Context, key string, value int64) (int64, error)

	DecrementBy(ctx context.Context, key string, value int64) (int64, error)

	GetInt(ctx context.Context, key string) (int64, error)

	SetFloat(ctx context.Context, key string, value float64, expiration time.Duration) error

	SetFloatIfNotExist(ctx context.Context, key string, value float64, expiration time.Duration) error

	SetFloatIfExist(ctx context.Context, key string, value float64, expiration time.Duration) error

	IncrementFloatBy(ctx context.Context, key string, value float64) (float64, error)

	GetFloat(ctx context.Context, key string) (float64, error)

	HashSet(ctx context.Context, key string, value interface{}) error

	HashGetAll(ctx context.Context, key string, out interface{}) error

	HashGetField(ctx context.Context, key string, field string, out interface{}) error
}

Commander represents redis pipeline supported commands

type Error 

type Error string

Error represents an error in redis package suppose to determine expected or unexpected error in another service

func (Error) Error 

func (e Error) Error() string

type Message added in v1.1.3 

type Message struct {
	Channel      string
	Pattern      string
	Payload      string
	PayloadSlice []string
}

type MessageHandler added in v1.1.3 

type MessageHandler func(ctx context.Context, msg Message) error

type MockClient 

type MockClient struct {
	mock.Mock
}

MockClient is an autogenerated mock type for the Client type

func NewMockClient 

func NewMockClient(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockClient

NewMockClient creates a new instance of MockClient. 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 (*MockClient) Close 

func (_mock *MockClient) Close() error

Close provides a mock function for the type MockClient

func (*MockClient) DecrementBy 

func (_mock *MockClient) DecrementBy(ctx context.Context, key string, value int64) (int64, error)

DecrementBy provides a mock function for the type MockClient

func (*MockClient) Delete 

func (_mock *MockClient) Delete(ctx context.Context, key string) (int64, error)

Delete provides a mock function for the type MockClient

func (*MockClient) Do 

func (_mock *MockClient) Do(ctx context.Context, cmd string, args ...interface{}) (interface{}, error)

Do provides a mock function for the type MockClient

func (*MockClient) DoInBatch 

func (_mock *MockClient) DoInBatch(ctx context.Context, fn func(cmder Commander) error) error

DoInBatch provides a mock function for the type MockClient

func (*MockClient) EXPECT 

func (_m *MockClient) EXPECT() *MockClient_Expecter

func (*MockClient) Expire 

func (_mock *MockClient) Expire(ctx context.Context, key string, expiration time.Duration) (bool, error)

Expire provides a mock function for the type MockClient

func (*MockClient) GetFloat 

func (_mock *MockClient) GetFloat(ctx context.Context, key string) (float64, error)

GetFloat provides a mock function for the type MockClient

func (*MockClient) GetInt 

func (_mock *MockClient) GetInt(ctx context.Context, key string) (int64, error)

GetInt provides a mock function for the type MockClient

func (*MockClient) GetString 

func (_mock *MockClient) GetString(ctx context.Context, key string) (string, error)

GetString provides a mock function for the type MockClient

func (*MockClient) HashGetAll 

func (_mock *MockClient) HashGetAll(ctx context.Context, key string, out interface{}) error

HashGetAll provides a mock function for the type MockClient

func (*MockClient) HashGetField 

func (_mock *MockClient) HashGetField(ctx context.Context, key string, field string, out interface{}) error

HashGetField provides a mock function for the type MockClient

func (*MockClient) HashSet 

func (_mock *MockClient) HashSet(ctx context.Context, key string, value interface{}) error

HashSet provides a mock function for the type MockClient

func (*MockClient) IncrementBy 

func (_mock *MockClient) IncrementBy(ctx context.Context, key string, value int64) (int64, error)

IncrementBy provides a mock function for the type MockClient

func (*MockClient) IncrementFloatBy 

func (_mock *MockClient) IncrementFloatBy(ctx context.Context, key string, value float64) (float64, error)

IncrementFloatBy provides a mock function for the type MockClient

func (*MockClient) Ping 

func (_mock *MockClient) Ping(ctx context.Context) error

Ping provides a mock function for the type MockClient

func (*MockClient) Publish added in v1.1.6 

func (_mock *MockClient) Publish(ctx context.Context, channel string, message interface{}) error

Publish provides a mock function for the type MockClient

func (*MockClient) SetFloat 

func (_mock *MockClient) SetFloat(ctx context.Context, key string, value float64, expiration time.Duration) error

SetFloat provides a mock function for the type MockClient

func (*MockClient) SetFloatIfExist 

func (_mock *MockClient) SetFloatIfExist(ctx context.Context, key string, value float64, expiration time.Duration) error

SetFloatIfExist provides a mock function for the type MockClient

func (*MockClient) SetFloatIfNotExist 

func (_mock *MockClient) SetFloatIfNotExist(ctx context.Context, key string, value float64, expiration time.Duration) error

SetFloatIfNotExist provides a mock function for the type MockClient

func (*MockClient) SetInt 

func (_mock *MockClient) SetInt(ctx context.Context, key string, value int64, expiration time.Duration) error

SetInt provides a mock function for the type MockClient

func (*MockClient) SetIntIfExist 

func (_mock *MockClient) SetIntIfExist(ctx context.Context, key string, value int64, expiration time.Duration) error

SetIntIfExist provides a mock function for the type MockClient

func (*MockClient) SetIntIfNotExist 

func (_mock *MockClient) SetIntIfNotExist(ctx context.Context, key string, value int64, expiration time.Duration) error

SetIntIfNotExist provides a mock function for the type MockClient

func (*MockClient) SetString 

func (_mock *MockClient) SetString(ctx context.Context, key string, value string, expiration time.Duration) error

SetString provides a mock function for the type MockClient

func (*MockClient) SetStringIfExist 

func (_mock *MockClient) SetStringIfExist(ctx context.Context, key string, value string, expiration time.Duration) error

SetStringIfExist provides a mock function for the type MockClient

func (*MockClient) SetStringIfNotExist 

func (_mock *MockClient) SetStringIfNotExist(ctx context.Context, key string, value string, expiration time.Duration) error

SetStringIfNotExist provides a mock function for the type MockClient

func (*MockClient) Subscribe added in v1.1.6 

func (_mock *MockClient) Subscribe(ctx context.Context, channels []string, handler MessageHandler) Subscriber

Subscribe provides a mock function for the type MockClient

type MockClient_Close_Call 

type MockClient_Close_Call struct {
	*mock.Call
}

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

func (*MockClient_Close_Call) Return 

func (_c *MockClient_Close_Call) Return(err error) *MockClient_Close_Call

func (*MockClient_Close_Call) Run 

func (_c *MockClient_Close_Call) Run(run func()) *MockClient_Close_Call

func (*MockClient_Close_Call) RunAndReturn 

func (_c *MockClient_Close_Call) RunAndReturn(run func() error) *MockClient_Close_Call

type MockClient_DecrementBy_Call 

type MockClient_DecrementBy_Call struct {
	*mock.Call
}

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

func (*MockClient_DecrementBy_Call) Return 

func (_c *MockClient_DecrementBy_Call) Return(n int64, err error) *MockClient_DecrementBy_Call

func (*MockClient_DecrementBy_Call) Run 

func (_c *MockClient_DecrementBy_Call) Run(run func(ctx context.Context, key string, value int64)) *MockClient_DecrementBy_Call

func (*MockClient_DecrementBy_Call) RunAndReturn 

func (_c *MockClient_DecrementBy_Call) RunAndReturn(run func(ctx context.Context, key string, value int64) (int64, error)) *MockClient_DecrementBy_Call

type MockClient_Delete_Call 

type MockClient_Delete_Call struct {
	*mock.Call
}

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

func (*MockClient_Delete_Call) Return 

func (_c *MockClient_Delete_Call) Return(n int64, err error) *MockClient_Delete_Call

func (*MockClient_Delete_Call) Run 

func (_c *MockClient_Delete_Call) Run(run func(ctx context.Context, key string)) *MockClient_Delete_Call

func (*MockClient_Delete_Call) RunAndReturn 

func (_c *MockClient_Delete_Call) RunAndReturn(run func(ctx context.Context, key string) (int64, error)) *MockClient_Delete_Call

type MockClient_DoInBatch_Call 

type MockClient_DoInBatch_Call struct {
	*mock.Call
}

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

func (*MockClient_DoInBatch_Call) Return 

func (_c *MockClient_DoInBatch_Call) Return(err error) *MockClient_DoInBatch_Call

func (*MockClient_DoInBatch_Call) Run 

func (_c *MockClient_DoInBatch_Call) Run(run func(ctx context.Context, fn func(cmder Commander) error)) *MockClient_DoInBatch_Call

func (*MockClient_DoInBatch_Call) RunAndReturn 

func (_c *MockClient_DoInBatch_Call) RunAndReturn(run func(ctx context.Context, fn func(cmder Commander) error) error) *MockClient_DoInBatch_Call

type MockClient_Do_Call 

type MockClient_Do_Call struct {
	*mock.Call
}

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

func (*MockClient_Do_Call) Return 

func (_c *MockClient_Do_Call) Return(ifaceVal interface{}, err error) *MockClient_Do_Call

func (*MockClient_Do_Call) Run 

func (_c *MockClient_Do_Call) Run(run func(ctx context.Context, cmd string, args ...interface{})) *MockClient_Do_Call

func (*MockClient_Do_Call) RunAndReturn 

func (_c *MockClient_Do_Call) RunAndReturn(run func(ctx context.Context, cmd string, args ...interface{}) (interface{}, error)) *MockClient_Do_Call

type MockClient_Expecter 

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

func (*MockClient_Expecter) Close 

func (_e *MockClient_Expecter) Close() *MockClient_Close_Call

Close is a helper method to define mock.On call

func (*MockClient_Expecter) DecrementBy 

func (_e *MockClient_Expecter) DecrementBy(ctx interface{}, key interface{}, value interface{}) *MockClient_DecrementBy_Call

DecrementBy is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value int64

func (*MockClient_Expecter) Delete 

func (_e *MockClient_Expecter) Delete(ctx interface{}, key interface{}) *MockClient_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*MockClient_Expecter) Do 

func (_e *MockClient_Expecter) Do(ctx interface{}, cmd interface{}, args ...interface{}) *MockClient_Do_Call

Do is a helper method to define mock.On call

  • ctx context.Context
  • cmd string
  • args ...interface{}

func (*MockClient_Expecter) DoInBatch 

func (_e *MockClient_Expecter) DoInBatch(ctx interface{}, fn interface{}) *MockClient_DoInBatch_Call

DoInBatch is a helper method to define mock.On call

  • ctx context.Context
  • fn func(cmder Commander) error

func (*MockClient_Expecter) Expire 

func (_e *MockClient_Expecter) Expire(ctx interface{}, key interface{}, expiration interface{}) *MockClient_Expire_Call

Expire is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • expiration time.Duration

func (*MockClient_Expecter) GetFloat 

func (_e *MockClient_Expecter) GetFloat(ctx interface{}, key interface{}) *MockClient_GetFloat_Call

GetFloat is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*MockClient_Expecter) GetInt 

func (_e *MockClient_Expecter) GetInt(ctx interface{}, key interface{}) *MockClient_GetInt_Call

GetInt is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*MockClient_Expecter) GetString 

func (_e *MockClient_Expecter) GetString(ctx interface{}, key interface{}) *MockClient_GetString_Call

GetString is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*MockClient_Expecter) HashGetAll 

func (_e *MockClient_Expecter) HashGetAll(ctx interface{}, key interface{}, out interface{}) *MockClient_HashGetAll_Call

HashGetAll is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • out interface{}

func (*MockClient_Expecter) HashGetField 

func (_e *MockClient_Expecter) HashGetField(ctx interface{}, key interface{}, field interface{}, out interface{}) *MockClient_HashGetField_Call

HashGetField is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • field string
  • out interface{}

func (*MockClient_Expecter) HashSet 

func (_e *MockClient_Expecter) HashSet(ctx interface{}, key interface{}, value interface{}) *MockClient_HashSet_Call

HashSet is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value interface{}

func (*MockClient_Expecter) IncrementBy 

func (_e *MockClient_Expecter) IncrementBy(ctx interface{}, key interface{}, value interface{}) *MockClient_IncrementBy_Call

IncrementBy is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value int64

func (*MockClient_Expecter) IncrementFloatBy 

func (_e *MockClient_Expecter) IncrementFloatBy(ctx interface{}, key interface{}, value interface{}) *MockClient_IncrementFloatBy_Call

IncrementFloatBy is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value float64

func (*MockClient_Expecter) Ping 

func (_e *MockClient_Expecter) Ping(ctx interface{}) *MockClient_Ping_Call

Ping is a helper method to define mock.On call

  • ctx context.Context

func (*MockClient_Expecter) Publish added in v1.1.6 

func (_e *MockClient_Expecter) Publish(ctx interface{}, channel interface{}, message interface{}) *MockClient_Publish_Call

Publish is a helper method to define mock.On call

  • ctx context.Context
  • channel string
  • message interface{}

func (*MockClient_Expecter) SetFloat 

func (_e *MockClient_Expecter) SetFloat(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockClient_SetFloat_Call

SetFloat is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value float64
  • expiration time.Duration

func (*MockClient_Expecter) SetFloatIfExist 

func (_e *MockClient_Expecter) SetFloatIfExist(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockClient_SetFloatIfExist_Call

SetFloatIfExist is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value float64
  • expiration time.Duration

func (*MockClient_Expecter) SetFloatIfNotExist 

func (_e *MockClient_Expecter) SetFloatIfNotExist(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockClient_SetFloatIfNotExist_Call

SetFloatIfNotExist is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value float64
  • expiration time.Duration

func (*MockClient_Expecter) SetInt 

func (_e *MockClient_Expecter) SetInt(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockClient_SetInt_Call

SetInt is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value int64
  • expiration time.Duration

func (*MockClient_Expecter) SetIntIfExist 

func (_e *MockClient_Expecter) SetIntIfExist(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockClient_SetIntIfExist_Call

SetIntIfExist is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value int64
  • expiration time.Duration

func (*MockClient_Expecter) SetIntIfNotExist 

func (_e *MockClient_Expecter) SetIntIfNotExist(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockClient_SetIntIfNotExist_Call

SetIntIfNotExist is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value int64
  • expiration time.Duration

func (*MockClient_Expecter) SetString 

func (_e *MockClient_Expecter) SetString(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockClient_SetString_Call

SetString is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value string
  • expiration time.Duration

func (*MockClient_Expecter) SetStringIfExist 

func (_e *MockClient_Expecter) SetStringIfExist(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockClient_SetStringIfExist_Call

SetStringIfExist is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value string
  • expiration time.Duration

func (*MockClient_Expecter) SetStringIfNotExist 

func (_e *MockClient_Expecter) SetStringIfNotExist(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockClient_SetStringIfNotExist_Call

SetStringIfNotExist is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value string
  • expiration time.Duration

func (*MockClient_Expecter) Subscribe added in v1.1.6 

func (_e *MockClient_Expecter) Subscribe(ctx interface{}, channels interface{}, handler interface{}) *MockClient_Subscribe_Call

Subscribe is a helper method to define mock.On call

  • ctx context.Context
  • channels []string
  • handler MessageHandler

type MockClient_Expire_Call 

type MockClient_Expire_Call struct {
	*mock.Call
}

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

func (*MockClient_Expire_Call) Return 

func (_c *MockClient_Expire_Call) Return(b bool, err error) *MockClient_Expire_Call

func (*MockClient_Expire_Call) Run 

func (_c *MockClient_Expire_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *MockClient_Expire_Call

func (*MockClient_Expire_Call) RunAndReturn 

func (_c *MockClient_Expire_Call) RunAndReturn(run func(ctx context.Context, key string, expiration time.Duration) (bool, error)) *MockClient_Expire_Call

type MockClient_GetFloat_Call 

type MockClient_GetFloat_Call struct {
	*mock.Call
}

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

func (*MockClient_GetFloat_Call) Return 

func (_c *MockClient_GetFloat_Call) Return(f float64, err error) *MockClient_GetFloat_Call

func (*MockClient_GetFloat_Call) Run 

func (_c *MockClient_GetFloat_Call) Run(run func(ctx context.Context, key string)) *MockClient_GetFloat_Call

func (*MockClient_GetFloat_Call) RunAndReturn 

func (_c *MockClient_GetFloat_Call) RunAndReturn(run func(ctx context.Context, key string) (float64, error)) *MockClient_GetFloat_Call

type MockClient_GetInt_Call 

type MockClient_GetInt_Call struct {
	*mock.Call
}

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

func (*MockClient_GetInt_Call) Return 

func (_c *MockClient_GetInt_Call) Return(n int64, err error) *MockClient_GetInt_Call

func (*MockClient_GetInt_Call) Run 

func (_c *MockClient_GetInt_Call) Run(run func(ctx context.Context, key string)) *MockClient_GetInt_Call

func (*MockClient_GetInt_Call) RunAndReturn 

func (_c *MockClient_GetInt_Call) RunAndReturn(run func(ctx context.Context, key string) (int64, error)) *MockClient_GetInt_Call

type MockClient_GetString_Call 

type MockClient_GetString_Call struct {
	*mock.Call
}

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

func (*MockClient_GetString_Call) Return 

func (_c *MockClient_GetString_Call) Return(s string, err error) *MockClient_GetString_Call

func (*MockClient_GetString_Call) Run 

func (_c *MockClient_GetString_Call) Run(run func(ctx context.Context, key string)) *MockClient_GetString_Call

func (*MockClient_GetString_Call) RunAndReturn 

func (_c *MockClient_GetString_Call) RunAndReturn(run func(ctx context.Context, key string) (string, error)) *MockClient_GetString_Call

type MockClient_HashGetAll_Call 

type MockClient_HashGetAll_Call struct {
	*mock.Call
}

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

func (*MockClient_HashGetAll_Call) Return 

func (_c *MockClient_HashGetAll_Call) Return(err error) *MockClient_HashGetAll_Call

func (*MockClient_HashGetAll_Call) Run 

func (_c *MockClient_HashGetAll_Call) Run(run func(ctx context.Context, key string, out interface{})) *MockClient_HashGetAll_Call

func (*MockClient_HashGetAll_Call) RunAndReturn 

func (_c *MockClient_HashGetAll_Call) RunAndReturn(run func(ctx context.Context, key string, out interface{}) error) *MockClient_HashGetAll_Call

type MockClient_HashGetField_Call 

type MockClient_HashGetField_Call struct {
	*mock.Call
}

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

func (*MockClient_HashGetField_Call) Return 

func (_c *MockClient_HashGetField_Call) Return(err error) *MockClient_HashGetField_Call

func (*MockClient_HashGetField_Call) Run 

func (_c *MockClient_HashGetField_Call) Run(run func(ctx context.Context, key string, field string, out interface{})) *MockClient_HashGetField_Call

func (*MockClient_HashGetField_Call) RunAndReturn 

func (_c *MockClient_HashGetField_Call) RunAndReturn(run func(ctx context.Context, key string, field string, out interface{}) error) *MockClient_HashGetField_Call

type MockClient_HashSet_Call 

type MockClient_HashSet_Call struct {
	*mock.Call
}

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

func (*MockClient_HashSet_Call) Return 

func (_c *MockClient_HashSet_Call) Return(err error) *MockClient_HashSet_Call

func (*MockClient_HashSet_Call) Run 

func (_c *MockClient_HashSet_Call) Run(run func(ctx context.Context, key string, value interface{})) *MockClient_HashSet_Call

func (*MockClient_HashSet_Call) RunAndReturn 

func (_c *MockClient_HashSet_Call) RunAndReturn(run func(ctx context.Context, key string, value interface{}) error) *MockClient_HashSet_Call

type MockClient_IncrementBy_Call 

type MockClient_IncrementBy_Call struct {
	*mock.Call
}

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

func (*MockClient_IncrementBy_Call) Return 

func (_c *MockClient_IncrementBy_Call) Return(n int64, err error) *MockClient_IncrementBy_Call

func (*MockClient_IncrementBy_Call) Run 

func (_c *MockClient_IncrementBy_Call) Run(run func(ctx context.Context, key string, value int64)) *MockClient_IncrementBy_Call

func (*MockClient_IncrementBy_Call) RunAndReturn 

func (_c *MockClient_IncrementBy_Call) RunAndReturn(run func(ctx context.Context, key string, value int64) (int64, error)) *MockClient_IncrementBy_Call

type MockClient_IncrementFloatBy_Call 

type MockClient_IncrementFloatBy_Call struct {
	*mock.Call
}

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

func (*MockClient_IncrementFloatBy_Call) Return 

func (_c *MockClient_IncrementFloatBy_Call) Return(f float64, err error) *MockClient_IncrementFloatBy_Call

func (*MockClient_IncrementFloatBy_Call) Run 

func (_c *MockClient_IncrementFloatBy_Call) Run(run func(ctx context.Context, key string, value float64)) *MockClient_IncrementFloatBy_Call

func (*MockClient_IncrementFloatBy_Call) RunAndReturn 

func (_c *MockClient_IncrementFloatBy_Call) RunAndReturn(run func(ctx context.Context, key string, value float64) (float64, error)) *MockClient_IncrementFloatBy_Call

type MockClient_Ping_Call 

type MockClient_Ping_Call struct {
	*mock.Call
}

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

func (*MockClient_Ping_Call) Return 

func (_c *MockClient_Ping_Call) Return(err error) *MockClient_Ping_Call

func (*MockClient_Ping_Call) Run 

func (_c *MockClient_Ping_Call) Run(run func(ctx context.Context)) *MockClient_Ping_Call

func (*MockClient_Ping_Call) RunAndReturn 

func (_c *MockClient_Ping_Call) RunAndReturn(run func(ctx context.Context) error) *MockClient_Ping_Call

type MockClient_Publish_Call added in v1.1.6 

type MockClient_Publish_Call struct {
	*mock.Call
}

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

func (*MockClient_Publish_Call) Return added in v1.1.6 

func (_c *MockClient_Publish_Call) Return(err error) *MockClient_Publish_Call

func (*MockClient_Publish_Call) Run added in v1.1.6 

func (_c *MockClient_Publish_Call) Run(run func(ctx context.Context, channel string, message interface{})) *MockClient_Publish_Call

func (*MockClient_Publish_Call) RunAndReturn added in v1.1.6 

func (_c *MockClient_Publish_Call) RunAndReturn(run func(ctx context.Context, channel string, message interface{}) error) *MockClient_Publish_Call

type MockClient_SetFloatIfExist_Call 

type MockClient_SetFloatIfExist_Call struct {
	*mock.Call
}

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

func (*MockClient_SetFloatIfExist_Call) Return 

func (_c *MockClient_SetFloatIfExist_Call) Return(err error) *MockClient_SetFloatIfExist_Call

func (*MockClient_SetFloatIfExist_Call) Run 

func (_c *MockClient_SetFloatIfExist_Call) Run(run func(ctx context.Context, key string, value float64, expiration time.Duration)) *MockClient_SetFloatIfExist_Call

func (*MockClient_SetFloatIfExist_Call) RunAndReturn 

func (_c *MockClient_SetFloatIfExist_Call) RunAndReturn(run func(ctx context.Context, key string, value float64, expiration time.Duration) error) *MockClient_SetFloatIfExist_Call

type MockClient_SetFloatIfNotExist_Call 

type MockClient_SetFloatIfNotExist_Call struct {
	*mock.Call
}

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

func (*MockClient_SetFloatIfNotExist_Call) Return 

func (_c *MockClient_SetFloatIfNotExist_Call) Return(err error) *MockClient_SetFloatIfNotExist_Call

func (*MockClient_SetFloatIfNotExist_Call) Run 

func (_c *MockClient_SetFloatIfNotExist_Call) Run(run func(ctx context.Context, key string, value float64, expiration time.Duration)) *MockClient_SetFloatIfNotExist_Call

func (*MockClient_SetFloatIfNotExist_Call) RunAndReturn 

func (_c *MockClient_SetFloatIfNotExist_Call) RunAndReturn(run func(ctx context.Context, key string, value float64, expiration time.Duration) error) *MockClient_SetFloatIfNotExist_Call

type MockClient_SetFloat_Call 

type MockClient_SetFloat_Call struct {
	*mock.Call
}

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

func (*MockClient_SetFloat_Call) Return 

func (_c *MockClient_SetFloat_Call) Return(err error) *MockClient_SetFloat_Call

func (*MockClient_SetFloat_Call) Run 

func (_c *MockClient_SetFloat_Call) Run(run func(ctx context.Context, key string, value float64, expiration time.Duration)) *MockClient_SetFloat_Call

func (*MockClient_SetFloat_Call) RunAndReturn 

func (_c *MockClient_SetFloat_Call) RunAndReturn(run func(ctx context.Context, key string, value float64, expiration time.Duration) error) *MockClient_SetFloat_Call

type MockClient_SetIntIfExist_Call 

type MockClient_SetIntIfExist_Call struct {
	*mock.Call
}

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

func (*MockClient_SetIntIfExist_Call) Return 

func (_c *MockClient_SetIntIfExist_Call) Return(err error) *MockClient_SetIntIfExist_Call

func (*MockClient_SetIntIfExist_Call) Run 

func (_c *MockClient_SetIntIfExist_Call) Run(run func(ctx context.Context, key string, value int64, expiration time.Duration)) *MockClient_SetIntIfExist_Call

func (*MockClient_SetIntIfExist_Call) RunAndReturn 

func (_c *MockClient_SetIntIfExist_Call) RunAndReturn(run func(ctx context.Context, key string, value int64, expiration time.Duration) error) *MockClient_SetIntIfExist_Call

type MockClient_SetIntIfNotExist_Call 

type MockClient_SetIntIfNotExist_Call struct {
	*mock.Call
}

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

func (*MockClient_SetIntIfNotExist_Call) Return 

func (_c *MockClient_SetIntIfNotExist_Call) Return(err error) *MockClient_SetIntIfNotExist_Call

func (*MockClient_SetIntIfNotExist_Call) Run 

func (_c *MockClient_SetIntIfNotExist_Call) Run(run func(ctx context.Context, key string, value int64, expiration time.Duration)) *MockClient_SetIntIfNotExist_Call

func (*MockClient_SetIntIfNotExist_Call) RunAndReturn 

func (_c *MockClient_SetIntIfNotExist_Call) RunAndReturn(run func(ctx context.Context, key string, value int64, expiration time.Duration) error) *MockClient_SetIntIfNotExist_Call

type MockClient_SetInt_Call 

type MockClient_SetInt_Call struct {
	*mock.Call
}

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

func (*MockClient_SetInt_Call) Return 

func (_c *MockClient_SetInt_Call) Return(err error) *MockClient_SetInt_Call

func (*MockClient_SetInt_Call) Run 

func (_c *MockClient_SetInt_Call) Run(run func(ctx context.Context, key string, value int64, expiration time.Duration)) *MockClient_SetInt_Call

func (*MockClient_SetInt_Call) RunAndReturn 

func (_c *MockClient_SetInt_Call) RunAndReturn(run func(ctx context.Context, key string, value int64, expiration time.Duration) error) *MockClient_SetInt_Call

type MockClient_SetStringIfExist_Call 

type MockClient_SetStringIfExist_Call struct {
	*mock.Call
}

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

func (*MockClient_SetStringIfExist_Call) Return 

func (_c *MockClient_SetStringIfExist_Call) Return(err error) *MockClient_SetStringIfExist_Call

func (*MockClient_SetStringIfExist_Call) Run 

func (_c *MockClient_SetStringIfExist_Call) Run(run func(ctx context.Context, key string, value string, expiration time.Duration)) *MockClient_SetStringIfExist_Call

func (*MockClient_SetStringIfExist_Call) RunAndReturn 

func (_c *MockClient_SetStringIfExist_Call) RunAndReturn(run func(ctx context.Context, key string, value string, expiration time.Duration) error) *MockClient_SetStringIfExist_Call

type MockClient_SetStringIfNotExist_Call 

type MockClient_SetStringIfNotExist_Call struct {
	*mock.Call
}

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

func (*MockClient_SetStringIfNotExist_Call) Return 

func (_c *MockClient_SetStringIfNotExist_Call) Return(err error) *MockClient_SetStringIfNotExist_Call

func (*MockClient_SetStringIfNotExist_Call) Run 

func (_c *MockClient_SetStringIfNotExist_Call) Run(run func(ctx context.Context, key string, value string, expiration time.Duration)) *MockClient_SetStringIfNotExist_Call

func (*MockClient_SetStringIfNotExist_Call) RunAndReturn 

func (_c *MockClient_SetStringIfNotExist_Call) RunAndReturn(run func(ctx context.Context, key string, value string, expiration time.Duration) error) *MockClient_SetStringIfNotExist_Call

type MockClient_SetString_Call 

type MockClient_SetString_Call struct {
	*mock.Call
}

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

func (*MockClient_SetString_Call) Return 

func (_c *MockClient_SetString_Call) Return(err error) *MockClient_SetString_Call

func (*MockClient_SetString_Call) Run 

func (_c *MockClient_SetString_Call) Run(run func(ctx context.Context, key string, value string, expiration time.Duration)) *MockClient_SetString_Call

func (*MockClient_SetString_Call) RunAndReturn 

func (_c *MockClient_SetString_Call) RunAndReturn(run func(ctx context.Context, key string, value string, expiration time.Duration) error) *MockClient_SetString_Call

type MockClient_Subscribe_Call added in v1.1.6 

type MockClient_Subscribe_Call struct {
	*mock.Call
}

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

func (*MockClient_Subscribe_Call) Return added in v1.1.6 

func (_c *MockClient_Subscribe_Call) Return(subscriber Subscriber) *MockClient_Subscribe_Call

func (*MockClient_Subscribe_Call) Run added in v1.1.6 

func (_c *MockClient_Subscribe_Call) Run(run func(ctx context.Context, channels []string, handler MessageHandler)) *MockClient_Subscribe_Call

func (*MockClient_Subscribe_Call) RunAndReturn added in v1.1.6 

func (_c *MockClient_Subscribe_Call) RunAndReturn(run func(ctx context.Context, channels []string, handler MessageHandler) Subscriber) *MockClient_Subscribe_Call

type MockCommander 

type MockCommander struct {
	mock.Mock
}

MockCommander is an autogenerated mock type for the Commander type

func NewMockCommander 

func NewMockCommander(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockCommander

NewMockCommander creates a new instance of MockCommander. 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 (*MockCommander) DecrementBy 

func (_mock *MockCommander) DecrementBy(ctx context.Context, key string, value int64) (int64, error)

DecrementBy provides a mock function for the type MockCommander

func (*MockCommander) Delete 

func (_mock *MockCommander) Delete(ctx context.Context, key string) (int64, error)

Delete provides a mock function for the type MockCommander

func (*MockCommander) Discard 

func (_mock *MockCommander) Discard()

Discard provides a mock function for the type MockCommander

func (*MockCommander) EXPECT 

func (_m *MockCommander) EXPECT() *MockCommander_Expecter

func (*MockCommander) Execute 

func (_mock *MockCommander) Execute(ctx context.Context) error

Execute provides a mock function for the type MockCommander

func (*MockCommander) Expire 

func (_mock *MockCommander) Expire(ctx context.Context, key string, expiration time.Duration) (bool, error)

Expire provides a mock function for the type MockCommander

func (*MockCommander) GetFloat 

func (_mock *MockCommander) GetFloat(ctx context.Context, key string) (float64, error)

GetFloat provides a mock function for the type MockCommander

func (*MockCommander) GetInt 

func (_mock *MockCommander) GetInt(ctx context.Context, key string) (int64, error)

GetInt provides a mock function for the type MockCommander

func (*MockCommander) GetString 

func (_mock *MockCommander) GetString(ctx context.Context, key string) (string, error)

GetString provides a mock function for the type MockCommander

func (*MockCommander) HashGetAll 

func (_mock *MockCommander) HashGetAll(ctx context.Context, key string, out interface{}) error

HashGetAll provides a mock function for the type MockCommander

func (*MockCommander) HashGetField 

func (_mock *MockCommander) HashGetField(ctx context.Context, key string, field string, out interface{}) error

HashGetField provides a mock function for the type MockCommander

func (*MockCommander) HashSet 

func (_mock *MockCommander) HashSet(ctx context.Context, key string, value interface{}) error

HashSet provides a mock function for the type MockCommander

func (*MockCommander) IncrementBy 

func (_mock *MockCommander) IncrementBy(ctx context.Context, key string, value int64) (int64, error)

IncrementBy provides a mock function for the type MockCommander

func (*MockCommander) IncrementFloatBy 

func (_mock *MockCommander) IncrementFloatBy(ctx context.Context, key string, value float64) (float64, error)

IncrementFloatBy provides a mock function for the type MockCommander

func (*MockCommander) SetFloat 

func (_mock *MockCommander) SetFloat(ctx context.Context, key string, value float64, expiration time.Duration) error

SetFloat provides a mock function for the type MockCommander

func (*MockCommander) SetFloatIfExist 

func (_mock *MockCommander) SetFloatIfExist(ctx context.Context, key string, value float64, expiration time.Duration) error

SetFloatIfExist provides a mock function for the type MockCommander

func (*MockCommander) SetFloatIfNotExist 

func (_mock *MockCommander) SetFloatIfNotExist(ctx context.Context, key string, value float64, expiration time.Duration) error

SetFloatIfNotExist provides a mock function for the type MockCommander

func (*MockCommander) SetInt 

func (_mock *MockCommander) SetInt(ctx context.Context, key string, value int64, expiration time.Duration) error

SetInt provides a mock function for the type MockCommander

func (*MockCommander) SetIntIfExist 

func (_mock *MockCommander) SetIntIfExist(ctx context.Context, key string, value int64, expiration time.Duration) error

SetIntIfExist provides a mock function for the type MockCommander

func (*MockCommander) SetIntIfNotExist 

func (_mock *MockCommander) SetIntIfNotExist(ctx context.Context, key string, value int64, expiration time.Duration) error

SetIntIfNotExist provides a mock function for the type MockCommander

func (*MockCommander) SetString 

func (_mock *MockCommander) SetString(ctx context.Context, key string, value string, expiration time.Duration) error

SetString provides a mock function for the type MockCommander

func (*MockCommander) SetStringIfExist 

func (_mock *MockCommander) SetStringIfExist(ctx context.Context, key string, value string, expiration time.Duration) error

SetStringIfExist provides a mock function for the type MockCommander

func (*MockCommander) SetStringIfNotExist 

func (_mock *MockCommander) SetStringIfNotExist(ctx context.Context, key string, value string, expiration time.Duration) error

SetStringIfNotExist provides a mock function for the type MockCommander

type MockCommander_DecrementBy_Call 

type MockCommander_DecrementBy_Call struct {
	*mock.Call
}

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

func (*MockCommander_DecrementBy_Call) Return 

func (_c *MockCommander_DecrementBy_Call) Return(n int64, err error) *MockCommander_DecrementBy_Call

func (*MockCommander_DecrementBy_Call) Run 

func (_c *MockCommander_DecrementBy_Call) Run(run func(ctx context.Context, key string, value int64)) *MockCommander_DecrementBy_Call

func (*MockCommander_DecrementBy_Call) RunAndReturn 

func (_c *MockCommander_DecrementBy_Call) RunAndReturn(run func(ctx context.Context, key string, value int64) (int64, error)) *MockCommander_DecrementBy_Call

type MockCommander_Delete_Call 

type MockCommander_Delete_Call struct {
	*mock.Call
}

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

func (*MockCommander_Delete_Call) Return 

func (_c *MockCommander_Delete_Call) Return(n int64, err error) *MockCommander_Delete_Call

func (*MockCommander_Delete_Call) Run 

func (_c *MockCommander_Delete_Call) Run(run func(ctx context.Context, key string)) *MockCommander_Delete_Call

func (*MockCommander_Delete_Call) RunAndReturn 

func (_c *MockCommander_Delete_Call) RunAndReturn(run func(ctx context.Context, key string) (int64, error)) *MockCommander_Delete_Call

type MockCommander_Discard_Call 

type MockCommander_Discard_Call struct {
	*mock.Call
}

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

func (*MockCommander_Discard_Call) Return 

func (_c *MockCommander_Discard_Call) Return() *MockCommander_Discard_Call

func (*MockCommander_Discard_Call) Run 

func (_c *MockCommander_Discard_Call) Run(run func()) *MockCommander_Discard_Call

func (*MockCommander_Discard_Call) RunAndReturn 

func (_c *MockCommander_Discard_Call) RunAndReturn(run func()) *MockCommander_Discard_Call

type MockCommander_Execute_Call 

type MockCommander_Execute_Call struct {
	*mock.Call
}

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

func (*MockCommander_Execute_Call) Return 

func (_c *MockCommander_Execute_Call) Return(err error) *MockCommander_Execute_Call

func (*MockCommander_Execute_Call) Run 

func (_c *MockCommander_Execute_Call) Run(run func(ctx context.Context)) *MockCommander_Execute_Call

func (*MockCommander_Execute_Call) RunAndReturn 

func (_c *MockCommander_Execute_Call) RunAndReturn(run func(ctx context.Context) error) *MockCommander_Execute_Call

type MockCommander_Expecter 

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

func (*MockCommander_Expecter) DecrementBy 

func (_e *MockCommander_Expecter) DecrementBy(ctx interface{}, key interface{}, value interface{}) *MockCommander_DecrementBy_Call

DecrementBy is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value int64

func (*MockCommander_Expecter) Delete 

func (_e *MockCommander_Expecter) Delete(ctx interface{}, key interface{}) *MockCommander_Delete_Call

Delete is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*MockCommander_Expecter) Discard 

func (_e *MockCommander_Expecter) Discard() *MockCommander_Discard_Call

Discard is a helper method to define mock.On call

func (*MockCommander_Expecter) Execute 

func (_e *MockCommander_Expecter) Execute(ctx interface{}) *MockCommander_Execute_Call

Execute is a helper method to define mock.On call

  • ctx context.Context

func (*MockCommander_Expecter) Expire 

func (_e *MockCommander_Expecter) Expire(ctx interface{}, key interface{}, expiration interface{}) *MockCommander_Expire_Call

Expire is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • expiration time.Duration

func (*MockCommander_Expecter) GetFloat 

func (_e *MockCommander_Expecter) GetFloat(ctx interface{}, key interface{}) *MockCommander_GetFloat_Call

GetFloat is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*MockCommander_Expecter) GetInt 

func (_e *MockCommander_Expecter) GetInt(ctx interface{}, key interface{}) *MockCommander_GetInt_Call

GetInt is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*MockCommander_Expecter) GetString 

func (_e *MockCommander_Expecter) GetString(ctx interface{}, key interface{}) *MockCommander_GetString_Call

GetString is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*MockCommander_Expecter) HashGetAll 

func (_e *MockCommander_Expecter) HashGetAll(ctx interface{}, key interface{}, out interface{}) *MockCommander_HashGetAll_Call

HashGetAll is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • out interface{}

func (*MockCommander_Expecter) HashGetField 

func (_e *MockCommander_Expecter) HashGetField(ctx interface{}, key interface{}, field interface{}, out interface{}) *MockCommander_HashGetField_Call

HashGetField is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • field string
  • out interface{}

func (*MockCommander_Expecter) HashSet 

func (_e *MockCommander_Expecter) HashSet(ctx interface{}, key interface{}, value interface{}) *MockCommander_HashSet_Call

HashSet is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value interface{}

func (*MockCommander_Expecter) IncrementBy 

func (_e *MockCommander_Expecter) IncrementBy(ctx interface{}, key interface{}, value interface{}) *MockCommander_IncrementBy_Call

IncrementBy is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value int64

func (*MockCommander_Expecter) IncrementFloatBy 

func (_e *MockCommander_Expecter) IncrementFloatBy(ctx interface{}, key interface{}, value interface{}) *MockCommander_IncrementFloatBy_Call

IncrementFloatBy is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value float64

func (*MockCommander_Expecter) SetFloat 

func (_e *MockCommander_Expecter) SetFloat(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockCommander_SetFloat_Call

SetFloat is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value float64
  • expiration time.Duration

func (*MockCommander_Expecter) SetFloatIfExist 

func (_e *MockCommander_Expecter) SetFloatIfExist(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockCommander_SetFloatIfExist_Call

SetFloatIfExist is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value float64
  • expiration time.Duration

func (*MockCommander_Expecter) SetFloatIfNotExist 

func (_e *MockCommander_Expecter) SetFloatIfNotExist(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockCommander_SetFloatIfNotExist_Call

SetFloatIfNotExist is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value float64
  • expiration time.Duration

func (*MockCommander_Expecter) SetInt 

func (_e *MockCommander_Expecter) SetInt(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockCommander_SetInt_Call

SetInt is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value int64
  • expiration time.Duration

func (*MockCommander_Expecter) SetIntIfExist 

func (_e *MockCommander_Expecter) SetIntIfExist(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockCommander_SetIntIfExist_Call

SetIntIfExist is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value int64
  • expiration time.Duration

func (*MockCommander_Expecter) SetIntIfNotExist 

func (_e *MockCommander_Expecter) SetIntIfNotExist(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockCommander_SetIntIfNotExist_Call

SetIntIfNotExist is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value int64
  • expiration time.Duration

func (*MockCommander_Expecter) SetString 

func (_e *MockCommander_Expecter) SetString(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockCommander_SetString_Call

SetString is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value string
  • expiration time.Duration

func (*MockCommander_Expecter) SetStringIfExist 

func (_e *MockCommander_Expecter) SetStringIfExist(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockCommander_SetStringIfExist_Call

SetStringIfExist is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value string
  • expiration time.Duration

func (*MockCommander_Expecter) SetStringIfNotExist 

func (_e *MockCommander_Expecter) SetStringIfNotExist(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *MockCommander_SetStringIfNotExist_Call

SetStringIfNotExist is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value string
  • expiration time.Duration

type MockCommander_Expire_Call 

type MockCommander_Expire_Call struct {
	*mock.Call
}

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

func (*MockCommander_Expire_Call) Return 

func (_c *MockCommander_Expire_Call) Return(b bool, err error) *MockCommander_Expire_Call

func (*MockCommander_Expire_Call) Run 

func (_c *MockCommander_Expire_Call) Run(run func(ctx context.Context, key string, expiration time.Duration)) *MockCommander_Expire_Call

func (*MockCommander_Expire_Call) RunAndReturn 

func (_c *MockCommander_Expire_Call) RunAndReturn(run func(ctx context.Context, key string, expiration time.Duration) (bool, error)) *MockCommander_Expire_Call

type MockCommander_GetFloat_Call 

type MockCommander_GetFloat_Call struct {
	*mock.Call
}

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

func (*MockCommander_GetFloat_Call) Return 

func (_c *MockCommander_GetFloat_Call) Return(f float64, err error) *MockCommander_GetFloat_Call

func (*MockCommander_GetFloat_Call) Run 

func (_c *MockCommander_GetFloat_Call) Run(run func(ctx context.Context, key string)) *MockCommander_GetFloat_Call

func (*MockCommander_GetFloat_Call) RunAndReturn 

func (_c *MockCommander_GetFloat_Call) RunAndReturn(run func(ctx context.Context, key string) (float64, error)) *MockCommander_GetFloat_Call

type MockCommander_GetInt_Call 

type MockCommander_GetInt_Call struct {
	*mock.Call
}

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

func (*MockCommander_GetInt_Call) Return 

func (_c *MockCommander_GetInt_Call) Return(n int64, err error) *MockCommander_GetInt_Call

func (*MockCommander_GetInt_Call) Run 

func (_c *MockCommander_GetInt_Call) Run(run func(ctx context.Context, key string)) *MockCommander_GetInt_Call

func (*MockCommander_GetInt_Call) RunAndReturn 

func (_c *MockCommander_GetInt_Call) RunAndReturn(run func(ctx context.Context, key string) (int64, error)) *MockCommander_GetInt_Call

type MockCommander_GetString_Call 

type MockCommander_GetString_Call struct {
	*mock.Call
}

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

func (*MockCommander_GetString_Call) Return 

func (_c *MockCommander_GetString_Call) Return(s string, err error) *MockCommander_GetString_Call

func (*MockCommander_GetString_Call) Run 

func (_c *MockCommander_GetString_Call) Run(run func(ctx context.Context, key string)) *MockCommander_GetString_Call

func (*MockCommander_GetString_Call) RunAndReturn 

func (_c *MockCommander_GetString_Call) RunAndReturn(run func(ctx context.Context, key string) (string, error)) *MockCommander_GetString_Call

type MockCommander_HashGetAll_Call 

type MockCommander_HashGetAll_Call struct {
	*mock.Call
}

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

func (*MockCommander_HashGetAll_Call) Return 

func (_c *MockCommander_HashGetAll_Call) Return(err error) *MockCommander_HashGetAll_Call

func (*MockCommander_HashGetAll_Call) Run 

func (_c *MockCommander_HashGetAll_Call) Run(run func(ctx context.Context, key string, out interface{})) *MockCommander_HashGetAll_Call

func (*MockCommander_HashGetAll_Call) RunAndReturn 

func (_c *MockCommander_HashGetAll_Call) RunAndReturn(run func(ctx context.Context, key string, out interface{}) error) *MockCommander_HashGetAll_Call

type MockCommander_HashGetField_Call 

type MockCommander_HashGetField_Call struct {
	*mock.Call
}

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

func (*MockCommander_HashGetField_Call) Return 

func (_c *MockCommander_HashGetField_Call) Return(err error) *MockCommander_HashGetField_Call

func (*MockCommander_HashGetField_Call) Run 

func (_c *MockCommander_HashGetField_Call) Run(run func(ctx context.Context, key string, field string, out interface{})) *MockCommander_HashGetField_Call

func (*MockCommander_HashGetField_Call) RunAndReturn 

func (_c *MockCommander_HashGetField_Call) RunAndReturn(run func(ctx context.Context, key string, field string, out interface{}) error) *MockCommander_HashGetField_Call

type MockCommander_HashSet_Call 

type MockCommander_HashSet_Call struct {
	*mock.Call
}

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

func (*MockCommander_HashSet_Call) Return 

func (_c *MockCommander_HashSet_Call) Return(err error) *MockCommander_HashSet_Call

func (*MockCommander_HashSet_Call) Run 

func (_c *MockCommander_HashSet_Call) Run(run func(ctx context.Context, key string, value interface{})) *MockCommander_HashSet_Call

func (*MockCommander_HashSet_Call) RunAndReturn 

func (_c *MockCommander_HashSet_Call) RunAndReturn(run func(ctx context.Context, key string, value interface{}) error) *MockCommander_HashSet_Call

type MockCommander_IncrementBy_Call 

type MockCommander_IncrementBy_Call struct {
	*mock.Call
}

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

func (*MockCommander_IncrementBy_Call) Return 

func (_c *MockCommander_IncrementBy_Call) Return(n int64, err error) *MockCommander_IncrementBy_Call

func (*MockCommander_IncrementBy_Call) Run 

func (_c *MockCommander_IncrementBy_Call) Run(run func(ctx context.Context, key string, value int64)) *MockCommander_IncrementBy_Call

func (*MockCommander_IncrementBy_Call) RunAndReturn 

func (_c *MockCommander_IncrementBy_Call) RunAndReturn(run func(ctx context.Context, key string, value int64) (int64, error)) *MockCommander_IncrementBy_Call

type MockCommander_IncrementFloatBy_Call 

type MockCommander_IncrementFloatBy_Call struct {
	*mock.Call
}

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

func (*MockCommander_IncrementFloatBy_Call) Return 

func (_c *MockCommander_IncrementFloatBy_Call) Return(f float64, err error) *MockCommander_IncrementFloatBy_Call

func (*MockCommander_IncrementFloatBy_Call) Run 

func (_c *MockCommander_IncrementFloatBy_Call) Run(run func(ctx context.Context, key string, value float64)) *MockCommander_IncrementFloatBy_Call

func (*MockCommander_IncrementFloatBy_Call) RunAndReturn 

func (_c *MockCommander_IncrementFloatBy_Call) RunAndReturn(run func(ctx context.Context, key string, value float64) (float64, error)) *MockCommander_IncrementFloatBy_Call

type MockCommander_SetFloatIfExist_Call 

type MockCommander_SetFloatIfExist_Call struct {
	*mock.Call
}

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

func (*MockCommander_SetFloatIfExist_Call) Return 

func (_c *MockCommander_SetFloatIfExist_Call) Return(err error) *MockCommander_SetFloatIfExist_Call

func (*MockCommander_SetFloatIfExist_Call) Run 

func (_c *MockCommander_SetFloatIfExist_Call) Run(run func(ctx context.Context, key string, value float64, expiration time.Duration)) *MockCommander_SetFloatIfExist_Call

func (*MockCommander_SetFloatIfExist_Call) RunAndReturn 

func (_c *MockCommander_SetFloatIfExist_Call) RunAndReturn(run func(ctx context.Context, key string, value float64, expiration time.Duration) error) *MockCommander_SetFloatIfExist_Call

type MockCommander_SetFloatIfNotExist_Call 

type MockCommander_SetFloatIfNotExist_Call struct {
	*mock.Call
}

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

func (*MockCommander_SetFloatIfNotExist_Call) Return 

func (_c *MockCommander_SetFloatIfNotExist_Call) Return(err error) *MockCommander_SetFloatIfNotExist_Call

func (*MockCommander_SetFloatIfNotExist_Call) Run 

func (_c *MockCommander_SetFloatIfNotExist_Call) Run(run func(ctx context.Context, key string, value float64, expiration time.Duration)) *MockCommander_SetFloatIfNotExist_Call

func (*MockCommander_SetFloatIfNotExist_Call) RunAndReturn 

func (_c *MockCommander_SetFloatIfNotExist_Call) RunAndReturn(run func(ctx context.Context, key string, value float64, expiration time.Duration) error) *MockCommander_SetFloatIfNotExist_Call

type MockCommander_SetFloat_Call 

type MockCommander_SetFloat_Call struct {
	*mock.Call
}

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

func (*MockCommander_SetFloat_Call) Return 

func (_c *MockCommander_SetFloat_Call) Return(err error) *MockCommander_SetFloat_Call

func (*MockCommander_SetFloat_Call) Run 

func (_c *MockCommander_SetFloat_Call) Run(run func(ctx context.Context, key string, value float64, expiration time.Duration)) *MockCommander_SetFloat_Call

func (*MockCommander_SetFloat_Call) RunAndReturn 

func (_c *MockCommander_SetFloat_Call) RunAndReturn(run func(ctx context.Context, key string, value float64, expiration time.Duration) error) *MockCommander_SetFloat_Call

type MockCommander_SetIntIfExist_Call 

type MockCommander_SetIntIfExist_Call struct {
	*mock.Call
}

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

func (*MockCommander_SetIntIfExist_Call) Return 

func (_c *MockCommander_SetIntIfExist_Call) Return(err error) *MockCommander_SetIntIfExist_Call

func (*MockCommander_SetIntIfExist_Call) Run 

func (_c *MockCommander_SetIntIfExist_Call) Run(run func(ctx context.Context, key string, value int64, expiration time.Duration)) *MockCommander_SetIntIfExist_Call

func (*MockCommander_SetIntIfExist_Call) RunAndReturn 

func (_c *MockCommander_SetIntIfExist_Call) RunAndReturn(run func(ctx context.Context, key string, value int64, expiration time.Duration) error) *MockCommander_SetIntIfExist_Call

type MockCommander_SetIntIfNotExist_Call 

type MockCommander_SetIntIfNotExist_Call struct {
	*mock.Call
}

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

func (*MockCommander_SetIntIfNotExist_Call) Return 

func (_c *MockCommander_SetIntIfNotExist_Call) Return(err error) *MockCommander_SetIntIfNotExist_Call

func (*MockCommander_SetIntIfNotExist_Call) Run 

func (_c *MockCommander_SetIntIfNotExist_Call) Run(run func(ctx context.Context, key string, value int64, expiration time.Duration)) *MockCommander_SetIntIfNotExist_Call

func (*MockCommander_SetIntIfNotExist_Call) RunAndReturn 

func (_c *MockCommander_SetIntIfNotExist_Call) RunAndReturn(run func(ctx context.Context, key string, value int64, expiration time.Duration) error) *MockCommander_SetIntIfNotExist_Call

type MockCommander_SetInt_Call 

type MockCommander_SetInt_Call struct {
	*mock.Call
}

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

func (*MockCommander_SetInt_Call) Return 

func (_c *MockCommander_SetInt_Call) Return(err error) *MockCommander_SetInt_Call

func (*MockCommander_SetInt_Call) Run 

func (_c *MockCommander_SetInt_Call) Run(run func(ctx context.Context, key string, value int64, expiration time.Duration)) *MockCommander_SetInt_Call

func (*MockCommander_SetInt_Call) RunAndReturn 

func (_c *MockCommander_SetInt_Call) RunAndReturn(run func(ctx context.Context, key string, value int64, expiration time.Duration) error) *MockCommander_SetInt_Call

type MockCommander_SetStringIfExist_Call 

type MockCommander_SetStringIfExist_Call struct {
	*mock.Call
}

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

func (*MockCommander_SetStringIfExist_Call) Return 

func (_c *MockCommander_SetStringIfExist_Call) Return(err error) *MockCommander_SetStringIfExist_Call

func (*MockCommander_SetStringIfExist_Call) Run 

func (_c *MockCommander_SetStringIfExist_Call) Run(run func(ctx context.Context, key string, value string, expiration time.Duration)) *MockCommander_SetStringIfExist_Call

func (*MockCommander_SetStringIfExist_Call) RunAndReturn 

func (_c *MockCommander_SetStringIfExist_Call) RunAndReturn(run func(ctx context.Context, key string, value string, expiration time.Duration) error) *MockCommander_SetStringIfExist_Call

type MockCommander_SetStringIfNotExist_Call 

type MockCommander_SetStringIfNotExist_Call struct {
	*mock.Call
}

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

func (*MockCommander_SetStringIfNotExist_Call) Return 

func (_c *MockCommander_SetStringIfNotExist_Call) Return(err error) *MockCommander_SetStringIfNotExist_Call

func (*MockCommander_SetStringIfNotExist_Call) Run 

func (_c *MockCommander_SetStringIfNotExist_Call) Run(run func(ctx context.Context, key string, value string, expiration time.Duration)) *MockCommander_SetStringIfNotExist_Call

func (*MockCommander_SetStringIfNotExist_Call) RunAndReturn 

func (_c *MockCommander_SetStringIfNotExist_Call) RunAndReturn(run func(ctx context.Context, key string, value string, expiration time.Duration) error) *MockCommander_SetStringIfNotExist_Call

type MockCommander_SetString_Call 

type MockCommander_SetString_Call struct {
	*mock.Call
}

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

func (*MockCommander_SetString_Call) Return 

func (_c *MockCommander_SetString_Call) Return(err error) *MockCommander_SetString_Call

func (*MockCommander_SetString_Call) Run 

func (_c *MockCommander_SetString_Call) Run(run func(ctx context.Context, key string, value string, expiration time.Duration)) *MockCommander_SetString_Call

func (*MockCommander_SetString_Call) RunAndReturn 

func (_c *MockCommander_SetString_Call) RunAndReturn(run func(ctx context.Context, key string, value string, expiration time.Duration) error) *MockCommander_SetString_Call

type MockRedisPubSub added in v1.1.6 

type MockRedisPubSub struct {
	mock.Mock
}

MockRedisPubSub is an autogenerated mock type for the RedisPubSub type

func NewMockRedisPubSub added in v1.1.6 

func NewMockRedisPubSub(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRedisPubSub

NewMockRedisPubSub creates a new instance of MockRedisPubSub. 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 (*MockRedisPubSub) Channel added in v1.1.6 

func (_mock *MockRedisPubSub) Channel(opts ...redis.ChannelOption) <-chan *redis.Message

Channel provides a mock function for the type MockRedisPubSub

func (*MockRedisPubSub) Close added in v1.1.6 

func (_mock *MockRedisPubSub) Close() error

Close provides a mock function for the type MockRedisPubSub

func (*MockRedisPubSub) EXPECT added in v1.1.6 

func (_m *MockRedisPubSub) EXPECT() *MockRedisPubSub_Expecter

func (*MockRedisPubSub) Receive added in v1.1.6 

func (_mock *MockRedisPubSub) Receive(ctx context.Context) (interface{}, error)

Receive provides a mock function for the type MockRedisPubSub

type MockRedisPubSub_Channel_Call added in v1.1.6 

type MockRedisPubSub_Channel_Call struct {
	*mock.Call
}

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

func (*MockRedisPubSub_Channel_Call) Return added in v1.1.6 

func (_c *MockRedisPubSub_Channel_Call) Return(messageCh <-chan *redis.Message) *MockRedisPubSub_Channel_Call

func (*MockRedisPubSub_Channel_Call) Run added in v1.1.6 

func (_c *MockRedisPubSub_Channel_Call) Run(run func(opts ...redis.ChannelOption)) *MockRedisPubSub_Channel_Call

func (*MockRedisPubSub_Channel_Call) RunAndReturn added in v1.1.6 

func (_c *MockRedisPubSub_Channel_Call) RunAndReturn(run func(opts ...redis.ChannelOption) <-chan *redis.Message) *MockRedisPubSub_Channel_Call

type MockRedisPubSub_Close_Call added in v1.1.6 

type MockRedisPubSub_Close_Call struct {
	*mock.Call
}

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

func (*MockRedisPubSub_Close_Call) Return added in v1.1.6 

func (_c *MockRedisPubSub_Close_Call) Return(err error) *MockRedisPubSub_Close_Call

func (*MockRedisPubSub_Close_Call) Run added in v1.1.6 

func (_c *MockRedisPubSub_Close_Call) Run(run func()) *MockRedisPubSub_Close_Call

func (*MockRedisPubSub_Close_Call) RunAndReturn added in v1.1.6 

func (_c *MockRedisPubSub_Close_Call) RunAndReturn(run func() error) *MockRedisPubSub_Close_Call

type MockRedisPubSub_Expecter added in v1.1.6 

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

func (*MockRedisPubSub_Expecter) Channel added in v1.1.6 

func (_e *MockRedisPubSub_Expecter) Channel(opts ...interface{}) *MockRedisPubSub_Channel_Call

Channel is a helper method to define mock.On call

  • opts ...redis.ChannelOption

func (*MockRedisPubSub_Expecter) Close added in v1.1.6 

func (_e *MockRedisPubSub_Expecter) Close() *MockRedisPubSub_Close_Call

Close is a helper method to define mock.On call

func (*MockRedisPubSub_Expecter) Receive added in v1.1.6 

func (_e *MockRedisPubSub_Expecter) Receive(ctx interface{}) *MockRedisPubSub_Receive_Call

Receive is a helper method to define mock.On call

  • ctx context.Context

type MockRedisPubSub_Receive_Call added in v1.1.6 

type MockRedisPubSub_Receive_Call struct {
	*mock.Call
}

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

func (*MockRedisPubSub_Receive_Call) Return added in v1.1.6 

func (_c *MockRedisPubSub_Receive_Call) Return(ifaceVal interface{}, err error) *MockRedisPubSub_Receive_Call

func (*MockRedisPubSub_Receive_Call) Run added in v1.1.6 

func (_c *MockRedisPubSub_Receive_Call) Run(run func(ctx context.Context)) *MockRedisPubSub_Receive_Call

func (*MockRedisPubSub_Receive_Call) RunAndReturn added in v1.1.6 

func (_c *MockRedisPubSub_Receive_Call) RunAndReturn(run func(ctx context.Context) (interface{}, error)) *MockRedisPubSub_Receive_Call

type MockSubscriber added in v1.1.6 

type MockSubscriber struct {
	mock.Mock
}

MockSubscriber is an autogenerated mock type for the Subscriber type

func NewMockSubscriber added in v1.1.6 

func NewMockSubscriber(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSubscriber

NewMockSubscriber creates a new instance of MockSubscriber. 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 (*MockSubscriber) EXPECT added in v1.1.6 

func (_m *MockSubscriber) EXPECT() *MockSubscriber_Expecter

func (*MockSubscriber) Subscribe added in v1.1.6 

func (_mock *MockSubscriber) Subscribe(ctx context.Context) error

Subscribe provides a mock function for the type MockSubscriber

func (*MockSubscriber) SubscribeWithOptions added in v1.1.6 

func (_mock *MockSubscriber) SubscribeWithOptions(ctx context.Context, opts ChannelOption) error

SubscribeWithOptions provides a mock function for the type MockSubscriber

type MockSubscriber_Expecter added in v1.1.6 

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

func (*MockSubscriber_Expecter) Subscribe added in v1.1.6 

func (_e *MockSubscriber_Expecter) Subscribe(ctx interface{}) *MockSubscriber_Subscribe_Call

Subscribe is a helper method to define mock.On call

  • ctx context.Context

func (*MockSubscriber_Expecter) SubscribeWithOptions added in v1.1.6 

func (_e *MockSubscriber_Expecter) SubscribeWithOptions(ctx interface{}, opts interface{}) *MockSubscriber_SubscribeWithOptions_Call

SubscribeWithOptions is a helper method to define mock.On call

  • ctx context.Context
  • opts ChannelOption

type MockSubscriber_SubscribeWithOptions_Call added in v1.1.6 

type MockSubscriber_SubscribeWithOptions_Call struct {
	*mock.Call
}

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

func (*MockSubscriber_SubscribeWithOptions_Call) Return added in v1.1.6 

func (_c *MockSubscriber_SubscribeWithOptions_Call) Return(err error) *MockSubscriber_SubscribeWithOptions_Call

func (*MockSubscriber_SubscribeWithOptions_Call) Run added in v1.1.6 

func (_c *MockSubscriber_SubscribeWithOptions_Call) Run(run func(ctx context.Context, opts ChannelOption)) *MockSubscriber_SubscribeWithOptions_Call

func (*MockSubscriber_SubscribeWithOptions_Call) RunAndReturn added in v1.1.6 

func (_c *MockSubscriber_SubscribeWithOptions_Call) RunAndReturn(run func(ctx context.Context, opts ChannelOption) error) *MockSubscriber_SubscribeWithOptions_Call

type MockSubscriber_Subscribe_Call added in v1.1.6 

type MockSubscriber_Subscribe_Call struct {
	*mock.Call
}

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

func (*MockSubscriber_Subscribe_Call) Return added in v1.1.6 

func (_c *MockSubscriber_Subscribe_Call) Return(err error) *MockSubscriber_Subscribe_Call

func (*MockSubscriber_Subscribe_Call) Run added in v1.1.6 

func (_c *MockSubscriber_Subscribe_Call) Run(run func(ctx context.Context)) *MockSubscriber_Subscribe_Call

func (*MockSubscriber_Subscribe_Call) RunAndReturn added in v1.1.6 

func (_c *MockSubscriber_Subscribe_Call) RunAndReturn(run func(ctx context.Context) error) *MockSubscriber_Subscribe_Call

type MockType 

type MockType struct {
	mock.Mock
}

MockType is an autogenerated mock type for the Type type

func NewMockType 

func NewMockType(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockType

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

func (_m *MockType) EXPECT() *MockType_Expecter

type MockType_Expecter 

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

type RedisPubSub added in v1.1.6 

type RedisPubSub interface {
	Receive(ctx context.Context) (interface{}, error)
	Channel(opts ...redis.ChannelOption) <-chan *redis.Message
	Close() error
}

type Subscriber added in v1.1.3 

type Subscriber interface {
	Subscribe(ctx context.Context) error

	SubscribeWithOptions(ctx context.Context, opts ChannelOption) error
}

type Type 

type Type interface {
	string | int64 | uint64 | float64
}

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.