Merge branch 'release/0.7.0' into production

Author: craigfowler

CSF.Screenplay.NUnit/CSF.Screenplay.NUnit.csproj

@@ -8,7 +8,7 @@
     <RootNamespace>CSF.Screenplay.NUnit</RootNamespace>
     <AssemblyName>CSF.Screenplay.NUnit</AssemblyName>
     <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
-    <ReleaseVersion>0.6.0</ReleaseVersion>
+    <ReleaseVersion>0.7.0</ReleaseVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>

CSF.Screenplay.NUnit/CSF.Screenplay.NUnit.nuspec

@@ -2,7 +2,7 @@
 <package>
   <metadata>
     <id>CSF.Screenplay.NUnit</id>
-    <version>0.6.0-alpha</version>
+    <version>0.7.0-alpha</version>
     <title>CSF.Screenplay.NUnit</title>
     <authors>CSF Software Ltd</authors>
     <licenseUrl>https://opensource.org/licenses/MIT</licenseUrl>
@@ -13,7 +13,7 @@
     <dependencies>
       <dependency id="CSF.Reflection" version="[1.0.1,2.0.0)" />
       <dependency id="NUnit" version="[3.4.0,4.0.0)" />
-      <dependency id="CSF.Screenplay" version="0.6.0-alpha" />
+      <dependency id="CSF.Screenplay" version="0.7.0-alpha" />
     </dependencies>
   </metadata>
   <files>

CSF.Screenplay.NUnit/Properties/AssemblyInfo.cs

@@ -17,7 +17,7 @@
 // The form "{Major}.{Minor}.*" will automatically update the build and revision,
 // and "{Major}.{Minor}.{Build}.*" will update just the revision.
 
-[assembly: AssemblyVersion("0.6.0.0")]
+[assembly: AssemblyVersion("0.7.0.0")]
 
 // The following attributes are used to specify the signing key for the assembly, 
 // if desired. See the Mono documentation for more information about signing.

CSF.Screenplay.NUnit/ScenarioAdapter.cs

@@ -112,17 +112,27 @@ public ScenarioAdapter(ITest featureSuite, IMethodInfo scenarioMethod, IScreenpl
     }
 
     /// <summary>
-    /// Gets the success of a single test.
+    /// Gets a value which indicates whether a single test passed.
     /// </summary>
     /// <returns><c>true</c>, if the test was successful, <c>false</c> otherwise.</returns>
     /// <param name="test">Test.</param>
     public static bool GetSuccess(ITest test)
     {
-      // TODO: #96 - is this call to TestContext.CurrentContext thread-safe or not?
       var result = TestContext.CurrentContext.Result;
       return result.Outcome.Status == TestStatus.Passed;
     }
 
+    /// <summary>
+    /// Gets a value which indicates whether a single test failed.
+    /// </summary>
+    /// <returns><c>true</c>, if the test was a failure, <c>false</c> otherwise.</returns>
+    /// <param name="test">Test.</param>
+    public static bool GetFailure(ITest test)
+    {
+      var result = TestContext.CurrentContext.Result;
+      return result.Outcome.Status == TestStatus.Failed;
+    }
+
     /// <summary>
     /// Gets an <see cref="IScreenplayScenario"/> from a given NUnit test instance.
     /// </summary>

CSF.Screenplay.NUnit/ScreenplayAttribute.cs

@@ -45,9 +45,9 @@ public void BeforeTest(ITest test)
     public void AfterTest(ITest test)
     {
       var scenario = ScenarioAdapter.GetScenario(test);
-      var success = ScenarioAdapter.GetSuccess(test);
+      var outcome = GetOutcome(test);
       var integration = integrationReader.GetIntegration(test);
-      integration.AfterScenario(scenario, success);
+      integration.AfterScenario(scenario, outcome);
     }
 
     /// <summary>
@@ -63,6 +63,17 @@ public IEnumerable<TestMethod> BuildFrom(IMethodInfo method, Test suite)
       return BuildFrom(method, suite, scenario);
     }
 
+    bool? GetOutcome(ITest test)
+    {
+      var success = ScenarioAdapter.GetSuccess(test);
+      var failure = ScenarioAdapter.GetFailure(test);
+
+      if(success) return true;
+      if(failure) return false;
+
+      return null;
+    }
+
     IEnumerable<TestMethod> BuildFrom(IMethodInfo method, Test suite, IScreenplayScenario scenario)
     {
       var builder = new NUnitTestCaseBuilder();

CSF.Screenplay.Reporting/Builders/PerformanceBuilder.cs

@@ -79,18 +79,18 @@ public Performance GetPerformance()
                              Reportables.ToArray());
     }
 
-    Outcome GetOutcome()
+    PerformanceOutcome GetOutcome()
     {
       if(IsFailure && Exception != null)
-        return Outcome.FailureWithException;
+        return PerformanceOutcome.FailureWithException;
 
       if(IsFailure)
-        return Outcome.Failure;
+        return PerformanceOutcome.Failure;
 
       if(HasResult)
-        return Outcome.SuccessWithResult;
+        return PerformanceOutcome.SuccessWithResult;
 
-      return Outcome.Success;
+      return PerformanceOutcome.Success;
     }
 
     /// <summary>

CSF.Screenplay.Reporting/Builders/ReportBuilder.cs

@@ -1,5 +1,7 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Linq;
 using CSF.Screenplay.Abilities;
 using CSF.Screenplay.Actors;
 using CSF.Screenplay.Reporting.Models;
@@ -11,10 +13,7 @@ namespace CSF.Screenplay.Reporting.Builders
   /// </summary>
   public class ReportBuilder
   {
-    List<Models.Scenario> scenarios;
-    Models.Scenario currentScenario;
-    PerformanceType currentPerformanceType;
-    Stack<PerformanceBuilder> builderStack;
+    readonly ConcurrentDictionary<Guid, ScenarioBuilder> scenarios;
 
     /// <summary>
     /// Begins reporting upon a new scenario.
@@ -23,112 +22,113 @@ public class ReportBuilder
     /// <param name="featureName">The feature name.</param>
     /// <param name="idName">The uniquely identifying name for the test.</param>
     /// <param name="featureId">The uniquely identifying name for the feature.</param>
-    public void BeginNewScenario(string idName, string friendlyName = null, string featureName = null, string featureId = null)
+    /// <param name="scenarioId">The screenplay scenario identity.</param>
+    public void BeginNewScenario(string idName,
+                                 string friendlyName,
+                                 string featureName,
+                                 string featureId,
+                                 Guid scenarioId)
     {
-      currentScenario = new Models.Scenario(idName, friendlyName, featureName, featureId);
-      scenarios.Add(currentScenario);
-      currentPerformanceType = PerformanceType.Unspecified;
-      builderStack.Clear();
+      var success = scenarios.TryAdd(scenarioId, new ScenarioBuilder(idName, friendlyName, featureName, featureId));
+      if(!success)
+        throw new InvalidOperationException("The current scenario already exists in the current builder instance");
     }
 
     /// <summary>
     /// Reports the end of a scenario.
     /// </summary>
-    /// <param name="isSuccess">Optional.  If set to <c>false</c> then the scenario is marked as a failure.</param>
-    public void EndScenario(bool isSuccess = true)
+    /// <param name="outcome">If set to <c>false</c> then the scenario is marked as a failure.</param>
+    /// <param name="scenarioId">The screenplay scenario identity.</param>
+    public void EndScenario(bool? outcome,
+                            Guid scenarioId)
     {
-      EnsureCurrentScenario();
-
-      if(!isSuccess)
-        currentScenario.IsFailure = true;
-      
-      currentScenario = null;
-      builderStack.Clear();
+      var scenario = GetScenario(scenarioId);
+      scenario.Finalise(outcome);
     }
 
     /// <summary>
     /// Begins reporting of a new performable.
     /// </summary>
     /// <param name="actor">Actor.</param>
     /// <param name="performable">Performable.</param>
-    public void BeginPerformance(INamed actor, Performables.IPerformable performable)
+    /// <param name="scenarioId">The screenplay scenario identity.</param>
+    public void BeginPerformance(INamed actor, Performables.IPerformable performable,
+                                 Guid scenarioId)
     {
-      EnsureCurrentScenario();
-
-      var builder = new PerformanceBuilder {
-        Performable = performable,
-        Actor = actor,
-        PerformanceType = currentPerformanceType,
-      };
-      AddPerformanceBuilder(builder);
+      var scenario = GetScenario(scenarioId);
+      scenario.BeginPerformance(actor, performable);
     }
 
     /// <summary>
     /// Begins reporting of a performance of a given type.
     /// </summary>
     /// <param name="performanceType">Performance type.</param>
-    public void BeginPerformanceType(PerformanceType performanceType)
+    /// <param name="scenarioId">The screenplay scenario identity.</param>
+    public void BeginPerformanceType(PerformanceType performanceType,
+                                     Guid scenarioId)
     {
-      EnsureCurrentScenario();
-
-      performanceType.RequireDefinedValue(nameof(performanceType));
-      currentPerformanceType = performanceType;
+      var scenario = GetScenario(scenarioId);
+      scenario.BeginPerformanceType(performanceType);
     }
 
     /// <summary>
     /// Records that the current performable has received a result.
     /// </summary>
     /// <param name="performable">Performable.</param>
     /// <param name="result">Result.</param>
-    public void RecordResult(Performables.IPerformable performable, object result)
+    /// <param name="scenarioId">The screenplay scenario identity.</param>
+    public void RecordResult(Performables.IPerformable performable, object result,
+                             Guid scenarioId)
     {
-      var builder = PeekCurrentBuilder(performable);
-
-      builder.HasResult = true;
-      builder.Result = result;
+      var scenario = GetScenario(scenarioId);
+      scenario.RecordResult(performable, result);
     }
 
     /// <summary>
     /// Records that the current performable has failed with an exception.
     /// </summary>
     /// <param name="performable">Performable.</param>
     /// <param name="exception">Exception.</param>
-    public void RecordFailure(Performables.IPerformable performable, Exception exception)
+    /// <param name="scenarioId">The screenplay scenario identity.</param>
+    public void RecordFailure(Performables.IPerformable performable, Exception exception,
+                              Guid scenarioId)
     {
-      var builder = PeekCurrentBuilder(performable);
-
-      builder.IsFailure = true;
-      builder.Exception = exception;
-
-      FinalisePerformance(performable);
+      var scenario = GetScenario(scenarioId);
+      scenario.RecordFailure(performable, exception);
     }
 
     /// <summary>
     /// Records that the current performable has completed successfully.
     /// </summary>
     /// <param name="performable">Performable.</param>
-    public void RecordSuccess(Performables.IPerformable performable)
+    /// <param name="scenarioId">The screenplay scenario identity.</param>
+    public void RecordSuccess(Performables.IPerformable performable,
+                              Guid scenarioId)
     {
-      FinalisePerformance(performable);
+      var scenario = GetScenario(scenarioId);
+      scenario.RecordSuccess(performable);
     }
 
     /// <summary>
     /// Ends the performance of the current type.
     /// </summary>
-    public void EndPerformanceType()
+    public void EndPerformanceType(Guid scenarioId)
     {
-      currentPerformanceType = PerformanceType.Unspecified;
+      var scenario = GetScenario(scenarioId);
+      scenario.EndPerformanceType();
     }
 
     /// <summary>
     /// Reports that the given actor has gained the given ability.
     /// </summary>
     /// <param name="actor">Actor.</param>
     /// <param name="ability">Ability.</param>
-    public void GainAbility(INamed actor, IAbility ability)
+    /// <param name="scenarioId">The screenplay scenario identity.</param>
+    public void GainAbility(INamed actor, IAbility ability,
+                            Guid scenarioId)
     {
-      var item = new GainAbility(actor, Outcome.Success, ability, currentPerformanceType);
-      AddReportable(item);
+      var scenario = GetScenario(scenarioId);
+      scenario.GainAbility(actor, ability);
     }
 
     /// <summary>
@@ -137,86 +137,24 @@ public void GainAbility(INamed actor, IAbility ability)
     /// <returns>The report.</returns>
     public Report GetReport()
     {
-      return new Report(scenarios.ToArray());
-    }
-
-    void AddReportable(Reportable item)
-    {
-      if(item == null)
-        throw new ArgumentNullException(nameof(item));
-
-      var list = GetCurrentReportables();
-      list.Add(item);
-    }
-
-    void FinalisePerformance(Performables.IPerformable performable)
-    {
-      var builder = PopCurrentBuilder(performable);
-      var performance = builder.GetPerformance();
-      AddReportable(performance);
-    }
-
-    void AddPerformanceBuilder(PerformanceBuilder builder)
-    {
-      if(builder == null)
-        throw new ArgumentNullException(nameof(builder));
-
-      builderStack.Push(builder);
-    }
-
-    PerformanceBuilder PopCurrentBuilder(Performables.IPerformable expectedPerformable)
-    {
-      PeekCurrentBuilder(expectedPerformable);
-      return builderStack.Pop();
+      return new Report(scenarios.Values.Select(x => x.GetScenario()).ToArray());
     }
 
-    PerformanceBuilder PeekCurrentBuilder(Performables.IPerformable expectedPerformable = null)
+    ScenarioBuilder GetScenario(Guid identity)
     {
-      if(builderStack.Count == 0 && expectedPerformable == null)
-        return null;
-      else if(builderStack.Count == 0)
-        throw new InvalidOperationException("An expected performable was specified but the builder stack was empty, this is not permitted.");
-        
-      var current = builderStack.Peek();
-
-      if(expectedPerformable == null)
-        return current;
+      ScenarioBuilder scenario;
+      if(!scenarios.TryGetValue(identity, out scenario))
+        throw new InvalidOperationException("There is no matching scenario in the current builder.");
 
-      if(!ReferenceEquals(expectedPerformable, current.Performable))
-      {
-        throw new ArgumentException("The expected performable must be the same as the current builder.",
-                                    nameof(expectedPerformable));
-      }
-
-      return current;
-    }
-
-    IList<Reportable> GetCurrentReportables()
-    {
-      var currentBuilder = PeekCurrentBuilder();
-      if(currentBuilder != null)
-        return currentBuilder.Reportables;
-
-      if(currentScenario != null)
-        return currentScenario.Reportables;
-
-      throw new InvalidOperationException("Cannot get the current reportables, there must be either a current builder or a current scenario.");
-    }
-
-    void EnsureCurrentScenario()
-    {
-      if(ReferenceEquals(currentScenario, null))
-        throw new InvalidOperationException("There must be a current scenario in order to report upon performables.");
+      return scenario;
     }
 
     /// <summary>
     /// Initializes a new instance of the <see cref="ReportBuilder"/> class.
     /// </summary>
     public ReportBuilder()
     {
-      scenarios = new List<Models.Scenario>();
-      builderStack = new Stack<PerformanceBuilder>();
-      currentPerformanceType = PerformanceType.Unspecified;
+      scenarios = new ConcurrentDictionary<Guid,ScenarioBuilder>();
     }
   }
 }