Each scenario on a new thread.

[zie1ony]

I have a code that uses thread_local!. It requires each scenario to run on a new thread, exactly like a standard behaviour of a standard #[test] tagged tests. Is it possible to force cucumber to do that?

[ilslv]

@zie1ony unfortunately we don't support this feature and have no plans to do it, as we targeting runtime-agnostic async test, which doesn't play nicely with spawning threads on each test. But in the book we briefly describe a way to implement a custom Runner. If you'll decide to go with this approach I will happily help.

[zie1ony]

I have followed this thread: https://users.rust-lang.org/t/return-value-from-catch-unwind-is-a-useless-any/89134/5.
They say to downcast errors to String, so I have blindly changed Info to String in events.rs and then treated all errors with

fn downcast_to_string(v: Box<dyn Any + Send>) -> String {
    match v.downcast_ref::<&'static str>() {
        Some(s) => String::from(*s),
        None => match v.downcast_ref::<String>() {
            Some(s) => s.clone(),
            None => String::from("Box<dyn Any>"),
        },
    }
}

That actually worked and now execute_scenario from CustomRunner is:

 async fn execute_scenario(
      scenario: gherkin::Scenario,
  ) -> impl Stream<Item = event::Feature<MyWorld>> {
      let s = scenario.clone();
      let (tx, rx) = futures::channel::oneshot::channel();
      thread::spawn(move || {
          let hook = panic::take_hook();
          panic::set_hook(Box::new(|_| {}));
          
          let steps = block_on(async {
              let mut steps = Vec::with_capacity(s.steps.len());
              let mut world = MyWorld::new().await.unwrap();
              for step in s.steps.clone() {
                  let (w, ev) = Self::execute_step(world, step.clone()).await;
                  world = w;
                  let should_stop = matches!(ev, event::Step::Failed(..));
                  steps.push((step, ev));
                  if should_stop {
                      break;
                  }
              }
              steps
          }); 
          
          panic::set_hook(hook);
          tx.send(steps).unwrap();
      });

      let steps = rx.await.unwrap();

      let scenario = Arc::new(scenario);
      stream::once(future::ready(event::Scenario::Started))
          .chain(stream::iter(steps.into_iter().flat_map(|(step, ev)| {
              let step = Arc::new(step);
              [
                  event::Scenario::Step(step.clone(), event::Step::Started),
                  event::Scenario::Step(step, ev),
              ]
          })))
          .chain(stream::once(future::ready(event::Scenario::Finished)))
          .map(move |event| event::Feature::Scenario(
              scenario.clone(), 
              event::RetryableScenario { event, retries: None },
          ))
  }

This doesn't work well with panics (yet). It's just proof of concept. Would you help me going this direction?

[ilslv]

@zie1ony

Would you consider making Info something more thread friendly?

The thing is, rust allows you to panic not only with Strings, but with arbitrary types too which can be !Sync for example. I would prefer to give users more options rather than immediately downcasting dyn Any + Send to Strings.

Would you help me going this direction?

Proof of concept looks fine. Do you have concrete questions about pushing it forward?

[zie1ony]

The question is still the same: How to send cucumber::event::Step to another thread?

[ilslv]

@zie1ony as I said earlier, to give users maximum flexibility, I would prefer to keep event::Step: !Sync, which makes it impossible to pass value to another thread. I would suggest implementing your own stricter version of event::Step, which will look something like:

#[derive(Debug)]
pub enum SyncStep<World> {
    Started,
    Skipped,
    Passed(regex::CaptureLocations, Option<step::Location>),
    Failed(
        Option<regex::CaptureLocations>,
        Option<step::Location>,
        Option<Arc<World>>,
        StepError,
    ),
}

#[derive(Clone, Debug, Display, Error, From)]
pub enum SyncStepError {
    #[display(fmt = "Step doesn't match any function")]
    NotFound,
    #[display(fmt = "Step match is ambiguous: {}", _0)]
    AmbiguousMatch(step::AmbiguousMatchError),
    #[display(fmt = "Step panicked. Captured output: {}", "coerce_error(_0)")]
    Panic(#[error(not(source))] String),
    //        Instead of `Info` ^^^^^^
}

and implement conversions from/to event::Step. So you will convert event::Step into a event::SyncStep, pass it to another thread and then convert back to event::Step

[zie1ony]

Thank you @ilslv