Introduce regions for orderly specs

Author: Ronald Kroon

Tests/FluentAssertions.Json.Shared.Specs/JTokenAssertionsSpecs.cs

@@ -12,6 +12,8 @@ public class JTokenAssertionsSpecs
 
         private static readonly JTokenFormatter _formatter = new JTokenFormatter();
 
+        #region (Not)Be
+
         [TestMethod]
         public void When_both_values_are_the_same_or_equal_Be_should_succeed()
         {
@@ -29,6 +31,44 @@ public void When_both_values_are_the_same_or_equal_Be_should_succeed()
             a.Should().Be(b);
         }
 
+        [TestMethod]
+        public void When_values_differ_Be_should_fail()
+        {
+            //-----------------------------------------------------------------------------------------------------------
+            // Arrange
+            //-----------------------------------------------------------------------------------------------------------
+            var testCases = new Dictionary<string, string>
+            {
+                {
+                    "{ id: 1 }",
+                    "{ id: 2 }"
+                },
+                {
+                    "{ id: 1, admin: true }",
+                    "{ id: 1, admin: false }"
+                }
+            };
+
+            foreach (var testCase in testCases)
+            {
+                var actualJson = testCase.Key;
+                var expectedJson = testCase.Value;
+
+                var a = JToken.Parse(actualJson);
+                var b = JToken.Parse(expectedJson);
+
+                var expectedMessage =
+                    $"Expected JSON document to be {_formatter.ToString(b)}, but found {_formatter.ToString(a)}.";
+
+                //-----------------------------------------------------------------------------------------------------------
+                // Act & Assert
+                //-----------------------------------------------------------------------------------------------------------
+                a.Should().Invoking(x => x.Be(b))
+                    .ShouldThrow<AssertFailedException>()
+                    .WithMessage(expectedMessage);
+            }
+        }
+
         [TestMethod]
         public void When_values_differ_NotBe_should_succeed()
         {
@@ -63,6 +103,9 @@ public void When_values_are_equal_or_equivalent_NotBe_should_fail()
                 .WithMessage($"Expected JSON document not to be {_formatter.ToString(b)}.");
         }
 
+        #endregion (Not)Be
+
+        #region (Not)BeEquivalentTo
 
         [TestMethod]
         public void When_both_values_are_equal_BeEquivalentTo_should_succeed()
@@ -97,46 +140,13 @@ public void When_both_values_are_equal_BeEquivalentTo_should_succeed()
         }
 
         [TestMethod]
-        public void When_values_differ_NotBeEquivalentTo_should_succeed()
-        {
-            //-----------------------------------------------------------------------------------------------------------
-            // Arrange
-            //-----------------------------------------------------------------------------------------------------------
-            var testCases = new Dictionary<string, string>
-            {
-                {
-                    "{ id: 1, admin: true }",
-                    "{ id: 1, admin: false }"
-                }
-            };
-
-            foreach (var testCase in testCases)
-            {
-                var actualJson = testCase.Key;
-                var expectedJson = testCase.Value;
-
-                var a = JToken.Parse(actualJson);
-                var b = JToken.Parse(expectedJson);
-
-                //-----------------------------------------------------------------------------------------------------------
-                // Act & Assert
-                //-----------------------------------------------------------------------------------------------------------
-                a.Should().NotBeEquivalentTo(b);
-            }
-        }
-
-        [TestMethod]
-        public void When_values_differ_Be_should_fail()
+        public void When_values_differ_BeEquivalentTo_should_fail()
         {
             //-----------------------------------------------------------------------------------------------------------
             // Arrange
             //-----------------------------------------------------------------------------------------------------------
             var testCases = new Dictionary<string, string>
             {
-                {
-                    "{ id: 1 }",
-                    "{ id: 2 }"
-                },
                 {
                     "{ id: 1, admin: true }",
                     "{ id: 1, admin: false }"
@@ -151,20 +161,19 @@ public void When_values_differ_Be_should_fail()
                 var a = JToken.Parse(actualJson);
                 var b = JToken.Parse(expectedJson);
 
-                var expectedMessage =
-                    $"Expected JSON document to be {_formatter.ToString(b)}, but found {_formatter.ToString(a)}.";
+                var expectedMessage = GetNotEquivalentMessage(a, b);
 
                 //-----------------------------------------------------------------------------------------------------------
                 // Act & Assert
                 //-----------------------------------------------------------------------------------------------------------
-                a.Should().Invoking(x => x.Be(b))
+                a.Should().Invoking(x => x.BeEquivalentTo(b))
                     .ShouldThrow<AssertFailedException>()
                     .WithMessage(expectedMessage);
             }
         }
 
         [TestMethod]
-        public void When_values_differ_BeEquivalentTo_should_fail()
+        public void When_values_differ_NotBeEquivalentTo_should_succeed()
         {
             //-----------------------------------------------------------------------------------------------------------
             // Arrange
@@ -185,14 +194,10 @@ public void When_values_differ_BeEquivalentTo_should_fail()
                 var a = JToken.Parse(actualJson);
                 var b = JToken.Parse(expectedJson);
 
-                var expectedMessage = GetNotEquivalentMessage(a, b);
-
                 //-----------------------------------------------------------------------------------------------------------
                 // Act & Assert
                 //-----------------------------------------------------------------------------------------------------------
-                a.Should().Invoking(x => x.BeEquivalentTo(b))
-                    .ShouldThrow<AssertFailedException>()
-                    .WithMessage(expectedMessage);
+                a.Should().NotBeEquivalentTo(b);
             }
         }
 
@@ -234,6 +239,10 @@ private static string GetNotEquivalentMessage(JToken actual, JToken expected,
             return expectedMessage;
         }
 
+        #endregion (Not)BeEquivalentTo
+
+        #region (Not)HaveValue
+
         [TestMethod]
         public void When_jtoken_has_value_HaveValue_should_succeed()
         {
@@ -294,6 +303,10 @@ public void When_jtoken_does_have_value_NotHaveValue_should_fail()
                 .WithMessage("Did not expect JSON property \"id\" to have value \"42\" because foo.");
         }
 
+        #endregion (Not)HaveValue
+
+        #region (Not)HaveElement
+
         [TestMethod]
         public void When_jtoken_has_element_HaveElement_should_succeed()
         {
@@ -354,6 +367,10 @@ public void When_jtoken_does_have_element_NotHaveElement_should_fail()
                 .WithMessage($"Did not expect JSON document {_formatter.ToString(subject)} to have element \"id\" because foo.");
         }
 
+        #endregion (Not)HaveElement
+
+        #region ContainSingleItem
+
         [TestMethod]
         public void When_jtoken_has_a_single_element_ContainSingleItem_should_succeed()
         {
@@ -533,5 +550,7 @@ public void When_jtoken_is_an_array_with_multiple_items_ContainSingleItem_should
             act.ShouldThrow<AssertFailedException>()
                 .WithMessage($"Expected JSON document {formattedSubject} to contain a single item because more is not allowed, but found {formattedSubject}.");
         }
+
+        #endregion ContainSingleItem
     }
 }