Cache.Sandbox (elixir_cache v0.4.5)

View Source

Sandbox adapter for isolated testing of applications using ElixirCache.

This module provides a mock implementation of all cache adapters, allowing tests to run in isolation without interfering with each other's data. The sandbox uses a basic Agent to store data in memory and implements the full range of caching operations supported by all adapters.

Features

  • Isolated cache namespaces for concurrent testing
  • Support for all standard cache operations
  • Implementation of Redis-specific features like hash and JSON operations
  • Implementation of ETS-specific operations for complete testing compatibility
  • Lightweight in-memory storage for fast test execution

Usage

The Sandbox adapter is typically enabled through the sandbox? option when defining a cache module:

defmodule MyApp.TestCache do
  use Cache,
    adapter: Cache.Redis,  # Original adapter doesn't matter when sandbox is enabled
    name: :test_cache,
    opts: [],
    sandbox?: Mix.env() == :test
end

In your tests, use Cache.SandboxRegistry.start(MyApp.TestCache) in the setup block to ensure proper isolation between test cases.

Note: This adapter should not be used in production environments.

Summary

Functions

Returns a specification to start this module under a supervisor.

Functions

all()

bchunk(cache_name, continuation)

child_spec(arg)

Returns a specification to start this module under a supervisor.

See Supervisor.

close(cache_name)

command(cache_name, command, opts)

command!(cache_name, command, opts)

delete_all_objects(cache_name)

delete_object(cache_name, object)

delete_table(cache_name)

dirty_get_or_store(cache_name, key, store_fun)

file2tab(filename)

file2tab(filename, options)

first(cache_name)

first_lookup(cache_name)

foldl(cache_name, function, acc)

foldr(cache_name, function, acc)

from_dets(cache_name, dets_table)

from_ets(cache_name, ets_table)

get_or_store(cache_name, key, ttl, store_fun)

give_away(cache_name, pid, gift_data)

hash_delete(cache_name, key, hash_key, opts)

hash_get(cache_name, key, hash_key, opts)

hash_get_all(cache_name, key, opts)

hash_get_many(cache_name, keys_fields, opts)

hash_scan(cache_name, key, scan_opts, opts)

hash_set(cache_name, key, field, value, ttl, opts)

hash_set_many(cache_name, keys_fields_values, ttl, opts)

hash_values(cache_name, key, opts)

info(cache_name)

info(cache_name, item)

init_table(cache_name, init_fun)

insert_new(cache_name, data)

insert_raw(cache_name, data)

is_compatible_bchunk_format(cache_name, bchunk_format)

is_compiled_ms(term)

is_dets_file(filename)

json_array_append(cache_name, key, path, values, opts)

json_clear(cache_name, key, path, opts)

json_delete(cache_name, key, path, opts)

json_get(cache_name, key, path, opts)

json_incr(cache_name, key, path, incr \\ 1, opts)

json_set(cache_name, key, path, value, opts)

last(cache_name)

last_lookup(cache_name)

lookup(cache_name, key)

lookup_element(cache_name, key, pos)

lookup_element(cache_name, key, pos, default)

match_delete(cache_name, pattern)

match_object(cache_name, pattern)

match_object(cache_name, pattern, limit)

match_pattern(cache_name, pattern)

match_pattern(cache_name, pattern, limit)

match_spec_compile(match_spec)

match_spec_run(list, compiled_match_spec)

member(cache_name, key)

next(cache_name, key)

next_lookup(cache_name, key)

open_file(filename)

open_file(name, args)

pid2name(pid)

pipeline(cache_name, commands, opts)

pipeline!(cache_name, commands, opts)

prev(cache_name, key)

prev_lookup(cache_name, key)

rename(cache_name, name)

repair_continuation(continuation, match_spec)

sadd(cache_name, key, value, opts)

safe_fixtable(cache_name, fix)

scan(cache_name, scan_opts, opts)

select(cache_name, match_spec)

select(cache_name, match_spec, limit)

select_count(cache_name, match_spec)

select_delete(cache_name, match_spec)

select_replace(cache_name, match_spec)

select_reverse(cache_name, match_spec)

select_reverse(cache_name, match_spec, limit)

setopts(cache_name, opts)

slot(cache_name, i)

smembers(cache_name, key, opts)

sync(cache_name)

tab2file(cache_name, filename)

tab2file(cache_name, filename, options)

tab2list(cache_name)

tabfile_info(filename)

table(cache_name)

table(cache_name, options)

take(cache_name, key)

test_ms(tuple, match_spec)

to_dets(cache_name, dets_table)

to_ets(cache_name)

to_ets(cache_name, ets_table)

traverse(cache_name, fun)

update_counter(cache_name, key, incr)

update_counter(cache_name, key, update_op, default)

update_element(cache_name, key, element_spec)

update_element(cache_name, key, element_spec, default)

whereis(cache_name)