Merge pull request #331 - OfType methods should have the option to pass Type without generics

OfType methods should have the option to pass Type without generics

Author: ivaylokenov

src/MyTested.AspNetCore.Mvc.Abstractions/Builders/Attributes/BaseAttributesTestBuilder{TAttributesTestBuilder}.cs

@@ -31,24 +31,26 @@ protected BaseAttributesTestBuilder(ComponentTestContext testContext)
         /// <value>Test builder for the attributes.</value>
         public abstract TAttributesTestBuilder AttributesTestBuilder { get; }
 
-        /// <inheritdoc />
-        public TAttributesTestBuilder ContainingAttributeOfType<TAttribute>()
-            where TAttribute : Attribute
+        ///// <inheritdoc />
+        public TAttributesTestBuilder ContainingAttributeOfType(Type attribute)
         {
-            var expectedAttributeType = typeof(TAttribute);
             this.Validations.Add(attrs =>
             {
-                if (attrs.All(a => a.GetType() != expectedAttributeType))
+                if (attrs.All(a => a.GetType() != attribute))
                 {
                     this.ThrowNewAttributeAssertionException(
-                        expectedAttributeType.ToFriendlyTypeName(),
+                        attribute.ToFriendlyTypeName(),
                         "in fact such was not found");
                 }
             });
 
             return this.AttributesTestBuilder;
         }
 
+        /// <inheritdoc />
+        public TAttributesTestBuilder ContainingAttributeOfType<TAttribute>()
+             where TAttribute : Attribute => this.ContainingAttributeOfType(typeof(TAttribute));
+        
         /// <inheritdoc />
         public TAttributesTestBuilder PassingFor<TAttribute>(Action<TAttribute> assertions)
             where TAttribute : Attribute

src/MyTested.AspNetCore.Mvc.Abstractions/Builders/CaughtExceptions/AggregateExceptionTestBuilder.cs

@@ -25,23 +25,25 @@ public AggregateExceptionTestBuilder(ComponentTestContext testContext)
         }
 
         /// <inheritdoc />
-        public IAndAggregateExceptionTestBuilder ContainingInnerExceptionOfType<TInnerException>()
-            where TInnerException : Exception
+        public IAndAggregateExceptionTestBuilder ContainingInnerExceptionOfType(Type innerException)
         {
-            var expectedInnerExceptionType = typeof(TInnerException);
-            var innerExceptionFound = this.aggregateException.InnerExceptions.Any(e => e.GetType() == expectedInnerExceptionType);
+            var innerExceptionFound = this.aggregateException.InnerExceptions.Any(e => e.GetType() == innerException);
             if (!innerExceptionFound)
             {
                 throw new InvalidExceptionAssertionException(string.Format(
                     "{0} {1} to contain {2}, but none was found.",
                     this.TestContext.ExceptionMessagePrefix,
                     nameof(AggregateException),
-                    expectedInnerExceptionType.ToFriendlyTypeName()));
+                    innerException.ToFriendlyTypeName()));
             }
 
             return this;
         }
 
+        /// <inheritdoc />
+        public IAndAggregateExceptionTestBuilder ContainingInnerExceptionOfType<TInnerException>()
+            where TInnerException : Exception  => this.ContainingInnerExceptionOfType(typeof(TInnerException));
+        
         /// <inheritdoc />
         public new IAggregateExceptionTestBuilder AndAlso() => this;
     }

src/MyTested.AspNetCore.Mvc.Abstractions/Builders/CaughtExceptions/ExceptionTestBuilder.cs

@@ -22,23 +22,25 @@ public ExceptionTestBuilder(ComponentTestContext testContext)
         }
 
         /// <inheritdoc />
-        public IAndExceptionTestBuilder OfType<TException>()
+        public IAndExceptionTestBuilder OfType(Type exceptionType)
         {
-            var expectedExceptionType = typeof(TException);
             var actualExceptionType = this.TestContext.CaughtException.GetType();
-            if (Reflection.AreDifferentTypes(expectedExceptionType, actualExceptionType))
+            if (Reflection.AreDifferentTypes(exceptionType, actualExceptionType))
             {
                 throw new InvalidExceptionAssertionException(string.Format(
                     "{0} {1}, but instead received {2}.",
                     this.TestContext.ExceptionMessagePrefix,
-                    expectedExceptionType.ToFriendlyTypeName(),
+                    exceptionType.ToFriendlyTypeName(),
                     actualExceptionType.ToFriendlyTypeName()));
             }
 
             return this;
         }
 
         /// <inheritdoc />
+        public IAndExceptionTestBuilder OfType<TException>()
+            => OfType(typeof(TException));
+
         public IExceptionMessageTestBuilder WithMessage()
         {
             return new ExceptionMessageTestBuilder(

src/MyTested.AspNetCore.Mvc.Abstractions/Builders/Contracts/Attributes/IBaseAttributesTestBuilder.cs

@@ -17,6 +17,13 @@ public interface IBaseAttributesTestBuilder<TAttributesTestBuilder>
         TAttributesTestBuilder ContainingAttributeOfType<TAttribute>()
             where TAttribute : Attribute;
 
+        /// <summary>
+        /// Tests whether the collected attributes contain the provided attribute type.
+        /// </summary>
+        /// <param name="attributeType"></param>
+        /// <returns></returns>
+        TAttributesTestBuilder ContainingAttributeOfType(Type attributeType);
+
         /// <summary>
         /// Tests whether the collected attributes contain the provided attribute type passing the given assertions.
         /// </summary>

src/MyTested.AspNetCore.Mvc.Abstractions/Builders/Contracts/CaughtExceptions/IAggregateExceptionTestBuilder.cs

@@ -14,5 +14,12 @@ public interface IAggregateExceptionTestBuilder : IBaseExceptionTestBuilder
         /// <returns>The same <see cref="IAndAggregateExceptionTestBuilder"/>.</returns>
         IAndAggregateExceptionTestBuilder ContainingInnerExceptionOfType<TInnerException>()
             where TInnerException : Exception;
+
+        /// <summary>
+        /// Tests whether <see cref="AggregateException"/> contains inner exception of the provided type.
+        /// </summary>
+        /// <param name="innerExeption"></param>
+        /// <returns></returns>
+        IAndAggregateExceptionTestBuilder ContainingInnerExceptionOfType(Type innerExeption);
     }
 }

src/MyTested.AspNetCore.Mvc.Abstractions/Builders/Contracts/CaughtExceptions/IExceptionTestBuilder.cs

@@ -1,5 +1,7 @@
 namespace MyTested.AspNetCore.Mvc.Builders.Contracts.CaughtExceptions
 {
+    using System;
+
     /// <summary>
     /// Used for testing expected <see cref="System.Exception"/>.
     /// </summary>
@@ -11,5 +13,11 @@ public interface IExceptionTestBuilder : IBaseExceptionTestBuilder
         /// <typeparam name="TException">Type of the expected <see cref="System.Exception"/>.</typeparam>
         /// <returns>The same <see cref="IAndExceptionTestBuilder"/>.</returns>
         IAndExceptionTestBuilder OfType<TException>();
+
+        /// <summary>
+        /// Tests whether certain type of <see cref="System.Exception"/> is thrown from the invoked method.
+        /// </summary>
+        /// <returns>The same <see cref="IAndExceptionTestBuilder"/>.</returns>
+        IAndExceptionTestBuilder OfType(Type exceptionType);
     }
 }

src/MyTested.AspNetCore.Mvc.Abstractions/Builders/Data/BaseDataProviderTestBuilder.cs

@@ -1,5 +1,6 @@
 namespace MyTested.AspNetCore.Mvc.Builders.Data
 {
+    using System;
     using System.Collections.Generic;
     using Base;
     using Exceptions;
@@ -79,11 +80,20 @@ protected void ValidateContainingEntryWithValue<TValue>(TValue value)
                 value,
                 this.ThrowNewDataProviderAssertionException);
 
+        /// <summary>
+        /// Validates whether the data provider contains entry value with the given type.
+        /// </summary>
+        protected void ValidateContainingEntryOfType(Type valueType)  
+            => DictionaryValidator.ValidateValueOfType(
+                this.DataProviderName,
+                this.DataProvider,
+                this.ThrowNewDataProviderAssertionException,valueType);
+
         /// <summary>
         /// Validates whether the data provider contains entry value with the given type.
         /// </summary>
         /// <typeparam name="TValue">Type of the value.</typeparam>
-        protected void ValidateContainingEntryOfType<TValue>() 
+        protected void ValidateContainingEntryOfType<TValue>()
             => DictionaryValidator.ValidateValueOfType<TValue>(
                 this.DataProviderName,
                 this.DataProvider,
@@ -101,6 +111,18 @@ protected void ValidateContainingEntryOfType<TValue>(string key)
                 key,
                 this.ThrowNewDataProviderAssertionException);
 
+        /// <summary>
+        /// Validates whether the data provider contains entry value with the given type and corresponding key.
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="valueType"></param>
+        protected void ValidateContainingEntryOfType(string key, Type valueType)
+            => DictionaryValidator.ValidateStringKeyAndValueOfType(
+                this.DataProviderName,
+                this.DataProvider,
+                key,
+                this.ThrowNewDataProviderAssertionException,valueType);
+
         /// <summary>
         /// Validates whether the data provider contains entry with the given key and corresponding value.
         /// </summary>

src/MyTested.AspNetCore.Mvc.Abstractions/Builders/Data/BaseDataProviderWithStringKeyTestBuilder.cs

@@ -47,14 +47,28 @@ public TDataProviderTestBuilder ContainingEntryWithValue<TValue>(TValue value)
         /// <inheritdoc />
         public TDataProviderTestBuilder ContainingEntryOfType<TValue>()
         {
-            this.ValidateContainingEntryOfType<TValue>();
+            this.ContainingEntryOfType(typeof(TValue));
+            return this.DataProviderTestBuilder;
+        }
+
+        /// <inheritdoc />
+        public TDataProviderTestBuilder ContainingEntryOfType(Type valueType)
+        {
+            this.ValidateContainingEntryOfType(valueType);
             return this.DataProviderTestBuilder;
         }
 
         /// <inheritdoc />
         public TDataProviderTestBuilder ContainingEntryOfType<TValue>(string key)
         {
-            this.ValidateContainingEntryOfType<TValue>(key);
+            this.ContainingEntryOfType(key,typeof(TValue));
+            return this.DataProviderTestBuilder;
+        }
+
+        /// <inheritdoc />
+        public TDataProviderTestBuilder ContainingEntryOfType(string key, Type valueType)
+        {
+            this.ValidateContainingEntryOfType(key, valueType);
             return this.DataProviderTestBuilder;
         }
 

src/MyTested.AspNetCore.Mvc.Abstractions/Utilities/Validators/DictionaryValidator.cs

@@ -49,34 +49,52 @@ public static void ValidateValueOfType<TValue>(
             ValidateValueOfType<TValue>(name, dictionary.Values, failedValidationAction);
         }
 
+        public static void ValidateValueOfType(
+            string name,
+            IDictionary<string, object> dictionary,
+            Action<string, string, string> failedValidationAction, Type valueType)
+            => ValidateValueOfType(name, dictionary.Values, failedValidationAction,valueType);
+        
         public static void ValidateValueOfType<TValue>(
             string name,
             IDictionary<object, object> dictionary,
             Action<string, string, string> failedValidationAction)
-        {
-            ValidateValueOfType<TValue>(name, dictionary.Values, failedValidationAction);
-        }
-
-        public static void ValidateStringKeyAndValueOfType<TValue>(
+            => ValidateValueOfType<TValue>(name, dictionary.Values, failedValidationAction);
+        
+        public static void ValidateValueOfType(
+           string name,
+           IDictionary<object, object> dictionary,
+           Action<string, string, string> failedValidationAction,
+           Type valueType)
+            => ValidateValueOfType(name, dictionary.Values, failedValidationAction, valueType);
+        
+        public static void ValidateStringKeyAndValueOfType(
             string name,
             IDictionary<string, object> dictionary,
             string key,
-            Action<string, string, string> failedValidationAction)
+            Action<string, string, string> failedValidationAction,
+            Type valueType)
         {
             var entryExists = dictionary.ContainsKey(key);
             var actualValue = entryExists ? dictionary[key] : null;
 
-            var expectedType = typeof(TValue);
             var actualType = actualValue?.GetType();
-            if (!entryExists || Reflection.AreDifferentTypes(expectedType, actualType))
+            if (!entryExists || Reflection.AreDifferentTypes(valueType, actualType))
             {
                 failedValidationAction(
                     name,
-                    $"to have entry with '{key}' key and value of {expectedType.ToFriendlyTypeName()} type",
+                    $"to have entry with '{key}' key and value of {valueType.ToFriendlyTypeName()} type",
                     $"{(entryExists ? $"in fact found {actualType.ToFriendlyTypeName()}" : "such was not found")}");
             }
         }
 
+        public static void ValidateStringKeyAndValueOfType<TValue>(
+            string name,
+            IDictionary<string, object> dictionary,
+            string key,
+            Action<string, string, string> failedValidationAction)
+            => ValidateStringKeyAndValueOfType(name, dictionary, key, failedValidationAction, typeof(TValue));
+
         public static void ValidateValue<TDictionaryKey, TValue>(
             string name,
             IDictionary<TDictionaryKey, object> dictionary,
@@ -122,21 +140,27 @@ public static void ValidateValues(
                 failedValidationAction));
         }
 
-        private static void ValidateValueOfType<TValue>(
-            string name,
-            ICollection<object> values,
-            Action<string, string, string> failedValidationAction)
+        private static void ValidateValueOfType(
+          string name,
+          ICollection<object> values,
+          Action<string, string, string> failedValidationAction,
+          Type valueType)
         {
-            var expectedType = typeof(TValue);
-            var entryOfSameType = values.FirstOrDefault(arg => arg.GetType() == expectedType);
+            var entryOfSameType = values.FirstOrDefault(arg => arg.GetType() == valueType);
 
             if (entryOfSameType == null)
             {
                 failedValidationAction(
                     name,
-                    $"to have at least one entry of {expectedType.ToFriendlyTypeName()} type",
+                    $"to have at least one entry of {valueType.ToFriendlyTypeName()} type",
                     "none was found");
             }
         }
+
+        private static void ValidateValueOfType<TValue>(
+            string name,
+            ICollection<object> values,
+            Action<string, string, string> failedValidationAction)
+            => ValidateValueOfType(name, values, failedValidationAction, typeof(TValue));
     }
 }

src/MyTested.AspNetCore.Mvc.Caching/Builders/Contracts/Data/MemoryCache/IMemoryCacheTestBuilder.cs

@@ -31,6 +31,13 @@ public interface IMemoryCacheTestBuilder
         /// <returns>The same <see cref="IAndWithMemoryCacheBuilder"/>.</returns>
         IAndMemoryCacheTestBuilder ContainingEntryOfType<TValue>();
 
+        /// <summary>
+        /// Tests whether the <see cref="IMemoryCache"/> contains entry with value of the provided type.
+        /// </summary>
+        /// <param name="valueType"></param>
+        /// <returns></returns>
+        IAndMemoryCacheTestBuilder ContainingEntryOfType(Type valueType);
+
         /// <summary>
         /// Tests whether the <see cref="IMemoryCache"/> contains entry with the provided key and corresponding value.
         /// </summary>
@@ -47,6 +54,14 @@ public interface IMemoryCacheTestBuilder
         /// <returns>The same <see cref="IAndWithMemoryCacheBuilder"/>.</returns>
         IAndMemoryCacheTestBuilder ContainingEntryOfType<TValue>(object key);
 
+        /// <summary>
+        /// Tests whether the <see cref="IMemoryCache"/> contains entry with value of the provided type and the given key.
+        /// </summary>
+        /// <param name="key"></param>
+        /// <param name="valueType"></param>
+        /// <returns></returns>
+        IAndMemoryCacheTestBuilder ContainingEntryOfType(object key, Type valueType);
+
         /// <summary>
         /// Tests whether the <see cref="IMemoryCache"/> contains entry with the provided key, corresponding value and the deeply equal options to the given ones.
         /// </summary>