From eb463a0f36e5dcf7a608ff0b741da26c5d5ba3fa Mon Sep 17 00:00:00 2001
From: Josh Creek <jcreek93@gmail.com>
Date: Sun, 28 Nov 2021 22:02:07 +0000
Subject: [PATCH] feat(*): Add ExceptionExtension unit tests

---
 UnitTests/ExceptionExtensionTests.cs | 144 +++++++++++++++++++++++++++
 1 file changed, 144 insertions(+)
 create mode 100644 UnitTests/ExceptionExtensionTests.cs

diff --git a/UnitTests/ExceptionExtensionTests.cs b/UnitTests/ExceptionExtensionTests.cs
new file mode 100644
index 0000000..c048906
--- /dev/null
+++ b/UnitTests/ExceptionExtensionTests.cs
@@ -0,0 +1,144 @@
+using NUnit.Framework;
+using Creek.HelpfulExtensions;
+using System;
+using System.Collections.Generic;
+
+namespace UnitTests
+{
+    public class ExceptionExtensionTests
+    {
+        [SetUp]
+        public void Setup()
+        {
+        }
+
+        [Test]
+        public void ShouldReturnBaseExceptionMessage()
+        {
+            try
+            {
+                // This function calls another that forces a
+                // division by 0.
+                Rethrow();
+            }
+            catch (Exception ex)
+            {
+                string baseExceptionMessage = ex.BaseExceptionMessage();
+                Assert.AreEqual("Attempted to divide by zero.", baseExceptionMessage);
+            }
+        }
+
+        [Test]
+        public void ShouldReturnBaseExceptionMessageAndStackTrace()
+        {
+            try
+            {
+                // This function calls another that forces a
+                // division by 0.
+                Rethrow();
+            }
+            catch (Exception ex)
+            {
+                string baseExceptionMessageAndStackTrace = ex.BaseExceptionMessageAndStackTrace();
+                StringAssert.StartsWith("Attempted to divide by zero.", baseExceptionMessageAndStackTrace);
+                Assert.AreNotEqual("Attempted to divide by zero.", baseExceptionMessageAndStackTrace);
+            }
+        }
+
+        [Test]
+        public void ShouldReturnAllInnerExceptionMessages()
+        {
+            try
+            {
+                // This function calls another that forces a
+                // division by 0.
+                Rethrow();
+            }
+            catch (Exception ex)
+            {
+                List<string> allInnerExceptionMessages = ex.AllInnerExceptionMessages();
+
+                List<string> expected = new List<string>()
+                {
+                    "Caught the second exception and threw a third in response.",
+                    "Forced a division by 0 and threw a second exception.",
+                    "Attempted to divide by zero.",
+                };
+
+                CollectionAssert.AreEqual(expected, allInnerExceptionMessages);
+            }
+        }
+
+        [Test]
+        public void ShouldReturnAllInnerExceptionMessagesAndStackTraces()
+        {
+            try
+            {
+                // This function calls another that forces a
+                // division by 0.
+                Rethrow();
+            }
+            catch (Exception ex)
+            {
+                List<string> allInnerExceptionMessagesAndStackTraces = ex.AllInnerExceptionMessagesAndStackTraces();
+
+                List<string> expected = new List<string>()
+                {
+                    "Caught the second exception and threw a third in response.",
+                    "Forced a division by 0 and threw a second exception.",
+                    "Attempted to divide by zero.",
+                };
+
+                foreach (var (baseExceptionMessageAndStackTrace, index) in allInnerExceptionMessagesAndStackTraces.WithIndex())
+                {
+                    StringAssert.StartsWith(expected[index], baseExceptionMessageAndStackTrace);
+                    Assert.AreNotEqual(expected[index], baseExceptionMessageAndStackTrace);
+                }
+            }
+        }
+
+        // This function catches the exception from the called
+        // function DivideBy0( ) and throws another in response.
+        private void Rethrow()
+        {
+            try
+            {
+                DivideBy0();
+            }
+            catch (Exception ex)
+            {
+                throw new ThirdLevelException("Caught the second exception and threw a third in response.", ex);
+            }
+        }
+
+        // This function forces a division by 0 and throws a second
+        // exception.
+        private void DivideBy0()
+        {
+            try
+            {
+                int zero = 0;
+                int ecks = 1 / zero;
+            }
+            catch (Exception ex)
+            {
+                throw new SecondLevelException("Forced a division by 0 and threw a second exception.", ex);
+            }
+        }
+
+        // Define two derived exceptions to demonstrate nested exceptions.
+        private class SecondLevelException : Exception
+        {
+            public SecondLevelException(string message, Exception inner)
+                : base(message, inner)
+            { }
+        }
+
+        private class ThirdLevelException : Exception
+        {
+            public ThirdLevelException(string message, Exception inner)
+                : base(message, inner)
+            { }
+        }
+    }
+}