redis

package

Go to main page

Versions in this module

v1

v1.1.6

Sep 12, 2025

Changes in this version

type MockClient

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

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

type MockClient_Expecter

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

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

+ type MockClient_Publish_Call struct

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

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

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

+ type MockClient_Subscribe_Call struct

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

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

+ func (_c *MockClient_Subscribe_Call) RunAndReturn(...) *MockClient_Subscribe_Call

+ type MockRedisPubSub struct

+ func NewMockRedisPubSub(t interface{ ... }) *MockRedisPubSub

+ func (_m *MockRedisPubSub) EXPECT() *MockRedisPubSub_Expecter

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

+ func (_mock *MockRedisPubSub) Close() error

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

+ type MockRedisPubSub_Channel_Call struct

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

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

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

+ type MockRedisPubSub_Close_Call struct

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

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

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

+ type MockRedisPubSub_Expecter struct

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

+ func (_e *MockRedisPubSub_Expecter) Close() *MockRedisPubSub_Close_Call

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

+ type MockRedisPubSub_Receive_Call struct

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

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

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

+ type MockSubscriber struct

+ func NewMockSubscriber(t interface{ ... }) *MockSubscriber

+ func (_m *MockSubscriber) EXPECT() *MockSubscriber_Expecter

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

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

+ type MockSubscriber_Expecter struct

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

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

+ type MockSubscriber_SubscribeWithOptions_Call struct

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

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

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

+ type MockSubscriber_Subscribe_Call struct

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

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

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

+ type RedisPubSub interface

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

+ Close func() error

+ Receive func(ctx context.Context) (interface{}, error)

v1.1.5

Aug 22, 2025

Changes in this version

+ type ChannelOption struct

+ ChannelSize int

+ HealthCheckInterval time.Duration

+ SendTimeout time.Duration

type Subscriber

+ SubscribeWithOptions func(ctx context.Context, opts ChannelOption) error

v1.1.3

Aug 6, 2025

Changes in this version

type Client

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

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

+ type Message struct

+ Channel string

+ Pattern string

+ Payload string

+ PayloadSlice []string

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

+ type Subscriber interface

+ Subscribe func(ctx context.Context) error

v1.1.2

Jul 16, 2025

v1.1.1

Jul 14, 2025

v1.1.0

Jul 11, 2025

v1.0.10

May 28, 2025

v1.0.9

Apr 22, 2025

v1.0.8

Apr 10, 2025

v1.0.7

Mar 26, 2025

v1.0.6

Mar 25, 2025

v1.0.5

Mar 20, 2025

v1.0.4

Mar 17, 2025

v1.0.3

Mar 8, 2025

v1.0.2

Mar 6, 2025

v1.0.1

Mar 5, 2025

v1.0.0

Mar 3, 2025

Changes in this version

+ const KeepTTL

+ var ErrFailToSetValue = newError("fail to set value")

+ var ErrUnsupportedInputType = newError("unsupported input type")

+ type Client interface

+ Close func() error

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

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

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

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

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

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

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

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

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

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

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

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

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

+ Ping func(ctx context.Context) error

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

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

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

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

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

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

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

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

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

+ func NewClient(url string) (Client, error)

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

+ type Commander interface

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

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

+ Discard func()

+ Execute func(ctx context.Context) error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type Error string

+ func (e Error) Error() string

+ type MockClient struct

+ func NewMockClient(t interface{ ... }) *MockClient

+ func (_m *MockClient) Close() error

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

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

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

+ func (_m *MockClient) DoInBatch(ctx context.Context, fn func(Commander) error) error

+ func (_m *MockClient) EXPECT() *MockClient_Expecter

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

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

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

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

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

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

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

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

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

+ func (_m *MockClient) Ping(ctx context.Context) error

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

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

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

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

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

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

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

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

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

+ type MockClient_Close_Call struct

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

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

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

+ type MockClient_DecrementBy_Call struct

+ func (_c *MockClient_DecrementBy_Call) Return(_a0 int64, _a1 error) *MockClient_DecrementBy_Call

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

+ func (_c *MockClient_DecrementBy_Call) RunAndReturn(run func(context.Context, string, int64) (int64, error)) *MockClient_DecrementBy_Call

+ type MockClient_Delete_Call struct

+ func (_c *MockClient_Delete_Call) Return(_a0 int64, _a1 error) *MockClient_Delete_Call

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

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

+ type MockClient_DoInBatch_Call struct

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

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

+ func (_c *MockClient_DoInBatch_Call) RunAndReturn(run func(context.Context, func(Commander) error) error) *MockClient_DoInBatch_Call

+ type MockClient_Do_Call struct

+ func (_c *MockClient_Do_Call) Return(_a0 interface{}, _a1 error) *MockClient_Do_Call

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

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

+ type MockClient_Expecter struct

+ func (_e *MockClient_Expecter) Close() *MockClient_Close_Call

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type MockClient_Expire_Call struct

+ func (_c *MockClient_Expire_Call) Return(_a0 bool, _a1 error) *MockClient_Expire_Call

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

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

+ type MockClient_GetFloat_Call struct

+ func (_c *MockClient_GetFloat_Call) Return(_a0 float64, _a1 error) *MockClient_GetFloat_Call

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

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

+ type MockClient_GetInt_Call struct

+ func (_c *MockClient_GetInt_Call) Return(_a0 int64, _a1 error) *MockClient_GetInt_Call

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

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

+ type MockClient_GetString_Call struct

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

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

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

+ type MockClient_HashGetAll_Call struct

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

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

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

+ type MockClient_HashGetField_Call struct

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

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

+ func (_c *MockClient_HashGetField_Call) RunAndReturn(run func(context.Context, string, string, interface{}) error) *MockClient_HashGetField_Call

+ type MockClient_HashSet_Call struct

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

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

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

+ type MockClient_IncrementBy_Call struct

+ func (_c *MockClient_IncrementBy_Call) Return(_a0 int64, _a1 error) *MockClient_IncrementBy_Call

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

+ func (_c *MockClient_IncrementBy_Call) RunAndReturn(run func(context.Context, string, int64) (int64, error)) *MockClient_IncrementBy_Call

+ type MockClient_IncrementFloatBy_Call struct

+ func (_c *MockClient_IncrementFloatBy_Call) Return(_a0 float64, _a1 error) *MockClient_IncrementFloatBy_Call

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

+ func (_c *MockClient_IncrementFloatBy_Call) RunAndReturn(run func(context.Context, string, float64) (float64, error)) *MockClient_IncrementFloatBy_Call

+ type MockClient_Ping_Call struct

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

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

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

+ type MockClient_SetFloatIfExist_Call struct

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

+ func (_c *MockClient_SetFloatIfExist_Call) Run(...) *MockClient_SetFloatIfExist_Call

+ func (_c *MockClient_SetFloatIfExist_Call) RunAndReturn(run func(context.Context, string, float64, time.Duration) error) *MockClient_SetFloatIfExist_Call

+ type MockClient_SetFloatIfNotExist_Call struct

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

+ func (_c *MockClient_SetFloatIfNotExist_Call) Run(...) *MockClient_SetFloatIfNotExist_Call

+ func (_c *MockClient_SetFloatIfNotExist_Call) RunAndReturn(run func(context.Context, string, float64, time.Duration) error) *MockClient_SetFloatIfNotExist_Call

+ type MockClient_SetFloat_Call struct

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

+ func (_c *MockClient_SetFloat_Call) Run(...) *MockClient_SetFloat_Call

+ func (_c *MockClient_SetFloat_Call) RunAndReturn(run func(context.Context, string, float64, time.Duration) error) *MockClient_SetFloat_Call

+ type MockClient_SetIntIfExist_Call struct

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

+ func (_c *MockClient_SetIntIfExist_Call) Run(...) *MockClient_SetIntIfExist_Call

+ func (_c *MockClient_SetIntIfExist_Call) RunAndReturn(run func(context.Context, string, int64, time.Duration) error) *MockClient_SetIntIfExist_Call

+ type MockClient_SetIntIfNotExist_Call struct

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

+ func (_c *MockClient_SetIntIfNotExist_Call) Run(...) *MockClient_SetIntIfNotExist_Call

+ func (_c *MockClient_SetIntIfNotExist_Call) RunAndReturn(run func(context.Context, string, int64, time.Duration) error) *MockClient_SetIntIfNotExist_Call

+ type MockClient_SetInt_Call struct

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

+ func (_c *MockClient_SetInt_Call) Run(...) *MockClient_SetInt_Call

+ func (_c *MockClient_SetInt_Call) RunAndReturn(run func(context.Context, string, int64, time.Duration) error) *MockClient_SetInt_Call

+ type MockClient_SetStringIfExist_Call struct

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

+ func (_c *MockClient_SetStringIfExist_Call) Run(...) *MockClient_SetStringIfExist_Call

+ func (_c *MockClient_SetStringIfExist_Call) RunAndReturn(run func(context.Context, string, string, time.Duration) error) *MockClient_SetStringIfExist_Call

+ type MockClient_SetStringIfNotExist_Call struct

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

+ func (_c *MockClient_SetStringIfNotExist_Call) Run(...) *MockClient_SetStringIfNotExist_Call

+ func (_c *MockClient_SetStringIfNotExist_Call) RunAndReturn(run func(context.Context, string, string, time.Duration) error) *MockClient_SetStringIfNotExist_Call

+ type MockClient_SetString_Call struct

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

+ func (_c *MockClient_SetString_Call) Run(...) *MockClient_SetString_Call

+ func (_c *MockClient_SetString_Call) RunAndReturn(run func(context.Context, string, string, time.Duration) error) *MockClient_SetString_Call

+ type MockCommander struct

+ func NewMockCommander(t interface{ ... }) *MockCommander

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

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

+ func (_m *MockCommander) Discard()

+ func (_m *MockCommander) EXPECT() *MockCommander_Expecter

+ func (_m *MockCommander) Execute(ctx context.Context) error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type MockCommander_DecrementBy_Call struct

+ func (_c *MockCommander_DecrementBy_Call) Return(_a0 int64, _a1 error) *MockCommander_DecrementBy_Call

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

+ func (_c *MockCommander_DecrementBy_Call) RunAndReturn(run func(context.Context, string, int64) (int64, error)) *MockCommander_DecrementBy_Call

+ type MockCommander_Delete_Call struct

+ func (_c *MockCommander_Delete_Call) Return(_a0 int64, _a1 error) *MockCommander_Delete_Call

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

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

+ type MockCommander_Discard_Call struct

+ func (_c *MockCommander_Discard_Call) Return() *MockCommander_Discard_Call

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

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

+ type MockCommander_Execute_Call struct

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

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

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

+ type MockCommander_Expecter struct

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

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

+ func (_e *MockCommander_Expecter) Discard() *MockCommander_Discard_Call

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type MockCommander_Expire_Call struct

+ func (_c *MockCommander_Expire_Call) Return(_a0 bool, _a1 error) *MockCommander_Expire_Call

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

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

+ type MockCommander_GetFloat_Call struct

+ func (_c *MockCommander_GetFloat_Call) Return(_a0 float64, _a1 error) *MockCommander_GetFloat_Call

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

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

+ type MockCommander_GetInt_Call struct

+ func (_c *MockCommander_GetInt_Call) Return(_a0 int64, _a1 error) *MockCommander_GetInt_Call

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

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

+ type MockCommander_GetString_Call struct

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

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

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

+ type MockCommander_HashGetAll_Call struct

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

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

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

+ type MockCommander_HashGetField_Call struct

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

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

+ func (_c *MockCommander_HashGetField_Call) RunAndReturn(run func(context.Context, string, string, interface{}) error) *MockCommander_HashGetField_Call

+ type MockCommander_HashSet_Call struct

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

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

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

+ type MockCommander_IncrementBy_Call struct

+ func (_c *MockCommander_IncrementBy_Call) Return(_a0 int64, _a1 error) *MockCommander_IncrementBy_Call

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

+ func (_c *MockCommander_IncrementBy_Call) RunAndReturn(run func(context.Context, string, int64) (int64, error)) *MockCommander_IncrementBy_Call

+ type MockCommander_IncrementFloatBy_Call struct

+ func (_c *MockCommander_IncrementFloatBy_Call) Return(_a0 float64, _a1 error) *MockCommander_IncrementFloatBy_Call

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

+ func (_c *MockCommander_IncrementFloatBy_Call) RunAndReturn(run func(context.Context, string, float64) (float64, error)) *MockCommander_IncrementFloatBy_Call

+ type MockCommander_SetFloatIfExist_Call struct

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

+ func (_c *MockCommander_SetFloatIfExist_Call) Run(...) *MockCommander_SetFloatIfExist_Call

+ func (_c *MockCommander_SetFloatIfExist_Call) RunAndReturn(run func(context.Context, string, float64, time.Duration) error) *MockCommander_SetFloatIfExist_Call

+ type MockCommander_SetFloatIfNotExist_Call struct

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

+ func (_c *MockCommander_SetFloatIfNotExist_Call) Run(...) *MockCommander_SetFloatIfNotExist_Call

+ func (_c *MockCommander_SetFloatIfNotExist_Call) RunAndReturn(run func(context.Context, string, float64, time.Duration) error) *MockCommander_SetFloatIfNotExist_Call

+ type MockCommander_SetFloat_Call struct

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

+ func (_c *MockCommander_SetFloat_Call) Run(...) *MockCommander_SetFloat_Call

+ func (_c *MockCommander_SetFloat_Call) RunAndReturn(run func(context.Context, string, float64, time.Duration) error) *MockCommander_SetFloat_Call

+ type MockCommander_SetIntIfExist_Call struct

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

+ func (_c *MockCommander_SetIntIfExist_Call) Run(...) *MockCommander_SetIntIfExist_Call

+ func (_c *MockCommander_SetIntIfExist_Call) RunAndReturn(run func(context.Context, string, int64, time.Duration) error) *MockCommander_SetIntIfExist_Call

+ type MockCommander_SetIntIfNotExist_Call struct

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

+ func (_c *MockCommander_SetIntIfNotExist_Call) Run(...) *MockCommander_SetIntIfNotExist_Call

+ func (_c *MockCommander_SetIntIfNotExist_Call) RunAndReturn(run func(context.Context, string, int64, time.Duration) error) *MockCommander_SetIntIfNotExist_Call

+ type MockCommander_SetInt_Call struct

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

+ func (_c *MockCommander_SetInt_Call) Run(...) *MockCommander_SetInt_Call

+ func (_c *MockCommander_SetInt_Call) RunAndReturn(run func(context.Context, string, int64, time.Duration) error) *MockCommander_SetInt_Call

+ type MockCommander_SetStringIfExist_Call struct

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

+ func (_c *MockCommander_SetStringIfExist_Call) Run(...) *MockCommander_SetStringIfExist_Call

+ func (_c *MockCommander_SetStringIfExist_Call) RunAndReturn(run func(context.Context, string, string, time.Duration) error) *MockCommander_SetStringIfExist_Call

+ type MockCommander_SetStringIfNotExist_Call struct

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

+ func (_c *MockCommander_SetStringIfNotExist_Call) Run(...) *MockCommander_SetStringIfNotExist_Call

+ func (_c *MockCommander_SetStringIfNotExist_Call) RunAndReturn(run func(context.Context, string, string, time.Duration) error) *MockCommander_SetStringIfNotExist_Call

+ type MockCommander_SetString_Call struct

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

+ func (_c *MockCommander_SetString_Call) Run(...) *MockCommander_SetString_Call

+ func (_c *MockCommander_SetString_Call) RunAndReturn(run func(context.Context, string, string, time.Duration) error) *MockCommander_SetString_Call

+ type MockType struct

+ func NewMockType(t interface{ ... }) *MockType

+ func (_m *MockType) EXPECT() *MockType_Expecter

+ type MockType_Expecter struct

+ type Type interface

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL