Add property tests and fix bug

Author: michaelstalker

lib/pointing_party/vote_calculator.ex

@@ -19,11 +19,7 @@ defmodule PointingParty.VoteCalculator do
   end
 
   defp get_points(score_card, users) do
-    votes =
-      users
-      |> Enum.map(fn {_username, %{metas: [%{points: points}]}} ->
-        points
-      end)
+    votes = Enum.map(users, fn {_username, %{metas: [%{points: points}]}} -> points end)
 
     update_score_card(score_card, :votes, votes)
   end
@@ -57,9 +53,10 @@ defmodule PointingParty.VoteCalculator do
 
   defp handle_tie(%{majority: nil, calculated_votes: calculated_votes}) do
     calculated_votes
-    |> Enum.sort_by(&elem(&1, 1))
-    |> Enum.take(2)
+    |> Enum.sort_by(&elem(&1, 1), &>=/2)
     |> Enum.map(&elem(&1, 0))
+    |> Enum.sort()
+    |> Enum.take(2)
   end
 
   defp handle_tie(%{majority: majority}), do: majority

mix.exs

@@ -42,6 +42,7 @@ defmodule PointingParty.MixProject do
       {:jason, "~> 1.0"},
       {:plug_cowboy, "~> 2.0"},
       {:ex_machina, "~> 2.3", only: :test},
+      {:mix_test_watch, "~> 0.8", only: :dev, runtime: false},
       {:stream_data, "~> 0.1", only: :test}
     ]
   end

mix.lock

@@ -11,6 +11,7 @@
   "gettext": {:hex, :gettext, "0.17.0", "abe21542c831887a2b16f4c94556db9c421ab301aee417b7c4fbde7fbdbe01ec", [:mix], [], "hexpm"},
   "jason": {:hex, :jason, "1.1.2", "b03dedea67a99223a2eaf9f1264ce37154564de899fd3d8b9a21b1a6fd64afe7", [:mix], [{:decimal, "~> 1.0", [hex: :decimal, repo: "hexpm", optional: true]}], "hexpm"},
   "mime": {:hex, :mime, "1.3.1", "30ce04ab3175b6ad0bdce0035cba77bba68b813d523d1aac73d9781b4d193cf8", [:mix], [], "hexpm"},
+  "mix_test_watch": {:hex, :mix_test_watch, "0.9.0", "c72132a6071261893518fa08e121e911c9358713f62794a90c95db59042af375", [:mix], [{:file_system, "~> 0.2.1 or ~> 0.3", [hex: :file_system, repo: "hexpm", optional: false]}], "hexpm"},
   "phoenix": {:hex, :phoenix, "1.4.9", "746d098e10741c334d88143d3c94cab1756435f94387a63441792e66ec0ee974", [:mix], [{:jason, "~> 1.0", [hex: :jason, repo: "hexpm", optional: true]}, {:phoenix_pubsub, "~> 1.1", [hex: :phoenix_pubsub, repo: "hexpm", optional: false]}, {:plug, "~> 1.8.1 or ~> 1.9", [hex: :plug, repo: "hexpm", optional: false]}, {:plug_cowboy, "~> 1.0 or ~> 2.0", [hex: :plug_cowboy, repo: "hexpm", optional: true]}, {:telemetry, "~> 0.4", [hex: :telemetry, repo: "hexpm", optional: false]}], "hexpm"},
   "phoenix_ecto": {:hex, :phoenix_ecto, "4.0.0", "c43117a136e7399ea04ecaac73f8f23ee0ffe3e07acfcb8062fe5f4c9f0f6531", [:mix], [{:ecto, "~> 3.0", [hex: :ecto, repo: "hexpm", optional: false]}, {:phoenix_html, "~> 2.9", [hex: :phoenix_html, repo: "hexpm", optional: true]}, {:plug, "~> 1.0", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},
   "phoenix_html": {:hex, :phoenix_html, "2.13.3", "850e292ff6e204257f5f9c4c54a8cb1f6fbc16ed53d360c2b780a3d0ba333867", [:mix], [{:plug, "~> 1.5", [hex: :plug, repo: "hexpm", optional: false]}], "hexpm"},

test/pointing_party/vote_calculator_test.exs

@@ -2,81 +2,93 @@ defmodule PointingParty.VoteCalculatorTest do
   use ExUnit.Case, async: true
   use ExUnitProperties
 
-  describe "calculate_votes/1" do
-    setup do
-      points_map = fixed_map(%{points: integer(1..5)})
+  alias PointingParty.Card
+
+  # Properties
+  # --------------
+  # When there is a tie, the result will be a list
+  # The tie list will be sorted in increasing order
+  # The tie list will contain unique elements
+  # The tie list will have exactly two elements
+  # The tie list contains only integers
+  # The tie list integers must be valid voting options
+  # The greatest element in the tie list will not be greater than the highest vote
+  #
+  # When there is a winner, the result will be an integer
+  # When there is a winner, the result will be one of the valid voting options
+  # When there is a winner, it will not be greater than the highest vote
+  #
+  # Notes
+  # --------------
+  # Ties can happen when there are even or odd numbers of players
+  # Winning votes can also have an even or odd number of players
+  # Single-player games will always have a winner
 
-      metas_map =
-        fixed_map(%{
-          metas: list_of(points_map, length: 1)
-        })
 
+  describe "calculate_votes/1" do
+    setup do
+      points_map = fixed_map(%{
+        points: member_of(Card.points_range())
+      })
+      metas_map = fixed_map(%{
+        metas: list_of(points_map, length: 1)
+      })
       users = nonempty(map_of(string(:alphanumeric), metas_map))
+
       [users: users]
     end
 
-    property "winning value is a list or a integer", %{users: users} do
-      check all users <- users do
-        {_event, winner} = PointingParty.VoteCalculator.calculate_votes(users)
+    property "calculated vote is a list or an integer", %{users: users} do
+      check all users <- users,
+                {_event, winner} = PointingParty.VoteCalculator.calculate_votes(users),
+                max_runs: 20 do
         assert is_list(winner) || is_integer(winner)
       end
     end
 
-    property "tie when winning value is a list, winner when winning value is an integer", %{users: users} do
-      check all users <- users 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
-
-    property "the winning value is not more than the highest point value", %{users: users} do
-      check all users <- users do
-        {_event, winner} = PointingParty.VoteCalculator.calculate_votes(users)
-
+    property "the winning value is not more than the highest vote", %{users: users} do
+      check all users <- users,
+                max_runs: 20 do
         max_vote =
           users
           |> Enum.map(fn {_username, %{metas: [%{points: points}]}} -> points end)
           |> Enum.max()
 
-        cond do
-          is_list(winner) ->
-            assert Enum.max(winner) <= max_vote
-
-          is_integer(winner) ->
-            assert winner <= max_vote
+        case PointingParty.VoteCalculator.calculate_votes(users) do
+          {"winner", winner} -> assert winner <= max_vote
+          {"tie", [_lesser, greater]} -> assert greater <= max_vote
         end
       end
     end
 
-    property "when the winner is a list of two sorted values", %{users: users} do
-      check all users <- users do
-        {_event, winner} = PointingParty.VoteCalculator.calculate_votes(users)
-
-        if is_list(winner) do
-          assert length(winner) == 2
-
-          votes = Enum.map(users, fn {_username, %{metas: [%{points: points}]}} -> points end)
+    property "when there is a winner, calculated vote is a valid integer", %{users: users} do
+      check all users <- users,
+                {event, winner} = PointingParty.VoteCalculator.calculate_votes(users),
+                max_runs: 20 do
+        if event == "winner" do
+          assert winner in Card.points_range()
+        end
+      end
+    end
 
-          calculated_votes =
-            Enum.reduce(votes, %{}, fn vote, acc ->
-              value = (acc[vote] || 0) + 1
-              Map.put(acc, vote, value)
-            end)
+    property "when there is a tie, calculated vote is a list with two sorted values", %{users: users} do
+      check all users <- users,
+                {event, votes} = PointingParty.VoteCalculator.calculate_votes(users),
+                max_runs: 20 do
+        if event == "tie" do
+          [lesser, greater] = votes
 
-          sorted =
-            calculated_votes
-            |> Enum.sort_by(fn ({_k, v}) -> v end)
-            |> Enum.map(fn ({a, _b}) -> a end)
-            |> Enum.take(2)
+          assert lesser < greater
+        end
+      end
+    end
 
-          assert sorted == winner
+    property "when there is a tie, calculated vote is a list whose elements are valid integers", %{users: users} do
+      check all users <- users,
+                {event, votes} = PointingParty.VoteCalculator.calculate_votes(users),
+                max_runs: 20 do
+        if event == "tie" do
+          assert Enum.all?(votes, fn vote -> vote in Card.points_range() end)
         end
       end
     end