Add several new methods to Types and Methods Assertions

CONTRIBUTING.md

@@ -5,4 +5,4 @@ No open-source project is going to be successful without contributions. After we
 * The [Pull Request](https://help.github.com/articles/using-pull-requests) is targeted at the `develop` branch.
 * The code complies with the [Coding Guidelines for C# 3.0, 4.0 and 5.0](https://csharpcodingguidelines.com/)/.
 * The changes are covered by a new or existing set of unit tests which follow the Arrange-Act-Assert syntax such as is used [in this example](https://github.com/fluentassertions/fluentassertions/blob/daaf35b9b59b622c96d0c034e8972a020b2bee55/Tests/FluentAssertions.Shared.Specs/BasicEquivalencySpecs.cs#L33).
-* If the contribution affects the documentation, please update [**the documentation**](https://github.com/fluentassertions/fluentassertions/tree/master/docs), which is published on the [website](https://fluentassertions.com/documentation/).
+* If the contribution affects the documentation, please update [**the documentation**](https://github.com/fluentassertions/fluentassertions/tree/master/docs), which is published on the [website](https://fluentassertions.com/introduction/).

Src/FluentAssertions/TypeEnumerableExtensions.cs

@@ -77,5 +77,60 @@ public static IEnumerable<Type> ThatImplement<T>(this IEnumerable<Type> types)
         {
             return new TypeSelector(types).ThatImplement<T>();
         }
+
+        /// <summary>
+        /// Filters to only include types that are classes.
+        /// </summary>
+        public static IEnumerable<Type> ThatAreClasses(this IEnumerable<Type> types)
+        {
+            return new TypeSelector(types).ThatAreClasses();
+        }
+
+        /// <summary>
+        /// Filters to only include types that are not classes.
+        /// </summary>
+        public static IEnumerable<Type> ThatAreNotClasses(this IEnumerable<Type> types)
+        {
+            return new TypeSelector(types).ThatAreNotClasses();
+        }
+        /// <summary>
+        /// Filters to only include types that are static classes.
+        /// </summary>
+        public static IEnumerable<Type> ThatAreStaticClasses(this IEnumerable<Type> types)
+        {
+            return new TypeSelector(types).ThatAreStaticClasses();
+        }
+
+        /// <summary>
+        /// Filters to only include types that are not static classes.
+        /// </summary>
+        public static IEnumerable<Type> ThatAreNotStaticClasses(this IEnumerable<Type> types)
+        {
+            return new TypeSelector(types).ThatAreNotStaticClasses();
+        }
+
+        /// <summary>
+        /// Filters to only include types that satisfies the <paramref name="predicate"/> passed.
+        /// </summary>
+        public static IEnumerable<Type> ThatAre(this IEnumerable<Type> types, Func<Type, bool> predicate)
+        {
+            return new TypeSelector(types).ThatAre(predicate);
+        }
+
+        /// <summary>
+        /// Returns T for the types which are Task&lt;T&gt;; the type itself otherwise
+        /// </summary>
+        public static IEnumerable<Type> UnwrapTaskTypes(this IEnumerable<Type> types)
+        {
+            return new TypeSelector(types).UnwrapTaskTypes();
+        }
+
+        /// <summary>
+        /// Returns T for the types which are IEnumerable&lt;T&gt; or implement the IEnumerable&lt;T&gt;; the type itself otherwise
+        /// </summary>
+        public static IEnumerable<Type> UnwrapEnumerableTypes(this IEnumerable<Type> types)
+        {
+            return new TypeSelector(types).UnwrapEnumerableTypes();
+        }
     }
 }

Src/FluentAssertions/Types/MethodInfoSelector.cs

@@ -128,6 +128,17 @@ public MethodInfoSelector ThatAreNotDecoratedWithOrInherit<TAttribute>()
             return this;
         }
 
+        /// <summary>
+        /// Select return types of the methods
+        /// </summary>
+        /// <returns></returns>
+        public TypeSelector ReturnTypes()
+        {
+            var returnTypes = selectedMethods.Select(mi => mi.ReturnType);
+
+            return new TypeSelector(returnTypes);
+        }
+
         /// <summary>
         /// The resulting <see cref="MethodInfo"/> objects.
         /// </summary>

Src/FluentAssertions/Types/MethodInfoSelectorAssertions.cs

@@ -205,6 +205,52 @@ public AndConstraint<MethodInfoSelectorAssertions> NotBeDecoratedWith<TAttribute
             return new AndConstraint<MethodInfoSelectorAssertions>(this);
         }
 
+        /// <summary>
+        /// Asserts that the selected methods have specified <paramref name="accessModifier"/>.
+        /// </summary>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+        /// </param>
+        public AndConstraint<MethodInfoSelectorAssertions> Be(CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs)
+        {
+            var methods = SubjectMethods.Where(pi => pi.GetCSharpAccessModifier() != accessModifier).ToArray();
+            var message = $"Expected all selected methods to be {accessModifier}{{reason}}, but the following methods are not:" + Environment.NewLine + GetDescriptionsFor(methods);
+
+            Execute.Assertion
+                .ForCondition(!methods.Any())
+                .BecauseOf(because, becauseArgs)
+                .FailWith(message);
+
+            return new AndConstraint<MethodInfoSelectorAssertions>(this);
+        }
+
+        /// <summary>
+        /// Asserts that the selected methods don't have specified <paramref name="accessModifier"/>
+        /// </summary>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+        /// </param>
+        public AndConstraint<MethodInfoSelectorAssertions> NotBe(CSharpAccessModifier accessModifier, string because = "", params object[] becauseArgs)
+        {
+            var methods = SubjectMethods.Where(pi => pi.GetCSharpAccessModifier() == accessModifier).ToArray();
+            var message = $"Expected all selected methods to not be {accessModifier}{{reason}}, but the following methods are:" + Environment.NewLine + GetDescriptionsFor(methods);
+
+            Execute.Assertion
+                .ForCondition(!methods.Any())
+                .BecauseOf(because, becauseArgs)
+                .FailWith(message);
+
+            return new AndConstraint<MethodInfoSelectorAssertions>(this);
+        }
+
         private MethodInfo[] GetMethodsWithout<TAttribute>(Expression<Func<TAttribute, bool>> isMatchingPredicate)
             where TAttribute : Attribute
         {

Src/FluentAssertions/Types/TypeSelector.cs

@@ -2,6 +2,8 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
+using System.Threading.Tasks;
 using FluentAssertions.Common;
 
 namespace FluentAssertions.Types
@@ -165,6 +167,96 @@ public TypeSelector ThatAreNotUnderNamespace(string @namespace)
             return this;
         }
 
+        /// <summary>
+        /// Determines whether the type is class
+        /// </summary>
+        public TypeSelector ThatAreClasses()
+        {
+            types = types.Where(t => t.IsClass).ToList();
+            return this;
+        }
+        /// <summary>
+        /// Determines whether the type is not a class
+        /// </summary>
+        public TypeSelector ThatAreNotClasses()
+        {
+            types = types.Where(t => !t.IsClass).ToList();
+            return this;
+        }
+
+        /// <summary>
+        /// Determines whether the type is a static class
+        /// </summary>
+        public TypeSelector ThatAreStaticClasses()
+        {
+            types = types.Where(t => t.IsCSharpStatic()).ToList();
+            return this;
+        }
+
+        /// <summary>
+        /// Determines whether the type is not a static class
+        /// </summary>
+        public TypeSelector ThatAreNotStaticClasses()
+        {
+            types = types.Where(t => !t.IsCSharpStatic()).ToList();
+            return this;
+        }
+
+        /// <summary>
+        /// Allows to filter the types with the <paramref name="predicate"/> passed
+        /// </summary>
+        public TypeSelector ThatAre(Func<Type, bool> predicate)
+        {
+            types = types.Where(predicate).ToList();
+            return this;
+        }
+
+        /// <summary>
+        /// Returns T for the types which are Task&lt;T&gt;; the type itself otherwise
+        /// </summary>
+        public TypeSelector UnwrapTaskTypes()
+        {
+            types = types.Select(type =>
+            {
+                if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Task<>))
+                {
+                    return type.GetGenericArguments().Single();
+                }
+                return type == typeof(Task) ? typeof(void) : type;
+            }).ToList();
+
+            return this;
+        }
+
+        /// <summary>
+        /// Returns T for the types which are IEnumerable&lt;T&gt; or implement the IEnumerable&lt;T&gt;; the type itself otherwise
+        /// </summary>
+        public TypeSelector UnwrapEnumerableTypes()
+        {
+            types = types
+                .Select(type =>
+                {
+                    if (type.IsGenericType)
+                    {
+                        if (type.GetGenericTypeDefinition() == typeof(IEnumerable<>))
+                        {
+                            return type.GetGenericArguments().Single();
+                        }
+
+                        var iEnumerableDefinition = type.GetInterfaces()
+                            .SingleOrDefault(iType => iType.IsGenericType && iType.GetGenericTypeDefinition() == typeof(IEnumerable<>));
+                        if (iEnumerableDefinition != null)
+                        {
+                            return iEnumerableDefinition.GetGenericArguments().Single();
+                        }
+                    }
+
+                    return type;
+                }).ToList();
+
+            return this;
+        }
+
         /// <summary>
         /// Returns an enumerator that iterates through the collection.
         /// </summary>

Src/FluentAssertions/Types/TypeSelectorAssertions.cs

@@ -292,6 +292,47 @@ public AndConstraint<TypeSelectorAssertions> NotBeDecoratedWithOrInherit<TAttrib
             return new AndConstraint<TypeSelectorAssertions>(this);
         }
 
+        /// <summary>
+        /// Asserts that the all <see cref="Type"/> are sealed classes
+        /// </summary>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+        /// </param>
+        public AndConstraint<TypeSelectorAssertions> BeSealed(string because = "", params object[] becauseArgs)
+        {
+            var notSealedTypes = Subject.Where(type => !type.IsCSharpSealed()).ToArray();
+
+            Execute.Assertion.ForCondition(!notSealedTypes.Any())
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected all types to be sealed{reason}, but the following types are not:{0}{1}.", Environment.NewLine, GetDescriptionsFor(notSealedTypes));
+
+            return new AndConstraint<TypeSelectorAssertions>(this);
+        }
+
+        /// <summary>
+        /// Asserts that the all <see cref="Type"/> are not sealed classes
+        /// </summary>
+        /// <param name="because">
+        /// A formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the assertion
+        /// is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <paramref name="because" />.
+        /// </param>
+        public AndConstraint<TypeSelectorAssertions> NotBeSealed(string because = "", params object[] becauseArgs)
+        {
+            var sealedTypes = Subject.Where(type => type.IsCSharpSealed()).ToArray();
+
+            Execute.Assertion.ForCondition(!sealedTypes.Any())
+                .BecauseOf(because, becauseArgs)
+                .FailWith("Expected all types not to be sealed{reason}, but the following types are:{0}{1}.", Environment.NewLine, GetDescriptionsFor(sealedTypes));
+
+            return new AndConstraint<TypeSelectorAssertions>(this);
+        }
         private static string GetDescriptionsFor(IEnumerable<Type> types)
         {
             string[] descriptions = types.Select(GetDescriptionFor).ToArray();