Added more xml comments.

Author: kevinkuszyk

src/FluentAssertions.Ioc.Ninject/AssemblyAssertions.cs

@@ -5,13 +5,19 @@
 
 namespace FluentAssertions.Ioc.Ninject
 {
+    /// <summary>
+    /// Contains a number of methods to assert that a <see cref="Assembly"/> is in the expected state.
+    /// </summary>
     public class AssemblyAssertions
     {
         protected internal AssemblyAssertions(Assembly assembly)
         {
             Subject = assembly;
         }
 
+        /// <summary>
+        /// Gets the assembly which is being asserted.
+        /// </summary>
         public Assembly Subject { get; private set; }
 
         /// <summary>

src/FluentAssertions.Ioc.Ninject/AssemblyExtensions.cs

@@ -7,26 +7,49 @@ namespace FluentAssertions.Ioc.Ninject
 {
     public static class AssemblyExtensions
     {
+        /// <summary>
+        /// Gets all the public interfaces in an assembly.
+        /// </summary>
+        /// <param name="assembly">The assembly to search</param>
         public static IEnumerable<Type> GetPublicInterfaces(this Assembly assembly)
         {
             return GetAllInterfaces(assembly).Where(x => x.IsPublic);
         }
 
+        /// <summary>
+        /// Gets all the interfaces in an assembly.
+        /// </summary>
+        /// <param name="assembly">The assembly to search</param>
         public static IEnumerable<Type> GetAllInterfaces(this Assembly assembly)
         {
             return assembly.GetTypes().Where(x => x.IsInterface);
         }
 
+        /// <summary>
+        /// Filters for just the types in the specified namespace.
+        /// </summary>
+        /// <typeparam name="T">The namespace of this type.</typeparam>
+        /// <param name="types">The types to filter.</param>
         public static IEnumerable<Type> InNamespaceOf<T>(this IEnumerable<Type> types)
         {
             return types.Where(x => x.Namespace == typeof(T).Namespace);
         }
 
+        /// <summary>
+        /// Filters to exclude the specified type.
+        /// </summary>
+        /// <typeparam name="T">The type to exclude.</typeparam>
+        /// <param name="types">The types to filter.</param>
         public static IEnumerable<Type> Excluding<T>(this IEnumerable<Type> types)
         {
             return types.Where(x => x.Name != typeof(T).Name);
         }
 
+        /// <summary>
+        /// Filters to only include types where the type name ends with the specified string.
+        /// </summary>
+        /// <param name="types">The types to filter.</param>
+        /// <param name="endingWith">The ending with string.</param>
         public static IEnumerable<Type> EndingWith(this IEnumerable<Type> types, string endingWith)
         {
             return types.Where(x => x.Name.EndsWith(endingWith));

src/FluentAssertions.Ioc.Ninject/FindAssembly.cs

@@ -4,6 +4,11 @@ namespace FluentAssertions.Ioc.Ninject
 {
     public static class FindAssembly
     {
+        /// <summary>
+        /// Finds the assembly containing the specified type.
+        /// </summary>
+        /// <typeparam name="T">The type to find.</typeparam>
+        /// <returns>The assembly.</returns>
         public static Assembly Containing<T>()
         {
             return typeof(T).Assembly;

src/FluentAssertions.Ioc.Ninject/KernelAssertions.cs

@@ -7,28 +7,50 @@
 
 namespace FluentAssertions.Ioc.Ninject
 {
+    /// <summary>
+    /// Contains a number of methods to assert that a <see cref="IKernel"/> is in the expected state.
+    /// </summary>
     public class KernelAssertions
     {
         protected internal KernelAssertions(IKernel kernel)
         {
             Subject = kernel;
         }
 
+        /// <summary>
+        /// Gets the kernel which is being asserted.
+        /// </summary>
         public IKernel Subject { get; private set; }
+
+        /// <summary>
+        /// Gets the interfaces which trying to be resolved.
+        /// </summary>
         private IEnumerable<Type> Interfaces { get; set; }
 
+        /// <summary>
+        /// Specifies the interfaces to try resolving from the kernel.
+        /// </summary>
+        /// <param name="interfaces">The interfaces to resolve.</param>
         public KernelAssertions ResolveInterfaces(IEnumerable<Type> interfaces)
         {
             Interfaces = interfaces;
             return this;
         }
 
-        public KernelAssertions ResolveInterface<TInferface>()
+        /// <summary>
+        /// Specifies the interface to try resolving from the kernel.
+        /// </summary>
+        /// <typeparam name="TInterface">The interface to resolve.</typeparam>
+        /// <returns></returns>
+        public KernelAssertions ResolveInterface<TInterface>()
         {
-            Interfaces = new List<Type>() { typeof(TInferface) };
+            Interfaces = new List<Type>() { typeof(TInterface) };
             return this;
         }
 
+        /// <summary>
+        /// Asserts that the selected interface(s) can be resolved with a single instance.
+        /// </summary>
         public void WithSingleInstance()
         {
             var failed = new List<ActivationError>();
@@ -55,6 +77,9 @@ public void WithSingleInstance()
                              .FailWith(BuildFailureMessage(failed));
         }
 
+        /// <summary>
+        /// Asserts that the selected interface(s) can be resolved with at least one instance.
+        /// </summary>
         public void WithAtLeastOneInstance()
         {
             var failed = new List<ActivationError>();