Share Data Between Threads when using SpecFlow + SpecRunner

Question

I am working on a test suit implementation which uses the SpecFlow + SpecRunner and XUnit. and we are trying to do parallel test execution and i would like to know is there are a way that i can run a hook in the begining of the test run and store the token value in a static variable so that that can be shared among threads.

to summarize is there a way that specflow offers a mechanism to share data between threads during parallel execution.

Answer 1

We can share the data using any one of the below approach

1. Scenario Context
2. Context Injection

Here, Approach 1 and 2 will not have any issue in multiple thread. Since, Context Injection life is specific to the scenario Level.

Approach 1 : we can define the Token Generation Step within the BeforeScenario hooks and the generated Token values can be updated in the ScenarioContext.

we can directly access the token from the scenario context in any place like below

Here, Token will be generated before each scenario run and it will not affect the Parallel execution.For more Details, Parallel-Execution

Scenarios and their related hooks (Before/After scenario, scenario block, step) are isolated in the different threads during execution and do not block each other. Each thread has a separate (and isolated) ScenarioContext.

Hooks Class:

public class CommonHooks
{
    [BeforeScenario]
    public static void Setup()
    {
        // Add Token Generation Step
        var adminToken = "<Generated Token>";
        ScenarioContext.Current["Token"] = adminToken;
    }
}

Step Class:

[Given(@"I Get the customer details""(.*)""")]
public void WhenIGetTheCustomerDetails(string endpoint)
{
   if(ScenarioContext.Current.ContainsKey("Token"))
   {
       var token = ScenarioContext.Current["Token"].ToString();
       //Now the Token variable holds the token value from the scenario context and It can be used in the subsequent steps
   }
   else
    {
        Assert.Fail("Unable to get the Token from the Scenario Context");
    }
}

If you wish to share the same token across multiple Step, then you can assign this token value within constructor and it can be used

For Example,

[Binding]
public class CustomerManagementSteps
{
    public readonly string token;
    public CustomerManagementSteps()
    {
        token= ScenarioContext.Current["Token"].ToString();
    }

    [Given(@"I Get the customer details""(.*)""")]
    public void WhenIGetTheCustomerDetails(string endpoint)
    {
        //Now the Token variable holds the token value from the scenario context and It can be used in the subsequent steps       
    }
}

Approach 2: Context Injection details can be referred in the below link with an example

Context Injection

Answer 2

Updated

Given the downvote and comments, I've updated my code example to better show exactly one way you can use dependency injection here with code of your own design. This shared data will last the lifetime of the scenario and be used by all bindings. I think that's what you're looking for unless I'm mistaken.

//Stores whatever data you want to share
//Write this however you want, it's your code
//You can use more than one of these custom data classes of course
public class SomeCustomDataStructure
{
    //If this is run in paralell, this should be thread-safe.  Using List<T> for simplicity purposes
    //Use EF, ConcurrentCollections, synchronization (like lock), etc...
    //Again, do NOT copy this code for parallel uses as List<int> is NOT thread-safe
    //You can force things to not run in parallel so this can be useful by itself
    public List<int> SomeData { get; } = new List<int>();
}

//Will be injected and the shared instance between any number of bindings.
//Lifespan is that of a scenario.
public class CatalogContext : IDisposable
{
    public SomeCustomDataStructure CustomData { get; private set; }

    public CatalogContext()
    {
        //Init shared data however you want here
        CustomData = new SomeCustomDataStructure();
    }

    //Added to show Dispose WILL be called at the end of a scenario
    //Feel free to do cleanup here if necessary.
    //You do NOT have to implement IDiposable, but it's supported and called.
    public void Dispose()
    {
        //Below obviously not thread-safe as mentioned earlier.  
        //Simple example is all.
        CustomData.SomeData.Clear();
    }
}

[Binding]
public class SomeSteps
{
    //Data shared here via instane variable, accessable to multiple steps
    private readonly CatalogContext catalogContext;

    //Dependency injection handled automatically here.  
    //Will get the same instance between other bindings.
    public SomeSteps(CatalogContext catalogContext)
    {
        this.catalogContext = catalogContext;
    }

    [Given(@"the following ints")]
    public void GivenTheFollowingInts(int[] numbers)
    {
        //This will be visible to all other steps in this binding, 
        //and all other bindings sharing the context
        catalogContext.CustomData.SomeData.AddRange(numbers);
    }
}