Fixing testing over queue

Author: abmBispo

lib/elixir_queue/application.ex

@@ -14,7 +14,7 @@ defmodule ElixirQueue.Application do
       {ElixirQueue.Queue, name: ElixirQueue.Queue},
       {DynamicSupervisor, name: ElixirQueue.WorkerSupervisor, strategy: :one_for_one},
       {ElixirQueue.WorkerPool, name: ElixirQueue.WorkerPool},
-      {ElixirQueue, []}
+      {ElixirQueue.EventLoop, []}
     ]
 
     tuple = Supervisor.start_link(children, strategy: :one_for_one, name: ElixirQueue.Supervisor)

lib/elixir_queue.ex renamed to lib/elixir_queue/event_loop.ex

@@ -1,5 +1,5 @@
-defmodule ElixirQueue do
-  use Task, restart: :permanent
+defmodule ElixirQueue.EventLoop do
+  use Task, restart: :transient
 
   alias ElixirQueue.{
     Queue,

lib/elixir_queue/queue.ex

@@ -15,6 +15,7 @@ defmodule ElixirQueue.Queue do
   @doc ~S"""
   Get next job to be processed
   ## Examples
+      iex> ElixirQueue.Queue.clear()
       iex> ElixirQueue.Queue.perform_later(Enum, :reverse, [[1,2,3,4,5]])
       :ok
   """
@@ -27,6 +28,7 @@ defmodule ElixirQueue.Queue do
   @doc ~S"""
   Get next job to be processed
   ## Examples
+      iex> ElixirQueue.Queue.clear()
       iex> ElixirQueue.Queue.fetch()
       {:error, :empty}
       iex> ElixirQueue.Queue.perform_later(Enum, :reverse, [[1,2,3,4,5]])
@@ -39,17 +41,18 @@ defmodule ElixirQueue.Queue do
   @spec fetch :: {:ok, any} | {:error, :empty}
   def fetch, do: GenServer.call(Queue, :fetch)
 
+  def clear, do: GenServer.call(Queue, :clear)
+
   @impl true
-  def handle_call({:perform_later, job}, _from, queue) do
-    {:reply, :ok, Tuple.append(queue, job)}
-  end
+  def handle_call({:perform_later, job}, _from, queue),
+    do: {:reply, :ok, Tuple.append(queue, job)}
 
-  def handle_call(:fetch, _from, {}) do
-    {:reply, {:error, :empty}, {}}
-  end
+  def handle_call(:fetch, _from, {}),
+    do: {:reply, {:error, :empty}, {}}
 
-  def handle_call(:fetch, _from, queue) do
-    job = elem(queue, 0)
-    {:reply, {:ok, job}, Tuple.delete_at(queue, 0)}
-  end
+  def handle_call(:fetch, _from, queue),
+    do: {:reply, {:ok, elem(queue, 0)}, Tuple.delete_at(queue, 0)}
+
+  def handle_call(:clear, _from, _queue),
+    do: {:reply, :ok, {}}
 end

test/elixir_queue_test.exs renamed to test/elixir_queue/queue_test.exs

@@ -1,14 +1,15 @@
-defmodule ElixirQueueTest do
+defmodule ElixirQueue.QueueTest do
   use ExUnit.Case
   doctest ElixirQueue.Queue
   alias ElixirQueue.{
+    EventLoop,
     Queue,
     Job
   }
 
   setup do
-    Application.stop(:elixir_queue)
-    :ok = Application.start(:elixir_queue)
+    :ok = Queue.clear()
+    Supervisor.terminate_child(ElixirQueue.Supervisor, EventLoop)
   end
 
   test "Queue.fetch/0 with no job should get {:error, :empty}" do
@@ -19,4 +20,10 @@ defmodule ElixirQueueTest do
     assert :ok = Queue.perform_later(Enum, :reverse, [[1,2,3,4,5]])
     assert {:ok, %Job{mod: Enum, func: :reverse, args: [[1,2,3,4,5]]}} = Queue.fetch()
   end
+
+  test "Queue.clear/0 should work" do
+    assert :ok = Queue.perform_later(Enum, :reverse, [[1,2,3,4,5]])
+    assert :ok = Queue.clear()
+    assert {:error, :empty} = Queue.fetch()
+  end
 end