Merge branch 'development' into development

Author: vaptsarov

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

@@ -41,5 +41,12 @@ TAttributesTestBuilder PassingFor<TAttribute>(Action<TAttribute> assertions)
         /// <returns>The same attributes test builder.</returns>
         TAttributesTestBuilder PassingFor<TAttribute>(Func<TAttribute, bool> predicate)
             where TAttribute : Attribute;
+
+
+        /// <summary>
+        /// Adds inherited attributes.
+        /// </summary>
+        /// <returns>The same attributes test builder.</returns>
+        TAttributesTestBuilder IncludingInherited();
     }
 }

src/MyTested.AspNetCore.Mvc.Abstractions/Internal/TestContexts/ComponentTestContext.cs

@@ -22,8 +22,11 @@ public abstract class ComponentTestContext : HttpTestContext
 
         public object Component => this.component ??= this.ComponentConstructionDelegate();
 
-        public IEnumerable<object> ComponentAttributes 
-            => this.componentAttributes ??= Reflection.GetCustomAttributes(this.Component);
+        public IEnumerable<object> ComponentAttributes
+        {
+            get => this.componentAttributes ??= Reflection.GetCustomAttributes(this.Component);
+            private set => this.componentAttributes = value;
+        }
 
         public IDictionary<Type, object> AggregatedDependencies 
             => this.aggregatedDependencies ??= new Dictionary<Type, object>();
@@ -66,27 +69,20 @@ public LambdaExpression MethodCall
         public object MethodResult
         { 
             get => this.methodResult;
-
             set => this.methodResult = this.ConvertMethodResult(value);
         }
 
-        public IEnumerable<object> MethodAttributes 
-            => this.methodAttributes ??= Reflection.GetCustomAttributes(this.Method);
+        public IEnumerable<object> MethodAttributes
+        {
+            get => this.methodAttributes ??= Reflection.GetCustomAttributes(this.Method);
+            private set => this.methodAttributes = value;
+        }
 
         public Exception CaughtException { get; set; }
 
         public object Model
         {
-            get
-            {
-                if (this.model == null)
-                {
-                    return this.MethodResult;
-                }
-
-                return this.model;
-            }
-
+            get => this.model ?? this.MethodResult;
             set => this.model = value;
         }
 
@@ -116,6 +112,12 @@ public void Apply<TMethodResult>(InvocationTestContext<TMethodResult> invocation
             this.CaughtException = invocationTestContext.CaughtException;
         }
 
+        public void IncludeInheritedComponentAttributes()
+            => this.ComponentAttributes = Reflection.GetCustomAttributes(this.Component, true);
+
+        public void IncludeInheritedMethodAttributes()
+            => this.MethodAttributes = Reflection.GetCustomAttributes(this.Method, true);
+
         protected virtual object ConvertMethodResult(object convertibleMethodResult) => convertibleMethodResult;
     }
 }

src/MyTested.AspNetCore.Mvc.Abstractions/Utilities/Reflection.cs

@@ -17,6 +17,8 @@
     /// </summary>
     public static class Reflection
     {
+        private const bool ShouldInheritAttributes = false;
+
         private static readonly ConcurrentDictionary<Type, ConstructorInfo> TypesWithOneConstructorCache = new ConcurrentDictionary<Type, ConstructorInfo>();
         private static readonly ConcurrentDictionary<Type, IEnumerable<object>> TypeAttributesCache = new ConcurrentDictionary<Type, IEnumerable<object>>();
         private static readonly ConcurrentDictionary<MethodInfo, IEnumerable<object>> MethodAttributesCache = new ConcurrentDictionary<MethodInfo, IEnumerable<object>>();
@@ -118,8 +120,8 @@ public static bool HasGenericTypeDefinition(Type type, Type genericTypeDefinitio
         /// <param name="inheritedType">Inherited type to be checked.</param>
         /// <returns>True or false.</returns>
         public static bool AreAssignableByGeneric(Type baseType, Type inheritedType)
-            => IsGeneric(inheritedType) 
-                && IsGeneric(baseType) 
+            => IsGeneric(inheritedType)
+                && IsGeneric(baseType)
                 && baseType.IsAssignableFrom(inheritedType.GetGenericTypeDefinition());
 
         /// <summary>
@@ -283,17 +285,32 @@ public static T TryCreateInstance<T>(IDictionary<Type, object> constructorParame
         /// Gets custom attributes on the provided object.
         /// </summary>
         /// <param name="obj">Object decorated with custom attribute.</param>
+        /// <param name="shouldInherit">Indicates whether it should include inherited component attributes</param>
         /// <returns>IEnumerable of objects representing the custom attributes.</returns>
-        public static IEnumerable<object> GetCustomAttributes(object obj)
+        public static IEnumerable<object> GetCustomAttributes(object obj, bool shouldInherit = ShouldInheritAttributes)
         {
             var type = obj.GetType();
+            var attributes = type.GetTypeInfo().GetCustomAttributes(shouldInherit);
+            UpdateAttributesIfNeeded(type, attributes, TypeAttributesCache);
+
             return TypeAttributesCache
-                .GetOrAdd(type, _ => type.GetTypeInfo().GetCustomAttributes(false));
+                .GetOrAdd(type, _ => attributes);
         }
 
-        public static IEnumerable<object> GetCustomAttributes(MethodInfo method)
-            => MethodAttributesCache
-                .GetOrAdd(method, _ => method.GetCustomAttributes(false));
+        /// <summary>
+        /// Gets custom attributes on the provided method.
+        /// </summary>
+        /// <param name="method">Method decorated with custom attribute.</param>
+        /// <param name="shouldInherit">Indicates whether it should include inherited method attributes</param>
+        /// <returns>IEnumerable of objects representing the custom attributes.</returns>
+        public static IEnumerable<object> GetCustomAttributes(MethodInfo method, bool shouldInherit = ShouldInheritAttributes)
+        {
+            var attributes = method.GetCustomAttributes(shouldInherit);
+            UpdateAttributesIfNeeded(method, attributes, MethodAttributesCache);
+
+            return MethodAttributesCache
+                .GetOrAdd(method, _ => attributes);
+        }
 
         /// <summary>
         /// Checks whether two objects are deeply equal by reflecting all their public properties recursively. Resolves successfully value and reference types, overridden Equals method, custom == operator, IComparable, nested objects and collection properties.
@@ -388,7 +405,7 @@ public static TDelegate CreateDelegateFromMethod<TDelegate>(object instance, Fun
                 .FirstOrDefault(methodFilter)
                 ?.CreateDelegate(typeof(TDelegate), instance) as TDelegate;
         }
-        
+
         /// <summary>
         /// Checks whether property with the provided name exists in a dynamic object.
         /// </summary>
@@ -462,8 +479,8 @@ private static ConstructorInfo GetConstructorByUnorderedParameters(this Type typ
         }
 
         private static bool AreDeeplyEqual(
-            object expected, 
-            object actual, 
+            object expected,
+            object actual,
             ConditionalWeakTable<object, object> processedElements,
             DeepEqualityResult result)
         {
@@ -531,7 +548,7 @@ private static bool AreDeeplyEqual(
                     ? result.Success
                     : result.Failure;
             }
-            
+
             var equalsOperator = expectedType.GetMethods().FirstOrDefault(m => m.Name == "op_Equality");
             if (equalsOperator != null)
             {
@@ -583,15 +600,15 @@ private static bool AreDeeplyEqual(
         }
 
         private static bool AreNotDeeplyEqual(
-            object expected, 
-            object actual, 
+            object expected,
+            object actual,
             ConditionalWeakTable<object, object> processedElements,
             DeepEqualityResult result)
             => !AreDeeplyEqual(expected, actual, processedElements, result);
 
         private static bool CollectionsAreDeeplyEqual(
-            object expected, 
-            object actual, 
+            object expected,
+            object actual,
             ConditionalWeakTable<object, object> processedElements,
             DeepEqualityResult result)
         {
@@ -675,8 +692,8 @@ private static bool ObjectImplementsIComparable(object obj)
                 .FirstOrDefault(i => i.Name.StartsWith("IComparable")) != null;
 
         private static bool ObjectPropertiesAreDeeplyEqual(
-            object expected, 
-            object actual, 
+            object expected,
+            object actual,
             ConditionalWeakTable<object, object> processedElements,
             DeepEqualityResult result)
         {
@@ -696,8 +713,8 @@ private static bool ObjectPropertiesAreDeeplyEqual(
                 if (expectedPropertyValue is IEnumerable && expectedPropertyValue.GetType() != typeof(string))
                 {
                     if (!CollectionsAreDeeplyEqual(
-                        expectedPropertyValue, 
-                        actualPropertyValue, 
+                        expectedPropertyValue,
+                        actualPropertyValue,
                         processedElements,
                         result))
                     {
@@ -706,8 +723,8 @@ private static bool ObjectPropertiesAreDeeplyEqual(
                 }
 
                 var propertiesAreDifferent = AreNotDeeplyEqual(
-                    expectedPropertyValue, 
-                    actualPropertyValue, 
+                    expectedPropertyValue,
+                    actualPropertyValue,
                     processedElements,
                     result);
 
@@ -722,11 +739,22 @@ private static bool ObjectPropertiesAreDeeplyEqual(
             return result.Success;
         }
 
+        private static void UpdateAttributesIfNeeded<T>(
+            T key,
+            object[] attributes,
+            ConcurrentDictionary<T, IEnumerable<object>> result)
+        {
+            if (result.ContainsKey(key))
+            {
+                result.AddOrUpdate(key, attributes, (dictKey, oldValue) => attributes);
+            }
+        }
+
         private static string GetFriendlyTypeName(Type type, bool useFullName)
         {
             const string anonymousTypePrefix = "<>f__";
 
-            var typeName = useFullName 
+            var typeName = useFullName
                 ? type?.FullName ?? type?.Name
                 : type?.Name;
 

src/MyTested.AspNetCore.Mvc.Controllers/Builders/Attributes/ActionAttributesTestBuilder.cs

@@ -31,10 +31,13 @@ public ActionAttributesTestBuilder(ControllerTestContext testContext)
         public IActionAttributesTestBuilder AndAlso() => this;
 
         public override void ThrowNewAttributeAssertionException(string expectedValue, string actualValue) 
-            => throw new AttributeAssertionException(string.Format(
-                "{0} action to have {1}, but {2}.",
-                this.TestContext.ExceptionMessagePrefix,
-                expectedValue,
-                actualValue));
+            => throw new AttributeAssertionException($"{this.TestContext.ExceptionMessagePrefix} action to have {expectedValue}, but {actualValue}.");
+
+        /// <inheritdoc />
+        public IAndActionAttributesTestBuilder IncludingInherited()
+        { 
+            this.TestContext.IncludeInheritedMethodAttributes();
+            return this;
+        }
     }
 }

src/MyTested.AspNetCore.Mvc.Controllers/Builders/Attributes/ControllerAttributesTestBuilder.cs

@@ -26,5 +26,12 @@ public ControllerAttributesTestBuilder(ControllerTestContext testContext)
 
         /// <inheritdoc />
         public IControllerAttributesTestBuilder AndAlso() => this;
+
+        /// <inheritdoc />
+        public IAndControllerAttributesTestBuilder IncludingInherited()
+        {
+            this.TestContext.IncludeInheritedComponentAttributes();
+            return this;
+        }
     }
 }

src/MyTested.AspNetCore.Mvc.ViewComponents/Builders/Attributes/ViewComponentAttributesTestBuilder.cs

@@ -24,5 +24,12 @@ public ViewComponentAttributesTestBuilder(ComponentTestContext testContext)
 
         /// <inheritdoc />
         public IViewComponentAttributesTestBuilder AndAlso() => this;
+
+        /// <inheritdoc />
+        public IAndViewComponentAttributesTestBuilder IncludingInherited()
+        {
+            this.TestContext.IncludeInheritedComponentAttributes();
+            return this;
+        }
     }
 }

test/MyTested.AspNetCore.Mvc.Controllers.Test/BuildersTests/AttributesTests/ActionAttributesTestBuilderTests.cs

@@ -6,6 +6,7 @@
     using Setups.Controllers;
     using Xunit;
     using System;
+    using Microsoft.AspNetCore.Authorization;
 
     public class ActionAttributesTestBuilderTests
     {
@@ -118,5 +119,17 @@ public void PassingForShouldThrowExceptionWithIncorrectAttributeWithPredicate()
                 },
                 "When calling OtherAttributes action in MvcController expected action to have ActionNameAttribute, but in fact such was not found.");
         }
+
+        [Fact]
+        public void IncludingInheritedShouldIncludeAllCustomInheritedAttributesFromBaseMethodsAndNotThrowException()
+        {
+            MyController<InheritControllerAttributes>
+                .Instance()
+                .Calling(c=> c.MethodA())
+                .ShouldHave()
+                .ActionAttributes(attributes => attributes.IncludingInherited()
+                    .ContainingAttributeOfType<HttpPostAttribute>()
+                    .ContainingAttributeOfType<AuthorizeAttribute>());
+        }
     }
 }

test/MyTested.AspNetCore.Mvc.Controllers.Test/BuildersTests/AttributesTests/ControllerAttributesTestBuilderTests.cs

@@ -66,7 +66,7 @@ public void PassingForShouldThrowExceptionWithIncorrectAttribute()
                 },
                 "When testing MvcController was expected to have ActionNameAttribute, but in fact such was not found.");
         }
-        
+
         [Fact]
         public void PassingForShouldNotThrowExceptionWithCorrectPredicate()
         {
@@ -105,5 +105,33 @@ public void PassingForShouldThrowExceptionWithIncorrectAttributeWithPredicate()
                 },
                 "When testing MvcController was expected to have ActionNameAttribute, but in fact such was not found.");
         }
+
+        [Fact]
+        public void IncludingInheritedShouldIncludeAllCustomInheritedAttributesFromBaseClassesAndNotThrowException()
+        {
+            MyController<InheritControllerAttributes>
+                .Instance()
+                .ShouldHave()
+                .Attributes(attributes => attributes.IncludingInherited()
+                    .ContainingAttributeOfType<ValidateAntiForgeryTokenAttribute>()
+                    .ContainingAttributeOfType<AllowAnonymousAttribute>()
+                    .ContainingAttributeOfType<ResponseCacheAttribute>());
+        }
+
+        [Fact]
+        public void TryingToAssertInheritedAttributesWithoutIncludingInheritedShouldThrowException()
+        {
+            Test.AssertException<AttributeAssertionException>(
+                () =>
+                {
+                    MyController<InheritControllerAttributes>
+                        .Instance()
+                        .ShouldHave()
+                        .Attributes(attributes => attributes//.IncludingInherited()
+                            .ContainingAttributeOfType<ValidateAntiForgeryTokenAttribute>()
+                            .ContainingAttributeOfType<AllowAnonymousAttribute>()
+                            .ContainingAttributeOfType<ResponseCacheAttribute>());
+                }, $"When testing {nameof(InheritControllerAttributes)} was expected to have ValidateAntiForgeryTokenAttribute, but in fact such was not found.");
+        }
     }
 }

test/MyTested.AspNetCore.Mvc.Test.Setups/Controllers/InheritControllerAttributes.cs

@@ -0,0 +1,22 @@
+namespace MyTested.AspNetCore.Mvc.Test.Setups.Controllers
+{
+    using System;
+    using Microsoft.AspNetCore.Authorization;
+    using Microsoft.AspNetCore.Mvc;
+
+    [ResponseCache]
+    public class InheritControllerAttributes : InheritAttributesBaseController
+    {
+        public override uint MethodA()
+            => 10;
+    }
+
+    [AllowAnonymous]
+    [ValidateAntiForgeryToken]
+    public abstract class InheritAttributesBaseController : ControllerBase
+    {
+        [Authorize]
+        [HttpPost]
+        public abstract uint MethodA();
+    }
+}

test/MyTested.AspNetCore.Mvc.Test.Setups/ViewComponents/InheritViewComponent.cs

@@ -0,0 +1,17 @@
+namespace MyTested.AspNetCore.Mvc.Test.Setups.ViewComponents
+{
+    using Microsoft.AspNetCore.Authorization;
+    using Microsoft.AspNetCore.Mvc;
+
+    [ResponseCache]
+    public class InheritViewComponent : BaseInheritViewComponent
+    {
+    }
+
+    [AllowAnonymous]
+    [ValidateAntiForgeryToken]
+    public abstract class BaseInheritViewComponent : ViewComponent
+    {
+        public virtual IViewComponentResult Invoke() => this.View();
+    }
+}