#3 Assert an interface resolves to a concrete implementation

Author: kevinkuszyk

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

@@ -1,5 +1,6 @@
 using System;
 using FluentAssertions.Ioc.Ninject.Sample;
+using FluentAssertions.Ioc.Samples.Core;
 using FluentAssertions.Ioc.Samples.Interfaces;
 using Ninject;
 using Ninject.Modules;
@@ -126,6 +127,32 @@ public void Should_fail_when_asserting_interfaces_can_be_resolved_when_implement
             act.ShouldThrow<AssertionException>();
         }
 
+        [Test]
+        public void Should_pass_when_asserting_an_interface_resolves_to_concrete_implementation()
+        {
+            // Arrange
+            var kernel = GetKernel();
+            
+            // Act
+            Action act = () => kernel.Should().Resolve<IFooService>().To<FooService>();
+
+            // Assert
+            act.ShouldNotThrow<Exception>();
+        }
+
+        [Test]
+        public void Should_fail_when_asserting_an_interface_resolves_to_concrete_implementation()
+        {
+            // Arrange
+            var kernel = GetKernel();
+            
+            // Act
+            Action act = () => kernel.Should().Resolve<IFooService>().To<FooService2>();
+
+            // Assert
+            act.ShouldThrow<AssertionException>().And.Message.Should().Be(@"Expected interface ""IFooService"" to resolve to type ""FooService2"", but found ""FooService"" instead");
+        }
+
         private IKernel GetKernel()
         {
             var modules = new INinjectModule[]
@@ -135,6 +162,14 @@ private IKernel GetKernel()
 
             return new StandardKernel(modules);
         }
+
+        public class FooService2 : IFooService
+        {
+            public void DoWork()
+            {
+                throw new NotImplementedException();
+            }
+        }
 
     }
 }

src/FluentAssertions.Ioc.Ninject/KernelAssertions.cs

@@ -103,6 +103,23 @@ public void WithAtLeastOneInstance()
                              .FailWith(BuildFailureMessage(failed));
         }
 
+        /// <summary>
+        /// Asserts that the specified interface resolves to a concrete type.
+        /// </summary>
+        /// <typeparam name="T">The expected concrete type.</typeparam>
+        public void To<T>()
+        {
+            foreach (var type in Types)
+            {
+                var actual = Subject.Get(type).GetType();
+                var expected = typeof (T);
+
+                Execute.Assertion.ForCondition(actual == expected)
+                                 .FailWith("Expected interface {0} to resolve to type {1}, but found {2} instead", type.Name, expected.Name, actual.Name);
+                
+            }
+        }
+
         private string BuildFailureMessage(List<ActivationError> failed)
         {
             // Build the failure message