InversionOfControl/Castle.MicroKernel.Tests/Facilities/Startable/StartableFacilityTestCase.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.Facilities.Startable.Tests
  16 {
  17         using System.Collections;
  18         using Castle.Core;
  19         using Castle.Core.Configuration;
  20         using Castle.Facilities.Startable.Tests.Components;
  21         using Castle.MicroKernel;
  22         using Castle.MicroKernel.Registration;
  23         using NUnit.Framework;
  24
  25         [TestFixture]
  26         public class StartableFacilityTestCase
  27         {
  28                 private bool startableCreatedBeforeResolved;
  29
  30                 [SetUp]
  31                 public void SetUp()
  32                 {
  33                         startableCreatedBeforeResolved = false;
  34                 }
  35
  36                 [Test]
  37                 public void TestInterfaceBasedStartable()
  38                 {
  39                         IKernel kernel = new DefaultKernel();
  40                         kernel.ComponentCreated += new ComponentInstanceDelegate(OnStartableComponentStarted);
  41
  42                         kernel.AddFacility("startable", new StartableFacility());
  43
  44                         kernel.AddComponent("a", typeof(StartableComponent));
  45
  46                         Assert.IsTrue(startableCreatedBeforeResolved, "Component was not properly started");
  47
  48                         StartableComponent component = kernel["a"] as StartableComponent;
  49
  50                         Assert.IsNotNull(component);
  51                         Assert.IsTrue(component.Started);
  52                         Assert.IsFalse(component.Stopped);
  53
  54                         kernel.ReleaseComponent(component);
  55                         Assert.IsTrue(component.Stopped);
  56                 }
  57
  58                 [Test]
  59                 public void TestComponentWithNoInterface()
  60                 {
  61                         IKernel kernel = new DefaultKernel();
  62                         kernel.ComponentCreated += new ComponentInstanceDelegate(OnNoInterfaceStartableComponentStarted);
  63
  64                         MutableConfiguration compNode = new MutableConfiguration("component");
  65                         compNode.Attributes["id"] = "b";
  66                         compNode.Attributes["startable"] = "true";
  67                         compNode.Attributes["startMethod"] = "Start";
  68                         compNode.Attributes["stopMethod"] = "Stop";
  69
  70                         kernel.ConfigurationStore.AddComponentConfiguration("b", compNode);
  71
  72                         kernel.AddFacility("startable", new StartableFacility());
  73                         kernel.AddComponent("b", typeof(NoInterfaceStartableComponent));
  74
  75                         Assert.IsTrue(startableCreatedBeforeResolved, "Component was not properly started");
  76
  77                         NoInterfaceStartableComponent component = kernel["b"] as NoInterfaceStartableComponent;
  78
  79                         Assert.IsNotNull(component);
  80                         Assert.IsTrue(component.Started);
  81                         Assert.IsFalse(component.Stopped);
  82
  83                         kernel.ReleaseComponent(component);
  84                         Assert.IsTrue(component.Stopped);
  85                 }
  86
  87                 [Test]
  88                 public void TestStartableWithRegisteredCustomDependencies()
  89                 {
  90                         IKernel kernel = new DefaultKernel();
  91                         kernel.ComponentCreated += new ComponentInstanceDelegate(OnStartableComponentStarted);
  92
  93                         kernel.AddFacility("startable", new StartableFacility());
  94
  95                         Hashtable dependencies = new Hashtable();
  96                         dependencies.Add("config", 1);
  97                         kernel.AddComponent("a", typeof(StartableComponentCustomDependencies));
  98                         kernel.RegisterCustomDependencies(typeof(StartableComponentCustomDependencies), dependencies);
  99
 100                         Assert.IsTrue(startableCreatedBeforeResolved, "Component was not properly started");
 101
 102                         StartableComponentCustomDependencies component = kernel["a"] as StartableComponentCustomDependencies;
 103
 104                         Assert.IsNotNull(component);
 105                         Assert.IsTrue(component.Started);
 106                         Assert.IsFalse(component.Stopped);
 107
 108                         kernel.ReleaseComponent(component);
 109                         Assert.IsTrue(component.Stopped);
 110                 }
 111
 112                 [Test]
 113                 public void TestStartableCustomDependencies()
 114                 {
 115                         IKernel kernel = new DefaultKernel();
 116                         kernel.ComponentCreated += new ComponentInstanceDelegate(OnStartableComponentStarted);
 117
 118                         kernel.AddFacility("startable", new StartableFacility());
 119
 120                         kernel.Register(
 121                                 Component.For<StartableComponentCustomDependencies>()
 122                                         .Named("a")
 123                                         .DependsOn(Property.ForKey("config").Eq(1))
 124                                 );
 125                         Assert.IsTrue(startableCreatedBeforeResolved, "Component was not properly started");
 126
 127                         StartableComponentCustomDependencies component = kernel["a"] as StartableComponentCustomDependencies;
 128
 129                         Assert.IsNotNull(component);
 130                         Assert.IsTrue(component.Started);
 131                         Assert.IsFalse(component.Stopped);
 132
 133                         kernel.ReleaseComponent(component);
 134                         Assert.IsTrue(component.Stopped);
 135                 }
 136
 137                 private void OnStartableComponentStarted(ComponentModel mode, object instance)
 138                 {
 139                         StartableComponent startable = instance as StartableComponent;
 140
 141                         Assert.IsNotNull(startable);
 142                         Assert.IsTrue(startable.Started);
 143                         Assert.IsFalse(startable.Stopped);
 144
 145                         startableCreatedBeforeResolved = true;
 146                 }
 147
 148                 private void OnNoInterfaceStartableComponentStarted(ComponentModel mode, object instance)
 149                 {
 150                         NoInterfaceStartableComponent startable = instance as NoInterfaceStartableComponent;
 151
 152                         Assert.IsNotNull(startable);
 153                         Assert.IsTrue(startable.Started);
 154                         Assert.IsFalse(startable.Stopped);
 155
 156                         startableCreatedBeforeResolved = true;
 157                 }
 158         }
 159 }