feat: add option to print steps that have not been used (#227)

Co-authored-by: Bart Kerkhoff <[email protected]>
Co-authored-by: Copilot <[email protected]>

Author: 3 people

cucumber_cpp/acceptance_test/features/test_unused_steps.feature

@@ -0,0 +1,5 @@
+@unused_steps
+Feature: Test for unused step detection
+    Scenario: One step used, one step not used
+        When this step is being used
+#       And this step is not being used

cucumber_cpp/acceptance_test/steps/Steps.cpp

@@ -63,6 +63,16 @@ GIVEN("Next block of text enclosed in \"\"\" characters")
     ASSERT_THAT(docString, testing::Eq("Multiline\nDocstring"));
 }
 
+WHEN("this step is being used")
+{
+    // empty
+}
+
+WHEN("this step is not being used")
+{
+    // empty
+}
+
 WHEN("I throw an exception")
 {
     throw std::runtime_error{ "Exception thrown" };

cucumber_cpp/acceptance_test/test.bats

@@ -192,3 +192,16 @@ teardown() {
     assert_success
     assert_output --partial "tests   : 1/1 passed"
 }
+
+@test "Test unused step reporting" {
+    run .build/Host/cucumber_cpp/acceptance_test/Debug/cucumber_cpp.acceptance_test run --feature cucumber_cpp/acceptance_test/features --tag "@unused_steps" --report console --unused 
+    assert_success
+    assert_output --regexp ".*The following steps have not been used:.*this step is not being used.*"
+    refute_output --regexp ".*The following steps have not been used:.*this step is being used.*"
+}
+
+@test "Test unused steps by default not reported" {
+    run .build/Host/cucumber_cpp/acceptance_test/Debug/cucumber_cpp.acceptance_test run --feature cucumber_cpp/acceptance_test/features --tag "@unused_steps" --report console
+    assert_success
+    refute_output --partial "The following steps have not been used:"
+}

cucumber_cpp/library/Application.cpp

@@ -3,6 +3,7 @@
 #include "cucumber_cpp/library/Errors.hpp"
 #include "cucumber_cpp/library/StepRegistry.hpp"
 #include "cucumber_cpp/library/cucumber_expression/Errors.hpp"
+#include "cucumber_cpp/library/cucumber_expression/Matcher.hpp"
 #include "cucumber_cpp/library/cucumber_expression/ParameterRegistry.hpp"
 #include "cucumber_cpp/library/engine/ContextManager.hpp"
 #include "cucumber_cpp/library/engine/FeatureFactory.hpp"
@@ -34,6 +35,7 @@
 #include <string_view>
 #include <type_traits>
 #include <utility>
+#include <variant>
 #include <vector>
 
 namespace cucumber_cpp::library
@@ -115,6 +117,7 @@ namespace cucumber_cpp::library
         runCommand->add_option("--outputfolder", options.outputfolder, "Specifies the output folder for generated report files")->group("report generation");
         runCommand->add_option("--reportfile", options.reportfile, "Specifies the output name for generated report files")->group("report generation");
         runCommand->add_flag("--dry", options.dryrun, "Generate report without running tests");
+        runCommand->add_flag("--unused", options.printStepsNotUsed, "Show step definitions that were not used");
 
         reporters.Add("console", std::make_unique<report::StdOutReport>());
         reporters.Add("junit-xml", std::make_unique<report::JunitReport>(options.outputfolder, options.reportfile));
@@ -213,10 +216,32 @@ namespace cucumber_cpp::library
 
         testRunner.Run(GetFeatureTree(featureTreeFactory, tagExpression));
 
+        if (options.printStepsNotUsed)
+            PrintStepsNotUsed(stepRegistry);
+
         std::cout << '\n'
                   << std::flush;
     }
 
+    void Application::PrintStepsNotUsed(const StepRegistry& stepRegistry) const
+    {
+        auto isUnused = [](const StepRegistry::EntryView& entry)
+        {
+            return entry.used == 0;
+        };
+
+        auto unusedSteps = stepRegistry.List() | std::views::filter(isUnused);
+
+        if (std::ranges::empty(unusedSteps))
+            std::cout << "\nAll steps have been used.";
+        else
+        {
+            std::cout << "\nThe following steps have not been used:";
+            for (const auto& entry : unusedSteps)
+                std::cout << "\n - " << std::visit(cucumber_expression::SourceVisitor{}, entry.stepRegex);
+        }
+    }
+
     std::vector<std::unique_ptr<engine::FeatureInfo>> Application::GetFeatureTree(const engine::FeatureTreeFactory& featureTreeFactory, std::string_view tagExpression)
     {
 

cucumber_cpp/library/Application.hpp

@@ -6,6 +6,7 @@
 
 #include "cucumber/gherkin/app.hpp"
 #include "cucumber_cpp/library/Context.hpp"
+#include "cucumber_cpp/library/StepRegistry.hpp"
 #include "cucumber_cpp/library/cucumber_expression/ParameterRegistry.hpp"
 #include "cucumber_cpp/library/engine/ContextManager.hpp"
 #include "cucumber_cpp/library/engine/FeatureFactory.hpp"
@@ -40,6 +41,7 @@ namespace cucumber_cpp::library
             std::string reportfile{ "TestReport" };
 
             bool dryrun{ false };
+            bool printStepsNotUsed{ false };
         };
 
         explicit Application(std::shared_ptr<ContextStorageFactory> contextStorageFactory = std::make_shared<ContextStorageFactoryImpl>(), bool removeDefaultGoogleTestListener = true);
@@ -53,12 +55,14 @@ namespace cucumber_cpp::library
         void AddReportHandler(const std::string& name, std::unique_ptr<report::ReportHandlerV2>&& reporter);
 
     private:
-        [[nodiscard]] int GetExitCode() const;
-        [[nodiscard]] int GetExitCode(engine::Result result) const;
         void DryRunFeatures();
         void RunFeatures();
-        [[nodiscard]] std::vector<std::unique_ptr<engine::FeatureInfo>> GetFeatureTree(const engine::FeatureTreeFactory& featureTreeFactory, std::string_view tagExpression);
         [[nodiscard]] engine::Result RunFeature(const std::filesystem::path& path, std::string_view tagExpression, report::ReportHandlerV2& reportHandler);
+        void PrintStepsNotUsed(const StepRegistry& stepRegistry) const;
+        [[nodiscard]] std::vector<std::unique_ptr<engine::FeatureInfo>> GetFeatureTree(const engine::FeatureTreeFactory& featureTreeFactory, std::string_view tagExpression);
+
+        [[nodiscard]] int GetExitCode() const;
+        [[nodiscard]] int GetExitCode(engine::Result result) const;
 
         Options options;
         CLI::App cli;

cucumber_cpp/library/test/TestApplication.cpp

@@ -1,6 +1,7 @@
 #include "cucumber_cpp/CucumberCpp.hpp"
 #include "cucumber_cpp/library/Application.hpp"
 #include "cucumber_cpp/library/engine/test_helper/TemporaryFile.hpp"
+#include "gmock/gmock.h"
 #include <CLI/Error.hpp>
 #include <array>
 #include <cstddef>
@@ -110,4 +111,33 @@ namespace cucumber_cpp::library
     {
         EXPECT_THAT(&Application{}.ParameterRegistration(), testing::NotNull());
     }
+
+    TEST_F(TestApplication, UnusedParameters)
+    {
+        auto tmp = engine::test_helper::TemporaryFile{ "tmpfile.feature" };
+        const auto path = tmp.Path().string();
+
+        tmp << "Feature: Test feature\n"
+               "  Rule: Test rule\n"
+               "    Scenario: Test scenario1\n"
+               "      Given 5 and 5 are equal\n"
+               "      And This is a GIVEN step\n"
+               "      And This is a WHEN step\n"
+               "      And This is a THEN step\n"
+               "      And This is a STEP step\n";
+
+        const std::array args{ "application", "run", "--feature", path.c_str(), "--report", "console", "--unused" };
+
+        std::string stdoutString = RunWithArgs(args, static_cast<std::underlying_type_t<CLI::ExitCodes>>(CLI::ExitCodes::Success));
+
+        EXPECT_THAT(stdoutString, testing::HasSubstr("The following steps have not been used:"));
+        EXPECT_THAT(stdoutString, testing::HasSubstr("^This is a step with a ([0-9]+)s delay$"));
+        EXPECT_THAT(stdoutString, testing::HasSubstr("Step with cucumber expression syntax {float} {string} {int}"));
+
+        EXPECT_THAT(stdoutString, testing::Not(testing::HasSubstr("{int} and {int} are equal")));
+        EXPECT_THAT(stdoutString, testing::Not(testing::HasSubstr("And This is a GIVEN step")));
+        EXPECT_THAT(stdoutString, testing::Not(testing::HasSubstr("And This is a WHEN step")));
+        EXPECT_THAT(stdoutString, testing::Not(testing::HasSubstr("And This is a THEN step")));
+        EXPECT_THAT(stdoutString, testing::Not(testing::HasSubstr("And This is a STEP step")));
+    }
 }