InversionOfControl/Castle.Windsor.Tests/Adapters/ComponentModel/ContainerAdapterTestCase.cs

   1 // Copyright 2004-2007 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.Windsor.Tests.Adapters.ComponentModel
  16 {
  17         using System;
  18         using System.ComponentModel;
  19         using System.ComponentModel.Design;
  20         using Castle.MicroKernel;
  21         using Castle.Windsor.Adapters.ComponentModel;
  22         using Castle.Windsor.Tests.Components;
  23         using NUnit.Framework;
  24
  25         [TestFixture]
  26         public class ContainerAdapterTestCase
  27         {
  28                 private bool disposed;
  29                 private int calledCount;
  30                 private IContainerAdapter container;
  31
  32                 [SetUp]
  33                 public void Init()
  34                 {
  35                         calledCount = 0;
  36                         disposed = false;
  37                         container = new ContainerAdapter();
  38                 }
  39
  40                 [TearDown]
  41                 public void Dispose()
  42                 {
  43                         container.Dispose();
  44                 }
  45
  46                 [Test]
  47                 public void GetIntrinsicServices()
  48                 {
  49                         Assert.IsNotNull(container.GetService(typeof(IContainer)));
  50                         Assert.IsNotNull(container.GetService(typeof(IServiceContainer)));
  51                         Assert.IsNotNull(container.GetService(typeof(IWindsorContainer)));
  52                         Assert.IsNotNull(container.GetService(typeof(IKernel)));
  53                 }
  54
  55                 [Test]
  56                 [ExpectedException(typeof(ArgumentException),
  57                         "A service for type 'Castle.Windsor.IWindsorContainer' already exists")]
  58                 public void AddIntrinsicService()
  59                 {
  60                         container.AddService(typeof(IWindsorContainer), new WindsorContainer());
  61                 }
  62
  63                 [Test]
  64                 [ExpectedException(typeof(ArgumentException), "Cannot remove an instrinsic service")]
  65                 public void RemoveInstrinsicService()
  66                 {
  67                         container.RemoveService(typeof(IWindsorContainer));
  68                 }
  69
  70                 [Test]
  71                 public void GetExistingServiceFromKernel()
  72                 {
  73                         WindsorContainer windsor = new WindsorContainer();
  74
  75                         windsor.AddComponent("calculator", typeof(ICalcService), typeof(CalculatorService));
  76
  77                         IContainerAdapter adapter = new ContainerAdapter(windsor);
  78
  79                         ICalcService service = (ICalcService) adapter.GetService(typeof(ICalcService));
  80
  81                         Assert.IsNotNull(service);
  82                 }
  83
  84                 [Test]
  85                 public void AddUnamedComponent()
  86                 {
  87                         IComponent component = new Component();
  88
  89                         container.Add(component);
  90                         ISite site = component.Site;
  91                         Assert.IsNotNull(site);
  92                         Assert.AreSame(container, site.Container);
  93                         Assert.AreEqual(1, container.Components.Count);
  94                         Assert.IsNotNull(site.GetService(typeof(IHandler)));
  95
  96                         IComponent component2 = container.Components[0];
  97                         Assert.AreSame(component, component2);
  98                         Assert.AreSame(container, component2.Site.Container);
  99                 }
 100
 101                 [Test]
 102                 public void AddNamedComponent()
 103                 {
 104                         IComponent component = new Component();
 105
 106                         container.Add(component, "myComponent");
 107                         ISite site = component.Site;
 108                         Assert.IsNotNull(site);
 109                         Assert.AreSame(container, site.Container);
 110                         Assert.AreEqual(1, container.Components.Count);
 111                         Assert.IsNotNull(container.Components["myComponent"]);
 112                         Assert.IsTrue(container.Container.Kernel.HasComponent("myComponent"));
 113                         Assert.IsNotNull(site.GetService(typeof(IHandler)));
 114
 115                         IComponent component2 = container.Components["myComponent"];
 116                         Assert.AreSame(component2, component);
 117                         Assert.AreSame(component2, container.Container["myComponent"]);
 118                         Assert.AreSame(container, component2.Site.Container);
 119                 }
 120
 121                 [Test]
 122                 [ExpectedException(typeof(ArgumentException),
 123                         "There is a component already registered for the given key myComponent")]
 124                 public void AddDuplicateComponent()
 125                 {
 126                         container.Add(new Component(), "myComponent");
 127                         container.Add(new Component(), "myComponent");
 128                 }
 129
 130                 [Test]
 131                 public void RemoveUnnamedComponent()
 132                 {
 133                         IComponent component = new Component();
 134
 135                         container.Add(component);
 136                         IContainerAdapterSite site = component.Site as IContainerAdapterSite;
 137                         Assert.IsNotNull(site);
 138
 139                         container.Remove(component);
 140                         Assert.IsNull(component.Site);
 141                         Assert.AreEqual(0, container.Components.Count);
 142                         Assert.IsFalse(container.Container.Kernel.HasComponent(site.EffectiveName));
 143                 }
 144
 145                 [Test]
 146                 public void RemoveNamedComponent()
 147                 {
 148                         IComponent component = new Component();
 149
 150                         container.Add(component, "myComponent");
 151                         ISite site = component.Site as ISite;
 152                         Assert.IsNotNull(site);
 153
 154                         container.Remove(component);
 155                         Assert.IsNull(component.Site);
 156                         Assert.AreEqual(0, container.Components.Count);
 157                         Assert.IsFalse(container.Container.Kernel.HasComponent("myComponent"));
 158                 }
 159
 160                 [Test]
 161                 public void RemoveComponentFromWindsor()
 162                 {
 163                         IComponent component = new Component();
 164
 165                         container.Add(component, "myComponent");
 166                         IContainerAdapterSite site = component.Site as IContainerAdapterSite;
 167
 168                         container.Container.Kernel.RemoveComponent(site.EffectiveName);
 169                         Assert.AreEqual(0, container.Components.Count);
 170                 }
 171
 172                 [Test]
 173                 public void GetComponentHandlers()
 174                 {
 175                         IComponent component = new Component();
 176
 177                         container.Add(component);
 178
 179                         IHandler[] handlers = container.Container.Kernel.GetHandlers(typeof(IComponent));
 180                         Assert.AreEqual(1, handlers.Length);
 181                         Assert.AreEqual(handlers[0].Resolve(CreationContext.Empty), component);
 182                 }
 183
 184                 [Test]
 185                 public void AddServiceInstance()
 186                 {
 187                         ICalcService service = new CalculatorService();
 188
 189                         container.AddService(typeof(ICalcService), service);
 190
 191                         Assert.AreSame(container.GetService(typeof(ICalcService)), service);
 192                         Assert.AreSame(container.Container[typeof(ICalcService)], service);
 193                 }
 194
 195                 [Test]
 196                 public void AddPromotedServiceInstance()
 197                 {
 198                         ContainerAdapter child = new ContainerAdapter();
 199                         container.Add(child);
 200
 201                         ICalcService service = new CalculatorService();
 202
 203                         child.AddService(typeof(ICalcService), service, true);
 204
 205                         Assert.AreSame(child.GetService(typeof(ICalcService)), service);
 206                         Assert.AreSame(container.GetService(typeof(ICalcService)), service);
 207
 208                         container.Remove(child);
 209                         Assert.IsNull(child.GetService(typeof(ICalcService)));
 210                         Assert.AreSame(container.GetService(typeof(ICalcService)), service);
 211                 }
 212
 213                 [Test]
 214                 [ExpectedException(typeof(ArgumentException),
 215                         "A service for type 'Castle.Windsor.Tests.Components.ICalcService' already exists")]
 216                 public void AddExistingServiceInstance()
 217                 {
 218                         container.AddService(typeof(ICalcService), new CalculatorService());
 219                         container.AddService(typeof(ICalcService), new CalculatorService());
 220                 }
 221
 222                 [Test]
 223                 public void AddServiceCreatorCallback()
 224                 {
 225                         ServiceCreatorCallback callback = new ServiceCreatorCallback(CreateCalculatorService);
 226
 227                         container.AddService(typeof(ICalcService), callback);
 228
 229                         ICalcService service = (ICalcService) container.GetService(typeof(ICalcService));
 230
 231                         Assert.IsNotNull(service);
 232                         Assert.AreSame(service, container.Container[typeof(ICalcService)]);
 233
 234                         service = (ICalcService) container.GetService(typeof(ICalcService));
 235                         Assert.AreEqual(1, calledCount);
 236                 }
 237
 238                 [Test]
 239                 public void AddPromotedServiceCreatorCallback()
 240                 {
 241                         ContainerAdapter child = new ContainerAdapter();
 242                         container.Add(child);
 243
 244                         ServiceCreatorCallback callback = new ServiceCreatorCallback(CreateCalculatorService);
 245
 246                         child.AddService(typeof(ICalcService), callback, true);
 247
 248                         ICalcService service = (ICalcService) child.GetService(typeof(ICalcService));
 249                         Assert.IsNotNull(service);
 250
 251                         ICalcService promotedService = (ICalcService) container.GetService(typeof(ICalcService));
 252                         Assert.IsNotNull(service);
 253
 254                         Assert.AreSame(service, promotedService);
 255
 256                         container.Remove(child);
 257                         Assert.IsNull(child.GetService(typeof(ICalcService)));
 258                         Assert.AreSame(container.GetService(typeof(ICalcService)), service);
 259                 }
 260
 261                 [Test]
 262                 public void RemoveServiceInstance()
 263                 {
 264                         ICalcService service = new CalculatorService();
 265
 266                         container.AddService(typeof(ICalcService), service);
 267                         container.RemoveService(typeof(ICalcService));
 268                         Assert.IsNull(container.GetService(typeof(ICalcService)));
 269                         Assert.IsFalse(container.Container.Kernel.HasComponent(typeof(ICalcService)));
 270                 }
 271
 272                 [Test]
 273                 public void RemovePromotedServiceInstance()
 274                 {
 275                         ContainerAdapter child = new ContainerAdapter();
 276                         container.Add(child);
 277
 278                         ICalcService service = new CalculatorService();
 279
 280                         child.AddService(typeof(ICalcService), service, true);
 281                         Assert.IsNotNull(child.GetService(typeof(ICalcService)));
 282
 283                         child.RemoveService(typeof(ICalcService), true);
 284                         Assert.IsNull(child.GetService(typeof(ICalcService)));
 285                         Assert.IsNull(container.GetService(typeof(ICalcService)));
 286                 }
 287
 288                 public void ChainContainers()
 289                 {
 290                         ICalcService service = new CalculatorService();
 291                         container.AddService(typeof(ICalcService), service);
 292
 293                         IContainerAdapter adapter = new ContainerAdapter(container);
 294
 295                         Assert.AreSame(service, container.GetService(typeof(ICalcService)));
 296                 }
 297
 298                 [Test]
 299                 public void ComponentLifecyle()
 300                 {
 301                         TestComponent component = new TestComponent();
 302                         Assert.IsFalse(component.IsSited);
 303                         Assert.IsFalse(component.IsDisposed);
 304
 305                         container.Add(component);
 306                         Assert.IsTrue(component.IsSited);
 307
 308                         container.Dispose();
 309                         Assert.IsTrue(component.IsDisposed);
 310                 }
 311
 312                 [Test]
 313                 public void ContainerLifecyle()
 314                 {
 315                         container.Disposed += new EventHandler(Container_Disposed);
 316                         Assert.IsFalse(disposed);
 317
 318                         container.Dispose();
 319                         Assert.IsTrue(disposed);
 320                 }
 321
 322                 [Test]
 323                 public void DisposeWindsorContainer()
 324                 {
 325                         container.Disposed += new EventHandler(Container_Disposed);
 326                         Assert.IsFalse(disposed);
 327
 328                         container.Container.Dispose();
 329                         Assert.IsTrue(disposed);
 330                 }
 331
 332                 private object CreateCalculatorService(IServiceContainer container, Type serviceType)
 333                 {
 334                         ++calledCount;
 335                         return new CalculatorService();
 336                 }
 337
 338                 private void Container_Disposed(object source, EventArgs args)
 339                 {
 340                         disposed = true;
 341                 }
 342         }
 343 }