InversionOfControl/Castle.MicroKernel.Tests/Registration/AllTypesOfTestCase.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.Registration
  16 {
  17         using System;
  18         using System.Reflection;
  19         using Castle.Core;
  20         using Castle.MicroKernel.Registration;
  21         using Castle.MicroKernel.Tests.ClassComponents;
  22         using NUnit.Framework;
  23
  24 #if DOTNET35
  25         using System.Linq;
  26 #endif
  27
  28         [TestFixture]
  29         public class AllTypesOfTestCase
  30         {
  31                 private IKernel kernel;
  32
  33                 [SetUp]
  34                 public void Init()
  35                 {
  36                         kernel = new DefaultKernel();
  37                 }
  38
  39                 [Test]
  40                 public void RegisterAssemblyTypes_NoService_RegisteredInContainer()
  41                 {
  42                         kernel.Register(AllTypesOf<ICommon>
  43                                 .FromAssembly(Assembly.GetExecutingAssembly())
  44                                 );
  45
  46                         IHandler[] handlers = kernel.GetHandlers(typeof(ICommon));
  47                         Assert.AreEqual(0, handlers.Length);
  48
  49                         handlers = kernel.GetAssignableHandlers(typeof(ICommon));
  50                         Assert.AreNotEqual(0, handlers.Length);
  51                 }
  52
  53                 [Test]
  54                 public void RegisterAssemblyTypes_FirstInterfaceService_RegisteredInContainer()
  55                 {
  56                         kernel.Register(AllTypesOf<ICommon>
  57                                 .FromAssembly(Assembly.GetExecutingAssembly())
  58                                 .WithService.FirstInterface()
  59                                 );
  60
  61                         IHandler[] handlers = kernel.GetHandlers(typeof(ICommon));
  62                         Assert.AreNotEqual(0, handlers.Length);
  63
  64                         handlers = kernel.GetAssignableHandlers(typeof(ICommon));
  65                         Assert.AreNotEqual(0, handlers.Length);
  66                 }
  67
  68                 [Test]
  69                 public void RegisterAssemblyTypes_DefaultService_RegisteredInContainer()
  70                 {
  71                         kernel.Register(AllTypesOf<ICommon>
  72                                 .FromAssembly(Assembly.GetExecutingAssembly())
  73                                 .WithService.Base()
  74                                 );
  75
  76                         IHandler[] handlers = kernel.GetHandlers(typeof(ICommon));
  77                         Assert.AreNotEqual(0, handlers.Length);
  78
  79                         handlers = kernel.GetAssignableHandlers(typeof(ICommon));
  80                         Assert.AreNotEqual(0, handlers.Length);
  81                 }
  82
  83                 [Test]
  84                 public void RegisterAssemblyTypes_WithConfiguration_RegisteredInContainer()
  85                 {
  86                         kernel.Register(AllTypesOf<ICommon>
  87                                 .FromAssembly(Assembly.GetExecutingAssembly())
  88                                 .Configure(delegate(ComponentRegistration component)
  89                                         {
  90                                                 component.LifeStyle.Transient
  91                                                         .Named(component.Implementation.FullName + "XYZ");
  92                                         })
  93                                 );
  94
  95                         foreach (IHandler handler in kernel.GetAssignableHandlers(typeof(ICommon)))
  96                         {
  97                                 Assert.AreEqual(LifestyleType.Transient, handler.ComponentModel.LifestyleType);
  98                                 Assert.AreEqual(handler.ComponentModel.Implementation.FullName + "XYZ", handler.ComponentModel.Name);
  99                         }
 100                 }
 101
 102                 #if DOTNET35
 103
 104                 [Test]
 105                 public void RegisterAssemblyTypes_IfCondition_RegisteredInContainer()
 106                 {
 107                         kernel.Register(AllTypesOf<ICustomer>
 108                                 .FromAssembly(Assembly.GetExecutingAssembly())
 109                                 .If(t => t.FullName.Contains("Chain"))
 110                                 );
 111
 112                         IHandler[] handlers = kernel.GetAssignableHandlers(typeof(ICustomer));
 113                         Assert.AreNotEqual(0, handlers.Length);
 114
 115                         foreach (IHandler handler in handlers)
 116                         {
 117                                 Assert.IsTrue(handler.ComponentModel.Implementation.FullName.Contains("Chain"));
 118                         }
 119                 }
 120
 121                 [Test]
 122                 public void RegisterAssemblyTypes_UnlessCondition_RegisteredInContainer()
 123                 {
 124                         kernel.Register(AllTypesOf<ICustomer>
 125                                 .FromAssembly(Assembly.GetExecutingAssembly())
 126                                 .Unless(t => typeof(CustomerChain1).IsAssignableFrom(t))
 127                                 );
 128
 129                         foreach (IHandler handler in kernel.GetAssignableHandlers(typeof(ICustomer)))
 130                         {
 131                                 Assert.IsFalse(typeof(CustomerChain1).IsAssignableFrom(handler.ComponentModel.Implementation));
 132                         }
 133                 }
 134
 135                 [Test]
 136                 public void RegisterTypes_WithLinq_RegisteredInContainer()
 137                 {
 138                         kernel.Register(AllTypesOf<CustomerChain1>
 139                                 .Pick(from type in Assembly.GetExecutingAssembly().GetExportedTypes()
 140                                           where type.IsDefined(typeof(SerializableAttribute), true)
 141                                           select type
 142                                          ));
 143
 144                         IHandler[] handlers = kernel.GetAssignableHandlers(typeof(CustomerChain1));
 145                         Assert.AreEqual(2, handlers.Length);
 146                 }
 147
 148                 [Test]
 149                 public void RegisterAssemblyTypes_WithKLinqConfiguration_RegisteredInContainer()
 150                 {
 151                         kernel.Register( AllTypesOf<ICommon>
 152                                 .FromAssembly( Assembly.GetExecutingAssembly() )
 153                                 .Configure( component => component.LifeStyle.Transient
 154                                                         .Named( component.Implementation.FullName + "XYZ" )
 155                                                         )
 156                                 );
 157
 158                         foreach ( IHandler handler in kernel.GetAssignableHandlers( typeof( ICommon ) ) )
 159                         {
 160                                 Assert.AreEqual( LifestyleType.Transient, handler.ComponentModel.LifestyleType );
 161                                 Assert.AreEqual( handler.ComponentModel.Implementation.FullName + "XYZ", handler.ComponentModel.Name );
 162                         }
 163                 }
 164
 165                 #endif
 166         }
 167 }