domain/tests: improve turn_order tests

1 files changed, 434 insertions, 43 deletions

diff --git a/domain/tests/turn_order.cpp b/domain/tests/turn_order.cpp
index 5bdc157..de1689c 100644
--- a/domain/tests/turn_order.cpp
+++ b/domain/tests/turn_order.cpp
@@ -1,71 +1,462 @@
 #include "turns/domain/turn_order.hpp"
 
-#include "turns/domain/participant.hpp"
-
 #include <catch2/catch_test_macros.hpp>
 
-#include <compare>
-
-#include <glibmm/init.h>
+#include <glibmm/ustring.h>
 
 namespace turns::domain::tests
 {
 
-  TEST_CASE("A freshly constructed turn order")
+  SCENARIO("Queries on a fresh turn_order instance", "[turn_order]")
   {
-    auto instance = turn_order::create();
-
-    SECTION("can be created")
+    GIVEN("an empty turn_order")
     {
-      REQUIRE(instance);
-    }
+      auto instance = turn_order::create();
 
-    SECTION("has 0 items")
-    {
-      REQUIRE(instance->size() == 0);
-    }
+      THEN("active_participant() is turn_order::invalid_participant_index")
+      {
+        REQUIRE(instance->active_participant() == turn_order::invalid_participant_index);
+      }
 
-    SECTION("accepts a new participant")
-    {
-      instance->add("River along the Field", 14, disposition::friendly);
-      REQUIRE(instance->size() == 1);
-    }
+      THEN("empty() is true")
+      {
+        REQUIRE(instance->empty());
+      }
 
-    SECTION("does nothing when trying to remove an item if no items were added beforehand")
-    {
-      instance->remove(5);
-      REQUIRE(instance->size() == 0);
-    }
+      THEN("get() returns a nullptr")
+      {
+        REQUIRE(instance->get(0) == nullptr);
+      }
 
-    SECTION("automatically sorts elements added in descending order of priority")
-    {
-      SECTION("when adding the higher one last")
+      THEN("list_model() returns a non-null pointer")
+      {
+        REQUIRE(instance->list_model());
+      }
+
+      THEN("round() returns 0")
+      {
+        REQUIRE(instance->round() == 0);
+      }
+
+      THEN("running() returns false")
+      {
+        REQUIRE_FALSE(instance->running());
+      }
+
+      THEN("size() returns 0")
+      {
+        REQUIRE(instance->size() == 0);
+      }
+
+      THEN("size() returns the same value as list_model()->get_n_item()")
+      {
+        REQUIRE(instance->size() == instance->list_model()->get_n_items());
+      }
+
+      WHEN("accessing turn_order:active-participant")
       {
-        instance->add("Tree Blossom", 6, disposition::friendly);
-        instance->add("Fish in the River", 12, disposition::friendly);
-        REQUIRE(instance->get(0)->get_name() == "Fish in the River");
+        THEN("get() returns turn_order::invalid_participant_index")
+        {
+          REQUIRE(instance->property_active_participant().get_value() == turn_order::invalid_participant_index);
+        }
+
+        THEN("get_object() returns a pointer to the instance")
+        {
+          REQUIRE(instance->property_active_participant().get_object() == instance.get());
+        }
+
+        THEN("get_name() returns \"active-participant\"")
+        {
+          REQUIRE(instance->property_active_participant().get_name() == Glib::ustring{"active-participant"});
+        }
       }
 
-      SECTION("when adding the higher one first")
+      WHEN("accessing turn_order:empty")
       {
-        instance->add("Fish in the River", 12, disposition::friendly);
-        instance->add("Tree Blossom", 6, disposition::friendly);
-        REQUIRE(instance->get(0)->get_name() == "Fish in the River");
+        THEN("get() returns true")
+        {
+          REQUIRE(instance->property_empty().get_value());
+        }
+
+        THEN("get_object() returns a pointer to the instance")
+        {
+          REQUIRE(instance->property_empty().get_object() == instance.get());
+        }
+
+        THEN("get_name() returns \"empty\"")
+        {
+          REQUIRE(instance->property_empty().get_name() == Glib::ustring{"empty"});
+        }
       }
 
-      SECTION("keeping the insertion order when adding items with equal priority")
+      WHEN("accessing turn_order:has-next")
       {
-        instance->add("Fish in the River", 6, disposition::friendly);
-        instance->add("Tree Blossom", 6, disposition::friendly);
-        REQUIRE(instance->get(0)->get_name() == "Fish in the River");
+        THEN("get() returns false")
+        {
+          REQUIRE_FALSE(instance->property_has_next().get_value());
+        }
+
+        THEN("get_object() returns a pointer to the instance")
+        {
+          REQUIRE(instance->property_has_next().get_object() == instance.get());
+        }
+
+        THEN("get_name() returns \"has-next\"")
+        {
+          REQUIRE(instance->property_has_next().get_name() == Glib::ustring{"has-next"});
+        }
+      }
+
+      WHEN("accessing turn_order:has-previous")
+      {
+        THEN("get() returns false")
+        {
+          REQUIRE_FALSE(instance->property_has_previous().get_value());
+        }
+
+        THEN("get_object() returns a pointer to the instance")
+        {
+          REQUIRE(instance->property_has_previous().get_object() == instance.get());
+        }
+
+        THEN("get_name() returns \"has-previous\"")
+        {
+          REQUIRE(instance->property_has_previous().get_name() == Glib::ustring{"has-previous"});
+        }
+      }
+
+      WHEN("accessing turn_order:running")
+      {
+        THEN("get() returns false")
+        {
+          REQUIRE_FALSE(instance->property_running().get_value());
+        }
+
+        THEN("get_object() returns a pointer to the instance")
+        {
+          REQUIRE(instance->property_running().get_object() == instance.get());
+        }
+
+        THEN("get_name() returns \"running\"")
+        {
+          REQUIRE(instance->property_running().get_name() == Glib::ustring{"running"});
+        }
+      }
+
+      WHEN("accessing turn_order:running")
+      {
+        THEN("get() returns 0")
+        {
+          REQUIRE(instance->property_round().get_value() == 0);
+        }
+
+        THEN("get_object() returns a pointer to the instance")
+        {
+          REQUIRE(instance->property_round().get_object() == instance.get());
+        }
+
+        THEN("get_name() returns \"round\"")
+        {
+          REQUIRE(instance->property_round().get_name() == Glib::ustring{"round"});
+        }
       }
     }
+  }
+
+  SCENARIO("Modification of an empty turn_order", "[turn_order]")
+  {
+    auto instance = turn_order::create();
 
-    SECTION("does not accept the same item twice by components")
+    GIVEN("a single participant was added")
     {
-      instance->add("Frozen Apple Tree", 2.1, disposition::friendly);
-      instance->add("Frozen Apple Tree", 2.1, disposition::friendly);
-      REQUIRE(instance->size() == 1);
+      auto constexpr priority = 12.0f;
+      instance->add("Participant #0", priority, disposition::friendly);
+
+      AND_GIVEN("the turn_order was never started")
+      {
+        WHEN("no other modification occurs")
+        {
+          THEN("active_participant() returns turn_order::invalid_participant_index")
+          {
+            REQUIRE(instance->active_participant() == turn_order::invalid_participant_index);
+          }
+
+          THEN("empty() returns false")
+          {
+            REQUIRE_FALSE(instance->empty());
+          }
+
+          THEN("get() returns a valid pointer for index 0")
+          {
+            REQUIRE(instance->get(0));
+          }
+
+          THEN("get() returns a nullptr for an index greater than 0")
+          {
+            REQUIRE(instance->get(1) == nullptr);
+          }
+
+          THEN("round() returns 0")
+          {
+            REQUIRE(instance->round() == 0);
+          }
+
+          THEN("running() returns false")
+          {
+            REQUIRE_FALSE(instance->running());
+          }
+
+          THEN("size() returns 1")
+          {
+            REQUIRE(instance->size() == 1);
+          }
+
+          THEN("turn_order:has-next is false")
+          {
+            REQUIRE(instance->property_has_next() == false);
+          }
+
+          THEN("turn_order:has-previous is false")
+          {
+            REQUIRE(instance->property_has_previous() == false);
+          }
+
+          THEN("turn_order:running is false")
+          {
+            REQUIRE(instance->property_running() == false);
+          }
+        }
+
+        WHEN("the participant is removed again")
+        {
+          instance->remove(0);
+
+          THEN("active_participant() returns turn_order::invalid_participant_index")
+          {
+            REQUIRE(instance->active_participant() == turn_order::invalid_participant_index);
+          }
+
+          THEN("empty() returns true")
+          {
+            REQUIRE(instance->empty());
+          }
+
+          THEN("get() returns a nullptr for index 0")
+          {
+            REQUIRE(instance->get(0) == nullptr);
+          }
+
+          THEN("round() returns 0")
+          {
+            REQUIRE(instance->round() == 0);
+          }
+
+          THEN("running() returns false")
+          {
+            REQUIRE_FALSE(instance->running());
+          }
+
+          THEN("size() returns 0")
+          {
+            REQUIRE(instance->size() == 0);
+          }
+
+          THEN("turn_order:has-next is false")
+          {
+            REQUIRE(instance->property_has_next() == false);
+          }
+
+          THEN("turn_order:has-previous is false")
+          {
+            REQUIRE(instance->property_has_previous() == false);
+          }
+
+          THEN("turn_order:running is false")
+          {
+            REQUIRE(instance->property_running() == false);
+          }
+        }
+
+        WHEN("another participant with the same priority is added")
+        {
+          instance->add("Participant #1", priority, disposition::friendly);
+
+          THEN("active_participant() returns turn_order::invalid_participant_index")
+          {
+            REQUIRE(instance->active_participant() == turn_order::invalid_participant_index);
+          }
+
+          THEN("empty() returns false")
+          {
+            REQUIRE_FALSE(instance->empty());
+          }
+
+          THEN("get() returns a valid pointer for index 0")
+          {
+            REQUIRE(instance->get(0));
+          }
+
+          THEN("get() returns a valid pointer for index 1")
+          {
+            REQUIRE(instance->get(1));
+          }
+
+          THEN("get() returns a nullptr for an index greater than 1")
+          {
+            REQUIRE(instance->get(2) == nullptr);
+          }
+
+          THEN("get(0) returns the participant that was added first")
+          {
+            REQUIRE(instance->get(0)->get_name() == "Participant #0");
+          }
+
+          THEN("get(1) returns the participant that was added second")
+          {
+            REQUIRE(instance->get(1)->get_name() == "Participant #1");
+          }
+
+          THEN("round() returns 0")
+          {
+            REQUIRE(instance->round() == 0);
+          }
+
+          THEN("running() returns false")
+          {
+            REQUIRE_FALSE(instance->running());
+          }
+
+          THEN("size() returns 2")
+          {
+            REQUIRE(instance->size() == 2);
+          }
+
+          THEN("turn_order:has-next is false")
+          {
+            REQUIRE(instance->property_has_next() == false);
+          }
+
+          THEN("turn_order:has-previous is false")
+          {
+            REQUIRE(instance->property_has_previous() == false);
+          }
+
+          THEN("turn_order:running is false")
+          {
+            REQUIRE(instance->property_running() == false);
+          }
+
+          AND_WHEN("the participant at index 0 is removed")
+          {
+            instance->remove(0);
+
+            THEN("active_participant() returns turn_order::invalid_participant_index")
+            {
+              REQUIRE(instance->active_participant() == turn_order::invalid_participant_index);
+            }
+
+            THEN("empty() returns false")
+            {
+              REQUIRE_FALSE(instance->empty());
+            }
+
+            THEN("get() returns a valid pointer for index 0")
+            {
+              REQUIRE(instance->get(0));
+            }
+
+            THEN("get() returns a nullptr for an index greater than 0")
+            {
+              REQUIRE(instance->get(1) == nullptr);
+            }
+
+            THEN("get(0) returns the participant that was added second")
+            {
+              REQUIRE(instance->get(0)->get_name() == "Participant #1");
+            }
+
+            THEN("round() returns 0")
+            {
+              REQUIRE(instance->round() == 0);
+            }
+
+            THEN("running() returns false")
+            {
+              REQUIRE_FALSE(instance->running());
+            }
+
+            THEN("size() returns 1")
+            {
+              REQUIRE(instance->size() == 1);
+            }
+
+            THEN("turn_order:has-next is false")
+            {
+              REQUIRE(instance->property_has_next() == false);
+            }
+
+            THEN("turn_order:has-previous is false")
+            {
+              REQUIRE(instance->property_has_previous() == false);
+            }
+
+            THEN("turn_order:running is false")
+            {
+              REQUIRE(instance->property_running() == false);
+            }
+          }
+
+          AND_WHEN("the turn_order is cleared")
+          {
+            instance->clear();
+
+            THEN("active_participant() returns turn_order::invalid_participant_index")
+            {
+              REQUIRE(instance->active_participant() == turn_order::invalid_participant_index);
+            }
+
+            THEN("empty() returns true")
+            {
+              REQUIRE(instance->empty());
+            }
+
+            THEN("get() returns a nullptr pointer for index 0")
+            {
+              REQUIRE(instance->get(0) == nullptr);
+            }
+
+            THEN("round() returns 0")
+            {
+              REQUIRE(instance->round() == 0);
+            }
+
+            THEN("running() returns false")
+            {
+              REQUIRE_FALSE(instance->running());
+            }
+
+            THEN("size() returns 0")
+            {
+              REQUIRE(instance->size() == 0);
+            }
+
+            THEN("turn_order:has-next is false")
+            {
+              REQUIRE(instance->property_has_next() == false);
+            }
+
+            THEN("turn_order:has-previous is false")
+            {
+              REQUIRE(instance->property_has_previous() == false);
+            }
+
+            THEN("turn_order:running is false")
+            {
+              REQUIRE(instance->property_running() == false);
+            }
+          }
+        }
+      }
     }
   }