fix: bump to 0.3.10 for sandbox fix for smembers & sadd

Author: MikaAK

CHANGELOG.md

@@ -1,3 +1,6 @@
+# 0.3.10
+- fix: sandbox fix for smembers & sadd
+
 # 0.3.9
 - chore: add docs
 - fix: set fix

guides/how-to/testing_with_cache.md

@@ -97,85 +97,6 @@ defmodule MyApp.CacheTest do
 end
 ```
 
-## Testing with Multiple Cache Modules
-
-If your application uses multiple cache modules, register each one with the sandbox:
-
-```elixir
-setup do
-  sandbox_id = "test-#{:erlang.unique_integer([:positive])}"
-  
-  :ok = Cache.SandboxRegistry.register(MyApp.UserCache, sandbox_id)
-  :ok = Cache.SandboxRegistry.register(MyApp.SessionCache, sandbox_id)
-  
-  on_exit(fn ->
-    Cache.SandboxRegistry.unregister(MyApp.UserCache)
-    Cache.SandboxRegistry.unregister(MyApp.SessionCache)
-  end)
-  
-  :ok
-end
-```
-
-## Testing Asynchronously
-
-The sandbox functionality allows for safe asynchronous testing:
-
-```elixir
-defmodule MyApp.AsyncCacheTest do
-  use ExUnit.Case, async: true
-  
-  setup do
-    sandbox_id = "test-#{:erlang.unique_integer([:positive])}"
-    :ok = Cache.SandboxRegistry.register(MyApp.Cache, sandbox_id)
-    
-    on_exit(fn ->
-      Cache.SandboxRegistry.unregister(MyApp.Cache)
-    end)
-    
-    :ok
-  end
-  
-  # Tests run in parallel without interfering with each other
-  test "first test" do
-    assert :ok = MyApp.Cache.put("key-1", "value-1")
-    assert {:ok, "value-1"} = MyApp.Cache.get("key-1")
-    assert {:ok, nil} = MyApp.Cache.get("key-2") # Doesn't see other test's data
-  end
-  
-  test "second test" do
-    assert :ok = MyApp.Cache.put("key-2", "value-2")
-    assert {:ok, "value-2"} = MyApp.Cache.get("key-2")
-    assert {:ok, nil} = MyApp.Cache.get("key-1") # Doesn't see other test's data
-  end
-end
-```
-
-## Mocking Cache Interactions
-
-For unit tests where you want to mock the cache entirely:
-
-```elixir
-defmodule MyApp.ServiceTest do
-  use ExUnit.Case
-  import Mox
-  
-  # Define a mock for your cache
-  defmock(MockCache, for: MyApp.CacheBehaviour)
-  
-  setup :verify_on_exit!
-  
-  test "service uses cache correctly" do
-    # Set up expectations for the mock
-    expect(MockCache, :get, fn "user:1" -> {:ok, %{name: "Test User"}} end)
-    expect(MockCache, :put, fn "user:1", _ttl, _data -> :ok end)
-    
-    # Test your service that uses the cache
-    result = MyApp.Service.update_user(1, %{name: "Updated User"})
-    assert result == :ok
-  end
-end
-```
 
 ## Tips for Testing with ElixirCache
 

lib/cache/redis.ex

@@ -24,25 +24,25 @@ defmodule Cache.Redis do
 
   @moduledoc """
   Redis adapter for distributed caching with ElixirCache.
-  
+
   This adapter provides a connection pool to Redis, enabling distributed caching
   across multiple nodes or services. It supports the standard Cache behavior plus
   additional Redis-specific operations like hash manipulation, JSON operations, and sets.
-  
+
   ## Features
-  
+
   * Connection pooling for efficient Redis access
   * Support for Redis URI connection strings
   * Hash operations for storing field-value pairs within a key
   * JSON operations for working with complex nested data structures
   * Set operations for managing collections
   * Direct access to Redis commands via pipeline and command functions
-  
+
   ## Options
   #{NimbleOptions.docs(@opts_definition)}
-  
+
   ## Example
-  
+
   ```elixir
   defmodule MyApp.RedisCache do
     use Cache,

lib/cache/sandbox.ex

@@ -1,23 +1,23 @@
 defmodule Cache.Sandbox do
   @moduledoc """
   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:
-  
+
   ```elixir
   defmodule MyApp.TestCache do
     use Cache,
@@ -27,10 +27,10 @@ defmodule Cache.Sandbox do
       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.
   """
 
@@ -333,6 +333,14 @@ defmodule Cache.Sandbox do
     raise "Not Implemented"
   end
 
+  def smembers(_cache_name, _key, _opts \\ []) do
+    raise "Not Implemented"
+  end
+
+  def sadd(_cache_name, _key, _value, _opts \\ []) do
+    raise "Not Implemented"
+  end
+
   defp put_hash_field_values(state, key, fields_values) do
     Map.update(
       state,

mix.exs

@@ -4,7 +4,7 @@ defmodule ElixirCache.MixProject do
   def project do
     [
       app: :elixir_cache,
-      version: "0.3.9",
+      version: "0.3.10",
       elixir: "~> 1.11",
       start_permanent: Mix.env() == :prod,
       description: "Standardized and testable caching across your app. In test caches are isolated.",