FauxRedis.Store (faux_redis v1.0.3)

In-memory, process-local data store that approximates a subset of Redis semantics sufficient for most integration tests.

This module is not intended to be a full, production-ready Redis implementation – correctness and testability are prioritised over complete feature parity.

Summary

Types

t()

Internal representation of the store.

value()

Functions

decr(store, key)

del(store, keys)

exists(store, keys)

expire(store, key, seconds)

get(store, key)

hget(store, key, field)

hgetall(store, key)

hset(store, key, field, value)

incr(store, key)

lpop(store, key)

lpush(store, key, values)

mget(store, keys)

mset(store, pairs)

new()

reset(store)

rpop(store, key)

rpush(store, key, values)

sadd(store, key, members)

scan(store, pattern, count)

scard(store, key)

set(store, key, value)

sismember(store, key, member)

smembers(store, key)

srem(store, key, members)

sscan(store, key, cursor, count)

system_now()

ttl(store, key)

Types

t()

@type t() :: %FauxRedis.Store{
  kv: %{required(binary()) => value()},
  now_fn: (-> integer()),
  ttl: %{required(binary()) => integer()}
}

Internal representation of the store.

value()

@type value() ::
  binary()
  | integer()
  | {:hash, %{required(binary()) => binary()}}
  | {:set, MapSet.t(binary())}
  | {:list, [binary()]}

Functions

decr(store, key)

@spec decr(t(), binary()) :: {t(), integer()}

del(store, keys)

@spec del(t(), [binary()]) :: {t(), non_neg_integer()}

exists(store, keys)

@spec exists(t(), [binary()]) :: {t(), non_neg_integer()}

expire(store, key, seconds)

@spec expire(t(), binary(), integer()) :: {t(), 0 | 1}

get(store, key)

@spec get(t(), binary()) :: {t(), nil | binary()}

hget(store, key, field)

@spec hget(t(), binary(), binary()) :: {t(), nil | binary()}

hgetall(store, key)

@spec hgetall(t(), binary()) :: {t(), [binary()]}

hset(store, key, field, value)

@spec hset(t(), binary(), binary(), binary()) :: {t(), 0 | 1}

incr(store, key)

@spec incr(t(), binary()) :: {t(), integer()}

lpop(store, key)

@spec lpop(t(), binary()) :: {t(), nil | binary()}

lpush(store, key, values)

@spec lpush(t(), binary(), [binary()]) :: {t(), non_neg_integer()}

mget(store, keys)

@spec mget(t(), [binary()]) :: {t(), [nil | binary()]}

mset(store, pairs)

@spec mset(t(), [{binary(), binary()}]) :: t()

new()

@spec new() :: t()

reset(store)

@spec reset(t()) :: t()

rpop(store, key)

@spec rpop(t(), binary()) :: {t(), nil | binary()}

rpush(store, key, values)

@spec rpush(t(), binary(), [binary()]) :: {t(), non_neg_integer()}

sadd(store, key, members)

@spec sadd(t(), binary(), [binary()]) :: {t(), non_neg_integer()}

scan(store, pattern, count)

@spec scan(t(), binary(), non_neg_integer()) :: {t(), {binary(), [binary()]}}

scard(store, key)

@spec scard(t(), binary()) :: {t(), non_neg_integer() | {:error, binary()}}

set(store, key, value)

@spec set(t(), binary(), binary()) :: t()

sismember(store, key, member)

@spec sismember(t(), binary(), binary()) :: {t(), 0 | 1}

smembers(store, key)

@spec smembers(t(), binary()) :: {t(), [binary()]}

srem(store, key, members)

@spec srem(t(), binary(), [binary()]) :: {t(), non_neg_integer()}

sscan(store, key, cursor, count)

@spec sscan(t(), binary(), binary(), non_neg_integer()) ::
  {t(), {binary(), [binary()]}}

system_now()

@spec system_now() :: integer()

ttl(store, key)

@spec ttl(t(), binary()) :: {t(), integer()}