Refactor tests

Author: antonmi

loop_test.sh

@@ -1 +1,2 @@
+rm -rf _build
 for i in {1..1000}; do mix test; done

test/crash_test.exs

@@ -1,5 +1,6 @@
 defmodule Strom.CrashTest do
   use ExUnit.Case, async: false
+  import Strom.TestHelper
 
   alias Strom.{Source, Source.ReadLines, Sink}
   alias Strom.{Transformer, Splitter}
@@ -25,23 +26,6 @@ defmodule Strom.CrashTest do
     end
   end
 
-  def build_stream(list, sleep \\ 0) do
-    {:ok, agent} = Agent.start_link(fn -> list end)
-
-    Stream.resource(
-      fn -> agent end,
-      fn agent ->
-        Process.sleep(sleep)
-
-        Agent.get_and_update(agent, fn
-          [] -> {{:halt, agent}, []}
-          [datum | data] -> {{[datum], agent}, data}
-        end)
-      end,
-      fn agent -> agent end
-    )
-  end
-
   describe "crash in transformer" do
     setup do
       %{stream: build_stream([1, 2, 3, 4, 5])}
@@ -214,14 +198,6 @@ defmodule Strom.CrashTest do
     end
   end
 
-  defp wait_for_dying(pid) do
-    if Process.alive?(pid) do
-      wait_for_dying(pid)
-    else
-      true
-    end
-  end
-
   describe "crash in splitter" do
     setup do
       %{stream: build_stream([1, 2, 3, 4, 5, 6], 1)}

test/gen_mix_test.exs

@@ -1,11 +1,11 @@
 defmodule Strom.GenMixTest do
   use ExUnit.Case, async: true
-
+  import Strom.TestHelper
   alias Strom.GenMix
 
   @moduletag timeout: 5000
 
-  def build_stream(list, sleep \\ 0) do
+  def build_list_stream(list, sleep \\ 0) do
     Stream.resource(
       fn -> list end,
       fn
@@ -28,7 +28,7 @@ defmodule Strom.GenMixTest do
   end
 
   test "start and stop with simple stream" do
-    stream = build_stream(Enum.to_list(1..10), 0)
+    stream = build_list_stream(Enum.to_list(1..10), 0)
     gen_mix = GenMix.start(%GenMix{inputs: [:stream], outputs: %{stream: & &1}, opts: [chunk: 1]})
     %{stream: stream} = GenMix.call(%{stream: stream}, gen_mix)
     task = Task.async(fn -> Enum.to_list(stream) end)
@@ -43,7 +43,7 @@ defmodule Strom.GenMixTest do
 
     flow =
       Enum.reduce(stream_names, %{}, fn name, acc ->
-        Map.put(acc, name, build_stream(Enum.to_list(1..max), 0))
+        Map.put(acc, name, build_list_stream(Enum.to_list(1..max), 0))
       end)
 
     outputs =
@@ -64,20 +64,12 @@ defmodule Strom.GenMixTest do
       |> Task.await_many()
       |> List.flatten()
 
-    assert length(numbers) == 10000
+    assert length(numbers) == 10_000
 
     :ok = GenMix.stop(gen_mix)
     assert wait_for_dying(gen_mix.pid)
   end
 
-  defp wait_for_dying(pid) do
-    if Process.alive?(pid) do
-      wait_for_dying(pid)
-    else
-      true
-    end
-  end
-
   test "call one by one" do
     flow = %{numbers1: [1, 2, 3, 4, 5], numbers2: [6, 7, 8, 9, 10], numbers3: [0, 0, 0, 0, 0]}
 
@@ -248,8 +240,8 @@ defmodule Strom.GenMixTest do
   end
 
   test "two streams with different rates, be sure that quick stream doesn't block the slow one" do
-    quick = build_stream(List.duplicate([101], 10000), 0)
-    slow = build_stream(Enum.to_list(1..10), 1)
+    quick = build_list_stream(List.duplicate([101], 10_000), 0)
+    slow = build_list_stream(Enum.to_list(1..10), 1)
 
     outputs = %{
       quick: fn n -> n > 10 end,

test/replace_test.exs

@@ -1,28 +1,11 @@
 defmodule Strom.ReplaceTest do
   use ExUnit.Case, async: false
-
+  import Strom.TestHelper
   alias Strom.Transformer
   alias Strom.Composite
 
   @moduletag timeout: 10_000
 
-  def build_stream(list, sleep \\ 0) do
-    {:ok, agent} = Agent.start_link(fn -> list end)
-
-    Stream.resource(
-      fn -> agent end,
-      fn agent ->
-        Process.sleep(sleep)
-
-        Agent.get_and_update(agent, fn
-          [] -> {{:halt, agent}, []}
-          [datum | data] -> {{[datum], agent}, data}
-        end)
-      end,
-      fn agent -> agent end
-    )
-  end
-
   describe "delete components" do
     test "delete one transformer" do
       stream = build_stream(Enum.to_list(1001..1020), 1)
@@ -108,16 +91,15 @@ defmodule Strom.ReplaceTest do
       list3 = Task.await(task3)
 
       Composite.stop(composite)
-      # one event can be lost, I'll address this later
       assert length(list1) == 10_000
-      # assert [10_011 | _] = list1
-      # assert [20_000 | _] = Enum.reverse(list1)
+      assert [10_011 | _] = list1
+      assert [20_000 | _] = Enum.reverse(list1)
       assert length(list2) == 10_000
-      # assert [20_011 | _] = list2
-      # assert [30_000 | _] = Enum.reverse(list2)
+      assert [20_011 | _] = list2
+      assert [30_000 | _] = Enum.reverse(list2)
       assert length(list3) == 10_000
-      # assert [30_011 | _] = list3
-      # assert [40_000 | _] = Enum.reverse(list3)
+      assert [30_011 | _] = list3
+      assert [40_000 | _] = Enum.reverse(list3)
     end
 
     test "delete two transformers" do
@@ -200,14 +182,6 @@ defmodule Strom.ReplaceTest do
       Composite.stop(composite)
     end
 
-    defp wait_for_dying(pid) do
-      if Process.alive?(pid) do
-        wait_for_dying(pid)
-      else
-        true
-      end
-    end
-
     # test "when there are two streams" do
     #   # TODO
     # end

test/sink_test.exs

@@ -1,5 +1,6 @@
 defmodule Strom.SinkTest do
   use ExUnit.Case, async: true
+  import Strom.TestHelper
   doctest Strom.Sink
 
   alias Strom.Source
@@ -80,12 +81,4 @@ defmodule Strom.SinkTest do
       assert wait_for_dying(agent)
     end
   end
-
-  defp wait_for_dying(pid) do
-    if Process.alive?(pid) do
-      wait_for_dying(pid)
-    else
-      true
-    end
-  end
 end

test/source_test.exs

@@ -1,7 +1,7 @@
 defmodule Strom.SourceTest do
   use ExUnit.Case, async: true
   doctest Strom.Source
-
+  import Strom.TestHelper
   alias Strom.Source
   alias Strom.Source.ReadLines
 
@@ -128,12 +128,4 @@ defmodule Strom.SourceTest do
       assert wait_for_dying(agent)
     end
   end
-
-  defp wait_for_dying(pid) do
-    if Process.alive?(pid) do
-      wait_for_dying(pid)
-    else
-      true
-    end
-  end
 end

test/test_helper.exs

@@ -1 +1,28 @@
 ExUnit.start()
+
+defmodule Strom.TestHelper do
+  def build_stream(list, sleep \\ 0) do
+    {:ok, agent} = Agent.start_link(fn -> list end)
+
+    Stream.resource(
+      fn -> agent end,
+      fn agent ->
+        Process.sleep(sleep)
+
+        Agent.get_and_update(agent, fn
+          [] -> {{:halt, agent}, []}
+          [datum | data] -> {{[datum], agent}, data}
+        end)
+      end,
+      fn agent -> agent end
+    )
+  end
+
+  def wait_for_dying(pid) do
+    if Process.alive?(pid) do
+      wait_for_dying(pid)
+    else
+      true
+    end
+  end
+end

test/transformer_test.exs

@@ -1,26 +1,10 @@
 defmodule Strom.TransformerTest do
   use ExUnit.Case, async: true
+  import Strom.TestHelper
   doctest Strom.Transformer
 
   alias Strom.Transformer
 
-  def build_stream(list, sleep \\ 0) do
-    {:ok, agent} = Agent.start_link(fn -> list end)
-
-    Stream.resource(
-      fn -> agent end,
-      fn agent ->
-        Process.sleep(sleep)
-
-        Agent.get_and_update(agent, fn
-          [] -> {{:halt, agent}, []}
-          [datum | data] -> {{[datum], agent}, data}
-        end)
-      end,
-      fn agent -> agent end
-    )
-  end
-
   test "start and stop" do
     transformer =
       :stream