StepArgumentTransformations using Name parameter

[AidenFuller]

I'm having a bit of trouble using the StepArgumentTransformation attribute with a named parameter and having it accurately refine to what I expected based on the expressions in my Given/When/Then clauses.

From the docs here

Step Argument Transformations with a name property, E.g., With [StepArgumentTransformation("v(.*)", Name = "my_version")], you can define a step as [When("I download the release {my_version} of the application")] that matches to When I download the release v1.2.3 of the application.

I was expecting this to mean that the argument transform would only be executed for values in expressions whose names matched the transformation attribute, but it seems like this isn't the case:

[Then("it should last {int} {timePeriod}", ExpressionType = ExpressionType.CucumberExpression)]
public void ThenItShouldLastIntTimePeriod(int numberOfPeriods, int timePeriodToDayMultiplier)
{
    var totalDays = numberOfPeriods * timePeriodToDayMultiplier;
    totalDays.Should().Be(_result);
}

[StepArgumentTransformation(Name = "timePeriod", Order = 0)]
public int ConvertToDayMultiplier(string timePeriod)
{
    return timePeriod.ToLowerInvariant() switch
    {
        "day" or "days"   => 1,
        "week" or "weeks" => 7,
        _                 => throw new ArgumentException($"Unsupported time period: {timePeriod}")
    };
}

In this example, I'd use gherkin along the lines of "Then it should last 10 days", but what happens when I execute this test is that I end up with an error saying "Unsupported time period: 10", which seems to imply that the {int} value was passed to the StepArgumentTransform. Am I missing something? Have I misinterpreted this functionality and how it's expected to behave?

[304NotModified]

Note: all typed below on mobile, so no IDE to check it.

AFAIK you need the regex in the StepArgumentTransformation, something like this: [StepArgumentTransformation("(days?|weeks?)", ...

Otherwise it means, convert any string to int.

See https://docs.reqnroll.net/latest/automation/step-argument-conversions.html#step-argument-transformation

I think it would be logical if the StepArgumentTransformation
does the "var totalDays = numberOfPeriods * timePeriodToDayMultiplier".

In that case the regex would be "(\d+) (days?|weeks?)", and add the int parameter to the StepArgumentTransformation.

Or even better, 2 StepArgumentTransformations. One for days, the other for weeks. Then the StepArgumentTransformation has one int parameter and no need to pattern match the string. I don't think you need the name property (correct me if I'm wrong)

E.g.

   [StepArgumentTransformation(@"(\d+) days?")]
   public int InXDaysTransform(int days)
   {
      return days;
   }

   [StepArgumentTransformation(@"(\d+) weeks?")]
   public int InXWeeksTransform(int weeks)
   {
      return weeks * 7;
   }


[Then("it should last {}", ExpressionType = ExpressionType.CucumberExpression)]
public void ThenItShouldLastIntTimePeriod(int totalDays)
{
    totalDays.Should().Be(_result);
}

[304NotModified]

With the last case {int} also works I think:

[Then("it should last {int}", ExpressionType = ExpressionType.CucumberExpression)]

[AidenFuller]

Thanks for the reply.

I did try with the regex string as well, which does seem to work as you describe, but I guess I'd just ask what the purpose of the "Name" property on the transformation attribute is then? It seems to at least imply that the transformation is scoped explicitly to references from expressions which share that name, i.e. only matches {timePeriod} in my case, especially given that the tests will fail to run if I name it something else and therefore have an unbound "{timePeriod}" usage in my Cucumber expression.

Is the expectation that this should be the behaviour? In what contexts would it make sense for that transformation to be used for the {int} expression when it's got an explicit name?

[304NotModified]

The name is AFAIK only for clarity. But I'm not sure on that.

[304NotModified]

We should update the docs, PR would be great :)

https://github.com/reqnroll/Reqnroll/edit/main/docs/automation/step-argument-conversions.md

[304NotModified]

What would be the feature exactly?

[AidenFuller]

Oh sorry, I should've been clearer there.

I'd propose scoping the StepArgumentTransformation attributes to be solely usable by Cucumber Expression parameters with the listed name. e.g. a transformation with the name timePeriod would only be usable by parameters named {timePeriod}. If there's no name then it's just generally applicable.

Perhaps this makes more sense as a collection of supported parameters rather than a specific name, but that's the general gist anyway.

[304NotModified]

You could of course post it here
https://github.com/orgs/reqnroll/discussions/categories/ideas

We need to be sure that we won't break current implementations. Maybe we need config or a new parameter for this. But let's discuss that a the ideas.

[AidenFuller]

No worries, thanks. I'll start a thread there

[gasparnagy]

Quick response (I'm on holidays, so limited possibilities): I think the use case that @AidenFuller described is logical for the first read and my first impression was that this is how the thing should work.

It's good that you correct the docs for the current behavior, but we should definitely look into how the scoping could be done and if there are any negative implications. It is clearly a breaking change but we want to have v4 in January/February, so could be a good timing. Let's not forget that.