[#3] Nebulex.Adapter.Transaction behaviour

[#5] `Nebulex.Adapter.Persistence` behaviour

Author: cabol

lib/nebulex/adapters/cachex.ex

@@ -6,10 +6,15 @@ defmodule Nebulex.Adapters.Cachex do
   # Provide Cache Implementation
   @behaviour Nebulex.Adapter
   @behaviour Nebulex.Adapter.Queryable
+  @behaviour Nebulex.Adapter.Persistence
+
+  # Inherit default transaction implementation
+  use Nebulex.Adapter.Transaction
 
   import Nebulex.Helpers
 
   alias Cachex.Query
+  alias Nebulex.Entry
 
   @compile {:inline, to_ttl: 1}
 
@@ -178,12 +183,49 @@ defmodule Nebulex.Adapters.Cachex do
   end
 
   def stream(%{name: name}, query, opts) do
-    Cachex.stream!(name, query, batch_size: opts[:page_size] || 100)
+    query = maybe_return_entry(query, opts[:return])
+    Cachex.stream!(name, query, batch_size: opts[:page_size] || 20)
   rescue
     e in Cachex.ExecutionError ->
       reraise Nebulex.QueryError, [message: e.message, query: query], __STACKTRACE__
   end
 
+  defp maybe_return_entry([{pattern, conds, _ret}], :key) do
+    [{pattern, conds, [:"$1"]}]
+  end
+
+  defp maybe_return_entry([{pattern, conds, _ret}], :value) do
+    [{pattern, conds, [:"$4"]}]
+  end
+
+  defp maybe_return_entry([{pattern, conds, _ret}], {:key, :value}) do
+    [{pattern, conds, [{{:"$1", :"$4"}}]}]
+  end
+
+  defp maybe_return_entry([{pattern, conds, _ret}], :entry) do
+    [{pattern, conds, [%Entry{key: :"$1", value: :"$4", touched: :"$2", ttl: :"$3"}]}]
+  end
+
+  defp maybe_return_entry(query, _return), do: query
+
+  ## Persistence
+
+  @impl true
+  def dump(%{name: name}, path, opts) do
+    case Cachex.dump(name, path, opts) do
+      {:ok, true} -> :ok
+      {:error, _} = error -> error
+    end
+  end
+
+  @impl true
+  def load(%{name: name}, path, opts) do
+    case Cachex.load(name, path, opts) do
+      {:ok, true} -> :ok
+      {:error, _} = error -> error
+    end
+  end
+
   ## Private Functions
 
   defp to_ttl(:infinity), do: nil

test/shared/cachex_test.exs

@@ -7,7 +7,10 @@ defmodule Nebulex.Adapters.CachexTest do
     quote do
       use Nebulex.Cache.EntryTest
       use Nebulex.Cache.EntryExpirationTest
+      use Nebulex.Cache.TransactionTest
+      use Nebulex.Cache.PersistenceTest
       use Nebulex.Adapters.Cachex.QueryableTest
+      use Nebulex.Adapters.Cachex.PersistenceErrorTest
     end
   end
 end

test/shared/persistence_error_test.exs

@@ -0,0 +1,15 @@
+defmodule Nebulex.Adapters.Cachex.PersistenceErrorTest do
+  import Nebulex.CacheCase
+
+  deftests "persistence error" do
+    test "dump: invalid path", %{cache: cache} do
+      assert {:error, reason} = cache.dump("/invalid/path")
+      assert reason in [:unreachable_file, :enoent]
+    end
+
+    test "load: invalid path", %{cache: cache} do
+      assert {:error, reason} = cache.load("wrong_file")
+      assert reason in [:unreachable_file, :enoent]
+    end
+  end
+end

test/shared/queryable_test.exs

@@ -1,49 +1,84 @@
 defmodule Nebulex.Adapters.Cachex.QueryableTest do
   import Nebulex.CacheCase
 
-  deftests "queryable" do
+  deftests do
     import Nebulex.CacheHelpers
 
     alias Cachex.Query
 
-    test "all", %{cache: cache} do
-      set1 = cache_put(cache, 1..50)
-      set2 = cache_put(cache, 51..100)
+    describe "all" do
+      test "returns all keys in cache", %{cache: cache} do
+        set1 = cache_put(cache, 1..50)
+        set2 = cache_put(cache, 51..100)
 
-      for x <- 1..100, do: assert(cache.get(x) == x)
-      expected = set1 ++ set2
+        for x <- 1..100, do: assert(cache.get(x) == x)
+        expected = set1 ++ set2
 
-      assert :lists.usort(cache.all()) == expected
+        assert :lists.usort(cache.all()) == expected
 
-      set3 = Enum.to_list(20..60)
-      :ok = Enum.each(set3, &cache.delete(&1))
-      expected = :lists.usort(expected -- set3)
+        set3 = Enum.to_list(20..60)
+        :ok = Enum.each(set3, &cache.delete(&1))
+        expected = :lists.usort(expected -- set3)
 
-      assert :lists.usort(cache.all()) == expected
+        assert :lists.usort(cache.all()) == expected
+      end
     end
 
-    test "stream", %{cache: cache} do
-      entries = for x <- 1..10, into: %{}, do: {x, x * 2}
-      assert cache.put_all(entries) == :ok
+    describe "stream" do
+      @entries for x <- 1..10, into: %{}, do: {x, x * 2}
+
+      test "returns all keys in cache", %{cache: cache} do
+        :ok = cache.put_all(@entries)
+
+        assert nil
+               |> cache.stream()
+               |> Enum.to_list()
+               |> :lists.usort() == Map.keys(@entries)
+      end
+
+      test "returns all values in cache", %{cache: cache} do
+        :ok = cache.put_all(@entries)
 
-      expected = Map.keys(entries)
+        assert true
+               |> Query.create(:key)
+               |> cache.stream(return: :value, page_size: 3)
+               |> Enum.to_list()
+               |> :lists.usort() == Map.values(@entries)
+      end
 
-      assert true
-             |> Query.create(:key)
-             |> cache.stream()
-             |> Enum.to_list()
-             |> :lists.usort() == expected
+      test "returns all key/value pairs in cache", %{cache: cache} do
+        :ok = cache.put_all(@entries)
 
-      assert true
-             |> Query.create(:key)
-             |> cache.stream(page_size: 3)
-             |> Enum.to_list()
-             |> :lists.usort() == expected
+        assert true
+               |> Query.create(:key)
+               |> cache.stream(return: {:key, :value}, page_size: 3)
+               |> Enum.to_list()
+               |> :lists.usort() == :maps.to_list(@entries)
+      end
+
+      test "returns what is dictated by the built query", %{cache: cache} do
+        :ok = cache.put_all(@entries)
+
+        expected =
+          :lists.zip3(
+            Map.keys(@entries),
+            Map.values(@entries),
+            List.duplicate(nil, map_size(@entries))
+          )
+
+        assert true
+               |> Query.create({:key, :value, :ttl})
+               |> cache.stream(page_size: 3)
+               |> Enum.to_list()
+               |> :lists.usort() == expected
+      end
 
-      assert_raise Nebulex.QueryError, fn ->
-        :invalid_query
-        |> cache.stream()
-        |> Enum.to_list()
+      test "raises when query is invalid", %{cache: cache} do
+        assert_raise Nebulex.QueryError, fn ->
+          :invalid_query
+          |> cache.stream()
+          |> Enum.to_list()
+        end
       end
     end
   end

test_cache

@@ -0,0 +1 @@
+�j