mocks

package
v0.18.1 Latest Latest
Warning

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

 Go to latest Published: May 16, 2024 License: MIT Imports: 5 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Client 

type Client struct {
	mock.Mock
}

Client is an autogenerated mock type for the Client type

func NewClient 

func NewClient(t mockConstructorTestingTNewClient) *Client

NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*Client) BLPop 

func (_m *Client) BLPop(ctx context.Context, timeout time.Duration, keys ...string) ([]string, error)

BLPop provides a mock function with given fields: ctx, timeout, keys

func (*Client) DBSize 

func (_m *Client) DBSize(ctx context.Context) (int64, error)

DBSize provides a mock function with given fields: ctx

func (*Client) Decr 

func (_m *Client) Decr(ctx context.Context, key string) (int64, error)

Decr provides a mock function with given fields: ctx, key

func (*Client) DecrBy 

func (_m *Client) DecrBy(ctx context.Context, key string, amount int64) (int64, error)

DecrBy provides a mock function with given fields: ctx, key, amount

func (*Client) Del 

func (_m *Client) Del(ctx context.Context, keys ...string) (int64, error)

Del provides a mock function with given fields: ctx, keys

func (*Client) EXPECT 

func (_m *Client) EXPECT() *Client_Expecter

func (*Client) Exists 

func (_m *Client) Exists(ctx context.Context, keys ...string) (int64, error)

Exists provides a mock function with given fields: ctx, keys

func (*Client) Expire 

func (_m *Client) Expire(ctx context.Context, key string, ttl time.Duration) (bool, error)

Expire provides a mock function with given fields: ctx, key, ttl

func (*Client) FlushDB 

func (_m *Client) FlushDB(ctx context.Context) (string, error)

FlushDB provides a mock function with given fields: ctx

func (*Client) Get 

func (_m *Client) Get(ctx context.Context, key string) (string, error)

Get provides a mock function with given fields: ctx, key

func (*Client) GetDel 

func (_m *Client) GetDel(ctx context.Context, key string) (interface{}, error)

GetDel provides a mock function with given fields: ctx, key

func (*Client) GetSet added in v0.8.1 

func (_m *Client) GetSet(ctx context.Context, key string, value interface{}) (interface{}, error)

GetSet provides a mock function with given fields: ctx, key, value

func (*Client) HDel 

func (_m *Client) HDel(ctx context.Context, key string, fields ...string) (int64, error)

HDel provides a mock function with given fields: ctx, key, fields

func (*Client) HExists 

func (_m *Client) HExists(ctx context.Context, key string, field string) (bool, error)

HExists provides a mock function with given fields: ctx, key, field

func (*Client) HGet 

func (_m *Client) HGet(ctx context.Context, key string, field string) (string, error)

HGet provides a mock function with given fields: ctx, key, field

func (*Client) HGetAll 

func (_m *Client) HGetAll(ctx context.Context, key string) (map[string]string, error)

HGetAll provides a mock function with given fields: ctx, key

func (*Client) HKeys 

func (_m *Client) HKeys(ctx context.Context, key string) ([]string, error)

HKeys provides a mock function with given fields: ctx, key

func (*Client) HMGet 

func (_m *Client) HMGet(ctx context.Context, key string, fields ...string) ([]interface{}, error)

HMGet provides a mock function with given fields: ctx, key, fields

func (*Client) HMSet 

func (_m *Client) HMSet(ctx context.Context, key string, pairs map[string]interface{}) error

HMSet provides a mock function with given fields: ctx, key, pairs

func (*Client) HSet 

func (_m *Client) HSet(ctx context.Context, key string, field string, value interface{}) error

HSet provides a mock function with given fields: ctx, key, field, value

func (*Client) HSetNX 

func (_m *Client) HSetNX(ctx context.Context, key string, field string, value interface{}) (bool, error)

HSetNX provides a mock function with given fields: ctx, key, field, value

func (*Client) Incr 

func (_m *Client) Incr(ctx context.Context, key string) (int64, error)

Incr provides a mock function with given fields: ctx, key

func (*Client) IncrBy 

func (_m *Client) IncrBy(ctx context.Context, key string, amount int64) (int64, error)

IncrBy provides a mock function with given fields: ctx, key, amount

func (*Client) IsAlive 

func (_m *Client) IsAlive(ctx context.Context) bool

IsAlive provides a mock function with given fields: ctx

func (*Client) LLen 

func (_m *Client) LLen(ctx context.Context, key string) (int64, error)

LLen provides a mock function with given fields: ctx, key

func (*Client) LPop 

func (_m *Client) LPop(ctx context.Context, key string) (string, error)

LPop provides a mock function with given fields: ctx, key

func (*Client) LPush 

func (_m *Client) LPush(ctx context.Context, key string, values ...interface{}) (int64, error)

LPush provides a mock function with given fields: ctx, key, values

func (*Client) LRem 

func (_m *Client) LRem(ctx context.Context, key string, count int64, value interface{}) (int64, error)

LRem provides a mock function with given fields: ctx, key, count, value

func (*Client) MGet 

func (_m *Client) MGet(ctx context.Context, keys ...string) ([]interface{}, error)

MGet provides a mock function with given fields: ctx, keys

func (*Client) MSet 

func (_m *Client) MSet(ctx context.Context, pairs ...interface{}) error

MSet provides a mock function with given fields: ctx, pairs

func (*Client) PFAdd 

func (_m *Client) PFAdd(ctx context.Context, key string, els ...interface{}) (int64, error)

PFAdd provides a mock function with given fields: ctx, key, els

func (*Client) PFCount 

func (_m *Client) PFCount(ctx context.Context, keys ...string) (int64, error)

PFCount provides a mock function with given fields: ctx, keys

func (*Client) PFMerge 

func (_m *Client) PFMerge(ctx context.Context, dest string, keys ...string) (string, error)

PFMerge provides a mock function with given fields: ctx, dest, keys

func (*Client) Pipeline 

func (_m *Client) Pipeline() redis.Pipeliner

Pipeline provides a mock function with given fields:

func (*Client) RPop 

func (_m *Client) RPop(ctx context.Context, key string) (string, error)

RPop provides a mock function with given fields: ctx, key

func (*Client) RPush 

func (_m *Client) RPush(ctx context.Context, key string, values ...interface{}) (int64, error)

RPush provides a mock function with given fields: ctx, key, values

func (*Client) SAdd 

func (_m *Client) SAdd(ctx context.Context, key string, values ...interface{}) (int64, error)

SAdd provides a mock function with given fields: ctx, key, values

func (*Client) SCard 

func (_m *Client) SCard(ctx context.Context, key string) (int64, error)

SCard provides a mock function with given fields: ctx, key

func (*Client) SDiff 

func (_m *Client) SDiff(ctx context.Context, keys ...string) ([]string, error)

SDiff provides a mock function with given fields: ctx, keys

func (*Client) SDiffStore 

func (_m *Client) SDiffStore(ctx context.Context, destination string, keys ...string) (int64, error)

SDiffStore provides a mock function with given fields: ctx, destination, keys

func (*Client) SInter 

func (_m *Client) SInter(ctx context.Context, keys ...string) ([]string, error)

SInter provides a mock function with given fields: ctx, keys

func (*Client) SInterStore 

func (_m *Client) SInterStore(ctx context.Context, destination string, keys ...string) (int64, error)

SInterStore provides a mock function with given fields: ctx, destination, keys

func (*Client) SIsMember 

func (_m *Client) SIsMember(ctx context.Context, key string, value interface{}) (bool, error)

SIsMember provides a mock function with given fields: ctx, key, value

func (*Client) SMembers 

func (_m *Client) SMembers(ctx context.Context, key string) ([]string, error)

SMembers provides a mock function with given fields: ctx, key

func (*Client) SMove 

func (_m *Client) SMove(ctx context.Context, sourceKey string, destKey string, member interface{}) (bool, error)

SMove provides a mock function with given fields: ctx, sourceKey, destKey, member

func (*Client) SPop 

func (_m *Client) SPop(ctx context.Context, key string) (string, error)

SPop provides a mock function with given fields: ctx, key

func (*Client) SRandMember 

func (_m *Client) SRandMember(ctx context.Context, key string) (string, error)

SRandMember provides a mock function with given fields: ctx, key

func (*Client) SRem 

func (_m *Client) SRem(ctx context.Context, key string, values ...interface{}) (int64, error)

SRem provides a mock function with given fields: ctx, key, values

func (*Client) SUnion 

func (_m *Client) SUnion(ctx context.Context, keys ...string) ([]string, error)

SUnion provides a mock function with given fields: ctx, keys

func (*Client) SUnionStore 

func (_m *Client) SUnionStore(ctx context.Context, destination string, keys ...string) (int64, error)

SUnionStore provides a mock function with given fields: ctx, destination, keys

func (*Client) Set 

func (_m *Client) Set(ctx context.Context, key string, value interface{}, ttl time.Duration) error

Set provides a mock function with given fields: ctx, key, value, ttl

func (*Client) SetNX 

func (_m *Client) SetNX(ctx context.Context, key string, value interface{}, ttl time.Duration) (bool, error)

SetNX provides a mock function with given fields: ctx, key, value, ttl

func (*Client) ZAdd 

func (_m *Client) ZAdd(ctx context.Context, key string, score float64, member string) (int64, error)

ZAdd provides a mock function with given fields: ctx, key, score, member

func (*Client) ZAddArgs 

func (_m *Client) ZAddArgs(ctx context.Context, args redis.ZAddArgs) (int64, error)

ZAddArgs provides a mock function with given fields: ctx, args

func (*Client) ZAddArgsIncr 

func (_m *Client) ZAddArgsIncr(ctx context.Context, args redis.ZAddArgs) (float64, error)

ZAddArgsIncr provides a mock function with given fields: ctx, args

func (*Client) ZCard 

func (_m *Client) ZCard(ctx context.Context, key string) (int64, error)

ZCard provides a mock function with given fields: ctx, key

func (*Client) ZCount 

func (_m *Client) ZCount(ctx context.Context, key string, min string, max string) (int64, error)

ZCount provides a mock function with given fields: ctx, key, min, max

func (*Client) ZIncrBy 

func (_m *Client) ZIncrBy(ctx context.Context, key string, increment float64, member string) (float64, error)

ZIncrBy provides a mock function with given fields: ctx, key, increment, member

func (*Client) ZMScore 

func (_m *Client) ZMScore(ctx context.Context, key string, members ...string) ([]float64, error)

ZMScore provides a mock function with given fields: ctx, key, members

func (*Client) ZRandMember 

func (_m *Client) ZRandMember(ctx context.Context, key string, count int) ([]string, error)

ZRandMember provides a mock function with given fields: ctx, key, count

func (*Client) ZRange 

func (_m *Client) ZRange(ctx context.Context, key string, start int64, stop int64) ([]string, error)

ZRange provides a mock function with given fields: ctx, key, start, stop

func (*Client) ZRangeArgs 

func (_m *Client) ZRangeArgs(ctx context.Context, args redis.ZRangeArgs) ([]string, error)

ZRangeArgs provides a mock function with given fields: ctx, args

func (*Client) ZRangeArgsWithScore 

func (_m *Client) ZRangeArgsWithScore(ctx context.Context, args redis.ZRangeArgs) ([]redis.Z, error)

ZRangeArgsWithScore provides a mock function with given fields: ctx, args

func (*Client) ZRank 

func (_m *Client) ZRank(ctx context.Context, key string, member string) (int64, error)

ZRank provides a mock function with given fields: ctx, key, member

func (*Client) ZRem 

func (_m *Client) ZRem(ctx context.Context, key string, members ...string) (int64, error)

ZRem provides a mock function with given fields: ctx, key, members

func (*Client) ZRevRank 

func (_m *Client) ZRevRank(ctx context.Context, key string, member string) (int64, error)

ZRevRank provides a mock function with given fields: ctx, key, member

func (*Client) ZScore 

func (_m *Client) ZScore(ctx context.Context, key string, member string) (float64, error)

ZScore provides a mock function with given fields: ctx, key, member

type Client_BLPop_Call 

type Client_BLPop_Call struct {
	*mock.Call
}

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

func (*Client_BLPop_Call) Return 

func (_c *Client_BLPop_Call) Return(_a0 []string, _a1 error) *Client_BLPop_Call

func (*Client_BLPop_Call) Run 

func (_c *Client_BLPop_Call) Run(run func(ctx context.Context, timeout time.Duration, keys ...string)) *Client_BLPop_Call

func (*Client_BLPop_Call) RunAndReturn 

func (_c *Client_BLPop_Call) RunAndReturn(run func(context.Context, time.Duration, ...string) ([]string, error)) *Client_BLPop_Call

type Client_DBSize_Call 

type Client_DBSize_Call struct {
	*mock.Call
}

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

func (*Client_DBSize_Call) Return 

func (_c *Client_DBSize_Call) Return(_a0 int64, _a1 error) *Client_DBSize_Call

func (*Client_DBSize_Call) Run 

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

func (*Client_DBSize_Call) RunAndReturn 

func (_c *Client_DBSize_Call) RunAndReturn(run func(context.Context) (int64, error)) *Client_DBSize_Call

type Client_DecrBy_Call 

type Client_DecrBy_Call struct {
	*mock.Call
}

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

func (*Client_DecrBy_Call) Return 

func (_c *Client_DecrBy_Call) Return(_a0 int64, _a1 error) *Client_DecrBy_Call

func (*Client_DecrBy_Call) Run 

func (_c *Client_DecrBy_Call) Run(run func(ctx context.Context, key string, amount int64)) *Client_DecrBy_Call

func (*Client_DecrBy_Call) RunAndReturn 

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

type Client_Decr_Call 

type Client_Decr_Call struct {
	*mock.Call
}

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

func (*Client_Decr_Call) Return 

func (_c *Client_Decr_Call) Return(_a0 int64, _a1 error) *Client_Decr_Call

func (*Client_Decr_Call) Run 

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

func (*Client_Decr_Call) RunAndReturn 

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

type Client_Del_Call 

type Client_Del_Call struct {
	*mock.Call
}

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

func (*Client_Del_Call) Return 

func (_c *Client_Del_Call) Return(_a0 int64, _a1 error) *Client_Del_Call

func (*Client_Del_Call) Run 

func (_c *Client_Del_Call) Run(run func(ctx context.Context, keys ...string)) *Client_Del_Call

func (*Client_Del_Call) RunAndReturn 

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

type Client_Exists_Call 

type Client_Exists_Call struct {
	*mock.Call
}

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

func (*Client_Exists_Call) Return 

func (_c *Client_Exists_Call) Return(_a0 int64, _a1 error) *Client_Exists_Call

func (*Client_Exists_Call) Run 

func (_c *Client_Exists_Call) Run(run func(ctx context.Context, keys ...string)) *Client_Exists_Call

func (*Client_Exists_Call) RunAndReturn 

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

type Client_Expecter 

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

func (*Client_Expecter) BLPop 

func (_e *Client_Expecter) BLPop(ctx interface{}, timeout interface{}, keys ...interface{}) *Client_BLPop_Call

BLPop is a helper method to define mock.On call

  • ctx context.Context
  • timeout time.Duration
  • keys ...string

func (*Client_Expecter) DBSize 

func (_e *Client_Expecter) DBSize(ctx interface{}) *Client_DBSize_Call

DBSize is a helper method to define mock.On call

  • ctx context.Context

func (*Client_Expecter) Decr 

func (_e *Client_Expecter) Decr(ctx interface{}, key interface{}) *Client_Decr_Call

Decr is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Client_Expecter) DecrBy 

func (_e *Client_Expecter) DecrBy(ctx interface{}, key interface{}, amount interface{}) *Client_DecrBy_Call

DecrBy is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • amount int64

func (*Client_Expecter) Del 

func (_e *Client_Expecter) Del(ctx interface{}, keys ...interface{}) *Client_Del_Call

Del is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Client_Expecter) Exists 

func (_e *Client_Expecter) Exists(ctx interface{}, keys ...interface{}) *Client_Exists_Call

Exists is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Client_Expecter) Expire 

func (_e *Client_Expecter) Expire(ctx interface{}, key interface{}, ttl interface{}) *Client_Expire_Call

Expire is a helper method to define mock.On call

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

func (*Client_Expecter) FlushDB 

func (_e *Client_Expecter) FlushDB(ctx interface{}) *Client_FlushDB_Call

FlushDB is a helper method to define mock.On call

  • ctx context.Context

func (*Client_Expecter) Get 

func (_e *Client_Expecter) Get(ctx interface{}, key interface{}) *Client_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Client_Expecter) GetDel 

func (_e *Client_Expecter) GetDel(ctx interface{}, key interface{}) *Client_GetDel_Call

GetDel is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Client_Expecter) GetSet added in v0.8.1 

func (_e *Client_Expecter) GetSet(ctx interface{}, key interface{}, value interface{}) *Client_GetSet_Call

GetSet is a helper method to define mock.On call

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

func (*Client_Expecter) HDel 

func (_e *Client_Expecter) HDel(ctx interface{}, key interface{}, fields ...interface{}) *Client_HDel_Call

HDel is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • fields ...string

func (*Client_Expecter) HExists 

func (_e *Client_Expecter) HExists(ctx interface{}, key interface{}, field interface{}) *Client_HExists_Call

HExists is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • field string

func (*Client_Expecter) HGet 

func (_e *Client_Expecter) HGet(ctx interface{}, key interface{}, field interface{}) *Client_HGet_Call

HGet is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • field string

func (*Client_Expecter) HGetAll 

func (_e *Client_Expecter) HGetAll(ctx interface{}, key interface{}) *Client_HGetAll_Call

HGetAll is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Client_Expecter) HKeys 

func (_e *Client_Expecter) HKeys(ctx interface{}, key interface{}) *Client_HKeys_Call

HKeys is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Client_Expecter) HMGet 

func (_e *Client_Expecter) HMGet(ctx interface{}, key interface{}, fields ...interface{}) *Client_HMGet_Call

HMGet is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • fields ...string

func (*Client_Expecter) HMSet 

func (_e *Client_Expecter) HMSet(ctx interface{}, key interface{}, pairs interface{}) *Client_HMSet_Call

HMSet is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • pairs map[string]interface{}

func (*Client_Expecter) HSet 

func (_e *Client_Expecter) HSet(ctx interface{}, key interface{}, field interface{}, value interface{}) *Client_HSet_Call

HSet is a helper method to define mock.On call

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

func (*Client_Expecter) HSetNX 

func (_e *Client_Expecter) HSetNX(ctx interface{}, key interface{}, field interface{}, value interface{}) *Client_HSetNX_Call

HSetNX is a helper method to define mock.On call

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

func (*Client_Expecter) Incr 

func (_e *Client_Expecter) Incr(ctx interface{}, key interface{}) *Client_Incr_Call

Incr is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Client_Expecter) IncrBy 

func (_e *Client_Expecter) IncrBy(ctx interface{}, key interface{}, amount interface{}) *Client_IncrBy_Call

IncrBy is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • amount int64

func (*Client_Expecter) IsAlive 

func (_e *Client_Expecter) IsAlive(ctx interface{}) *Client_IsAlive_Call

IsAlive is a helper method to define mock.On call

  • ctx context.Context

func (*Client_Expecter) LLen 

func (_e *Client_Expecter) LLen(ctx interface{}, key interface{}) *Client_LLen_Call

LLen is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Client_Expecter) LPop 

func (_e *Client_Expecter) LPop(ctx interface{}, key interface{}) *Client_LPop_Call

LPop is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Client_Expecter) LPush 

func (_e *Client_Expecter) LPush(ctx interface{}, key interface{}, values ...interface{}) *Client_LPush_Call

LPush is a helper method to define mock.On call

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

func (*Client_Expecter) LRem 

func (_e *Client_Expecter) LRem(ctx interface{}, key interface{}, count interface{}, value interface{}) *Client_LRem_Call

LRem is a helper method to define mock.On call

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

func (*Client_Expecter) MGet 

func (_e *Client_Expecter) MGet(ctx interface{}, keys ...interface{}) *Client_MGet_Call

MGet is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Client_Expecter) MSet 

func (_e *Client_Expecter) MSet(ctx interface{}, pairs ...interface{}) *Client_MSet_Call

MSet is a helper method to define mock.On call

  • ctx context.Context
  • pairs ...interface{}

func (*Client_Expecter) PFAdd 

func (_e *Client_Expecter) PFAdd(ctx interface{}, key interface{}, els ...interface{}) *Client_PFAdd_Call

PFAdd is a helper method to define mock.On call

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

func (*Client_Expecter) PFCount 

func (_e *Client_Expecter) PFCount(ctx interface{}, keys ...interface{}) *Client_PFCount_Call

PFCount is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Client_Expecter) PFMerge 

func (_e *Client_Expecter) PFMerge(ctx interface{}, dest interface{}, keys ...interface{}) *Client_PFMerge_Call

PFMerge is a helper method to define mock.On call

  • ctx context.Context
  • dest string
  • keys ...string

func (*Client_Expecter) Pipeline 

func (_e *Client_Expecter) Pipeline() *Client_Pipeline_Call

Pipeline is a helper method to define mock.On call

func (*Client_Expecter) RPop 

func (_e *Client_Expecter) RPop(ctx interface{}, key interface{}) *Client_RPop_Call

RPop is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Client_Expecter) RPush 

func (_e *Client_Expecter) RPush(ctx interface{}, key interface{}, values ...interface{}) *Client_RPush_Call

RPush is a helper method to define mock.On call

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

func (*Client_Expecter) SAdd 

func (_e *Client_Expecter) SAdd(ctx interface{}, key interface{}, values ...interface{}) *Client_SAdd_Call

SAdd is a helper method to define mock.On call

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

func (*Client_Expecter) SCard 

func (_e *Client_Expecter) SCard(ctx interface{}, key interface{}) *Client_SCard_Call

SCard is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Client_Expecter) SDiff 

func (_e *Client_Expecter) SDiff(ctx interface{}, keys ...interface{}) *Client_SDiff_Call

SDiff is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Client_Expecter) SDiffStore 

func (_e *Client_Expecter) SDiffStore(ctx interface{}, destination interface{}, keys ...interface{}) *Client_SDiffStore_Call

SDiffStore is a helper method to define mock.On call

  • ctx context.Context
  • destination string
  • keys ...string

func (*Client_Expecter) SInter 

func (_e *Client_Expecter) SInter(ctx interface{}, keys ...interface{}) *Client_SInter_Call

SInter is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Client_Expecter) SInterStore 

func (_e *Client_Expecter) SInterStore(ctx interface{}, destination interface{}, keys ...interface{}) *Client_SInterStore_Call

SInterStore is a helper method to define mock.On call

  • ctx context.Context
  • destination string
  • keys ...string

func (*Client_Expecter) SIsMember 

func (_e *Client_Expecter) SIsMember(ctx interface{}, key interface{}, value interface{}) *Client_SIsMember_Call

SIsMember is a helper method to define mock.On call

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

func (*Client_Expecter) SMembers 

func (_e *Client_Expecter) SMembers(ctx interface{}, key interface{}) *Client_SMembers_Call

SMembers is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Client_Expecter) SMove 

func (_e *Client_Expecter) SMove(ctx interface{}, sourceKey interface{}, destKey interface{}, member interface{}) *Client_SMove_Call

SMove is a helper method to define mock.On call

  • ctx context.Context
  • sourceKey string
  • destKey string
  • member interface{}

func (*Client_Expecter) SPop 

func (_e *Client_Expecter) SPop(ctx interface{}, key interface{}) *Client_SPop_Call

SPop is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Client_Expecter) SRandMember 

func (_e *Client_Expecter) SRandMember(ctx interface{}, key interface{}) *Client_SRandMember_Call

SRandMember is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Client_Expecter) SRem 

func (_e *Client_Expecter) SRem(ctx interface{}, key interface{}, values ...interface{}) *Client_SRem_Call

SRem is a helper method to define mock.On call

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

func (*Client_Expecter) SUnion 

func (_e *Client_Expecter) SUnion(ctx interface{}, keys ...interface{}) *Client_SUnion_Call

SUnion is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Client_Expecter) SUnionStore 

func (_e *Client_Expecter) SUnionStore(ctx interface{}, destination interface{}, keys ...interface{}) *Client_SUnionStore_Call

SUnionStore is a helper method to define mock.On call

  • ctx context.Context
  • destination string
  • keys ...string

func (*Client_Expecter) Set 

func (_e *Client_Expecter) Set(ctx interface{}, key interface{}, value interface{}, ttl interface{}) *Client_Set_Call

Set is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value interface{}
  • ttl time.Duration

func (*Client_Expecter) SetNX 

func (_e *Client_Expecter) SetNX(ctx interface{}, key interface{}, value interface{}, ttl interface{}) *Client_SetNX_Call

SetNX is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value interface{}
  • ttl time.Duration

func (*Client_Expecter) ZAdd 

func (_e *Client_Expecter) ZAdd(ctx interface{}, key interface{}, score interface{}, member interface{}) *Client_ZAdd_Call

ZAdd is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • score float64
  • member string

func (*Client_Expecter) ZAddArgs 

func (_e *Client_Expecter) ZAddArgs(ctx interface{}, args interface{}) *Client_ZAddArgs_Call

ZAddArgs is a helper method to define mock.On call

  • ctx context.Context
  • args redis.ZAddArgs

func (*Client_Expecter) ZAddArgsIncr 

func (_e *Client_Expecter) ZAddArgsIncr(ctx interface{}, args interface{}) *Client_ZAddArgsIncr_Call

ZAddArgsIncr is a helper method to define mock.On call

  • ctx context.Context
  • args redis.ZAddArgs

func (*Client_Expecter) ZCard 

func (_e *Client_Expecter) ZCard(ctx interface{}, key interface{}) *Client_ZCard_Call

ZCard is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Client_Expecter) ZCount 

func (_e *Client_Expecter) ZCount(ctx interface{}, key interface{}, min interface{}, max interface{}) *Client_ZCount_Call

ZCount is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • min string
  • max string

func (*Client_Expecter) ZIncrBy 

func (_e *Client_Expecter) ZIncrBy(ctx interface{}, key interface{}, increment interface{}, member interface{}) *Client_ZIncrBy_Call

ZIncrBy is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • increment float64
  • member string

func (*Client_Expecter) ZMScore 

func (_e *Client_Expecter) ZMScore(ctx interface{}, key interface{}, members ...interface{}) *Client_ZMScore_Call

ZMScore is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • members ...string

func (*Client_Expecter) ZRandMember 

func (_e *Client_Expecter) ZRandMember(ctx interface{}, key interface{}, count interface{}) *Client_ZRandMember_Call

ZRandMember is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • count int

func (*Client_Expecter) ZRange 

func (_e *Client_Expecter) ZRange(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Client_ZRange_Call

ZRange is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • start int64
  • stop int64

func (*Client_Expecter) ZRangeArgs 

func (_e *Client_Expecter) ZRangeArgs(ctx interface{}, args interface{}) *Client_ZRangeArgs_Call

ZRangeArgs is a helper method to define mock.On call

  • ctx context.Context
  • args redis.ZRangeArgs

func (*Client_Expecter) ZRangeArgsWithScore 

func (_e *Client_Expecter) ZRangeArgsWithScore(ctx interface{}, args interface{}) *Client_ZRangeArgsWithScore_Call

ZRangeArgsWithScore is a helper method to define mock.On call

  • ctx context.Context
  • args redis.ZRangeArgs

func (*Client_Expecter) ZRank 

func (_e *Client_Expecter) ZRank(ctx interface{}, key interface{}, member interface{}) *Client_ZRank_Call

ZRank is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • member string

func (*Client_Expecter) ZRem 

func (_e *Client_Expecter) ZRem(ctx interface{}, key interface{}, members ...interface{}) *Client_ZRem_Call

ZRem is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • members ...string

func (*Client_Expecter) ZRevRank 

func (_e *Client_Expecter) ZRevRank(ctx interface{}, key interface{}, member interface{}) *Client_ZRevRank_Call

ZRevRank is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • member string

func (*Client_Expecter) ZScore 

func (_e *Client_Expecter) ZScore(ctx interface{}, key interface{}, member interface{}) *Client_ZScore_Call

ZScore is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • member string

type Client_Expire_Call 

type Client_Expire_Call struct {
	*mock.Call
}

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

func (*Client_Expire_Call) Return 

func (_c *Client_Expire_Call) Return(_a0 bool, _a1 error) *Client_Expire_Call

func (*Client_Expire_Call) Run 

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

func (*Client_Expire_Call) RunAndReturn 

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

type Client_FlushDB_Call 

type Client_FlushDB_Call struct {
	*mock.Call
}

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

func (*Client_FlushDB_Call) Return 

func (_c *Client_FlushDB_Call) Return(_a0 string, _a1 error) *Client_FlushDB_Call

func (*Client_FlushDB_Call) Run 

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

func (*Client_FlushDB_Call) RunAndReturn 

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

type Client_GetDel_Call 

type Client_GetDel_Call struct {
	*mock.Call
}

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

func (*Client_GetDel_Call) Return 

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

func (*Client_GetDel_Call) Run 

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

func (*Client_GetDel_Call) RunAndReturn 

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

type Client_GetSet_Call added in v0.8.1 

type Client_GetSet_Call struct {
	*mock.Call
}

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

func (*Client_GetSet_Call) Return added in v0.8.1 

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

func (*Client_GetSet_Call) Run added in v0.8.1 

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

func (*Client_GetSet_Call) RunAndReturn added in v0.8.1 

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

type Client_Get_Call 

type Client_Get_Call struct {
	*mock.Call
}

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

func (*Client_Get_Call) Return 

func (_c *Client_Get_Call) Return(_a0 string, _a1 error) *Client_Get_Call

func (*Client_Get_Call) Run 

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

func (*Client_Get_Call) RunAndReturn 

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

type Client_HDel_Call 

type Client_HDel_Call struct {
	*mock.Call
}

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

func (*Client_HDel_Call) Return 

func (_c *Client_HDel_Call) Return(_a0 int64, _a1 error) *Client_HDel_Call

func (*Client_HDel_Call) Run 

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

func (*Client_HDel_Call) RunAndReturn 

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

type Client_HExists_Call 

type Client_HExists_Call struct {
	*mock.Call
}

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

func (*Client_HExists_Call) Return 

func (_c *Client_HExists_Call) Return(_a0 bool, _a1 error) *Client_HExists_Call

func (*Client_HExists_Call) Run 

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

func (*Client_HExists_Call) RunAndReturn 

func (_c *Client_HExists_Call) RunAndReturn(run func(context.Context, string, string) (bool, error)) *Client_HExists_Call

type Client_HGetAll_Call 

type Client_HGetAll_Call struct {
	*mock.Call
}

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

func (*Client_HGetAll_Call) Return 

func (_c *Client_HGetAll_Call) Return(_a0 map[string]string, _a1 error) *Client_HGetAll_Call

func (*Client_HGetAll_Call) Run 

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

func (*Client_HGetAll_Call) RunAndReturn 

func (_c *Client_HGetAll_Call) RunAndReturn(run func(context.Context, string) (map[string]string, error)) *Client_HGetAll_Call

type Client_HGet_Call 

type Client_HGet_Call struct {
	*mock.Call
}

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

func (*Client_HGet_Call) Return 

func (_c *Client_HGet_Call) Return(_a0 string, _a1 error) *Client_HGet_Call

func (*Client_HGet_Call) Run 

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

func (*Client_HGet_Call) RunAndReturn 

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

type Client_HKeys_Call 

type Client_HKeys_Call struct {
	*mock.Call
}

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

func (*Client_HKeys_Call) Return 

func (_c *Client_HKeys_Call) Return(_a0 []string, _a1 error) *Client_HKeys_Call

func (*Client_HKeys_Call) Run 

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

func (*Client_HKeys_Call) RunAndReturn 

func (_c *Client_HKeys_Call) RunAndReturn(run func(context.Context, string) ([]string, error)) *Client_HKeys_Call

type Client_HMGet_Call 

type Client_HMGet_Call struct {
	*mock.Call
}

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

func (*Client_HMGet_Call) Return 

func (_c *Client_HMGet_Call) Return(_a0 []interface{}, _a1 error) *Client_HMGet_Call

func (*Client_HMGet_Call) Run 

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

func (*Client_HMGet_Call) RunAndReturn 

func (_c *Client_HMGet_Call) RunAndReturn(run func(context.Context, string, ...string) ([]interface{}, error)) *Client_HMGet_Call

type Client_HMSet_Call 

type Client_HMSet_Call struct {
	*mock.Call
}

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

func (*Client_HMSet_Call) Return 

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

func (*Client_HMSet_Call) Run 

func (_c *Client_HMSet_Call) Run(run func(ctx context.Context, key string, pairs map[string]interface{})) *Client_HMSet_Call

func (*Client_HMSet_Call) RunAndReturn 

func (_c *Client_HMSet_Call) RunAndReturn(run func(context.Context, string, map[string]interface{}) error) *Client_HMSet_Call

type Client_HSetNX_Call 

type Client_HSetNX_Call struct {
	*mock.Call
}

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

func (*Client_HSetNX_Call) Return 

func (_c *Client_HSetNX_Call) Return(_a0 bool, _a1 error) *Client_HSetNX_Call

func (*Client_HSetNX_Call) Run 

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

func (*Client_HSetNX_Call) RunAndReturn 

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

type Client_HSet_Call 

type Client_HSet_Call struct {
	*mock.Call
}

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

func (*Client_HSet_Call) Return 

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

func (*Client_HSet_Call) Run 

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

func (*Client_HSet_Call) RunAndReturn 

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

type Client_IncrBy_Call 

type Client_IncrBy_Call struct {
	*mock.Call
}

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

func (*Client_IncrBy_Call) Return 

func (_c *Client_IncrBy_Call) Return(_a0 int64, _a1 error) *Client_IncrBy_Call

func (*Client_IncrBy_Call) Run 

func (_c *Client_IncrBy_Call) Run(run func(ctx context.Context, key string, amount int64)) *Client_IncrBy_Call

func (*Client_IncrBy_Call) RunAndReturn 

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

type Client_Incr_Call 

type Client_Incr_Call struct {
	*mock.Call
}

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

func (*Client_Incr_Call) Return 

func (_c *Client_Incr_Call) Return(_a0 int64, _a1 error) *Client_Incr_Call

func (*Client_Incr_Call) Run 

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

func (*Client_Incr_Call) RunAndReturn 

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

type Client_IsAlive_Call 

type Client_IsAlive_Call struct {
	*mock.Call
}

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

func (*Client_IsAlive_Call) Return 

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

func (*Client_IsAlive_Call) Run 

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

func (*Client_IsAlive_Call) RunAndReturn 

func (_c *Client_IsAlive_Call) RunAndReturn(run func(context.Context) bool) *Client_IsAlive_Call

type Client_LLen_Call 

type Client_LLen_Call struct {
	*mock.Call
}

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

func (*Client_LLen_Call) Return 

func (_c *Client_LLen_Call) Return(_a0 int64, _a1 error) *Client_LLen_Call

func (*Client_LLen_Call) Run 

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

func (*Client_LLen_Call) RunAndReturn 

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

type Client_LPop_Call 

type Client_LPop_Call struct {
	*mock.Call
}

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

func (*Client_LPop_Call) Return 

func (_c *Client_LPop_Call) Return(_a0 string, _a1 error) *Client_LPop_Call

func (*Client_LPop_Call) Run 

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

func (*Client_LPop_Call) RunAndReturn 

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

type Client_LPush_Call 

type Client_LPush_Call struct {
	*mock.Call
}

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

func (*Client_LPush_Call) Return 

func (_c *Client_LPush_Call) Return(_a0 int64, _a1 error) *Client_LPush_Call

func (*Client_LPush_Call) Run 

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

func (*Client_LPush_Call) RunAndReturn 

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

type Client_LRem_Call 

type Client_LRem_Call struct {
	*mock.Call
}

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

func (*Client_LRem_Call) Return 

func (_c *Client_LRem_Call) Return(_a0 int64, _a1 error) *Client_LRem_Call

func (*Client_LRem_Call) Run 

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

func (*Client_LRem_Call) RunAndReturn 

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

type Client_MGet_Call 

type Client_MGet_Call struct {
	*mock.Call
}

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

func (*Client_MGet_Call) Return 

func (_c *Client_MGet_Call) Return(_a0 []interface{}, _a1 error) *Client_MGet_Call

func (*Client_MGet_Call) Run 

func (_c *Client_MGet_Call) Run(run func(ctx context.Context, keys ...string)) *Client_MGet_Call

func (*Client_MGet_Call) RunAndReturn 

func (_c *Client_MGet_Call) RunAndReturn(run func(context.Context, ...string) ([]interface{}, error)) *Client_MGet_Call

type Client_MSet_Call 

type Client_MSet_Call struct {
	*mock.Call
}

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

func (*Client_MSet_Call) Return 

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

func (*Client_MSet_Call) Run 

func (_c *Client_MSet_Call) Run(run func(ctx context.Context, pairs ...interface{})) *Client_MSet_Call

func (*Client_MSet_Call) RunAndReturn 

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

type Client_PFAdd_Call 

type Client_PFAdd_Call struct {
	*mock.Call
}

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

func (*Client_PFAdd_Call) Return 

func (_c *Client_PFAdd_Call) Return(_a0 int64, _a1 error) *Client_PFAdd_Call

func (*Client_PFAdd_Call) Run 

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

func (*Client_PFAdd_Call) RunAndReturn 

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

type Client_PFCount_Call 

type Client_PFCount_Call struct {
	*mock.Call
}

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

func (*Client_PFCount_Call) Return 

func (_c *Client_PFCount_Call) Return(_a0 int64, _a1 error) *Client_PFCount_Call

func (*Client_PFCount_Call) Run 

func (_c *Client_PFCount_Call) Run(run func(ctx context.Context, keys ...string)) *Client_PFCount_Call

func (*Client_PFCount_Call) RunAndReturn 

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

type Client_PFMerge_Call 

type Client_PFMerge_Call struct {
	*mock.Call
}

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

func (*Client_PFMerge_Call) Return 

func (_c *Client_PFMerge_Call) Return(_a0 string, _a1 error) *Client_PFMerge_Call

func (*Client_PFMerge_Call) Run 

func (_c *Client_PFMerge_Call) Run(run func(ctx context.Context, dest string, keys ...string)) *Client_PFMerge_Call

func (*Client_PFMerge_Call) RunAndReturn 

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

type Client_Pipeline_Call 

type Client_Pipeline_Call struct {
	*mock.Call
}

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

func (*Client_Pipeline_Call) Return 

func (_c *Client_Pipeline_Call) Return(_a0 redis.Pipeliner) *Client_Pipeline_Call

func (*Client_Pipeline_Call) Run 

func (_c *Client_Pipeline_Call) Run(run func()) *Client_Pipeline_Call

func (*Client_Pipeline_Call) RunAndReturn 

func (_c *Client_Pipeline_Call) RunAndReturn(run func() redis.Pipeliner) *Client_Pipeline_Call

type Client_RPop_Call 

type Client_RPop_Call struct {
	*mock.Call
}

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

func (*Client_RPop_Call) Return 

func (_c *Client_RPop_Call) Return(_a0 string, _a1 error) *Client_RPop_Call

func (*Client_RPop_Call) Run 

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

func (*Client_RPop_Call) RunAndReturn 

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

type Client_RPush_Call 

type Client_RPush_Call struct {
	*mock.Call
}

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

func (*Client_RPush_Call) Return 

func (_c *Client_RPush_Call) Return(_a0 int64, _a1 error) *Client_RPush_Call

func (*Client_RPush_Call) Run 

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

func (*Client_RPush_Call) RunAndReturn 

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

type Client_SAdd_Call 

type Client_SAdd_Call struct {
	*mock.Call
}

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

func (*Client_SAdd_Call) Return 

func (_c *Client_SAdd_Call) Return(_a0 int64, _a1 error) *Client_SAdd_Call

func (*Client_SAdd_Call) Run 

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

func (*Client_SAdd_Call) RunAndReturn 

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

type Client_SCard_Call 

type Client_SCard_Call struct {
	*mock.Call
}

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

func (*Client_SCard_Call) Return 

func (_c *Client_SCard_Call) Return(_a0 int64, _a1 error) *Client_SCard_Call

func (*Client_SCard_Call) Run 

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

func (*Client_SCard_Call) RunAndReturn 

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

type Client_SDiffStore_Call 

type Client_SDiffStore_Call struct {
	*mock.Call
}

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

func (*Client_SDiffStore_Call) Return 

func (_c *Client_SDiffStore_Call) Return(_a0 int64, _a1 error) *Client_SDiffStore_Call

func (*Client_SDiffStore_Call) Run 

func (_c *Client_SDiffStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *Client_SDiffStore_Call

func (*Client_SDiffStore_Call) RunAndReturn 

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

type Client_SDiff_Call 

type Client_SDiff_Call struct {
	*mock.Call
}

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

func (*Client_SDiff_Call) Return 

func (_c *Client_SDiff_Call) Return(_a0 []string, _a1 error) *Client_SDiff_Call

func (*Client_SDiff_Call) Run 

func (_c *Client_SDiff_Call) Run(run func(ctx context.Context, keys ...string)) *Client_SDiff_Call

func (*Client_SDiff_Call) RunAndReturn 

func (_c *Client_SDiff_Call) RunAndReturn(run func(context.Context, ...string) ([]string, error)) *Client_SDiff_Call

type Client_SInterStore_Call 

type Client_SInterStore_Call struct {
	*mock.Call
}

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

func (*Client_SInterStore_Call) Return 

func (_c *Client_SInterStore_Call) Return(_a0 int64, _a1 error) *Client_SInterStore_Call

func (*Client_SInterStore_Call) Run 

func (_c *Client_SInterStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *Client_SInterStore_Call

func (*Client_SInterStore_Call) RunAndReturn 

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

type Client_SInter_Call 

type Client_SInter_Call struct {
	*mock.Call
}

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

func (*Client_SInter_Call) Return 

func (_c *Client_SInter_Call) Return(_a0 []string, _a1 error) *Client_SInter_Call

func (*Client_SInter_Call) Run 

func (_c *Client_SInter_Call) Run(run func(ctx context.Context, keys ...string)) *Client_SInter_Call

func (*Client_SInter_Call) RunAndReturn 

func (_c *Client_SInter_Call) RunAndReturn(run func(context.Context, ...string) ([]string, error)) *Client_SInter_Call

type Client_SIsMember_Call 

type Client_SIsMember_Call struct {
	*mock.Call
}

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

func (*Client_SIsMember_Call) Return 

func (_c *Client_SIsMember_Call) Return(_a0 bool, _a1 error) *Client_SIsMember_Call

func (*Client_SIsMember_Call) Run 

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

func (*Client_SIsMember_Call) RunAndReturn 

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

type Client_SMembers_Call 

type Client_SMembers_Call struct {
	*mock.Call
}

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

func (*Client_SMembers_Call) Return 

func (_c *Client_SMembers_Call) Return(_a0 []string, _a1 error) *Client_SMembers_Call

func (*Client_SMembers_Call) Run 

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

func (*Client_SMembers_Call) RunAndReturn 

func (_c *Client_SMembers_Call) RunAndReturn(run func(context.Context, string) ([]string, error)) *Client_SMembers_Call

type Client_SMove_Call 

type Client_SMove_Call struct {
	*mock.Call
}

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

func (*Client_SMove_Call) Return 

func (_c *Client_SMove_Call) Return(_a0 bool, _a1 error) *Client_SMove_Call

func (*Client_SMove_Call) Run 

func (_c *Client_SMove_Call) Run(run func(ctx context.Context, sourceKey string, destKey string, member interface{})) *Client_SMove_Call

func (*Client_SMove_Call) RunAndReturn 

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

type Client_SPop_Call 

type Client_SPop_Call struct {
	*mock.Call
}

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

func (*Client_SPop_Call) Return 

func (_c *Client_SPop_Call) Return(_a0 string, _a1 error) *Client_SPop_Call

func (*Client_SPop_Call) Run 

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

func (*Client_SPop_Call) RunAndReturn 

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

type Client_SRandMember_Call 

type Client_SRandMember_Call struct {
	*mock.Call
}

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

func (*Client_SRandMember_Call) Return 

func (_c *Client_SRandMember_Call) Return(_a0 string, _a1 error) *Client_SRandMember_Call

func (*Client_SRandMember_Call) Run 

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

func (*Client_SRandMember_Call) RunAndReturn 

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

type Client_SRem_Call 

type Client_SRem_Call struct {
	*mock.Call
}

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

func (*Client_SRem_Call) Return 

func (_c *Client_SRem_Call) Return(_a0 int64, _a1 error) *Client_SRem_Call

func (*Client_SRem_Call) Run 

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

func (*Client_SRem_Call) RunAndReturn 

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

type Client_SUnionStore_Call 

type Client_SUnionStore_Call struct {
	*mock.Call
}

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

func (*Client_SUnionStore_Call) Return 

func (_c *Client_SUnionStore_Call) Return(_a0 int64, _a1 error) *Client_SUnionStore_Call

func (*Client_SUnionStore_Call) Run 

func (_c *Client_SUnionStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *Client_SUnionStore_Call

func (*Client_SUnionStore_Call) RunAndReturn 

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

type Client_SUnion_Call 

type Client_SUnion_Call struct {
	*mock.Call
}

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

func (*Client_SUnion_Call) Return 

func (_c *Client_SUnion_Call) Return(_a0 []string, _a1 error) *Client_SUnion_Call

func (*Client_SUnion_Call) Run 

func (_c *Client_SUnion_Call) Run(run func(ctx context.Context, keys ...string)) *Client_SUnion_Call

func (*Client_SUnion_Call) RunAndReturn 

func (_c *Client_SUnion_Call) RunAndReturn(run func(context.Context, ...string) ([]string, error)) *Client_SUnion_Call

type Client_SetNX_Call 

type Client_SetNX_Call struct {
	*mock.Call
}

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

func (*Client_SetNX_Call) Return 

func (_c *Client_SetNX_Call) Return(_a0 bool, _a1 error) *Client_SetNX_Call

func (*Client_SetNX_Call) Run 

func (_c *Client_SetNX_Call) Run(run func(ctx context.Context, key string, value interface{}, ttl time.Duration)) *Client_SetNX_Call

func (*Client_SetNX_Call) RunAndReturn 

func (_c *Client_SetNX_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) (bool, error)) *Client_SetNX_Call

type Client_Set_Call 

type Client_Set_Call struct {
	*mock.Call
}

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

func (*Client_Set_Call) Return 

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

func (*Client_Set_Call) Run 

func (_c *Client_Set_Call) Run(run func(ctx context.Context, key string, value interface{}, ttl time.Duration)) *Client_Set_Call

func (*Client_Set_Call) RunAndReturn 

func (_c *Client_Set_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) error) *Client_Set_Call

type Client_ZAddArgsIncr_Call 

type Client_ZAddArgsIncr_Call struct {
	*mock.Call
}

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

func (*Client_ZAddArgsIncr_Call) Return 

func (_c *Client_ZAddArgsIncr_Call) Return(_a0 float64, _a1 error) *Client_ZAddArgsIncr_Call

func (*Client_ZAddArgsIncr_Call) Run 

func (_c *Client_ZAddArgsIncr_Call) Run(run func(ctx context.Context, args redis.ZAddArgs)) *Client_ZAddArgsIncr_Call

func (*Client_ZAddArgsIncr_Call) RunAndReturn 

func (_c *Client_ZAddArgsIncr_Call) RunAndReturn(run func(context.Context, redis.ZAddArgs) (float64, error)) *Client_ZAddArgsIncr_Call

type Client_ZAddArgs_Call 

type Client_ZAddArgs_Call struct {
	*mock.Call
}

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

func (*Client_ZAddArgs_Call) Return 

func (_c *Client_ZAddArgs_Call) Return(_a0 int64, _a1 error) *Client_ZAddArgs_Call

func (*Client_ZAddArgs_Call) Run 

func (_c *Client_ZAddArgs_Call) Run(run func(ctx context.Context, args redis.ZAddArgs)) *Client_ZAddArgs_Call

func (*Client_ZAddArgs_Call) RunAndReturn 

func (_c *Client_ZAddArgs_Call) RunAndReturn(run func(context.Context, redis.ZAddArgs) (int64, error)) *Client_ZAddArgs_Call

type Client_ZAdd_Call 

type Client_ZAdd_Call struct {
	*mock.Call
}

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

func (*Client_ZAdd_Call) Return 

func (_c *Client_ZAdd_Call) Return(_a0 int64, _a1 error) *Client_ZAdd_Call

func (*Client_ZAdd_Call) Run 

func (_c *Client_ZAdd_Call) Run(run func(ctx context.Context, key string, score float64, member string)) *Client_ZAdd_Call

func (*Client_ZAdd_Call) RunAndReturn 

func (_c *Client_ZAdd_Call) RunAndReturn(run func(context.Context, string, float64, string) (int64, error)) *Client_ZAdd_Call

type Client_ZCard_Call 

type Client_ZCard_Call struct {
	*mock.Call
}

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

func (*Client_ZCard_Call) Return 

func (_c *Client_ZCard_Call) Return(_a0 int64, _a1 error) *Client_ZCard_Call

func (*Client_ZCard_Call) Run 

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

func (*Client_ZCard_Call) RunAndReturn 

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

type Client_ZCount_Call 

type Client_ZCount_Call struct {
	*mock.Call
}

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

func (*Client_ZCount_Call) Return 

func (_c *Client_ZCount_Call) Return(_a0 int64, _a1 error) *Client_ZCount_Call

func (*Client_ZCount_Call) Run 

func (_c *Client_ZCount_Call) Run(run func(ctx context.Context, key string, min string, max string)) *Client_ZCount_Call

func (*Client_ZCount_Call) RunAndReturn 

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

type Client_ZIncrBy_Call 

type Client_ZIncrBy_Call struct {
	*mock.Call
}

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

func (*Client_ZIncrBy_Call) Return 

func (_c *Client_ZIncrBy_Call) Return(_a0 float64, _a1 error) *Client_ZIncrBy_Call

func (*Client_ZIncrBy_Call) Run 

func (_c *Client_ZIncrBy_Call) Run(run func(ctx context.Context, key string, increment float64, member string)) *Client_ZIncrBy_Call

func (*Client_ZIncrBy_Call) RunAndReturn 

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

type Client_ZMScore_Call 

type Client_ZMScore_Call struct {
	*mock.Call
}

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

func (*Client_ZMScore_Call) Return 

func (_c *Client_ZMScore_Call) Return(_a0 []float64, _a1 error) *Client_ZMScore_Call

func (*Client_ZMScore_Call) Run 

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

func (*Client_ZMScore_Call) RunAndReturn 

func (_c *Client_ZMScore_Call) RunAndReturn(run func(context.Context, string, ...string) ([]float64, error)) *Client_ZMScore_Call

type Client_ZRandMember_Call 

type Client_ZRandMember_Call struct {
	*mock.Call
}

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

func (*Client_ZRandMember_Call) Return 

func (_c *Client_ZRandMember_Call) Return(_a0 []string, _a1 error) *Client_ZRandMember_Call

func (*Client_ZRandMember_Call) Run 

func (_c *Client_ZRandMember_Call) Run(run func(ctx context.Context, key string, count int)) *Client_ZRandMember_Call

func (*Client_ZRandMember_Call) RunAndReturn 

func (_c *Client_ZRandMember_Call) RunAndReturn(run func(context.Context, string, int) ([]string, error)) *Client_ZRandMember_Call

type Client_ZRangeArgsWithScore_Call 

type Client_ZRangeArgsWithScore_Call struct {
	*mock.Call
}

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

func (*Client_ZRangeArgsWithScore_Call) Return 

func (_c *Client_ZRangeArgsWithScore_Call) Return(_a0 []redis.Z, _a1 error) *Client_ZRangeArgsWithScore_Call

func (*Client_ZRangeArgsWithScore_Call) Run 

func (_c *Client_ZRangeArgsWithScore_Call) Run(run func(ctx context.Context, args redis.ZRangeArgs)) *Client_ZRangeArgsWithScore_Call

func (*Client_ZRangeArgsWithScore_Call) RunAndReturn 

func (_c *Client_ZRangeArgsWithScore_Call) RunAndReturn(run func(context.Context, redis.ZRangeArgs) ([]redis.Z, error)) *Client_ZRangeArgsWithScore_Call

type Client_ZRangeArgs_Call 

type Client_ZRangeArgs_Call struct {
	*mock.Call
}

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

func (*Client_ZRangeArgs_Call) Return 

func (_c *Client_ZRangeArgs_Call) Return(_a0 []string, _a1 error) *Client_ZRangeArgs_Call

func (*Client_ZRangeArgs_Call) Run 

func (_c *Client_ZRangeArgs_Call) Run(run func(ctx context.Context, args redis.ZRangeArgs)) *Client_ZRangeArgs_Call

func (*Client_ZRangeArgs_Call) RunAndReturn 

func (_c *Client_ZRangeArgs_Call) RunAndReturn(run func(context.Context, redis.ZRangeArgs) ([]string, error)) *Client_ZRangeArgs_Call

type Client_ZRange_Call 

type Client_ZRange_Call struct {
	*mock.Call
}

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

func (*Client_ZRange_Call) Return 

func (_c *Client_ZRange_Call) Return(_a0 []string, _a1 error) *Client_ZRange_Call

func (*Client_ZRange_Call) Run 

func (_c *Client_ZRange_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Client_ZRange_Call

func (*Client_ZRange_Call) RunAndReturn 

func (_c *Client_ZRange_Call) RunAndReturn(run func(context.Context, string, int64, int64) ([]string, error)) *Client_ZRange_Call

type Client_ZRank_Call 

type Client_ZRank_Call struct {
	*mock.Call
}

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

func (*Client_ZRank_Call) Return 

func (_c *Client_ZRank_Call) Return(_a0 int64, _a1 error) *Client_ZRank_Call

func (*Client_ZRank_Call) Run 

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

func (*Client_ZRank_Call) RunAndReturn 

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

type Client_ZRem_Call 

type Client_ZRem_Call struct {
	*mock.Call
}

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

func (*Client_ZRem_Call) Return 

func (_c *Client_ZRem_Call) Return(_a0 int64, _a1 error) *Client_ZRem_Call

func (*Client_ZRem_Call) Run 

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

func (*Client_ZRem_Call) RunAndReturn 

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

type Client_ZRevRank_Call 

type Client_ZRevRank_Call struct {
	*mock.Call
}

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

func (*Client_ZRevRank_Call) Return 

func (_c *Client_ZRevRank_Call) Return(_a0 int64, _a1 error) *Client_ZRevRank_Call

func (*Client_ZRevRank_Call) Run 

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

func (*Client_ZRevRank_Call) RunAndReturn 

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

type Client_ZScore_Call 

type Client_ZScore_Call struct {
	*mock.Call
}

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

func (*Client_ZScore_Call) Return 

func (_c *Client_ZScore_Call) Return(_a0 float64, _a1 error) *Client_ZScore_Call

func (*Client_ZScore_Call) Run 

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

func (*Client_ZScore_Call) RunAndReturn 

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

type Pipeliner 

type Pipeliner struct {
	mock.Mock
}

Pipeliner is an autogenerated mock type for the Pipeliner type

func NewPipeliner 

func NewPipeliner(t mockConstructorTestingTNewPipeliner) *Pipeliner

NewPipeliner creates a new instance of Pipeliner. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.

func (*Pipeliner) Append 

func (_m *Pipeliner) Append(ctx context.Context, key string, value string) *redis.IntCmd

Append provides a mock function with given fields: ctx, key, value

func (*Pipeliner) Auth 

func (_m *Pipeliner) Auth(ctx context.Context, password string) *redis.StatusCmd

Auth provides a mock function with given fields: ctx, password

func (*Pipeliner) AuthACL 

func (_m *Pipeliner) AuthACL(ctx context.Context, username string, password string) *redis.StatusCmd

AuthACL provides a mock function with given fields: ctx, username, password

func (*Pipeliner) BLMove 

func (_m *Pipeliner) BLMove(ctx context.Context, source string, destination string, srcpos string, destpos string, timeout time.Duration) *redis.StringCmd

BLMove provides a mock function with given fields: ctx, source, destination, srcpos, destpos, timeout

func (*Pipeliner) BLPop 

func (_m *Pipeliner) BLPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd

BLPop provides a mock function with given fields: ctx, timeout, keys

func (*Pipeliner) BRPop 

func (_m *Pipeliner) BRPop(ctx context.Context, timeout time.Duration, keys ...string) *redis.StringSliceCmd

BRPop provides a mock function with given fields: ctx, timeout, keys

func (*Pipeliner) BRPopLPush 

func (_m *Pipeliner) BRPopLPush(ctx context.Context, source string, destination string, timeout time.Duration) *redis.StringCmd

BRPopLPush provides a mock function with given fields: ctx, source, destination, timeout

func (*Pipeliner) BZPopMax 

func (_m *Pipeliner) BZPopMax(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd

BZPopMax provides a mock function with given fields: ctx, timeout, keys

func (*Pipeliner) BZPopMin 

func (_m *Pipeliner) BZPopMin(ctx context.Context, timeout time.Duration, keys ...string) *redis.ZWithKeyCmd

BZPopMin provides a mock function with given fields: ctx, timeout, keys

func (*Pipeliner) BgRewriteAOF 

func (_m *Pipeliner) BgRewriteAOF(ctx context.Context) *redis.StatusCmd

BgRewriteAOF provides a mock function with given fields: ctx

func (*Pipeliner) BgSave 

func (_m *Pipeliner) BgSave(ctx context.Context) *redis.StatusCmd

BgSave provides a mock function with given fields: ctx

func (*Pipeliner) BitCount 

func (_m *Pipeliner) BitCount(ctx context.Context, key string, bitCount *redis.BitCount) *redis.IntCmd

BitCount provides a mock function with given fields: ctx, key, bitCount

func (*Pipeliner) BitField 

func (_m *Pipeliner) BitField(ctx context.Context, key string, args ...interface{}) *redis.IntSliceCmd

BitField provides a mock function with given fields: ctx, key, args

func (*Pipeliner) BitOpAnd 

func (_m *Pipeliner) BitOpAnd(ctx context.Context, destKey string, keys ...string) *redis.IntCmd

BitOpAnd provides a mock function with given fields: ctx, destKey, keys

func (*Pipeliner) BitOpNot 

func (_m *Pipeliner) BitOpNot(ctx context.Context, destKey string, key string) *redis.IntCmd

BitOpNot provides a mock function with given fields: ctx, destKey, key

func (*Pipeliner) BitOpOr 

func (_m *Pipeliner) BitOpOr(ctx context.Context, destKey string, keys ...string) *redis.IntCmd

BitOpOr provides a mock function with given fields: ctx, destKey, keys

func (*Pipeliner) BitOpXor 

func (_m *Pipeliner) BitOpXor(ctx context.Context, destKey string, keys ...string) *redis.IntCmd

BitOpXor provides a mock function with given fields: ctx, destKey, keys

func (*Pipeliner) BitPos 

func (_m *Pipeliner) BitPos(ctx context.Context, key string, bit int64, pos ...int64) *redis.IntCmd

BitPos provides a mock function with given fields: ctx, key, bit, pos

func (*Pipeliner) ClientGetName 

func (_m *Pipeliner) ClientGetName(ctx context.Context) *redis.StringCmd

ClientGetName provides a mock function with given fields: ctx

func (*Pipeliner) ClientID 

func (_m *Pipeliner) ClientID(ctx context.Context) *redis.IntCmd

ClientID provides a mock function with given fields: ctx

func (*Pipeliner) ClientKill 

func (_m *Pipeliner) ClientKill(ctx context.Context, ipPort string) *redis.StatusCmd

ClientKill provides a mock function with given fields: ctx, ipPort

func (*Pipeliner) ClientKillByFilter 

func (_m *Pipeliner) ClientKillByFilter(ctx context.Context, keys ...string) *redis.IntCmd

ClientKillByFilter provides a mock function with given fields: ctx, keys

func (*Pipeliner) ClientList 

func (_m *Pipeliner) ClientList(ctx context.Context) *redis.StringCmd

ClientList provides a mock function with given fields: ctx

func (*Pipeliner) ClientPause 

func (_m *Pipeliner) ClientPause(ctx context.Context, dur time.Duration) *redis.BoolCmd

ClientPause provides a mock function with given fields: ctx, dur

func (*Pipeliner) ClientSetName 

func (_m *Pipeliner) ClientSetName(ctx context.Context, name string) *redis.BoolCmd

ClientSetName provides a mock function with given fields: ctx, name

func (*Pipeliner) Close 

func (_m *Pipeliner) Close() error

Close provides a mock function with given fields:

func (*Pipeliner) ClusterAddSlots 

func (_m *Pipeliner) ClusterAddSlots(ctx context.Context, slots ...int) *redis.StatusCmd

ClusterAddSlots provides a mock function with given fields: ctx, slots

func (*Pipeliner) ClusterAddSlotsRange 

func (_m *Pipeliner) ClusterAddSlotsRange(ctx context.Context, min int, max int) *redis.StatusCmd

ClusterAddSlotsRange provides a mock function with given fields: ctx, min, max

func (*Pipeliner) ClusterCountFailureReports 

func (_m *Pipeliner) ClusterCountFailureReports(ctx context.Context, nodeID string) *redis.IntCmd

ClusterCountFailureReports provides a mock function with given fields: ctx, nodeID

func (*Pipeliner) ClusterCountKeysInSlot 

func (_m *Pipeliner) ClusterCountKeysInSlot(ctx context.Context, slot int) *redis.IntCmd

ClusterCountKeysInSlot provides a mock function with given fields: ctx, slot

func (*Pipeliner) ClusterDelSlots 

func (_m *Pipeliner) ClusterDelSlots(ctx context.Context, slots ...int) *redis.StatusCmd

ClusterDelSlots provides a mock function with given fields: ctx, slots

func (*Pipeliner) ClusterDelSlotsRange 

func (_m *Pipeliner) ClusterDelSlotsRange(ctx context.Context, min int, max int) *redis.StatusCmd

ClusterDelSlotsRange provides a mock function with given fields: ctx, min, max

func (*Pipeliner) ClusterFailover 

func (_m *Pipeliner) ClusterFailover(ctx context.Context) *redis.StatusCmd

ClusterFailover provides a mock function with given fields: ctx

func (*Pipeliner) ClusterForget 

func (_m *Pipeliner) ClusterForget(ctx context.Context, nodeID string) *redis.StatusCmd

ClusterForget provides a mock function with given fields: ctx, nodeID

func (*Pipeliner) ClusterGetKeysInSlot 

func (_m *Pipeliner) ClusterGetKeysInSlot(ctx context.Context, slot int, count int) *redis.StringSliceCmd

ClusterGetKeysInSlot provides a mock function with given fields: ctx, slot, count

func (*Pipeliner) ClusterInfo 

func (_m *Pipeliner) ClusterInfo(ctx context.Context) *redis.StringCmd

ClusterInfo provides a mock function with given fields: ctx

func (*Pipeliner) ClusterKeySlot 

func (_m *Pipeliner) ClusterKeySlot(ctx context.Context, key string) *redis.IntCmd

ClusterKeySlot provides a mock function with given fields: ctx, key

func (*Pipeliner) ClusterMeet 

func (_m *Pipeliner) ClusterMeet(ctx context.Context, host string, port string) *redis.StatusCmd

ClusterMeet provides a mock function with given fields: ctx, host, port

func (*Pipeliner) ClusterNodes 

func (_m *Pipeliner) ClusterNodes(ctx context.Context) *redis.StringCmd

ClusterNodes provides a mock function with given fields: ctx

func (*Pipeliner) ClusterReplicate 

func (_m *Pipeliner) ClusterReplicate(ctx context.Context, nodeID string) *redis.StatusCmd

ClusterReplicate provides a mock function with given fields: ctx, nodeID

func (*Pipeliner) ClusterResetHard 

func (_m *Pipeliner) ClusterResetHard(ctx context.Context) *redis.StatusCmd

ClusterResetHard provides a mock function with given fields: ctx

func (*Pipeliner) ClusterResetSoft 

func (_m *Pipeliner) ClusterResetSoft(ctx context.Context) *redis.StatusCmd

ClusterResetSoft provides a mock function with given fields: ctx

func (*Pipeliner) ClusterSaveConfig 

func (_m *Pipeliner) ClusterSaveConfig(ctx context.Context) *redis.StatusCmd

ClusterSaveConfig provides a mock function with given fields: ctx

func (*Pipeliner) ClusterSlaves 

func (_m *Pipeliner) ClusterSlaves(ctx context.Context, nodeID string) *redis.StringSliceCmd

ClusterSlaves provides a mock function with given fields: ctx, nodeID

func (*Pipeliner) ClusterSlots 

func (_m *Pipeliner) ClusterSlots(ctx context.Context) *redis.ClusterSlotsCmd

ClusterSlots provides a mock function with given fields: ctx

func (*Pipeliner) Command 

func (_m *Pipeliner) Command(ctx context.Context) *redis.CommandsInfoCmd

Command provides a mock function with given fields: ctx

func (*Pipeliner) ConfigGet 

func (_m *Pipeliner) ConfigGet(ctx context.Context, parameter string) *redis.SliceCmd

ConfigGet provides a mock function with given fields: ctx, parameter

func (*Pipeliner) ConfigResetStat 

func (_m *Pipeliner) ConfigResetStat(ctx context.Context) *redis.StatusCmd

ConfigResetStat provides a mock function with given fields: ctx

func (*Pipeliner) ConfigRewrite 

func (_m *Pipeliner) ConfigRewrite(ctx context.Context) *redis.StatusCmd

ConfigRewrite provides a mock function with given fields: ctx

func (*Pipeliner) ConfigSet 

func (_m *Pipeliner) ConfigSet(ctx context.Context, parameter string, value string) *redis.StatusCmd

ConfigSet provides a mock function with given fields: ctx, parameter, value

func (*Pipeliner) Copy 

func (_m *Pipeliner) Copy(ctx context.Context, sourceKey string, destKey string, db int, replace bool) *redis.IntCmd

Copy provides a mock function with given fields: ctx, sourceKey, destKey, db, replace

func (*Pipeliner) DBSize 

func (_m *Pipeliner) DBSize(ctx context.Context) *redis.IntCmd

DBSize provides a mock function with given fields: ctx

func (*Pipeliner) DebugObject 

func (_m *Pipeliner) DebugObject(ctx context.Context, key string) *redis.StringCmd

DebugObject provides a mock function with given fields: ctx, key

func (*Pipeliner) Decr 

func (_m *Pipeliner) Decr(ctx context.Context, key string) *redis.IntCmd

Decr provides a mock function with given fields: ctx, key

func (*Pipeliner) DecrBy 

func (_m *Pipeliner) DecrBy(ctx context.Context, key string, decrement int64) *redis.IntCmd

DecrBy provides a mock function with given fields: ctx, key, decrement

func (*Pipeliner) Del 

func (_m *Pipeliner) Del(ctx context.Context, keys ...string) *redis.IntCmd

Del provides a mock function with given fields: ctx, keys

func (*Pipeliner) Discard 

func (_m *Pipeliner) Discard() error

Discard provides a mock function with given fields:

func (*Pipeliner) Do 

func (_m *Pipeliner) Do(ctx context.Context, args ...interface{}) *redis.Cmd

Do provides a mock function with given fields: ctx, args

func (*Pipeliner) Dump 

func (_m *Pipeliner) Dump(ctx context.Context, key string) *redis.StringCmd

Dump provides a mock function with given fields: ctx, key

func (*Pipeliner) EXPECT 

func (_m *Pipeliner) EXPECT() *Pipeliner_Expecter

func (*Pipeliner) Echo 

func (_m *Pipeliner) Echo(ctx context.Context, message interface{}) *redis.StringCmd

Echo provides a mock function with given fields: ctx, message

func (*Pipeliner) Eval 

func (_m *Pipeliner) Eval(ctx context.Context, script string, keys []string, args ...interface{}) *redis.Cmd

Eval provides a mock function with given fields: ctx, script, keys, args

func (*Pipeliner) EvalSha 

func (_m *Pipeliner) EvalSha(ctx context.Context, sha1 string, keys []string, args ...interface{}) *redis.Cmd

EvalSha provides a mock function with given fields: ctx, sha1, keys, args

func (*Pipeliner) Exec 

func (_m *Pipeliner) Exec(ctx context.Context) ([]redis.Cmder, error)

Exec provides a mock function with given fields: ctx

func (*Pipeliner) Exists 

func (_m *Pipeliner) Exists(ctx context.Context, keys ...string) *redis.IntCmd

Exists provides a mock function with given fields: ctx, keys

func (*Pipeliner) Expire 

func (_m *Pipeliner) Expire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd

Expire provides a mock function with given fields: ctx, key, expiration

func (*Pipeliner) ExpireAt 

func (_m *Pipeliner) ExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd

ExpireAt provides a mock function with given fields: ctx, key, tm

func (*Pipeliner) ExpireGT 

func (_m *Pipeliner) ExpireGT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd

ExpireGT provides a mock function with given fields: ctx, key, expiration

func (*Pipeliner) ExpireLT 

func (_m *Pipeliner) ExpireLT(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd

ExpireLT provides a mock function with given fields: ctx, key, expiration

func (*Pipeliner) ExpireNX 

func (_m *Pipeliner) ExpireNX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd

ExpireNX provides a mock function with given fields: ctx, key, expiration

func (*Pipeliner) ExpireXX 

func (_m *Pipeliner) ExpireXX(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd

ExpireXX provides a mock function with given fields: ctx, key, expiration

func (*Pipeliner) FlushAll 

func (_m *Pipeliner) FlushAll(ctx context.Context) *redis.StatusCmd

FlushAll provides a mock function with given fields: ctx

func (*Pipeliner) FlushAllAsync 

func (_m *Pipeliner) FlushAllAsync(ctx context.Context) *redis.StatusCmd

FlushAllAsync provides a mock function with given fields: ctx

func (*Pipeliner) FlushDB 

func (_m *Pipeliner) FlushDB(ctx context.Context) *redis.StatusCmd

FlushDB provides a mock function with given fields: ctx

func (*Pipeliner) FlushDBAsync 

func (_m *Pipeliner) FlushDBAsync(ctx context.Context) *redis.StatusCmd

FlushDBAsync provides a mock function with given fields: ctx

func (*Pipeliner) GeoAdd 

func (_m *Pipeliner) GeoAdd(ctx context.Context, key string, geoLocation ...*redis.GeoLocation) *redis.IntCmd

GeoAdd provides a mock function with given fields: ctx, key, geoLocation

func (*Pipeliner) GeoDist 

func (_m *Pipeliner) GeoDist(ctx context.Context, key string, member1 string, member2 string, unit string) *redis.FloatCmd

GeoDist provides a mock function with given fields: ctx, key, member1, member2, unit

func (*Pipeliner) GeoHash 

func (_m *Pipeliner) GeoHash(ctx context.Context, key string, members ...string) *redis.StringSliceCmd

GeoHash provides a mock function with given fields: ctx, key, members

func (*Pipeliner) GeoPos 

func (_m *Pipeliner) GeoPos(ctx context.Context, key string, members ...string) *redis.GeoPosCmd

GeoPos provides a mock function with given fields: ctx, key, members

func (*Pipeliner) GeoRadius 

func (_m *Pipeliner) GeoRadius(ctx context.Context, key string, longitude float64, latitude float64, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd

GeoRadius provides a mock function with given fields: ctx, key, longitude, latitude, query

func (*Pipeliner) GeoRadiusByMember 

func (_m *Pipeliner) GeoRadiusByMember(ctx context.Context, key string, member string, query *redis.GeoRadiusQuery) *redis.GeoLocationCmd

GeoRadiusByMember provides a mock function with given fields: ctx, key, member, query

func (*Pipeliner) GeoRadiusByMemberStore 

func (_m *Pipeliner) GeoRadiusByMemberStore(ctx context.Context, key string, member string, query *redis.GeoRadiusQuery) *redis.IntCmd

GeoRadiusByMemberStore provides a mock function with given fields: ctx, key, member, query

func (*Pipeliner) GeoRadiusStore 

func (_m *Pipeliner) GeoRadiusStore(ctx context.Context, key string, longitude float64, latitude float64, query *redis.GeoRadiusQuery) *redis.IntCmd

GeoRadiusStore provides a mock function with given fields: ctx, key, longitude, latitude, query

func (*Pipeliner) GeoSearch 

func (_m *Pipeliner) GeoSearch(ctx context.Context, key string, q *redis.GeoSearchQuery) *redis.StringSliceCmd

GeoSearch provides a mock function with given fields: ctx, key, q

func (*Pipeliner) GeoSearchLocation 

func (_m *Pipeliner) GeoSearchLocation(ctx context.Context, key string, q *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd

GeoSearchLocation provides a mock function with given fields: ctx, key, q

func (*Pipeliner) GeoSearchStore 

func (_m *Pipeliner) GeoSearchStore(ctx context.Context, key string, store string, q *redis.GeoSearchStoreQuery) *redis.IntCmd

GeoSearchStore provides a mock function with given fields: ctx, key, store, q

func (*Pipeliner) Get 

func (_m *Pipeliner) Get(ctx context.Context, key string) *redis.StringCmd

Get provides a mock function with given fields: ctx, key

func (*Pipeliner) GetBit 

func (_m *Pipeliner) GetBit(ctx context.Context, key string, offset int64) *redis.IntCmd

GetBit provides a mock function with given fields: ctx, key, offset

func (*Pipeliner) GetDel 

func (_m *Pipeliner) GetDel(ctx context.Context, key string) *redis.StringCmd

GetDel provides a mock function with given fields: ctx, key

func (*Pipeliner) GetEx 

func (_m *Pipeliner) GetEx(ctx context.Context, key string, expiration time.Duration) *redis.StringCmd

GetEx provides a mock function with given fields: ctx, key, expiration

func (*Pipeliner) GetRange 

func (_m *Pipeliner) GetRange(ctx context.Context, key string, start int64, end int64) *redis.StringCmd

GetRange provides a mock function with given fields: ctx, key, start, end

func (*Pipeliner) GetSet 

func (_m *Pipeliner) GetSet(ctx context.Context, key string, value interface{}) *redis.StringCmd

GetSet provides a mock function with given fields: ctx, key, value

func (*Pipeliner) HDel 

func (_m *Pipeliner) HDel(ctx context.Context, key string, fields ...string) *redis.IntCmd

HDel provides a mock function with given fields: ctx, key, fields

func (*Pipeliner) HExists 

func (_m *Pipeliner) HExists(ctx context.Context, key string, field string) *redis.BoolCmd

HExists provides a mock function with given fields: ctx, key, field

func (*Pipeliner) HGet 

func (_m *Pipeliner) HGet(ctx context.Context, key string, field string) *redis.StringCmd

HGet provides a mock function with given fields: ctx, key, field

func (*Pipeliner) HGetAll 

func (_m *Pipeliner) HGetAll(ctx context.Context, key string) *redis.StringStringMapCmd

HGetAll provides a mock function with given fields: ctx, key

func (*Pipeliner) HIncrBy 

func (_m *Pipeliner) HIncrBy(ctx context.Context, key string, field string, incr int64) *redis.IntCmd

HIncrBy provides a mock function with given fields: ctx, key, field, incr

func (*Pipeliner) HIncrByFloat 

func (_m *Pipeliner) HIncrByFloat(ctx context.Context, key string, field string, incr float64) *redis.FloatCmd

HIncrByFloat provides a mock function with given fields: ctx, key, field, incr

func (*Pipeliner) HKeys 

func (_m *Pipeliner) HKeys(ctx context.Context, key string) *redis.StringSliceCmd

HKeys provides a mock function with given fields: ctx, key

func (*Pipeliner) HLen 

func (_m *Pipeliner) HLen(ctx context.Context, key string) *redis.IntCmd

HLen provides a mock function with given fields: ctx, key

func (*Pipeliner) HMGet 

func (_m *Pipeliner) HMGet(ctx context.Context, key string, fields ...string) *redis.SliceCmd

HMGet provides a mock function with given fields: ctx, key, fields

func (*Pipeliner) HMSet 

func (_m *Pipeliner) HMSet(ctx context.Context, key string, values ...interface{}) *redis.BoolCmd

HMSet provides a mock function with given fields: ctx, key, values

func (*Pipeliner) HRandField 

func (_m *Pipeliner) HRandField(ctx context.Context, key string, count int, withValues bool) *redis.StringSliceCmd

HRandField provides a mock function with given fields: ctx, key, count, withValues

func (*Pipeliner) HScan 

func (_m *Pipeliner) HScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd

HScan provides a mock function with given fields: ctx, key, cursor, match, count

func (*Pipeliner) HSet 

func (_m *Pipeliner) HSet(ctx context.Context, key string, values ...interface{}) *redis.IntCmd

HSet provides a mock function with given fields: ctx, key, values

func (*Pipeliner) HSetNX 

func (_m *Pipeliner) HSetNX(ctx context.Context, key string, field string, value interface{}) *redis.BoolCmd

HSetNX provides a mock function with given fields: ctx, key, field, value

func (*Pipeliner) HVals 

func (_m *Pipeliner) HVals(ctx context.Context, key string) *redis.StringSliceCmd

HVals provides a mock function with given fields: ctx, key

func (*Pipeliner) Incr 

func (_m *Pipeliner) Incr(ctx context.Context, key string) *redis.IntCmd

Incr provides a mock function with given fields: ctx, key

func (*Pipeliner) IncrBy 

func (_m *Pipeliner) IncrBy(ctx context.Context, key string, value int64) *redis.IntCmd

IncrBy provides a mock function with given fields: ctx, key, value

func (*Pipeliner) IncrByFloat 

func (_m *Pipeliner) IncrByFloat(ctx context.Context, key string, value float64) *redis.FloatCmd

IncrByFloat provides a mock function with given fields: ctx, key, value

func (*Pipeliner) Info 

func (_m *Pipeliner) Info(ctx context.Context, section ...string) *redis.StringCmd

Info provides a mock function with given fields: ctx, section

func (*Pipeliner) Keys 

func (_m *Pipeliner) Keys(ctx context.Context, pattern string) *redis.StringSliceCmd

Keys provides a mock function with given fields: ctx, pattern

func (*Pipeliner) LIndex 

func (_m *Pipeliner) LIndex(ctx context.Context, key string, index int64) *redis.StringCmd

LIndex provides a mock function with given fields: ctx, key, index

func (*Pipeliner) LInsert 

func (_m *Pipeliner) LInsert(ctx context.Context, key string, op string, pivot interface{}, value interface{}) *redis.IntCmd

LInsert provides a mock function with given fields: ctx, key, op, pivot, value

func (*Pipeliner) LInsertAfter 

func (_m *Pipeliner) LInsertAfter(ctx context.Context, key string, pivot interface{}, value interface{}) *redis.IntCmd

LInsertAfter provides a mock function with given fields: ctx, key, pivot, value

func (*Pipeliner) LInsertBefore 

func (_m *Pipeliner) LInsertBefore(ctx context.Context, key string, pivot interface{}, value interface{}) *redis.IntCmd

LInsertBefore provides a mock function with given fields: ctx, key, pivot, value

func (*Pipeliner) LLen 

func (_m *Pipeliner) LLen(ctx context.Context, key string) *redis.IntCmd

LLen provides a mock function with given fields: ctx, key

func (*Pipeliner) LMove 

func (_m *Pipeliner) LMove(ctx context.Context, source string, destination string, srcpos string, destpos string) *redis.StringCmd

LMove provides a mock function with given fields: ctx, source, destination, srcpos, destpos

func (*Pipeliner) LPop 

func (_m *Pipeliner) LPop(ctx context.Context, key string) *redis.StringCmd

LPop provides a mock function with given fields: ctx, key

func (*Pipeliner) LPopCount 

func (_m *Pipeliner) LPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd

LPopCount provides a mock function with given fields: ctx, key, count

func (*Pipeliner) LPos 

func (_m *Pipeliner) LPos(ctx context.Context, key string, value string, args redis.LPosArgs) *redis.IntCmd

LPos provides a mock function with given fields: ctx, key, value, args

func (*Pipeliner) LPosCount 

func (_m *Pipeliner) LPosCount(ctx context.Context, key string, value string, count int64, args redis.LPosArgs) *redis.IntSliceCmd

LPosCount provides a mock function with given fields: ctx, key, value, count, args

func (*Pipeliner) LPush 

func (_m *Pipeliner) LPush(ctx context.Context, key string, values ...interface{}) *redis.IntCmd

LPush provides a mock function with given fields: ctx, key, values

func (*Pipeliner) LPushX 

func (_m *Pipeliner) LPushX(ctx context.Context, key string, values ...interface{}) *redis.IntCmd

LPushX provides a mock function with given fields: ctx, key, values

func (*Pipeliner) LRange 

func (_m *Pipeliner) LRange(ctx context.Context, key string, start int64, stop int64) *redis.StringSliceCmd

LRange provides a mock function with given fields: ctx, key, start, stop

func (*Pipeliner) LRem 

func (_m *Pipeliner) LRem(ctx context.Context, key string, count int64, value interface{}) *redis.IntCmd

LRem provides a mock function with given fields: ctx, key, count, value

func (*Pipeliner) LSet 

func (_m *Pipeliner) LSet(ctx context.Context, key string, index int64, value interface{}) *redis.StatusCmd

LSet provides a mock function with given fields: ctx, key, index, value

func (*Pipeliner) LTrim 

func (_m *Pipeliner) LTrim(ctx context.Context, key string, start int64, stop int64) *redis.StatusCmd

LTrim provides a mock function with given fields: ctx, key, start, stop

func (*Pipeliner) LastSave 

func (_m *Pipeliner) LastSave(ctx context.Context) *redis.IntCmd

LastSave provides a mock function with given fields: ctx

func (*Pipeliner) Len 

func (_m *Pipeliner) Len() int

Len provides a mock function with given fields:

func (*Pipeliner) MGet 

func (_m *Pipeliner) MGet(ctx context.Context, keys ...string) *redis.SliceCmd

MGet provides a mock function with given fields: ctx, keys

func (*Pipeliner) MSet 

func (_m *Pipeliner) MSet(ctx context.Context, values ...interface{}) *redis.StatusCmd

MSet provides a mock function with given fields: ctx, values

func (*Pipeliner) MSetNX 

func (_m *Pipeliner) MSetNX(ctx context.Context, values ...interface{}) *redis.BoolCmd

MSetNX provides a mock function with given fields: ctx, values

func (*Pipeliner) MemoryUsage 

func (_m *Pipeliner) MemoryUsage(ctx context.Context, key string, samples ...int) *redis.IntCmd

MemoryUsage provides a mock function with given fields: ctx, key, samples

func (*Pipeliner) Migrate 

func (_m *Pipeliner) Migrate(ctx context.Context, host string, port string, key string, db int, timeout time.Duration) *redis.StatusCmd

Migrate provides a mock function with given fields: ctx, host, port, key, db, timeout

func (*Pipeliner) Move 

func (_m *Pipeliner) Move(ctx context.Context, key string, db int) *redis.BoolCmd

Move provides a mock function with given fields: ctx, key, db

func (*Pipeliner) ObjectEncoding 

func (_m *Pipeliner) ObjectEncoding(ctx context.Context, key string) *redis.StringCmd

ObjectEncoding provides a mock function with given fields: ctx, key

func (*Pipeliner) ObjectIdleTime 

func (_m *Pipeliner) ObjectIdleTime(ctx context.Context, key string) *redis.DurationCmd

ObjectIdleTime provides a mock function with given fields: ctx, key

func (*Pipeliner) ObjectRefCount 

func (_m *Pipeliner) ObjectRefCount(ctx context.Context, key string) *redis.IntCmd

ObjectRefCount provides a mock function with given fields: ctx, key

func (*Pipeliner) PExpire 

func (_m *Pipeliner) PExpire(ctx context.Context, key string, expiration time.Duration) *redis.BoolCmd

PExpire provides a mock function with given fields: ctx, key, expiration

func (*Pipeliner) PExpireAt 

func (_m *Pipeliner) PExpireAt(ctx context.Context, key string, tm time.Time) *redis.BoolCmd

PExpireAt provides a mock function with given fields: ctx, key, tm

func (*Pipeliner) PFAdd 

func (_m *Pipeliner) PFAdd(ctx context.Context, key string, els ...interface{}) *redis.IntCmd

PFAdd provides a mock function with given fields: ctx, key, els

func (*Pipeliner) PFCount 

func (_m *Pipeliner) PFCount(ctx context.Context, keys ...string) *redis.IntCmd

PFCount provides a mock function with given fields: ctx, keys

func (*Pipeliner) PFMerge 

func (_m *Pipeliner) PFMerge(ctx context.Context, dest string, keys ...string) *redis.StatusCmd

PFMerge provides a mock function with given fields: ctx, dest, keys

func (*Pipeliner) PTTL 

func (_m *Pipeliner) PTTL(ctx context.Context, key string) *redis.DurationCmd

PTTL provides a mock function with given fields: ctx, key

func (*Pipeliner) Persist 

func (_m *Pipeliner) Persist(ctx context.Context, key string) *redis.BoolCmd

Persist provides a mock function with given fields: ctx, key

func (*Pipeliner) Ping 

func (_m *Pipeliner) Ping(ctx context.Context) *redis.StatusCmd

Ping provides a mock function with given fields: ctx

func (*Pipeliner) Pipeline 

func (_m *Pipeliner) Pipeline() redis.Pipeliner

Pipeline provides a mock function with given fields:

func (*Pipeliner) Pipelined 

func (_m *Pipeliner) Pipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error)

Pipelined provides a mock function with given fields: ctx, fn

func (*Pipeliner) Process 

func (_m *Pipeliner) Process(ctx context.Context, cmd redis.Cmder) error

Process provides a mock function with given fields: ctx, cmd

func (*Pipeliner) PubSubChannels 

func (_m *Pipeliner) PubSubChannels(ctx context.Context, pattern string) *redis.StringSliceCmd

PubSubChannels provides a mock function with given fields: ctx, pattern

func (*Pipeliner) PubSubNumPat 

func (_m *Pipeliner) PubSubNumPat(ctx context.Context) *redis.IntCmd

PubSubNumPat provides a mock function with given fields: ctx

func (*Pipeliner) PubSubNumSub 

func (_m *Pipeliner) PubSubNumSub(ctx context.Context, channels ...string) *redis.StringIntMapCmd

PubSubNumSub provides a mock function with given fields: ctx, channels

func (*Pipeliner) Publish 

func (_m *Pipeliner) Publish(ctx context.Context, channel string, message interface{}) *redis.IntCmd

Publish provides a mock function with given fields: ctx, channel, message

func (*Pipeliner) Quit 

func (_m *Pipeliner) Quit(ctx context.Context) *redis.StatusCmd

Quit provides a mock function with given fields: ctx

func (*Pipeliner) RPop 

func (_m *Pipeliner) RPop(ctx context.Context, key string) *redis.StringCmd

RPop provides a mock function with given fields: ctx, key

func (*Pipeliner) RPopCount 

func (_m *Pipeliner) RPopCount(ctx context.Context, key string, count int) *redis.StringSliceCmd

RPopCount provides a mock function with given fields: ctx, key, count

func (*Pipeliner) RPopLPush 

func (_m *Pipeliner) RPopLPush(ctx context.Context, source string, destination string) *redis.StringCmd

RPopLPush provides a mock function with given fields: ctx, source, destination

func (*Pipeliner) RPush 

func (_m *Pipeliner) RPush(ctx context.Context, key string, values ...interface{}) *redis.IntCmd

RPush provides a mock function with given fields: ctx, key, values

func (*Pipeliner) RPushX 

func (_m *Pipeliner) RPushX(ctx context.Context, key string, values ...interface{}) *redis.IntCmd

RPushX provides a mock function with given fields: ctx, key, values

func (*Pipeliner) RandomKey 

func (_m *Pipeliner) RandomKey(ctx context.Context) *redis.StringCmd

RandomKey provides a mock function with given fields: ctx

func (*Pipeliner) ReadOnly 

func (_m *Pipeliner) ReadOnly(ctx context.Context) *redis.StatusCmd

ReadOnly provides a mock function with given fields: ctx

func (*Pipeliner) ReadWrite 

func (_m *Pipeliner) ReadWrite(ctx context.Context) *redis.StatusCmd

ReadWrite provides a mock function with given fields: ctx

func (*Pipeliner) Rename 

func (_m *Pipeliner) Rename(ctx context.Context, key string, newkey string) *redis.StatusCmd

Rename provides a mock function with given fields: ctx, key, newkey

func (*Pipeliner) RenameNX 

func (_m *Pipeliner) RenameNX(ctx context.Context, key string, newkey string) *redis.BoolCmd

RenameNX provides a mock function with given fields: ctx, key, newkey

func (*Pipeliner) Restore 

func (_m *Pipeliner) Restore(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd

Restore provides a mock function with given fields: ctx, key, ttl, value

func (*Pipeliner) RestoreReplace 

func (_m *Pipeliner) RestoreReplace(ctx context.Context, key string, ttl time.Duration, value string) *redis.StatusCmd

RestoreReplace provides a mock function with given fields: ctx, key, ttl, value

func (*Pipeliner) SAdd 

func (_m *Pipeliner) SAdd(ctx context.Context, key string, members ...interface{}) *redis.IntCmd

SAdd provides a mock function with given fields: ctx, key, members

func (*Pipeliner) SCard 

func (_m *Pipeliner) SCard(ctx context.Context, key string) *redis.IntCmd

SCard provides a mock function with given fields: ctx, key

func (*Pipeliner) SDiff 

func (_m *Pipeliner) SDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd

SDiff provides a mock function with given fields: ctx, keys

func (*Pipeliner) SDiffStore 

func (_m *Pipeliner) SDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd

SDiffStore provides a mock function with given fields: ctx, destination, keys

func (*Pipeliner) SInter 

func (_m *Pipeliner) SInter(ctx context.Context, keys ...string) *redis.StringSliceCmd

SInter provides a mock function with given fields: ctx, keys

func (*Pipeliner) SInterStore 

func (_m *Pipeliner) SInterStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd

SInterStore provides a mock function with given fields: ctx, destination, keys

func (*Pipeliner) SIsMember 

func (_m *Pipeliner) SIsMember(ctx context.Context, key string, member interface{}) *redis.BoolCmd

SIsMember provides a mock function with given fields: ctx, key, member

func (*Pipeliner) SMIsMember 

func (_m *Pipeliner) SMIsMember(ctx context.Context, key string, members ...interface{}) *redis.BoolSliceCmd

SMIsMember provides a mock function with given fields: ctx, key, members

func (*Pipeliner) SMembers 

func (_m *Pipeliner) SMembers(ctx context.Context, key string) *redis.StringSliceCmd

SMembers provides a mock function with given fields: ctx, key

func (*Pipeliner) SMembersMap 

func (_m *Pipeliner) SMembersMap(ctx context.Context, key string) *redis.StringStructMapCmd

SMembersMap provides a mock function with given fields: ctx, key

func (*Pipeliner) SMove 

func (_m *Pipeliner) SMove(ctx context.Context, source string, destination string, member interface{}) *redis.BoolCmd

SMove provides a mock function with given fields: ctx, source, destination, member

func (*Pipeliner) SPop 

func (_m *Pipeliner) SPop(ctx context.Context, key string) *redis.StringCmd

SPop provides a mock function with given fields: ctx, key

func (*Pipeliner) SPopN 

func (_m *Pipeliner) SPopN(ctx context.Context, key string, count int64) *redis.StringSliceCmd

SPopN provides a mock function with given fields: ctx, key, count

func (*Pipeliner) SRandMember 

func (_m *Pipeliner) SRandMember(ctx context.Context, key string) *redis.StringCmd

SRandMember provides a mock function with given fields: ctx, key

func (*Pipeliner) SRandMemberN 

func (_m *Pipeliner) SRandMemberN(ctx context.Context, key string, count int64) *redis.StringSliceCmd

SRandMemberN provides a mock function with given fields: ctx, key, count

func (*Pipeliner) SRem 

func (_m *Pipeliner) SRem(ctx context.Context, key string, members ...interface{}) *redis.IntCmd

SRem provides a mock function with given fields: ctx, key, members

func (*Pipeliner) SScan 

func (_m *Pipeliner) SScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd

SScan provides a mock function with given fields: ctx, key, cursor, match, count

func (*Pipeliner) SUnion 

func (_m *Pipeliner) SUnion(ctx context.Context, keys ...string) *redis.StringSliceCmd

SUnion provides a mock function with given fields: ctx, keys

func (*Pipeliner) SUnionStore 

func (_m *Pipeliner) SUnionStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd

SUnionStore provides a mock function with given fields: ctx, destination, keys

func (*Pipeliner) Save 

func (_m *Pipeliner) Save(ctx context.Context) *redis.StatusCmd

Save provides a mock function with given fields: ctx

func (*Pipeliner) Scan 

func (_m *Pipeliner) Scan(ctx context.Context, cursor uint64, match string, count int64) *redis.ScanCmd

Scan provides a mock function with given fields: ctx, cursor, match, count

func (*Pipeliner) ScanType 

func (_m *Pipeliner) ScanType(ctx context.Context, cursor uint64, match string, count int64, keyType string) *redis.ScanCmd

ScanType provides a mock function with given fields: ctx, cursor, match, count, keyType

func (*Pipeliner) ScriptExists 

func (_m *Pipeliner) ScriptExists(ctx context.Context, hashes ...string) *redis.BoolSliceCmd

ScriptExists provides a mock function with given fields: ctx, hashes

func (*Pipeliner) ScriptFlush 

func (_m *Pipeliner) ScriptFlush(ctx context.Context) *redis.StatusCmd

ScriptFlush provides a mock function with given fields: ctx

func (*Pipeliner) ScriptKill 

func (_m *Pipeliner) ScriptKill(ctx context.Context) *redis.StatusCmd

ScriptKill provides a mock function with given fields: ctx

func (*Pipeliner) ScriptLoad 

func (_m *Pipeliner) ScriptLoad(ctx context.Context, script string) *redis.StringCmd

ScriptLoad provides a mock function with given fields: ctx, script

func (*Pipeliner) Select 

func (_m *Pipeliner) Select(ctx context.Context, index int) *redis.StatusCmd

Select provides a mock function with given fields: ctx, index

func (*Pipeliner) Set 

func (_m *Pipeliner) Set(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.StatusCmd

Set provides a mock function with given fields: ctx, key, value, expiration

func (*Pipeliner) SetArgs 

func (_m *Pipeliner) SetArgs(ctx context.Context, key string, value interface{}, a redis.SetArgs) *redis.StatusCmd

SetArgs provides a mock function with given fields: ctx, key, value, a

func (*Pipeliner) SetBit 

func (_m *Pipeliner) SetBit(ctx context.Context, key string, offset int64, value int) *redis.IntCmd

SetBit provides a mock function with given fields: ctx, key, offset, value

func (*Pipeliner) SetEX 

func (_m *Pipeliner) SetEX(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.StatusCmd

SetEX provides a mock function with given fields: ctx, key, value, expiration

func (*Pipeliner) SetNX 

func (_m *Pipeliner) SetNX(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.BoolCmd

SetNX provides a mock function with given fields: ctx, key, value, expiration

func (*Pipeliner) SetRange 

func (_m *Pipeliner) SetRange(ctx context.Context, key string, offset int64, value string) *redis.IntCmd

SetRange provides a mock function with given fields: ctx, key, offset, value

func (*Pipeliner) SetXX 

func (_m *Pipeliner) SetXX(ctx context.Context, key string, value interface{}, expiration time.Duration) *redis.BoolCmd

SetXX provides a mock function with given fields: ctx, key, value, expiration

func (*Pipeliner) Shutdown 

func (_m *Pipeliner) Shutdown(ctx context.Context) *redis.StatusCmd

Shutdown provides a mock function with given fields: ctx

func (*Pipeliner) ShutdownNoSave 

func (_m *Pipeliner) ShutdownNoSave(ctx context.Context) *redis.StatusCmd

ShutdownNoSave provides a mock function with given fields: ctx

func (*Pipeliner) ShutdownSave 

func (_m *Pipeliner) ShutdownSave(ctx context.Context) *redis.StatusCmd

ShutdownSave provides a mock function with given fields: ctx

func (*Pipeliner) SlaveOf 

func (_m *Pipeliner) SlaveOf(ctx context.Context, host string, port string) *redis.StatusCmd

SlaveOf provides a mock function with given fields: ctx, host, port

func (*Pipeliner) Sort 

func (_m *Pipeliner) Sort(ctx context.Context, key string, sort *redis.Sort) *redis.StringSliceCmd

Sort provides a mock function with given fields: ctx, key, sort

func (*Pipeliner) SortInterfaces 

func (_m *Pipeliner) SortInterfaces(ctx context.Context, key string, sort *redis.Sort) *redis.SliceCmd

SortInterfaces provides a mock function with given fields: ctx, key, sort

func (*Pipeliner) SortStore 

func (_m *Pipeliner) SortStore(ctx context.Context, key string, store string, sort *redis.Sort) *redis.IntCmd

SortStore provides a mock function with given fields: ctx, key, store, sort

func (*Pipeliner) StrLen 

func (_m *Pipeliner) StrLen(ctx context.Context, key string) *redis.IntCmd

StrLen provides a mock function with given fields: ctx, key

func (*Pipeliner) SwapDB 

func (_m *Pipeliner) SwapDB(ctx context.Context, index1 int, index2 int) *redis.StatusCmd

SwapDB provides a mock function with given fields: ctx, index1, index2

func (*Pipeliner) TTL 

func (_m *Pipeliner) TTL(ctx context.Context, key string) *redis.DurationCmd

TTL provides a mock function with given fields: ctx, key

func (*Pipeliner) Time 

func (_m *Pipeliner) Time(ctx context.Context) *redis.TimeCmd

Time provides a mock function with given fields: ctx

func (*Pipeliner) Touch 

func (_m *Pipeliner) Touch(ctx context.Context, keys ...string) *redis.IntCmd

Touch provides a mock function with given fields: ctx, keys

func (*Pipeliner) TxPipeline 

func (_m *Pipeliner) TxPipeline() redis.Pipeliner

TxPipeline provides a mock function with given fields:

func (*Pipeliner) TxPipelined 

func (_m *Pipeliner) TxPipelined(ctx context.Context, fn func(redis.Pipeliner) error) ([]redis.Cmder, error)

TxPipelined provides a mock function with given fields: ctx, fn

func (*Pipeliner) Type 

func (_m *Pipeliner) Type(ctx context.Context, key string) *redis.StatusCmd

Type provides a mock function with given fields: ctx, key 

func (_m *Pipeliner) Unlink(ctx context.Context, keys ...string) *redis.IntCmd

Unlink provides a mock function with given fields: ctx, keys

func (*Pipeliner) XAck 

func (_m *Pipeliner) XAck(ctx context.Context, stream string, group string, ids ...string) *redis.IntCmd

XAck provides a mock function with given fields: ctx, stream, group, ids

func (*Pipeliner) XAdd 

func (_m *Pipeliner) XAdd(ctx context.Context, a *redis.XAddArgs) *redis.StringCmd

XAdd provides a mock function with given fields: ctx, a

func (*Pipeliner) XAutoClaim 

func (_m *Pipeliner) XAutoClaim(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimCmd

XAutoClaim provides a mock function with given fields: ctx, a

func (*Pipeliner) XAutoClaimJustID 

func (_m *Pipeliner) XAutoClaimJustID(ctx context.Context, a *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd

XAutoClaimJustID provides a mock function with given fields: ctx, a

func (*Pipeliner) XClaim 

func (_m *Pipeliner) XClaim(ctx context.Context, a *redis.XClaimArgs) *redis.XMessageSliceCmd

XClaim provides a mock function with given fields: ctx, a

func (*Pipeliner) XClaimJustID 

func (_m *Pipeliner) XClaimJustID(ctx context.Context, a *redis.XClaimArgs) *redis.StringSliceCmd

XClaimJustID provides a mock function with given fields: ctx, a

func (*Pipeliner) XDel 

func (_m *Pipeliner) XDel(ctx context.Context, stream string, ids ...string) *redis.IntCmd

XDel provides a mock function with given fields: ctx, stream, ids

func (*Pipeliner) XGroupCreate 

func (_m *Pipeliner) XGroupCreate(ctx context.Context, stream string, group string, start string) *redis.StatusCmd

XGroupCreate provides a mock function with given fields: ctx, stream, group, start

func (*Pipeliner) XGroupCreateConsumer 

func (_m *Pipeliner) XGroupCreateConsumer(ctx context.Context, stream string, group string, consumer string) *redis.IntCmd

XGroupCreateConsumer provides a mock function with given fields: ctx, stream, group, consumer

func (*Pipeliner) XGroupCreateMkStream 

func (_m *Pipeliner) XGroupCreateMkStream(ctx context.Context, stream string, group string, start string) *redis.StatusCmd

XGroupCreateMkStream provides a mock function with given fields: ctx, stream, group, start

func (*Pipeliner) XGroupDelConsumer 

func (_m *Pipeliner) XGroupDelConsumer(ctx context.Context, stream string, group string, consumer string) *redis.IntCmd

XGroupDelConsumer provides a mock function with given fields: ctx, stream, group, consumer

func (*Pipeliner) XGroupDestroy 

func (_m *Pipeliner) XGroupDestroy(ctx context.Context, stream string, group string) *redis.IntCmd

XGroupDestroy provides a mock function with given fields: ctx, stream, group

func (*Pipeliner) XGroupSetID 

func (_m *Pipeliner) XGroupSetID(ctx context.Context, stream string, group string, start string) *redis.StatusCmd

XGroupSetID provides a mock function with given fields: ctx, stream, group, start

func (*Pipeliner) XInfoConsumers 

func (_m *Pipeliner) XInfoConsumers(ctx context.Context, key string, group string) *redis.XInfoConsumersCmd

XInfoConsumers provides a mock function with given fields: ctx, key, group

func (*Pipeliner) XInfoGroups 

func (_m *Pipeliner) XInfoGroups(ctx context.Context, key string) *redis.XInfoGroupsCmd

XInfoGroups provides a mock function with given fields: ctx, key

func (*Pipeliner) XInfoStream 

func (_m *Pipeliner) XInfoStream(ctx context.Context, key string) *redis.XInfoStreamCmd

XInfoStream provides a mock function with given fields: ctx, key

func (*Pipeliner) XInfoStreamFull 

func (_m *Pipeliner) XInfoStreamFull(ctx context.Context, key string, count int) *redis.XInfoStreamFullCmd

XInfoStreamFull provides a mock function with given fields: ctx, key, count

func (*Pipeliner) XLen 

func (_m *Pipeliner) XLen(ctx context.Context, stream string) *redis.IntCmd

XLen provides a mock function with given fields: ctx, stream

func (*Pipeliner) XPending 

func (_m *Pipeliner) XPending(ctx context.Context, stream string, group string) *redis.XPendingCmd

XPending provides a mock function with given fields: ctx, stream, group

func (*Pipeliner) XPendingExt 

func (_m *Pipeliner) XPendingExt(ctx context.Context, a *redis.XPendingExtArgs) *redis.XPendingExtCmd

XPendingExt provides a mock function with given fields: ctx, a

func (*Pipeliner) XRange 

func (_m *Pipeliner) XRange(ctx context.Context, stream string, start string, stop string) *redis.XMessageSliceCmd

XRange provides a mock function with given fields: ctx, stream, start, stop

func (*Pipeliner) XRangeN 

func (_m *Pipeliner) XRangeN(ctx context.Context, stream string, start string, stop string, count int64) *redis.XMessageSliceCmd

XRangeN provides a mock function with given fields: ctx, stream, start, stop, count

func (*Pipeliner) XRead 

func (_m *Pipeliner) XRead(ctx context.Context, a *redis.XReadArgs) *redis.XStreamSliceCmd

XRead provides a mock function with given fields: ctx, a

func (*Pipeliner) XReadGroup 

func (_m *Pipeliner) XReadGroup(ctx context.Context, a *redis.XReadGroupArgs) *redis.XStreamSliceCmd

XReadGroup provides a mock function with given fields: ctx, a

func (*Pipeliner) XReadStreams 

func (_m *Pipeliner) XReadStreams(ctx context.Context, streams ...string) *redis.XStreamSliceCmd

XReadStreams provides a mock function with given fields: ctx, streams

func (*Pipeliner) XRevRange 

func (_m *Pipeliner) XRevRange(ctx context.Context, stream string, start string, stop string) *redis.XMessageSliceCmd

XRevRange provides a mock function with given fields: ctx, stream, start, stop

func (*Pipeliner) XRevRangeN 

func (_m *Pipeliner) XRevRangeN(ctx context.Context, stream string, start string, stop string, count int64) *redis.XMessageSliceCmd

XRevRangeN provides a mock function with given fields: ctx, stream, start, stop, count

func (*Pipeliner) XTrim 

func (_m *Pipeliner) XTrim(ctx context.Context, key string, maxLen int64) *redis.IntCmd

XTrim provides a mock function with given fields: ctx, key, maxLen

func (*Pipeliner) XTrimApprox 

func (_m *Pipeliner) XTrimApprox(ctx context.Context, key string, maxLen int64) *redis.IntCmd

XTrimApprox provides a mock function with given fields: ctx, key, maxLen

func (*Pipeliner) XTrimMaxLen 

func (_m *Pipeliner) XTrimMaxLen(ctx context.Context, key string, maxLen int64) *redis.IntCmd

XTrimMaxLen provides a mock function with given fields: ctx, key, maxLen

func (*Pipeliner) XTrimMaxLenApprox 

func (_m *Pipeliner) XTrimMaxLenApprox(ctx context.Context, key string, maxLen int64, limit int64) *redis.IntCmd

XTrimMaxLenApprox provides a mock function with given fields: ctx, key, maxLen, limit

func (*Pipeliner) XTrimMinID 

func (_m *Pipeliner) XTrimMinID(ctx context.Context, key string, minID string) *redis.IntCmd

XTrimMinID provides a mock function with given fields: ctx, key, minID

func (*Pipeliner) XTrimMinIDApprox 

func (_m *Pipeliner) XTrimMinIDApprox(ctx context.Context, key string, minID string, limit int64) *redis.IntCmd

XTrimMinIDApprox provides a mock function with given fields: ctx, key, minID, limit

func (*Pipeliner) ZAdd 

func (_m *Pipeliner) ZAdd(ctx context.Context, key string, members ...*redis.Z) *redis.IntCmd

ZAdd provides a mock function with given fields: ctx, key, members

func (*Pipeliner) ZAddArgs 

func (_m *Pipeliner) ZAddArgs(ctx context.Context, key string, args redis.ZAddArgs) *redis.IntCmd

ZAddArgs provides a mock function with given fields: ctx, key, args

func (*Pipeliner) ZAddArgsIncr 

func (_m *Pipeliner) ZAddArgsIncr(ctx context.Context, key string, args redis.ZAddArgs) *redis.FloatCmd

ZAddArgsIncr provides a mock function with given fields: ctx, key, args

func (*Pipeliner) ZAddCh 

func (_m *Pipeliner) ZAddCh(ctx context.Context, key string, members ...*redis.Z) *redis.IntCmd

ZAddCh provides a mock function with given fields: ctx, key, members

func (*Pipeliner) ZAddNX 

func (_m *Pipeliner) ZAddNX(ctx context.Context, key string, members ...*redis.Z) *redis.IntCmd

ZAddNX provides a mock function with given fields: ctx, key, members

func (*Pipeliner) ZAddNXCh 

func (_m *Pipeliner) ZAddNXCh(ctx context.Context, key string, members ...*redis.Z) *redis.IntCmd

ZAddNXCh provides a mock function with given fields: ctx, key, members

func (*Pipeliner) ZAddXX 

func (_m *Pipeliner) ZAddXX(ctx context.Context, key string, members ...*redis.Z) *redis.IntCmd

ZAddXX provides a mock function with given fields: ctx, key, members

func (*Pipeliner) ZAddXXCh 

func (_m *Pipeliner) ZAddXXCh(ctx context.Context, key string, members ...*redis.Z) *redis.IntCmd

ZAddXXCh provides a mock function with given fields: ctx, key, members

func (*Pipeliner) ZCard 

func (_m *Pipeliner) ZCard(ctx context.Context, key string) *redis.IntCmd

ZCard provides a mock function with given fields: ctx, key

func (*Pipeliner) ZCount 

func (_m *Pipeliner) ZCount(ctx context.Context, key string, min string, max string) *redis.IntCmd

ZCount provides a mock function with given fields: ctx, key, min, max

func (*Pipeliner) ZDiff 

func (_m *Pipeliner) ZDiff(ctx context.Context, keys ...string) *redis.StringSliceCmd

ZDiff provides a mock function with given fields: ctx, keys

func (*Pipeliner) ZDiffStore 

func (_m *Pipeliner) ZDiffStore(ctx context.Context, destination string, keys ...string) *redis.IntCmd

ZDiffStore provides a mock function with given fields: ctx, destination, keys

func (*Pipeliner) ZDiffWithScores 

func (_m *Pipeliner) ZDiffWithScores(ctx context.Context, keys ...string) *redis.ZSliceCmd

ZDiffWithScores provides a mock function with given fields: ctx, keys

func (*Pipeliner) ZIncr 

func (_m *Pipeliner) ZIncr(ctx context.Context, key string, member *redis.Z) *redis.FloatCmd

ZIncr provides a mock function with given fields: ctx, key, member

func (*Pipeliner) ZIncrBy 

func (_m *Pipeliner) ZIncrBy(ctx context.Context, key string, increment float64, member string) *redis.FloatCmd

ZIncrBy provides a mock function with given fields: ctx, key, increment, member

func (*Pipeliner) ZIncrNX 

func (_m *Pipeliner) ZIncrNX(ctx context.Context, key string, member *redis.Z) *redis.FloatCmd

ZIncrNX provides a mock function with given fields: ctx, key, member

func (*Pipeliner) ZIncrXX 

func (_m *Pipeliner) ZIncrXX(ctx context.Context, key string, member *redis.Z) *redis.FloatCmd

ZIncrXX provides a mock function with given fields: ctx, key, member

func (*Pipeliner) ZInter 

func (_m *Pipeliner) ZInter(ctx context.Context, store *redis.ZStore) *redis.StringSliceCmd

ZInter provides a mock function with given fields: ctx, store

func (*Pipeliner) ZInterStore 

func (_m *Pipeliner) ZInterStore(ctx context.Context, destination string, store *redis.ZStore) *redis.IntCmd

ZInterStore provides a mock function with given fields: ctx, destination, store

func (*Pipeliner) ZInterWithScores 

func (_m *Pipeliner) ZInterWithScores(ctx context.Context, store *redis.ZStore) *redis.ZSliceCmd

ZInterWithScores provides a mock function with given fields: ctx, store

func (*Pipeliner) ZLexCount 

func (_m *Pipeliner) ZLexCount(ctx context.Context, key string, min string, max string) *redis.IntCmd

ZLexCount provides a mock function with given fields: ctx, key, min, max

func (*Pipeliner) ZMScore 

func (_m *Pipeliner) ZMScore(ctx context.Context, key string, members ...string) *redis.FloatSliceCmd

ZMScore provides a mock function with given fields: ctx, key, members

func (*Pipeliner) ZPopMax 

func (_m *Pipeliner) ZPopMax(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd

ZPopMax provides a mock function with given fields: ctx, key, count

func (*Pipeliner) ZPopMin 

func (_m *Pipeliner) ZPopMin(ctx context.Context, key string, count ...int64) *redis.ZSliceCmd

ZPopMin provides a mock function with given fields: ctx, key, count

func (*Pipeliner) ZRandMember 

func (_m *Pipeliner) ZRandMember(ctx context.Context, key string, count int, withScores bool) *redis.StringSliceCmd

ZRandMember provides a mock function with given fields: ctx, key, count, withScores

func (*Pipeliner) ZRange 

func (_m *Pipeliner) ZRange(ctx context.Context, key string, start int64, stop int64) *redis.StringSliceCmd

ZRange provides a mock function with given fields: ctx, key, start, stop

func (*Pipeliner) ZRangeArgs 

func (_m *Pipeliner) ZRangeArgs(ctx context.Context, z redis.ZRangeArgs) *redis.StringSliceCmd

ZRangeArgs provides a mock function with given fields: ctx, z

func (*Pipeliner) ZRangeArgsWithScores 

func (_m *Pipeliner) ZRangeArgsWithScores(ctx context.Context, z redis.ZRangeArgs) *redis.ZSliceCmd

ZRangeArgsWithScores provides a mock function with given fields: ctx, z

func (*Pipeliner) ZRangeByLex 

func (_m *Pipeliner) ZRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd

ZRangeByLex provides a mock function with given fields: ctx, key, opt

func (*Pipeliner) ZRangeByScore 

func (_m *Pipeliner) ZRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd

ZRangeByScore provides a mock function with given fields: ctx, key, opt

func (*Pipeliner) ZRangeByScoreWithScores 

func (_m *Pipeliner) ZRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd

ZRangeByScoreWithScores provides a mock function with given fields: ctx, key, opt

func (*Pipeliner) ZRangeStore 

func (_m *Pipeliner) ZRangeStore(ctx context.Context, dst string, z redis.ZRangeArgs) *redis.IntCmd

ZRangeStore provides a mock function with given fields: ctx, dst, z

func (*Pipeliner) ZRangeWithScores 

func (_m *Pipeliner) ZRangeWithScores(ctx context.Context, key string, start int64, stop int64) *redis.ZSliceCmd

ZRangeWithScores provides a mock function with given fields: ctx, key, start, stop

func (*Pipeliner) ZRank 

func (_m *Pipeliner) ZRank(ctx context.Context, key string, member string) *redis.IntCmd

ZRank provides a mock function with given fields: ctx, key, member

func (*Pipeliner) ZRem 

func (_m *Pipeliner) ZRem(ctx context.Context, key string, members ...interface{}) *redis.IntCmd

ZRem provides a mock function with given fields: ctx, key, members

func (*Pipeliner) ZRemRangeByLex 

func (_m *Pipeliner) ZRemRangeByLex(ctx context.Context, key string, min string, max string) *redis.IntCmd

ZRemRangeByLex provides a mock function with given fields: ctx, key, min, max

func (*Pipeliner) ZRemRangeByRank 

func (_m *Pipeliner) ZRemRangeByRank(ctx context.Context, key string, start int64, stop int64) *redis.IntCmd

ZRemRangeByRank provides a mock function with given fields: ctx, key, start, stop

func (*Pipeliner) ZRemRangeByScore 

func (_m *Pipeliner) ZRemRangeByScore(ctx context.Context, key string, min string, max string) *redis.IntCmd

ZRemRangeByScore provides a mock function with given fields: ctx, key, min, max

func (*Pipeliner) ZRevRange 

func (_m *Pipeliner) ZRevRange(ctx context.Context, key string, start int64, stop int64) *redis.StringSliceCmd

ZRevRange provides a mock function with given fields: ctx, key, start, stop

func (*Pipeliner) ZRevRangeByLex 

func (_m *Pipeliner) ZRevRangeByLex(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd

ZRevRangeByLex provides a mock function with given fields: ctx, key, opt

func (*Pipeliner) ZRevRangeByScore 

func (_m *Pipeliner) ZRevRangeByScore(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.StringSliceCmd

ZRevRangeByScore provides a mock function with given fields: ctx, key, opt

func (*Pipeliner) ZRevRangeByScoreWithScores 

func (_m *Pipeliner) ZRevRangeByScoreWithScores(ctx context.Context, key string, opt *redis.ZRangeBy) *redis.ZSliceCmd

ZRevRangeByScoreWithScores provides a mock function with given fields: ctx, key, opt

func (*Pipeliner) ZRevRangeWithScores 

func (_m *Pipeliner) ZRevRangeWithScores(ctx context.Context, key string, start int64, stop int64) *redis.ZSliceCmd

ZRevRangeWithScores provides a mock function with given fields: ctx, key, start, stop

func (*Pipeliner) ZRevRank 

func (_m *Pipeliner) ZRevRank(ctx context.Context, key string, member string) *redis.IntCmd

ZRevRank provides a mock function with given fields: ctx, key, member

func (*Pipeliner) ZScan 

func (_m *Pipeliner) ZScan(ctx context.Context, key string, cursor uint64, match string, count int64) *redis.ScanCmd

ZScan provides a mock function with given fields: ctx, key, cursor, match, count

func (*Pipeliner) ZScore 

func (_m *Pipeliner) ZScore(ctx context.Context, key string, member string) *redis.FloatCmd

ZScore provides a mock function with given fields: ctx, key, member

func (*Pipeliner) ZUnion 

func (_m *Pipeliner) ZUnion(ctx context.Context, store redis.ZStore) *redis.StringSliceCmd

ZUnion provides a mock function with given fields: ctx, store

func (*Pipeliner) ZUnionStore 

func (_m *Pipeliner) ZUnionStore(ctx context.Context, dest string, store *redis.ZStore) *redis.IntCmd

ZUnionStore provides a mock function with given fields: ctx, dest, store

func (*Pipeliner) ZUnionWithScores 

func (_m *Pipeliner) ZUnionWithScores(ctx context.Context, store redis.ZStore) *redis.ZSliceCmd

ZUnionWithScores provides a mock function with given fields: ctx, store

type Pipeliner_Append_Call 

type Pipeliner_Append_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Append_Call) Return 

func (_c *Pipeliner_Append_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Append_Call

func (*Pipeliner_Append_Call) Run 

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

func (*Pipeliner_Append_Call) RunAndReturn 

func (_c *Pipeliner_Append_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *Pipeliner_Append_Call

type Pipeliner_AuthACL_Call 

type Pipeliner_AuthACL_Call struct {
	*mock.Call
}

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

func (*Pipeliner_AuthACL_Call) Return 

func (_c *Pipeliner_AuthACL_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_AuthACL_Call

func (*Pipeliner_AuthACL_Call) Run 

func (_c *Pipeliner_AuthACL_Call) Run(run func(ctx context.Context, username string, password string)) *Pipeliner_AuthACL_Call

func (*Pipeliner_AuthACL_Call) RunAndReturn 

func (_c *Pipeliner_AuthACL_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *Pipeliner_AuthACL_Call

type Pipeliner_Auth_Call 

type Pipeliner_Auth_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Auth_Call) Return 

func (_c *Pipeliner_Auth_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Auth_Call

func (*Pipeliner_Auth_Call) Run 

func (_c *Pipeliner_Auth_Call) Run(run func(ctx context.Context, password string)) *Pipeliner_Auth_Call

func (*Pipeliner_Auth_Call) RunAndReturn 

func (_c *Pipeliner_Auth_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *Pipeliner_Auth_Call

type Pipeliner_BLMove_Call 

type Pipeliner_BLMove_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BLMove_Call) Return 

func (_c *Pipeliner_BLMove_Call) Return(_a0 *redis.StringCmd) *Pipeliner_BLMove_Call

func (*Pipeliner_BLMove_Call) Run 

func (_c *Pipeliner_BLMove_Call) Run(run func(ctx context.Context, source string, destination string, srcpos string, destpos string, timeout time.Duration)) *Pipeliner_BLMove_Call

func (*Pipeliner_BLMove_Call) RunAndReturn 

func (_c *Pipeliner_BLMove_Call) RunAndReturn(run func(context.Context, string, string, string, string, time.Duration) *redis.StringCmd) *Pipeliner_BLMove_Call

type Pipeliner_BLPop_Call 

type Pipeliner_BLPop_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BLPop_Call) Return 

func (_c *Pipeliner_BLPop_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_BLPop_Call

func (*Pipeliner_BLPop_Call) Run 

func (_c *Pipeliner_BLPop_Call) Run(run func(ctx context.Context, timeout time.Duration, keys ...string)) *Pipeliner_BLPop_Call

func (*Pipeliner_BLPop_Call) RunAndReturn 

func (_c *Pipeliner_BLPop_Call) RunAndReturn(run func(context.Context, time.Duration, ...string) *redis.StringSliceCmd) *Pipeliner_BLPop_Call

type Pipeliner_BRPopLPush_Call 

type Pipeliner_BRPopLPush_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BRPopLPush_Call) Return 

func (_c *Pipeliner_BRPopLPush_Call) Return(_a0 *redis.StringCmd) *Pipeliner_BRPopLPush_Call

func (*Pipeliner_BRPopLPush_Call) Run 

func (_c *Pipeliner_BRPopLPush_Call) Run(run func(ctx context.Context, source string, destination string, timeout time.Duration)) *Pipeliner_BRPopLPush_Call

func (*Pipeliner_BRPopLPush_Call) RunAndReturn 

func (_c *Pipeliner_BRPopLPush_Call) RunAndReturn(run func(context.Context, string, string, time.Duration) *redis.StringCmd) *Pipeliner_BRPopLPush_Call

type Pipeliner_BRPop_Call 

type Pipeliner_BRPop_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BRPop_Call) Return 

func (_c *Pipeliner_BRPop_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_BRPop_Call

func (*Pipeliner_BRPop_Call) Run 

func (_c *Pipeliner_BRPop_Call) Run(run func(ctx context.Context, timeout time.Duration, keys ...string)) *Pipeliner_BRPop_Call

func (*Pipeliner_BRPop_Call) RunAndReturn 

func (_c *Pipeliner_BRPop_Call) RunAndReturn(run func(context.Context, time.Duration, ...string) *redis.StringSliceCmd) *Pipeliner_BRPop_Call

type Pipeliner_BZPopMax_Call 

type Pipeliner_BZPopMax_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BZPopMax_Call) Return 

func (_c *Pipeliner_BZPopMax_Call) Return(_a0 *redis.ZWithKeyCmd) *Pipeliner_BZPopMax_Call

func (*Pipeliner_BZPopMax_Call) Run 

func (_c *Pipeliner_BZPopMax_Call) Run(run func(ctx context.Context, timeout time.Duration, keys ...string)) *Pipeliner_BZPopMax_Call

func (*Pipeliner_BZPopMax_Call) RunAndReturn 

func (_c *Pipeliner_BZPopMax_Call) RunAndReturn(run func(context.Context, time.Duration, ...string) *redis.ZWithKeyCmd) *Pipeliner_BZPopMax_Call

type Pipeliner_BZPopMin_Call 

type Pipeliner_BZPopMin_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BZPopMin_Call) Return 

func (_c *Pipeliner_BZPopMin_Call) Return(_a0 *redis.ZWithKeyCmd) *Pipeliner_BZPopMin_Call

func (*Pipeliner_BZPopMin_Call) Run 

func (_c *Pipeliner_BZPopMin_Call) Run(run func(ctx context.Context, timeout time.Duration, keys ...string)) *Pipeliner_BZPopMin_Call

func (*Pipeliner_BZPopMin_Call) RunAndReturn 

func (_c *Pipeliner_BZPopMin_Call) RunAndReturn(run func(context.Context, time.Duration, ...string) *redis.ZWithKeyCmd) *Pipeliner_BZPopMin_Call

type Pipeliner_BgRewriteAOF_Call 

type Pipeliner_BgRewriteAOF_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BgRewriteAOF_Call) Return 

func (_c *Pipeliner_BgRewriteAOF_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_BgRewriteAOF_Call

func (*Pipeliner_BgRewriteAOF_Call) Run 

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

func (*Pipeliner_BgRewriteAOF_Call) RunAndReturn 

func (_c *Pipeliner_BgRewriteAOF_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_BgRewriteAOF_Call

type Pipeliner_BgSave_Call 

type Pipeliner_BgSave_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BgSave_Call) Return 

func (_c *Pipeliner_BgSave_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_BgSave_Call

func (*Pipeliner_BgSave_Call) Run 

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

func (*Pipeliner_BgSave_Call) RunAndReturn 

func (_c *Pipeliner_BgSave_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_BgSave_Call

type Pipeliner_BitCount_Call 

type Pipeliner_BitCount_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BitCount_Call) Return 

func (_c *Pipeliner_BitCount_Call) Return(_a0 *redis.IntCmd) *Pipeliner_BitCount_Call

func (*Pipeliner_BitCount_Call) Run 

func (_c *Pipeliner_BitCount_Call) Run(run func(ctx context.Context, key string, bitCount *redis.BitCount)) *Pipeliner_BitCount_Call

func (*Pipeliner_BitCount_Call) RunAndReturn 

func (_c *Pipeliner_BitCount_Call) RunAndReturn(run func(context.Context, string, *redis.BitCount) *redis.IntCmd) *Pipeliner_BitCount_Call

type Pipeliner_BitField_Call 

type Pipeliner_BitField_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BitField_Call) Return 

func (_c *Pipeliner_BitField_Call) Return(_a0 *redis.IntSliceCmd) *Pipeliner_BitField_Call

func (*Pipeliner_BitField_Call) Run 

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

func (*Pipeliner_BitField_Call) RunAndReturn 

func (_c *Pipeliner_BitField_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntSliceCmd) *Pipeliner_BitField_Call

type Pipeliner_BitOpAnd_Call 

type Pipeliner_BitOpAnd_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BitOpAnd_Call) Return 

func (_c *Pipeliner_BitOpAnd_Call) Return(_a0 *redis.IntCmd) *Pipeliner_BitOpAnd_Call

func (*Pipeliner_BitOpAnd_Call) Run 

func (_c *Pipeliner_BitOpAnd_Call) Run(run func(ctx context.Context, destKey string, keys ...string)) *Pipeliner_BitOpAnd_Call

func (*Pipeliner_BitOpAnd_Call) RunAndReturn 

func (_c *Pipeliner_BitOpAnd_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_BitOpAnd_Call

type Pipeliner_BitOpNot_Call 

type Pipeliner_BitOpNot_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BitOpNot_Call) Return 

func (_c *Pipeliner_BitOpNot_Call) Return(_a0 *redis.IntCmd) *Pipeliner_BitOpNot_Call

func (*Pipeliner_BitOpNot_Call) Run 

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

func (*Pipeliner_BitOpNot_Call) RunAndReturn 

func (_c *Pipeliner_BitOpNot_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *Pipeliner_BitOpNot_Call

type Pipeliner_BitOpOr_Call 

type Pipeliner_BitOpOr_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BitOpOr_Call) Return 

func (_c *Pipeliner_BitOpOr_Call) Return(_a0 *redis.IntCmd) *Pipeliner_BitOpOr_Call

func (*Pipeliner_BitOpOr_Call) Run 

func (_c *Pipeliner_BitOpOr_Call) Run(run func(ctx context.Context, destKey string, keys ...string)) *Pipeliner_BitOpOr_Call

func (*Pipeliner_BitOpOr_Call) RunAndReturn 

func (_c *Pipeliner_BitOpOr_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_BitOpOr_Call

type Pipeliner_BitOpXor_Call 

type Pipeliner_BitOpXor_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BitOpXor_Call) Return 

func (_c *Pipeliner_BitOpXor_Call) Return(_a0 *redis.IntCmd) *Pipeliner_BitOpXor_Call

func (*Pipeliner_BitOpXor_Call) Run 

func (_c *Pipeliner_BitOpXor_Call) Run(run func(ctx context.Context, destKey string, keys ...string)) *Pipeliner_BitOpXor_Call

func (*Pipeliner_BitOpXor_Call) RunAndReturn 

func (_c *Pipeliner_BitOpXor_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_BitOpXor_Call

type Pipeliner_BitPos_Call 

type Pipeliner_BitPos_Call struct {
	*mock.Call
}

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

func (*Pipeliner_BitPos_Call) Return 

func (_c *Pipeliner_BitPos_Call) Return(_a0 *redis.IntCmd) *Pipeliner_BitPos_Call

func (*Pipeliner_BitPos_Call) Run 

func (_c *Pipeliner_BitPos_Call) Run(run func(ctx context.Context, key string, bit int64, pos ...int64)) *Pipeliner_BitPos_Call

func (*Pipeliner_BitPos_Call) RunAndReturn 

func (_c *Pipeliner_BitPos_Call) RunAndReturn(run func(context.Context, string, int64, ...int64) *redis.IntCmd) *Pipeliner_BitPos_Call

type Pipeliner_ClientGetName_Call 

type Pipeliner_ClientGetName_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClientGetName_Call) Return 

func (_c *Pipeliner_ClientGetName_Call) Return(_a0 *redis.StringCmd) *Pipeliner_ClientGetName_Call

func (*Pipeliner_ClientGetName_Call) Run 

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

func (*Pipeliner_ClientGetName_Call) RunAndReturn 

func (_c *Pipeliner_ClientGetName_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *Pipeliner_ClientGetName_Call

type Pipeliner_ClientID_Call 

type Pipeliner_ClientID_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClientID_Call) Return 

func (_c *Pipeliner_ClientID_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ClientID_Call

func (*Pipeliner_ClientID_Call) Run 

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

func (*Pipeliner_ClientID_Call) RunAndReturn 

func (_c *Pipeliner_ClientID_Call) RunAndReturn(run func(context.Context) *redis.IntCmd) *Pipeliner_ClientID_Call

type Pipeliner_ClientKillByFilter_Call 

type Pipeliner_ClientKillByFilter_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClientKillByFilter_Call) Return 

func (_c *Pipeliner_ClientKillByFilter_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ClientKillByFilter_Call

func (*Pipeliner_ClientKillByFilter_Call) Run 

func (_c *Pipeliner_ClientKillByFilter_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_ClientKillByFilter_Call

func (*Pipeliner_ClientKillByFilter_Call) RunAndReturn 

func (_c *Pipeliner_ClientKillByFilter_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *Pipeliner_ClientKillByFilter_Call

type Pipeliner_ClientKill_Call 

type Pipeliner_ClientKill_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClientKill_Call) Return 

func (_c *Pipeliner_ClientKill_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClientKill_Call

func (*Pipeliner_ClientKill_Call) Run 

func (_c *Pipeliner_ClientKill_Call) Run(run func(ctx context.Context, ipPort string)) *Pipeliner_ClientKill_Call

func (*Pipeliner_ClientKill_Call) RunAndReturn 

func (_c *Pipeliner_ClientKill_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *Pipeliner_ClientKill_Call

type Pipeliner_ClientList_Call 

type Pipeliner_ClientList_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClientList_Call) Return 

func (_c *Pipeliner_ClientList_Call) Return(_a0 *redis.StringCmd) *Pipeliner_ClientList_Call

func (*Pipeliner_ClientList_Call) Run 

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

func (*Pipeliner_ClientList_Call) RunAndReturn 

func (_c *Pipeliner_ClientList_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *Pipeliner_ClientList_Call

type Pipeliner_ClientPause_Call 

type Pipeliner_ClientPause_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClientPause_Call) Return 

func (_c *Pipeliner_ClientPause_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_ClientPause_Call

func (*Pipeliner_ClientPause_Call) Run 

func (_c *Pipeliner_ClientPause_Call) Run(run func(ctx context.Context, dur time.Duration)) *Pipeliner_ClientPause_Call

func (*Pipeliner_ClientPause_Call) RunAndReturn 

func (_c *Pipeliner_ClientPause_Call) RunAndReturn(run func(context.Context, time.Duration) *redis.BoolCmd) *Pipeliner_ClientPause_Call

type Pipeliner_ClientSetName_Call 

type Pipeliner_ClientSetName_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClientSetName_Call) Return 

func (_c *Pipeliner_ClientSetName_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_ClientSetName_Call

func (*Pipeliner_ClientSetName_Call) Run 

func (_c *Pipeliner_ClientSetName_Call) Run(run func(ctx context.Context, name string)) *Pipeliner_ClientSetName_Call

func (*Pipeliner_ClientSetName_Call) RunAndReturn 

func (_c *Pipeliner_ClientSetName_Call) RunAndReturn(run func(context.Context, string) *redis.BoolCmd) *Pipeliner_ClientSetName_Call

type Pipeliner_Close_Call 

type Pipeliner_Close_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Close_Call) Return 

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

func (*Pipeliner_Close_Call) Run 

func (_c *Pipeliner_Close_Call) Run(run func()) *Pipeliner_Close_Call

func (*Pipeliner_Close_Call) RunAndReturn 

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

type Pipeliner_ClusterAddSlotsRange_Call 

type Pipeliner_ClusterAddSlotsRange_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterAddSlotsRange_Call) Return 

func (_c *Pipeliner_ClusterAddSlotsRange_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterAddSlotsRange_Call

func (*Pipeliner_ClusterAddSlotsRange_Call) Run 

func (_c *Pipeliner_ClusterAddSlotsRange_Call) Run(run func(ctx context.Context, min int, max int)) *Pipeliner_ClusterAddSlotsRange_Call

func (*Pipeliner_ClusterAddSlotsRange_Call) RunAndReturn 

func (_c *Pipeliner_ClusterAddSlotsRange_Call) RunAndReturn(run func(context.Context, int, int) *redis.StatusCmd) *Pipeliner_ClusterAddSlotsRange_Call

type Pipeliner_ClusterAddSlots_Call 

type Pipeliner_ClusterAddSlots_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterAddSlots_Call) Return 

func (_c *Pipeliner_ClusterAddSlots_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterAddSlots_Call

func (*Pipeliner_ClusterAddSlots_Call) Run 

func (_c *Pipeliner_ClusterAddSlots_Call) Run(run func(ctx context.Context, slots ...int)) *Pipeliner_ClusterAddSlots_Call

func (*Pipeliner_ClusterAddSlots_Call) RunAndReturn 

func (_c *Pipeliner_ClusterAddSlots_Call) RunAndReturn(run func(context.Context, ...int) *redis.StatusCmd) *Pipeliner_ClusterAddSlots_Call

type Pipeliner_ClusterCountFailureReports_Call 

type Pipeliner_ClusterCountFailureReports_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterCountFailureReports_Call) Return 

func (_c *Pipeliner_ClusterCountFailureReports_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ClusterCountFailureReports_Call

func (*Pipeliner_ClusterCountFailureReports_Call) Run 

func (_c *Pipeliner_ClusterCountFailureReports_Call) Run(run func(ctx context.Context, nodeID string)) *Pipeliner_ClusterCountFailureReports_Call

func (*Pipeliner_ClusterCountFailureReports_Call) RunAndReturn 

func (_c *Pipeliner_ClusterCountFailureReports_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_ClusterCountFailureReports_Call

type Pipeliner_ClusterCountKeysInSlot_Call 

type Pipeliner_ClusterCountKeysInSlot_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterCountKeysInSlot_Call) Return 

func (_c *Pipeliner_ClusterCountKeysInSlot_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ClusterCountKeysInSlot_Call

func (*Pipeliner_ClusterCountKeysInSlot_Call) Run 

func (_c *Pipeliner_ClusterCountKeysInSlot_Call) Run(run func(ctx context.Context, slot int)) *Pipeliner_ClusterCountKeysInSlot_Call

func (*Pipeliner_ClusterCountKeysInSlot_Call) RunAndReturn 

func (_c *Pipeliner_ClusterCountKeysInSlot_Call) RunAndReturn(run func(context.Context, int) *redis.IntCmd) *Pipeliner_ClusterCountKeysInSlot_Call

type Pipeliner_ClusterDelSlotsRange_Call 

type Pipeliner_ClusterDelSlotsRange_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterDelSlotsRange_Call) Return 

func (_c *Pipeliner_ClusterDelSlotsRange_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterDelSlotsRange_Call

func (*Pipeliner_ClusterDelSlotsRange_Call) Run 

func (_c *Pipeliner_ClusterDelSlotsRange_Call) Run(run func(ctx context.Context, min int, max int)) *Pipeliner_ClusterDelSlotsRange_Call

func (*Pipeliner_ClusterDelSlotsRange_Call) RunAndReturn 

func (_c *Pipeliner_ClusterDelSlotsRange_Call) RunAndReturn(run func(context.Context, int, int) *redis.StatusCmd) *Pipeliner_ClusterDelSlotsRange_Call

type Pipeliner_ClusterDelSlots_Call 

type Pipeliner_ClusterDelSlots_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterDelSlots_Call) Return 

func (_c *Pipeliner_ClusterDelSlots_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterDelSlots_Call

func (*Pipeliner_ClusterDelSlots_Call) Run 

func (_c *Pipeliner_ClusterDelSlots_Call) Run(run func(ctx context.Context, slots ...int)) *Pipeliner_ClusterDelSlots_Call

func (*Pipeliner_ClusterDelSlots_Call) RunAndReturn 

func (_c *Pipeliner_ClusterDelSlots_Call) RunAndReturn(run func(context.Context, ...int) *redis.StatusCmd) *Pipeliner_ClusterDelSlots_Call

type Pipeliner_ClusterFailover_Call 

type Pipeliner_ClusterFailover_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterFailover_Call) Return 

func (_c *Pipeliner_ClusterFailover_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterFailover_Call

func (*Pipeliner_ClusterFailover_Call) Run 

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

func (*Pipeliner_ClusterFailover_Call) RunAndReturn 

func (_c *Pipeliner_ClusterFailover_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ClusterFailover_Call

type Pipeliner_ClusterForget_Call 

type Pipeliner_ClusterForget_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterForget_Call) Return 

func (_c *Pipeliner_ClusterForget_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterForget_Call

func (*Pipeliner_ClusterForget_Call) Run 

func (_c *Pipeliner_ClusterForget_Call) Run(run func(ctx context.Context, nodeID string)) *Pipeliner_ClusterForget_Call

func (*Pipeliner_ClusterForget_Call) RunAndReturn 

func (_c *Pipeliner_ClusterForget_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *Pipeliner_ClusterForget_Call

type Pipeliner_ClusterGetKeysInSlot_Call 

type Pipeliner_ClusterGetKeysInSlot_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterGetKeysInSlot_Call) Return 

func (_c *Pipeliner_ClusterGetKeysInSlot_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ClusterGetKeysInSlot_Call

func (*Pipeliner_ClusterGetKeysInSlot_Call) Run 

func (_c *Pipeliner_ClusterGetKeysInSlot_Call) Run(run func(ctx context.Context, slot int, count int)) *Pipeliner_ClusterGetKeysInSlot_Call

func (*Pipeliner_ClusterGetKeysInSlot_Call) RunAndReturn 

func (_c *Pipeliner_ClusterGetKeysInSlot_Call) RunAndReturn(run func(context.Context, int, int) *redis.StringSliceCmd) *Pipeliner_ClusterGetKeysInSlot_Call

type Pipeliner_ClusterInfo_Call 

type Pipeliner_ClusterInfo_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterInfo_Call) Return 

func (_c *Pipeliner_ClusterInfo_Call) Return(_a0 *redis.StringCmd) *Pipeliner_ClusterInfo_Call

func (*Pipeliner_ClusterInfo_Call) Run 

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

func (*Pipeliner_ClusterInfo_Call) RunAndReturn 

func (_c *Pipeliner_ClusterInfo_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *Pipeliner_ClusterInfo_Call

type Pipeliner_ClusterKeySlot_Call 

type Pipeliner_ClusterKeySlot_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterKeySlot_Call) Return 

func (_c *Pipeliner_ClusterKeySlot_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ClusterKeySlot_Call

func (*Pipeliner_ClusterKeySlot_Call) Run 

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

func (*Pipeliner_ClusterKeySlot_Call) RunAndReturn 

func (_c *Pipeliner_ClusterKeySlot_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_ClusterKeySlot_Call

type Pipeliner_ClusterMeet_Call 

type Pipeliner_ClusterMeet_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterMeet_Call) Return 

func (_c *Pipeliner_ClusterMeet_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterMeet_Call

func (*Pipeliner_ClusterMeet_Call) Run 

func (_c *Pipeliner_ClusterMeet_Call) Run(run func(ctx context.Context, host string, port string)) *Pipeliner_ClusterMeet_Call

func (*Pipeliner_ClusterMeet_Call) RunAndReturn 

func (_c *Pipeliner_ClusterMeet_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *Pipeliner_ClusterMeet_Call

type Pipeliner_ClusterNodes_Call 

type Pipeliner_ClusterNodes_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterNodes_Call) Return 

func (_c *Pipeliner_ClusterNodes_Call) Return(_a0 *redis.StringCmd) *Pipeliner_ClusterNodes_Call

func (*Pipeliner_ClusterNodes_Call) Run 

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

func (*Pipeliner_ClusterNodes_Call) RunAndReturn 

func (_c *Pipeliner_ClusterNodes_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *Pipeliner_ClusterNodes_Call

type Pipeliner_ClusterReplicate_Call 

type Pipeliner_ClusterReplicate_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterReplicate_Call) Return 

func (_c *Pipeliner_ClusterReplicate_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterReplicate_Call

func (*Pipeliner_ClusterReplicate_Call) Run 

func (_c *Pipeliner_ClusterReplicate_Call) Run(run func(ctx context.Context, nodeID string)) *Pipeliner_ClusterReplicate_Call

func (*Pipeliner_ClusterReplicate_Call) RunAndReturn 

func (_c *Pipeliner_ClusterReplicate_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *Pipeliner_ClusterReplicate_Call

type Pipeliner_ClusterResetHard_Call 

type Pipeliner_ClusterResetHard_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterResetHard_Call) Return 

func (_c *Pipeliner_ClusterResetHard_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterResetHard_Call

func (*Pipeliner_ClusterResetHard_Call) Run 

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

func (*Pipeliner_ClusterResetHard_Call) RunAndReturn 

func (_c *Pipeliner_ClusterResetHard_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ClusterResetHard_Call

type Pipeliner_ClusterResetSoft_Call 

type Pipeliner_ClusterResetSoft_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterResetSoft_Call) Return 

func (_c *Pipeliner_ClusterResetSoft_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterResetSoft_Call

func (*Pipeliner_ClusterResetSoft_Call) Run 

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

func (*Pipeliner_ClusterResetSoft_Call) RunAndReturn 

func (_c *Pipeliner_ClusterResetSoft_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ClusterResetSoft_Call

type Pipeliner_ClusterSaveConfig_Call 

type Pipeliner_ClusterSaveConfig_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterSaveConfig_Call) Return 

func (_c *Pipeliner_ClusterSaveConfig_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ClusterSaveConfig_Call

func (*Pipeliner_ClusterSaveConfig_Call) Run 

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

func (*Pipeliner_ClusterSaveConfig_Call) RunAndReturn 

func (_c *Pipeliner_ClusterSaveConfig_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ClusterSaveConfig_Call

type Pipeliner_ClusterSlaves_Call 

type Pipeliner_ClusterSlaves_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterSlaves_Call) Return 

func (_c *Pipeliner_ClusterSlaves_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ClusterSlaves_Call

func (*Pipeliner_ClusterSlaves_Call) Run 

func (_c *Pipeliner_ClusterSlaves_Call) Run(run func(ctx context.Context, nodeID string)) *Pipeliner_ClusterSlaves_Call

func (*Pipeliner_ClusterSlaves_Call) RunAndReturn 

func (_c *Pipeliner_ClusterSlaves_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *Pipeliner_ClusterSlaves_Call

type Pipeliner_ClusterSlots_Call 

type Pipeliner_ClusterSlots_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ClusterSlots_Call) Return 

func (_c *Pipeliner_ClusterSlots_Call) Return(_a0 *redis.ClusterSlotsCmd) *Pipeliner_ClusterSlots_Call

func (*Pipeliner_ClusterSlots_Call) Run 

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

func (*Pipeliner_ClusterSlots_Call) RunAndReturn 

func (_c *Pipeliner_ClusterSlots_Call) RunAndReturn(run func(context.Context) *redis.ClusterSlotsCmd) *Pipeliner_ClusterSlots_Call

type Pipeliner_Command_Call 

type Pipeliner_Command_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Command_Call) Return 

func (_c *Pipeliner_Command_Call) Return(_a0 *redis.CommandsInfoCmd) *Pipeliner_Command_Call

func (*Pipeliner_Command_Call) Run 

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

func (*Pipeliner_Command_Call) RunAndReturn 

func (_c *Pipeliner_Command_Call) RunAndReturn(run func(context.Context) *redis.CommandsInfoCmd) *Pipeliner_Command_Call

type Pipeliner_ConfigGet_Call 

type Pipeliner_ConfigGet_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ConfigGet_Call) Return 

func (_c *Pipeliner_ConfigGet_Call) Return(_a0 *redis.SliceCmd) *Pipeliner_ConfigGet_Call

func (*Pipeliner_ConfigGet_Call) Run 

func (_c *Pipeliner_ConfigGet_Call) Run(run func(ctx context.Context, parameter string)) *Pipeliner_ConfigGet_Call

func (*Pipeliner_ConfigGet_Call) RunAndReturn 

func (_c *Pipeliner_ConfigGet_Call) RunAndReturn(run func(context.Context, string) *redis.SliceCmd) *Pipeliner_ConfigGet_Call

type Pipeliner_ConfigResetStat_Call 

type Pipeliner_ConfigResetStat_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ConfigResetStat_Call) Return 

func (_c *Pipeliner_ConfigResetStat_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ConfigResetStat_Call

func (*Pipeliner_ConfigResetStat_Call) Run 

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

func (*Pipeliner_ConfigResetStat_Call) RunAndReturn 

func (_c *Pipeliner_ConfigResetStat_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ConfigResetStat_Call

type Pipeliner_ConfigRewrite_Call 

type Pipeliner_ConfigRewrite_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ConfigRewrite_Call) Return 

func (_c *Pipeliner_ConfigRewrite_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ConfigRewrite_Call

func (*Pipeliner_ConfigRewrite_Call) Run 

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

func (*Pipeliner_ConfigRewrite_Call) RunAndReturn 

func (_c *Pipeliner_ConfigRewrite_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ConfigRewrite_Call

type Pipeliner_ConfigSet_Call 

type Pipeliner_ConfigSet_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ConfigSet_Call) Return 

func (_c *Pipeliner_ConfigSet_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ConfigSet_Call

func (*Pipeliner_ConfigSet_Call) Run 

func (_c *Pipeliner_ConfigSet_Call) Run(run func(ctx context.Context, parameter string, value string)) *Pipeliner_ConfigSet_Call

func (*Pipeliner_ConfigSet_Call) RunAndReturn 

func (_c *Pipeliner_ConfigSet_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *Pipeliner_ConfigSet_Call

type Pipeliner_Copy_Call 

type Pipeliner_Copy_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Copy_Call) Return 

func (_c *Pipeliner_Copy_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Copy_Call

func (*Pipeliner_Copy_Call) Run 

func (_c *Pipeliner_Copy_Call) Run(run func(ctx context.Context, sourceKey string, destKey string, db int, replace bool)) *Pipeliner_Copy_Call

func (*Pipeliner_Copy_Call) RunAndReturn 

func (_c *Pipeliner_Copy_Call) RunAndReturn(run func(context.Context, string, string, int, bool) *redis.IntCmd) *Pipeliner_Copy_Call

type Pipeliner_DBSize_Call 

type Pipeliner_DBSize_Call struct {
	*mock.Call
}

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

func (*Pipeliner_DBSize_Call) Return 

func (_c *Pipeliner_DBSize_Call) Return(_a0 *redis.IntCmd) *Pipeliner_DBSize_Call

func (*Pipeliner_DBSize_Call) Run 

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

func (*Pipeliner_DBSize_Call) RunAndReturn 

func (_c *Pipeliner_DBSize_Call) RunAndReturn(run func(context.Context) *redis.IntCmd) *Pipeliner_DBSize_Call

type Pipeliner_DebugObject_Call 

type Pipeliner_DebugObject_Call struct {
	*mock.Call
}

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

func (*Pipeliner_DebugObject_Call) Return 

func (_c *Pipeliner_DebugObject_Call) Return(_a0 *redis.StringCmd) *Pipeliner_DebugObject_Call

func (*Pipeliner_DebugObject_Call) Run 

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

func (*Pipeliner_DebugObject_Call) RunAndReturn 

func (_c *Pipeliner_DebugObject_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_DebugObject_Call

type Pipeliner_DecrBy_Call 

type Pipeliner_DecrBy_Call struct {
	*mock.Call
}

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

func (*Pipeliner_DecrBy_Call) Return 

func (_c *Pipeliner_DecrBy_Call) Return(_a0 *redis.IntCmd) *Pipeliner_DecrBy_Call

func (*Pipeliner_DecrBy_Call) Run 

func (_c *Pipeliner_DecrBy_Call) Run(run func(ctx context.Context, key string, decrement int64)) *Pipeliner_DecrBy_Call

func (*Pipeliner_DecrBy_Call) RunAndReturn 

func (_c *Pipeliner_DecrBy_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *Pipeliner_DecrBy_Call

type Pipeliner_Decr_Call 

type Pipeliner_Decr_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Decr_Call) Return 

func (_c *Pipeliner_Decr_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Decr_Call

func (*Pipeliner_Decr_Call) Run 

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

func (*Pipeliner_Decr_Call) RunAndReturn 

func (_c *Pipeliner_Decr_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_Decr_Call

type Pipeliner_Del_Call 

type Pipeliner_Del_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Del_Call) Return 

func (_c *Pipeliner_Del_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Del_Call

func (*Pipeliner_Del_Call) Run 

func (_c *Pipeliner_Del_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_Del_Call

func (*Pipeliner_Del_Call) RunAndReturn 

func (_c *Pipeliner_Del_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *Pipeliner_Del_Call

type Pipeliner_Discard_Call 

type Pipeliner_Discard_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Discard_Call) Return 

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

func (*Pipeliner_Discard_Call) Run 

func (_c *Pipeliner_Discard_Call) Run(run func()) *Pipeliner_Discard_Call

func (*Pipeliner_Discard_Call) RunAndReturn 

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

type Pipeliner_Do_Call 

type Pipeliner_Do_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Do_Call) Return 

func (_c *Pipeliner_Do_Call) Return(_a0 *redis.Cmd) *Pipeliner_Do_Call

func (*Pipeliner_Do_Call) Run 

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

func (*Pipeliner_Do_Call) RunAndReturn 

func (_c *Pipeliner_Do_Call) RunAndReturn(run func(context.Context, ...interface{}) *redis.Cmd) *Pipeliner_Do_Call

type Pipeliner_Dump_Call 

type Pipeliner_Dump_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Dump_Call) Return 

func (_c *Pipeliner_Dump_Call) Return(_a0 *redis.StringCmd) *Pipeliner_Dump_Call

func (*Pipeliner_Dump_Call) Run 

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

func (*Pipeliner_Dump_Call) RunAndReturn 

func (_c *Pipeliner_Dump_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_Dump_Call

type Pipeliner_Echo_Call 

type Pipeliner_Echo_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Echo_Call) Return 

func (_c *Pipeliner_Echo_Call) Return(_a0 *redis.StringCmd) *Pipeliner_Echo_Call

func (*Pipeliner_Echo_Call) Run 

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

func (*Pipeliner_Echo_Call) RunAndReturn 

func (_c *Pipeliner_Echo_Call) RunAndReturn(run func(context.Context, interface{}) *redis.StringCmd) *Pipeliner_Echo_Call

type Pipeliner_EvalSha_Call 

type Pipeliner_EvalSha_Call struct {
	*mock.Call
}

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

func (*Pipeliner_EvalSha_Call) Return 

func (_c *Pipeliner_EvalSha_Call) Return(_a0 *redis.Cmd) *Pipeliner_EvalSha_Call

func (*Pipeliner_EvalSha_Call) Run 

func (_c *Pipeliner_EvalSha_Call) Run(run func(ctx context.Context, sha1 string, keys []string, args ...interface{})) *Pipeliner_EvalSha_Call

func (*Pipeliner_EvalSha_Call) RunAndReturn 

func (_c *Pipeliner_EvalSha_Call) RunAndReturn(run func(context.Context, string, []string, ...interface{}) *redis.Cmd) *Pipeliner_EvalSha_Call

type Pipeliner_Eval_Call 

type Pipeliner_Eval_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Eval_Call) Return 

func (_c *Pipeliner_Eval_Call) Return(_a0 *redis.Cmd) *Pipeliner_Eval_Call

func (*Pipeliner_Eval_Call) Run 

func (_c *Pipeliner_Eval_Call) Run(run func(ctx context.Context, script string, keys []string, args ...interface{})) *Pipeliner_Eval_Call

func (*Pipeliner_Eval_Call) RunAndReturn 

func (_c *Pipeliner_Eval_Call) RunAndReturn(run func(context.Context, string, []string, ...interface{}) *redis.Cmd) *Pipeliner_Eval_Call

type Pipeliner_Exec_Call 

type Pipeliner_Exec_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Exec_Call) Return 

func (_c *Pipeliner_Exec_Call) Return(_a0 []redis.Cmder, _a1 error) *Pipeliner_Exec_Call

func (*Pipeliner_Exec_Call) Run 

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

func (*Pipeliner_Exec_Call) RunAndReturn 

func (_c *Pipeliner_Exec_Call) RunAndReturn(run func(context.Context) ([]redis.Cmder, error)) *Pipeliner_Exec_Call

type Pipeliner_Exists_Call 

type Pipeliner_Exists_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Exists_Call) Return 

func (_c *Pipeliner_Exists_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Exists_Call

func (*Pipeliner_Exists_Call) Run 

func (_c *Pipeliner_Exists_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_Exists_Call

func (*Pipeliner_Exists_Call) RunAndReturn 

func (_c *Pipeliner_Exists_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *Pipeliner_Exists_Call

type Pipeliner_Expecter 

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

func (*Pipeliner_Expecter) Append 

func (_e *Pipeliner_Expecter) Append(ctx interface{}, key interface{}, value interface{}) *Pipeliner_Append_Call

Append is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value string

func (*Pipeliner_Expecter) Auth 

func (_e *Pipeliner_Expecter) Auth(ctx interface{}, password interface{}) *Pipeliner_Auth_Call

Auth is a helper method to define mock.On call

  • ctx context.Context
  • password string

func (*Pipeliner_Expecter) AuthACL 

func (_e *Pipeliner_Expecter) AuthACL(ctx interface{}, username interface{}, password interface{}) *Pipeliner_AuthACL_Call

AuthACL is a helper method to define mock.On call

  • ctx context.Context
  • username string
  • password string

func (*Pipeliner_Expecter) BLMove 

func (_e *Pipeliner_Expecter) BLMove(ctx interface{}, source interface{}, destination interface{}, srcpos interface{}, destpos interface{}, timeout interface{}) *Pipeliner_BLMove_Call

BLMove is a helper method to define mock.On call

  • ctx context.Context
  • source string
  • destination string
  • srcpos string
  • destpos string
  • timeout time.Duration

func (*Pipeliner_Expecter) BLPop 

func (_e *Pipeliner_Expecter) BLPop(ctx interface{}, timeout interface{}, keys ...interface{}) *Pipeliner_BLPop_Call

BLPop is a helper method to define mock.On call

  • ctx context.Context
  • timeout time.Duration
  • keys ...string

func (*Pipeliner_Expecter) BRPop 

func (_e *Pipeliner_Expecter) BRPop(ctx interface{}, timeout interface{}, keys ...interface{}) *Pipeliner_BRPop_Call

BRPop is a helper method to define mock.On call

  • ctx context.Context
  • timeout time.Duration
  • keys ...string

func (*Pipeliner_Expecter) BRPopLPush 

func (_e *Pipeliner_Expecter) BRPopLPush(ctx interface{}, source interface{}, destination interface{}, timeout interface{}) *Pipeliner_BRPopLPush_Call

BRPopLPush is a helper method to define mock.On call

  • ctx context.Context
  • source string
  • destination string
  • timeout time.Duration

func (*Pipeliner_Expecter) BZPopMax 

func (_e *Pipeliner_Expecter) BZPopMax(ctx interface{}, timeout interface{}, keys ...interface{}) *Pipeliner_BZPopMax_Call

BZPopMax is a helper method to define mock.On call

  • ctx context.Context
  • timeout time.Duration
  • keys ...string

func (*Pipeliner_Expecter) BZPopMin 

func (_e *Pipeliner_Expecter) BZPopMin(ctx interface{}, timeout interface{}, keys ...interface{}) *Pipeliner_BZPopMin_Call

BZPopMin is a helper method to define mock.On call

  • ctx context.Context
  • timeout time.Duration
  • keys ...string

func (*Pipeliner_Expecter) BgRewriteAOF 

func (_e *Pipeliner_Expecter) BgRewriteAOF(ctx interface{}) *Pipeliner_BgRewriteAOF_Call

BgRewriteAOF is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) BgSave 

func (_e *Pipeliner_Expecter) BgSave(ctx interface{}) *Pipeliner_BgSave_Call

BgSave is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) BitCount 

func (_e *Pipeliner_Expecter) BitCount(ctx interface{}, key interface{}, bitCount interface{}) *Pipeliner_BitCount_Call

BitCount is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • bitCount *redis.BitCount

func (*Pipeliner_Expecter) BitField 

func (_e *Pipeliner_Expecter) BitField(ctx interface{}, key interface{}, args ...interface{}) *Pipeliner_BitField_Call

BitField is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) BitOpAnd 

func (_e *Pipeliner_Expecter) BitOpAnd(ctx interface{}, destKey interface{}, keys ...interface{}) *Pipeliner_BitOpAnd_Call

BitOpAnd is a helper method to define mock.On call

  • ctx context.Context
  • destKey string
  • keys ...string

func (*Pipeliner_Expecter) BitOpNot 

func (_e *Pipeliner_Expecter) BitOpNot(ctx interface{}, destKey interface{}, key interface{}) *Pipeliner_BitOpNot_Call

BitOpNot is a helper method to define mock.On call

  • ctx context.Context
  • destKey string
  • key string

func (*Pipeliner_Expecter) BitOpOr 

func (_e *Pipeliner_Expecter) BitOpOr(ctx interface{}, destKey interface{}, keys ...interface{}) *Pipeliner_BitOpOr_Call

BitOpOr is a helper method to define mock.On call

  • ctx context.Context
  • destKey string
  • keys ...string

func (*Pipeliner_Expecter) BitOpXor 

func (_e *Pipeliner_Expecter) BitOpXor(ctx interface{}, destKey interface{}, keys ...interface{}) *Pipeliner_BitOpXor_Call

BitOpXor is a helper method to define mock.On call

  • ctx context.Context
  • destKey string
  • keys ...string

func (*Pipeliner_Expecter) BitPos 

func (_e *Pipeliner_Expecter) BitPos(ctx interface{}, key interface{}, bit interface{}, pos ...interface{}) *Pipeliner_BitPos_Call

BitPos is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • bit int64
  • pos ...int64

func (*Pipeliner_Expecter) ClientGetName 

func (_e *Pipeliner_Expecter) ClientGetName(ctx interface{}) *Pipeliner_ClientGetName_Call

ClientGetName is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ClientID 

func (_e *Pipeliner_Expecter) ClientID(ctx interface{}) *Pipeliner_ClientID_Call

ClientID is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ClientKill 

func (_e *Pipeliner_Expecter) ClientKill(ctx interface{}, ipPort interface{}) *Pipeliner_ClientKill_Call

ClientKill is a helper method to define mock.On call

  • ctx context.Context
  • ipPort string

func (*Pipeliner_Expecter) ClientKillByFilter 

func (_e *Pipeliner_Expecter) ClientKillByFilter(ctx interface{}, keys ...interface{}) *Pipeliner_ClientKillByFilter_Call

ClientKillByFilter is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Pipeliner_Expecter) ClientList 

func (_e *Pipeliner_Expecter) ClientList(ctx interface{}) *Pipeliner_ClientList_Call

ClientList is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ClientPause 

func (_e *Pipeliner_Expecter) ClientPause(ctx interface{}, dur interface{}) *Pipeliner_ClientPause_Call

ClientPause is a helper method to define mock.On call

  • ctx context.Context
  • dur time.Duration

func (*Pipeliner_Expecter) ClientSetName 

func (_e *Pipeliner_Expecter) ClientSetName(ctx interface{}, name interface{}) *Pipeliner_ClientSetName_Call

ClientSetName is a helper method to define mock.On call

  • ctx context.Context
  • name string

func (*Pipeliner_Expecter) Close 

func (_e *Pipeliner_Expecter) Close() *Pipeliner_Close_Call

Close is a helper method to define mock.On call

func (*Pipeliner_Expecter) ClusterAddSlots 

func (_e *Pipeliner_Expecter) ClusterAddSlots(ctx interface{}, slots ...interface{}) *Pipeliner_ClusterAddSlots_Call

ClusterAddSlots is a helper method to define mock.On call

  • ctx context.Context
  • slots ...int

func (*Pipeliner_Expecter) ClusterAddSlotsRange 

func (_e *Pipeliner_Expecter) ClusterAddSlotsRange(ctx interface{}, min interface{}, max interface{}) *Pipeliner_ClusterAddSlotsRange_Call

ClusterAddSlotsRange is a helper method to define mock.On call

  • ctx context.Context
  • min int
  • max int

func (*Pipeliner_Expecter) ClusterCountFailureReports 

func (_e *Pipeliner_Expecter) ClusterCountFailureReports(ctx interface{}, nodeID interface{}) *Pipeliner_ClusterCountFailureReports_Call

ClusterCountFailureReports is a helper method to define mock.On call

  • ctx context.Context
  • nodeID string

func (*Pipeliner_Expecter) ClusterCountKeysInSlot 

func (_e *Pipeliner_Expecter) ClusterCountKeysInSlot(ctx interface{}, slot interface{}) *Pipeliner_ClusterCountKeysInSlot_Call

ClusterCountKeysInSlot is a helper method to define mock.On call

  • ctx context.Context
  • slot int

func (*Pipeliner_Expecter) ClusterDelSlots 

func (_e *Pipeliner_Expecter) ClusterDelSlots(ctx interface{}, slots ...interface{}) *Pipeliner_ClusterDelSlots_Call

ClusterDelSlots is a helper method to define mock.On call

  • ctx context.Context
  • slots ...int

func (*Pipeliner_Expecter) ClusterDelSlotsRange 

func (_e *Pipeliner_Expecter) ClusterDelSlotsRange(ctx interface{}, min interface{}, max interface{}) *Pipeliner_ClusterDelSlotsRange_Call

ClusterDelSlotsRange is a helper method to define mock.On call

  • ctx context.Context
  • min int
  • max int

func (*Pipeliner_Expecter) ClusterFailover 

func (_e *Pipeliner_Expecter) ClusterFailover(ctx interface{}) *Pipeliner_ClusterFailover_Call

ClusterFailover is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ClusterForget 

func (_e *Pipeliner_Expecter) ClusterForget(ctx interface{}, nodeID interface{}) *Pipeliner_ClusterForget_Call

ClusterForget is a helper method to define mock.On call

  • ctx context.Context
  • nodeID string

func (*Pipeliner_Expecter) ClusterGetKeysInSlot 

func (_e *Pipeliner_Expecter) ClusterGetKeysInSlot(ctx interface{}, slot interface{}, count interface{}) *Pipeliner_ClusterGetKeysInSlot_Call

ClusterGetKeysInSlot is a helper method to define mock.On call

  • ctx context.Context
  • slot int
  • count int

func (*Pipeliner_Expecter) ClusterInfo 

func (_e *Pipeliner_Expecter) ClusterInfo(ctx interface{}) *Pipeliner_ClusterInfo_Call

ClusterInfo is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ClusterKeySlot 

func (_e *Pipeliner_Expecter) ClusterKeySlot(ctx interface{}, key interface{}) *Pipeliner_ClusterKeySlot_Call

ClusterKeySlot is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) ClusterMeet 

func (_e *Pipeliner_Expecter) ClusterMeet(ctx interface{}, host interface{}, port interface{}) *Pipeliner_ClusterMeet_Call

ClusterMeet is a helper method to define mock.On call

  • ctx context.Context
  • host string
  • port string

func (*Pipeliner_Expecter) ClusterNodes 

func (_e *Pipeliner_Expecter) ClusterNodes(ctx interface{}) *Pipeliner_ClusterNodes_Call

ClusterNodes is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ClusterReplicate 

func (_e *Pipeliner_Expecter) ClusterReplicate(ctx interface{}, nodeID interface{}) *Pipeliner_ClusterReplicate_Call

ClusterReplicate is a helper method to define mock.On call

  • ctx context.Context
  • nodeID string

func (*Pipeliner_Expecter) ClusterResetHard 

func (_e *Pipeliner_Expecter) ClusterResetHard(ctx interface{}) *Pipeliner_ClusterResetHard_Call

ClusterResetHard is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ClusterResetSoft 

func (_e *Pipeliner_Expecter) ClusterResetSoft(ctx interface{}) *Pipeliner_ClusterResetSoft_Call

ClusterResetSoft is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ClusterSaveConfig 

func (_e *Pipeliner_Expecter) ClusterSaveConfig(ctx interface{}) *Pipeliner_ClusterSaveConfig_Call

ClusterSaveConfig is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ClusterSlaves 

func (_e *Pipeliner_Expecter) ClusterSlaves(ctx interface{}, nodeID interface{}) *Pipeliner_ClusterSlaves_Call

ClusterSlaves is a helper method to define mock.On call

  • ctx context.Context
  • nodeID string

func (*Pipeliner_Expecter) ClusterSlots 

func (_e *Pipeliner_Expecter) ClusterSlots(ctx interface{}) *Pipeliner_ClusterSlots_Call

ClusterSlots is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) Command 

func (_e *Pipeliner_Expecter) Command(ctx interface{}) *Pipeliner_Command_Call

Command is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ConfigGet 

func (_e *Pipeliner_Expecter) ConfigGet(ctx interface{}, parameter interface{}) *Pipeliner_ConfigGet_Call

ConfigGet is a helper method to define mock.On call

  • ctx context.Context
  • parameter string

func (*Pipeliner_Expecter) ConfigResetStat 

func (_e *Pipeliner_Expecter) ConfigResetStat(ctx interface{}) *Pipeliner_ConfigResetStat_Call

ConfigResetStat is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ConfigRewrite 

func (_e *Pipeliner_Expecter) ConfigRewrite(ctx interface{}) *Pipeliner_ConfigRewrite_Call

ConfigRewrite is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ConfigSet 

func (_e *Pipeliner_Expecter) ConfigSet(ctx interface{}, parameter interface{}, value interface{}) *Pipeliner_ConfigSet_Call

ConfigSet is a helper method to define mock.On call

  • ctx context.Context
  • parameter string
  • value string

func (*Pipeliner_Expecter) Copy 

func (_e *Pipeliner_Expecter) Copy(ctx interface{}, sourceKey interface{}, destKey interface{}, db interface{}, replace interface{}) *Pipeliner_Copy_Call

Copy is a helper method to define mock.On call

  • ctx context.Context
  • sourceKey string
  • destKey string
  • db int
  • replace bool

func (*Pipeliner_Expecter) DBSize 

func (_e *Pipeliner_Expecter) DBSize(ctx interface{}) *Pipeliner_DBSize_Call

DBSize is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) DebugObject 

func (_e *Pipeliner_Expecter) DebugObject(ctx interface{}, key interface{}) *Pipeliner_DebugObject_Call

DebugObject is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) Decr 

func (_e *Pipeliner_Expecter) Decr(ctx interface{}, key interface{}) *Pipeliner_Decr_Call

Decr is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) DecrBy 

func (_e *Pipeliner_Expecter) DecrBy(ctx interface{}, key interface{}, decrement interface{}) *Pipeliner_DecrBy_Call

DecrBy is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • decrement int64

func (*Pipeliner_Expecter) Del 

func (_e *Pipeliner_Expecter) Del(ctx interface{}, keys ...interface{}) *Pipeliner_Del_Call

Del is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Pipeliner_Expecter) Discard 

func (_e *Pipeliner_Expecter) Discard() *Pipeliner_Discard_Call

Discard is a helper method to define mock.On call

func (*Pipeliner_Expecter) Do 

func (_e *Pipeliner_Expecter) Do(ctx interface{}, args ...interface{}) *Pipeliner_Do_Call

Do is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) Dump 

func (_e *Pipeliner_Expecter) Dump(ctx interface{}, key interface{}) *Pipeliner_Dump_Call

Dump is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) Echo 

func (_e *Pipeliner_Expecter) Echo(ctx interface{}, message interface{}) *Pipeliner_Echo_Call

Echo is a helper method to define mock.On call

  • ctx context.Context
  • message interface{}

func (*Pipeliner_Expecter) Eval 

func (_e *Pipeliner_Expecter) Eval(ctx interface{}, script interface{}, keys interface{}, args ...interface{}) *Pipeliner_Eval_Call

Eval is a helper method to define mock.On call

  • ctx context.Context
  • script string
  • keys []string
  • args ...interface{}

func (*Pipeliner_Expecter) EvalSha 

func (_e *Pipeliner_Expecter) EvalSha(ctx interface{}, sha1 interface{}, keys interface{}, args ...interface{}) *Pipeliner_EvalSha_Call

EvalSha is a helper method to define mock.On call

  • ctx context.Context
  • sha1 string
  • keys []string
  • args ...interface{}

func (*Pipeliner_Expecter) Exec 

func (_e *Pipeliner_Expecter) Exec(ctx interface{}) *Pipeliner_Exec_Call

Exec is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) Exists 

func (_e *Pipeliner_Expecter) Exists(ctx interface{}, keys ...interface{}) *Pipeliner_Exists_Call

Exists is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Pipeliner_Expecter) Expire 

func (_e *Pipeliner_Expecter) Expire(ctx interface{}, key interface{}, expiration interface{}) *Pipeliner_Expire_Call

Expire is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) ExpireAt 

func (_e *Pipeliner_Expecter) ExpireAt(ctx interface{}, key interface{}, tm interface{}) *Pipeliner_ExpireAt_Call

ExpireAt is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • tm time.Time

func (*Pipeliner_Expecter) ExpireGT 

func (_e *Pipeliner_Expecter) ExpireGT(ctx interface{}, key interface{}, expiration interface{}) *Pipeliner_ExpireGT_Call

ExpireGT is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) ExpireLT 

func (_e *Pipeliner_Expecter) ExpireLT(ctx interface{}, key interface{}, expiration interface{}) *Pipeliner_ExpireLT_Call

ExpireLT is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) ExpireNX 

func (_e *Pipeliner_Expecter) ExpireNX(ctx interface{}, key interface{}, expiration interface{}) *Pipeliner_ExpireNX_Call

ExpireNX is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) ExpireXX 

func (_e *Pipeliner_Expecter) ExpireXX(ctx interface{}, key interface{}, expiration interface{}) *Pipeliner_ExpireXX_Call

ExpireXX is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) FlushAll 

func (_e *Pipeliner_Expecter) FlushAll(ctx interface{}) *Pipeliner_FlushAll_Call

FlushAll is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) FlushAllAsync 

func (_e *Pipeliner_Expecter) FlushAllAsync(ctx interface{}) *Pipeliner_FlushAllAsync_Call

FlushAllAsync is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) FlushDB 

func (_e *Pipeliner_Expecter) FlushDB(ctx interface{}) *Pipeliner_FlushDB_Call

FlushDB is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) FlushDBAsync 

func (_e *Pipeliner_Expecter) FlushDBAsync(ctx interface{}) *Pipeliner_FlushDBAsync_Call

FlushDBAsync is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) GeoAdd 

func (_e *Pipeliner_Expecter) GeoAdd(ctx interface{}, key interface{}, geoLocation ...interface{}) *Pipeliner_GeoAdd_Call

GeoAdd is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • geoLocation ...*redis.GeoLocation

func (*Pipeliner_Expecter) GeoDist 

func (_e *Pipeliner_Expecter) GeoDist(ctx interface{}, key interface{}, member1 interface{}, member2 interface{}, unit interface{}) *Pipeliner_GeoDist_Call

GeoDist is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • member1 string
  • member2 string
  • unit string

func (*Pipeliner_Expecter) GeoHash 

func (_e *Pipeliner_Expecter) GeoHash(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_GeoHash_Call

GeoHash is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • members ...string

func (*Pipeliner_Expecter) GeoPos 

func (_e *Pipeliner_Expecter) GeoPos(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_GeoPos_Call

GeoPos is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • members ...string

func (*Pipeliner_Expecter) GeoRadius 

func (_e *Pipeliner_Expecter) GeoRadius(ctx interface{}, key interface{}, longitude interface{}, latitude interface{}, query interface{}) *Pipeliner_GeoRadius_Call

GeoRadius is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • longitude float64
  • latitude float64
  • query *redis.GeoRadiusQuery

func (*Pipeliner_Expecter) GeoRadiusByMember 

func (_e *Pipeliner_Expecter) GeoRadiusByMember(ctx interface{}, key interface{}, member interface{}, query interface{}) *Pipeliner_GeoRadiusByMember_Call

GeoRadiusByMember is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • member string
  • query *redis.GeoRadiusQuery

func (*Pipeliner_Expecter) GeoRadiusByMemberStore 

func (_e *Pipeliner_Expecter) GeoRadiusByMemberStore(ctx interface{}, key interface{}, member interface{}, query interface{}) *Pipeliner_GeoRadiusByMemberStore_Call

GeoRadiusByMemberStore is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • member string
  • query *redis.GeoRadiusQuery

func (*Pipeliner_Expecter) GeoRadiusStore 

func (_e *Pipeliner_Expecter) GeoRadiusStore(ctx interface{}, key interface{}, longitude interface{}, latitude interface{}, query interface{}) *Pipeliner_GeoRadiusStore_Call

GeoRadiusStore is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • longitude float64
  • latitude float64
  • query *redis.GeoRadiusQuery

func (*Pipeliner_Expecter) GeoSearch 

func (_e *Pipeliner_Expecter) GeoSearch(ctx interface{}, key interface{}, q interface{}) *Pipeliner_GeoSearch_Call

GeoSearch is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • q *redis.GeoSearchQuery

func (*Pipeliner_Expecter) GeoSearchLocation 

func (_e *Pipeliner_Expecter) GeoSearchLocation(ctx interface{}, key interface{}, q interface{}) *Pipeliner_GeoSearchLocation_Call

GeoSearchLocation is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • q *redis.GeoSearchLocationQuery

func (*Pipeliner_Expecter) GeoSearchStore 

func (_e *Pipeliner_Expecter) GeoSearchStore(ctx interface{}, key interface{}, store interface{}, q interface{}) *Pipeliner_GeoSearchStore_Call

GeoSearchStore is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • store string
  • q *redis.GeoSearchStoreQuery

func (*Pipeliner_Expecter) Get 

func (_e *Pipeliner_Expecter) Get(ctx interface{}, key interface{}) *Pipeliner_Get_Call

Get is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) GetBit 

func (_e *Pipeliner_Expecter) GetBit(ctx interface{}, key interface{}, offset interface{}) *Pipeliner_GetBit_Call

GetBit is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • offset int64

func (*Pipeliner_Expecter) GetDel 

func (_e *Pipeliner_Expecter) GetDel(ctx interface{}, key interface{}) *Pipeliner_GetDel_Call

GetDel is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) GetEx 

func (_e *Pipeliner_Expecter) GetEx(ctx interface{}, key interface{}, expiration interface{}) *Pipeliner_GetEx_Call

GetEx is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) GetRange 

func (_e *Pipeliner_Expecter) GetRange(ctx interface{}, key interface{}, start interface{}, end interface{}) *Pipeliner_GetRange_Call

GetRange is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • start int64
  • end int64

func (*Pipeliner_Expecter) GetSet 

func (_e *Pipeliner_Expecter) GetSet(ctx interface{}, key interface{}, value interface{}) *Pipeliner_GetSet_Call

GetSet is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) HDel 

func (_e *Pipeliner_Expecter) HDel(ctx interface{}, key interface{}, fields ...interface{}) *Pipeliner_HDel_Call

HDel is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • fields ...string

func (*Pipeliner_Expecter) HExists 

func (_e *Pipeliner_Expecter) HExists(ctx interface{}, key interface{}, field interface{}) *Pipeliner_HExists_Call

HExists is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • field string

func (*Pipeliner_Expecter) HGet 

func (_e *Pipeliner_Expecter) HGet(ctx interface{}, key interface{}, field interface{}) *Pipeliner_HGet_Call

HGet is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • field string

func (*Pipeliner_Expecter) HGetAll 

func (_e *Pipeliner_Expecter) HGetAll(ctx interface{}, key interface{}) *Pipeliner_HGetAll_Call

HGetAll is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) HIncrBy 

func (_e *Pipeliner_Expecter) HIncrBy(ctx interface{}, key interface{}, field interface{}, incr interface{}) *Pipeliner_HIncrBy_Call

HIncrBy is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • field string
  • incr int64

func (*Pipeliner_Expecter) HIncrByFloat 

func (_e *Pipeliner_Expecter) HIncrByFloat(ctx interface{}, key interface{}, field interface{}, incr interface{}) *Pipeliner_HIncrByFloat_Call

HIncrByFloat is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • field string
  • incr float64

func (*Pipeliner_Expecter) HKeys 

func (_e *Pipeliner_Expecter) HKeys(ctx interface{}, key interface{}) *Pipeliner_HKeys_Call

HKeys is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) HLen 

func (_e *Pipeliner_Expecter) HLen(ctx interface{}, key interface{}) *Pipeliner_HLen_Call

HLen is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) HMGet 

func (_e *Pipeliner_Expecter) HMGet(ctx interface{}, key interface{}, fields ...interface{}) *Pipeliner_HMGet_Call

HMGet is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • fields ...string

func (*Pipeliner_Expecter) HMSet 

func (_e *Pipeliner_Expecter) HMSet(ctx interface{}, key interface{}, values ...interface{}) *Pipeliner_HMSet_Call

HMSet is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) HRandField 

func (_e *Pipeliner_Expecter) HRandField(ctx interface{}, key interface{}, count interface{}, withValues interface{}) *Pipeliner_HRandField_Call

HRandField is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • count int
  • withValues bool

func (*Pipeliner_Expecter) HScan 

func (_e *Pipeliner_Expecter) HScan(ctx interface{}, key interface{}, cursor interface{}, match interface{}, count interface{}) *Pipeliner_HScan_Call

HScan is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • cursor uint64
  • match string
  • count int64

func (*Pipeliner_Expecter) HSet 

func (_e *Pipeliner_Expecter) HSet(ctx interface{}, key interface{}, values ...interface{}) *Pipeliner_HSet_Call

HSet is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) HSetNX 

func (_e *Pipeliner_Expecter) HSetNX(ctx interface{}, key interface{}, field interface{}, value interface{}) *Pipeliner_HSetNX_Call

HSetNX is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) HVals 

func (_e *Pipeliner_Expecter) HVals(ctx interface{}, key interface{}) *Pipeliner_HVals_Call

HVals is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) Incr 

func (_e *Pipeliner_Expecter) Incr(ctx interface{}, key interface{}) *Pipeliner_Incr_Call

Incr is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) IncrBy 

func (_e *Pipeliner_Expecter) IncrBy(ctx interface{}, key interface{}, value interface{}) *Pipeliner_IncrBy_Call

IncrBy is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value int64

func (*Pipeliner_Expecter) IncrByFloat 

func (_e *Pipeliner_Expecter) IncrByFloat(ctx interface{}, key interface{}, value interface{}) *Pipeliner_IncrByFloat_Call

IncrByFloat is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value float64

func (*Pipeliner_Expecter) Info 

func (_e *Pipeliner_Expecter) Info(ctx interface{}, section ...interface{}) *Pipeliner_Info_Call

Info is a helper method to define mock.On call

  • ctx context.Context
  • section ...string

func (*Pipeliner_Expecter) Keys 

func (_e *Pipeliner_Expecter) Keys(ctx interface{}, pattern interface{}) *Pipeliner_Keys_Call

Keys is a helper method to define mock.On call

  • ctx context.Context
  • pattern string

func (*Pipeliner_Expecter) LIndex 

func (_e *Pipeliner_Expecter) LIndex(ctx interface{}, key interface{}, index interface{}) *Pipeliner_LIndex_Call

LIndex is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • index int64

func (*Pipeliner_Expecter) LInsert 

func (_e *Pipeliner_Expecter) LInsert(ctx interface{}, key interface{}, op interface{}, pivot interface{}, value interface{}) *Pipeliner_LInsert_Call

LInsert is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) LInsertAfter 

func (_e *Pipeliner_Expecter) LInsertAfter(ctx interface{}, key interface{}, pivot interface{}, value interface{}) *Pipeliner_LInsertAfter_Call

LInsertAfter is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) LInsertBefore 

func (_e *Pipeliner_Expecter) LInsertBefore(ctx interface{}, key interface{}, pivot interface{}, value interface{}) *Pipeliner_LInsertBefore_Call

LInsertBefore is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) LLen 

func (_e *Pipeliner_Expecter) LLen(ctx interface{}, key interface{}) *Pipeliner_LLen_Call

LLen is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) LMove 

func (_e *Pipeliner_Expecter) LMove(ctx interface{}, source interface{}, destination interface{}, srcpos interface{}, destpos interface{}) *Pipeliner_LMove_Call

LMove is a helper method to define mock.On call

  • ctx context.Context
  • source string
  • destination string
  • srcpos string
  • destpos string

func (*Pipeliner_Expecter) LPop 

func (_e *Pipeliner_Expecter) LPop(ctx interface{}, key interface{}) *Pipeliner_LPop_Call

LPop is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) LPopCount 

func (_e *Pipeliner_Expecter) LPopCount(ctx interface{}, key interface{}, count interface{}) *Pipeliner_LPopCount_Call

LPopCount is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • count int

func (*Pipeliner_Expecter) LPos 

func (_e *Pipeliner_Expecter) LPos(ctx interface{}, key interface{}, value interface{}, args interface{}) *Pipeliner_LPos_Call

LPos is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value string
  • args redis.LPosArgs

func (*Pipeliner_Expecter) LPosCount 

func (_e *Pipeliner_Expecter) LPosCount(ctx interface{}, key interface{}, value interface{}, count interface{}, args interface{}) *Pipeliner_LPosCount_Call

LPosCount is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value string
  • count int64
  • args redis.LPosArgs

func (*Pipeliner_Expecter) LPush 

func (_e *Pipeliner_Expecter) LPush(ctx interface{}, key interface{}, values ...interface{}) *Pipeliner_LPush_Call

LPush is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) LPushX 

func (_e *Pipeliner_Expecter) LPushX(ctx interface{}, key interface{}, values ...interface{}) *Pipeliner_LPushX_Call

LPushX is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) LRange 

func (_e *Pipeliner_Expecter) LRange(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Pipeliner_LRange_Call

LRange is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • start int64
  • stop int64

func (*Pipeliner_Expecter) LRem 

func (_e *Pipeliner_Expecter) LRem(ctx interface{}, key interface{}, count interface{}, value interface{}) *Pipeliner_LRem_Call

LRem is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) LSet 

func (_e *Pipeliner_Expecter) LSet(ctx interface{}, key interface{}, index interface{}, value interface{}) *Pipeliner_LSet_Call

LSet is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) LTrim 

func (_e *Pipeliner_Expecter) LTrim(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Pipeliner_LTrim_Call

LTrim is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • start int64
  • stop int64

func (*Pipeliner_Expecter) LastSave 

func (_e *Pipeliner_Expecter) LastSave(ctx interface{}) *Pipeliner_LastSave_Call

LastSave is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) Len 

func (_e *Pipeliner_Expecter) Len() *Pipeliner_Len_Call

Len is a helper method to define mock.On call

func (*Pipeliner_Expecter) MGet 

func (_e *Pipeliner_Expecter) MGet(ctx interface{}, keys ...interface{}) *Pipeliner_MGet_Call

MGet is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Pipeliner_Expecter) MSet 

func (_e *Pipeliner_Expecter) MSet(ctx interface{}, values ...interface{}) *Pipeliner_MSet_Call

MSet is a helper method to define mock.On call

  • ctx context.Context
  • values ...interface{}

func (*Pipeliner_Expecter) MSetNX 

func (_e *Pipeliner_Expecter) MSetNX(ctx interface{}, values ...interface{}) *Pipeliner_MSetNX_Call

MSetNX is a helper method to define mock.On call

  • ctx context.Context
  • values ...interface{}

func (*Pipeliner_Expecter) MemoryUsage 

func (_e *Pipeliner_Expecter) MemoryUsage(ctx interface{}, key interface{}, samples ...interface{}) *Pipeliner_MemoryUsage_Call

MemoryUsage is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • samples ...int

func (*Pipeliner_Expecter) Migrate 

func (_e *Pipeliner_Expecter) Migrate(ctx interface{}, host interface{}, port interface{}, key interface{}, db interface{}, timeout interface{}) *Pipeliner_Migrate_Call

Migrate is a helper method to define mock.On call

  • ctx context.Context
  • host string
  • port string
  • key string
  • db int
  • timeout time.Duration

func (*Pipeliner_Expecter) Move 

func (_e *Pipeliner_Expecter) Move(ctx interface{}, key interface{}, db interface{}) *Pipeliner_Move_Call

Move is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • db int

func (*Pipeliner_Expecter) ObjectEncoding 

func (_e *Pipeliner_Expecter) ObjectEncoding(ctx interface{}, key interface{}) *Pipeliner_ObjectEncoding_Call

ObjectEncoding is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) ObjectIdleTime 

func (_e *Pipeliner_Expecter) ObjectIdleTime(ctx interface{}, key interface{}) *Pipeliner_ObjectIdleTime_Call

ObjectIdleTime is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) ObjectRefCount 

func (_e *Pipeliner_Expecter) ObjectRefCount(ctx interface{}, key interface{}) *Pipeliner_ObjectRefCount_Call

ObjectRefCount is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) PExpire 

func (_e *Pipeliner_Expecter) PExpire(ctx interface{}, key interface{}, expiration interface{}) *Pipeliner_PExpire_Call

PExpire is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) PExpireAt 

func (_e *Pipeliner_Expecter) PExpireAt(ctx interface{}, key interface{}, tm interface{}) *Pipeliner_PExpireAt_Call

PExpireAt is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • tm time.Time

func (*Pipeliner_Expecter) PFAdd 

func (_e *Pipeliner_Expecter) PFAdd(ctx interface{}, key interface{}, els ...interface{}) *Pipeliner_PFAdd_Call

PFAdd is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) PFCount 

func (_e *Pipeliner_Expecter) PFCount(ctx interface{}, keys ...interface{}) *Pipeliner_PFCount_Call

PFCount is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Pipeliner_Expecter) PFMerge 

func (_e *Pipeliner_Expecter) PFMerge(ctx interface{}, dest interface{}, keys ...interface{}) *Pipeliner_PFMerge_Call

PFMerge is a helper method to define mock.On call

  • ctx context.Context
  • dest string
  • keys ...string

func (*Pipeliner_Expecter) PTTL 

func (_e *Pipeliner_Expecter) PTTL(ctx interface{}, key interface{}) *Pipeliner_PTTL_Call

PTTL is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) Persist 

func (_e *Pipeliner_Expecter) Persist(ctx interface{}, key interface{}) *Pipeliner_Persist_Call

Persist is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) Ping 

func (_e *Pipeliner_Expecter) Ping(ctx interface{}) *Pipeliner_Ping_Call

Ping is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) Pipeline 

func (_e *Pipeliner_Expecter) Pipeline() *Pipeliner_Pipeline_Call

Pipeline is a helper method to define mock.On call

func (*Pipeliner_Expecter) Pipelined 

func (_e *Pipeliner_Expecter) Pipelined(ctx interface{}, fn interface{}) *Pipeliner_Pipelined_Call

Pipelined is a helper method to define mock.On call

  • ctx context.Context
  • fn func(redis.Pipeliner) error

func (*Pipeliner_Expecter) Process 

func (_e *Pipeliner_Expecter) Process(ctx interface{}, cmd interface{}) *Pipeliner_Process_Call

Process is a helper method to define mock.On call

  • ctx context.Context
  • cmd redis.Cmder

func (*Pipeliner_Expecter) PubSubChannels 

func (_e *Pipeliner_Expecter) PubSubChannels(ctx interface{}, pattern interface{}) *Pipeliner_PubSubChannels_Call

PubSubChannels is a helper method to define mock.On call

  • ctx context.Context
  • pattern string

func (*Pipeliner_Expecter) PubSubNumPat 

func (_e *Pipeliner_Expecter) PubSubNumPat(ctx interface{}) *Pipeliner_PubSubNumPat_Call

PubSubNumPat is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) PubSubNumSub 

func (_e *Pipeliner_Expecter) PubSubNumSub(ctx interface{}, channels ...interface{}) *Pipeliner_PubSubNumSub_Call

PubSubNumSub is a helper method to define mock.On call

  • ctx context.Context
  • channels ...string

func (*Pipeliner_Expecter) Publish 

func (_e *Pipeliner_Expecter) Publish(ctx interface{}, channel interface{}, message interface{}) *Pipeliner_Publish_Call

Publish is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) Quit 

func (_e *Pipeliner_Expecter) Quit(ctx interface{}) *Pipeliner_Quit_Call

Quit is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) RPop 

func (_e *Pipeliner_Expecter) RPop(ctx interface{}, key interface{}) *Pipeliner_RPop_Call

RPop is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) RPopCount 

func (_e *Pipeliner_Expecter) RPopCount(ctx interface{}, key interface{}, count interface{}) *Pipeliner_RPopCount_Call

RPopCount is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • count int

func (*Pipeliner_Expecter) RPopLPush 

func (_e *Pipeliner_Expecter) RPopLPush(ctx interface{}, source interface{}, destination interface{}) *Pipeliner_RPopLPush_Call

RPopLPush is a helper method to define mock.On call

  • ctx context.Context
  • source string
  • destination string

func (*Pipeliner_Expecter) RPush 

func (_e *Pipeliner_Expecter) RPush(ctx interface{}, key interface{}, values ...interface{}) *Pipeliner_RPush_Call

RPush is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) RPushX 

func (_e *Pipeliner_Expecter) RPushX(ctx interface{}, key interface{}, values ...interface{}) *Pipeliner_RPushX_Call

RPushX is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) RandomKey 

func (_e *Pipeliner_Expecter) RandomKey(ctx interface{}) *Pipeliner_RandomKey_Call

RandomKey is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ReadOnly 

func (_e *Pipeliner_Expecter) ReadOnly(ctx interface{}) *Pipeliner_ReadOnly_Call

ReadOnly is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ReadWrite 

func (_e *Pipeliner_Expecter) ReadWrite(ctx interface{}) *Pipeliner_ReadWrite_Call

ReadWrite is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) Rename 

func (_e *Pipeliner_Expecter) Rename(ctx interface{}, key interface{}, newkey interface{}) *Pipeliner_Rename_Call

Rename is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • newkey string

func (*Pipeliner_Expecter) RenameNX 

func (_e *Pipeliner_Expecter) RenameNX(ctx interface{}, key interface{}, newkey interface{}) *Pipeliner_RenameNX_Call

RenameNX is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • newkey string

func (*Pipeliner_Expecter) Restore 

func (_e *Pipeliner_Expecter) Restore(ctx interface{}, key interface{}, ttl interface{}, value interface{}) *Pipeliner_Restore_Call

Restore is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) RestoreReplace 

func (_e *Pipeliner_Expecter) RestoreReplace(ctx interface{}, key interface{}, ttl interface{}, value interface{}) *Pipeliner_RestoreReplace_Call

RestoreReplace is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) SAdd 

func (_e *Pipeliner_Expecter) SAdd(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_SAdd_Call

SAdd is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) SCard 

func (_e *Pipeliner_Expecter) SCard(ctx interface{}, key interface{}) *Pipeliner_SCard_Call

SCard is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) SDiff 

func (_e *Pipeliner_Expecter) SDiff(ctx interface{}, keys ...interface{}) *Pipeliner_SDiff_Call

SDiff is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Pipeliner_Expecter) SDiffStore 

func (_e *Pipeliner_Expecter) SDiffStore(ctx interface{}, destination interface{}, keys ...interface{}) *Pipeliner_SDiffStore_Call

SDiffStore is a helper method to define mock.On call

  • ctx context.Context
  • destination string
  • keys ...string

func (*Pipeliner_Expecter) SInter 

func (_e *Pipeliner_Expecter) SInter(ctx interface{}, keys ...interface{}) *Pipeliner_SInter_Call

SInter is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Pipeliner_Expecter) SInterStore 

func (_e *Pipeliner_Expecter) SInterStore(ctx interface{}, destination interface{}, keys ...interface{}) *Pipeliner_SInterStore_Call

SInterStore is a helper method to define mock.On call

  • ctx context.Context
  • destination string
  • keys ...string

func (*Pipeliner_Expecter) SIsMember 

func (_e *Pipeliner_Expecter) SIsMember(ctx interface{}, key interface{}, member interface{}) *Pipeliner_SIsMember_Call

SIsMember is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) SMIsMember 

func (_e *Pipeliner_Expecter) SMIsMember(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_SMIsMember_Call

SMIsMember is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) SMembers 

func (_e *Pipeliner_Expecter) SMembers(ctx interface{}, key interface{}) *Pipeliner_SMembers_Call

SMembers is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) SMembersMap 

func (_e *Pipeliner_Expecter) SMembersMap(ctx interface{}, key interface{}) *Pipeliner_SMembersMap_Call

SMembersMap is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) SMove 

func (_e *Pipeliner_Expecter) SMove(ctx interface{}, source interface{}, destination interface{}, member interface{}) *Pipeliner_SMove_Call

SMove is a helper method to define mock.On call

  • ctx context.Context
  • source string
  • destination string
  • member interface{}

func (*Pipeliner_Expecter) SPop 

func (_e *Pipeliner_Expecter) SPop(ctx interface{}, key interface{}) *Pipeliner_SPop_Call

SPop is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) SPopN 

func (_e *Pipeliner_Expecter) SPopN(ctx interface{}, key interface{}, count interface{}) *Pipeliner_SPopN_Call

SPopN is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • count int64

func (*Pipeliner_Expecter) SRandMember 

func (_e *Pipeliner_Expecter) SRandMember(ctx interface{}, key interface{}) *Pipeliner_SRandMember_Call

SRandMember is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) SRandMemberN 

func (_e *Pipeliner_Expecter) SRandMemberN(ctx interface{}, key interface{}, count interface{}) *Pipeliner_SRandMemberN_Call

SRandMemberN is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • count int64

func (*Pipeliner_Expecter) SRem 

func (_e *Pipeliner_Expecter) SRem(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_SRem_Call

SRem is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) SScan 

func (_e *Pipeliner_Expecter) SScan(ctx interface{}, key interface{}, cursor interface{}, match interface{}, count interface{}) *Pipeliner_SScan_Call

SScan is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • cursor uint64
  • match string
  • count int64

func (*Pipeliner_Expecter) SUnion 

func (_e *Pipeliner_Expecter) SUnion(ctx interface{}, keys ...interface{}) *Pipeliner_SUnion_Call

SUnion is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Pipeliner_Expecter) SUnionStore 

func (_e *Pipeliner_Expecter) SUnionStore(ctx interface{}, destination interface{}, keys ...interface{}) *Pipeliner_SUnionStore_Call

SUnionStore is a helper method to define mock.On call

  • ctx context.Context
  • destination string
  • keys ...string

func (*Pipeliner_Expecter) Save 

func (_e *Pipeliner_Expecter) Save(ctx interface{}) *Pipeliner_Save_Call

Save is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) Scan 

func (_e *Pipeliner_Expecter) Scan(ctx interface{}, cursor interface{}, match interface{}, count interface{}) *Pipeliner_Scan_Call

Scan is a helper method to define mock.On call

  • ctx context.Context
  • cursor uint64
  • match string
  • count int64

func (*Pipeliner_Expecter) ScanType 

func (_e *Pipeliner_Expecter) ScanType(ctx interface{}, cursor interface{}, match interface{}, count interface{}, keyType interface{}) *Pipeliner_ScanType_Call

ScanType is a helper method to define mock.On call

  • ctx context.Context
  • cursor uint64
  • match string
  • count int64
  • keyType string

func (*Pipeliner_Expecter) ScriptExists 

func (_e *Pipeliner_Expecter) ScriptExists(ctx interface{}, hashes ...interface{}) *Pipeliner_ScriptExists_Call

ScriptExists is a helper method to define mock.On call

  • ctx context.Context
  • hashes ...string

func (*Pipeliner_Expecter) ScriptFlush 

func (_e *Pipeliner_Expecter) ScriptFlush(ctx interface{}) *Pipeliner_ScriptFlush_Call

ScriptFlush is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ScriptKill 

func (_e *Pipeliner_Expecter) ScriptKill(ctx interface{}) *Pipeliner_ScriptKill_Call

ScriptKill is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ScriptLoad 

func (_e *Pipeliner_Expecter) ScriptLoad(ctx interface{}, script interface{}) *Pipeliner_ScriptLoad_Call

ScriptLoad is a helper method to define mock.On call

  • ctx context.Context
  • script string

func (*Pipeliner_Expecter) Select 

func (_e *Pipeliner_Expecter) Select(ctx interface{}, index interface{}) *Pipeliner_Select_Call

Select is a helper method to define mock.On call

  • ctx context.Context
  • index int

func (*Pipeliner_Expecter) Set 

func (_e *Pipeliner_Expecter) Set(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *Pipeliner_Set_Call

Set is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value interface{}
  • expiration time.Duration

func (*Pipeliner_Expecter) SetArgs 

func (_e *Pipeliner_Expecter) SetArgs(ctx interface{}, key interface{}, value interface{}, a interface{}) *Pipeliner_SetArgs_Call

SetArgs is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value interface{}
  • a redis.SetArgs

func (*Pipeliner_Expecter) SetBit 

func (_e *Pipeliner_Expecter) SetBit(ctx interface{}, key interface{}, offset interface{}, value interface{}) *Pipeliner_SetBit_Call

SetBit is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • offset int64
  • value int

func (*Pipeliner_Expecter) SetEX 

func (_e *Pipeliner_Expecter) SetEX(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *Pipeliner_SetEX_Call

SetEX is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value interface{}
  • expiration time.Duration

func (*Pipeliner_Expecter) SetNX 

func (_e *Pipeliner_Expecter) SetNX(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *Pipeliner_SetNX_Call

SetNX is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value interface{}
  • expiration time.Duration

func (*Pipeliner_Expecter) SetRange 

func (_e *Pipeliner_Expecter) SetRange(ctx interface{}, key interface{}, offset interface{}, value interface{}) *Pipeliner_SetRange_Call

SetRange is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • offset int64
  • value string

func (*Pipeliner_Expecter) SetXX 

func (_e *Pipeliner_Expecter) SetXX(ctx interface{}, key interface{}, value interface{}, expiration interface{}) *Pipeliner_SetXX_Call

SetXX is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • value interface{}
  • expiration time.Duration

func (*Pipeliner_Expecter) Shutdown 

func (_e *Pipeliner_Expecter) Shutdown(ctx interface{}) *Pipeliner_Shutdown_Call

Shutdown is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ShutdownNoSave 

func (_e *Pipeliner_Expecter) ShutdownNoSave(ctx interface{}) *Pipeliner_ShutdownNoSave_Call

ShutdownNoSave is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) ShutdownSave 

func (_e *Pipeliner_Expecter) ShutdownSave(ctx interface{}) *Pipeliner_ShutdownSave_Call

ShutdownSave is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) SlaveOf 

func (_e *Pipeliner_Expecter) SlaveOf(ctx interface{}, host interface{}, port interface{}) *Pipeliner_SlaveOf_Call

SlaveOf is a helper method to define mock.On call

  • ctx context.Context
  • host string
  • port string

func (*Pipeliner_Expecter) Sort 

func (_e *Pipeliner_Expecter) Sort(ctx interface{}, key interface{}, sort interface{}) *Pipeliner_Sort_Call

Sort is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • sort *redis.Sort

func (*Pipeliner_Expecter) SortInterfaces 

func (_e *Pipeliner_Expecter) SortInterfaces(ctx interface{}, key interface{}, sort interface{}) *Pipeliner_SortInterfaces_Call

SortInterfaces is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • sort *redis.Sort

func (*Pipeliner_Expecter) SortStore 

func (_e *Pipeliner_Expecter) SortStore(ctx interface{}, key interface{}, store interface{}, sort interface{}) *Pipeliner_SortStore_Call

SortStore is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • store string
  • sort *redis.Sort

func (*Pipeliner_Expecter) StrLen 

func (_e *Pipeliner_Expecter) StrLen(ctx interface{}, key interface{}) *Pipeliner_StrLen_Call

StrLen is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) SwapDB 

func (_e *Pipeliner_Expecter) SwapDB(ctx interface{}, index1 interface{}, index2 interface{}) *Pipeliner_SwapDB_Call

SwapDB is a helper method to define mock.On call

  • ctx context.Context
  • index1 int
  • index2 int

func (*Pipeliner_Expecter) TTL 

func (_e *Pipeliner_Expecter) TTL(ctx interface{}, key interface{}) *Pipeliner_TTL_Call

TTL is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) Time 

func (_e *Pipeliner_Expecter) Time(ctx interface{}) *Pipeliner_Time_Call

Time is a helper method to define mock.On call

  • ctx context.Context

func (*Pipeliner_Expecter) Touch 

func (_e *Pipeliner_Expecter) Touch(ctx interface{}, keys ...interface{}) *Pipeliner_Touch_Call

Touch is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Pipeliner_Expecter) TxPipeline 

func (_e *Pipeliner_Expecter) TxPipeline() *Pipeliner_TxPipeline_Call

TxPipeline is a helper method to define mock.On call

func (*Pipeliner_Expecter) TxPipelined 

func (_e *Pipeliner_Expecter) TxPipelined(ctx interface{}, fn interface{}) *Pipeliner_TxPipelined_Call

TxPipelined is a helper method to define mock.On call

  • ctx context.Context
  • fn func(redis.Pipeliner) error

func (*Pipeliner_Expecter) Type 

func (_e *Pipeliner_Expecter) Type(ctx interface{}, key interface{}) *Pipeliner_Type_Call

Type is a helper method to define mock.On call

  • ctx context.Context
  • key string
func (_e *Pipeliner_Expecter) Unlink(ctx interface{}, keys ...interface{}) *Pipeliner_Unlink_Call

Unlink is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Pipeliner_Expecter) XAck 

func (_e *Pipeliner_Expecter) XAck(ctx interface{}, stream interface{}, group interface{}, ids ...interface{}) *Pipeliner_XAck_Call

XAck is a helper method to define mock.On call

  • ctx context.Context
  • stream string
  • group string
  • ids ...string

func (*Pipeliner_Expecter) XAdd 

func (_e *Pipeliner_Expecter) XAdd(ctx interface{}, a interface{}) *Pipeliner_XAdd_Call

XAdd is a helper method to define mock.On call

  • ctx context.Context
  • a *redis.XAddArgs

func (*Pipeliner_Expecter) XAutoClaim 

func (_e *Pipeliner_Expecter) XAutoClaim(ctx interface{}, a interface{}) *Pipeliner_XAutoClaim_Call

XAutoClaim is a helper method to define mock.On call

  • ctx context.Context
  • a *redis.XAutoClaimArgs

func (*Pipeliner_Expecter) XAutoClaimJustID 

func (_e *Pipeliner_Expecter) XAutoClaimJustID(ctx interface{}, a interface{}) *Pipeliner_XAutoClaimJustID_Call

XAutoClaimJustID is a helper method to define mock.On call

  • ctx context.Context
  • a *redis.XAutoClaimArgs

func (*Pipeliner_Expecter) XClaim 

func (_e *Pipeliner_Expecter) XClaim(ctx interface{}, a interface{}) *Pipeliner_XClaim_Call

XClaim is a helper method to define mock.On call

  • ctx context.Context
  • a *redis.XClaimArgs

func (*Pipeliner_Expecter) XClaimJustID 

func (_e *Pipeliner_Expecter) XClaimJustID(ctx interface{}, a interface{}) *Pipeliner_XClaimJustID_Call

XClaimJustID is a helper method to define mock.On call

  • ctx context.Context
  • a *redis.XClaimArgs

func (*Pipeliner_Expecter) XDel 

func (_e *Pipeliner_Expecter) XDel(ctx interface{}, stream interface{}, ids ...interface{}) *Pipeliner_XDel_Call

XDel is a helper method to define mock.On call

  • ctx context.Context
  • stream string
  • ids ...string

func (*Pipeliner_Expecter) XGroupCreate 

func (_e *Pipeliner_Expecter) XGroupCreate(ctx interface{}, stream interface{}, group interface{}, start interface{}) *Pipeliner_XGroupCreate_Call

XGroupCreate is a helper method to define mock.On call

  • ctx context.Context
  • stream string
  • group string
  • start string

func (*Pipeliner_Expecter) XGroupCreateConsumer 

func (_e *Pipeliner_Expecter) XGroupCreateConsumer(ctx interface{}, stream interface{}, group interface{}, consumer interface{}) *Pipeliner_XGroupCreateConsumer_Call

XGroupCreateConsumer is a helper method to define mock.On call

  • ctx context.Context
  • stream string
  • group string
  • consumer string

func (*Pipeliner_Expecter) XGroupCreateMkStream 

func (_e *Pipeliner_Expecter) XGroupCreateMkStream(ctx interface{}, stream interface{}, group interface{}, start interface{}) *Pipeliner_XGroupCreateMkStream_Call

XGroupCreateMkStream is a helper method to define mock.On call

  • ctx context.Context
  • stream string
  • group string
  • start string

func (*Pipeliner_Expecter) XGroupDelConsumer 

func (_e *Pipeliner_Expecter) XGroupDelConsumer(ctx interface{}, stream interface{}, group interface{}, consumer interface{}) *Pipeliner_XGroupDelConsumer_Call

XGroupDelConsumer is a helper method to define mock.On call

  • ctx context.Context
  • stream string
  • group string
  • consumer string

func (*Pipeliner_Expecter) XGroupDestroy 

func (_e *Pipeliner_Expecter) XGroupDestroy(ctx interface{}, stream interface{}, group interface{}) *Pipeliner_XGroupDestroy_Call

XGroupDestroy is a helper method to define mock.On call

  • ctx context.Context
  • stream string
  • group string

func (*Pipeliner_Expecter) XGroupSetID 

func (_e *Pipeliner_Expecter) XGroupSetID(ctx interface{}, stream interface{}, group interface{}, start interface{}) *Pipeliner_XGroupSetID_Call

XGroupSetID is a helper method to define mock.On call

  • ctx context.Context
  • stream string
  • group string
  • start string

func (*Pipeliner_Expecter) XInfoConsumers 

func (_e *Pipeliner_Expecter) XInfoConsumers(ctx interface{}, key interface{}, group interface{}) *Pipeliner_XInfoConsumers_Call

XInfoConsumers is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • group string

func (*Pipeliner_Expecter) XInfoGroups 

func (_e *Pipeliner_Expecter) XInfoGroups(ctx interface{}, key interface{}) *Pipeliner_XInfoGroups_Call

XInfoGroups is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) XInfoStream 

func (_e *Pipeliner_Expecter) XInfoStream(ctx interface{}, key interface{}) *Pipeliner_XInfoStream_Call

XInfoStream is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) XInfoStreamFull 

func (_e *Pipeliner_Expecter) XInfoStreamFull(ctx interface{}, key interface{}, count interface{}) *Pipeliner_XInfoStreamFull_Call

XInfoStreamFull is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • count int

func (*Pipeliner_Expecter) XLen 

func (_e *Pipeliner_Expecter) XLen(ctx interface{}, stream interface{}) *Pipeliner_XLen_Call

XLen is a helper method to define mock.On call

  • ctx context.Context
  • stream string

func (*Pipeliner_Expecter) XPending 

func (_e *Pipeliner_Expecter) XPending(ctx interface{}, stream interface{}, group interface{}) *Pipeliner_XPending_Call

XPending is a helper method to define mock.On call

  • ctx context.Context
  • stream string
  • group string

func (*Pipeliner_Expecter) XPendingExt 

func (_e *Pipeliner_Expecter) XPendingExt(ctx interface{}, a interface{}) *Pipeliner_XPendingExt_Call

XPendingExt is a helper method to define mock.On call

  • ctx context.Context
  • a *redis.XPendingExtArgs

func (*Pipeliner_Expecter) XRange 

func (_e *Pipeliner_Expecter) XRange(ctx interface{}, stream interface{}, start interface{}, stop interface{}) *Pipeliner_XRange_Call

XRange is a helper method to define mock.On call

  • ctx context.Context
  • stream string
  • start string
  • stop string

func (*Pipeliner_Expecter) XRangeN 

func (_e *Pipeliner_Expecter) XRangeN(ctx interface{}, stream interface{}, start interface{}, stop interface{}, count interface{}) *Pipeliner_XRangeN_Call

XRangeN is a helper method to define mock.On call

  • ctx context.Context
  • stream string
  • start string
  • stop string
  • count int64

func (*Pipeliner_Expecter) XRead 

func (_e *Pipeliner_Expecter) XRead(ctx interface{}, a interface{}) *Pipeliner_XRead_Call

XRead is a helper method to define mock.On call

  • ctx context.Context
  • a *redis.XReadArgs

func (*Pipeliner_Expecter) XReadGroup 

func (_e *Pipeliner_Expecter) XReadGroup(ctx interface{}, a interface{}) *Pipeliner_XReadGroup_Call

XReadGroup is a helper method to define mock.On call

  • ctx context.Context
  • a *redis.XReadGroupArgs

func (*Pipeliner_Expecter) XReadStreams 

func (_e *Pipeliner_Expecter) XReadStreams(ctx interface{}, streams ...interface{}) *Pipeliner_XReadStreams_Call

XReadStreams is a helper method to define mock.On call

  • ctx context.Context
  • streams ...string

func (*Pipeliner_Expecter) XRevRange 

func (_e *Pipeliner_Expecter) XRevRange(ctx interface{}, stream interface{}, start interface{}, stop interface{}) *Pipeliner_XRevRange_Call

XRevRange is a helper method to define mock.On call

  • ctx context.Context
  • stream string
  • start string
  • stop string

func (*Pipeliner_Expecter) XRevRangeN 

func (_e *Pipeliner_Expecter) XRevRangeN(ctx interface{}, stream interface{}, start interface{}, stop interface{}, count interface{}) *Pipeliner_XRevRangeN_Call

XRevRangeN is a helper method to define mock.On call

  • ctx context.Context
  • stream string
  • start string
  • stop string
  • count int64

func (*Pipeliner_Expecter) XTrim 

func (_e *Pipeliner_Expecter) XTrim(ctx interface{}, key interface{}, maxLen interface{}) *Pipeliner_XTrim_Call

XTrim is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • maxLen int64

func (*Pipeliner_Expecter) XTrimApprox 

func (_e *Pipeliner_Expecter) XTrimApprox(ctx interface{}, key interface{}, maxLen interface{}) *Pipeliner_XTrimApprox_Call

XTrimApprox is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • maxLen int64

func (*Pipeliner_Expecter) XTrimMaxLen 

func (_e *Pipeliner_Expecter) XTrimMaxLen(ctx interface{}, key interface{}, maxLen interface{}) *Pipeliner_XTrimMaxLen_Call

XTrimMaxLen is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • maxLen int64

func (*Pipeliner_Expecter) XTrimMaxLenApprox 

func (_e *Pipeliner_Expecter) XTrimMaxLenApprox(ctx interface{}, key interface{}, maxLen interface{}, limit interface{}) *Pipeliner_XTrimMaxLenApprox_Call

XTrimMaxLenApprox is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • maxLen int64
  • limit int64

func (*Pipeliner_Expecter) XTrimMinID 

func (_e *Pipeliner_Expecter) XTrimMinID(ctx interface{}, key interface{}, minID interface{}) *Pipeliner_XTrimMinID_Call

XTrimMinID is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • minID string

func (*Pipeliner_Expecter) XTrimMinIDApprox 

func (_e *Pipeliner_Expecter) XTrimMinIDApprox(ctx interface{}, key interface{}, minID interface{}, limit interface{}) *Pipeliner_XTrimMinIDApprox_Call

XTrimMinIDApprox is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • minID string
  • limit int64

func (*Pipeliner_Expecter) ZAdd 

func (_e *Pipeliner_Expecter) ZAdd(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZAdd_Call

ZAdd is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • members ...*redis.Z

func (*Pipeliner_Expecter) ZAddArgs 

func (_e *Pipeliner_Expecter) ZAddArgs(ctx interface{}, key interface{}, args interface{}) *Pipeliner_ZAddArgs_Call

ZAddArgs is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • args redis.ZAddArgs

func (*Pipeliner_Expecter) ZAddArgsIncr 

func (_e *Pipeliner_Expecter) ZAddArgsIncr(ctx interface{}, key interface{}, args interface{}) *Pipeliner_ZAddArgsIncr_Call

ZAddArgsIncr is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • args redis.ZAddArgs

func (*Pipeliner_Expecter) ZAddCh 

func (_e *Pipeliner_Expecter) ZAddCh(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZAddCh_Call

ZAddCh is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • members ...*redis.Z

func (*Pipeliner_Expecter) ZAddNX 

func (_e *Pipeliner_Expecter) ZAddNX(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZAddNX_Call

ZAddNX is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • members ...*redis.Z

func (*Pipeliner_Expecter) ZAddNXCh 

func (_e *Pipeliner_Expecter) ZAddNXCh(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZAddNXCh_Call

ZAddNXCh is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • members ...*redis.Z

func (*Pipeliner_Expecter) ZAddXX 

func (_e *Pipeliner_Expecter) ZAddXX(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZAddXX_Call

ZAddXX is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • members ...*redis.Z

func (*Pipeliner_Expecter) ZAddXXCh 

func (_e *Pipeliner_Expecter) ZAddXXCh(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZAddXXCh_Call

ZAddXXCh is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • members ...*redis.Z

func (*Pipeliner_Expecter) ZCard 

func (_e *Pipeliner_Expecter) ZCard(ctx interface{}, key interface{}) *Pipeliner_ZCard_Call

ZCard is a helper method to define mock.On call

  • ctx context.Context
  • key string

func (*Pipeliner_Expecter) ZCount 

func (_e *Pipeliner_Expecter) ZCount(ctx interface{}, key interface{}, min interface{}, max interface{}) *Pipeliner_ZCount_Call

ZCount is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • min string
  • max string

func (*Pipeliner_Expecter) ZDiff 

func (_e *Pipeliner_Expecter) ZDiff(ctx interface{}, keys ...interface{}) *Pipeliner_ZDiff_Call

ZDiff is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Pipeliner_Expecter) ZDiffStore 

func (_e *Pipeliner_Expecter) ZDiffStore(ctx interface{}, destination interface{}, keys ...interface{}) *Pipeliner_ZDiffStore_Call

ZDiffStore is a helper method to define mock.On call

  • ctx context.Context
  • destination string
  • keys ...string

func (*Pipeliner_Expecter) ZDiffWithScores 

func (_e *Pipeliner_Expecter) ZDiffWithScores(ctx interface{}, keys ...interface{}) *Pipeliner_ZDiffWithScores_Call

ZDiffWithScores is a helper method to define mock.On call

  • ctx context.Context
  • keys ...string

func (*Pipeliner_Expecter) ZIncr 

func (_e *Pipeliner_Expecter) ZIncr(ctx interface{}, key interface{}, member interface{}) *Pipeliner_ZIncr_Call

ZIncr is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • member *redis.Z

func (*Pipeliner_Expecter) ZIncrBy 

func (_e *Pipeliner_Expecter) ZIncrBy(ctx interface{}, key interface{}, increment interface{}, member interface{}) *Pipeliner_ZIncrBy_Call

ZIncrBy is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • increment float64
  • member string

func (*Pipeliner_Expecter) ZIncrNX 

func (_e *Pipeliner_Expecter) ZIncrNX(ctx interface{}, key interface{}, member interface{}) *Pipeliner_ZIncrNX_Call

ZIncrNX is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • member *redis.Z

func (*Pipeliner_Expecter) ZIncrXX 

func (_e *Pipeliner_Expecter) ZIncrXX(ctx interface{}, key interface{}, member interface{}) *Pipeliner_ZIncrXX_Call

ZIncrXX is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • member *redis.Z

func (*Pipeliner_Expecter) ZInter 

func (_e *Pipeliner_Expecter) ZInter(ctx interface{}, store interface{}) *Pipeliner_ZInter_Call

ZInter is a helper method to define mock.On call

  • ctx context.Context
  • store *redis.ZStore

func (*Pipeliner_Expecter) ZInterStore 

func (_e *Pipeliner_Expecter) ZInterStore(ctx interface{}, destination interface{}, store interface{}) *Pipeliner_ZInterStore_Call

ZInterStore is a helper method to define mock.On call

  • ctx context.Context
  • destination string
  • store *redis.ZStore

func (*Pipeliner_Expecter) ZInterWithScores 

func (_e *Pipeliner_Expecter) ZInterWithScores(ctx interface{}, store interface{}) *Pipeliner_ZInterWithScores_Call

ZInterWithScores is a helper method to define mock.On call

  • ctx context.Context
  • store *redis.ZStore

func (*Pipeliner_Expecter) ZLexCount 

func (_e *Pipeliner_Expecter) ZLexCount(ctx interface{}, key interface{}, min interface{}, max interface{}) *Pipeliner_ZLexCount_Call

ZLexCount is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • min string
  • max string

func (*Pipeliner_Expecter) ZMScore 

func (_e *Pipeliner_Expecter) ZMScore(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZMScore_Call

ZMScore is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • members ...string

func (*Pipeliner_Expecter) ZPopMax 

func (_e *Pipeliner_Expecter) ZPopMax(ctx interface{}, key interface{}, count ...interface{}) *Pipeliner_ZPopMax_Call

ZPopMax is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • count ...int64

func (*Pipeliner_Expecter) ZPopMin 

func (_e *Pipeliner_Expecter) ZPopMin(ctx interface{}, key interface{}, count ...interface{}) *Pipeliner_ZPopMin_Call

ZPopMin is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • count ...int64

func (*Pipeliner_Expecter) ZRandMember 

func (_e *Pipeliner_Expecter) ZRandMember(ctx interface{}, key interface{}, count interface{}, withScores interface{}) *Pipeliner_ZRandMember_Call

ZRandMember is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • count int
  • withScores bool

func (*Pipeliner_Expecter) ZRange 

func (_e *Pipeliner_Expecter) ZRange(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Pipeliner_ZRange_Call

ZRange is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • start int64
  • stop int64

func (*Pipeliner_Expecter) ZRangeArgs 

func (_e *Pipeliner_Expecter) ZRangeArgs(ctx interface{}, z interface{}) *Pipeliner_ZRangeArgs_Call

ZRangeArgs is a helper method to define mock.On call

  • ctx context.Context
  • z redis.ZRangeArgs

func (*Pipeliner_Expecter) ZRangeArgsWithScores 

func (_e *Pipeliner_Expecter) ZRangeArgsWithScores(ctx interface{}, z interface{}) *Pipeliner_ZRangeArgsWithScores_Call

ZRangeArgsWithScores is a helper method to define mock.On call

  • ctx context.Context
  • z redis.ZRangeArgs

func (*Pipeliner_Expecter) ZRangeByLex 

func (_e *Pipeliner_Expecter) ZRangeByLex(ctx interface{}, key interface{}, opt interface{}) *Pipeliner_ZRangeByLex_Call

ZRangeByLex is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • opt *redis.ZRangeBy

func (*Pipeliner_Expecter) ZRangeByScore 

func (_e *Pipeliner_Expecter) ZRangeByScore(ctx interface{}, key interface{}, opt interface{}) *Pipeliner_ZRangeByScore_Call

ZRangeByScore is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • opt *redis.ZRangeBy

func (*Pipeliner_Expecter) ZRangeByScoreWithScores 

func (_e *Pipeliner_Expecter) ZRangeByScoreWithScores(ctx interface{}, key interface{}, opt interface{}) *Pipeliner_ZRangeByScoreWithScores_Call

ZRangeByScoreWithScores is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • opt *redis.ZRangeBy

func (*Pipeliner_Expecter) ZRangeStore 

func (_e *Pipeliner_Expecter) ZRangeStore(ctx interface{}, dst interface{}, z interface{}) *Pipeliner_ZRangeStore_Call

ZRangeStore is a helper method to define mock.On call

  • ctx context.Context
  • dst string
  • z redis.ZRangeArgs

func (*Pipeliner_Expecter) ZRangeWithScores 

func (_e *Pipeliner_Expecter) ZRangeWithScores(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Pipeliner_ZRangeWithScores_Call

ZRangeWithScores is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • start int64
  • stop int64

func (*Pipeliner_Expecter) ZRank 

func (_e *Pipeliner_Expecter) ZRank(ctx interface{}, key interface{}, member interface{}) *Pipeliner_ZRank_Call

ZRank is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • member string

func (*Pipeliner_Expecter) ZRem 

func (_e *Pipeliner_Expecter) ZRem(ctx interface{}, key interface{}, members ...interface{}) *Pipeliner_ZRem_Call

ZRem is a helper method to define mock.On call

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

func (*Pipeliner_Expecter) ZRemRangeByLex 

func (_e *Pipeliner_Expecter) ZRemRangeByLex(ctx interface{}, key interface{}, min interface{}, max interface{}) *Pipeliner_ZRemRangeByLex_Call

ZRemRangeByLex is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • min string
  • max string

func (*Pipeliner_Expecter) ZRemRangeByRank 

func (_e *Pipeliner_Expecter) ZRemRangeByRank(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Pipeliner_ZRemRangeByRank_Call

ZRemRangeByRank is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • start int64
  • stop int64

func (*Pipeliner_Expecter) ZRemRangeByScore 

func (_e *Pipeliner_Expecter) ZRemRangeByScore(ctx interface{}, key interface{}, min interface{}, max interface{}) *Pipeliner_ZRemRangeByScore_Call

ZRemRangeByScore is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • min string
  • max string

func (*Pipeliner_Expecter) ZRevRange 

func (_e *Pipeliner_Expecter) ZRevRange(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Pipeliner_ZRevRange_Call

ZRevRange is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • start int64
  • stop int64

func (*Pipeliner_Expecter) ZRevRangeByLex 

func (_e *Pipeliner_Expecter) ZRevRangeByLex(ctx interface{}, key interface{}, opt interface{}) *Pipeliner_ZRevRangeByLex_Call

ZRevRangeByLex is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • opt *redis.ZRangeBy

func (*Pipeliner_Expecter) ZRevRangeByScore 

func (_e *Pipeliner_Expecter) ZRevRangeByScore(ctx interface{}, key interface{}, opt interface{}) *Pipeliner_ZRevRangeByScore_Call

ZRevRangeByScore is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • opt *redis.ZRangeBy

func (*Pipeliner_Expecter) ZRevRangeByScoreWithScores 

func (_e *Pipeliner_Expecter) ZRevRangeByScoreWithScores(ctx interface{}, key interface{}, opt interface{}) *Pipeliner_ZRevRangeByScoreWithScores_Call

ZRevRangeByScoreWithScores is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • opt *redis.ZRangeBy

func (*Pipeliner_Expecter) ZRevRangeWithScores 

func (_e *Pipeliner_Expecter) ZRevRangeWithScores(ctx interface{}, key interface{}, start interface{}, stop interface{}) *Pipeliner_ZRevRangeWithScores_Call

ZRevRangeWithScores is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • start int64
  • stop int64

func (*Pipeliner_Expecter) ZRevRank 

func (_e *Pipeliner_Expecter) ZRevRank(ctx interface{}, key interface{}, member interface{}) *Pipeliner_ZRevRank_Call

ZRevRank is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • member string

func (*Pipeliner_Expecter) ZScan 

func (_e *Pipeliner_Expecter) ZScan(ctx interface{}, key interface{}, cursor interface{}, match interface{}, count interface{}) *Pipeliner_ZScan_Call

ZScan is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • cursor uint64
  • match string
  • count int64

func (*Pipeliner_Expecter) ZScore 

func (_e *Pipeliner_Expecter) ZScore(ctx interface{}, key interface{}, member interface{}) *Pipeliner_ZScore_Call

ZScore is a helper method to define mock.On call

  • ctx context.Context
  • key string
  • member string

func (*Pipeliner_Expecter) ZUnion 

func (_e *Pipeliner_Expecter) ZUnion(ctx interface{}, store interface{}) *Pipeliner_ZUnion_Call

ZUnion is a helper method to define mock.On call

  • ctx context.Context
  • store redis.ZStore

func (*Pipeliner_Expecter) ZUnionStore 

func (_e *Pipeliner_Expecter) ZUnionStore(ctx interface{}, dest interface{}, store interface{}) *Pipeliner_ZUnionStore_Call

ZUnionStore is a helper method to define mock.On call

  • ctx context.Context
  • dest string
  • store *redis.ZStore

func (*Pipeliner_Expecter) ZUnionWithScores 

func (_e *Pipeliner_Expecter) ZUnionWithScores(ctx interface{}, store interface{}) *Pipeliner_ZUnionWithScores_Call

ZUnionWithScores is a helper method to define mock.On call

  • ctx context.Context
  • store redis.ZStore

type Pipeliner_ExpireAt_Call 

type Pipeliner_ExpireAt_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ExpireAt_Call) Return 

func (_c *Pipeliner_ExpireAt_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_ExpireAt_Call

func (*Pipeliner_ExpireAt_Call) Run 

func (_c *Pipeliner_ExpireAt_Call) Run(run func(ctx context.Context, key string, tm time.Time)) *Pipeliner_ExpireAt_Call

func (*Pipeliner_ExpireAt_Call) RunAndReturn 

func (_c *Pipeliner_ExpireAt_Call) RunAndReturn(run func(context.Context, string, time.Time) *redis.BoolCmd) *Pipeliner_ExpireAt_Call

type Pipeliner_ExpireGT_Call 

type Pipeliner_ExpireGT_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ExpireGT_Call) Return 

func (_c *Pipeliner_ExpireGT_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_ExpireGT_Call

func (*Pipeliner_ExpireGT_Call) Run 

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

func (*Pipeliner_ExpireGT_Call) RunAndReturn 

func (_c *Pipeliner_ExpireGT_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *Pipeliner_ExpireGT_Call

type Pipeliner_ExpireLT_Call 

type Pipeliner_ExpireLT_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ExpireLT_Call) Return 

func (_c *Pipeliner_ExpireLT_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_ExpireLT_Call

func (*Pipeliner_ExpireLT_Call) Run 

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

func (*Pipeliner_ExpireLT_Call) RunAndReturn 

func (_c *Pipeliner_ExpireLT_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *Pipeliner_ExpireLT_Call

type Pipeliner_ExpireNX_Call 

type Pipeliner_ExpireNX_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ExpireNX_Call) Return 

func (_c *Pipeliner_ExpireNX_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_ExpireNX_Call

func (*Pipeliner_ExpireNX_Call) Run 

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

func (*Pipeliner_ExpireNX_Call) RunAndReturn 

func (_c *Pipeliner_ExpireNX_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *Pipeliner_ExpireNX_Call

type Pipeliner_ExpireXX_Call 

type Pipeliner_ExpireXX_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ExpireXX_Call) Return 

func (_c *Pipeliner_ExpireXX_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_ExpireXX_Call

func (*Pipeliner_ExpireXX_Call) Run 

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

func (*Pipeliner_ExpireXX_Call) RunAndReturn 

func (_c *Pipeliner_ExpireXX_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *Pipeliner_ExpireXX_Call

type Pipeliner_Expire_Call 

type Pipeliner_Expire_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Expire_Call) Return 

func (_c *Pipeliner_Expire_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_Expire_Call

func (*Pipeliner_Expire_Call) Run 

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

func (*Pipeliner_Expire_Call) RunAndReturn 

func (_c *Pipeliner_Expire_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *Pipeliner_Expire_Call

type Pipeliner_FlushAllAsync_Call 

type Pipeliner_FlushAllAsync_Call struct {
	*mock.Call
}

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

func (*Pipeliner_FlushAllAsync_Call) Return 

func (_c *Pipeliner_FlushAllAsync_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_FlushAllAsync_Call

func (*Pipeliner_FlushAllAsync_Call) Run 

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

func (*Pipeliner_FlushAllAsync_Call) RunAndReturn 

func (_c *Pipeliner_FlushAllAsync_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_FlushAllAsync_Call

type Pipeliner_FlushAll_Call 

type Pipeliner_FlushAll_Call struct {
	*mock.Call
}

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

func (*Pipeliner_FlushAll_Call) Return 

func (_c *Pipeliner_FlushAll_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_FlushAll_Call

func (*Pipeliner_FlushAll_Call) Run 

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

func (*Pipeliner_FlushAll_Call) RunAndReturn 

func (_c *Pipeliner_FlushAll_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_FlushAll_Call

type Pipeliner_FlushDBAsync_Call 

type Pipeliner_FlushDBAsync_Call struct {
	*mock.Call
}

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

func (*Pipeliner_FlushDBAsync_Call) Return 

func (_c *Pipeliner_FlushDBAsync_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_FlushDBAsync_Call

func (*Pipeliner_FlushDBAsync_Call) Run 

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

func (*Pipeliner_FlushDBAsync_Call) RunAndReturn 

func (_c *Pipeliner_FlushDBAsync_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_FlushDBAsync_Call

type Pipeliner_FlushDB_Call 

type Pipeliner_FlushDB_Call struct {
	*mock.Call
}

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

func (*Pipeliner_FlushDB_Call) Return 

func (_c *Pipeliner_FlushDB_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_FlushDB_Call

func (*Pipeliner_FlushDB_Call) Run 

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

func (*Pipeliner_FlushDB_Call) RunAndReturn 

func (_c *Pipeliner_FlushDB_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_FlushDB_Call

type Pipeliner_GeoAdd_Call 

type Pipeliner_GeoAdd_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GeoAdd_Call) Return 

func (_c *Pipeliner_GeoAdd_Call) Return(_a0 *redis.IntCmd) *Pipeliner_GeoAdd_Call

func (*Pipeliner_GeoAdd_Call) Run 

func (_c *Pipeliner_GeoAdd_Call) Run(run func(ctx context.Context, key string, geoLocation ...*redis.GeoLocation)) *Pipeliner_GeoAdd_Call

func (*Pipeliner_GeoAdd_Call) RunAndReturn 

func (_c *Pipeliner_GeoAdd_Call) RunAndReturn(run func(context.Context, string, ...*redis.GeoLocation) *redis.IntCmd) *Pipeliner_GeoAdd_Call

type Pipeliner_GeoDist_Call 

type Pipeliner_GeoDist_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GeoDist_Call) Return 

func (_c *Pipeliner_GeoDist_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_GeoDist_Call

func (*Pipeliner_GeoDist_Call) Run 

func (_c *Pipeliner_GeoDist_Call) Run(run func(ctx context.Context, key string, member1 string, member2 string, unit string)) *Pipeliner_GeoDist_Call

func (*Pipeliner_GeoDist_Call) RunAndReturn 

func (_c *Pipeliner_GeoDist_Call) RunAndReturn(run func(context.Context, string, string, string, string) *redis.FloatCmd) *Pipeliner_GeoDist_Call

type Pipeliner_GeoHash_Call 

type Pipeliner_GeoHash_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GeoHash_Call) Return 

func (_c *Pipeliner_GeoHash_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_GeoHash_Call

func (*Pipeliner_GeoHash_Call) Run 

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

func (*Pipeliner_GeoHash_Call) RunAndReturn 

func (_c *Pipeliner_GeoHash_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.StringSliceCmd) *Pipeliner_GeoHash_Call

type Pipeliner_GeoPos_Call 

type Pipeliner_GeoPos_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GeoPos_Call) Return 

func (_c *Pipeliner_GeoPos_Call) Return(_a0 *redis.GeoPosCmd) *Pipeliner_GeoPos_Call

func (*Pipeliner_GeoPos_Call) Run 

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

func (*Pipeliner_GeoPos_Call) RunAndReturn 

func (_c *Pipeliner_GeoPos_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.GeoPosCmd) *Pipeliner_GeoPos_Call

type Pipeliner_GeoRadiusByMemberStore_Call 

type Pipeliner_GeoRadiusByMemberStore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GeoRadiusByMemberStore_Call) Return 

func (_c *Pipeliner_GeoRadiusByMemberStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_GeoRadiusByMemberStore_Call

func (*Pipeliner_GeoRadiusByMemberStore_Call) Run 

func (_c *Pipeliner_GeoRadiusByMemberStore_Call) Run(run func(ctx context.Context, key string, member string, query *redis.GeoRadiusQuery)) *Pipeliner_GeoRadiusByMemberStore_Call

func (*Pipeliner_GeoRadiusByMemberStore_Call) RunAndReturn 

func (_c *Pipeliner_GeoRadiusByMemberStore_Call) RunAndReturn(run func(context.Context, string, string, *redis.GeoRadiusQuery) *redis.IntCmd) *Pipeliner_GeoRadiusByMemberStore_Call

type Pipeliner_GeoRadiusByMember_Call 

type Pipeliner_GeoRadiusByMember_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GeoRadiusByMember_Call) Return 

func (_c *Pipeliner_GeoRadiusByMember_Call) Return(_a0 *redis.GeoLocationCmd) *Pipeliner_GeoRadiusByMember_Call

func (*Pipeliner_GeoRadiusByMember_Call) Run 

func (_c *Pipeliner_GeoRadiusByMember_Call) Run(run func(ctx context.Context, key string, member string, query *redis.GeoRadiusQuery)) *Pipeliner_GeoRadiusByMember_Call

func (*Pipeliner_GeoRadiusByMember_Call) RunAndReturn 

func (_c *Pipeliner_GeoRadiusByMember_Call) RunAndReturn(run func(context.Context, string, string, *redis.GeoRadiusQuery) *redis.GeoLocationCmd) *Pipeliner_GeoRadiusByMember_Call

type Pipeliner_GeoRadiusStore_Call 

type Pipeliner_GeoRadiusStore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GeoRadiusStore_Call) Return 

func (_c *Pipeliner_GeoRadiusStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_GeoRadiusStore_Call

func (*Pipeliner_GeoRadiusStore_Call) Run 

func (_c *Pipeliner_GeoRadiusStore_Call) Run(run func(ctx context.Context, key string, longitude float64, latitude float64, query *redis.GeoRadiusQuery)) *Pipeliner_GeoRadiusStore_Call

func (*Pipeliner_GeoRadiusStore_Call) RunAndReturn 

func (_c *Pipeliner_GeoRadiusStore_Call) RunAndReturn(run func(context.Context, string, float64, float64, *redis.GeoRadiusQuery) *redis.IntCmd) *Pipeliner_GeoRadiusStore_Call

type Pipeliner_GeoRadius_Call 

type Pipeliner_GeoRadius_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GeoRadius_Call) Return 

func (_c *Pipeliner_GeoRadius_Call) Return(_a0 *redis.GeoLocationCmd) *Pipeliner_GeoRadius_Call

func (*Pipeliner_GeoRadius_Call) Run 

func (_c *Pipeliner_GeoRadius_Call) Run(run func(ctx context.Context, key string, longitude float64, latitude float64, query *redis.GeoRadiusQuery)) *Pipeliner_GeoRadius_Call

func (*Pipeliner_GeoRadius_Call) RunAndReturn 

func (_c *Pipeliner_GeoRadius_Call) RunAndReturn(run func(context.Context, string, float64, float64, *redis.GeoRadiusQuery) *redis.GeoLocationCmd) *Pipeliner_GeoRadius_Call

type Pipeliner_GeoSearchLocation_Call 

type Pipeliner_GeoSearchLocation_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GeoSearchLocation_Call) Return 

func (_c *Pipeliner_GeoSearchLocation_Call) Return(_a0 *redis.GeoSearchLocationCmd) *Pipeliner_GeoSearchLocation_Call

func (*Pipeliner_GeoSearchLocation_Call) Run 

func (_c *Pipeliner_GeoSearchLocation_Call) Run(run func(ctx context.Context, key string, q *redis.GeoSearchLocationQuery)) *Pipeliner_GeoSearchLocation_Call

func (*Pipeliner_GeoSearchLocation_Call) RunAndReturn 

func (_c *Pipeliner_GeoSearchLocation_Call) RunAndReturn(run func(context.Context, string, *redis.GeoSearchLocationQuery) *redis.GeoSearchLocationCmd) *Pipeliner_GeoSearchLocation_Call

type Pipeliner_GeoSearchStore_Call 

type Pipeliner_GeoSearchStore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GeoSearchStore_Call) Return 

func (_c *Pipeliner_GeoSearchStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_GeoSearchStore_Call

func (*Pipeliner_GeoSearchStore_Call) Run 

func (_c *Pipeliner_GeoSearchStore_Call) Run(run func(ctx context.Context, key string, store string, q *redis.GeoSearchStoreQuery)) *Pipeliner_GeoSearchStore_Call

func (*Pipeliner_GeoSearchStore_Call) RunAndReturn 

func (_c *Pipeliner_GeoSearchStore_Call) RunAndReturn(run func(context.Context, string, string, *redis.GeoSearchStoreQuery) *redis.IntCmd) *Pipeliner_GeoSearchStore_Call

type Pipeliner_GeoSearch_Call 

type Pipeliner_GeoSearch_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GeoSearch_Call) Return 

func (_c *Pipeliner_GeoSearch_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_GeoSearch_Call

func (*Pipeliner_GeoSearch_Call) Run 

func (_c *Pipeliner_GeoSearch_Call) Run(run func(ctx context.Context, key string, q *redis.GeoSearchQuery)) *Pipeliner_GeoSearch_Call

func (*Pipeliner_GeoSearch_Call) RunAndReturn 

func (_c *Pipeliner_GeoSearch_Call) RunAndReturn(run func(context.Context, string, *redis.GeoSearchQuery) *redis.StringSliceCmd) *Pipeliner_GeoSearch_Call

type Pipeliner_GetBit_Call 

type Pipeliner_GetBit_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GetBit_Call) Return 

func (_c *Pipeliner_GetBit_Call) Return(_a0 *redis.IntCmd) *Pipeliner_GetBit_Call

func (*Pipeliner_GetBit_Call) Run 

func (_c *Pipeliner_GetBit_Call) Run(run func(ctx context.Context, key string, offset int64)) *Pipeliner_GetBit_Call

func (*Pipeliner_GetBit_Call) RunAndReturn 

func (_c *Pipeliner_GetBit_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *Pipeliner_GetBit_Call

type Pipeliner_GetDel_Call 

type Pipeliner_GetDel_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GetDel_Call) Return 

func (_c *Pipeliner_GetDel_Call) Return(_a0 *redis.StringCmd) *Pipeliner_GetDel_Call

func (*Pipeliner_GetDel_Call) Run 

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

func (*Pipeliner_GetDel_Call) RunAndReturn 

func (_c *Pipeliner_GetDel_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_GetDel_Call

type Pipeliner_GetEx_Call 

type Pipeliner_GetEx_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GetEx_Call) Return 

func (_c *Pipeliner_GetEx_Call) Return(_a0 *redis.StringCmd) *Pipeliner_GetEx_Call

func (*Pipeliner_GetEx_Call) Run 

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

func (*Pipeliner_GetEx_Call) RunAndReturn 

func (_c *Pipeliner_GetEx_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.StringCmd) *Pipeliner_GetEx_Call

type Pipeliner_GetRange_Call 

type Pipeliner_GetRange_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GetRange_Call) Return 

func (_c *Pipeliner_GetRange_Call) Return(_a0 *redis.StringCmd) *Pipeliner_GetRange_Call

func (*Pipeliner_GetRange_Call) Run 

func (_c *Pipeliner_GetRange_Call) Run(run func(ctx context.Context, key string, start int64, end int64)) *Pipeliner_GetRange_Call

func (*Pipeliner_GetRange_Call) RunAndReturn 

func (_c *Pipeliner_GetRange_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StringCmd) *Pipeliner_GetRange_Call

type Pipeliner_GetSet_Call 

type Pipeliner_GetSet_Call struct {
	*mock.Call
}

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

func (*Pipeliner_GetSet_Call) Return 

func (_c *Pipeliner_GetSet_Call) Return(_a0 *redis.StringCmd) *Pipeliner_GetSet_Call

func (*Pipeliner_GetSet_Call) Run 

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

func (*Pipeliner_GetSet_Call) RunAndReturn 

func (_c *Pipeliner_GetSet_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.StringCmd) *Pipeliner_GetSet_Call

type Pipeliner_Get_Call 

type Pipeliner_Get_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Get_Call) Return 

func (_c *Pipeliner_Get_Call) Return(_a0 *redis.StringCmd) *Pipeliner_Get_Call

func (*Pipeliner_Get_Call) Run 

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

func (*Pipeliner_Get_Call) RunAndReturn 

func (_c *Pipeliner_Get_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_Get_Call

type Pipeliner_HDel_Call 

type Pipeliner_HDel_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HDel_Call) Return 

func (_c *Pipeliner_HDel_Call) Return(_a0 *redis.IntCmd) *Pipeliner_HDel_Call

func (*Pipeliner_HDel_Call) Run 

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

func (*Pipeliner_HDel_Call) RunAndReturn 

func (_c *Pipeliner_HDel_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_HDel_Call

type Pipeliner_HExists_Call 

type Pipeliner_HExists_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HExists_Call) Return 

func (_c *Pipeliner_HExists_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_HExists_Call

func (*Pipeliner_HExists_Call) Run 

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

func (*Pipeliner_HExists_Call) RunAndReturn 

func (_c *Pipeliner_HExists_Call) RunAndReturn(run func(context.Context, string, string) *redis.BoolCmd) *Pipeliner_HExists_Call

type Pipeliner_HGetAll_Call 

type Pipeliner_HGetAll_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HGetAll_Call) Return 

func (_c *Pipeliner_HGetAll_Call) Return(_a0 *redis.StringStringMapCmd) *Pipeliner_HGetAll_Call

func (*Pipeliner_HGetAll_Call) Run 

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

func (*Pipeliner_HGetAll_Call) RunAndReturn 

func (_c *Pipeliner_HGetAll_Call) RunAndReturn(run func(context.Context, string) *redis.StringStringMapCmd) *Pipeliner_HGetAll_Call

type Pipeliner_HGet_Call 

type Pipeliner_HGet_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HGet_Call) Return 

func (_c *Pipeliner_HGet_Call) Return(_a0 *redis.StringCmd) *Pipeliner_HGet_Call

func (*Pipeliner_HGet_Call) Run 

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

func (*Pipeliner_HGet_Call) RunAndReturn 

func (_c *Pipeliner_HGet_Call) RunAndReturn(run func(context.Context, string, string) *redis.StringCmd) *Pipeliner_HGet_Call

type Pipeliner_HIncrByFloat_Call 

type Pipeliner_HIncrByFloat_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HIncrByFloat_Call) Return 

func (_c *Pipeliner_HIncrByFloat_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_HIncrByFloat_Call

func (*Pipeliner_HIncrByFloat_Call) Run 

func (_c *Pipeliner_HIncrByFloat_Call) Run(run func(ctx context.Context, key string, field string, incr float64)) *Pipeliner_HIncrByFloat_Call

func (*Pipeliner_HIncrByFloat_Call) RunAndReturn 

func (_c *Pipeliner_HIncrByFloat_Call) RunAndReturn(run func(context.Context, string, string, float64) *redis.FloatCmd) *Pipeliner_HIncrByFloat_Call

type Pipeliner_HIncrBy_Call 

type Pipeliner_HIncrBy_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HIncrBy_Call) Return 

func (_c *Pipeliner_HIncrBy_Call) Return(_a0 *redis.IntCmd) *Pipeliner_HIncrBy_Call

func (*Pipeliner_HIncrBy_Call) Run 

func (_c *Pipeliner_HIncrBy_Call) Run(run func(ctx context.Context, key string, field string, incr int64)) *Pipeliner_HIncrBy_Call

func (*Pipeliner_HIncrBy_Call) RunAndReturn 

func (_c *Pipeliner_HIncrBy_Call) RunAndReturn(run func(context.Context, string, string, int64) *redis.IntCmd) *Pipeliner_HIncrBy_Call

type Pipeliner_HKeys_Call 

type Pipeliner_HKeys_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HKeys_Call) Return 

func (_c *Pipeliner_HKeys_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_HKeys_Call

func (*Pipeliner_HKeys_Call) Run 

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

func (*Pipeliner_HKeys_Call) RunAndReturn 

func (_c *Pipeliner_HKeys_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *Pipeliner_HKeys_Call

type Pipeliner_HLen_Call 

type Pipeliner_HLen_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HLen_Call) Return 

func (_c *Pipeliner_HLen_Call) Return(_a0 *redis.IntCmd) *Pipeliner_HLen_Call

func (*Pipeliner_HLen_Call) Run 

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

func (*Pipeliner_HLen_Call) RunAndReturn 

func (_c *Pipeliner_HLen_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_HLen_Call

type Pipeliner_HMGet_Call 

type Pipeliner_HMGet_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HMGet_Call) Return 

func (_c *Pipeliner_HMGet_Call) Return(_a0 *redis.SliceCmd) *Pipeliner_HMGet_Call

func (*Pipeliner_HMGet_Call) Run 

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

func (*Pipeliner_HMGet_Call) RunAndReturn 

func (_c *Pipeliner_HMGet_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.SliceCmd) *Pipeliner_HMGet_Call

type Pipeliner_HMSet_Call 

type Pipeliner_HMSet_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HMSet_Call) Return 

func (_c *Pipeliner_HMSet_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_HMSet_Call

func (*Pipeliner_HMSet_Call) Run 

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

func (*Pipeliner_HMSet_Call) RunAndReturn 

func (_c *Pipeliner_HMSet_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.BoolCmd) *Pipeliner_HMSet_Call

type Pipeliner_HRandField_Call 

type Pipeliner_HRandField_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HRandField_Call) Return 

func (_c *Pipeliner_HRandField_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_HRandField_Call

func (*Pipeliner_HRandField_Call) Run 

func (_c *Pipeliner_HRandField_Call) Run(run func(ctx context.Context, key string, count int, withValues bool)) *Pipeliner_HRandField_Call

func (*Pipeliner_HRandField_Call) RunAndReturn 

func (_c *Pipeliner_HRandField_Call) RunAndReturn(run func(context.Context, string, int, bool) *redis.StringSliceCmd) *Pipeliner_HRandField_Call

type Pipeliner_HScan_Call 

type Pipeliner_HScan_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HScan_Call) Return 

func (_c *Pipeliner_HScan_Call) Return(_a0 *redis.ScanCmd) *Pipeliner_HScan_Call

func (*Pipeliner_HScan_Call) Run 

func (_c *Pipeliner_HScan_Call) Run(run func(ctx context.Context, key string, cursor uint64, match string, count int64)) *Pipeliner_HScan_Call

func (*Pipeliner_HScan_Call) RunAndReturn 

func (_c *Pipeliner_HScan_Call) RunAndReturn(run func(context.Context, string, uint64, string, int64) *redis.ScanCmd) *Pipeliner_HScan_Call

type Pipeliner_HSetNX_Call 

type Pipeliner_HSetNX_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HSetNX_Call) Return 

func (_c *Pipeliner_HSetNX_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_HSetNX_Call

func (*Pipeliner_HSetNX_Call) Run 

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

func (*Pipeliner_HSetNX_Call) RunAndReturn 

func (_c *Pipeliner_HSetNX_Call) RunAndReturn(run func(context.Context, string, string, interface{}) *redis.BoolCmd) *Pipeliner_HSetNX_Call

type Pipeliner_HSet_Call 

type Pipeliner_HSet_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HSet_Call) Return 

func (_c *Pipeliner_HSet_Call) Return(_a0 *redis.IntCmd) *Pipeliner_HSet_Call

func (*Pipeliner_HSet_Call) Run 

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

func (*Pipeliner_HSet_Call) RunAndReturn 

func (_c *Pipeliner_HSet_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_HSet_Call

type Pipeliner_HVals_Call 

type Pipeliner_HVals_Call struct {
	*mock.Call
}

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

func (*Pipeliner_HVals_Call) Return 

func (_c *Pipeliner_HVals_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_HVals_Call

func (*Pipeliner_HVals_Call) Run 

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

func (*Pipeliner_HVals_Call) RunAndReturn 

func (_c *Pipeliner_HVals_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *Pipeliner_HVals_Call

type Pipeliner_IncrByFloat_Call 

type Pipeliner_IncrByFloat_Call struct {
	*mock.Call
}

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

func (*Pipeliner_IncrByFloat_Call) Return 

func (_c *Pipeliner_IncrByFloat_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_IncrByFloat_Call

func (*Pipeliner_IncrByFloat_Call) Run 

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

func (*Pipeliner_IncrByFloat_Call) RunAndReturn 

func (_c *Pipeliner_IncrByFloat_Call) RunAndReturn(run func(context.Context, string, float64) *redis.FloatCmd) *Pipeliner_IncrByFloat_Call

type Pipeliner_IncrBy_Call 

type Pipeliner_IncrBy_Call struct {
	*mock.Call
}

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

func (*Pipeliner_IncrBy_Call) Return 

func (_c *Pipeliner_IncrBy_Call) Return(_a0 *redis.IntCmd) *Pipeliner_IncrBy_Call

func (*Pipeliner_IncrBy_Call) Run 

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

func (*Pipeliner_IncrBy_Call) RunAndReturn 

func (_c *Pipeliner_IncrBy_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *Pipeliner_IncrBy_Call

type Pipeliner_Incr_Call 

type Pipeliner_Incr_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Incr_Call) Return 

func (_c *Pipeliner_Incr_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Incr_Call

func (*Pipeliner_Incr_Call) Run 

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

func (*Pipeliner_Incr_Call) RunAndReturn 

func (_c *Pipeliner_Incr_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_Incr_Call

type Pipeliner_Info_Call 

type Pipeliner_Info_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Info_Call) Return 

func (_c *Pipeliner_Info_Call) Return(_a0 *redis.StringCmd) *Pipeliner_Info_Call

func (*Pipeliner_Info_Call) Run 

func (_c *Pipeliner_Info_Call) Run(run func(ctx context.Context, section ...string)) *Pipeliner_Info_Call

func (*Pipeliner_Info_Call) RunAndReturn 

func (_c *Pipeliner_Info_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringCmd) *Pipeliner_Info_Call

type Pipeliner_Keys_Call 

type Pipeliner_Keys_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Keys_Call) Return 

func (_c *Pipeliner_Keys_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_Keys_Call

func (*Pipeliner_Keys_Call) Run 

func (_c *Pipeliner_Keys_Call) Run(run func(ctx context.Context, pattern string)) *Pipeliner_Keys_Call

func (*Pipeliner_Keys_Call) RunAndReturn 

func (_c *Pipeliner_Keys_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *Pipeliner_Keys_Call

type Pipeliner_LIndex_Call 

type Pipeliner_LIndex_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LIndex_Call) Return 

func (_c *Pipeliner_LIndex_Call) Return(_a0 *redis.StringCmd) *Pipeliner_LIndex_Call

func (*Pipeliner_LIndex_Call) Run 

func (_c *Pipeliner_LIndex_Call) Run(run func(ctx context.Context, key string, index int64)) *Pipeliner_LIndex_Call

func (*Pipeliner_LIndex_Call) RunAndReturn 

func (_c *Pipeliner_LIndex_Call) RunAndReturn(run func(context.Context, string, int64) *redis.StringCmd) *Pipeliner_LIndex_Call

type Pipeliner_LInsertAfter_Call 

type Pipeliner_LInsertAfter_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LInsertAfter_Call) Return 

func (_c *Pipeliner_LInsertAfter_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LInsertAfter_Call

func (*Pipeliner_LInsertAfter_Call) Run 

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

func (*Pipeliner_LInsertAfter_Call) RunAndReturn 

func (_c *Pipeliner_LInsertAfter_Call) RunAndReturn(run func(context.Context, string, interface{}, interface{}) *redis.IntCmd) *Pipeliner_LInsertAfter_Call

type Pipeliner_LInsertBefore_Call 

type Pipeliner_LInsertBefore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LInsertBefore_Call) Return 

func (_c *Pipeliner_LInsertBefore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LInsertBefore_Call

func (*Pipeliner_LInsertBefore_Call) Run 

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

func (*Pipeliner_LInsertBefore_Call) RunAndReturn 

func (_c *Pipeliner_LInsertBefore_Call) RunAndReturn(run func(context.Context, string, interface{}, interface{}) *redis.IntCmd) *Pipeliner_LInsertBefore_Call

type Pipeliner_LInsert_Call 

type Pipeliner_LInsert_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LInsert_Call) Return 

func (_c *Pipeliner_LInsert_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LInsert_Call

func (*Pipeliner_LInsert_Call) Run 

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

func (*Pipeliner_LInsert_Call) RunAndReturn 

func (_c *Pipeliner_LInsert_Call) RunAndReturn(run func(context.Context, string, string, interface{}, interface{}) *redis.IntCmd) *Pipeliner_LInsert_Call

type Pipeliner_LLen_Call 

type Pipeliner_LLen_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LLen_Call) Return 

func (_c *Pipeliner_LLen_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LLen_Call

func (*Pipeliner_LLen_Call) Run 

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

func (*Pipeliner_LLen_Call) RunAndReturn 

func (_c *Pipeliner_LLen_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_LLen_Call

type Pipeliner_LMove_Call 

type Pipeliner_LMove_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LMove_Call) Return 

func (_c *Pipeliner_LMove_Call) Return(_a0 *redis.StringCmd) *Pipeliner_LMove_Call

func (*Pipeliner_LMove_Call) Run 

func (_c *Pipeliner_LMove_Call) Run(run func(ctx context.Context, source string, destination string, srcpos string, destpos string)) *Pipeliner_LMove_Call

func (*Pipeliner_LMove_Call) RunAndReturn 

func (_c *Pipeliner_LMove_Call) RunAndReturn(run func(context.Context, string, string, string, string) *redis.StringCmd) *Pipeliner_LMove_Call

type Pipeliner_LPopCount_Call 

type Pipeliner_LPopCount_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LPopCount_Call) Return 

func (_c *Pipeliner_LPopCount_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_LPopCount_Call

func (*Pipeliner_LPopCount_Call) Run 

func (_c *Pipeliner_LPopCount_Call) Run(run func(ctx context.Context, key string, count int)) *Pipeliner_LPopCount_Call

func (*Pipeliner_LPopCount_Call) RunAndReturn 

func (_c *Pipeliner_LPopCount_Call) RunAndReturn(run func(context.Context, string, int) *redis.StringSliceCmd) *Pipeliner_LPopCount_Call

type Pipeliner_LPop_Call 

type Pipeliner_LPop_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LPop_Call) Return 

func (_c *Pipeliner_LPop_Call) Return(_a0 *redis.StringCmd) *Pipeliner_LPop_Call

func (*Pipeliner_LPop_Call) Run 

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

func (*Pipeliner_LPop_Call) RunAndReturn 

func (_c *Pipeliner_LPop_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_LPop_Call

type Pipeliner_LPosCount_Call 

type Pipeliner_LPosCount_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LPosCount_Call) Return 

func (_c *Pipeliner_LPosCount_Call) Return(_a0 *redis.IntSliceCmd) *Pipeliner_LPosCount_Call

func (*Pipeliner_LPosCount_Call) Run 

func (_c *Pipeliner_LPosCount_Call) Run(run func(ctx context.Context, key string, value string, count int64, args redis.LPosArgs)) *Pipeliner_LPosCount_Call

func (*Pipeliner_LPosCount_Call) RunAndReturn 

func (_c *Pipeliner_LPosCount_Call) RunAndReturn(run func(context.Context, string, string, int64, redis.LPosArgs) *redis.IntSliceCmd) *Pipeliner_LPosCount_Call

type Pipeliner_LPos_Call 

type Pipeliner_LPos_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LPos_Call) Return 

func (_c *Pipeliner_LPos_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LPos_Call

func (*Pipeliner_LPos_Call) Run 

func (_c *Pipeliner_LPos_Call) Run(run func(ctx context.Context, key string, value string, args redis.LPosArgs)) *Pipeliner_LPos_Call

func (*Pipeliner_LPos_Call) RunAndReturn 

func (_c *Pipeliner_LPos_Call) RunAndReturn(run func(context.Context, string, string, redis.LPosArgs) *redis.IntCmd) *Pipeliner_LPos_Call

type Pipeliner_LPushX_Call 

type Pipeliner_LPushX_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LPushX_Call) Return 

func (_c *Pipeliner_LPushX_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LPushX_Call

func (*Pipeliner_LPushX_Call) Run 

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

func (*Pipeliner_LPushX_Call) RunAndReturn 

func (_c *Pipeliner_LPushX_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_LPushX_Call

type Pipeliner_LPush_Call 

type Pipeliner_LPush_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LPush_Call) Return 

func (_c *Pipeliner_LPush_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LPush_Call

func (*Pipeliner_LPush_Call) Run 

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

func (*Pipeliner_LPush_Call) RunAndReturn 

func (_c *Pipeliner_LPush_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_LPush_Call

type Pipeliner_LRange_Call 

type Pipeliner_LRange_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LRange_Call) Return 

func (_c *Pipeliner_LRange_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_LRange_Call

func (*Pipeliner_LRange_Call) Run 

func (_c *Pipeliner_LRange_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Pipeliner_LRange_Call

func (*Pipeliner_LRange_Call) RunAndReturn 

func (_c *Pipeliner_LRange_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StringSliceCmd) *Pipeliner_LRange_Call

type Pipeliner_LRem_Call 

type Pipeliner_LRem_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LRem_Call) Return 

func (_c *Pipeliner_LRem_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LRem_Call

func (*Pipeliner_LRem_Call) Run 

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

func (*Pipeliner_LRem_Call) RunAndReturn 

func (_c *Pipeliner_LRem_Call) RunAndReturn(run func(context.Context, string, int64, interface{}) *redis.IntCmd) *Pipeliner_LRem_Call

type Pipeliner_LSet_Call 

type Pipeliner_LSet_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LSet_Call) Return 

func (_c *Pipeliner_LSet_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_LSet_Call

func (*Pipeliner_LSet_Call) Run 

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

func (*Pipeliner_LSet_Call) RunAndReturn 

func (_c *Pipeliner_LSet_Call) RunAndReturn(run func(context.Context, string, int64, interface{}) *redis.StatusCmd) *Pipeliner_LSet_Call

type Pipeliner_LTrim_Call 

type Pipeliner_LTrim_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LTrim_Call) Return 

func (_c *Pipeliner_LTrim_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_LTrim_Call

func (*Pipeliner_LTrim_Call) Run 

func (_c *Pipeliner_LTrim_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Pipeliner_LTrim_Call

func (*Pipeliner_LTrim_Call) RunAndReturn 

func (_c *Pipeliner_LTrim_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StatusCmd) *Pipeliner_LTrim_Call

type Pipeliner_LastSave_Call 

type Pipeliner_LastSave_Call struct {
	*mock.Call
}

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

func (*Pipeliner_LastSave_Call) Return 

func (_c *Pipeliner_LastSave_Call) Return(_a0 *redis.IntCmd) *Pipeliner_LastSave_Call

func (*Pipeliner_LastSave_Call) Run 

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

func (*Pipeliner_LastSave_Call) RunAndReturn 

func (_c *Pipeliner_LastSave_Call) RunAndReturn(run func(context.Context) *redis.IntCmd) *Pipeliner_LastSave_Call

type Pipeliner_Len_Call 

type Pipeliner_Len_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Len_Call) Return 

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

func (*Pipeliner_Len_Call) Run 

func (_c *Pipeliner_Len_Call) Run(run func()) *Pipeliner_Len_Call

func (*Pipeliner_Len_Call) RunAndReturn 

func (_c *Pipeliner_Len_Call) RunAndReturn(run func() int) *Pipeliner_Len_Call

type Pipeliner_MGet_Call 

type Pipeliner_MGet_Call struct {
	*mock.Call
}

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

func (*Pipeliner_MGet_Call) Return 

func (_c *Pipeliner_MGet_Call) Return(_a0 *redis.SliceCmd) *Pipeliner_MGet_Call

func (*Pipeliner_MGet_Call) Run 

func (_c *Pipeliner_MGet_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_MGet_Call

func (*Pipeliner_MGet_Call) RunAndReturn 

func (_c *Pipeliner_MGet_Call) RunAndReturn(run func(context.Context, ...string) *redis.SliceCmd) *Pipeliner_MGet_Call

type Pipeliner_MSetNX_Call 

type Pipeliner_MSetNX_Call struct {
	*mock.Call
}

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

func (*Pipeliner_MSetNX_Call) Return 

func (_c *Pipeliner_MSetNX_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_MSetNX_Call

func (*Pipeliner_MSetNX_Call) Run 

func (_c *Pipeliner_MSetNX_Call) Run(run func(ctx context.Context, values ...interface{})) *Pipeliner_MSetNX_Call

func (*Pipeliner_MSetNX_Call) RunAndReturn 

func (_c *Pipeliner_MSetNX_Call) RunAndReturn(run func(context.Context, ...interface{}) *redis.BoolCmd) *Pipeliner_MSetNX_Call

type Pipeliner_MSet_Call 

type Pipeliner_MSet_Call struct {
	*mock.Call
}

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

func (*Pipeliner_MSet_Call) Return 

func (_c *Pipeliner_MSet_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_MSet_Call

func (*Pipeliner_MSet_Call) Run 

func (_c *Pipeliner_MSet_Call) Run(run func(ctx context.Context, values ...interface{})) *Pipeliner_MSet_Call

func (*Pipeliner_MSet_Call) RunAndReturn 

func (_c *Pipeliner_MSet_Call) RunAndReturn(run func(context.Context, ...interface{}) *redis.StatusCmd) *Pipeliner_MSet_Call

type Pipeliner_MemoryUsage_Call 

type Pipeliner_MemoryUsage_Call struct {
	*mock.Call
}

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

func (*Pipeliner_MemoryUsage_Call) Return 

func (_c *Pipeliner_MemoryUsage_Call) Return(_a0 *redis.IntCmd) *Pipeliner_MemoryUsage_Call

func (*Pipeliner_MemoryUsage_Call) Run 

func (_c *Pipeliner_MemoryUsage_Call) Run(run func(ctx context.Context, key string, samples ...int)) *Pipeliner_MemoryUsage_Call

func (*Pipeliner_MemoryUsage_Call) RunAndReturn 

func (_c *Pipeliner_MemoryUsage_Call) RunAndReturn(run func(context.Context, string, ...int) *redis.IntCmd) *Pipeliner_MemoryUsage_Call

type Pipeliner_Migrate_Call 

type Pipeliner_Migrate_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Migrate_Call) Return 

func (_c *Pipeliner_Migrate_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Migrate_Call

func (*Pipeliner_Migrate_Call) Run 

func (_c *Pipeliner_Migrate_Call) Run(run func(ctx context.Context, host string, port string, key string, db int, timeout time.Duration)) *Pipeliner_Migrate_Call

func (*Pipeliner_Migrate_Call) RunAndReturn 

func (_c *Pipeliner_Migrate_Call) RunAndReturn(run func(context.Context, string, string, string, int, time.Duration) *redis.StatusCmd) *Pipeliner_Migrate_Call

type Pipeliner_Move_Call 

type Pipeliner_Move_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Move_Call) Return 

func (_c *Pipeliner_Move_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_Move_Call

func (*Pipeliner_Move_Call) Run 

func (_c *Pipeliner_Move_Call) Run(run func(ctx context.Context, key string, db int)) *Pipeliner_Move_Call

func (*Pipeliner_Move_Call) RunAndReturn 

func (_c *Pipeliner_Move_Call) RunAndReturn(run func(context.Context, string, int) *redis.BoolCmd) *Pipeliner_Move_Call

type Pipeliner_ObjectEncoding_Call 

type Pipeliner_ObjectEncoding_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ObjectEncoding_Call) Return 

func (_c *Pipeliner_ObjectEncoding_Call) Return(_a0 *redis.StringCmd) *Pipeliner_ObjectEncoding_Call

func (*Pipeliner_ObjectEncoding_Call) Run 

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

func (*Pipeliner_ObjectEncoding_Call) RunAndReturn 

func (_c *Pipeliner_ObjectEncoding_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_ObjectEncoding_Call

type Pipeliner_ObjectIdleTime_Call 

type Pipeliner_ObjectIdleTime_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ObjectIdleTime_Call) Return 

func (_c *Pipeliner_ObjectIdleTime_Call) Return(_a0 *redis.DurationCmd) *Pipeliner_ObjectIdleTime_Call

func (*Pipeliner_ObjectIdleTime_Call) Run 

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

func (*Pipeliner_ObjectIdleTime_Call) RunAndReturn 

func (_c *Pipeliner_ObjectIdleTime_Call) RunAndReturn(run func(context.Context, string) *redis.DurationCmd) *Pipeliner_ObjectIdleTime_Call

type Pipeliner_ObjectRefCount_Call 

type Pipeliner_ObjectRefCount_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ObjectRefCount_Call) Return 

func (_c *Pipeliner_ObjectRefCount_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ObjectRefCount_Call

func (*Pipeliner_ObjectRefCount_Call) Run 

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

func (*Pipeliner_ObjectRefCount_Call) RunAndReturn 

func (_c *Pipeliner_ObjectRefCount_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_ObjectRefCount_Call

type Pipeliner_PExpireAt_Call 

type Pipeliner_PExpireAt_Call struct {
	*mock.Call
}

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

func (*Pipeliner_PExpireAt_Call) Return 

func (_c *Pipeliner_PExpireAt_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_PExpireAt_Call

func (*Pipeliner_PExpireAt_Call) Run 

func (_c *Pipeliner_PExpireAt_Call) Run(run func(ctx context.Context, key string, tm time.Time)) *Pipeliner_PExpireAt_Call

func (*Pipeliner_PExpireAt_Call) RunAndReturn 

func (_c *Pipeliner_PExpireAt_Call) RunAndReturn(run func(context.Context, string, time.Time) *redis.BoolCmd) *Pipeliner_PExpireAt_Call

type Pipeliner_PExpire_Call 

type Pipeliner_PExpire_Call struct {
	*mock.Call
}

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

func (*Pipeliner_PExpire_Call) Return 

func (_c *Pipeliner_PExpire_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_PExpire_Call

func (*Pipeliner_PExpire_Call) Run 

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

func (*Pipeliner_PExpire_Call) RunAndReturn 

func (_c *Pipeliner_PExpire_Call) RunAndReturn(run func(context.Context, string, time.Duration) *redis.BoolCmd) *Pipeliner_PExpire_Call

type Pipeliner_PFAdd_Call 

type Pipeliner_PFAdd_Call struct {
	*mock.Call
}

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

func (*Pipeliner_PFAdd_Call) Return 

func (_c *Pipeliner_PFAdd_Call) Return(_a0 *redis.IntCmd) *Pipeliner_PFAdd_Call

func (*Pipeliner_PFAdd_Call) Run 

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

func (*Pipeliner_PFAdd_Call) RunAndReturn 

func (_c *Pipeliner_PFAdd_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_PFAdd_Call

type Pipeliner_PFCount_Call 

type Pipeliner_PFCount_Call struct {
	*mock.Call
}

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

func (*Pipeliner_PFCount_Call) Return 

func (_c *Pipeliner_PFCount_Call) Return(_a0 *redis.IntCmd) *Pipeliner_PFCount_Call

func (*Pipeliner_PFCount_Call) Run 

func (_c *Pipeliner_PFCount_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_PFCount_Call

func (*Pipeliner_PFCount_Call) RunAndReturn 

func (_c *Pipeliner_PFCount_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *Pipeliner_PFCount_Call

type Pipeliner_PFMerge_Call 

type Pipeliner_PFMerge_Call struct {
	*mock.Call
}

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

func (*Pipeliner_PFMerge_Call) Return 

func (_c *Pipeliner_PFMerge_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_PFMerge_Call

func (*Pipeliner_PFMerge_Call) Run 

func (_c *Pipeliner_PFMerge_Call) Run(run func(ctx context.Context, dest string, keys ...string)) *Pipeliner_PFMerge_Call

func (*Pipeliner_PFMerge_Call) RunAndReturn 

func (_c *Pipeliner_PFMerge_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.StatusCmd) *Pipeliner_PFMerge_Call

type Pipeliner_PTTL_Call 

type Pipeliner_PTTL_Call struct {
	*mock.Call
}

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

func (*Pipeliner_PTTL_Call) Return 

func (_c *Pipeliner_PTTL_Call) Return(_a0 *redis.DurationCmd) *Pipeliner_PTTL_Call

func (*Pipeliner_PTTL_Call) Run 

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

func (*Pipeliner_PTTL_Call) RunAndReturn 

func (_c *Pipeliner_PTTL_Call) RunAndReturn(run func(context.Context, string) *redis.DurationCmd) *Pipeliner_PTTL_Call

type Pipeliner_Persist_Call 

type Pipeliner_Persist_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Persist_Call) Return 

func (_c *Pipeliner_Persist_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_Persist_Call

func (*Pipeliner_Persist_Call) Run 

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

func (*Pipeliner_Persist_Call) RunAndReturn 

func (_c *Pipeliner_Persist_Call) RunAndReturn(run func(context.Context, string) *redis.BoolCmd) *Pipeliner_Persist_Call

type Pipeliner_Ping_Call 

type Pipeliner_Ping_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Ping_Call) Return 

func (_c *Pipeliner_Ping_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Ping_Call

func (*Pipeliner_Ping_Call) Run 

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

func (*Pipeliner_Ping_Call) RunAndReturn 

func (_c *Pipeliner_Ping_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_Ping_Call

type Pipeliner_Pipeline_Call 

type Pipeliner_Pipeline_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Pipeline_Call) Return 

func (_c *Pipeliner_Pipeline_Call) Return(_a0 redis.Pipeliner) *Pipeliner_Pipeline_Call

func (*Pipeliner_Pipeline_Call) Run 

func (_c *Pipeliner_Pipeline_Call) Run(run func()) *Pipeliner_Pipeline_Call

func (*Pipeliner_Pipeline_Call) RunAndReturn 

func (_c *Pipeliner_Pipeline_Call) RunAndReturn(run func() redis.Pipeliner) *Pipeliner_Pipeline_Call

type Pipeliner_Pipelined_Call 

type Pipeliner_Pipelined_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Pipelined_Call) Return 

func (_c *Pipeliner_Pipelined_Call) Return(_a0 []redis.Cmder, _a1 error) *Pipeliner_Pipelined_Call

func (*Pipeliner_Pipelined_Call) Run 

func (_c *Pipeliner_Pipelined_Call) Run(run func(ctx context.Context, fn func(redis.Pipeliner) error)) *Pipeliner_Pipelined_Call

func (*Pipeliner_Pipelined_Call) RunAndReturn 

func (_c *Pipeliner_Pipelined_Call) RunAndReturn(run func(context.Context, func(redis.Pipeliner) error) ([]redis.Cmder, error)) *Pipeliner_Pipelined_Call

type Pipeliner_Process_Call 

type Pipeliner_Process_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Process_Call) Return 

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

func (*Pipeliner_Process_Call) Run 

func (_c *Pipeliner_Process_Call) Run(run func(ctx context.Context, cmd redis.Cmder)) *Pipeliner_Process_Call

func (*Pipeliner_Process_Call) RunAndReturn 

func (_c *Pipeliner_Process_Call) RunAndReturn(run func(context.Context, redis.Cmder) error) *Pipeliner_Process_Call

type Pipeliner_PubSubChannels_Call 

type Pipeliner_PubSubChannels_Call struct {
	*mock.Call
}

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

func (*Pipeliner_PubSubChannels_Call) Return 

func (_c *Pipeliner_PubSubChannels_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_PubSubChannels_Call

func (*Pipeliner_PubSubChannels_Call) Run 

func (_c *Pipeliner_PubSubChannels_Call) Run(run func(ctx context.Context, pattern string)) *Pipeliner_PubSubChannels_Call

func (*Pipeliner_PubSubChannels_Call) RunAndReturn 

func (_c *Pipeliner_PubSubChannels_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *Pipeliner_PubSubChannels_Call

type Pipeliner_PubSubNumPat_Call 

type Pipeliner_PubSubNumPat_Call struct {
	*mock.Call
}

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

func (*Pipeliner_PubSubNumPat_Call) Return 

func (_c *Pipeliner_PubSubNumPat_Call) Return(_a0 *redis.IntCmd) *Pipeliner_PubSubNumPat_Call

func (*Pipeliner_PubSubNumPat_Call) Run 

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

func (*Pipeliner_PubSubNumPat_Call) RunAndReturn 

func (_c *Pipeliner_PubSubNumPat_Call) RunAndReturn(run func(context.Context) *redis.IntCmd) *Pipeliner_PubSubNumPat_Call

type Pipeliner_PubSubNumSub_Call 

type Pipeliner_PubSubNumSub_Call struct {
	*mock.Call
}

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

func (*Pipeliner_PubSubNumSub_Call) Return 

func (_c *Pipeliner_PubSubNumSub_Call) Return(_a0 *redis.StringIntMapCmd) *Pipeliner_PubSubNumSub_Call

func (*Pipeliner_PubSubNumSub_Call) Run 

func (_c *Pipeliner_PubSubNumSub_Call) Run(run func(ctx context.Context, channels ...string)) *Pipeliner_PubSubNumSub_Call

func (*Pipeliner_PubSubNumSub_Call) RunAndReturn 

func (_c *Pipeliner_PubSubNumSub_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringIntMapCmd) *Pipeliner_PubSubNumSub_Call

type Pipeliner_Publish_Call 

type Pipeliner_Publish_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Publish_Call) Return 

func (_c *Pipeliner_Publish_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Publish_Call

func (*Pipeliner_Publish_Call) Run 

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

func (*Pipeliner_Publish_Call) RunAndReturn 

func (_c *Pipeliner_Publish_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.IntCmd) *Pipeliner_Publish_Call

type Pipeliner_Quit_Call 

type Pipeliner_Quit_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Quit_Call) Return 

func (_c *Pipeliner_Quit_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Quit_Call

func (*Pipeliner_Quit_Call) Run 

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

func (*Pipeliner_Quit_Call) RunAndReturn 

func (_c *Pipeliner_Quit_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_Quit_Call

type Pipeliner_RPopCount_Call 

type Pipeliner_RPopCount_Call struct {
	*mock.Call
}

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

func (*Pipeliner_RPopCount_Call) Return 

func (_c *Pipeliner_RPopCount_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_RPopCount_Call

func (*Pipeliner_RPopCount_Call) Run 

func (_c *Pipeliner_RPopCount_Call) Run(run func(ctx context.Context, key string, count int)) *Pipeliner_RPopCount_Call

func (*Pipeliner_RPopCount_Call) RunAndReturn 

func (_c *Pipeliner_RPopCount_Call) RunAndReturn(run func(context.Context, string, int) *redis.StringSliceCmd) *Pipeliner_RPopCount_Call

type Pipeliner_RPopLPush_Call 

type Pipeliner_RPopLPush_Call struct {
	*mock.Call
}

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

func (*Pipeliner_RPopLPush_Call) Return 

func (_c *Pipeliner_RPopLPush_Call) Return(_a0 *redis.StringCmd) *Pipeliner_RPopLPush_Call

func (*Pipeliner_RPopLPush_Call) Run 

func (_c *Pipeliner_RPopLPush_Call) Run(run func(ctx context.Context, source string, destination string)) *Pipeliner_RPopLPush_Call

func (*Pipeliner_RPopLPush_Call) RunAndReturn 

func (_c *Pipeliner_RPopLPush_Call) RunAndReturn(run func(context.Context, string, string) *redis.StringCmd) *Pipeliner_RPopLPush_Call

type Pipeliner_RPop_Call 

type Pipeliner_RPop_Call struct {
	*mock.Call
}

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

func (*Pipeliner_RPop_Call) Return 

func (_c *Pipeliner_RPop_Call) Return(_a0 *redis.StringCmd) *Pipeliner_RPop_Call

func (*Pipeliner_RPop_Call) Run 

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

func (*Pipeliner_RPop_Call) RunAndReturn 

func (_c *Pipeliner_RPop_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_RPop_Call

type Pipeliner_RPushX_Call 

type Pipeliner_RPushX_Call struct {
	*mock.Call
}

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

func (*Pipeliner_RPushX_Call) Return 

func (_c *Pipeliner_RPushX_Call) Return(_a0 *redis.IntCmd) *Pipeliner_RPushX_Call

func (*Pipeliner_RPushX_Call) Run 

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

func (*Pipeliner_RPushX_Call) RunAndReturn 

func (_c *Pipeliner_RPushX_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_RPushX_Call

type Pipeliner_RPush_Call 

type Pipeliner_RPush_Call struct {
	*mock.Call
}

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

func (*Pipeliner_RPush_Call) Return 

func (_c *Pipeliner_RPush_Call) Return(_a0 *redis.IntCmd) *Pipeliner_RPush_Call

func (*Pipeliner_RPush_Call) Run 

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

func (*Pipeliner_RPush_Call) RunAndReturn 

func (_c *Pipeliner_RPush_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_RPush_Call

type Pipeliner_RandomKey_Call 

type Pipeliner_RandomKey_Call struct {
	*mock.Call
}

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

func (*Pipeliner_RandomKey_Call) Return 

func (_c *Pipeliner_RandomKey_Call) Return(_a0 *redis.StringCmd) *Pipeliner_RandomKey_Call

func (*Pipeliner_RandomKey_Call) Run 

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

func (*Pipeliner_RandomKey_Call) RunAndReturn 

func (_c *Pipeliner_RandomKey_Call) RunAndReturn(run func(context.Context) *redis.StringCmd) *Pipeliner_RandomKey_Call

type Pipeliner_ReadOnly_Call 

type Pipeliner_ReadOnly_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ReadOnly_Call) Return 

func (_c *Pipeliner_ReadOnly_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ReadOnly_Call

func (*Pipeliner_ReadOnly_Call) Run 

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

func (*Pipeliner_ReadOnly_Call) RunAndReturn 

func (_c *Pipeliner_ReadOnly_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ReadOnly_Call

type Pipeliner_ReadWrite_Call 

type Pipeliner_ReadWrite_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ReadWrite_Call) Return 

func (_c *Pipeliner_ReadWrite_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ReadWrite_Call

func (*Pipeliner_ReadWrite_Call) Run 

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

func (*Pipeliner_ReadWrite_Call) RunAndReturn 

func (_c *Pipeliner_ReadWrite_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ReadWrite_Call

type Pipeliner_RenameNX_Call 

type Pipeliner_RenameNX_Call struct {
	*mock.Call
}

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

func (*Pipeliner_RenameNX_Call) Return 

func (_c *Pipeliner_RenameNX_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_RenameNX_Call

func (*Pipeliner_RenameNX_Call) Run 

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

func (*Pipeliner_RenameNX_Call) RunAndReturn 

func (_c *Pipeliner_RenameNX_Call) RunAndReturn(run func(context.Context, string, string) *redis.BoolCmd) *Pipeliner_RenameNX_Call

type Pipeliner_Rename_Call 

type Pipeliner_Rename_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Rename_Call) Return 

func (_c *Pipeliner_Rename_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Rename_Call

func (*Pipeliner_Rename_Call) Run 

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

func (*Pipeliner_Rename_Call) RunAndReturn 

func (_c *Pipeliner_Rename_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *Pipeliner_Rename_Call

type Pipeliner_RestoreReplace_Call 

type Pipeliner_RestoreReplace_Call struct {
	*mock.Call
}

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

func (*Pipeliner_RestoreReplace_Call) Return 

func (_c *Pipeliner_RestoreReplace_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_RestoreReplace_Call

func (*Pipeliner_RestoreReplace_Call) Run 

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

func (*Pipeliner_RestoreReplace_Call) RunAndReturn 

func (_c *Pipeliner_RestoreReplace_Call) RunAndReturn(run func(context.Context, string, time.Duration, string) *redis.StatusCmd) *Pipeliner_RestoreReplace_Call

type Pipeliner_Restore_Call 

type Pipeliner_Restore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Restore_Call) Return 

func (_c *Pipeliner_Restore_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Restore_Call

func (*Pipeliner_Restore_Call) Run 

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

func (*Pipeliner_Restore_Call) RunAndReturn 

func (_c *Pipeliner_Restore_Call) RunAndReturn(run func(context.Context, string, time.Duration, string) *redis.StatusCmd) *Pipeliner_Restore_Call

type Pipeliner_SAdd_Call 

type Pipeliner_SAdd_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SAdd_Call) Return 

func (_c *Pipeliner_SAdd_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SAdd_Call

func (*Pipeliner_SAdd_Call) Run 

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

func (*Pipeliner_SAdd_Call) RunAndReturn 

func (_c *Pipeliner_SAdd_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_SAdd_Call

type Pipeliner_SCard_Call 

type Pipeliner_SCard_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SCard_Call) Return 

func (_c *Pipeliner_SCard_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SCard_Call

func (*Pipeliner_SCard_Call) Run 

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

func (*Pipeliner_SCard_Call) RunAndReturn 

func (_c *Pipeliner_SCard_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_SCard_Call

type Pipeliner_SDiffStore_Call 

type Pipeliner_SDiffStore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SDiffStore_Call) Return 

func (_c *Pipeliner_SDiffStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SDiffStore_Call

func (*Pipeliner_SDiffStore_Call) Run 

func (_c *Pipeliner_SDiffStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *Pipeliner_SDiffStore_Call

func (*Pipeliner_SDiffStore_Call) RunAndReturn 

func (_c *Pipeliner_SDiffStore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_SDiffStore_Call

type Pipeliner_SDiff_Call 

type Pipeliner_SDiff_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SDiff_Call) Return 

func (_c *Pipeliner_SDiff_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_SDiff_Call

func (*Pipeliner_SDiff_Call) Run 

func (_c *Pipeliner_SDiff_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_SDiff_Call

func (*Pipeliner_SDiff_Call) RunAndReturn 

func (_c *Pipeliner_SDiff_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringSliceCmd) *Pipeliner_SDiff_Call

type Pipeliner_SInterStore_Call 

type Pipeliner_SInterStore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SInterStore_Call) Return 

func (_c *Pipeliner_SInterStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SInterStore_Call

func (*Pipeliner_SInterStore_Call) Run 

func (_c *Pipeliner_SInterStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *Pipeliner_SInterStore_Call

func (*Pipeliner_SInterStore_Call) RunAndReturn 

func (_c *Pipeliner_SInterStore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_SInterStore_Call

type Pipeliner_SInter_Call 

type Pipeliner_SInter_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SInter_Call) Return 

func (_c *Pipeliner_SInter_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_SInter_Call

func (*Pipeliner_SInter_Call) Run 

func (_c *Pipeliner_SInter_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_SInter_Call

func (*Pipeliner_SInter_Call) RunAndReturn 

func (_c *Pipeliner_SInter_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringSliceCmd) *Pipeliner_SInter_Call

type Pipeliner_SIsMember_Call 

type Pipeliner_SIsMember_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SIsMember_Call) Return 

func (_c *Pipeliner_SIsMember_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_SIsMember_Call

func (*Pipeliner_SIsMember_Call) Run 

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

func (*Pipeliner_SIsMember_Call) RunAndReturn 

func (_c *Pipeliner_SIsMember_Call) RunAndReturn(run func(context.Context, string, interface{}) *redis.BoolCmd) *Pipeliner_SIsMember_Call

type Pipeliner_SMIsMember_Call 

type Pipeliner_SMIsMember_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SMIsMember_Call) Return 

func (_c *Pipeliner_SMIsMember_Call) Return(_a0 *redis.BoolSliceCmd) *Pipeliner_SMIsMember_Call

func (*Pipeliner_SMIsMember_Call) Run 

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

func (*Pipeliner_SMIsMember_Call) RunAndReturn 

func (_c *Pipeliner_SMIsMember_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.BoolSliceCmd) *Pipeliner_SMIsMember_Call

type Pipeliner_SMembersMap_Call 

type Pipeliner_SMembersMap_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SMembersMap_Call) Return 

func (_c *Pipeliner_SMembersMap_Call) Return(_a0 *redis.StringStructMapCmd) *Pipeliner_SMembersMap_Call

func (*Pipeliner_SMembersMap_Call) Run 

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

func (*Pipeliner_SMembersMap_Call) RunAndReturn 

func (_c *Pipeliner_SMembersMap_Call) RunAndReturn(run func(context.Context, string) *redis.StringStructMapCmd) *Pipeliner_SMembersMap_Call

type Pipeliner_SMembers_Call 

type Pipeliner_SMembers_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SMembers_Call) Return 

func (_c *Pipeliner_SMembers_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_SMembers_Call

func (*Pipeliner_SMembers_Call) Run 

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

func (*Pipeliner_SMembers_Call) RunAndReturn 

func (_c *Pipeliner_SMembers_Call) RunAndReturn(run func(context.Context, string) *redis.StringSliceCmd) *Pipeliner_SMembers_Call

type Pipeliner_SMove_Call 

type Pipeliner_SMove_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SMove_Call) Return 

func (_c *Pipeliner_SMove_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_SMove_Call

func (*Pipeliner_SMove_Call) Run 

func (_c *Pipeliner_SMove_Call) Run(run func(ctx context.Context, source string, destination string, member interface{})) *Pipeliner_SMove_Call

func (*Pipeliner_SMove_Call) RunAndReturn 

func (_c *Pipeliner_SMove_Call) RunAndReturn(run func(context.Context, string, string, interface{}) *redis.BoolCmd) *Pipeliner_SMove_Call

type Pipeliner_SPopN_Call 

type Pipeliner_SPopN_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SPopN_Call) Return 

func (_c *Pipeliner_SPopN_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_SPopN_Call

func (*Pipeliner_SPopN_Call) Run 

func (_c *Pipeliner_SPopN_Call) Run(run func(ctx context.Context, key string, count int64)) *Pipeliner_SPopN_Call

func (*Pipeliner_SPopN_Call) RunAndReturn 

func (_c *Pipeliner_SPopN_Call) RunAndReturn(run func(context.Context, string, int64) *redis.StringSliceCmd) *Pipeliner_SPopN_Call

type Pipeliner_SPop_Call 

type Pipeliner_SPop_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SPop_Call) Return 

func (_c *Pipeliner_SPop_Call) Return(_a0 *redis.StringCmd) *Pipeliner_SPop_Call

func (*Pipeliner_SPop_Call) Run 

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

func (*Pipeliner_SPop_Call) RunAndReturn 

func (_c *Pipeliner_SPop_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_SPop_Call

type Pipeliner_SRandMemberN_Call 

type Pipeliner_SRandMemberN_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SRandMemberN_Call) Return 

func (_c *Pipeliner_SRandMemberN_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_SRandMemberN_Call

func (*Pipeliner_SRandMemberN_Call) Run 

func (_c *Pipeliner_SRandMemberN_Call) Run(run func(ctx context.Context, key string, count int64)) *Pipeliner_SRandMemberN_Call

func (*Pipeliner_SRandMemberN_Call) RunAndReturn 

func (_c *Pipeliner_SRandMemberN_Call) RunAndReturn(run func(context.Context, string, int64) *redis.StringSliceCmd) *Pipeliner_SRandMemberN_Call

type Pipeliner_SRandMember_Call 

type Pipeliner_SRandMember_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SRandMember_Call) Return 

func (_c *Pipeliner_SRandMember_Call) Return(_a0 *redis.StringCmd) *Pipeliner_SRandMember_Call

func (*Pipeliner_SRandMember_Call) Run 

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

func (*Pipeliner_SRandMember_Call) RunAndReturn 

func (_c *Pipeliner_SRandMember_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_SRandMember_Call

type Pipeliner_SRem_Call 

type Pipeliner_SRem_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SRem_Call) Return 

func (_c *Pipeliner_SRem_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SRem_Call

func (*Pipeliner_SRem_Call) Run 

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

func (*Pipeliner_SRem_Call) RunAndReturn 

func (_c *Pipeliner_SRem_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_SRem_Call

type Pipeliner_SScan_Call 

type Pipeliner_SScan_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SScan_Call) Return 

func (_c *Pipeliner_SScan_Call) Return(_a0 *redis.ScanCmd) *Pipeliner_SScan_Call

func (*Pipeliner_SScan_Call) Run 

func (_c *Pipeliner_SScan_Call) Run(run func(ctx context.Context, key string, cursor uint64, match string, count int64)) *Pipeliner_SScan_Call

func (*Pipeliner_SScan_Call) RunAndReturn 

func (_c *Pipeliner_SScan_Call) RunAndReturn(run func(context.Context, string, uint64, string, int64) *redis.ScanCmd) *Pipeliner_SScan_Call

type Pipeliner_SUnionStore_Call 

type Pipeliner_SUnionStore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SUnionStore_Call) Return 

func (_c *Pipeliner_SUnionStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SUnionStore_Call

func (*Pipeliner_SUnionStore_Call) Run 

func (_c *Pipeliner_SUnionStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *Pipeliner_SUnionStore_Call

func (*Pipeliner_SUnionStore_Call) RunAndReturn 

func (_c *Pipeliner_SUnionStore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_SUnionStore_Call

type Pipeliner_SUnion_Call 

type Pipeliner_SUnion_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SUnion_Call) Return 

func (_c *Pipeliner_SUnion_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_SUnion_Call

func (*Pipeliner_SUnion_Call) Run 

func (_c *Pipeliner_SUnion_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_SUnion_Call

func (*Pipeliner_SUnion_Call) RunAndReturn 

func (_c *Pipeliner_SUnion_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringSliceCmd) *Pipeliner_SUnion_Call

type Pipeliner_Save_Call 

type Pipeliner_Save_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Save_Call) Return 

func (_c *Pipeliner_Save_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Save_Call

func (*Pipeliner_Save_Call) Run 

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

func (*Pipeliner_Save_Call) RunAndReturn 

func (_c *Pipeliner_Save_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_Save_Call

type Pipeliner_ScanType_Call 

type Pipeliner_ScanType_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ScanType_Call) Return 

func (_c *Pipeliner_ScanType_Call) Return(_a0 *redis.ScanCmd) *Pipeliner_ScanType_Call

func (*Pipeliner_ScanType_Call) Run 

func (_c *Pipeliner_ScanType_Call) Run(run func(ctx context.Context, cursor uint64, match string, count int64, keyType string)) *Pipeliner_ScanType_Call

func (*Pipeliner_ScanType_Call) RunAndReturn 

func (_c *Pipeliner_ScanType_Call) RunAndReturn(run func(context.Context, uint64, string, int64, string) *redis.ScanCmd) *Pipeliner_ScanType_Call

type Pipeliner_Scan_Call 

type Pipeliner_Scan_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Scan_Call) Return 

func (_c *Pipeliner_Scan_Call) Return(_a0 *redis.ScanCmd) *Pipeliner_Scan_Call

func (*Pipeliner_Scan_Call) Run 

func (_c *Pipeliner_Scan_Call) Run(run func(ctx context.Context, cursor uint64, match string, count int64)) *Pipeliner_Scan_Call

func (*Pipeliner_Scan_Call) RunAndReturn 

func (_c *Pipeliner_Scan_Call) RunAndReturn(run func(context.Context, uint64, string, int64) *redis.ScanCmd) *Pipeliner_Scan_Call

type Pipeliner_ScriptExists_Call 

type Pipeliner_ScriptExists_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ScriptExists_Call) Return 

func (_c *Pipeliner_ScriptExists_Call) Return(_a0 *redis.BoolSliceCmd) *Pipeliner_ScriptExists_Call

func (*Pipeliner_ScriptExists_Call) Run 

func (_c *Pipeliner_ScriptExists_Call) Run(run func(ctx context.Context, hashes ...string)) *Pipeliner_ScriptExists_Call

func (*Pipeliner_ScriptExists_Call) RunAndReturn 

func (_c *Pipeliner_ScriptExists_Call) RunAndReturn(run func(context.Context, ...string) *redis.BoolSliceCmd) *Pipeliner_ScriptExists_Call

type Pipeliner_ScriptFlush_Call 

type Pipeliner_ScriptFlush_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ScriptFlush_Call) Return 

func (_c *Pipeliner_ScriptFlush_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ScriptFlush_Call

func (*Pipeliner_ScriptFlush_Call) Run 

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

func (*Pipeliner_ScriptFlush_Call) RunAndReturn 

func (_c *Pipeliner_ScriptFlush_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ScriptFlush_Call

type Pipeliner_ScriptKill_Call 

type Pipeliner_ScriptKill_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ScriptKill_Call) Return 

func (_c *Pipeliner_ScriptKill_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ScriptKill_Call

func (*Pipeliner_ScriptKill_Call) Run 

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

func (*Pipeliner_ScriptKill_Call) RunAndReturn 

func (_c *Pipeliner_ScriptKill_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ScriptKill_Call

type Pipeliner_ScriptLoad_Call 

type Pipeliner_ScriptLoad_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ScriptLoad_Call) Return 

func (_c *Pipeliner_ScriptLoad_Call) Return(_a0 *redis.StringCmd) *Pipeliner_ScriptLoad_Call

func (*Pipeliner_ScriptLoad_Call) Run 

func (_c *Pipeliner_ScriptLoad_Call) Run(run func(ctx context.Context, script string)) *Pipeliner_ScriptLoad_Call

func (*Pipeliner_ScriptLoad_Call) RunAndReturn 

func (_c *Pipeliner_ScriptLoad_Call) RunAndReturn(run func(context.Context, string) *redis.StringCmd) *Pipeliner_ScriptLoad_Call

type Pipeliner_Select_Call 

type Pipeliner_Select_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Select_Call) Return 

func (_c *Pipeliner_Select_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Select_Call

func (*Pipeliner_Select_Call) Run 

func (_c *Pipeliner_Select_Call) Run(run func(ctx context.Context, index int)) *Pipeliner_Select_Call

func (*Pipeliner_Select_Call) RunAndReturn 

func (_c *Pipeliner_Select_Call) RunAndReturn(run func(context.Context, int) *redis.StatusCmd) *Pipeliner_Select_Call

type Pipeliner_SetArgs_Call 

type Pipeliner_SetArgs_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SetArgs_Call) Return 

func (_c *Pipeliner_SetArgs_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_SetArgs_Call

func (*Pipeliner_SetArgs_Call) Run 

func (_c *Pipeliner_SetArgs_Call) Run(run func(ctx context.Context, key string, value interface{}, a redis.SetArgs)) *Pipeliner_SetArgs_Call

func (*Pipeliner_SetArgs_Call) RunAndReturn 

func (_c *Pipeliner_SetArgs_Call) RunAndReturn(run func(context.Context, string, interface{}, redis.SetArgs) *redis.StatusCmd) *Pipeliner_SetArgs_Call

type Pipeliner_SetBit_Call 

type Pipeliner_SetBit_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SetBit_Call) Return 

func (_c *Pipeliner_SetBit_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SetBit_Call

func (*Pipeliner_SetBit_Call) Run 

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

func (*Pipeliner_SetBit_Call) RunAndReturn 

func (_c *Pipeliner_SetBit_Call) RunAndReturn(run func(context.Context, string, int64, int) *redis.IntCmd) *Pipeliner_SetBit_Call

type Pipeliner_SetEX_Call 

type Pipeliner_SetEX_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SetEX_Call) Return 

func (_c *Pipeliner_SetEX_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_SetEX_Call

func (*Pipeliner_SetEX_Call) Run 

func (_c *Pipeliner_SetEX_Call) Run(run func(ctx context.Context, key string, value interface{}, expiration time.Duration)) *Pipeliner_SetEX_Call

func (*Pipeliner_SetEX_Call) RunAndReturn 

func (_c *Pipeliner_SetEX_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) *redis.StatusCmd) *Pipeliner_SetEX_Call

type Pipeliner_SetNX_Call 

type Pipeliner_SetNX_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SetNX_Call) Return 

func (_c *Pipeliner_SetNX_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_SetNX_Call

func (*Pipeliner_SetNX_Call) Run 

func (_c *Pipeliner_SetNX_Call) Run(run func(ctx context.Context, key string, value interface{}, expiration time.Duration)) *Pipeliner_SetNX_Call

func (*Pipeliner_SetNX_Call) RunAndReturn 

func (_c *Pipeliner_SetNX_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) *redis.BoolCmd) *Pipeliner_SetNX_Call

type Pipeliner_SetRange_Call 

type Pipeliner_SetRange_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SetRange_Call) Return 

func (_c *Pipeliner_SetRange_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SetRange_Call

func (*Pipeliner_SetRange_Call) Run 

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

func (*Pipeliner_SetRange_Call) RunAndReturn 

func (_c *Pipeliner_SetRange_Call) RunAndReturn(run func(context.Context, string, int64, string) *redis.IntCmd) *Pipeliner_SetRange_Call

type Pipeliner_SetXX_Call 

type Pipeliner_SetXX_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SetXX_Call) Return 

func (_c *Pipeliner_SetXX_Call) Return(_a0 *redis.BoolCmd) *Pipeliner_SetXX_Call

func (*Pipeliner_SetXX_Call) Run 

func (_c *Pipeliner_SetXX_Call) Run(run func(ctx context.Context, key string, value interface{}, expiration time.Duration)) *Pipeliner_SetXX_Call

func (*Pipeliner_SetXX_Call) RunAndReturn 

func (_c *Pipeliner_SetXX_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) *redis.BoolCmd) *Pipeliner_SetXX_Call

type Pipeliner_Set_Call 

type Pipeliner_Set_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Set_Call) Return 

func (_c *Pipeliner_Set_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Set_Call

func (*Pipeliner_Set_Call) Run 

func (_c *Pipeliner_Set_Call) Run(run func(ctx context.Context, key string, value interface{}, expiration time.Duration)) *Pipeliner_Set_Call

func (*Pipeliner_Set_Call) RunAndReturn 

func (_c *Pipeliner_Set_Call) RunAndReturn(run func(context.Context, string, interface{}, time.Duration) *redis.StatusCmd) *Pipeliner_Set_Call

type Pipeliner_ShutdownNoSave_Call 

type Pipeliner_ShutdownNoSave_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ShutdownNoSave_Call) Return 

func (_c *Pipeliner_ShutdownNoSave_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ShutdownNoSave_Call

func (*Pipeliner_ShutdownNoSave_Call) Run 

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

func (*Pipeliner_ShutdownNoSave_Call) RunAndReturn 

func (_c *Pipeliner_ShutdownNoSave_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ShutdownNoSave_Call

type Pipeliner_ShutdownSave_Call 

type Pipeliner_ShutdownSave_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ShutdownSave_Call) Return 

func (_c *Pipeliner_ShutdownSave_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_ShutdownSave_Call

func (*Pipeliner_ShutdownSave_Call) Run 

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

func (*Pipeliner_ShutdownSave_Call) RunAndReturn 

func (_c *Pipeliner_ShutdownSave_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_ShutdownSave_Call

type Pipeliner_Shutdown_Call 

type Pipeliner_Shutdown_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Shutdown_Call) Return 

func (_c *Pipeliner_Shutdown_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Shutdown_Call

func (*Pipeliner_Shutdown_Call) Run 

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

func (*Pipeliner_Shutdown_Call) RunAndReturn 

func (_c *Pipeliner_Shutdown_Call) RunAndReturn(run func(context.Context) *redis.StatusCmd) *Pipeliner_Shutdown_Call

type Pipeliner_SlaveOf_Call 

type Pipeliner_SlaveOf_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SlaveOf_Call) Return 

func (_c *Pipeliner_SlaveOf_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_SlaveOf_Call

func (*Pipeliner_SlaveOf_Call) Run 

func (_c *Pipeliner_SlaveOf_Call) Run(run func(ctx context.Context, host string, port string)) *Pipeliner_SlaveOf_Call

func (*Pipeliner_SlaveOf_Call) RunAndReturn 

func (_c *Pipeliner_SlaveOf_Call) RunAndReturn(run func(context.Context, string, string) *redis.StatusCmd) *Pipeliner_SlaveOf_Call

type Pipeliner_SortInterfaces_Call 

type Pipeliner_SortInterfaces_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SortInterfaces_Call) Return 

func (_c *Pipeliner_SortInterfaces_Call) Return(_a0 *redis.SliceCmd) *Pipeliner_SortInterfaces_Call

func (*Pipeliner_SortInterfaces_Call) Run 

func (_c *Pipeliner_SortInterfaces_Call) Run(run func(ctx context.Context, key string, sort *redis.Sort)) *Pipeliner_SortInterfaces_Call

func (*Pipeliner_SortInterfaces_Call) RunAndReturn 

func (_c *Pipeliner_SortInterfaces_Call) RunAndReturn(run func(context.Context, string, *redis.Sort) *redis.SliceCmd) *Pipeliner_SortInterfaces_Call

type Pipeliner_SortStore_Call 

type Pipeliner_SortStore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SortStore_Call) Return 

func (_c *Pipeliner_SortStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_SortStore_Call

func (*Pipeliner_SortStore_Call) Run 

func (_c *Pipeliner_SortStore_Call) Run(run func(ctx context.Context, key string, store string, sort *redis.Sort)) *Pipeliner_SortStore_Call

func (*Pipeliner_SortStore_Call) RunAndReturn 

func (_c *Pipeliner_SortStore_Call) RunAndReturn(run func(context.Context, string, string, *redis.Sort) *redis.IntCmd) *Pipeliner_SortStore_Call

type Pipeliner_Sort_Call 

type Pipeliner_Sort_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Sort_Call) Return 

func (_c *Pipeliner_Sort_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_Sort_Call

func (*Pipeliner_Sort_Call) Run 

func (_c *Pipeliner_Sort_Call) Run(run func(ctx context.Context, key string, sort *redis.Sort)) *Pipeliner_Sort_Call

func (*Pipeliner_Sort_Call) RunAndReturn 

func (_c *Pipeliner_Sort_Call) RunAndReturn(run func(context.Context, string, *redis.Sort) *redis.StringSliceCmd) *Pipeliner_Sort_Call

type Pipeliner_StrLen_Call 

type Pipeliner_StrLen_Call struct {
	*mock.Call
}

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

func (*Pipeliner_StrLen_Call) Return 

func (_c *Pipeliner_StrLen_Call) Return(_a0 *redis.IntCmd) *Pipeliner_StrLen_Call

func (*Pipeliner_StrLen_Call) Run 

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

func (*Pipeliner_StrLen_Call) RunAndReturn 

func (_c *Pipeliner_StrLen_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_StrLen_Call

type Pipeliner_SwapDB_Call 

type Pipeliner_SwapDB_Call struct {
	*mock.Call
}

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

func (*Pipeliner_SwapDB_Call) Return 

func (_c *Pipeliner_SwapDB_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_SwapDB_Call

func (*Pipeliner_SwapDB_Call) Run 

func (_c *Pipeliner_SwapDB_Call) Run(run func(ctx context.Context, index1 int, index2 int)) *Pipeliner_SwapDB_Call

func (*Pipeliner_SwapDB_Call) RunAndReturn 

func (_c *Pipeliner_SwapDB_Call) RunAndReturn(run func(context.Context, int, int) *redis.StatusCmd) *Pipeliner_SwapDB_Call

type Pipeliner_TTL_Call 

type Pipeliner_TTL_Call struct {
	*mock.Call
}

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

func (*Pipeliner_TTL_Call) Return 

func (_c *Pipeliner_TTL_Call) Return(_a0 *redis.DurationCmd) *Pipeliner_TTL_Call

func (*Pipeliner_TTL_Call) Run 

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

func (*Pipeliner_TTL_Call) RunAndReturn 

func (_c *Pipeliner_TTL_Call) RunAndReturn(run func(context.Context, string) *redis.DurationCmd) *Pipeliner_TTL_Call

type Pipeliner_Time_Call 

type Pipeliner_Time_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Time_Call) Return 

func (_c *Pipeliner_Time_Call) Return(_a0 *redis.TimeCmd) *Pipeliner_Time_Call

func (*Pipeliner_Time_Call) Run 

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

func (*Pipeliner_Time_Call) RunAndReturn 

func (_c *Pipeliner_Time_Call) RunAndReturn(run func(context.Context) *redis.TimeCmd) *Pipeliner_Time_Call

type Pipeliner_Touch_Call 

type Pipeliner_Touch_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Touch_Call) Return 

func (_c *Pipeliner_Touch_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Touch_Call

func (*Pipeliner_Touch_Call) Run 

func (_c *Pipeliner_Touch_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_Touch_Call

func (*Pipeliner_Touch_Call) RunAndReturn 

func (_c *Pipeliner_Touch_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *Pipeliner_Touch_Call

type Pipeliner_TxPipeline_Call 

type Pipeliner_TxPipeline_Call struct {
	*mock.Call
}

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

func (*Pipeliner_TxPipeline_Call) Return 

func (_c *Pipeliner_TxPipeline_Call) Return(_a0 redis.Pipeliner) *Pipeliner_TxPipeline_Call

func (*Pipeliner_TxPipeline_Call) Run 

func (_c *Pipeliner_TxPipeline_Call) Run(run func()) *Pipeliner_TxPipeline_Call

func (*Pipeliner_TxPipeline_Call) RunAndReturn 

func (_c *Pipeliner_TxPipeline_Call) RunAndReturn(run func() redis.Pipeliner) *Pipeliner_TxPipeline_Call

type Pipeliner_TxPipelined_Call 

type Pipeliner_TxPipelined_Call struct {
	*mock.Call
}

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

func (*Pipeliner_TxPipelined_Call) Return 

func (_c *Pipeliner_TxPipelined_Call) Return(_a0 []redis.Cmder, _a1 error) *Pipeliner_TxPipelined_Call

func (*Pipeliner_TxPipelined_Call) Run 

func (_c *Pipeliner_TxPipelined_Call) Run(run func(ctx context.Context, fn func(redis.Pipeliner) error)) *Pipeliner_TxPipelined_Call

func (*Pipeliner_TxPipelined_Call) RunAndReturn 

func (_c *Pipeliner_TxPipelined_Call) RunAndReturn(run func(context.Context, func(redis.Pipeliner) error) ([]redis.Cmder, error)) *Pipeliner_TxPipelined_Call

type Pipeliner_Type_Call 

type Pipeliner_Type_Call struct {
	*mock.Call
}

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

func (*Pipeliner_Type_Call) Return 

func (_c *Pipeliner_Type_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_Type_Call

func (*Pipeliner_Type_Call) Run 

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

func (*Pipeliner_Type_Call) RunAndReturn 

func (_c *Pipeliner_Type_Call) RunAndReturn(run func(context.Context, string) *redis.StatusCmd) *Pipeliner_Type_Call
type Pipeliner_Unlink_Call struct {
	*mock.Call
}

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

func (_c *Pipeliner_Unlink_Call) Return(_a0 *redis.IntCmd) *Pipeliner_Unlink_Call
func (_c *Pipeliner_Unlink_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_Unlink_Call
func (_c *Pipeliner_Unlink_Call) RunAndReturn(run func(context.Context, ...string) *redis.IntCmd) *Pipeliner_Unlink_Call

type Pipeliner_XAck_Call 

type Pipeliner_XAck_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XAck_Call) Return 

func (_c *Pipeliner_XAck_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XAck_Call

func (*Pipeliner_XAck_Call) Run 

func (_c *Pipeliner_XAck_Call) Run(run func(ctx context.Context, stream string, group string, ids ...string)) *Pipeliner_XAck_Call

func (*Pipeliner_XAck_Call) RunAndReturn 

func (_c *Pipeliner_XAck_Call) RunAndReturn(run func(context.Context, string, string, ...string) *redis.IntCmd) *Pipeliner_XAck_Call

type Pipeliner_XAdd_Call 

type Pipeliner_XAdd_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XAdd_Call) Return 

func (_c *Pipeliner_XAdd_Call) Return(_a0 *redis.StringCmd) *Pipeliner_XAdd_Call

func (*Pipeliner_XAdd_Call) Run 

func (_c *Pipeliner_XAdd_Call) Run(run func(ctx context.Context, a *redis.XAddArgs)) *Pipeliner_XAdd_Call

func (*Pipeliner_XAdd_Call) RunAndReturn 

func (_c *Pipeliner_XAdd_Call) RunAndReturn(run func(context.Context, *redis.XAddArgs) *redis.StringCmd) *Pipeliner_XAdd_Call

type Pipeliner_XAutoClaimJustID_Call 

type Pipeliner_XAutoClaimJustID_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XAutoClaimJustID_Call) Return 

func (_c *Pipeliner_XAutoClaimJustID_Call) Return(_a0 *redis.XAutoClaimJustIDCmd) *Pipeliner_XAutoClaimJustID_Call

func (*Pipeliner_XAutoClaimJustID_Call) Run 

func (_c *Pipeliner_XAutoClaimJustID_Call) Run(run func(ctx context.Context, a *redis.XAutoClaimArgs)) *Pipeliner_XAutoClaimJustID_Call

func (*Pipeliner_XAutoClaimJustID_Call) RunAndReturn 

func (_c *Pipeliner_XAutoClaimJustID_Call) RunAndReturn(run func(context.Context, *redis.XAutoClaimArgs) *redis.XAutoClaimJustIDCmd) *Pipeliner_XAutoClaimJustID_Call

type Pipeliner_XAutoClaim_Call 

type Pipeliner_XAutoClaim_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XAutoClaim_Call) Return 

func (_c *Pipeliner_XAutoClaim_Call) Return(_a0 *redis.XAutoClaimCmd) *Pipeliner_XAutoClaim_Call

func (*Pipeliner_XAutoClaim_Call) Run 

func (_c *Pipeliner_XAutoClaim_Call) Run(run func(ctx context.Context, a *redis.XAutoClaimArgs)) *Pipeliner_XAutoClaim_Call

func (*Pipeliner_XAutoClaim_Call) RunAndReturn 

func (_c *Pipeliner_XAutoClaim_Call) RunAndReturn(run func(context.Context, *redis.XAutoClaimArgs) *redis.XAutoClaimCmd) *Pipeliner_XAutoClaim_Call

type Pipeliner_XClaimJustID_Call 

type Pipeliner_XClaimJustID_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XClaimJustID_Call) Return 

func (_c *Pipeliner_XClaimJustID_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_XClaimJustID_Call

func (*Pipeliner_XClaimJustID_Call) Run 

func (_c *Pipeliner_XClaimJustID_Call) Run(run func(ctx context.Context, a *redis.XClaimArgs)) *Pipeliner_XClaimJustID_Call

func (*Pipeliner_XClaimJustID_Call) RunAndReturn 

func (_c *Pipeliner_XClaimJustID_Call) RunAndReturn(run func(context.Context, *redis.XClaimArgs) *redis.StringSliceCmd) *Pipeliner_XClaimJustID_Call

type Pipeliner_XClaim_Call 

type Pipeliner_XClaim_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XClaim_Call) Return 

func (_c *Pipeliner_XClaim_Call) Return(_a0 *redis.XMessageSliceCmd) *Pipeliner_XClaim_Call

func (*Pipeliner_XClaim_Call) Run 

func (_c *Pipeliner_XClaim_Call) Run(run func(ctx context.Context, a *redis.XClaimArgs)) *Pipeliner_XClaim_Call

func (*Pipeliner_XClaim_Call) RunAndReturn 

func (_c *Pipeliner_XClaim_Call) RunAndReturn(run func(context.Context, *redis.XClaimArgs) *redis.XMessageSliceCmd) *Pipeliner_XClaim_Call

type Pipeliner_XDel_Call 

type Pipeliner_XDel_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XDel_Call) Return 

func (_c *Pipeliner_XDel_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XDel_Call

func (*Pipeliner_XDel_Call) Run 

func (_c *Pipeliner_XDel_Call) Run(run func(ctx context.Context, stream string, ids ...string)) *Pipeliner_XDel_Call

func (*Pipeliner_XDel_Call) RunAndReturn 

func (_c *Pipeliner_XDel_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_XDel_Call

type Pipeliner_XGroupCreateConsumer_Call 

type Pipeliner_XGroupCreateConsumer_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XGroupCreateConsumer_Call) Return 

func (_c *Pipeliner_XGroupCreateConsumer_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XGroupCreateConsumer_Call

func (*Pipeliner_XGroupCreateConsumer_Call) Run 

func (_c *Pipeliner_XGroupCreateConsumer_Call) Run(run func(ctx context.Context, stream string, group string, consumer string)) *Pipeliner_XGroupCreateConsumer_Call

func (*Pipeliner_XGroupCreateConsumer_Call) RunAndReturn 

func (_c *Pipeliner_XGroupCreateConsumer_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *Pipeliner_XGroupCreateConsumer_Call

type Pipeliner_XGroupCreateMkStream_Call 

type Pipeliner_XGroupCreateMkStream_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XGroupCreateMkStream_Call) Return 

func (_c *Pipeliner_XGroupCreateMkStream_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_XGroupCreateMkStream_Call

func (*Pipeliner_XGroupCreateMkStream_Call) Run 

func (_c *Pipeliner_XGroupCreateMkStream_Call) Run(run func(ctx context.Context, stream string, group string, start string)) *Pipeliner_XGroupCreateMkStream_Call

func (*Pipeliner_XGroupCreateMkStream_Call) RunAndReturn 

func (_c *Pipeliner_XGroupCreateMkStream_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.StatusCmd) *Pipeliner_XGroupCreateMkStream_Call

type Pipeliner_XGroupCreate_Call 

type Pipeliner_XGroupCreate_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XGroupCreate_Call) Return 

func (_c *Pipeliner_XGroupCreate_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_XGroupCreate_Call

func (*Pipeliner_XGroupCreate_Call) Run 

func (_c *Pipeliner_XGroupCreate_Call) Run(run func(ctx context.Context, stream string, group string, start string)) *Pipeliner_XGroupCreate_Call

func (*Pipeliner_XGroupCreate_Call) RunAndReturn 

func (_c *Pipeliner_XGroupCreate_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.StatusCmd) *Pipeliner_XGroupCreate_Call

type Pipeliner_XGroupDelConsumer_Call 

type Pipeliner_XGroupDelConsumer_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XGroupDelConsumer_Call) Return 

func (_c *Pipeliner_XGroupDelConsumer_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XGroupDelConsumer_Call

func (*Pipeliner_XGroupDelConsumer_Call) Run 

func (_c *Pipeliner_XGroupDelConsumer_Call) Run(run func(ctx context.Context, stream string, group string, consumer string)) *Pipeliner_XGroupDelConsumer_Call

func (*Pipeliner_XGroupDelConsumer_Call) RunAndReturn 

func (_c *Pipeliner_XGroupDelConsumer_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *Pipeliner_XGroupDelConsumer_Call

type Pipeliner_XGroupDestroy_Call 

type Pipeliner_XGroupDestroy_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XGroupDestroy_Call) Return 

func (_c *Pipeliner_XGroupDestroy_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XGroupDestroy_Call

func (*Pipeliner_XGroupDestroy_Call) Run 

func (_c *Pipeliner_XGroupDestroy_Call) Run(run func(ctx context.Context, stream string, group string)) *Pipeliner_XGroupDestroy_Call

func (*Pipeliner_XGroupDestroy_Call) RunAndReturn 

func (_c *Pipeliner_XGroupDestroy_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *Pipeliner_XGroupDestroy_Call

type Pipeliner_XGroupSetID_Call 

type Pipeliner_XGroupSetID_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XGroupSetID_Call) Return 

func (_c *Pipeliner_XGroupSetID_Call) Return(_a0 *redis.StatusCmd) *Pipeliner_XGroupSetID_Call

func (*Pipeliner_XGroupSetID_Call) Run 

func (_c *Pipeliner_XGroupSetID_Call) Run(run func(ctx context.Context, stream string, group string, start string)) *Pipeliner_XGroupSetID_Call

func (*Pipeliner_XGroupSetID_Call) RunAndReturn 

func (_c *Pipeliner_XGroupSetID_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.StatusCmd) *Pipeliner_XGroupSetID_Call

type Pipeliner_XInfoConsumers_Call 

type Pipeliner_XInfoConsumers_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XInfoConsumers_Call) Return 

func (_c *Pipeliner_XInfoConsumers_Call) Return(_a0 *redis.XInfoConsumersCmd) *Pipeliner_XInfoConsumers_Call

func (*Pipeliner_XInfoConsumers_Call) Run 

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

func (*Pipeliner_XInfoConsumers_Call) RunAndReturn 

func (_c *Pipeliner_XInfoConsumers_Call) RunAndReturn(run func(context.Context, string, string) *redis.XInfoConsumersCmd) *Pipeliner_XInfoConsumers_Call

type Pipeliner_XInfoGroups_Call 

type Pipeliner_XInfoGroups_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XInfoGroups_Call) Return 

func (_c *Pipeliner_XInfoGroups_Call) Return(_a0 *redis.XInfoGroupsCmd) *Pipeliner_XInfoGroups_Call

func (*Pipeliner_XInfoGroups_Call) Run 

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

func (*Pipeliner_XInfoGroups_Call) RunAndReturn 

func (_c *Pipeliner_XInfoGroups_Call) RunAndReturn(run func(context.Context, string) *redis.XInfoGroupsCmd) *Pipeliner_XInfoGroups_Call

type Pipeliner_XInfoStreamFull_Call 

type Pipeliner_XInfoStreamFull_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XInfoStreamFull_Call) Return 

func (_c *Pipeliner_XInfoStreamFull_Call) Return(_a0 *redis.XInfoStreamFullCmd) *Pipeliner_XInfoStreamFull_Call

func (*Pipeliner_XInfoStreamFull_Call) Run 

func (_c *Pipeliner_XInfoStreamFull_Call) Run(run func(ctx context.Context, key string, count int)) *Pipeliner_XInfoStreamFull_Call

func (*Pipeliner_XInfoStreamFull_Call) RunAndReturn 

func (_c *Pipeliner_XInfoStreamFull_Call) RunAndReturn(run func(context.Context, string, int) *redis.XInfoStreamFullCmd) *Pipeliner_XInfoStreamFull_Call

type Pipeliner_XInfoStream_Call 

type Pipeliner_XInfoStream_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XInfoStream_Call) Return 

func (_c *Pipeliner_XInfoStream_Call) Return(_a0 *redis.XInfoStreamCmd) *Pipeliner_XInfoStream_Call

func (*Pipeliner_XInfoStream_Call) Run 

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

func (*Pipeliner_XInfoStream_Call) RunAndReturn 

func (_c *Pipeliner_XInfoStream_Call) RunAndReturn(run func(context.Context, string) *redis.XInfoStreamCmd) *Pipeliner_XInfoStream_Call

type Pipeliner_XLen_Call 

type Pipeliner_XLen_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XLen_Call) Return 

func (_c *Pipeliner_XLen_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XLen_Call

func (*Pipeliner_XLen_Call) Run 

func (_c *Pipeliner_XLen_Call) Run(run func(ctx context.Context, stream string)) *Pipeliner_XLen_Call

func (*Pipeliner_XLen_Call) RunAndReturn 

func (_c *Pipeliner_XLen_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_XLen_Call

type Pipeliner_XPendingExt_Call 

type Pipeliner_XPendingExt_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XPendingExt_Call) Return 

func (_c *Pipeliner_XPendingExt_Call) Return(_a0 *redis.XPendingExtCmd) *Pipeliner_XPendingExt_Call

func (*Pipeliner_XPendingExt_Call) Run 

func (_c *Pipeliner_XPendingExt_Call) Run(run func(ctx context.Context, a *redis.XPendingExtArgs)) *Pipeliner_XPendingExt_Call

func (*Pipeliner_XPendingExt_Call) RunAndReturn 

func (_c *Pipeliner_XPendingExt_Call) RunAndReturn(run func(context.Context, *redis.XPendingExtArgs) *redis.XPendingExtCmd) *Pipeliner_XPendingExt_Call

type Pipeliner_XPending_Call 

type Pipeliner_XPending_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XPending_Call) Return 

func (_c *Pipeliner_XPending_Call) Return(_a0 *redis.XPendingCmd) *Pipeliner_XPending_Call

func (*Pipeliner_XPending_Call) Run 

func (_c *Pipeliner_XPending_Call) Run(run func(ctx context.Context, stream string, group string)) *Pipeliner_XPending_Call

func (*Pipeliner_XPending_Call) RunAndReturn 

func (_c *Pipeliner_XPending_Call) RunAndReturn(run func(context.Context, string, string) *redis.XPendingCmd) *Pipeliner_XPending_Call

type Pipeliner_XRangeN_Call 

type Pipeliner_XRangeN_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XRangeN_Call) Return 

func (_c *Pipeliner_XRangeN_Call) Return(_a0 *redis.XMessageSliceCmd) *Pipeliner_XRangeN_Call

func (*Pipeliner_XRangeN_Call) Run 

func (_c *Pipeliner_XRangeN_Call) Run(run func(ctx context.Context, stream string, start string, stop string, count int64)) *Pipeliner_XRangeN_Call

func (*Pipeliner_XRangeN_Call) RunAndReturn 

func (_c *Pipeliner_XRangeN_Call) RunAndReturn(run func(context.Context, string, string, string, int64) *redis.XMessageSliceCmd) *Pipeliner_XRangeN_Call

type Pipeliner_XRange_Call 

type Pipeliner_XRange_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XRange_Call) Return 

func (_c *Pipeliner_XRange_Call) Return(_a0 *redis.XMessageSliceCmd) *Pipeliner_XRange_Call

func (*Pipeliner_XRange_Call) Run 

func (_c *Pipeliner_XRange_Call) Run(run func(ctx context.Context, stream string, start string, stop string)) *Pipeliner_XRange_Call

func (*Pipeliner_XRange_Call) RunAndReturn 

func (_c *Pipeliner_XRange_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.XMessageSliceCmd) *Pipeliner_XRange_Call

type Pipeliner_XReadGroup_Call 

type Pipeliner_XReadGroup_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XReadGroup_Call) Return 

func (_c *Pipeliner_XReadGroup_Call) Return(_a0 *redis.XStreamSliceCmd) *Pipeliner_XReadGroup_Call

func (*Pipeliner_XReadGroup_Call) Run 

func (_c *Pipeliner_XReadGroup_Call) Run(run func(ctx context.Context, a *redis.XReadGroupArgs)) *Pipeliner_XReadGroup_Call

func (*Pipeliner_XReadGroup_Call) RunAndReturn 

func (_c *Pipeliner_XReadGroup_Call) RunAndReturn(run func(context.Context, *redis.XReadGroupArgs) *redis.XStreamSliceCmd) *Pipeliner_XReadGroup_Call

type Pipeliner_XReadStreams_Call 

type Pipeliner_XReadStreams_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XReadStreams_Call) Return 

func (_c *Pipeliner_XReadStreams_Call) Return(_a0 *redis.XStreamSliceCmd) *Pipeliner_XReadStreams_Call

func (*Pipeliner_XReadStreams_Call) Run 

func (_c *Pipeliner_XReadStreams_Call) Run(run func(ctx context.Context, streams ...string)) *Pipeliner_XReadStreams_Call

func (*Pipeliner_XReadStreams_Call) RunAndReturn 

func (_c *Pipeliner_XReadStreams_Call) RunAndReturn(run func(context.Context, ...string) *redis.XStreamSliceCmd) *Pipeliner_XReadStreams_Call

type Pipeliner_XRead_Call 

type Pipeliner_XRead_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XRead_Call) Return 

func (_c *Pipeliner_XRead_Call) Return(_a0 *redis.XStreamSliceCmd) *Pipeliner_XRead_Call

func (*Pipeliner_XRead_Call) Run 

func (_c *Pipeliner_XRead_Call) Run(run func(ctx context.Context, a *redis.XReadArgs)) *Pipeliner_XRead_Call

func (*Pipeliner_XRead_Call) RunAndReturn 

func (_c *Pipeliner_XRead_Call) RunAndReturn(run func(context.Context, *redis.XReadArgs) *redis.XStreamSliceCmd) *Pipeliner_XRead_Call

type Pipeliner_XRevRangeN_Call 

type Pipeliner_XRevRangeN_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XRevRangeN_Call) Return 

func (_c *Pipeliner_XRevRangeN_Call) Return(_a0 *redis.XMessageSliceCmd) *Pipeliner_XRevRangeN_Call

func (*Pipeliner_XRevRangeN_Call) Run 

func (_c *Pipeliner_XRevRangeN_Call) Run(run func(ctx context.Context, stream string, start string, stop string, count int64)) *Pipeliner_XRevRangeN_Call

func (*Pipeliner_XRevRangeN_Call) RunAndReturn 

func (_c *Pipeliner_XRevRangeN_Call) RunAndReturn(run func(context.Context, string, string, string, int64) *redis.XMessageSliceCmd) *Pipeliner_XRevRangeN_Call

type Pipeliner_XRevRange_Call 

type Pipeliner_XRevRange_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XRevRange_Call) Return 

func (_c *Pipeliner_XRevRange_Call) Return(_a0 *redis.XMessageSliceCmd) *Pipeliner_XRevRange_Call

func (*Pipeliner_XRevRange_Call) Run 

func (_c *Pipeliner_XRevRange_Call) Run(run func(ctx context.Context, stream string, start string, stop string)) *Pipeliner_XRevRange_Call

func (*Pipeliner_XRevRange_Call) RunAndReturn 

func (_c *Pipeliner_XRevRange_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.XMessageSliceCmd) *Pipeliner_XRevRange_Call

type Pipeliner_XTrimApprox_Call 

type Pipeliner_XTrimApprox_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XTrimApprox_Call) Return 

func (_c *Pipeliner_XTrimApprox_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XTrimApprox_Call

func (*Pipeliner_XTrimApprox_Call) Run 

func (_c *Pipeliner_XTrimApprox_Call) Run(run func(ctx context.Context, key string, maxLen int64)) *Pipeliner_XTrimApprox_Call

func (*Pipeliner_XTrimApprox_Call) RunAndReturn 

func (_c *Pipeliner_XTrimApprox_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *Pipeliner_XTrimApprox_Call

type Pipeliner_XTrimMaxLenApprox_Call 

type Pipeliner_XTrimMaxLenApprox_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XTrimMaxLenApprox_Call) Return 

func (_c *Pipeliner_XTrimMaxLenApprox_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XTrimMaxLenApprox_Call

func (*Pipeliner_XTrimMaxLenApprox_Call) Run 

func (_c *Pipeliner_XTrimMaxLenApprox_Call) Run(run func(ctx context.Context, key string, maxLen int64, limit int64)) *Pipeliner_XTrimMaxLenApprox_Call

func (*Pipeliner_XTrimMaxLenApprox_Call) RunAndReturn 

func (_c *Pipeliner_XTrimMaxLenApprox_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.IntCmd) *Pipeliner_XTrimMaxLenApprox_Call

type Pipeliner_XTrimMaxLen_Call 

type Pipeliner_XTrimMaxLen_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XTrimMaxLen_Call) Return 

func (_c *Pipeliner_XTrimMaxLen_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XTrimMaxLen_Call

func (*Pipeliner_XTrimMaxLen_Call) Run 

func (_c *Pipeliner_XTrimMaxLen_Call) Run(run func(ctx context.Context, key string, maxLen int64)) *Pipeliner_XTrimMaxLen_Call

func (*Pipeliner_XTrimMaxLen_Call) RunAndReturn 

func (_c *Pipeliner_XTrimMaxLen_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *Pipeliner_XTrimMaxLen_Call

type Pipeliner_XTrimMinIDApprox_Call 

type Pipeliner_XTrimMinIDApprox_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XTrimMinIDApprox_Call) Return 

func (_c *Pipeliner_XTrimMinIDApprox_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XTrimMinIDApprox_Call

func (*Pipeliner_XTrimMinIDApprox_Call) Run 

func (_c *Pipeliner_XTrimMinIDApprox_Call) Run(run func(ctx context.Context, key string, minID string, limit int64)) *Pipeliner_XTrimMinIDApprox_Call

func (*Pipeliner_XTrimMinIDApprox_Call) RunAndReturn 

func (_c *Pipeliner_XTrimMinIDApprox_Call) RunAndReturn(run func(context.Context, string, string, int64) *redis.IntCmd) *Pipeliner_XTrimMinIDApprox_Call

type Pipeliner_XTrimMinID_Call 

type Pipeliner_XTrimMinID_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XTrimMinID_Call) Return 

func (_c *Pipeliner_XTrimMinID_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XTrimMinID_Call

func (*Pipeliner_XTrimMinID_Call) Run 

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

func (*Pipeliner_XTrimMinID_Call) RunAndReturn 

func (_c *Pipeliner_XTrimMinID_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *Pipeliner_XTrimMinID_Call

type Pipeliner_XTrim_Call 

type Pipeliner_XTrim_Call struct {
	*mock.Call
}

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

func (*Pipeliner_XTrim_Call) Return 

func (_c *Pipeliner_XTrim_Call) Return(_a0 *redis.IntCmd) *Pipeliner_XTrim_Call

func (*Pipeliner_XTrim_Call) Run 

func (_c *Pipeliner_XTrim_Call) Run(run func(ctx context.Context, key string, maxLen int64)) *Pipeliner_XTrim_Call

func (*Pipeliner_XTrim_Call) RunAndReturn 

func (_c *Pipeliner_XTrim_Call) RunAndReturn(run func(context.Context, string, int64) *redis.IntCmd) *Pipeliner_XTrim_Call

type Pipeliner_ZAddArgsIncr_Call 

type Pipeliner_ZAddArgsIncr_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZAddArgsIncr_Call) Return 

func (_c *Pipeliner_ZAddArgsIncr_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_ZAddArgsIncr_Call

func (*Pipeliner_ZAddArgsIncr_Call) Run 

func (_c *Pipeliner_ZAddArgsIncr_Call) Run(run func(ctx context.Context, key string, args redis.ZAddArgs)) *Pipeliner_ZAddArgsIncr_Call

func (*Pipeliner_ZAddArgsIncr_Call) RunAndReturn 

func (_c *Pipeliner_ZAddArgsIncr_Call) RunAndReturn(run func(context.Context, string, redis.ZAddArgs) *redis.FloatCmd) *Pipeliner_ZAddArgsIncr_Call

type Pipeliner_ZAddArgs_Call 

type Pipeliner_ZAddArgs_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZAddArgs_Call) Return 

func (_c *Pipeliner_ZAddArgs_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZAddArgs_Call

func (*Pipeliner_ZAddArgs_Call) Run 

func (_c *Pipeliner_ZAddArgs_Call) Run(run func(ctx context.Context, key string, args redis.ZAddArgs)) *Pipeliner_ZAddArgs_Call

func (*Pipeliner_ZAddArgs_Call) RunAndReturn 

func (_c *Pipeliner_ZAddArgs_Call) RunAndReturn(run func(context.Context, string, redis.ZAddArgs) *redis.IntCmd) *Pipeliner_ZAddArgs_Call

type Pipeliner_ZAddCh_Call 

type Pipeliner_ZAddCh_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZAddCh_Call) Return 

func (_c *Pipeliner_ZAddCh_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZAddCh_Call

func (*Pipeliner_ZAddCh_Call) Run 

func (_c *Pipeliner_ZAddCh_Call) Run(run func(ctx context.Context, key string, members ...*redis.Z)) *Pipeliner_ZAddCh_Call

func (*Pipeliner_ZAddCh_Call) RunAndReturn 

func (_c *Pipeliner_ZAddCh_Call) RunAndReturn(run func(context.Context, string, ...*redis.Z) *redis.IntCmd) *Pipeliner_ZAddCh_Call

type Pipeliner_ZAddNXCh_Call 

type Pipeliner_ZAddNXCh_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZAddNXCh_Call) Return 

func (_c *Pipeliner_ZAddNXCh_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZAddNXCh_Call

func (*Pipeliner_ZAddNXCh_Call) Run 

func (_c *Pipeliner_ZAddNXCh_Call) Run(run func(ctx context.Context, key string, members ...*redis.Z)) *Pipeliner_ZAddNXCh_Call

func (*Pipeliner_ZAddNXCh_Call) RunAndReturn 

func (_c *Pipeliner_ZAddNXCh_Call) RunAndReturn(run func(context.Context, string, ...*redis.Z) *redis.IntCmd) *Pipeliner_ZAddNXCh_Call

type Pipeliner_ZAddNX_Call 

type Pipeliner_ZAddNX_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZAddNX_Call) Return 

func (_c *Pipeliner_ZAddNX_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZAddNX_Call

func (*Pipeliner_ZAddNX_Call) Run 

func (_c *Pipeliner_ZAddNX_Call) Run(run func(ctx context.Context, key string, members ...*redis.Z)) *Pipeliner_ZAddNX_Call

func (*Pipeliner_ZAddNX_Call) RunAndReturn 

func (_c *Pipeliner_ZAddNX_Call) RunAndReturn(run func(context.Context, string, ...*redis.Z) *redis.IntCmd) *Pipeliner_ZAddNX_Call

type Pipeliner_ZAddXXCh_Call 

type Pipeliner_ZAddXXCh_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZAddXXCh_Call) Return 

func (_c *Pipeliner_ZAddXXCh_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZAddXXCh_Call

func (*Pipeliner_ZAddXXCh_Call) Run 

func (_c *Pipeliner_ZAddXXCh_Call) Run(run func(ctx context.Context, key string, members ...*redis.Z)) *Pipeliner_ZAddXXCh_Call

func (*Pipeliner_ZAddXXCh_Call) RunAndReturn 

func (_c *Pipeliner_ZAddXXCh_Call) RunAndReturn(run func(context.Context, string, ...*redis.Z) *redis.IntCmd) *Pipeliner_ZAddXXCh_Call

type Pipeliner_ZAddXX_Call 

type Pipeliner_ZAddXX_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZAddXX_Call) Return 

func (_c *Pipeliner_ZAddXX_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZAddXX_Call

func (*Pipeliner_ZAddXX_Call) Run 

func (_c *Pipeliner_ZAddXX_Call) Run(run func(ctx context.Context, key string, members ...*redis.Z)) *Pipeliner_ZAddXX_Call

func (*Pipeliner_ZAddXX_Call) RunAndReturn 

func (_c *Pipeliner_ZAddXX_Call) RunAndReturn(run func(context.Context, string, ...*redis.Z) *redis.IntCmd) *Pipeliner_ZAddXX_Call

type Pipeliner_ZAdd_Call 

type Pipeliner_ZAdd_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZAdd_Call) Return 

func (_c *Pipeliner_ZAdd_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZAdd_Call

func (*Pipeliner_ZAdd_Call) Run 

func (_c *Pipeliner_ZAdd_Call) Run(run func(ctx context.Context, key string, members ...*redis.Z)) *Pipeliner_ZAdd_Call

func (*Pipeliner_ZAdd_Call) RunAndReturn 

func (_c *Pipeliner_ZAdd_Call) RunAndReturn(run func(context.Context, string, ...*redis.Z) *redis.IntCmd) *Pipeliner_ZAdd_Call

type Pipeliner_ZCard_Call 

type Pipeliner_ZCard_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZCard_Call) Return 

func (_c *Pipeliner_ZCard_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZCard_Call

func (*Pipeliner_ZCard_Call) Run 

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

func (*Pipeliner_ZCard_Call) RunAndReturn 

func (_c *Pipeliner_ZCard_Call) RunAndReturn(run func(context.Context, string) *redis.IntCmd) *Pipeliner_ZCard_Call

type Pipeliner_ZCount_Call 

type Pipeliner_ZCount_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZCount_Call) Return 

func (_c *Pipeliner_ZCount_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZCount_Call

func (*Pipeliner_ZCount_Call) Run 

func (_c *Pipeliner_ZCount_Call) Run(run func(ctx context.Context, key string, min string, max string)) *Pipeliner_ZCount_Call

func (*Pipeliner_ZCount_Call) RunAndReturn 

func (_c *Pipeliner_ZCount_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *Pipeliner_ZCount_Call

type Pipeliner_ZDiffStore_Call 

type Pipeliner_ZDiffStore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZDiffStore_Call) Return 

func (_c *Pipeliner_ZDiffStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZDiffStore_Call

func (*Pipeliner_ZDiffStore_Call) Run 

func (_c *Pipeliner_ZDiffStore_Call) Run(run func(ctx context.Context, destination string, keys ...string)) *Pipeliner_ZDiffStore_Call

func (*Pipeliner_ZDiffStore_Call) RunAndReturn 

func (_c *Pipeliner_ZDiffStore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.IntCmd) *Pipeliner_ZDiffStore_Call

type Pipeliner_ZDiffWithScores_Call 

type Pipeliner_ZDiffWithScores_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZDiffWithScores_Call) Return 

func (_c *Pipeliner_ZDiffWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZDiffWithScores_Call

func (*Pipeliner_ZDiffWithScores_Call) Run 

func (_c *Pipeliner_ZDiffWithScores_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_ZDiffWithScores_Call

func (*Pipeliner_ZDiffWithScores_Call) RunAndReturn 

func (_c *Pipeliner_ZDiffWithScores_Call) RunAndReturn(run func(context.Context, ...string) *redis.ZSliceCmd) *Pipeliner_ZDiffWithScores_Call

type Pipeliner_ZDiff_Call 

type Pipeliner_ZDiff_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZDiff_Call) Return 

func (_c *Pipeliner_ZDiff_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZDiff_Call

func (*Pipeliner_ZDiff_Call) Run 

func (_c *Pipeliner_ZDiff_Call) Run(run func(ctx context.Context, keys ...string)) *Pipeliner_ZDiff_Call

func (*Pipeliner_ZDiff_Call) RunAndReturn 

func (_c *Pipeliner_ZDiff_Call) RunAndReturn(run func(context.Context, ...string) *redis.StringSliceCmd) *Pipeliner_ZDiff_Call

type Pipeliner_ZIncrBy_Call 

type Pipeliner_ZIncrBy_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZIncrBy_Call) Return 

func (_c *Pipeliner_ZIncrBy_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_ZIncrBy_Call

func (*Pipeliner_ZIncrBy_Call) Run 

func (_c *Pipeliner_ZIncrBy_Call) Run(run func(ctx context.Context, key string, increment float64, member string)) *Pipeliner_ZIncrBy_Call

func (*Pipeliner_ZIncrBy_Call) RunAndReturn 

func (_c *Pipeliner_ZIncrBy_Call) RunAndReturn(run func(context.Context, string, float64, string) *redis.FloatCmd) *Pipeliner_ZIncrBy_Call

type Pipeliner_ZIncrNX_Call 

type Pipeliner_ZIncrNX_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZIncrNX_Call) Return 

func (_c *Pipeliner_ZIncrNX_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_ZIncrNX_Call

func (*Pipeliner_ZIncrNX_Call) Run 

func (_c *Pipeliner_ZIncrNX_Call) Run(run func(ctx context.Context, key string, member *redis.Z)) *Pipeliner_ZIncrNX_Call

func (*Pipeliner_ZIncrNX_Call) RunAndReturn 

func (_c *Pipeliner_ZIncrNX_Call) RunAndReturn(run func(context.Context, string, *redis.Z) *redis.FloatCmd) *Pipeliner_ZIncrNX_Call

type Pipeliner_ZIncrXX_Call 

type Pipeliner_ZIncrXX_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZIncrXX_Call) Return 

func (_c *Pipeliner_ZIncrXX_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_ZIncrXX_Call

func (*Pipeliner_ZIncrXX_Call) Run 

func (_c *Pipeliner_ZIncrXX_Call) Run(run func(ctx context.Context, key string, member *redis.Z)) *Pipeliner_ZIncrXX_Call

func (*Pipeliner_ZIncrXX_Call) RunAndReturn 

func (_c *Pipeliner_ZIncrXX_Call) RunAndReturn(run func(context.Context, string, *redis.Z) *redis.FloatCmd) *Pipeliner_ZIncrXX_Call

type Pipeliner_ZIncr_Call 

type Pipeliner_ZIncr_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZIncr_Call) Return 

func (_c *Pipeliner_ZIncr_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_ZIncr_Call

func (*Pipeliner_ZIncr_Call) Run 

func (_c *Pipeliner_ZIncr_Call) Run(run func(ctx context.Context, key string, member *redis.Z)) *Pipeliner_ZIncr_Call

func (*Pipeliner_ZIncr_Call) RunAndReturn 

func (_c *Pipeliner_ZIncr_Call) RunAndReturn(run func(context.Context, string, *redis.Z) *redis.FloatCmd) *Pipeliner_ZIncr_Call

type Pipeliner_ZInterStore_Call 

type Pipeliner_ZInterStore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZInterStore_Call) Return 

func (_c *Pipeliner_ZInterStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZInterStore_Call

func (*Pipeliner_ZInterStore_Call) Run 

func (_c *Pipeliner_ZInterStore_Call) Run(run func(ctx context.Context, destination string, store *redis.ZStore)) *Pipeliner_ZInterStore_Call

func (*Pipeliner_ZInterStore_Call) RunAndReturn 

func (_c *Pipeliner_ZInterStore_Call) RunAndReturn(run func(context.Context, string, *redis.ZStore) *redis.IntCmd) *Pipeliner_ZInterStore_Call

type Pipeliner_ZInterWithScores_Call 

type Pipeliner_ZInterWithScores_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZInterWithScores_Call) Return 

func (_c *Pipeliner_ZInterWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZInterWithScores_Call

func (*Pipeliner_ZInterWithScores_Call) Run 

func (_c *Pipeliner_ZInterWithScores_Call) Run(run func(ctx context.Context, store *redis.ZStore)) *Pipeliner_ZInterWithScores_Call

func (*Pipeliner_ZInterWithScores_Call) RunAndReturn 

func (_c *Pipeliner_ZInterWithScores_Call) RunAndReturn(run func(context.Context, *redis.ZStore) *redis.ZSliceCmd) *Pipeliner_ZInterWithScores_Call

type Pipeliner_ZInter_Call 

type Pipeliner_ZInter_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZInter_Call) Return 

func (_c *Pipeliner_ZInter_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZInter_Call

func (*Pipeliner_ZInter_Call) Run 

func (_c *Pipeliner_ZInter_Call) Run(run func(ctx context.Context, store *redis.ZStore)) *Pipeliner_ZInter_Call

func (*Pipeliner_ZInter_Call) RunAndReturn 

func (_c *Pipeliner_ZInter_Call) RunAndReturn(run func(context.Context, *redis.ZStore) *redis.StringSliceCmd) *Pipeliner_ZInter_Call

type Pipeliner_ZLexCount_Call 

type Pipeliner_ZLexCount_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZLexCount_Call) Return 

func (_c *Pipeliner_ZLexCount_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZLexCount_Call

func (*Pipeliner_ZLexCount_Call) Run 

func (_c *Pipeliner_ZLexCount_Call) Run(run func(ctx context.Context, key string, min string, max string)) *Pipeliner_ZLexCount_Call

func (*Pipeliner_ZLexCount_Call) RunAndReturn 

func (_c *Pipeliner_ZLexCount_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *Pipeliner_ZLexCount_Call

type Pipeliner_ZMScore_Call 

type Pipeliner_ZMScore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZMScore_Call) Return 

func (_c *Pipeliner_ZMScore_Call) Return(_a0 *redis.FloatSliceCmd) *Pipeliner_ZMScore_Call

func (*Pipeliner_ZMScore_Call) Run 

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

func (*Pipeliner_ZMScore_Call) RunAndReturn 

func (_c *Pipeliner_ZMScore_Call) RunAndReturn(run func(context.Context, string, ...string) *redis.FloatSliceCmd) *Pipeliner_ZMScore_Call

type Pipeliner_ZPopMax_Call 

type Pipeliner_ZPopMax_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZPopMax_Call) Return 

func (_c *Pipeliner_ZPopMax_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZPopMax_Call

func (*Pipeliner_ZPopMax_Call) Run 

func (_c *Pipeliner_ZPopMax_Call) Run(run func(ctx context.Context, key string, count ...int64)) *Pipeliner_ZPopMax_Call

func (*Pipeliner_ZPopMax_Call) RunAndReturn 

func (_c *Pipeliner_ZPopMax_Call) RunAndReturn(run func(context.Context, string, ...int64) *redis.ZSliceCmd) *Pipeliner_ZPopMax_Call

type Pipeliner_ZPopMin_Call 

type Pipeliner_ZPopMin_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZPopMin_Call) Return 

func (_c *Pipeliner_ZPopMin_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZPopMin_Call

func (*Pipeliner_ZPopMin_Call) Run 

func (_c *Pipeliner_ZPopMin_Call) Run(run func(ctx context.Context, key string, count ...int64)) *Pipeliner_ZPopMin_Call

func (*Pipeliner_ZPopMin_Call) RunAndReturn 

func (_c *Pipeliner_ZPopMin_Call) RunAndReturn(run func(context.Context, string, ...int64) *redis.ZSliceCmd) *Pipeliner_ZPopMin_Call

type Pipeliner_ZRandMember_Call 

type Pipeliner_ZRandMember_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRandMember_Call) Return 

func (_c *Pipeliner_ZRandMember_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRandMember_Call

func (*Pipeliner_ZRandMember_Call) Run 

func (_c *Pipeliner_ZRandMember_Call) Run(run func(ctx context.Context, key string, count int, withScores bool)) *Pipeliner_ZRandMember_Call

func (*Pipeliner_ZRandMember_Call) RunAndReturn 

func (_c *Pipeliner_ZRandMember_Call) RunAndReturn(run func(context.Context, string, int, bool) *redis.StringSliceCmd) *Pipeliner_ZRandMember_Call

type Pipeliner_ZRangeArgsWithScores_Call 

type Pipeliner_ZRangeArgsWithScores_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRangeArgsWithScores_Call) Return 

func (_c *Pipeliner_ZRangeArgsWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZRangeArgsWithScores_Call

func (*Pipeliner_ZRangeArgsWithScores_Call) Run 

func (_c *Pipeliner_ZRangeArgsWithScores_Call) Run(run func(ctx context.Context, z redis.ZRangeArgs)) *Pipeliner_ZRangeArgsWithScores_Call

func (*Pipeliner_ZRangeArgsWithScores_Call) RunAndReturn 

func (_c *Pipeliner_ZRangeArgsWithScores_Call) RunAndReturn(run func(context.Context, redis.ZRangeArgs) *redis.ZSliceCmd) *Pipeliner_ZRangeArgsWithScores_Call

type Pipeliner_ZRangeArgs_Call 

type Pipeliner_ZRangeArgs_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRangeArgs_Call) Return 

func (_c *Pipeliner_ZRangeArgs_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRangeArgs_Call

func (*Pipeliner_ZRangeArgs_Call) Run 

func (_c *Pipeliner_ZRangeArgs_Call) Run(run func(ctx context.Context, z redis.ZRangeArgs)) *Pipeliner_ZRangeArgs_Call

func (*Pipeliner_ZRangeArgs_Call) RunAndReturn 

func (_c *Pipeliner_ZRangeArgs_Call) RunAndReturn(run func(context.Context, redis.ZRangeArgs) *redis.StringSliceCmd) *Pipeliner_ZRangeArgs_Call

type Pipeliner_ZRangeByLex_Call 

type Pipeliner_ZRangeByLex_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRangeByLex_Call) Return 

func (_c *Pipeliner_ZRangeByLex_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRangeByLex_Call

func (*Pipeliner_ZRangeByLex_Call) Run 

func (_c *Pipeliner_ZRangeByLex_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *Pipeliner_ZRangeByLex_Call

func (*Pipeliner_ZRangeByLex_Call) RunAndReturn 

func (_c *Pipeliner_ZRangeByLex_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd) *Pipeliner_ZRangeByLex_Call

type Pipeliner_ZRangeByScoreWithScores_Call 

type Pipeliner_ZRangeByScoreWithScores_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRangeByScoreWithScores_Call) Return 

func (_c *Pipeliner_ZRangeByScoreWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZRangeByScoreWithScores_Call

func (*Pipeliner_ZRangeByScoreWithScores_Call) Run 

func (_c *Pipeliner_ZRangeByScoreWithScores_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *Pipeliner_ZRangeByScoreWithScores_Call

func (*Pipeliner_ZRangeByScoreWithScores_Call) RunAndReturn 

func (_c *Pipeliner_ZRangeByScoreWithScores_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.ZSliceCmd) *Pipeliner_ZRangeByScoreWithScores_Call

type Pipeliner_ZRangeByScore_Call 

type Pipeliner_ZRangeByScore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRangeByScore_Call) Return 

func (_c *Pipeliner_ZRangeByScore_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRangeByScore_Call

func (*Pipeliner_ZRangeByScore_Call) Run 

func (_c *Pipeliner_ZRangeByScore_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *Pipeliner_ZRangeByScore_Call

func (*Pipeliner_ZRangeByScore_Call) RunAndReturn 

func (_c *Pipeliner_ZRangeByScore_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd) *Pipeliner_ZRangeByScore_Call

type Pipeliner_ZRangeStore_Call 

type Pipeliner_ZRangeStore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRangeStore_Call) Return 

func (_c *Pipeliner_ZRangeStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZRangeStore_Call

func (*Pipeliner_ZRangeStore_Call) Run 

func (_c *Pipeliner_ZRangeStore_Call) Run(run func(ctx context.Context, dst string, z redis.ZRangeArgs)) *Pipeliner_ZRangeStore_Call

func (*Pipeliner_ZRangeStore_Call) RunAndReturn 

func (_c *Pipeliner_ZRangeStore_Call) RunAndReturn(run func(context.Context, string, redis.ZRangeArgs) *redis.IntCmd) *Pipeliner_ZRangeStore_Call

type Pipeliner_ZRangeWithScores_Call 

type Pipeliner_ZRangeWithScores_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRangeWithScores_Call) Return 

func (_c *Pipeliner_ZRangeWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZRangeWithScores_Call

func (*Pipeliner_ZRangeWithScores_Call) Run 

func (_c *Pipeliner_ZRangeWithScores_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Pipeliner_ZRangeWithScores_Call

func (*Pipeliner_ZRangeWithScores_Call) RunAndReturn 

func (_c *Pipeliner_ZRangeWithScores_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.ZSliceCmd) *Pipeliner_ZRangeWithScores_Call

type Pipeliner_ZRange_Call 

type Pipeliner_ZRange_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRange_Call) Return 

func (_c *Pipeliner_ZRange_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRange_Call

func (*Pipeliner_ZRange_Call) Run 

func (_c *Pipeliner_ZRange_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Pipeliner_ZRange_Call

func (*Pipeliner_ZRange_Call) RunAndReturn 

func (_c *Pipeliner_ZRange_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StringSliceCmd) *Pipeliner_ZRange_Call

type Pipeliner_ZRank_Call 

type Pipeliner_ZRank_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRank_Call) Return 

func (_c *Pipeliner_ZRank_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZRank_Call

func (*Pipeliner_ZRank_Call) Run 

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

func (*Pipeliner_ZRank_Call) RunAndReturn 

func (_c *Pipeliner_ZRank_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *Pipeliner_ZRank_Call

type Pipeliner_ZRemRangeByLex_Call 

type Pipeliner_ZRemRangeByLex_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRemRangeByLex_Call) Return 

func (_c *Pipeliner_ZRemRangeByLex_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZRemRangeByLex_Call

func (*Pipeliner_ZRemRangeByLex_Call) Run 

func (_c *Pipeliner_ZRemRangeByLex_Call) Run(run func(ctx context.Context, key string, min string, max string)) *Pipeliner_ZRemRangeByLex_Call

func (*Pipeliner_ZRemRangeByLex_Call) RunAndReturn 

func (_c *Pipeliner_ZRemRangeByLex_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *Pipeliner_ZRemRangeByLex_Call

type Pipeliner_ZRemRangeByRank_Call 

type Pipeliner_ZRemRangeByRank_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRemRangeByRank_Call) Return 

func (_c *Pipeliner_ZRemRangeByRank_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZRemRangeByRank_Call

func (*Pipeliner_ZRemRangeByRank_Call) Run 

func (_c *Pipeliner_ZRemRangeByRank_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Pipeliner_ZRemRangeByRank_Call

func (*Pipeliner_ZRemRangeByRank_Call) RunAndReturn 

func (_c *Pipeliner_ZRemRangeByRank_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.IntCmd) *Pipeliner_ZRemRangeByRank_Call

type Pipeliner_ZRemRangeByScore_Call 

type Pipeliner_ZRemRangeByScore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRemRangeByScore_Call) Return 

func (_c *Pipeliner_ZRemRangeByScore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZRemRangeByScore_Call

func (*Pipeliner_ZRemRangeByScore_Call) Run 

func (_c *Pipeliner_ZRemRangeByScore_Call) Run(run func(ctx context.Context, key string, min string, max string)) *Pipeliner_ZRemRangeByScore_Call

func (*Pipeliner_ZRemRangeByScore_Call) RunAndReturn 

func (_c *Pipeliner_ZRemRangeByScore_Call) RunAndReturn(run func(context.Context, string, string, string) *redis.IntCmd) *Pipeliner_ZRemRangeByScore_Call

type Pipeliner_ZRem_Call 

type Pipeliner_ZRem_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRem_Call) Return 

func (_c *Pipeliner_ZRem_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZRem_Call

func (*Pipeliner_ZRem_Call) Run 

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

func (*Pipeliner_ZRem_Call) RunAndReturn 

func (_c *Pipeliner_ZRem_Call) RunAndReturn(run func(context.Context, string, ...interface{}) *redis.IntCmd) *Pipeliner_ZRem_Call

type Pipeliner_ZRevRangeByLex_Call 

type Pipeliner_ZRevRangeByLex_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRevRangeByLex_Call) Return 

func (_c *Pipeliner_ZRevRangeByLex_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRevRangeByLex_Call

func (*Pipeliner_ZRevRangeByLex_Call) Run 

func (_c *Pipeliner_ZRevRangeByLex_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *Pipeliner_ZRevRangeByLex_Call

func (*Pipeliner_ZRevRangeByLex_Call) RunAndReturn 

func (_c *Pipeliner_ZRevRangeByLex_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd) *Pipeliner_ZRevRangeByLex_Call

type Pipeliner_ZRevRangeByScoreWithScores_Call 

type Pipeliner_ZRevRangeByScoreWithScores_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRevRangeByScoreWithScores_Call) Return 

func (_c *Pipeliner_ZRevRangeByScoreWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZRevRangeByScoreWithScores_Call

func (*Pipeliner_ZRevRangeByScoreWithScores_Call) Run 

func (_c *Pipeliner_ZRevRangeByScoreWithScores_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *Pipeliner_ZRevRangeByScoreWithScores_Call

func (*Pipeliner_ZRevRangeByScoreWithScores_Call) RunAndReturn 

func (_c *Pipeliner_ZRevRangeByScoreWithScores_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.ZSliceCmd) *Pipeliner_ZRevRangeByScoreWithScores_Call

type Pipeliner_ZRevRangeByScore_Call 

type Pipeliner_ZRevRangeByScore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRevRangeByScore_Call) Return 

func (_c *Pipeliner_ZRevRangeByScore_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRevRangeByScore_Call

func (*Pipeliner_ZRevRangeByScore_Call) Run 

func (_c *Pipeliner_ZRevRangeByScore_Call) Run(run func(ctx context.Context, key string, opt *redis.ZRangeBy)) *Pipeliner_ZRevRangeByScore_Call

func (*Pipeliner_ZRevRangeByScore_Call) RunAndReturn 

func (_c *Pipeliner_ZRevRangeByScore_Call) RunAndReturn(run func(context.Context, string, *redis.ZRangeBy) *redis.StringSliceCmd) *Pipeliner_ZRevRangeByScore_Call

type Pipeliner_ZRevRangeWithScores_Call 

type Pipeliner_ZRevRangeWithScores_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRevRangeWithScores_Call) Return 

func (_c *Pipeliner_ZRevRangeWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZRevRangeWithScores_Call

func (*Pipeliner_ZRevRangeWithScores_Call) Run 

func (_c *Pipeliner_ZRevRangeWithScores_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Pipeliner_ZRevRangeWithScores_Call

func (*Pipeliner_ZRevRangeWithScores_Call) RunAndReturn 

func (_c *Pipeliner_ZRevRangeWithScores_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.ZSliceCmd) *Pipeliner_ZRevRangeWithScores_Call

type Pipeliner_ZRevRange_Call 

type Pipeliner_ZRevRange_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRevRange_Call) Return 

func (_c *Pipeliner_ZRevRange_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZRevRange_Call

func (*Pipeliner_ZRevRange_Call) Run 

func (_c *Pipeliner_ZRevRange_Call) Run(run func(ctx context.Context, key string, start int64, stop int64)) *Pipeliner_ZRevRange_Call

func (*Pipeliner_ZRevRange_Call) RunAndReturn 

func (_c *Pipeliner_ZRevRange_Call) RunAndReturn(run func(context.Context, string, int64, int64) *redis.StringSliceCmd) *Pipeliner_ZRevRange_Call

type Pipeliner_ZRevRank_Call 

type Pipeliner_ZRevRank_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZRevRank_Call) Return 

func (_c *Pipeliner_ZRevRank_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZRevRank_Call

func (*Pipeliner_ZRevRank_Call) Run 

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

func (*Pipeliner_ZRevRank_Call) RunAndReturn 

func (_c *Pipeliner_ZRevRank_Call) RunAndReturn(run func(context.Context, string, string) *redis.IntCmd) *Pipeliner_ZRevRank_Call

type Pipeliner_ZScan_Call 

type Pipeliner_ZScan_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZScan_Call) Return 

func (_c *Pipeliner_ZScan_Call) Return(_a0 *redis.ScanCmd) *Pipeliner_ZScan_Call

func (*Pipeliner_ZScan_Call) Run 

func (_c *Pipeliner_ZScan_Call) Run(run func(ctx context.Context, key string, cursor uint64, match string, count int64)) *Pipeliner_ZScan_Call

func (*Pipeliner_ZScan_Call) RunAndReturn 

func (_c *Pipeliner_ZScan_Call) RunAndReturn(run func(context.Context, string, uint64, string, int64) *redis.ScanCmd) *Pipeliner_ZScan_Call

type Pipeliner_ZScore_Call 

type Pipeliner_ZScore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZScore_Call) Return 

func (_c *Pipeliner_ZScore_Call) Return(_a0 *redis.FloatCmd) *Pipeliner_ZScore_Call

func (*Pipeliner_ZScore_Call) Run 

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

func (*Pipeliner_ZScore_Call) RunAndReturn 

func (_c *Pipeliner_ZScore_Call) RunAndReturn(run func(context.Context, string, string) *redis.FloatCmd) *Pipeliner_ZScore_Call

type Pipeliner_ZUnionStore_Call 

type Pipeliner_ZUnionStore_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZUnionStore_Call) Return 

func (_c *Pipeliner_ZUnionStore_Call) Return(_a0 *redis.IntCmd) *Pipeliner_ZUnionStore_Call

func (*Pipeliner_ZUnionStore_Call) Run 

func (_c *Pipeliner_ZUnionStore_Call) Run(run func(ctx context.Context, dest string, store *redis.ZStore)) *Pipeliner_ZUnionStore_Call

func (*Pipeliner_ZUnionStore_Call) RunAndReturn 

func (_c *Pipeliner_ZUnionStore_Call) RunAndReturn(run func(context.Context, string, *redis.ZStore) *redis.IntCmd) *Pipeliner_ZUnionStore_Call

type Pipeliner_ZUnionWithScores_Call 

type Pipeliner_ZUnionWithScores_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZUnionWithScores_Call) Return 

func (_c *Pipeliner_ZUnionWithScores_Call) Return(_a0 *redis.ZSliceCmd) *Pipeliner_ZUnionWithScores_Call

func (*Pipeliner_ZUnionWithScores_Call) Run 

func (_c *Pipeliner_ZUnionWithScores_Call) Run(run func(ctx context.Context, store redis.ZStore)) *Pipeliner_ZUnionWithScores_Call

func (*Pipeliner_ZUnionWithScores_Call) RunAndReturn 

func (_c *Pipeliner_ZUnionWithScores_Call) RunAndReturn(run func(context.Context, redis.ZStore) *redis.ZSliceCmd) *Pipeliner_ZUnionWithScores_Call

type Pipeliner_ZUnion_Call 

type Pipeliner_ZUnion_Call struct {
	*mock.Call
}

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

func (*Pipeliner_ZUnion_Call) Return 

func (_c *Pipeliner_ZUnion_Call) Return(_a0 *redis.StringSliceCmd) *Pipeliner_ZUnion_Call

func (*Pipeliner_ZUnion_Call) Run 

func (_c *Pipeliner_ZUnion_Call) Run(run func(ctx context.Context, store redis.ZStore)) *Pipeliner_ZUnion_Call

func (*Pipeliner_ZUnion_Call) RunAndReturn 

func (_c *Pipeliner_ZUnion_Call) RunAndReturn(run func(context.Context, redis.ZStore) *redis.StringSliceCmd) *Pipeliner_ZUnion_Call

Source Files

View all Source files

Jump to

Keyboard shortcuts

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