Added global-hooks-afterall-error, global-hooks-attachments, global-hooks-beforeall-error, hooks, hooks-attachment and hooks-conditional compatibility tests

Author: daantimmer

compatibility/compatibility.cpp

@@ -209,7 +209,19 @@ namespace compatibility
 
             void CompareEnvelopes()
             {
-                ASSERT_THAT(actualEnvelopes.size(), testing::Eq(expectedEnvelopes.size()));
+                EXPECT_THAT(actualEnvelopes.size(), testing::Eq(expectedEnvelopes.size()));
+
+                for (auto& json : actualEnvelopes)
+                {
+                    SanitizeActualJson(json);
+                    actualOfs << json.dump() << "\n";
+                }
+
+                for (auto& json : expectedEnvelopes)
+                {
+                    SanitizeExpectedJson(json);
+                    expectedOfs << json.dump() << "\n";
+                }
 
                 while (!actualEnvelopes.empty() && !expectedEnvelopes.empty())
                 {
@@ -219,12 +231,6 @@ namespace compatibility
                     auto expectedJson = expectedEnvelopes.front();
                     expectedEnvelopes.pop_front();
 
-                    SanitizeActualJson(actualJson);
-                    SanitizeExpectedJson(expectedJson);
-
-                    expectedOfs << expectedJson.dump() << "\n";
-                    actualOfs << actualJson.dump() << "\n";
-
                     EXPECT_THAT(actualJson, testing::Eq(expectedJson));
                 }
             }

compatibility/global-hooks-afterall-error/global-hooks-afterall-error.cpp

@@ -0,0 +1,32 @@
+#include "cucumber_cpp/CucumberCpp.hpp"
+#include <gmock/gmock.h>
+
+HOOK_BEFORE_ALL()
+{
+    // no-op
+}
+
+HOOK_BEFORE_ALL()
+{
+    // no-op
+}
+
+WHEN(R"(a step passes)")
+{
+    // no-op
+}
+
+HOOK_AFTER_ALL()
+{
+    // no-op
+}
+
+HOOK_AFTER_ALL()
+{
+    ASSERT_THAT(true, false);
+}
+
+HOOK_AFTER_ALL()
+{
+    // no-op
+}

compatibility/global-hooks-attachments/global-hooks-attachments.cpp

@@ -0,0 +1,17 @@
+#include "cucumber_cpp/CucumberCpp.hpp"
+#include <gmock/gmock.h>
+
+HOOK_BEFORE_ALL()
+{
+    Attach("Attachment from BeforeAll hook", "text/plain");
+}
+
+WHEN(R"(a step passes)")
+{
+    // no-op
+}
+
+HOOK_AFTER_ALL()
+{
+    Attach("Attachment from AfterAll hook", "text/plain");
+}

compatibility/global-hooks-beforeall-error/global-hooks-beforeall-error.cpp

@@ -0,0 +1,32 @@
+#include "cucumber_cpp/CucumberCpp.hpp"
+#include <gmock/gmock.h>
+
+HOOK_BEFORE_ALL()
+{
+    // no-op
+}
+
+HOOK_BEFORE_ALL()
+{
+    ASSERT_THAT(true, false);
+}
+
+HOOK_BEFORE_ALL()
+{
+    // no-op
+}
+
+WHEN(R"(a step passes)")
+{
+    // no-op
+}
+
+HOOK_AFTER_ALL()
+{
+    // no-op
+}
+
+HOOK_AFTER_ALL()
+{
+    // no-op
+}

compatibility/hooks-attachment/hooks-attachment.cpp

@@ -0,0 +1,28 @@
+#include "cucumber_cpp/CucumberCpp.hpp"
+#include <filesystem>
+#include <fstream>
+#include <gmock/gmock.h>
+#include <ios>
+#include <source_location>
+
+namespace
+{
+    const std::filesystem::path currentCompileDir = std::filesystem::path{ std::source_location::current().file_name() }.parent_path();
+}
+
+HOOK_BEFORE_SCENARIO()
+{
+    std::ifstream svgFile{ currentCompileDir / "cucumber.svg", std::ios::binary };
+    Attach(svgFile, "image/svg+xml");
+}
+
+WHEN(R"(a step passes)")
+{
+    // no-op
+}
+
+HOOK_AFTER_SCENARIO()
+{
+    std::ifstream svgFile{ currentCompileDir / "cucumber.svg", std::ios::binary };
+    Attach(svgFile, "image/svg+xml");
+}

compatibility/hooks-conditional/hooks-conditional.cpp

@@ -0,0 +1,27 @@
+#include "cucumber_cpp/CucumberCpp.hpp"
+#include <gmock/gmock.h>
+
+HOOK_BEFORE_SCENARIO("@passing-hook")
+{
+    // no-op
+}
+
+HOOK_BEFORE_SCENARIO("@fail-before")
+{
+    ASSERT_THAT(true, false);
+}
+
+WHEN(R"(a step passes)")
+{
+    // no-op
+}
+
+HOOK_AFTER_SCENARIO("@fail-after")
+{
+    ASSERT_THAT(true, false);
+}
+
+HOOK_AFTER_SCENARIO("@passing-hook")
+{
+    // no-op
+}

compatibility/hooks/hooks.cpp

@@ -0,0 +1,22 @@
+#include "cucumber_cpp/CucumberCpp.hpp"
+#include <gmock/gmock.h>
+
+HOOK_BEFORE_SCENARIO()
+{
+    // no-op
+}
+
+WHEN(R"(a step passes)")
+{
+    // no-op
+}
+
+WHEN(R"(a step fails)")
+{
+    ASSERT_THAT(true, false);
+}
+
+HOOK_AFTER_SCENARIO()
+{
+    // no-op
+}

cucumber_cpp/library/HookRegistry.cpp

@@ -7,8 +7,10 @@
 #include "cucumber/messages/source_reference.hpp"
 #include "cucumber/messages/tag.hpp"
 #include "cucumber_cpp/library/Context.hpp"
+#include "cucumber_cpp/library/engine/ExecutionContext.hpp"
 #include "cucumber_cpp/library/support/SupportCodeLibrary.hpp"
 #include "cucumber_cpp/library/tag_expression/Parser.hpp"
+#include "cucumber_cpp/library/util/Broadcaster.hpp"
 #include <algorithm>
 #include <cstddef>
 #include <map>
@@ -61,8 +63,8 @@ namespace cucumber_cpp::library
         };
     }
 
-    HookBase::HookBase(Context& context)
-        : context{ context }
+    HookBase::HookBase(util::Broadcaster& broadCaster, Context& context, engine::StepOrHookStarted stepOrHookStarted)
+        : engine::ExecutionContext{ broadCaster, context, stepOrHookStarted }
     {}
 
     HookRegistry::Definition::Definition(std::string id, HookType type, std::string_view expression, HookFactory factory, std::source_location sourceLocation)
@@ -89,9 +91,7 @@ namespace cucumber_cpp::library
 
     void HookRegistry::LoadHooks()
     {
-
         for (const auto& matcher : support::DefinitionRegistration::Instance().GetHooks())
-            // for (const auto& matcher : HookRegistration::Instance().GetEntries())
             Register(matcher.id, matcher.type, matcher.expression, matcher.factory, matcher.sourceLocation);
     }
 

cucumber_cpp/library/HookRegistry.hpp

@@ -3,20 +3,17 @@
 
 #include "cucumber/gherkin/id_generator.hpp"
 #include "cucumber/messages/hook.hpp"
-#include "cucumber/messages/hook_type.hpp"
-#include "cucumber/messages/location.hpp"
 #include "cucumber/messages/pickle_tag.hpp"
-#include "cucumber/messages/source_reference.hpp"
 #include "cucumber/messages/tag.hpp"
 #include "cucumber_cpp/library/Body.hpp"
 #include "cucumber_cpp/library/Context.hpp"
+#include "cucumber_cpp/library/engine/ExecutionContext.hpp"
 #include "cucumber_cpp/library/tag_expression/Model.hpp"
-#include "cucumber_cpp/library/tag_expression/Parser.hpp"
+#include "cucumber_cpp/library/util/Broadcaster.hpp"
 #include <cstddef>
 #include <cstdint>
 #include <map>
 #include <memory>
-#include <optional>
 #include <ranges>
 #include <source_location>
 #include <span>
@@ -27,12 +24,6 @@
 namespace cucumber_cpp::library
 {
 
-    template<class T>
-    std::unique_ptr<Body> HookBodyFactory(Context& context)
-    {
-        return std::make_unique<T>(context);
-    }
-
     enum struct HookType
     {
         beforeAll,
@@ -45,9 +36,9 @@ namespace cucumber_cpp::library
         afterStep,
     };
 
-    struct HookBase
+    struct HookBase : engine::ExecutionContext
     {
-        explicit HookBase(Context& context);
+        HookBase(util::Broadcaster& broadCaster, Context& context, engine::StepOrHookStarted stepOrHookStarted);
 
         virtual ~HookBase() = default;
 
@@ -60,12 +51,15 @@ namespace cucumber_cpp::library
         {
             /* nothing to do */
         }
-
-    protected:
-        Context& context;
     };
 
-    using HookFactory = std::unique_ptr<Body> (&)(Context& context);
+    using HookFactory = std::unique_ptr<Body> (&)(util::Broadcaster& broadCaster, Context& context, engine::StepOrHookStarted stepOrHookStarted);
+
+    template<class T>
+    std::unique_ptr<Body> HookBodyFactory(util::Broadcaster& broadCaster, Context& context, engine::StepOrHookStarted stepOrHookStarted)
+    {
+        return std::make_unique<T>(broadCaster, context, stepOrHookStarted);
+    }
 
     struct HookMatch
     {