Examples

.gitattributes

@@ -17,4 +17,6 @@
 
 # Denote all files that are truly binary and should not be modified.
 *.exe binary
-*.dll binary
+*.dll binary
+
+*.approved.* binary

.gitignore

@@ -3,7 +3,6 @@ bin/
 obj/
 *.user
 *.suo
-*.DotSettings
 *~
 *.swp
 *.orig

Samples/TestStack.BDDfy.Samples/BDDfyConfiguration.cs

@@ -1,7 +1,6 @@
 using NUnit.Framework;
 using TestStack.BDDfy.Configuration;
 using TestStack.BDDfy.Reporters.Html;
-using TestStack.BDDfy.Reporters.HtmlMetro;
 using TestStack.BDDfy.Samples.Atm;
 
 namespace TestStack.BDDfy.Samples
@@ -15,7 +14,7 @@ public void Config()
             Configurator.Processors.Add(() => new CustomTextReporter());
             Configurator.BatchProcessors.MarkDownReport.Enable();
             Configurator.BatchProcessors.DiagnosticsReport.Enable();
-            Configurator.BatchProcessors.Add(new HtmlReporter(new AtmHtmlReportConfig(), new HtmlMetroReportBuilder()));
+            Configurator.BatchProcessors.Add(new HtmlReporter(new AtmHtmlReportConfig(), new MetroReportBuilder()));
         }
     }
 }

Samples/TestStack.BDDfy.Samples/BuyingTrainFareWithExamples.cs

@@ -0,0 +1,59 @@
+using NUnit.Framework;
+using TestStack.BDDfy.Samples.BuyingTrainFares;
+
+namespace TestStack.BDDfy.Samples
+{
+    [TestFixture]
+    public class BuyingTrainFareWithExamples
+    {
+        private Fare fare;
+        private BuyerCategory _buyerCategory;
+        Money Price { get; set; }
+
+        [Test]
+        public void SuccessfulRailCardPurchases()
+        {
+            this.Given(_ => TheBuyerIsA(_buyerCategory))
+                .And(_ => TheBuyerSelectsA(fare))
+                .When(_ => TheBuyerPays())
+                .Then(_ => ASaleOccursWithAnAmountOf(Price))
+                .WithExamples(new ExampleTable(
+                    "Buyer Category", "Fare", "Price")
+                {
+                    {BuyerCategory.Student, new MonthlyPass(), new Money(76)},
+                    {BuyerCategory.Senior, new MonthlyPass(), new Money(98)},
+                    {BuyerCategory.Standard, new MonthlyPass(), new Money(146)},
+                    {BuyerCategory.Student, new WeeklyPass(), new Money(23)},
+                    {BuyerCategory.Senior, new WeeklyPass(), new Money(30)},
+                    {BuyerCategory.Standard, new WeeklyPass(), new Money(44)},
+                    {BuyerCategory.Student, new DayPass(), new Money(4)},
+                    {BuyerCategory.Senior, new DayPass(), new Money(5)},
+                    {BuyerCategory.Standard, new DayPass(), new Money(7)},
+                    {BuyerCategory.Student, new SingleTicket(), new Money(1.5m)},
+                    {BuyerCategory.Senior, new SingleTicket(), new Money(2m)},
+                    {BuyerCategory.Standard, new SingleTicket(), new Money(3m)}
+                })
+                .BDDfy("Successful rail card purchases");
+        }
+
+        void TheBuyerIsA(BuyerCategory buyerCategory)
+        {
+
+        }
+
+        void TheBuyerSelectsA(Fare fare)
+        {
+
+        }
+
+        void TheBuyerPays()
+        {
+
+        }
+
+        void ASaleOccursWithAnAmountOf(Money price)
+        {
+
+        }
+    }
+}

Samples/TestStack.BDDfy.Samples/BuyingTrainFares/BuyerCategory.cs

@@ -0,0 +1,9 @@
+namespace TestStack.BDDfy.Samples.BuyingTrainFares
+{
+    enum BuyerCategory
+    {
+        Student,
+        Senior,
+        Standard
+    }
+}

Samples/TestStack.BDDfy.Samples/BuyingTrainFares/DayPass.cs

@@ -0,0 +1,10 @@
+namespace TestStack.BDDfy.Samples.BuyingTrainFares
+{
+    class DayPass : Fare
+    {
+        public override string ToString()
+        {
+            return "Day Pass";
+        }
+    }
+}

Samples/TestStack.BDDfy.Samples/BuyingTrainFares/Fare.cs

@@ -0,0 +1,7 @@
+namespace TestStack.BDDfy.Samples.BuyingTrainFares
+{
+    class Fare
+    {
+
+    }
+}

Samples/TestStack.BDDfy.Samples/BuyingTrainFares/Money.cs

@@ -0,0 +1,47 @@
+using System.Globalization;
+
+namespace TestStack.BDDfy.Samples.BuyingTrainFares
+{
+    class Money
+    {
+        public Money(decimal amount)
+        {
+            Amount = amount;
+        }
+
+        public decimal Amount { get; set; }
+
+        protected bool Equals(Money other)
+        {
+            return Amount == other.Amount;
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (ReferenceEquals(null, obj)) return false;
+            if (ReferenceEquals(this, obj)) return true;
+            if (obj.GetType() != GetType()) return false;
+            return Equals((Money)obj);
+        }
+
+        public override int GetHashCode()
+        {
+            return Amount.GetHashCode();
+        }
+
+        public static bool operator ==(Money left, Money right)
+        {
+            return Equals(left, right);
+        }
+
+        public static bool operator !=(Money left, Money right)
+        {
+            return !Equals(left, right);
+        }
+
+        public override string ToString()
+        {
+            return Amount.ToString("C", CultureInfo.CreateSpecificCulture("EN-US"));
+        }
+    }
+}

Samples/TestStack.BDDfy.Samples/BuyingTrainFares/MonthlyPass.cs

@@ -0,0 +1,10 @@
+namespace TestStack.BDDfy.Samples.BuyingTrainFares
+{
+    class MonthlyPass : Fare
+    {
+        public override string ToString()
+        {
+            return "Monthly Pass";
+        }
+    }
+}

Samples/TestStack.BDDfy.Samples/BuyingTrainFares/SingleTicket.cs

@@ -0,0 +1,10 @@
+namespace TestStack.BDDfy.Samples.BuyingTrainFares
+{
+    class SingleTicket : Fare
+    {
+        public override string ToString()
+        {
+            return "Day Pass";
+        }
+    }
+}

Samples/TestStack.BDDfy.Samples/BuyingTrainFares/WeeklyPass.cs

@@ -0,0 +1,10 @@
+namespace TestStack.BDDfy.Samples.BuyingTrainFares
+{
+    class WeeklyPass : Fare
+    {
+        public override string ToString()
+        {
+            return "Weekly Pass";
+        }
+    }
+}

Samples/TestStack.BDDfy.Samples/AsyncExample.cs → Samples/TestStack.BDDfy.Samples/CanRunAsyncSteps.cs

@@ -4,7 +4,7 @@
 
 namespace TestStack.BDDfy.Samples
 {
-    public class AsyncExample
+    public class CanRunAsyncSteps
     {
         private Sut _sut;
 
@@ -33,19 +33,10 @@ private async Task<Sut> CreateSut()
         [Test]
         public void Run()
         {
-            try
-            {
-                // we need TestObject for this test; so I disable StoryCache processor for this one test
-                Configuration.Configurator.Processors.StoryCache.Disable();
-                var engine = this.LazyBDDfy();
-                var exception = Assert.Throws<Exception>(() => engine.Run());
-
-                Assert.AreEqual("Exception in async void method!!", exception.Message);
-            }
-            finally
-            {
-                Configuration.Configurator.Processors.StoryCache.Enable();
-            }
+            var engine = this.LazyBDDfy();
+            var exception = Assert.Throws<Exception>(() => engine.Run());
+
+            Assert.AreEqual("Exception in async void method!!", exception.Message);
         }
 
         internal class Sut

Samples/TestStack.BDDfy.Samples/TestStack.BDDfy.Samples.csproj

@@ -44,7 +44,15 @@
     <Folder Include="Properties\" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="AsyncExample.cs" />
+    <Compile Include="BuyingTrainFares\BuyerCategory.cs" />
+    <Compile Include="BuyingTrainFares\DayPass.cs" />
+    <Compile Include="BuyingTrainFares\Fare.cs" />
+    <Compile Include="BuyingTrainFares\Money.cs" />
+    <Compile Include="BuyingTrainFares\MonthlyPass.cs" />
+    <Compile Include="BuyingTrainFares\SingleTicket.cs" />
+    <Compile Include="BuyingTrainFares\WeeklyPass.cs" />
+    <Compile Include="BuyingTrainFareWithExamples.cs" />
+    <Compile Include="CanRunAsyncSteps.cs" />
     <Compile Include="Atm\AccountHasInsufficientFund.cs" />
     <Compile Include="Atm\Atm.cs" />
     <Compile Include="Atm\AccountHolderWithdrawsCash.cs" />
@@ -58,6 +66,8 @@
     <Compile Include="TicTacToe\TicTacToe.cs" />
     <Compile Include="TicTacToe\WinnerGame.cs" />
     <Compile Include="TicTacToe\XWins.cs" />
+    <Compile Include="UseExamplesWithReflectiveApi.cs" />
+    <Compile Include="UseExamplesWithFluentApi.cs" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="nunit.framework">

Samples/TestStack.BDDfy.Samples/TestStack.BDDfy.Samples.v2.ncrunchproject

@@ -0,0 +1,22 @@
+<ProjectConfiguration>
+  <CopyReferencedAssembliesToWorkspace>false</CopyReferencedAssembliesToWorkspace>
+  <ConsiderInconclusiveTestsAsPassing>false</ConsiderInconclusiveTestsAsPassing>
+  <PreloadReferencedAssemblies>false</PreloadReferencedAssemblies>
+  <AllowDynamicCodeContractChecking>true</AllowDynamicCodeContractChecking>
+  <AllowStaticCodeContractChecking>false</AllowStaticCodeContractChecking>
+  <IgnoreThisComponentCompletely>false</IgnoreThisComponentCompletely>
+  <RunPreBuildEvents>false</RunPreBuildEvents>
+  <RunPostBuildEvents>false</RunPostBuildEvents>
+  <PreviouslyBuiltSuccessfully>true</PreviouslyBuiltSuccessfully>
+  <InstrumentAssembly>true</InstrumentAssembly>
+  <PreventSigningOfAssembly>false</PreventSigningOfAssembly>
+  <AnalyseExecutionTimes>true</AnalyseExecutionTimes>
+  <IncludeStaticReferencesInWorkspace>true</IncludeStaticReferencesInWorkspace>
+  <DefaultTestTimeout>60000</DefaultTestTimeout>
+  <UseBuildConfiguration />
+  <UseBuildPlatform />
+  <ProxyProcessPath />
+  <UseCPUArchitecture>AutoDetect</UseCPUArchitecture>
+  <MSTestThreadApartmentState>STA</MSTestThreadApartmentState>
+  <BuildProcessArchitecture>x86</BuildProcessArchitecture>
+</ProjectConfiguration>

Samples/TestStack.BDDfy.Samples/UseExamplesWithFluentApi.cs

@@ -0,0 +1,53 @@
+using NUnit.Framework;
+
+namespace TestStack.BDDfy.Samples
+{
+    [TestFixture]
+    public class UseExamplesWithFluentApi
+    {
+        public int Start { get; set; }
+        public int Eat { get; set; }
+        public int Left { get; set; }
+
+        [Test]
+        public void RunExamplesWithFluentApi()
+        {
+            this.Given("Given there are <start> cucumbers")
+                    .And(_ => _.AndIStealTwoMore())
+                .When(_ => _.WhenIEat__eat__Cucumbers())
+                .Then(_ => _.ThenIShouldHave__left__Cucumbers())
+                .WithExamples(new ExampleTable("Start", "Eat", "Left")
+                {
+                    {12, 5, 9},
+                    {20, 5, 17}
+                })
+                .BDDfy();
+        }
+
+
+        // I didn't have to create this method 
+        // because all it was going to do was to set Start property 
+        // which is being handled by the framework
+        // And the step title is provided inline
+        //private void GivenThereAre__start__Cucumbers()
+        //{
+        //}
+
+        private void AndIStealTwoMore()
+        {
+            Start += 2;
+        }
+
+        private void WhenIEat__eat__Cucumbers()
+        {
+            // This method is called after the Eat property is set by the framework
+            // I didn't have to put this here, like the Given method, but I put it here to show that 
+            // you can take additional actions here if you want
+        }
+
+        private void ThenIShouldHave__left__Cucumbers()
+        {
+            Assert.That(Start - Eat, Is.EqualTo(Left));
+        }
+    }
+}

Samples/TestStack.BDDfy.Samples/UseExamplesWithReflectiveApi.cs

@@ -0,0 +1,45 @@
+using NUnit.Framework;
+
+namespace TestStack.BDDfy.Samples
+{
+    [TestFixture]
+    public class UseExamplesWithReflectiveApi
+    {
+        private int _start;
+        private int _eat;
+
+        [Test]
+        public void CanRunExamplesWithReflectiveApi()
+        {
+            this.WithExamples(new ExampleTable("Start", "Eat", "Left")
+                {
+                    {12, 5, 7},
+                    {20, 5, 15}
+                })
+                .BDDfy();
+        }
+
+        void GivenThereAre__start__Cucumbers(int start)
+        {
+            // the start argument is provided by the framework based on the example entries
+            // please note that `start` argument name matches the `start` header from the examples
+            // and also it has to match with the <start> placeholder in the step title which is created based on conventions
+            _start = start;
+        }
+
+        [AndGiven("And I eat <eat> of them")]
+        void WhenIEatAFewCucumbers(int eat)
+        {
+            // the eat argument is provided by the framework based on the example entries
+            // please note that `eat` argument name matches the `start` header from the examples
+            // and also it has to match the <eat> placeholder in the step title
+            _eat = eat;
+        }
+
+        void ThenIShouldHave__left__Cucumbers(int left)
+        {
+            // like given and when steps left is provided here because it matches the example header and is found on the step title
+            Assert.That(_start - _eat, Is.EqualTo(left));
+        }
+    }
+}