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

redis

package

Go to main page

Versions in this module

v1

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