InversionOfControl/Castle.MicroKernel.Tests/KeySearchNamingSubSystemTestCase.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.MicroKernel.Tests
  16 {
  17         using System;
  18         using System.Collections;
  19         using System.Threading;
  20         using Castle.MicroKernel.SubSystems.Naming;
  21         using Castle.MicroKernel.Tests.ClassComponents;
  22         using NUnit.Framework;
  23
  24         [TestFixture]
  25         public class KeySearchNamingSubSystemTestCase
  26         {
  27                 [Test]
  28                 public void EmptyDelegateReturnsFirstTypeLoaded()
  29                 {
  30                         IKernel kernel = new DefaultKernel();
  31                         kernel.AddSubSystem(SubSystemConstants.NamingKey, new KeySearchNamingSubSystem());
  32
  33                         kernel.AddComponent("1.common", typeof(ICommon), typeof(CommonImpl1));
  34                         kernel.AddComponent("2.common", typeof(ICommon), typeof(CommonImpl2));
  35
  36                         ICommon common = kernel[typeof(ICommon)] as ICommon;
  37
  38                         Assert.IsNotNull(common);
  39                         Assert.AreEqual(typeof(CommonImpl1), common.GetType());
  40                 }
  41
  42                 [Test]
  43                 public void ReturnsCorrectType()
  44                 {
  45                         IKernel kernel = new DefaultKernel();
  46                         kernel.AddSubSystem(SubSystemConstants.NamingKey,
  47                                             new KeySearchNamingSubSystem(
  48                                                 delegate(string key) { return key.StartsWith("castlestronghold.com"); }));
  49
  50                         kernel.AddComponent("castleproject.org.common", typeof(ICommon), typeof(CommonImpl1));
  51                         kernel.AddComponent("castlestronghold.com.common", typeof(ICommon), typeof(CommonImpl2));
  52
  53                         ICommon common = kernel[typeof(ICommon)] as ICommon;
  54
  55                         Assert.IsNotNull(common);
  56                         Assert.AreEqual(typeof(CommonImpl2), common.GetType());
  57                 }
  58
  59                 [Test]
  60                 public void ReturnsFirstTypeWhenNotFound()
  61                 {
  62                         IKernel kernel = new DefaultKernel();
  63                         kernel.AddSubSystem(SubSystemConstants.NamingKey,
  64                                             new KeySearchNamingSubSystem(delegate(string key) { return key.StartsWith("3"); }));
  65
  66                         kernel.AddComponent("1.common", typeof(ICommon), typeof(CommonImpl1));
  67                         kernel.AddComponent("2.common", typeof(ICommon), typeof(CommonImpl2));
  68
  69                         ICommon common = kernel[typeof(ICommon)] as ICommon;
  70
  71                         Assert.IsNotNull(common);
  72                         Assert.AreEqual(typeof(CommonImpl1), common.GetType());
  73                 }
  74
  75                 [Test]
  76                 public void ReturnsFirstMatchingType()
  77                 {
  78                         IKernel kernel = new DefaultKernel();
  79                         kernel.AddSubSystem(SubSystemConstants.NamingKey,
  80                                             new KeySearchNamingSubSystem(delegate(string key) { return key.StartsWith("1"); }));
  81
  82                         kernel.AddComponent("1.common", typeof(ICommon), typeof(CommonImpl1));
  83                         kernel.AddComponent("11.common", typeof(ICommon), typeof(CommonImpl2));
  84
  85                         ICommon common = kernel[typeof(ICommon)] as ICommon;
  86
  87                         Assert.IsNotNull(common);
  88                         Assert.AreEqual(typeof(CommonImpl1), common.GetType());
  89                 }
  90
  91                 [Test]
  92                 public void ComponentUnregistersProperly()
  93                 {
  94                         IKernel kernel = new DefaultKernel();
  95
  96                         kernel.AddSubSystem(SubSystemConstants.NamingKey,
  97                                             new KeySearchNamingSubSystem(delegate(string key) { return key.StartsWith("2"); }));
  98
  99                         kernel.AddComponent("1.common", typeof(ICommon), typeof(CommonImpl1));
 100                         kernel.AddComponent("2.common", typeof(ICommon), typeof(CommonImpl2));
 101
 102                         ICommon common = kernel[typeof(ICommon)] as ICommon;
 103
 104                         Assert.IsNotNull(common);
 105                         Assert.AreEqual(typeof(CommonImpl2), common.GetType());
 106
 107                         kernel.RemoveComponent("2.common");
 108
 109                         common = kernel[typeof(ICommon)] as ICommon;
 110
 111                         Assert.IsNotNull(common);
 112                         Assert.AreEqual(typeof(CommonImpl1), common.GetType());
 113
 114                         kernel.RemoveComponent("1.common");
 115                         Assert.AreEqual(0, kernel.GetHandlers(typeof(ICommon)).Length);
 116                 }
 117
 118                 [Test]
 119                 public void FirstLoadedComponentUnregistersProperly()
 120                 {
 121                         IKernel kernel = new DefaultKernel();
 122                         kernel.AddSubSystem(SubSystemConstants.NamingKey,
 123                                             new KeySearchNamingSubSystem(delegate(string key) { return key.StartsWith("1"); }));
 124
 125                         kernel.AddComponent("1.common", typeof(ICommon), typeof(CommonImpl1));
 126                         kernel.AddComponent("2.common", typeof(ICommon), typeof(CommonImpl2));
 127
 128                         ICommon common = kernel[typeof(ICommon)] as ICommon;
 129
 130                         Assert.IsNotNull(common);
 131                         Assert.AreEqual(typeof(CommonImpl1), common.GetType());
 132
 133                         kernel.RemoveComponent("1.common");
 134
 135                         common = kernel[typeof(ICommon)] as ICommon;
 136
 137                         Assert.IsNotNull(common);
 138                         Assert.AreEqual(typeof(CommonImpl2), common.GetType());
 139                 }
 140
 141                 [Test]
 142                 [ExpectedException(typeof(ComponentNotFoundException))]
 143                 public void SingleComponentUnregistersProperly()
 144                 {
 145                         IKernel kernel = new DefaultKernel();
 146                         kernel.AddSubSystem(SubSystemConstants.NamingKey,
 147                                             new KeySearchNamingSubSystem(delegate(string key) { return key.StartsWith("1"); }));
 148
 149                         kernel.AddComponent("1.common", typeof(ICommon), typeof(CommonImpl1));
 150
 151                         ICommon common = kernel[typeof(ICommon)] as ICommon;
 152
 153                         Assert.IsNotNull(common);
 154                         Assert.AreEqual(typeof(CommonImpl1), common.GetType());
 155
 156                         kernel.RemoveComponent("1.common");
 157
 158                         Assert.IsFalse(kernel.HasComponent("1.common"));
 159                         Assert.IsFalse(kernel.HasComponent(typeof(CommonImpl1)));
 160                         common = kernel[typeof(ICommon)] as ICommon;
 161                 }
 162
 163                 [Test]
 164                 public void MultiThreadedAddResolve()
 165                 {
 166                         int threadCount = 100;
 167                         ArrayList list = ArrayList.Synchronized(new ArrayList());
 168                         Random rand = new Random();
 169                         ManualResetEvent waitEvent = new ManualResetEvent(false);
 170
 171                         IKernel kernel = new DefaultKernel();
 172                         kernel.AddSubSystem(SubSystemConstants.NamingKey, new KeySearchNamingSubSystem());
 173                         kernel.AddComponent("common", typeof(ICommon), typeof(CommonImpl1));
 174
 175                         WaitCallback resolveThread = delegate
 176                                                         {
 177                                                                 waitEvent.WaitOne();
 178                                                                 while(threadCount > 0 && list.Count == 0)
 179                                                                 {
 180                                                                         try
 181                                                                         {
 182                                                                                 ICommon common = kernel[typeof(ICommon)] as ICommon;
 183                                                                         }
 184                                                                         catch(Exception e)
 185                                                                         {
 186                                                                                 list.Add(e.ToString());
 187                                                                         }
 188                                                                 }
 189                                                         };
 190                         ThreadPool.QueueUserWorkItem(resolveThread);
 191
 192                         WaitCallback addThread = delegate
 193                                                         {
 194                                                                 waitEvent.WaitOne();
 195                                                                 kernel.AddComponent(rand.Next() + ".common", typeof(ICommon), typeof(CommonImpl1));
 196                                                                 Interlocked.Decrement(ref threadCount);
 197                                                         };
 198                         for(int i = 0; i < threadCount; i++)
 199                         {
 200                                 ThreadPool.QueueUserWorkItem(addThread);
 201                         }
 202
 203                         waitEvent.Set();
 204                         while(threadCount > 0 && list.Count == 0)
 205                         {
 206                                 Thread.Sleep(15);
 207                         }
 208
 209                         if (list.Count > 0)
 210                         {
 211                                 Assert.Fail(list[0].ToString());
 212                         }
 213                 }
 214
 215                 /// <summary>
 216                 /// What I consider an edge case (only consistently reproducable with 1000+ threads):
 217                 ///   + Large number of components that implement the same service
 218                 ///   + Thread 1 Requests component by service
 219                 ///   + Thread n is simultaneously removing component
 220                 ///   + Predicate does not match any keys for the requested service OR
 221                 ///   + Matching component is removed before the Predicate can match it
 222                 /// </summary>
 223                 [Test]
 224                 [ExpectedException(typeof(ArgumentOutOfRangeException))]
 225                 [Ignore("This test needs to be reviewed")]
 226                 public void MultiThreaded_RemoveResolve_Throws_When_LargeRatio_Of_ComponentsToService()
 227                 {
 228                         int threadCount = 1000;
 229                         ArrayList list = ArrayList.Synchronized(new ArrayList());
 230                         Random rand = new Random();
 231                         ManualResetEvent waitEvent = new ManualResetEvent(false);
 232
 233                         IKernel kernel = new DefaultKernel();
 234                         kernel.AddSubSystem(SubSystemConstants.NamingKey, new KeySearchNamingSubSystem(delegate { return false; }));
 235
 236                         kernel.AddComponent("common", typeof(ICommon), typeof(CommonImpl1));
 237
 238                         WaitCallback resolveThread = delegate
 239                                                         {
 240                                                                 waitEvent.WaitOne();
 241                                                                 while(threadCount > 0 && list.Count == 0)
 242                                                                 {
 243                                                                         try
 244                                                                         {
 245                                                                                 ICommon common = kernel[typeof(ICommon)] as ICommon;
 246                                                                         }
 247                                                                         catch(Exception e)
 248                                                                         {
 249                                                                                 list.Add(e);
 250                                                                         }
 251                                                                 }
 252                                                         };
 253                         ThreadPool.QueueUserWorkItem(resolveThread);
 254
 255                         WaitCallback removeThread = delegate
 256                                                         {
 257                                                                 waitEvent.WaitOne();
 258                                                                 kernel.RemoveComponent(threadCount + ".common");
 259                                                                 Interlocked.Decrement(ref threadCount);
 260                                                         };
 261                         for(int i = 0; i < threadCount; i++)
 262                         {
 263                                 kernel.AddComponent(i + ".common", typeof(ICommon), typeof(CommonImpl1));
 264                                 ThreadPool.QueueUserWorkItem(removeThread);
 265                         }
 266
 267                         waitEvent.Set();
 268                         while(threadCount > 0 && list.Count == 0)
 269                         {
 270                                 Thread.Sleep(15);
 271                         }
 272
 273                         if (list.Count > 0)
 274                         {
 275                                 throw (Exception) list[0];
 276                         }
 277                 }
 278         }
 279 }