Add MatchRegex() and NotMatchRegex() assertions (#23)

Author: dstj

README.md

@@ -12,9 +12,11 @@
 - `HaveCount()`
 - `HaveElement()`
 - `HaveValue()`
+- `MatchRegex()`
 - `NotBeEquivalentTo()`
 - `NotHaveElement()`
 - `NotHaveValue()`
+- `NotMatchRegex()`
 
 See "in-code" description for more information.
 

Src/FluentAssertions.Json/JTokenAssertions.cs

@@ -6,6 +6,8 @@
 using FluentAssertions.Formatting;
 using FluentAssertions.Primitives;
 using Newtonsoft.Json.Linq;
+using System.Text.RegularExpressions;
+using System;
 
 namespace FluentAssertions.Json
 {
@@ -180,6 +182,67 @@ public AndConstraint<JTokenAssertions> NotHaveValue(string unexpected, string be
             return new AndConstraint<JTokenAssertions>(this);
         }
 
+        /// <summary>
+        ///     Asserts that the current <see cref="JToken" /> matches the specified <paramref name="regularExpression" /> regular expression pattern.
+        /// </summary>
+        /// <param name="regularExpression">The expected regular expression pattern</param>
+        public AndConstraint<JTokenAssertions> MatchRegex(string regularExpression)
+        {
+            return MatchRegex(regularExpression, string.Empty);
+        }
+
+        /// <summary>
+        ///     Asserts that the current <see cref="JToken" /> matches the specified <paramref name="regularExpression" /> regular expression pattern.
+        /// </summary>
+        /// <param name="regularExpression">The expected regular expression pattern</param>
+        /// <param name="because">
+        ///     A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        ///     is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        ///     Zero or more objects to format using the placeholders in <see paramref="because" />.
+        /// </param>
+        public AndConstraint<JTokenAssertions> MatchRegex(string regularExpression, string because, params object[] becauseArgs)
+        {
+            if (regularExpression == null) {
+                throw new ArgumentNullException(nameof(regularExpression), "MatchRegex does not support <null> pattern");
+            }
+
+            Execute.Assertion
+                .ForCondition(Regex.IsMatch(Subject.Value<string>(), regularExpression ?? ""))
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected {context:JSON property} {0} to match regex pattern {1}{reason}, but found {2}.",
+                    Subject.Path, regularExpression, Subject.Value<string>());
+
+            return new AndConstraint<JTokenAssertions>(this);
+        }
+
+        /// <summary>
+        ///     Asserts that the current <see cref="JToken" /> does not match the specified <paramref name="regularExpression" /> regular expression pattern.
+        /// </summary>
+        /// <param name="regularExpression">The expected regular expression pattern</param>
+        /// <param name="because">
+        ///     A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        ///     is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        ///     Zero or more objects to format using the placeholders in <see paramref="because" />.
+        /// </param>
+        public AndConstraint<JTokenAssertions> NotMatchRegex(string regularExpression, string because = "", params object[] becauseArgs)
+        {
+            if (regularExpression == null) {
+                throw new ArgumentNullException(nameof(regularExpression), "MatchRegex does not support <null> pattern");
+            }
+
+            Execute.Assertion
+                .ForCondition(!Regex.IsMatch(Subject.Value<string>(), regularExpression))
+                 .BecauseOf(because, becauseArgs)
+                 .FailWith("Did not expect {context:JSON property} {0} to match regex pattern {1}{reason}.",
+                      Subject.Path, regularExpression, Subject.Value<string>());
+
+            return new AndConstraint<JTokenAssertions>(this);
+        }
+
         /// <summary>
         ///     Asserts that the current <see cref="JToken" /> has a direct child element with the specified
         ///     <paramref name="expected" /> name.
@@ -397,6 +460,5 @@ public string Format(JToken value, bool useLineBreaks = false)
                 UseLineBreaks = useLineBreaks
             }, null);
         }
-
     }
 }

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

@@ -457,6 +457,70 @@ public void When_jtoken_does_have_value_NotHaveValue_should_fail()
 
         #endregion (Not)HaveValue
 
+        #region (Not)MatchRegex
+
+        [Fact]
+        public void When_json_matches_regex_pattern_MatchRegex_should_succeed()
+        {
+            //-----------------------------------------------------------------------------------------------------------
+            // Arrange
+            //-----------------------------------------------------------------------------------------------------------
+            var subject = JToken.Parse("{ 'id': 42 }");
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Act & Assert
+            //-----------------------------------------------------------------------------------------------------------
+            subject["id"].Should().MatchRegex("\\d{2}");
+        }
+
+        [Fact]
+        public void When_json_does_not_match_regex_pattern_MatchRegex_should_fail()
+        {
+            //-----------------------------------------------------------------------------------------------------------
+            // Arrange
+            //-----------------------------------------------------------------------------------------------------------
+            var subject = JToken.Parse("{ 'id': 'not two digits' }");
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Act & Assert
+            //-----------------------------------------------------------------------------------------------------------
+            subject["id"].Should().Invoking(x => x.MatchRegex("\\d{2}", "because foo"))
+                 .Should().Throw<XunitException>()
+                 .WithMessage("Expected JSON property \"id\" to match regex pattern \"\\d{2}\" because foo, but found \"not two digits\".");
+        }
+
+        [Fact]
+        public void When_json_does_not_match_regex_pattern_NotHaveRegexValue_should_succeed()
+        {
+            //-----------------------------------------------------------------------------------------------------------
+            // Arrange
+            //-----------------------------------------------------------------------------------------------------------
+            var subject = JToken.Parse("{ 'id': 'not two digits' }");
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Act & Assert
+            //-----------------------------------------------------------------------------------------------------------
+            subject["id"].Should().NotMatchRegex("\\d{2}");
+        }
+
+        [Fact]
+        public void When_json_matches_regex_pattern_NotHaveRegexValue_should_fail()
+        {
+            //-----------------------------------------------------------------------------------------------------------
+            // Arrange
+            //-----------------------------------------------------------------------------------------------------------
+            var subject = JToken.Parse("{ 'id': 42 }");
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Act & Assert
+            //-----------------------------------------------------------------------------------------------------------
+            subject["id"].Should().Invoking(x => x.NotMatchRegex("\\d{2}", "because foo"))
+                 .Should().Throw<XunitException>()
+                 .WithMessage("Did not expect JSON property \"id\" to match regex pattern \"\\d{2}\" because foo.");
+        }
+
+        #endregion (Not)MatchRegex
+
         #region (Not)HaveElement
 
         [Fact]