Named parameter binding in step definitions

[princemuel]

Hi, I’m experimenting with cucumber-rs and trying to write steps like this:

Scenario: A tuple with w=1.0 is a point
       Given a ← tuple(4.3, -4.2, 3.1, 1.0)
       Then a.x = 4.3
       And a.y = -4.2
       And a.z = 3.1
       And a.w = 1.0
       And a is a point
       And a is not a vector

I tried expressions like {x:float} using Parameter Types as i have many scenarios, and using regex was very verbose and messy.

#[derive(Default, Debug, Copy, Clone, PartialEq, Parameter)]
#[param(
  name = "float64",
  regex = r"[+-]?(?:\d+\.\d+|\d+|\.\d+)(?:[eE][+-]?\d+)?"
)]
pub struct Float64(pub f64);

impl From<Float64> for f64 {
  fn from(p: Float64) -> Self { p.0 }
}

impl Deref for Float64 {
  type Target = f64;

  fn deref(&self) -> &Self::Target { &self.0 }
}

impl FromStr for Float64 {
  type Err = String;

  fn from_str(s: &str) -> Result<Self, Self::Err> {
      s.trim()
          .parse::<f64>()
          .map(Float64)
          .map_err(|e| e.to_string())
  }
}


#[given(expr = "a ← tuple({x:float64}, {y:float64}, {z:float64}, {w:float64})")]
async fn given_a_tuple(world: &mut TestWorld, x: Float64, y: Float64, z: Float64, w: Float64) {
  // let x = f64::from(x);
  // let y = f64::from(y);
  // let z = f64::from(z);
  // let w = f64::from(w);
  // ...
}

but i get this

evaluation panicked: Type `Float64` doesn't implement a custom parameter `{x:float64}`
evaluation of `steps::tuple::_::__INVENTORY::{closure#0}::LAZY::{closure#0}::_` ...

So my questions are:

• Does cucumber-rs currently support named parameters in step definitions?
• If not, would the recommended approach be to stick with positional arguments?
• Is there a way to define a custom parameter type (like Float64) and have it map correctly to the relevant value?

Thanks!

[tyranron]

@princemuel sorry for the late response. {y:float64} is not a valid Cucumber Expression. See the grammar for details: there is no other naming for parameters except its "type" (which is named "name" in the grammar).

• If not, would the recommended approach be to stick with positional arguments?

Yes, that's what you have if you're using Cucumber Expressions.

We will be happy to support such a feature if the upstream Cucumber Expressions will provide it.