Add support for Tag Expressions

CHANGELOG.md

@@ -5,6 +5,7 @@
 * Updated NUnit3TestAdapter to v5.2.0 and NUnit to v4.4.0 in templates and tests to fix spurious warnings during test runs (#846)
 * Formatters: configured OutputFilePath may now contain variable substitution parameters for build metadata, timestamp, and environment variables. (#930)
 * Improved packaging of Reqnroll NuGet packages (#914)
+* Tag Expressions: step definition scopes and hooks may now use tag expressions (such as `@db and not @slow`) (#911)
 * Improved up-to-date checking for feature files that results in faster builds. As part of this the code-behind files are deleted on clean or rebuild. (#941)
 * Support for storing the code-behind files in the intermediate output folder (obj folder) by setting the `ReqnrollUseIntermediateOutputPathForCodeBehind` MSBuild property to `true`. (#947)
 * Support for linked feature files (files used from outside of the project folder). To use this feature, the `ReqnrollUseIntermediateOutputPathForCodeBehind` flag must be enabled (see above). (#948)

Reqnroll/Bindings/BindingScope.cs

@@ -1,38 +1,26 @@
 using System;
 using System.Linq;
+using Cucumber.TagExpressions;
 
 namespace Reqnroll.Bindings
 {
-    public class BindingScope
+    public class BindingScope(ITagExpression tagExpression, string featureTitle, string scenarioTitle)
     {
-        public string Tag { get; private set; }
-        public string FeatureTitle { get; private set; }
-        public string ScenarioTitle { get; private set; }
+        public string Tag => tagExpression.ToString();
 
-        public BindingScope(string tag, string featureTitle, string scenarioTitle)
-        {
-            Tag = RemoveLeadingAt(tag);
-            FeatureTitle = featureTitle;
-            ScenarioTitle = scenarioTitle;
-        }
+        public string FeatureTitle { get; } = featureTitle;
 
-        private string RemoveLeadingAt(string tag)
-        {
-            if (tag == null || !tag.StartsWith("@"))
-                return tag;
-
-            return tag.Substring(1); // remove leading "@"
-        }
+        public string ScenarioTitle { get; } = scenarioTitle;
 
         public bool Match(StepContext stepContext, out int scopeMatches)
         {
             scopeMatches = 0;
 
-            var tags = stepContext.Tags;
-
             if (Tag != null)
             {
-                if (!tags.Contains(Tag))
+                var tags = stepContext.Tags.Select(t => "@" + t).ToList();
+
+                if (!tagExpression.Evaluate(tags))    
                     return false;
 
                 scopeMatches++;
@@ -64,7 +52,7 @@ public override bool Equals(object obj)
         {
             if (ReferenceEquals(null, obj)) return false;
             if (ReferenceEquals(this, obj)) return true;
-            if (obj.GetType() != this.GetType()) return false;
+            if (obj.GetType() != GetType()) return false;
             return Equals((BindingScope) obj);
         }
 

Reqnroll/Bindings/Discovery/BindingSourceProcessor.cs

@@ -3,20 +3,23 @@
 using System.Linq;
 using Reqnroll.Bindings.Reflection;
 using Reqnroll.PlatformCompatibility;
+using Cucumber.TagExpressions;
 
 namespace Reqnroll.Bindings.Discovery
 {
     public abstract class BindingSourceProcessor : IBindingSourceProcessor
     {
         private readonly IBindingFactory _bindingFactory;
+        private readonly ITagExpressionParser _tagExpressionParser;
 
         private BindingSourceType _currentBindingSourceType = null;
         private BindingScope[] _typeScopes = null;
         private readonly List<IStepDefinitionBindingBuilder> _stepDefinitionBindingBuilders = new();
 
-        protected BindingSourceProcessor(IBindingFactory bindingFactory)
+        protected BindingSourceProcessor(IBindingFactory bindingFactory, ITagExpressionParser tagExpressionParser)
         {
             _bindingFactory = bindingFactory;
+            _tagExpressionParser = tagExpressionParser;
         }
 
         public bool CanProcessTypeAttribute(string attributeTypeName)
@@ -75,7 +78,7 @@ public virtual void BuildingCompleted()
         private IEnumerable<BindingScope> GetScopes(IEnumerable<BindingSourceAttribute> attributes)
         {
             return attributes.Where(attr => attr.AttributeType.TypeEquals(typeof(ScopeAttribute)))
-                .Select(attr => new BindingScope(attr.TryGetAttributeValue<string>("Tag"), attr.TryGetAttributeValue<string>("Feature"), attr.TryGetAttributeValue<string>("Scenario")));
+                .Select(attr => new BindingScope(_tagExpressionParser.Parse(attr.TryGetAttributeValue<string>("Tag")), attr.TryGetAttributeValue<string>("Feature"), attr.TryGetAttributeValue<string>("Scenario")));
         }
 
         private bool IsBindingType(BindingSourceType bindingSourceType)
@@ -156,7 +159,7 @@ private void ProcessHookAttribute(BindingSourceMethod bindingSourceMethod, Bindi
 
             string[] tags = GetTagsDefinedOnBindingAttribute(hookAttribute);
             if (tags != null)
-                scopes = scopes.Concat(tags.Select(t => new BindingScope(t, null, null)));
+                scopes = scopes.Concat(tags.Select(t => new BindingScope(_tagExpressionParser.Parse(t), null, null)));
 
 
             ApplyForScope(scopes.ToArray(), scope => ProcessHookAttribute(bindingSourceMethod, hookAttribute, scope));

Reqnroll/Bindings/Discovery/ReqnrollTagExpressionParser.cs

@@ -0,0 +1,33 @@
+using Cucumber.TagExpressions;
+using System;
+
+namespace Reqnroll.Bindings.Discovery;
+
+public class ReqnrollTagExpressionParser(ITagExpressionParser tagExpressionParser) : ITagExpressionParser
+{
+    public ITagExpression Parse(string tagExpression)
+    {
+        return Rewrite(tagExpressionParser.Parse(tagExpression));
+    }
+
+    private ITagExpression Rewrite(ITagExpression expression)
+    {
+        return expression switch
+        {
+            NullExpression nullExpression => nullExpression,
+            NotNode notNode => new NotNode(Rewrite(notNode.Operand)),
+            BinaryOpNode binaryOpNode => new BinaryOpNode(binaryOpNode.Op, Rewrite(binaryOpNode.Left), Rewrite(binaryOpNode.Right)),
+            LiteralNode literalNode => new LiteralNode(PrefixLiteral(literalNode.Name)),
+            _ => throw new NotSupportedException($"Unsupported tag expression type: {expression.GetType().FullName}"),
+        };
+    }
+
+    private string PrefixLiteral(string name)
+    {
+        if (name.IsNullOrEmpty() )
+            return name;
+        if (name.StartsWith("@"))
+            return name;
+        return "@" + name;
+    }
+}

Reqnroll/Bindings/Discovery/RuntimeBindingSourceProcessor.cs

@@ -1,4 +1,5 @@
 using Reqnroll.Tracing;
+using Cucumber.TagExpressions;
 
 namespace Reqnroll.Bindings.Discovery
 {
@@ -12,7 +13,7 @@ public class RuntimeBindingSourceProcessor : BindingSourceProcessor, IRuntimeBin
         private readonly IBindingRegistry _bindingRegistry;
         private readonly ITestTracer _testTracer;
 
-        public RuntimeBindingSourceProcessor(IBindingFactory bindingFactory, IBindingRegistry bindingRegistry, ITestTracer testTracer) : base(bindingFactory)
+        public RuntimeBindingSourceProcessor(IBindingFactory bindingFactory, IBindingRegistry bindingRegistry, ITestTracer testTracer, ITagExpressionParser tagExpressionParser) : base(bindingFactory, tagExpressionParser)
         {
             _bindingRegistry = bindingRegistry;
             _testTracer = testTracer;

Reqnroll/Bindings/Provider/BindingProviderService.cs

@@ -1,8 +1,8 @@
-using Reqnroll.Bindings.Discovery;
+using Cucumber.TagExpressions;
+using Reqnroll.Bindings.Discovery;
 using Reqnroll.Bindings.Provider.Data;
 using Reqnroll.Bindings.Reflection;
 using Reqnroll.BoDi;
-using Reqnroll.CommonModels;
 using Reqnroll.Configuration;
 using Reqnroll.EnvironmentAccess;
 using Reqnroll.Formatters.Configuration;
@@ -138,9 +138,7 @@ BindingScopeData GetScope(IScopedBinding scopedBinding)
 
             return new BindingScopeData
             {
-                Tag = scopedBinding.BindingScope.Tag == null
-                    ? null
-                    : "@" + scopedBinding.BindingScope.Tag,
+                Tag = scopedBinding.BindingScope.Tag,
                 FeatureTitle = scopedBinding.BindingScope.FeatureTitle,
                 ScenarioTitle = scopedBinding.BindingScope.ScenarioTitle
             };
@@ -188,6 +186,7 @@ public override void RegisterGlobalContainerDefaults(ObjectContainer container)
             base.RegisterGlobalContainerDefaults(container);
             container.RegisterTypeAs<DryRunBindingInvoker, IAsyncBindingInvoker>();
             container.RegisterTypeAs<Formatters.Configuration.FormattersForcedDisabledOverrideProvider, IFormattersConfigurationDisableOverrideProvider>();
+            var _ = container.RegisterFactoryAs<ITagExpressionParser>(() => new ReqnrollTagExpressionParser(new TagExpressionParser())).InstancePerDependency;
         }
     }
 

Reqnroll/Formatters/PayloadProcessing/Cucumber/CucumberMessageFactory.cs

@@ -230,7 +230,7 @@ public virtual Hook ToHook(IHookBinding hookBinding, IIdGenerator iDGenerator)
             iDGenerator.GetNewId(),
             null,
             sourceRef,
-            hookBinding.IsScoped ? $"@{hookBinding.BindingScope.Tag}" : null,
+            hookBinding.IsScoped ? hookBinding.BindingScope.Tag : null,
             ToHookType(hookBinding)
         );
         return result;

Reqnroll/Infrastructure/DefaultDependencyProvider.cs

@@ -1,3 +1,4 @@
+using Cucumber.TagExpressions;
 using Gherkin.CucumberMessages;
 using Reqnroll.Analytics;
 using Reqnroll.Analytics.AppInsights;
@@ -27,7 +28,6 @@
 using Reqnroll.Time;
 using Reqnroll.Tracing;
 using Reqnroll.Utils;
-using System;
 
 namespace Reqnroll.Infrastructure
 {
@@ -135,6 +135,8 @@ public virtual void RegisterGlobalContainerDefaults(ObjectContainer container)
             container.RegisterTypeAs<TestCaseExecutionTrackerFactory, ITestCaseExecutionTrackerFactory>();
             container.RegisterFactoryAs<IMessagePublisher>(() => container.Resolve<ICucumberMessageBroker>());
             container.RegisterTypeAs<StepTrackerFactory, IStepTrackerFactory>();
+
+            var _ = container.RegisterFactoryAs<ITagExpressionParser>(() => new ReqnrollTagExpressionParser(new TagExpressionParser())).InstancePerDependency;
         }
 
         public virtual void RegisterTestThreadContainerDefaults(ObjectContainer testThreadContainer)

Reqnroll/Reqnroll.csproj

@@ -18,6 +18,7 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Cucumber.TagExpressions" Version="8.1.0" />
     <PackageReference Include="Gherkin" Version="35.0.0" />
     <PackageReference Include="Cucumber.CucumberExpressions" Version="17.1.0" />
     <PackageReference Include="Cucumber.Messages" Version="30.1.0" />

Tests/Reqnroll.Formatters.Tests/CucumberMessagesValidator.cs

@@ -3,9 +3,7 @@
 using FluentAssertions.Execution;
 using Io.Cucumber.Messages.Types;
 using Reqnroll.Formatters.PayloadProcessing.Cucumber;
-using System.Collections.Concurrent;
 using System.Reflection;
-using System.Runtime.Versioning;
 
 namespace Reqnroll.Formatters.Tests;
 
@@ -139,10 +137,10 @@ private void CompareMessageType<T>(int partitionNumber)
         if (!_expectedElementsByType.ContainsKey(typeof(T)))
             return;
 
-        int actualsPartitionNumber = MapPartitionNumber(partitionNumber);
+        int actualPartitionNumber = MapPartitionNumber(partitionNumber);
 
         var actual = _actualElementsByType.TryGetValue(typeof(T), out HashSet<object>? actualElements) && actualElements.Count > 0 ?
-            actualElements.OfType<T>().Where(e => _actualPartitions[e!] == actualsPartitionNumber).ToList() : new List<T>();
+            actualElements.OfType<T>().Where(e => _actualPartitions[e!] == actualPartitionNumber).ToList() : new List<T>();
 
         var expected = _expectedElementsByType[typeof(T)].AsEnumerable().OfType<T>().Where(e => _expectedPartitions[e!] == partitionNumber).ToList();
 
@@ -191,11 +189,11 @@ private void ActualTestExecutionMessagesShouldReferBackToTheSameStepTextAsExpect
         for (int i = 0; i < _numPartitions; i++)
         {
             var partitionNumber = i + 1;
-            int actualsPartitionNumber = MapPartitionNumber(partitionNumber);
+            int actualPartitionNumber = MapPartitionNumber(partitionNumber);
 
             // For each TestStepStarted message, ensure that the pickle step referred to is the same in Actual and Expected for the corresponding testStepStarted message
-            var actualTestStepStartedTestStepIds = _actualElementsByType[typeof(TestStepStarted)].OfType<TestStepStarted>().Where(e => _actualPartitions[e!] == actualsPartitionNumber).Select(tss => tss.TestStepId).ToList();
-            var expectedTestStepStartedTestStepIds = _expectedElementsByType[typeof(TestStepStarted)].OfType<TestStepStarted>().Where(e => _expectedPartitions[e!] == partitionNumber).Select(tss => tss.TestStepId).ToList();
+            var actualTestStepStartedTestStepIds = _actualElementsByType[typeof(TestStepStarted)].OfType<TestStepStarted>().Where(e => _actualPartitions[e] == actualPartitionNumber).Select(tss => tss.TestStepId).ToList();
+            var expectedTestStepStartedTestStepIds = _expectedElementsByType[typeof(TestStepStarted)].OfType<TestStepStarted>().Where(e => _expectedPartitions[e] == partitionNumber).Select(tss => tss.TestStepId).ToList();
 
             // Making the assumption here that the order of TestStepStarted messages is the same in both Actual and Expected within a Partition
             // pair these up, and walk back to the pickle step text and compare
@@ -330,7 +328,7 @@ private void EachTestCaseAndStepsShouldProperlyReferToAPickleAndStepDefinitionOr
                 if (step.PickleStepId != null)
                     _actualElementsById.Should().ContainKey(step.PickleStepId, "a step references a pickle step that doesn't exist");
 
-                if (step.StepDefinitionIds != null && step.StepDefinitionIds.Count > 0)
+                if (step.StepDefinitionIds is { Count: > 0 })
                 {
                     foreach (var stepDefinitionId in step.StepDefinitionIds)
                         _actualElementsById.Should().ContainKey(stepDefinitionId, "a step references a step definition that doesn't exist");
@@ -374,19 +372,19 @@ public void ShouldPassBasicStructuralChecks()
                 {
                     throw new System.Exception($"{messageType} present in the expected but not in the actual.");
                 }
-                if (messageType != typeof(Hook) && _actualElementsByType.ContainsKey(messageType))
+                if (messageType != typeof(Hook) && _actualElementsByType.TryGetValue(messageType, out var nonHookElement))
                 {
-                    _actualElementsByType[messageType].Should().HaveCount(_expectedElementsByType[messageType].Count());
+                    nonHookElement.Should().HaveCount(_expectedElementsByType[messageType].Count);
                 }
-                if (messageType == typeof(Hook) && _actualElementsByType.ContainsKey(messageType))
-                    _actualElementsByType[messageType].Should().HaveCountGreaterThanOrEqualTo(_expectedElementsByType[messageType].Count());
+                if (messageType == typeof(Hook) && _actualElementsByType.TryGetValue(messageType, out var hookElement))
+                    hookElement.Should().HaveCountGreaterThanOrEqualTo(_expectedElementsByType[messageType].Count);
             }
 
             actual.Should().HaveCountGreaterThanOrEqualTo(expected.Count(), "the total number of envelopes in the actual should be at least as many as in the expected");
         }
     }
 
-    private bool GroupListIsEmpty(List<Group> groups)
+    private bool GroupListIsEmpty(List<Group>? groups)
     {
         if (groups == null || groups.Count == 0) return true;
         foreach (var group in groups)
@@ -407,7 +405,7 @@ private EquivalencyAssertionOptions<T> ArrangeFluentAssertionOptions<T>(Equivale
                .ComparingByMembers<Ci>()
                .ComparingByMembers<Comment>()
                .ComparingByMembers<Io.Cucumber.Messages.Types.DataTable>()
-               .ComparingByMembers<Io.Cucumber.Messages.Types.DocString>()
+               .ComparingByMembers<DocString>()
                .ComparingByMembers<Envelope>()
                .ComparingByMembers<Examples>()
                .ComparingByMembers<Feature>()
@@ -458,15 +456,15 @@ private EquivalencyAssertionOptions<T> ArrangeFluentAssertionOptions<T>(Equivale
 
                // Using a custom Property Selector so that we can ignore the properties that are not comparable
                .Using(_customCucumberMessagesPropertySelector)
-               // Using a custom string comparison that deals with ISO langauge codes when the property name ends with "Language"
+               // Using a custom string comparison that deals with ISO language codes when the property name ends with "Language"
                //.Using<string>(ctx =>
                //{
                //    var actual = ctx.Subject.Split("-")[0];
                //    var expected = ctx.Expectation.Split("-")[0];
                //    actual.Should().Be(expected);
                //})
 
-               // Using special logic to assert that suggestions must contain at least one snippets among those specified in the Expected set
+               // Using special logic to assert that suggestions must contain at least one snippet among those specified in the Expected set
                // We can't compare snippet content as the Language and Code properties won't match
                .Using<Suggestion>(ctx =>
                {
@@ -547,17 +545,15 @@ private EquivalencyAssertionOptions<T> ArrangeFluentAssertionOptions<T>(Equivale
                        actualList.Should().HaveCountGreaterThanOrEqualTo(expectedList.Count,
                                                                          "actual collection should have at least as many items as expected");
 
-                       // Impossible to compare individual Hook messages (Ids aren't comparable, the Source references aren't compatible, 
-                       // and the Scope tags won't line up because the CCK uses tag expressions and RnR does not support them)
+                       // Difficult to compare individual Hook messages: Ids aren't comparable, the Source references aren't compatible, 
                        // and After Hook execution ordering is different between Reqnroll and CCK.
-                       /*
-                           foreach (var expectedItem in expectedList)
-                           {
-                               actualList.Should().Contain(actualItem =>
-                                   AssertionExtensions.Should(actualItem).BeEquivalentTo(expectedItem, "").And.Subject == actualItem,
-                                   "actual collection should contain an item equivalent to {0}", expectedItem);
-                           }
-                       */
+                       foreach (var expectedItem in expectedList)
+                       {
+                           actualList.Should().Contain(actualItem =>
+                               actualItem.TagExpression == expectedItem.TagExpression
+                               && actualItem.Type == expectedItem.Type,
+                               "actual collection should contain an item equivalent to {0}", expectedItem);
+                       }
                    }
                })
                .WhenTypeIs<List<Hook>>()

Tests/Reqnroll.RuntimeTests/BindingSourceProcessorStub.cs

@@ -4,6 +4,7 @@
 using Reqnroll.Bindings.CucumberExpressions;
 using Reqnroll.Bindings.Discovery;
 using Reqnroll.Configuration;
+using Cucumber.TagExpressions;
 
 namespace Reqnroll.RuntimeTests
 {
@@ -17,7 +18,7 @@ public class BindingSourceProcessorStub : BindingSourceProcessor, IRuntimeBindin
 
         public IEnumerable<string> ValidationErrors => GeneralErrorMessages.Concat(BindingSpecificErrorMessages);
 
-        public BindingSourceProcessorStub() : base(new BindingFactory(new StepDefinitionRegexCalculator(ConfigurationLoader.GetDefault()), new CucumberExpressionStepDefinitionBindingBuilderFactory(new CucumberExpressionParameterTypeRegistry(new BindingRegistry())), new CucumberExpressionDetector()))
+        public BindingSourceProcessorStub() : base(new BindingFactory(new StepDefinitionRegexCalculator(ConfigurationLoader.GetDefault()), new CucumberExpressionStepDefinitionBindingBuilderFactory(new CucumberExpressionParameterTypeRegistry(new BindingRegistry())), new CucumberExpressionDetector()), new ReqnrollTagExpressionParser(new TagExpressionParser()))
         {
         }