Rename ResolveInterfaces methods so it's clear they can be used with types too

Author: kevinkuszyk

src/FluentAssertions.Ioc.Ninject.SampleTests/IocTests.cs

@@ -23,7 +23,7 @@ public void Services_can_be_resolved_with_a_single_instance()
                                                                       .EndingWith("Service");
 
             // Assert
-            kernel.Should().ResolveInterfaces(interfaces).WithSingleInstance();
+            kernel.Should().Resolve(interfaces).WithSingleInstance();
         }
 
         [Test]
@@ -35,7 +35,7 @@ public void Providers_can_be_resolved_with_at_least_one_instance()
                                                                      .EndingWith("Provider");
 
             // Assert
-            kernel.Should().ResolveInterfaces(interfaces).WithAtLeastOneInstance();
+            kernel.Should().Resolve(interfaces).WithAtLeastOneInstance();
         }
 
         private IKernel GetKernel()

src/FluentAssertions.Ioc.Ninject.Tests/KernelAssertionTests.cs

@@ -19,7 +19,7 @@ public void Should_succeed_when_asserting_interfaces_can_be_resolved_with_a_sing
                                                                       .EndingWith("Service");
 
             // Act
-            Action act = () => kernel.Should().ResolveInterfaces(interfaces).WithSingleInstance();
+            Action act = () => kernel.Should().Resolve(interfaces).WithSingleInstance();
 
             // Assert
             act.ShouldNotThrow<AssertionException>();
@@ -34,7 +34,7 @@ public void Should_fail_when_asserting_interfaces_can_be_resolved_with_a_single_
                                                                     .EndingWith("Factory");
 
             // Act
-            Action act = () => kernel.Should().ResolveInterfaces(interfaces).WithSingleInstance();
+            Action act = () => kernel.Should().Resolve(interfaces).WithSingleInstance();
 
             // Assert
             act.ShouldThrow<AssertionException>();
@@ -47,7 +47,7 @@ public void Should_succeed_when_asserting_an_interface_can_be_resolved_with_a_si
             var kernel = GetKernel();
 
             // Act
-            Action act = () => kernel.Should().ResolveInterface<ISampleService>().WithSingleInstance();
+            Action act = () => kernel.Should().Resolve<ISampleService>().WithSingleInstance();
 
             // Assert
             act.ShouldNotThrow<AssertionException>();
@@ -60,7 +60,7 @@ public void Should_fail_when_asserting_an_interface_can_be_resolved_with_a_singl
             var kernel = GetKernel();
 
             // Act
-            Action act = () => kernel.Should().ResolveInterface<ISomeFactory>().WithSingleInstance();
+            Action act = () => kernel.Should().Resolve<ISomeFactory>().WithSingleInstance();
 
             // Assert
             act.ShouldThrow<AssertionException>();
@@ -75,7 +75,7 @@ public void Should_succeed_when_asserting_interfaces_can_be_resolved_with_at_lea
                                                                      .EndingWith("Provider");
 
             // Act
-            Action act = () => kernel.Should().ResolveInterfaces(interfaces).WithAtLeastOneInstance();
+            Action act = () => kernel.Should().Resolve(interfaces).WithAtLeastOneInstance();
 
             // Assert
             act.ShouldNotThrow<AssertionException>();
@@ -90,7 +90,7 @@ public void Should_fail_when_asserting_interfaces_can_be_resolved_with_at_least_
                                                                     .EndingWith("Factory");
 
             // Act
-            Action act = () => kernel.Should().ResolveInterfaces(interfaces).WithAtLeastOneInstance();
+            Action act = () => kernel.Should().Resolve(interfaces).WithAtLeastOneInstance();
 
             // Assert
             act.ShouldThrow<AssertionException>();
@@ -104,7 +104,7 @@ public void Should_succeed_when_asserting_interfaces_can_be_resolved_when_implem
             var interfaces = new [] { typeof (IFooService) };
 
             // Act
-            Action act = () => kernel.Should().ResolveInterfaces(interfaces).WithSingleInstance();
+            Action act = () => kernel.Should().Resolve(interfaces).WithSingleInstance();
 
             // Assert
             act.ShouldNotThrow<AssertionException>();
@@ -120,7 +120,7 @@ public void Should_fail_when_asserting_interfaces_can_be_resolved_when_implement
             kernel.Unbind<ISampleRepository>();
 
             // Act
-            Action act = () => kernel.Should().ResolveInterfaces(interfaces).WithSingleInstance();
+            Action act = () => kernel.Should().Resolve(interfaces).WithSingleInstance();
 
             // Assert
             act.ShouldThrow<AssertionException>();

src/FluentAssertions.Ioc.Ninject/KernelAssertions.cs

@@ -23,40 +23,40 @@ protected internal KernelAssertions(IKernel kernel)
         public IKernel Subject { get; private set; }
 
         /// <summary>
-        /// Gets the interfaces which trying to be resolved.
+        /// Gets the types to be resolved.
         /// </summary>
-        private IEnumerable<Type> Interfaces { get; set; }
+        private IEnumerable<Type> Types { get; set; }
 
         /// <summary>
-        /// Specifies the interfaces to try resolving from the kernel.
+        /// Specifies the types to try resolving from the kernel.
         /// </summary>
-        /// <param name="interfaces">The interfaces to resolve.</param>
-        public KernelAssertions ResolveInterfaces(IEnumerable<Type> interfaces)
+        /// <param name="types">The types to resolve.</param>
+        public KernelAssertions Resolve(IEnumerable<Type> types)
         {
-            Interfaces = interfaces;
+            Types = types;
             return this;
         }
 
         /// <summary>
-        /// Specifies the interface to try resolving from the kernel.
+        /// Specifies the type to try resolving from the kernel.
         /// </summary>
-        /// <typeparam name="TInterface">The interface to resolve.</typeparam>
+        /// <typeparam name="T">The type to resolve.</typeparam>
         /// <returns></returns>
-        public KernelAssertions ResolveInterface<TInterface>()
+        public KernelAssertions Resolve<T>()
         {
-            Interfaces = new List<Type>() { typeof(TInterface) };
+            Types = new List<Type>() { typeof(T) };
             return this;
         }
 
         /// <summary>
-        /// Asserts that the selected interface(s) can be resolved with a single instance.
+        /// Asserts that the selected type(s) can be resolved with a single instance.
         /// </summary>
         public void WithSingleInstance()
         {
             var failed = new List<ActivationError>();
 
-            // Try to activate each interface in the list
-            foreach (var type in Interfaces)
+            // Try to activate each type in the list
+            foreach (var type in Types)
             {
                 try
                 {
@@ -82,7 +82,7 @@ public void WithAtLeastOneInstance()
             var failed = new List<ActivationError>();
 
             // Try to activate each interface in the list
-            foreach (var type in Interfaces)
+            foreach (var type in Types)
             {
                 try
                 {
@@ -107,7 +107,7 @@ private string BuildFailureMessage(List<ActivationError> failed)
         {
             // Build the failure message
             var builder = new StringBuilder();
-            builder.AppendLine("The following interfaces could not be resolved:").AppendLine();
+            builder.AppendLine("The following types could not be resolved:").AppendLine();
 
             foreach (var error in failed)
                 builder.AppendFormat(" - {0}", error.Type.FullName).AppendLine();