AssertApi.cs

Go to the documentation of this file.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Net;
using System.Reflection;
 
using AnalyzeRe;
using AnalyzeRe.APITypes;
using AnalyzeRe.Attributes;
using AnalyzeRe.Layers;
using AnalyzeRe.Utilities;
 
using RestSharp;
#if MSTEST
using Microsoft.VisualStudio.TestTools.UnitTesting;
#elif NUNIT
using NUnit.Framework;
using AssertFailedException = NUnit.Framework.AssertionException;
#endif
 
namespace AnalyzeReTesting.Utilities
{
    public static class AssertApi
    {
        public const double DEFAULT_DOUBLE_EQUIVALENCE_TOLERANCE = 1E-14;
 
        public static bool TryFindException<T>(Exception ex, out T foundException) where T : Exception
        {
            do
            {
                foundException = ex as T;
                if (foundException != null) return true;
                ex = ex.InnerException;
            } while (ex != null);
 
            return false;
        }
 
        public static void LogExceptionDetails(Exception ex)
        {
            if (TryFindException(ex, out APIRequestException apiError) &&
                apiError.RestResponse is IRestResponse response)
                Console.WriteLine("Error response from the URL: " +
                    (response.ResponseUri?.ToString() ?? response.Request.Resource) +
                    $"\n{response.Request.PrettyPrint()}\n{response.PrettyPrint()}");
            else
                Console.WriteLine($"Unexpected exception: \"{ex.Message}\". Details:\n{ex}");
        }
 
        public static void ExceptionThrown<T>(Action action, Action<T> exceptionTest = null)
            where T : Exception
        {
            try
            {
                action.Invoke();
            }
            catch (T e)
            {
                Console.WriteLine($"Assert ExceptionThrown<{typeof(T).NiceTypeName()}> " +
                    $"Successfully caught an exception of the expected type. Details:\n{e}");
                exceptionTest?.Invoke(e);
                return;
            }
            catch (Exception e)
            {
                LogExceptionDetails(e);
                Assert.Fail("Exception of the wrong type was thrown. " +
                    $"Expected type {typeof(T).NiceTypeName()}, " +
                    $"but received {e.GetType().NiceTypeName()}.");
            }
            Assert.Fail("The action ran without raising an exception. " +
                $"Expected: {typeof(T).NiceTypeName()} to be thrown.");
        }
 
        public static void MethodIsAllowed(Action request, string methodName, bool methodAllowed = true)
        {
            try
            {
                request();
            }
            catch (APIRequestException e)
            {
                if (e.RestResponse?.StatusCode == HttpStatusCode.MethodNotAllowed)
                {
                    Debug.WriteLine($"{(methodAllowed ? "Test Failed" : "Test Passed")}: " +
                        $"{methodName} method is not allowed.");
                    Assert.IsFalse(methodAllowed, $"{methodName} method is not allowed (Returned 405), " +
                        $"but it should be for this test to pass.\nDetails:\n{e}");
                    return;
                }
                // Any other APIRequestException is unexpected and should be logged in detail.
                LogExceptionDetails(e);
                Assert.Fail($"{methodName} method failed" + (methodAllowed ? ". Expected Success" :
                        " for an unexpected reason. Expected 405 - MethodNotAllowed") +
                    $", Received status: {e.RestResponse?.StatusCode.ToString() ?? "(No Response)"}, " +
                    $"and error message: {e.Message}\nDetails:\n{e}");
            }
            Assert.IsTrue(methodAllowed, $"{methodName} is allowed, " +
                "but should not be for this test to pass. (Expected 405 - MethodNotAllowed)");
        }
 
        public static void AllPropertiesEqual<T>(T objExpected, T objActual) where T : IAPIType
        {
            try
            {
                AllPropertiesEqual_Helper(typeof(T), objExpected, objActual, objExpected);
            }
            catch
            {
                // Before allowing the test failure to bubble up, serialize both objects.
                Console.WriteLine("\nOne or more sub-properties of these two resources were not equal:" +
                    $"\nExpected: {objExpected.Serialize()}" +
                    $"\n  Actual: {objActual.Serialize()}");
                throw;
            }
        }
 
        public static void PostResponseMatches<T>(T objPosted, T objReturned) where T : IAPIResource
        {
            try
            {
                AllPropertiesEqual_Helper(typeof(T), objPosted, objReturned, objPosted, isPOST: true);
            }
            catch
            {
                // Before allowing the test failure to bubble up, serialize both objects.
                Console.WriteLine("\nOne or more sub-properties of the POST response did not match:" +
                    $"\nPOST Body: {objPosted.Serialize()}" +
                    $"\n Response: {objReturned.Serialize()}");
                throw;
            }
        }
 
        public static void PutResponseMatches<T>(T original, T objPut, T objReturned) where T : IAPIResource
        {
            try
            {
                AllPropertiesEqual_Helper(typeof(T), objPut, objReturned, original, isPUT: true);
            }
            catch
            {
                // Before allowing the test failure to bubble up, serialize all objects involved
                Console.WriteLine("\nOne or more sub-properties of the PUT response did not match expectations:" +
                    $"\nOriginal: {original.Serialize()}" +
                    $"\nPUT Body: {objPut.Serialize()}" +
                    $"\n  Result: {objReturned.Serialize()}");
                throw;
            }
        }
 
        private static void AllPropertiesEqual_Helper(Type runtimeType,
            object fromClient, object fromServer, object originalObject,
            string propertyName = null, HashSet<object> stack = null,
            bool isPOST = false, bool isPUT = false)
        {
            if (fromClient == null && fromServer == null)
                return;
            // Fill in default values
            if (propertyName == null)
                propertyName = runtimeType.NiceTypeName();
            // Keep track of all objects recursed on, to avoid recursing on circular references.
            if (stack == null)
                stack = new HashSet<object> { fromClient };
            else if (stack.Contains(fromClient))
                return;
            else
                stack = new HashSet<object>(stack) { fromClient };
 
            Assert.IsNotNull(fromClient, $"The expected \"{propertyName}\" attribute value is null, " +
                $"but the result was not null, it was: {Output.AutoFormat(fromServer)}");
            Assert.IsNotNull(fromServer, $"The resulting \"{propertyName}\" attribute value was null, " +
                $"but it was expected to have the following value: {Output.AutoFormat(fromClient)}");
 
            // Determine the common property type
            Type sharedType = runtimeType;
            Type clientType = fromClient.GetType();
            Type serverType = fromServer.GetType();
            // Find the most strongly typed instance and treat that as the shared type
            if (clientType == serverType || serverType.IsInstanceOfType(fromClient))
                sharedType = clientType;
            else if (clientType.IsInstanceOfType(fromServer))
                sharedType = serverType;
            // Special case, Newtonsoft Deserializer returns all numeric types as Int64
            else if (clientType.IsIntegerType() && fromServer is long)
            {
                sharedType = clientType;
                fromServer = Convert.ChangeType((long)fromServer, clientType);
                Assert.IsNotNull(fromServer,
                    $"The value {fromServer} could not be converted to the type {clientType}.");
            }
            // Raise an error if both objects aren't an instance of the shared type
            if (!(sharedType.IsInstanceOfType(fromClient) && sharedType.IsInstanceOfType(fromServer)))
            {
                Assert.Fail("The objects being compared are of fundamentally different types: " +
                    $"objPosted is a {clientType.NiceTypeName()}, " +
                    $"objReturned is a {fromServer.GetType().NiceTypeName()}. " +
                    $"Expected type is {sharedType.NiceTypeName()}");
            }
 
            // Comparing doubles
            if (typeof(double).IsAssignableFrom(sharedType))
            {
                DoublesAreEqual((double)fromClient, (double)fromServer,
                    () => GetNoValueMatchErrorMessage(propertyName, fromClient, fromServer));
            }
            // Comparing dates
            else if (typeof(DateTime).IsAssignableFrom(sharedType))
            {
                DateTime clientTime = (DateTime)fromClient;
                DateTime serverTime = (DateTime)fromServer;
                DatesAreEqual(clientTime, serverTime, propertyName);
            }
            // Comparing other simple types (int, string, bool, enum, etc)
            else if (sharedType == typeof(string) || sharedType.IsPrimitive || sharedType.IsEnum)
            {
                if (!Equals(fromClient, fromServer))
                    Assert.Fail(GetNoValueMatchErrorMessage(propertyName, fromClient, fromServer));
            }
            // Comparing Reference Objects
            else if (typeof(IReference).IsAssignableFrom(sharedType))
            {
                // Assert that at the very least, the reference type returned is compatible with that POSTED
                if (isPOST)
                {
                    Assert.IsTrue(fromServer.GetType().GetGenericArguments()[0].IsAssignableFrom(
                        clientType.GetGenericArguments()[0]),
                        $"{propertyName} reference types do not match. " +
                        $"Expected: \"{clientType.NiceTypeName()}\", " +
                        $"Actual: \"{fromServer.GetType().NiceTypeName()}\".");
                }
 
                // If comparing two inlined references to objects, compare just the object definitions.
                if (fromClient is IReference<IAPIResource> refPosted && refPosted.resolved &&
                    fromServer is IReference<IAPIResource> refReturned && refReturned.resolved)
                {
                    AllPropertiesEqual_Helper(typeof(IAPIResource),
                        refPosted.GetValue(), refReturned.GetValue(), originalObject, $"{propertyName} inlined reference", stack, isPOST, isPUT);
                }
                // Otherwise, just use the reference equality test
                else
                {
                    Assert.AreEqual(fromClient, fromServer,
                        $"{propertyName} reference objects do not match: " +
                        $"Expected: {(IReference)fromClient}, " +
                        $"Actual: {(IReference)fromServer}");
                }
            }
            // Comparing collection types
            else if (typeof(IEnumerable).IsAssignableFrom(sharedType))
            {
                List<object> expectedCollection = ((IEnumerable)fromClient).Cast<object>().ToList();
                List<object> returnedCollection = ((IEnumerable)fromServer).Cast<object>().ToList();
                // Testing if collections are the same size.
                Assert.AreEqual(expectedCollection.Count, returnedCollection.Count,
                    $"{propertyName} collections do not contain the same number of elements. " +
                    $"Expected: \"{expectedCollection.Count}\", " +
                    $"Actual: \"{returnedCollection.Count}\".");
                Type collectionItemsSharedType = TypeResolver.GetEnumerableType(sharedType);
                // Test that the resulting collection contains all the same objects
                // (but not necessarily in the same order)
                // TODO: Define an attribute which indicates whether collection order is maintained.
                int expectedIndex = -1;
                bool outOfOrder = false;
                foreach (object expectedElement in expectedCollection)
                {
                    expectedIndex++;
                    bool matchFound = FindCollectionElement(element => AllPropertiesEqual_Helper(
                            collectionItemsSharedType, expectedElement, element, originalObject, $"{propertyName}[{expectedIndex}]", stack, isPOST, isPUT),
                        expectedIndex, returnedCollection, out int foundIndex, out List<Exception> errors);
                    if (foundIndex != expectedIndex)
                        outOfOrder = true;
                    if (matchFound)
                        continue;
                    // If no match was found, build a meaningful error message
                    Assert.Fail(GetNoValueMatchErrorMessage(propertyName, fromClient, fromServer) +
                        $"\nSpecifically - collection element number {expectedIndex} had no matching " +
                        "element in the resulting collection. Results from each comparison attempt:\n  " +
                        String.Join("\n  ", errors.Select(ex => ex.Message.Replace("\n", "\n    "))));
                }
                if(outOfOrder)
                    Debug.WriteLine($"All \"{propertyName}\" collection elements were found, " +
                        "but they appeared in a different order than what was originally posted.");
            }
            // Other Analyze Re custom types, try comparing all readable sub-properties for equivalence
            else if(typeof(IAPIType).IsAssignableFrom(sharedType))
            {
                int subPropertiesCompared = 0;
                foreach (PropertyInfo property in sharedType.GetUserFacingProperties(
                    // Ignore server generated properties (like id),
                    // since they change at the server's discretion.
                    excludeServerGenerated: true))
                {
                    subPropertiesCompared++;
                    object propExpected, propActual;
                    try
                    {
                        propExpected = property.GetValue(fromClient);
                        propActual = property.GetValue(fromServer);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Fatal error encountered while getting the property from " +
                            $"one or both {sharedType.NiceTypeName()} resources being compared. " +
                            $"Property was: {property.PropertyType.NiceTypeName()} " +
                            $"{property.DeclaringType.NiceTypeName()}.{property.Name} \nError was: {ex}");
                        throw;
                    }
 
                    // Indicates whether the "expected" value has been changed from what was submitted
                    // to the server to some different expected value based on defaults/server behaviour.
                    bool expectedValueSet = false;
 
                    // When PUTing a resource, the server will not change top-level properties
                    // if they are omitted from the PUT body.
                    // BUG ARE-2618 - These PUT expectation are violated almost all the time.
                    //     The most common behaviour is that the property is "reset" to its default.
                    //if (isPUT && propExpected == null)
                    //{
                    //    // Only applies if we are checking top-level properties
                    //    if (fromClient is IAPIResource asResource &&
                    //        originalObject is IAPIResource originalResource &&
                    //        asResource.id != null && asResource.id == originalResource.id &&
                    //        // EXCEPT if the NullValueHanlding JsonProperty is set to "Include" nulls,
                    //        // in which case the server will actually override the original value with 'null'
                    //        !(property.GetCustomAttributeFast<JsonPropertyAttribute>() is
                    //            JsonPropertyAttribute jsonProperty &&
                    //            jsonProperty.NullValueHandling == NullValueHandling.Include))
                    //    {
                    //        propExpected = property.GetValue(originalResource);
                    //        expectedValueSet = true;
                    //    }
                    //}
                    // When POSTing, the server may have a default value for
                    // certain properties when set to null. Check for that here.
                    if ((isPOST || isPUT) && property.IsAttributeDefinedFast<ServerHasDefault>() &&
                    // else if (isPOST && property.IsAttributeDefinedFast<ServerHasDefault>() &&
                        (propExpected == null ||
                            // Yet another special case - the portfolio_view.layer_views property
                            // will be defaulted if it is null *or an empty list* due to special logic
                            // coded into "AnalyzeRe.JsonConverters.PortfolioViewSerializer"
                            Reflection.IsProperty<PortfolioView>(property, pv => pv.layer_views) &&
                            ((HashSet<IReference<ILayerView>>)propExpected).Count == 0))
                    {
                        ServerHasDefault defaultAttribute = property.GetCustomAttributeFast<ServerHasDefault>();
                        if (defaultAttribute.HasDefaultValue(fromClient))
                            propExpected = defaultAttribute.GetDefaultValue(fromClient);
                        else
                        {
                            // If the attribute doesn't specify an expected default, we just have to trust
                            // that whatever the server has returned is the correct default value,
                            // whether it's null or otherwise.
                            Console.WriteLine("Warning: The server is known to provide a default value " +
                                $"when \"{property.Name}\" is set to null, but the defaulted value returned " +
                                $"({propActual ?? "null"}) could not be verified. Assuming it is valid.");
                            propExpected = propActual;
                        }
                        expectedValueSet = true;
                    }
                    // The server may convert some references to inlined objects. Handle these special cases.
                    if ((isPOST || isPUT) && originalObject is IAPIResourceView)
                    {
                        // The API will inline any layer references appearing as part of a nested layer definition.
                        // We can verify this by resolving the reference and setting the propExpected value.
                        IReference<T> InlineReference<T>(IReference<T> reference) where T : IAPIResource =>
                            reference.DeepCopy().GetValue().Change(r => r.id, null).ToReference(true);
 
                        // Note: As of ARE-5975 we can encounter non-layer references, but only
                        //       layer references are expected to be converted to inlined layers.
                        if(property.PropertyType == typeof(Nested.Sources))
                            propExpected = new Nested.Sources(((IEnumerable<IReference>)propExpected)?
                                .Select(r => r is IReference<ILayer> layerRef ? InlineReference(layerRef) : r));
                        else if (property.PropertyType == typeof(IReference<ILayerSource>) &&
                            propExpected is IReference<ILayer> layerRef)
                            propExpected = InlineReference(layerRef);
                    }
 
                    // Assert the resulting objects' value for this property matches the expected value
                    // Set POST_Comparison_Mode to false since only root level objects
                    AllPropertiesEqual_Helper(property.PropertyType, propExpected, propActual, originalObject, $"{propertyName}.{property.Name}", stack, isPOST && !expectedValueSet, isPUT && !expectedValueSet);
                }
                // If the above reflection method found no readable sub-properties to compare, then we must
                // rely on the objects own equivalency test.
                if (subPropertiesCompared == 0)
                {
                    Assert.AreEqual(fromClient, fromServer,
                        GetNoValueMatchErrorMessage(propertyName, fromClient, fromServer));
                }
            }
            // We probably don't even need to compare SubResourceEndpoint instances, since they
            // are "defined" properties, not mutable attributes. Still, we can test that 
            // SubResourceEndpoint objects are equivalent if they share the same path.
            else if (typeof(SubResourceEndpoint).IsAssignableFrom(sharedType))
            {
                // Note that we cannot compare paths if the original object was a resource without an id.
                if (isPOST || originalObject is IAPIResource resource && resource.id == null) return;
                Assert.AreEqual(((IEndpoint)fromClient).Path, ((IEndpoint)fromServer).Path);
            }
            // Comparing dictionary elements
            else if (sharedType.IsSubclassOfRawGeneric(typeof(KeyValuePair<,>)))
            {
                AllPropertiesEqual_Helper(sharedType.GetGenericArguments()[0],
                    fromClient.GetType().GetProperty("Key").GetValue(fromClient),
                    fromServer.GetType().GetProperty("Key").GetValue(fromServer), originalObject, $"{sharedType.NiceTypeName()}.Key", stack, isPOST, isPUT);
                AllPropertiesEqual_Helper(sharedType.GetGenericArguments()[1],
                    fromClient.GetType().GetProperty("Value").GetValue(fromClient),
                    fromServer.GetType().GetProperty("Value").GetValue(fromServer), originalObject, $"{sharedType.NiceTypeName()}.Value", stack, isPOST, isPUT);
            }
            // Any other types can't safely be compared.
            // Fail if the standard equals method doesn't consider the two objects equivalent.
            else if(!fromClient.Equals(fromServer))
            {
                Assert.Fail("This routine doesn't know how to compare the following two objects:\n" +
                    $"Expected: {fromClient.GetType().NiceTypeName()} \"{fromClient}\"\n" +
                    $"Actual: {fromServer.GetType().NiceTypeName()} \"{fromServer}\"");
            }
        }
 
        private static bool FindCollectionElement(Action<object> elementTest, int expectedIndex,
            List<object> returnedCollection, out int foundIndex, out List<Exception> errors)
        {
#if NUNIT
            // NUnit does not allow assertion failures to be suppressed via try/catch,
            // they must be suppressed by creating and discarding an isolated test context.
            // TODO: Refactor the AllPropertiesEqual_Helper to not use assertions, so that the caller
            //       can decide whether to handle differences with a failed assertion or not.
            using (new NUnit.Framework.Internal.TestExecutionContext.IsolatedContext())
#endif
            {
                foundIndex = -1;
                errors = new List<Exception>();
                // 1. Assume order was maintained: Compare the current enumerable element
                // to the element at the same index in the returned collection
                try
                {
                    elementTest(returnedCollection.Skip(expectedIndex).First());
                    foundIndex = expectedIndex;
                    return true; // Found the matching element
                }
                catch (Exception ex)
                {
                    // If there is only one element in each collection, the above test should have passed
                    // Otherwise, if this collection element isn't a match, it's possible the server has just
                    // changed the order. See if any element in the collection matches it.
                    // TODO: Also fail here given some attribute that specifies that the collection order matters.
                    if (returnedCollection.Count == 1)
                    {
                        errors.Add(ex);
                        return false;
                    }
                }
 
                // 2. Either the collections are different, or they are not in the same order.
                // If order doesn't matter, try to find any returned collection element that matches.
                foreach (object element in returnedCollection)
                {
                    foundIndex++;
                    try
                    {
                        elementTest(element);
                        return true; // Found a matching element
                    }
                    catch (AssertFailedException ex)
                    {
                        errors.Add(ex);
                    }
                }
 
                return false;
            }
        }
 
        // Used to generate an error message that comes up in a few cases if assertions fail.
        private static string GetNoValueMatchErrorMessage(string propertyName, object expected, object actual)
        {
            return $"{propertyName} values do not match. " +
                $"Type: \"{expected?.GetType().NiceTypeName() ?? "(null)"}\"." +
                $"\nExpected: {Output.AutoFormat(expected)}," +
                $"\nActual: {Output.AutoFormat(actual)}.";
        }
 
        public static bool FileContentsAreEqual(string expected, string actual,
            StringComparison comparisonType = StringComparison.InvariantCulture)
        {
            string mod_expected = String.Join("\n", expected.Split('\n').Select(s => s.Trim())).Trim();
            string mod_actual = String.Join("\n", actual.Split('\n').Select(s => s.Trim())).Trim();
            return mod_expected.Equals(mod_actual, comparisonType);
        }
 
        public static Action<APIRequestException> ApiExceptionTest(HttpStatusCode expectedStatusCode)
        {
            return delegate (APIRequestException ex)
            {
                Assert.IsNotNull(ex, "Expected some APIRequestException, got null.");
                string message = "Expected an APIRequestException to contain a RestResponse " +
                    "with the HTTP Status: " + expectedStatusCode;
                string messageEnd = "\nReceived Exception Details:\n" + ex;
                Assert.IsNotNull(ex.RestResponse, message +
                    ", but the exception contained no RestResponse." + messageEnd);
                Assert.IsNotNull(ex.ServerError, message +
                    ", but the exception contained no ServerError." + messageEnd);
                message += ".  Received Status: " + ex.RestResponse.StatusCode + " and Message: \"" +
                    (String.IsNullOrWhiteSpace(ex.ServerError.message) ? "(null)" : ex.ServerError.message) + "\"";
                Assert.AreEqual(expectedStatusCode, ex.RestResponse.StatusCode, message + messageEnd);
            };
        }
 
        // Asserts that all IReference properties within an object have been resolved.
        public static void ReferencesResolved(object obj)
        {
            // Ensure that all reference properties with a non-null value have been resolved.
            foreach (IReference<IAPIResource> reference in obj.GetType().GetUserFacingProperties()
                .Where(p => typeof(IReference<IAPIResource>).IsAssignableFrom(p.PropertyType))
                .Select(referencePropertyInfo => (IReference<IAPIResource>)referencePropertyInfo.GetValue(obj, null)))
            {
                ReferencesResolvedHelper(reference);
            }
            // Ensure that any lists of references have every item in the list resolved.
            foreach (IEnumerable<IReference<IAPIResource>> refList in obj.GetType().GetUserFacingProperties()
                .Where(p => typeof(IEnumerable<IReference<IAPIResource>>).IsAssignableFrom(p.PropertyType))
                .Select(referencePropertyInfo => (IEnumerable<IReference<IAPIResource>>)referencePropertyInfo.GetValue(obj, null)))
            {
                if (refList == null || !refList.Any())
                    continue;
                foreach (IReference<IAPIResource> reference in refList)
                    ReferencesResolvedHelper(reference);
            }
        }
 
        // Checks that a specific instance of a reference property has been resolved.
        private static void ReferencesResolvedHelper(IReference<IAPIResource> reference)
        {
            if (reference == null)
                return;
            Assert.IsTrue(reference.resolved, $"A {reference.GetType().NiceTypeName()} reference " +
                "that has not been resolved was encountered.");
            ReferencesResolved(reference.GetValue());
        }
 
        public static void DoublesAreEqual(double expected, double actual, Func<string> message,
            double? relative_tolerance = null)
        {
            bool isTrue = relative_tolerance.HasValue ?
                AlmostEquals(actual, expected, relative_tolerance.Value) : AlmostEquals(actual, expected);
            if (!isTrue)
                Assert.Fail(message());
        }
 
        public static void DoublesAreEqual(double expected, double actual, string message = null,
            double? relative_tolerance = null)
        {
            DoublesAreEqual(expected, actual, () => $"Expected: {Output.AutoFormat(expected)} and " +
                $"Actual: {Output.AutoFormat(actual)} do not match within a tolerance of: " +
                $"{relative_tolerance ?? DEFAULT_DOUBLE_EQUIVALENCE_TOLERANCE:G17}. " +
                $"{message}", relative_tolerance);
        }
 
        public static bool AlmostEquals(double d1, double d2,
            double tolerance = DEFAULT_DOUBLE_EQUIVALENCE_TOLERANCE)
        {
            return d1.AlmostEquals(d2, tolerance);
        }
 
 
        public static void DatesAreEqual(DateTime? dt1, DateTime? dt2, string propertyName = "DateTime")
        {
            if (!dt1.HasValue && !dt2.HasValue) return;
            if (!dt1.HasValue || !dt2.HasValue || !dt1.Value.AlmostEquals(dt2.Value))
                Assert.Fail(GetNoValueMatchErrorMessage(propertyName, dt1, dt2));
        }
 
        public static void IsValidUUID(string toCheck)
        {
            Assert.IsNotNull(toCheck, "Expected a UUID but the result was empty.");
            Assert.IsTrue(Guid.TryParseExact(toCheck, "D", out Guid _),
                "The Id \"" + toCheck + "\" was not a valid UUID.");
        }
    }
}