renamed ExecutionStep to Step & its StepTitle to Title

Author: MehdiK

Samples/TestStack.BDDfy.Samples/CustomTextReporter.cs

@@ -59,7 +59,7 @@ public void Process(Story story)
             scenarioReport.AppendLine();
 
             foreach (var step in scenario.Steps)
-                scenarioReport.AppendLine(string.Format("   [{1}] {0}", step.StepTitle, step.Result));
+                scenarioReport.AppendLine(string.Format("   [{1}] {0}", step.Title, step.Result));
 
             scenarioReport.AppendLine("--------------------------------------------------------------------------------");
             scenarioReport.AppendLine();

TestStack.BDDfy.Tests/Exceptions/ExceptionThrowingTest.cs

@@ -86,35 +86,35 @@ private void SetThrowingStep(ThrowingMethods methodToThrow)
             }
         }
 
-        private ExecutionStep GetStep(string stepTitle)
+        private Step GetStep(string stepTitle)
         {
-            return _scenario.Steps.First(s => s.StepTitle == stepTitle);
+            return _scenario.Steps.First(s => s.Title == stepTitle);
         }
 
-        ExecutionStep GivenStep
+        Step GivenStep
         {
             get
             {
                 return GetStep("Given");
             }
         }
 
-        ExecutionStep WhenStep
+        Step WhenStep
         {
             get {
                 return GetStep("When");
             }
         }
 
-        ExecutionStep ThenStep
+        Step ThenStep
         {
             get
             {
                 return GetStep("Then");
             }
         }
 
-        ExecutionStep TearDownStep
+        Step TearDownStep
         {
             get
             {

TestStack.BDDfy.Tests/Exceptions/WhenAnInconclusiveTestIsRun.cs

@@ -30,35 +30,35 @@ public void TearDownThis()
         Engine _engine;
         private Scenario _scenario;
 
-        ExecutionStep GivenStep
+        Step GivenStep
         {
             get
             {
-                return _scenario.Steps.Single(s => s.StepTitle == "Given a class under test");
+                return _scenario.Steps.Single(s => s.Title == "Given a class under test");
             }
         }
 
-        ExecutionStep WhenStep
+        Step WhenStep
         {
             get
             {
-                return _scenario.Steps.Single(s => s.StepTitle == "When inconclusive exception is thrown in one of the methods");
+                return _scenario.Steps.Single(s => s.Title == "When inconclusive exception is thrown in one of the methods");
             }
         }
 
-        ExecutionStep ThenStep
+        Step ThenStep
         {
             get
             {
-                return _scenario.Steps.Single(s => s.StepTitle == "Then the context is flagged as inconclusive");
+                return _scenario.Steps.Single(s => s.Title == "Then the context is flagged as inconclusive");
             }
         }
 
-        ExecutionStep DisposeStep
+        Step DisposeStep
         {
             get
             {
-                return _scenario.Steps.Single(s => s.StepTitle == "Tear down this");
+                return _scenario.Steps.Single(s => s.Title == "Tear down this");
             }
         }
 

TestStack.BDDfy.Tests/FluentScanner/ScenarioToBeScannedUsingFluentScanner.cs

@@ -71,7 +71,7 @@ public void AndIncorrectAttributeWouldNotMatter()
         public void Dispose()
         {}
 
-        public static IEnumerable<ExecutionStep> GetSteps(ScenarioToBeScannedUsingFluentScanner testObject)
+        public static IEnumerable<Step> GetSteps(ScenarioToBeScannedUsingFluentScanner testObject)
         {
             var fluentScanner = testObject
                 .Given(s => s.GivenSomeState(1, 2))

TestStack.BDDfy.Tests/FluentScanner/WhenStepsAreScannedUsingFluentScanner.cs

@@ -7,7 +7,7 @@ namespace TestStack.BDDfy.Tests.FluentScanner
     [TestFixture]
     public class WhenStepsAreScannedUsingFluentScanner
     {
-        private IEnumerable<ExecutionStep> _steps;
+        private IEnumerable<Step> _steps;
 
         [SetUp]
         public void Setup()
@@ -22,11 +22,11 @@ public void IndicatedStepsAreReturned()
             Assert.That(_steps.Count(), Is.EqualTo(12));
         }
 
-        ExecutionStep GivenSomeStateStep
+        Step GivenSomeStateStep
         {
             get
             {
-                return _steps.Single(s => s.StepTitle == "Given some state 1, 2");
+                return _steps.Single(s => s.Title == "Given some state 1, 2");
             }
         }
 
@@ -48,11 +48,11 @@ public void GivenSomeState_StepReports()
             Assert.IsTrue(GivenSomeStateStep.ShouldReport);        
         }
 
-        ExecutionStep WhenSomeStepUsesIncompatibleNamingConventionStep
+        Step WhenSomeStepUsesIncompatibleNamingConventionStep
         {
             get
             {
-                return _steps.Single(s => s.StepTitle.Trim() == "When some step uses incompatible naming convention");
+                return _steps.Single(s => s.Title.Trim() == "When some step uses incompatible naming convention");
             }
         }
 
@@ -74,11 +74,11 @@ public void WhenSomeStepUsesIncompatibleNamingConvention_Reports()
             Assert.IsTrue(WhenSomeStepUsesIncompatibleNamingConventionStep.ShouldReport);        
         }
 
-        ExecutionStep AndAMethodTakesArrayInputsStep
+        Step AndAMethodTakesArrayInputsStep
         {
             get
             {
-                return _steps.Single(s => s.StepTitle.Trim() == "And a method takes array inputs 1, 2, 3, 4, 5");
+                return _steps.Single(s => s.Title.Trim() == "And a method takes array inputs 1, 2, 3, 4, 5");
             }
         }
 
@@ -100,11 +100,11 @@ public void AndAMethodTakesArrayInputs_Reports()
             Assert.IsTrue(AndAMethodTakesArrayInputsStep.ShouldReport);
         }
 
-        ExecutionStep WhenSomethingHappensTransitionStep
+        Step WhenSomethingHappensTransitionStep
         {
             get
             {
-                return _steps.Single(s => s.StepTitle == "When something happens some input here");
+                return _steps.Single(s => s.Title == "When something happens some input here");
             }
         }
 
@@ -126,11 +126,11 @@ public void WhenSomethingHappensTransitionStep_Reports()
             Assert.IsTrue(WhenSomethingHappensTransitionStep.ShouldReport);        
         }
 
-        ExecutionStep WhenSomethingHappensTransitionStepIgnoringInputInStepTitle
+        Step WhenSomethingHappensTransitionStepIgnoringInputInStepTitle
         {
             get
             {
-                return _steps.Single(s => s.StepTitle == "When something happens");
+                return _steps.Single(s => s.Title == "When something happens");
             }
         }
 
@@ -152,11 +152,11 @@ public void WhenSomethingHappensTransitionStepIgnoringInputInStepTitle_Reports()
             Assert.IsTrue(WhenSomethingHappensTransitionStepIgnoringInputInStepTitle.ShouldReport);        
         }
 
-        ExecutionStep WhenSomethingHappensConsecutiveTransitionStep
+        Step WhenSomethingHappensConsecutiveTransitionStep
         {
             get
             {
-                return _steps.Single(s => s.StepTitle.Trim() == "step used with other input for the second time");
+                return _steps.Single(s => s.Title.Trim() == "step used with other input for the second time");
             }
         }
 
@@ -178,11 +178,11 @@ public void WhenSomethingHappensConsecutiveTransitionStep_Reports()
             Assert.IsTrue(WhenSomethingHappensConsecutiveTransitionStep.ShouldReport);        
         }
 
-        ExecutionStep AndThenSomethingElseHappensStep
+        Step AndThenSomethingElseHappensStep
         {
             get
             {
-                return _steps.Single(s => s.StepTitle.Trim() == "Overriding step name without arguments");
+                return _steps.Single(s => s.Title.Trim() == "Overriding step name without arguments");
             }
         }
 
@@ -204,11 +204,11 @@ public void AndThenSomethingElseHappensStep_Reports()
             Assert.IsTrue(AndThenSomethingElseHappensStep.ShouldReport);        
         }
 
-        ExecutionStep ThenTheFollowingAssertionsShouldBeCorrectStep
+        Step ThenTheFollowingAssertionsShouldBeCorrectStep
         {
             get
             {
-                return _steps.Single(s => s.StepTitle == "Then the following assertions should be correct");
+                return _steps.Single(s => s.Title == "Then the following assertions should be correct");
             }
         }
 
@@ -230,11 +230,11 @@ public void ThenTheFollowingAssertionsShouldBeCorrectStep_Reports()
             Assert.IsTrue(ThenTheFollowingAssertionsShouldBeCorrectStep.ShouldReport);        
         }
 
-        ExecutionStep AndIncorrectAttributeWouldNotMatterStep
+        Step AndIncorrectAttributeWouldNotMatterStep
         {
             get
             {
-                return _steps.Single(s => s.StepTitle.Trim() == "And incorrect attribute would not matter");
+                return _steps.Single(s => s.Title.Trim() == "And incorrect attribute would not matter");
             }
         }
 
@@ -256,15 +256,15 @@ public void AndIncorrectAttributeWouldNotMatterStep_Reports()
             Assert.IsTrue(AndIncorrectAttributeWouldNotMatterStep.ShouldReport);        
         }
 
-        ExecutionStep AndInputsAreFormattedPropertlyInTheTitle
+        Step AndInputsAreFormattedPropertlyInTheTitle
         {
             get
             {
                 var formattedTitle = string.Format(
                     ScenarioToBeScannedUsingFluentScanner.InputDateStepTitleTemplate, 
                     ScenarioToBeScannedUsingFluentScanner.InputDate);
 
-                return _steps.Single(s => s.StepTitle.Trim() == formattedTitle);
+                return _steps.Single(s => s.Title.Trim() == formattedTitle);
             }
         }
 
@@ -274,11 +274,11 @@ public void AndInputsAreFormattedPropertlyInTheTitle_IsAConsecutiveAssertingStep
             Assert.That(AndInputsAreFormattedPropertlyInTheTitle.ExecutionOrder, Is.EqualTo(ExecutionOrder.ConsecutiveAssertion));
         }
 
-        ExecutionStep TearDownStep
+        Step TearDownStep
         {
             get
             {
-                return _steps.Single(s => s.StepTitle == "Dispose");
+                return _steps.Single(s => s.Title == "Dispose");
             }
         }
 

TestStack.BDDfy.Tests/Reporters/ReportTestData.cs

@@ -28,24 +28,24 @@ private Scenario[] GetScenarios()
             return scenarios.ToArray();
         }
 
-        private IEnumerable<ExecutionStep> GetHappyExecutionSteps()
+        private IEnumerable<Step> GetHappyExecutionSteps()
         {
-            var steps = new List<ExecutionStep>()
+            var steps = new List<Step>()
             {
-                new ExecutionStep(null, "Given a positive account balance", true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
-                new ExecutionStep(null, "When the account holder requests money", true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
-                new ExecutionStep(null, "Then money is dispensed", true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
+                new Step(null, "Given a positive account balance", true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
+                new Step(null, "When the account holder requests money", true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
+                new Step(null, "Then money is dispensed", true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
             };
             return steps;
         }
 
-        private IEnumerable<ExecutionStep> GetSadExecutionSteps()
+        private IEnumerable<Step> GetSadExecutionSteps()
         {
-            var steps = new List<ExecutionStep>()
+            var steps = new List<Step>()
             {
-                new ExecutionStep(null, "Given a negative account balance", true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
-                new ExecutionStep(null, "When the account holder requests money", true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
-                new ExecutionStep(null, "Then no money is dispensed", true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
+                new Step(null, "Given a negative account balance", true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
+                new Step(null, "When the account holder requests money", true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
+                new Step(null, "Then no money is dispensed", true, ExecutionOrder.Assertion, true) {Duration = new TimeSpan(0, 0, 0, 0, 5)},
             };
             return steps;
         }