InversionOfControl/Castle.MicroKernel.Tests/MicroKernelTestCase.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.MicroKernel.Tests
  16 {
  17         using System;
  18         using System.Collections;
  19         using Castle.MicroKernel.Tests.ClassComponents;
  20         using NUnit.Framework;
  21
  22         [TestFixture]
  23         public class MicroKernelTestCase
  24         {
  25                 private IKernel kernel;
  26
  27                 [SetUp]
  28                 public void Init()
  29                 {
  30                         kernel = new DefaultKernel();
  31                 }
  32
  33                 [TearDown]
  34                 public void Dispose()
  35                 {
  36                         kernel.Dispose();
  37                 }
  38
  39                 [Test]
  40                 public void IOC_50_AddTwoComponentWithSameService_RequestFirstByKey_RemoveFirst_RequestByService_ShouldReturnSecond()
  41                 {
  42                         kernel.AddComponent("key", typeof(ICustomer), typeof(CustomerImpl));
  43                         kernel.AddComponent("key2", typeof(ICustomer), typeof(CustomerImpl));
  44                         object result = kernel["key"];
  45                         Assert.IsNotNull(result);
  46
  47                         kernel.RemoveComponent("key");
  48
  49                         result = kernel[typeof(ICustomer)];
  50                         Assert.IsNotNull(result);
  51                 }
  52
  53                 [Test]
  54                 public void AddClassComponentWithInterface()
  55                 {
  56                         kernel.AddComponent("key", typeof(CustomerImpl));
  57                         Assert.IsTrue(kernel.HasComponent("key"));
  58                 }
  59
  60                 [Test]
  61                 public void AddClassComponentWithNoInterface()
  62                 {
  63                         kernel.AddComponent("key", typeof(DefaultCustomer));
  64                         Assert.IsTrue(kernel.HasComponent("key"));
  65                 }
  66
  67                 [Test]
  68                 public void AddComponentInstance()
  69                 {
  70                         CustomerImpl customer = new CustomerImpl();
  71
  72                         kernel.AddComponentInstance("key", typeof(ICustomer), customer);
  73                         Assert.IsTrue(kernel.HasComponent("key"));
  74
  75                         CustomerImpl customer2 = kernel["key"] as CustomerImpl;
  76                         Assert.AreSame(customer, customer2);
  77
  78                         customer2 = kernel[typeof(ICustomer)] as CustomerImpl;
  79                         Assert.AreSame(customer, customer2);
  80                 }
  81
  82                 [Test]
  83                 public void AddComponentInstance_ByService()
  84                 {
  85                         CustomerImpl customer = new CustomerImpl();
  86
  87                         kernel.AddComponentInstance <ICustomer>(customer);
  88                         Assert.AreSame(kernel[typeof(ICustomer)],customer);
  89                 }
  90
  91                 [Test]
  92                 public void AddComponentInstance2()
  93                 {
  94                         CustomerImpl customer = new CustomerImpl();
  95
  96                         kernel.AddComponentInstance("key", customer);
  97                         Assert.IsTrue(kernel.HasComponent("key"));
  98
  99                         CustomerImpl customer2 = kernel["key"] as CustomerImpl;
 100                         Assert.AreSame(customer, customer2);
 101
 102                         customer2 = kernel[typeof(CustomerImpl)] as CustomerImpl;
 103                         Assert.AreSame(customer, customer2);
 104                 }
 105
 106                 [Test]
 107                 public void AddCommonComponent()
 108                 {
 109                         kernel.AddComponent("key", typeof(ICustomer), typeof(CustomerImpl));
 110                         Assert.IsTrue(kernel.HasComponent("key"));
 111                 }
 112
 113                 [Test]
 114                 public void HandlerForClassComponent()
 115                 {
 116                         kernel.AddComponent("key", typeof(CustomerImpl));
 117                         IHandler handler = kernel.GetHandler("key");
 118                         Assert.IsNotNull(handler);
 119                 }
 120
 121                 [Test]
 122                 public void HandlerForClassWithNoInterface()
 123                 {
 124                         kernel.AddComponent("key", typeof(DefaultCustomer));
 125                         IHandler handler = kernel.GetHandler("key");
 126                         Assert.IsNotNull(handler);
 127                 }
 128
 129                 [Test]
 130                 [ExpectedException(typeof(ComponentRegistrationException))]
 131                 public void KeyCollision()
 132                 {
 133                         kernel.AddComponent("key", typeof(CustomerImpl));
 134                         kernel.AddComponent("key", typeof(CustomerImpl));
 135                 }
 136
 137                 [Test]
 138                 [ExpectedException(typeof(ComponentNotFoundException))]
 139                 public void UnregisteredComponentByKey()
 140                 {
 141                         kernel.AddComponent("key1", typeof(CustomerImpl));
 142                         object component = kernel["key2"];
 143                 }
 144
 145                 [Test]
 146                 [ExpectedException(typeof(ComponentNotFoundException))]
 147                 public void UnregisteredComponentByService()
 148                 {
 149                         kernel.AddComponent("key1", typeof(CustomerImpl));
 150                         object component = kernel[typeof(IDisposable)];
 151                 }
 152
 153                 [Test]
 154                 public void AddClassThatHasTwoParametersOfSameTypeAndNoOverloads()
 155                 {
 156                         kernel.AddComponent("test", typeof(ClassWithTwoParametersWithSameType));
 157                         kernel.AddComponent("test2", typeof(ICommon), typeof(CommonImpl1));
 158                         object resolved = kernel.Resolve(typeof(ClassWithTwoParametersWithSameType), new Hashtable());
 159                         Assert.IsNotNull(resolved);
 160                 }
 161
 162                 [Test]
 163                 public void ResolveAll()
 164                 {
 165                         kernel.AddComponent("test", typeof(ICommon), typeof(CommonImpl2));
 166                         kernel.AddComponent("test2", typeof(ICommon), typeof(CommonImpl1));
 167                         ICommon[] services = kernel.ResolveAll<ICommon>();
 168                         Assert.AreEqual(2, services.Length);
 169                 }
 170
 171                 [Test]
 172                 public void ResolveAllWaitingOnDependencies()
 173                 {
 174                         kernel.AddComponent("test", typeof(ICommon), typeof(CommonImplWithDependancy));
 175                         ICommon[] services = kernel.ResolveAll<ICommon>();
 176                         Assert.AreEqual(0, services.Length);
 177                 }
 178         }
 179 }