Add assert for code that throws exceptions

Author: kbilsted

CHANGELOG.md

@@ -2,17 +2,18 @@
 
 
 ## v0.5.0
-* Bugfix some datetime compare output
-* Add string match with `*`
+* Bugfix some datetime compare output.
+* Add support for partial string match with `*`.
+* Add support for asserting code that throws exceptions.
 
 ## v0.1.0
-* Handling uninitialized `ImmutableArray<>`
-* Empty objects returns empty results
-* Support data projection - fields can change value or be filtered away
+* Handling uninitialized `ImmutableArray<>`.
+* Empty objects returns empty results.
+* Add support for data projection - fields can change value or be filtered away.
 
 ## v0.0.3
 * One line printing of empty classes.
-* Change how configuration is passed onto `Is()`
+* Change how configuration is passed onto `Is()`.
 * Improved error messages.
 
 ## v0.0.2
@@ -25,4 +26,4 @@ initial test release.
 
 Have fun!
 
-Kasper B. Graversen
+ Kasper B. Graversen

README.md

@@ -92,8 +92,10 @@ We achieve these goals by using a novel new way of specifying asserts. Expected
 # 1. Getting started 
 
 1. Install the nuget package `ReassureTest` from nuget.org (`dotnet add package ReassureTest`)
-2. Use the `Is()` method in your tests (`Calculator.Add(2,3).Is("5")`)
-3. Done
+2. Write your asserts using ReassureTest
+  * e.g. `calculator.Add(2, 3).Is("5");` 
+  * or `Reassure.Catch(() => illegalOrder.Handle()).Is(@"{ Message=`Illegal number of widgets!`}");`
+3. Done...
 
 
 
@@ -387,7 +389,7 @@ e.g. the string `"some text"` is matched by all of the following: `*`, `some *`,
 
 
 ### Exceptions
-* Exceptions are transformed into a simple form, a class containing `Message`, `Data` and `Type`.
+* Exceptions are transformed into a simple form, a class containing `Message` and `Type`. A `Data` field is added only when it contains elements.
 
 ```csharp
 var ex = new Exception("message") { Data = {{"a", "b"}} };

ReassureTest.Net.Tests/ThrowsTests.cs

@@ -0,0 +1,47 @@
+using System;
+using NUnit.Framework;
+
+namespace ReassureTest.Tests
+{
+    class ThrowsTests
+    {
+        [Test]
+        public void Inline_action()
+        {
+            Reassure.Catch(() => throw new Exception("eee")).Is(@"{
+                Message = `eee`
+                Type = `System.Exception`
+            }");
+
+            Reassure.With(Reassure.DefaultConfiguration).Catch(() => throw new Exception("eee")).Is(@"{
+                Message = `eee`
+                Type = `System.Exception`
+            }");
+
+            Reassure.With(Reassure.DefaultConfiguration).Catch(() =>
+            {
+                var exception = new Exception("eee");
+                exception.Data.Add("a","b");
+                throw exception;
+            }).Is(@"{
+                Message = `eee`
+                Data = [ { Key = `a` Value = `b` } ]
+                Type = `System.Exception`
+            }");
+        }
+
+        [Test]
+        public void Inline_func()
+        {
+            Reassure.Catch(() => ((string)null).Length).Is(@"{
+                Message = `Object reference not set to an instance of an object.`
+                Type = `System.NullReferenceException`
+            }");
+
+            Reassure.With(Reassure.DefaultConfiguration).Catch(() => ((string)null).Length).Is(@"{
+                Message = `Object reference not set to an instance of an object.`
+                Type = `System.NullReferenceException`
+            }");
+        }
+    }
+}

ReassureTest.Net/Reassure.cs

@@ -10,6 +10,43 @@ namespace ReassureTest
 {
     public static class Reassure
     {
+        /// <summary>
+        /// Run code and catch the exception
+        /// </summary>
+        public static Exception Catch(Action actual)
+        {
+            try
+            {
+                actual();
+            }
+            catch (Exception e)
+            {
+                return e;
+            }
+            
+            throw new AssertException($"Expected: an exception to be thrown\r\nBut no exception was throws");
+        }
+
+        /// <summary>
+        /// Run code and catch the exception
+        /// </summary>
+        public static Exception Catch<T>(Func<T> actual)
+        {
+            try
+            {
+                actual();
+            }
+            catch (Exception e)
+            {
+                return e;
+            }
+
+            throw new AssertException($"Expected: an exception to be thrown\r\nBut no exception was throws");
+        }
+
+        /// <summary>
+        /// Assert 'actual' obeys the specification using the default configuration
+        /// </summary>
         public static string Is(this object actual, string expected) => Is(actual, expected, DefaultConfiguration.DeepClone());
 
         internal static string Is(this object actual, string expected, Configuration cfg)
@@ -49,8 +86,19 @@ internal static string Is(this object actual, string expected, Configuration cfg
             return graph;
         }
 
+        /// <summary>
+        /// inject a configuration into a throws
+        /// </summary>
+        public static ReassureRunContext With(Configuration configuration) => new ReassureRunContext(configuration);
+
+        /// <summary>
+        /// inject a configuration 
+        /// </summary>
         public static ReassureRunContext With(this object actual, Configuration configuration) => new ReassureRunContext(actual, configuration);
 
+        /// <summary>
+        /// Alter this to change the general behaviour of ReassureTest
+        /// </summary>
         public static Configuration DefaultConfiguration = new Configuration(
             new Configuration.OutputtingCfg(
                 indention: "    ",

ReassureTest.Net/ReassureRunContext.cs

@@ -1,16 +1,41 @@
-namespace ReassureTest
+using System;
+
+namespace ReassureTest
 {
     public class ReassureRunContext
     {
         private readonly object actual;
+        private Action alternativeActual;
+
         private readonly Configuration configuration;
 
-        public ReassureRunContext(object actual, Configuration configuration)
+        public ReassureRunContext(Configuration configuration)
         {
-            this.actual = actual;
             this.configuration = configuration.DeepClone();
         }
 
-        public string Is(string expected) => actual.Is(expected, configuration);
+        public ReassureRunContext(object actual, Configuration configuration) : this(configuration)
+        {
+            this.actual = actual;
+        }
+
+        public string Is(string expected)
+        {
+            var target = actual ?? Reassure.Catch(alternativeActual);
+
+            return target.Is(expected, configuration);
+        }
+
+        public ReassureRunContext Catch(Action actual)
+        {
+            alternativeActual = actual;
+            return this;
+        }
+
+        public ReassureRunContext Catch<T>(Func<T> actual)
+        {
+            alternativeActual = () => actual();
+            return this;
+        }
     }
 }

ReassureTest.Net/ReusableProjections.cs

@@ -9,11 +9,16 @@ public static class ReusableProjections
     {
         public static Flow SimplifyExceptions(object parent, object field, PropertyInfo pi)
         {
-            if (field is Exception ex)
-                return Flow.Use(new SimplifiedException(ex));
+            if (parent is SimplifiedException 
+                && pi.Name == "Data" 
+                && field is IDictionary d 
+                && d.Keys.Count == 0)
+            {
+                  return Flow.Skip;
+            }
             return Flow.Use(field);
         }
-        
+
         public static Flow FixDefaultImmutableArrayCanNotBeTraversed(object parent, object field, PropertyInfo pi)
         {
             var type = field.GetType().ToString();