stream data tests

Author: SophieDeBenedetto

lib/pointing_party/vote_calculator.ex

@@ -1,4 +1,12 @@
 defmodule PointingParty.VoteCalculator do
+
+  def calculate_votes(users) do
+    case winning_vote(users) do
+      top_two when is_list(top_two) -> {"tie", top_two}
+      winner -> {"winner", winner}
+    end
+  end
+
   def winning_vote(users) do
     votes = Enum.map(users, fn {_username, %{metas: [%{points: points}]}} -> points end)
     calculated_votes = Enum.reduce(votes, %{}, fn vote, acc ->

lib/pointing_party_web/channels/room_channel.ex

@@ -57,12 +57,7 @@ defmodule PointingPartyWeb.RoomChannel do
   defp finalize_voting(socket) do
     current_users = Presence.list(socket)
 
-    {event, points} =
-      case VoteCalculator.winning_vote(current_users) do
-        top_two when is_list(top_two) -> {"tie", top_two}
-        winner -> {"winner", winner}
-      end
-
+    {event, points} = VoteCalculator.calculate_votes(current_users)
     broadcast!(socket, event, %{points: points})
   end
 

test/pointing_party/vote_calculator_test.exs

@@ -2,24 +2,66 @@ defmodule PointingParty.VoteCalculatorTest do
   use ExUnit.Case, async: true
   use ExUnitProperties
 
-  @users %{
-    "sean" => %{metas: [%{points: 1}]},
-    "michael" => %{metas: [%{points: 3}]},
-    "sophie" => %{metas: [%{points: 3}]}
-  }
-
-  describe "winning_vote/1" do
-    test "calculates the card estimate from the votes" do
-      # check all str <- string(:printable),
-      #           times <- integer(),
-      #           times >= 0 do
-      #   new_string = Repeater.duplicate(str, times)
-
-      check all users <- map_of(string(:printable), StreamData.fixed_map(%{
-        metas: list_of(StreamData.fixed_map(%{points: integer()})),
-      })) do
-        winning = PointingParty.VoteCalculator.winning_vote(users)
-        assert winning
+  describe "calculate_votes/1" do
+    setup do
+      points_map = StreamData.fixed_map(%{points: integer(1..5)})
+      metas_map  = StreamData.fixed_map(%{
+        metas: list_of(points_map, length: 1),
+      })
+      user = nonempty(map_of(string(:printable), metas_map))
+      [user: user]
+    end
+
+    test "winning value is a list or a integer", %{user: user} do
+      check all users <- user do
+        {_event, winner} = PointingParty.VoteCalculator.calculate_votes(users)
+        assert is_list(winner) || is_integer(winner)
+      end
+    end
+
+    test "tie when winning value is a list, winner when winning value is an integer", %{user: user} do
+      check all users <- user do
+        {event, winner} = PointingParty.VoteCalculator.calculate_votes(users)
+        cond do
+          is_list(winner) ->
+            assert event == "tie"
+          is_integer(winner) ->
+            assert event == "winner"
+        end
+      end
+    end
+
+    test "the winning value is not more than the highest point value", %{user: user} do
+      check all users <- user do
+        {_event, winner} = PointingParty.VoteCalculator.calculate_votes(users)
+
+        max_vote = users
+        |> Enum.map(fn {_username, %{metas: [%{points: points}]}} -> points end)
+        |> Enum.max()
+
+        cond do
+          is_list(winner) ->
+            winner
+            |> Enum.max()
+            winner <= max_vote
+          is_integer(winner) ->
+            winner <= max_vote
+        end
+      end
+    end
+
+    test "when the winner is a list of two sorted values", %{user: user} do
+      check all users <- user do
+        {_event, winner} = PointingParty.VoteCalculator.calculate_votes(users)
+        if is_list(winner) do
+          length = winner
+          |> length
+          assert length == 2
+
+          sorted = winner
+          |> Enum.sort()
+          assert sorted = winner
+        end
       end
     end
   end