Added support of sequential When in AAA.

Heleonix · Jun 30, 2018 · 6f6b6c4 · 6f6b6c4
1 parent 1d3f716
commit 6f6b6c4
Show file tree

Hide file tree

Showing 8 changed files with 270 additions and 52 deletions.
diff --git a/Docs/images/AAA.png b/Docs/images/AAA.png
diff --git a/Heleonix.Testing.NUnit.Tests/Aaa/AaaSpecTests.cs b/Heleonix.Testing.NUnit.Tests/Aaa/AaaSpecTests.cs
@@ -250,40 +250,5 @@ public static void When()
             Assert.That(node.NestingLevel, Is.EqualTo(0));
             Assert.That(node.Parent, Is.EqualTo(rootNode));
         }
-
-        /// <summary>
-        /// Tests integration of specs.
-        /// </summary>
-        [MemberTest(Name = nameof(Example))]
-        public static void Example()
-        {
-            AaaSpec.Arrange(() => { });
-
-            AaaSpec.Act(() => { });
-
-            AaaSpec.Teardown(() => { });
-
-            AaaSpec.When("When 1", () =>
-            {
-                AaaSpec.Arrange(() => { });
-
-                AaaSpec.Act(() => { });
-
-                AaaSpec.Teardown(() => { });
-
-                AaaSpec.Should("Should 1", () => { });
-
-                AaaSpec.And("And 1", () =>
-                {
-                    AaaSpec.Arrange(() => { });
-
-                    AaaSpec.Act(() => { });
-
-                    AaaSpec.Teardown(() => { });
-
-                    AaaSpec.Should("Should 2", () => { });
-                });
-            });
-        }
     }
 }
diff --git a/Heleonix.Testing.NUnit.Tests/Aaa/Examples/MyComponent.cs b/Heleonix.Testing.NUnit.Tests/Aaa/Examples/MyComponent.cs
@@ -0,0 +1,29 @@
+// <copyright file="MyComponent.cs" company="Heleonix - Hennadii Lutsyshyn">
+// Copyright (c) 2018-present Heleonix - Hennadii Lutsyshyn. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the repository root for full license information.
+// </copyright>
+
+namespace Heleonix.Testing.NUnit.Tests.Aaa.Examples
+{
+    /// <summary>
+    /// Dummy component.
+    /// </summary>
+    public static class MyComponent
+    {
+        /// <summary>
+        /// Dummy member.
+        /// </summary>
+        public static void Member1()
+        {
+            // Dummy member.
+        }
+
+        /// <summary>
+        /// Dummy member.
+        /// </summary>
+        public static void Member2()
+        {
+            // Dummy member.
+        }
+    }
+}
diff --git a/Heleonix.Testing.NUnit.Tests/Aaa/Examples/MyComponentTests.cs b/Heleonix.Testing.NUnit.Tests/Aaa/Examples/MyComponentTests.cs
@@ -0,0 +1,131 @@
+// <copyright file="MyComponentTests.cs" company="Heleonix - Hennadii Lutsyshyn">
+// Copyright (c) 2018-present Heleonix - Hennadii Lutsyshyn. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the repository root for full license information.
+// </copyright>
+
+namespace Heleonix.Testing.NUnit.Tests.Aaa.Examples
+{
+    using Heleonix.Testing.NUnit.Aaa;
+    using static Heleonix.Testing.NUnit.Aaa.AaaSpec;
+
+    /// <summary>
+    /// Tests the <see cref="MyComponent"/>.
+    /// </summary>
+    [ComponentTest(Type = typeof(MyComponent))]
+    public static class MyComponentTests
+    {
+        /// <summary>
+        /// Tests the <see cref="MyComponent.Member1"/>.
+        /// </summary>
+        [MemberTest(Name = nameof(MyComponent.Member1))]
+        public static void Member1()
+        {
+            Arrange(() =>
+            {
+            });
+
+            Act(() =>
+            {
+            });
+
+            Teardown(() =>
+            {
+            });
+
+            When("the condition #1 is true", () =>
+            {
+                Arrange(() =>
+                {
+                });
+
+                Act(() =>
+                {
+                });
+
+                Teardown(() =>
+                {
+                });
+
+                Should("lead to the result #1", () =>
+                {
+                });
+            });
+
+            When("the condition #2 is true", () =>
+            {
+                Arrange(() =>
+                {
+                });
+
+                Act(() =>
+                {
+                });
+
+                Teardown(() =>
+                {
+                });
+
+                Should("lead to the result #2", () =>
+                {
+                });
+            });
+        }
+
+        /// <summary>
+        /// Tests the <see cref="MyComponent.Member2"/>.
+        /// </summary>
+        [MemberTest(Name = nameof(MyComponent.Member2))]
+        public static void Member2()
+        {
+            Arrange(() =>
+            {
+            });
+
+            Act(() =>
+            {
+            });
+
+            Teardown(() =>
+            {
+            });
+
+            When("the action #1 is executed", () =>
+            {
+                Arrange(() =>
+                {
+                });
+
+                Act(() =>
+                {
+                });
+
+                Teardown(() =>
+                {
+                });
+
+                Should("lead to the result #1", () =>
+                {
+                });
+
+                And("the condition #1 is true", () =>
+                {
+                    Arrange(() =>
+                    {
+                    });
+
+                    Act(() =>
+                    {
+                    });
+
+                    Teardown(() =>
+                    {
+                    });
+
+                    Should("lead to the result #2", () =>
+                    {
+                    });
+                });
+            });
+        }
+    }
+}
diff --git a/Heleonix.Testing.NUnit.Tests/Aaa/Internal/AaaTestHostTests.cs b/Heleonix.Testing.NUnit.Tests/Aaa/Internal/AaaTestHostTests.cs
@@ -38,7 +38,7 @@ public static void SpecStructureRules()
 
             // Assert
             Assert.That(rules[SpecNodeType.When].SpecExecutionStackRule, Is.EqualTo("^$"));
-            Assert.That(rules[SpecNodeType.When].PredecessorsRule, Is.EqualTo("^(Arrange)|^(Act)|^(Teardown)|^$"));
+            Assert.That(rules[SpecNodeType.When].PredecessorsRule, Is.EqualTo("^(Arrange)|^(Act)|^(Teardown)|^(When)|^$"));
 
             Assert.That(rules[SpecNodeType.And].SpecExecutionStackRule, Is.EqualTo("^(And,)*(When)"));
             Assert.That(rules[SpecNodeType.And].PredecessorsRule, Is.EqualTo("^(Arrange)|^(Act)|^(Should)|^(Teardown)|^(And)|^$"));

diff --git a/Heleonix.Testing.NUnit.Tests/Heleonix.Testing.NUnit.Tests.csproj b/Heleonix.Testing.NUnit.Tests/Heleonix.Testing.NUnit.Tests.csproj
@@ -56,6 +56,8 @@
       <Link>Properties\SharedAssemblyInfo.cs</Link>
     </Compile>
     <Compile Include="Aaa\AaaSpecTests.cs" />
+    <Compile Include="Aaa\Examples\MyComponent.cs" />
+    <Compile Include="Aaa\Examples\MyComponentTests.cs" />
     <Compile Include="Aaa\Internal\AaaTestHostTests.cs" />
     <Compile Include="Bdd\BddSpecTests.cs" />
     <Compile Include="Bdd\Internal\BddTestHostTests.cs" />
@@ -100,12 +102,18 @@
     <PackageReference Include="Microsoft.CodeAnalysis.FxCopAnalyzers">
       <Version>2.6.0</Version>
     </PackageReference>
+    <PackageReference Include="Microsoft.NET.Test.Sdk">
+      <Version>15.7.2</Version>
+    </PackageReference>
     <PackageReference Include="moq">
       <Version>4.8.2</Version>
     </PackageReference>
     <PackageReference Include="nunit">
       <Version>3.9.0</Version>
     </PackageReference>
+    <PackageReference Include="NUnit3TestAdapter">
+      <Version>3.10.0</Version>
+    </PackageReference>
     <PackageReference Include="RoslynSecurityGuard">
       <Version>2.3.0</Version>
     </PackageReference>

diff --git a/Heleonix.Testing.NUnit/Aaa/Internal/AaaTestHost.cs b/Heleonix.Testing.NUnit/Aaa/Internal/AaaTestHost.cs
@@ -23,7 +23,7 @@ internal class AaaTestHost : TestHost
         protected override IDictionary<SpecNodeType, SpecStructureRule> SpecStructureRules { get; } =
             new Dictionary<SpecNodeType, SpecStructureRule>
             {
-                { SpecNodeType.When, new SpecStructureRule("^$", "^(Arrange)|^(Act)|^(Teardown)|^$") },
+                { SpecNodeType.When, new SpecStructureRule("^$", "^(Arrange)|^(Act)|^(Teardown)|^(When)|^$") },
                 {
                     SpecNodeType.And, new SpecStructureRule(
                         "^(And,)*(When)",

diff --git a/README.md b/README.md
@@ -11,37 +11,122 @@ https://www.nuget.org/packages/Heleonix.Testing.NUnit
 using Heleonix.Testing.NUnit.Aaa;
 using static Heleonix.Testing.NUnit.Aaa.AaaSpec;
 
-[ComponentTest(Type = typeof(Component))]
-public static class ComponentTests
+/// <summary>
+/// Tests the <see cref="MyComponent"/>.
+/// </summary>
+[ComponentTest(Type = typeof(MyComponent))]
+public static class MyComponentTests
 {
-    [MemberTest(Name = nameof(Component.Member))]
-    public static void Member()
+    /// <summary>
+    /// Tests the <see cref="MyComponent.Member1"/>.
+    /// </summary>
+    [MemberTest(Name = nameof(MyComponent.Member1))]
+    public static void Member1()
     {
-        Arrange(() => { });
+        Arrange(() =>
+        {
+        });
+
+        Act(() =>
+        {
+        });
+
+        Teardown(() =>
+        {
+        });
 
-        Act(() => { });
+        When("the condition #1 is true", () =>
+        {
+            Arrange(() =>
+            {
+            });
+
+            Act(() =>
+            {
+            });
 
-        Teardown(() => { });
+            Teardown(() =>
+            {
+            });
+
+            Should("lead to the result #1", () =>
+            {
+            });
+        });
+
+        When("the condition #2 is true", () =>
+        {
+            Arrange(() =>
+            {
+            });
+
+            Act(() =>
+            {
+            });
+
+            Teardown(() =>
+            {
+            });
+
+            Should("lead to the result #2", () =>
+            {
+            });
+        });
+    }
+
+    /// <summary>
+    /// Tests the <see cref="MyComponent.Member2"/>.
+    /// </summary>
+    [MemberTest(Name = nameof(MyComponent.Member2))]
+    public static void Member2()
+    {
+        Arrange(() =>
+        {
+        });
+
+        Act(() =>
+        {
+        });
+
+        Teardown(() =>
+        {
+        });
 
         When("the action #1 is executed", () =>
         {
-            Arrange(() => { });
+            Arrange(() =>
+            {
+            });
 
-            Act(() => { });
+            Act(() =>
+            {
+            });
 
-            Teardown(() => { });
+            Teardown(() =>
+            {
+            });
 
-            Should("lead to the result #1", () => { });
+            Should("lead to the result #1", () =>
+            {
+            });
 
             And("the condition #1 is true", () =>
             {
-                Arrange(() => { });
+                Arrange(() =>
+                {
+                });
 
-                Act(() => { });
+                Act(() =>
+                {
+                });
 
-                Teardown(() => { });
+                Teardown(() =>
+                {
+                });
 
-                Should("lead to the result #2", () => { });
+                Should("lead to the result #2", () =>
+                {
+                });
             });
         });
     }