InversionOfControl/Castle.Windsor.Tests/WindsorDotNet2Tests.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 #if !MONO
  16
  17 namespace Castle.Windsor.Tests
  18 {
  19         using System;
  20         using System.IO;
  21         using Castle.Core.Interceptor;
  22         using Castle.Windsor.Configuration.Interpreters;
  23         using Components;
  24         using Core;
  25         using NUnit.Framework;
  26
  27         [TestFixture]
  28         public class WindsorDotNet2Tests
  29         {
  30                 [Test]
  31                 public void UsingResolveGenericMethodOverload()
  32                 {
  33                         IWindsorContainer container = new WindsorContainer(new XmlInterpreter(GetFilePath("GenericsConfig.xml")));
  34                         ICalcService svr = container.Resolve<ICalcService>();
  35                         Assert.IsTrue(typeof (CalculatorService).IsInstanceOfType(svr));
  36                 }
  37
  38                 [Test]
  39                 public void ResolveGenericWithId()
  40                 {
  41                         IWindsorContainer container = new WindsorContainer(new XmlInterpreter(GetFilePath("GenericsConfig.xml")));
  42                         ICalcService svr = container.Resolve<ICalcService>("calc");
  43                         Assert.IsTrue(typeof (CalculatorService).IsInstanceOfType(svr));
  44                 }
  45
  46                 [Test]
  47                 public void GetGenericService()
  48                 {
  49                         IWindsorContainer container = new WindsorContainer(new XmlInterpreter(GetFilePath("GenericsConfig.xml")));
  50                         IRepository<int> repos = container.Resolve<IRepository<int>>("int.repos.generic");
  51                         Assert.IsNotNull(repos);
  52                         Assert.IsTrue(typeof (DemoRepository<int>).IsInstanceOfType(repos));
  53                 }
  54
  55                 [Test]
  56                 public void GetGenericServiceWithDecorator()
  57                 {
  58                         IWindsorContainer container = new WindsorContainer(new XmlInterpreter(GetFilePath("GenericsConfig.xml")));
  59                         IRepository<int> repos = container.Resolve<IRepository<int>>("int.repos");
  60                         Assert.IsNotNull(repos);
  61                         Assert.IsTrue(typeof (LoggingRepositoryDecorator<int>).IsInstanceOfType(repos));
  62                         Assert.IsTrue(typeof (DemoRepository<int>).IsInstanceOfType(((LoggingRepositoryDecorator<int>) repos).inner));
  63                 }
  64
  65                 [Test]
  66                 public void WillUseDefaultCtorOnGenericComponentIfTryingToResolveOnSameComponent()
  67                 {
  68                         IWindsorContainer container =
  69                                 new WindsorContainer(new XmlInterpreter(GetFilePath("RecursiveDecoratorConfig.xml")));
  70                         LoggingRepositoryDecorator<int> resolve =
  71                                 (LoggingRepositoryDecorator<int>) container.Resolve<IRepository<int>>();
  72                         Assert.IsNull(resolve.inner);
  73                 }
  74
  75                 [Test]
  76                 public void GetGenericServiceWithDecorator_GenericDecoratorOnTop()
  77                 {
  78                         IWindsorContainer container = new WindsorContainer(new XmlInterpreter(GetFilePath("DecoratorConfig.xml")));
  79                         IRepository<int> repos = container.Resolve<IRepository<int>>();
  80                         Assert.IsTrue(typeof (LoggingRepositoryDecorator<int>).IsInstanceOfType(repos));
  81
  82                         Assert.IsTrue(typeof (LoggingRepositoryDecorator<int>).IsInstanceOfType(repos));
  83                         Assert.IsTrue(typeof (DemoRepository<int>).IsInstanceOfType(((LoggingRepositoryDecorator<int>) repos).inner));
  84
  85                         DemoRepository<int> inner = ((LoggingRepositoryDecorator<int>) repos).inner as DemoRepository<int>;
  86
  87                         Assert.AreEqual("second", inner.Name);
  88                 }
  89
  90                 [Test]
  91                 public void InferGenericArgumentForComponentFromPassedType()
  92                 {
  93                         IWindsorContainer container =
  94                                 new WindsorContainer(new XmlInterpreter(GetFilePath("GenericDecoratorConfig.xml")));
  95
  96                         IRepository<string> repos = container.Resolve<IRepository<string>>();
  97                         Assert.IsTrue(typeof (LoggingRepositoryDecorator<string>).IsInstanceOfType(repos));
  98
  99                         DemoRepository<string> inner = ((LoggingRepositoryDecorator<string>) repos).inner as DemoRepository<string>;
 100
 101                         Assert.AreEqual("second", inner.Name);
 102                 }
 103
 104                 [Test]
 105                 public void GetSameInstanceFromGenericType()
 106                 {
 107                         IWindsorContainer container =
 108                                 new WindsorContainer(new XmlInterpreter(GetFilePath("GenericDecoratorConfig.xml")));
 109
 110                         IRepository<string> repos1 = container.Resolve<IRepository<string>>();
 111                         IRepository<string> repos2 = container.Resolve<IRepository<string>>();
 112
 113                         Assert.AreSame(repos1, repos2);
 114                 }
 115
 116                 [Test]
 117                 public void GetSameInstanceOfGenericFromTwoDifferentGenericTypes()
 118                 {
 119                         IWindsorContainer container =
 120                                 new WindsorContainer(new XmlInterpreter(GetFilePath("GenericDecoratorConfig.xml")));
 121
 122                         IRepository<string> repos1 = container.Resolve<IRepository<string>>();
 123                         IRepository<string> repos2 = container.Resolve<IRepository<string>>();
 124
 125                         Assert.AreSame(repos1, repos2);
 126
 127                         IRepository<int> repos3 = container.Resolve<IRepository<int>>();
 128                         IRepository<int> repos4 = container.Resolve<IRepository<int>>();
 129
 130                         Assert.AreSame(repos3, repos4);
 131                 }
 132
 133                 [Test]
 134                 public void ComplexGenericConfiguration_GetGenericRepostiory()
 135                 {
 136                         IWindsorContainer container =
 137                                 new WindsorContainer(new XmlInterpreter(GetFilePath("ComplexGenericConfig.xml")));
 138                         IRepository<IEmployee> empRepost = container[typeof (IRepository<IEmployee>)] as IRepository<IEmployee>;
 139                         Assert.IsNotNull(empRepost);
 140                         Assert.IsTrue(typeof (LoggingRepositoryDecorator<IEmployee>).IsInstanceOfType(empRepost));
 141                         LoggingRepositoryDecorator<IEmployee> log = empRepost as LoggingRepositoryDecorator<IEmployee>;
 142                         IRepository<IEmployee> inner = log.inner;
 143                         Assert.IsNotNull(inner);
 144                         Assert.IsTrue(typeof (DemoRepository<IEmployee>).IsInstanceOfType(inner));
 145                         DemoRepository<IEmployee> demoEmpRepost = inner as DemoRepository<IEmployee>;
 146                         Assert.AreEqual("Generic Repostiory", demoEmpRepost.Name);
 147                         Assert.IsNotNull(demoEmpRepost.Cache);
 148                         Assert.IsTrue(typeof (HashTableCache<IEmployee>).IsInstanceOfType(demoEmpRepost.Cache));
 149                 }
 150
 151                 [Test]
 152                 public void ComplexGenericConfiguration_GetReviewRepository_BoundAtConfiguration()
 153                 {
 154                         IWindsorContainer container =
 155                                 new WindsorContainer(new XmlInterpreter(GetFilePath("ComplexGenericConfig.xml")));
 156                         IRepository<IReviewer> rev = container.Resolve<IRepository<IReviewer>>();
 157
 158                         Assert.IsTrue(typeof (ReviewerRepository).IsInstanceOfType(rev));
 159                         ReviewerRepository repos = rev as ReviewerRepository;
 160                         Assert.AreEqual("Reviewer Repository", repos.Name);
 161                         Assert.IsNotNull(repos.Cache);
 162                         Assert.IsTrue(typeof (HashTableCache<IReviewer>).IsInstanceOfType(repos.Cache));
 163                 }
 164
 165                 [Test]
 166                 public void
 167                         ComplexGenericConfiguration_GetReviewableRepostiory_ShouldResolveToDemoRepostiroyInsideLoggingRepositoryWithNoCaching
 168                         ()
 169                 {
 170                         IWindsorContainer container =
 171                                 new WindsorContainer(new XmlInterpreter(GetFilePath("ComplexGenericConfig.xml")));
 172                         IRepository<IReviewableEmployee> empRepost = container.Resolve<IRepository<IReviewableEmployee>>();
 173                         Assert.IsNotNull(empRepost);
 174                         Assert.IsTrue(typeof (LoggingRepositoryDecorator<IReviewableEmployee>).IsInstanceOfType(empRepost));
 175                         LoggingRepositoryDecorator<IReviewableEmployee> log =
 176                                 empRepost as LoggingRepositoryDecorator<IReviewableEmployee>;
 177                         IRepository<IReviewableEmployee> inner = log.inner;
 178                         Assert.IsNotNull(inner);
 179                         Assert.IsTrue(typeof (DemoRepository<IReviewableEmployee>).IsInstanceOfType(inner));
 180                         DemoRepository<IReviewableEmployee> demoEmpRepost = inner as DemoRepository<IReviewableEmployee>;
 181                         Assert.AreEqual("Generic Repostiory With No Cache", demoEmpRepost.Name);
 182                         Assert.IsNotNull(demoEmpRepost.Cache);
 183                         Assert.IsTrue(typeof (NullCache<IReviewableEmployee>).IsInstanceOfType(demoEmpRepost.Cache));
 184                 }
 185
 186                 [Test]
 187                 public void TestGenericSpecialization()
 188                 {
 189                         IWindsorContainer container =
 190                                 new WindsorContainer(new XmlInterpreter(GetFilePath("ComplexGenericConfig.xml")));
 191                         IRepository<IReviewer> repository = container.Resolve<IRepository<IReviewer>>();
 192                         Assert.IsTrue(typeof (ReviewerRepository).IsInstanceOfType(repository), "Not ReviewerRepository!");
 193                 }
 194
 195                 [Test]
 196                 public void ComplexGenericConfiguration_GetRepositoryByIdAndType()
 197                 {
 198                         IWindsorContainer container =
 199                                 new WindsorContainer(new XmlInterpreter(GetFilePath("ComplexGenericConfig.xml")));
 200                         IRepository<IReviewer> repository = container.Resolve<IRepository<IReviewer>>("generic.repository");
 201                         Assert.IsTrue(typeof (DemoRepository<IReviewer>).IsInstanceOfType(repository), "Not DemoRepository!");
 202                 }
 203
 204                 [Test]
 205                 public void TestComponentLifestylePerGenericType()
 206                 {
 207                         IWindsorContainer container = new WindsorContainer();
 208
 209                         container.AddComponent("comp", typeof (IRepository<>), typeof (TransientRepository<>));
 210
 211                         object o1 = container.Resolve<IRepository<Employee>>();
 212                         object o2 = container.Resolve<IRepository<Employee>>();
 213                         object o3 = container.Resolve<IRepository<Reviewer>>();
 214                         object o4 = container.Resolve<IRepository<Reviewer>>();
 215
 216                         Assert.IsFalse(ReferenceEquals(o1, o2));
 217                         Assert.IsFalse(ReferenceEquals(o1, o3));
 218                         Assert.IsFalse(ReferenceEquals(o1, o4));
 219                 }
 220
 221                 [Test]
 222                 public void CanCreateANormalTypeWithCtorDependencyOnGenericType()
 223                 {
 224                         IWindsorContainer container = new WindsorContainer();
 225
 226                         container.AddComponent("comp", typeof (NeedsGenericType));
 227                         container.AddComponent("cache", typeof (ICache<>), typeof (NullCache<>));
 228
 229                         NeedsGenericType needsGenericType = container.Resolve<NeedsGenericType>();
 230
 231                         Assert.IsNotNull(needsGenericType);
 232                 }
 233
 234                 [Test]
 235                 public void InterceptGeneric1()
 236                 {
 237                         WindsorContainer container = new WindsorContainer();
 238
 239                         container.AddFacility("interceptor-facility", new MyInterceptorGreedyFacility());
 240                         container.AddComponent("interceptor", typeof (StandardInterceptor));
 241                         container.AddComponent("key", typeof (IRepository<Employee>), typeof (DemoRepository<Employee>));
 242
 243                         IRepository<Employee> store = container.Resolve<IRepository<Employee>>();
 244
 245                         Assert.IsFalse(typeof (DemoRepository<Employee>).IsInstanceOfType(store), "This should have been a proxy");
 246                 }
 247
 248                 [Test]
 249                 public void InterceptGeneric2()
 250                 {
 251                         WindsorContainer container = new WindsorContainer();
 252
 253                         container.AddFacility("interceptor-facility", new MyInterceptorGreedyFacility2());
 254                         container.AddComponent("interceptor", typeof (StandardInterceptor));
 255                         container.AddComponent("key", typeof (IRepository<>), typeof (DemoRepository<>));
 256
 257                         IRepository<Employee> store = container.Resolve<IRepository<Employee>>();
 258
 259                         Assert.IsFalse(typeof (DemoRepository<Employee>).IsInstanceOfType(store), "This should have been a proxy");
 260                 }
 261
 262                 [Test]
 263                 public void ChainOfResponsability()
 264                 {
 265                         IWindsorContainer container =
 266                                 new WindsorContainer(new XmlInterpreter(GetFilePath("chainOfRespnsability.config")));
 267                         IResultFinder<int> resolve = container.Resolve<IResultFinder<int>>();
 268                         Assert.IsTrue(resolve.Finder is DatabaseResultFinder<int>);
 269                         Assert.IsTrue(resolve.Finder.Finder is WebServiceResultFinder<int>);
 270                         Assert.IsTrue(resolve.Finder.Finder.Finder is FailedResultFinder<int>);
 271                         Assert.IsTrue(resolve.Finder.Finder.Finder.Finder == null);
 272                 }
 273
 274                 [Test]
 275                 public void ChainOfResponsability_Smart()
 276                 {
 277                         IWindsorContainer container =
 278                                 new WindsorContainer(new XmlInterpreter(GetFilePath("chainOfRespnsability_smart.config")));
 279                         IResultFinder<int> resolve = container.Resolve<IResultFinder<int>>();
 280                         Assert.IsTrue(resolve is CacheResultFinder<int>);
 281                         Assert.IsTrue(resolve.Finder is DatabaseResultFinder<int>);
 282                         Assert.IsTrue(resolve.Finder.Finder is WebServiceResultFinder<int>);
 283                         Assert.IsNull(resolve.Finder.Finder.Finder);
 284
 285                         IResultFinder<String> resolve2 = container.Resolve<IResultFinder<String>>();
 286                         Assert.IsTrue(resolve2 is ResultFinderStringDecorator);
 287                         Assert.IsNotNull(resolve2.Finder);
 288                 }
 289
 290                 [Test]
 291                 public void LifestyleIsInheritsFromGenericType()
 292                 {
 293                         WindsorContainer container = new WindsorContainer();
 294
 295                         container.AddFacility("interceptor-facility", new MyInterceptorGreedyFacility2());
 296                         container.AddComponent("interceptor", typeof (StandardInterceptor));
 297                         container.AddComponentWithLifestyle("key", typeof (IRepository<>), typeof (DemoRepository<>), LifestyleType.Transient);
 298
 299                         IRepository<Employee> store = container.Resolve<IRepository<Employee>>();
 300                         IRepository<Employee> anotherStore = container.Resolve<IRepository<Employee>>();
 301
 302                         Assert.IsFalse(typeof (DemoRepository<Employee>).IsInstanceOfType(store), "This should have been a proxy");
 303                         Assert.AreNotSame(store, anotherStore, "This should be two different instances");
 304                 }
 305
 306                 [Test]
 307                 public void InterceptorInheritFromGenericType()
 308                 {
 309                         WindsorContainer container = new WindsorContainer();
 310
 311                         container.AddComponent("interceptor", typeof (MyInterceptor));
 312                         container.AddComponent("key", typeof (IRepository<>), typeof (DemoRepository<>));
 313                         container.Kernel.GetHandler(typeof (IRepository<>)).ComponentModel.Interceptors.Add(
 314                                 new InterceptorReference(typeof (MyInterceptor)));
 315
 316                         IRepository<object> demoRepository = container.Resolve<IRepository<object>>();
 317                         demoRepository.Get(12);
 318
 319                         Assert.IsTrue(MyInterceptor.InterceptedId == 12, "invocation should have been intercepted by MyInterceptor");
 320                 }
 321
 322                 public string GetFilePath(string fileName)
 323                 {
 324                         return Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
 325                                                                 ConfigHelper.ResolveConfigPath("DotNet2Config/" + fileName));
 326                 }
 327         }
 328
 329         public class MyInterceptor : IInterceptor
 330         {
 331                 public static int InterceptedId = 0;
 332
 333                 public void Intercept(IInvocation invocation)
 334                 {
 335                         invocation.Proceed();
 336                         InterceptedId = (int) invocation.Arguments[0];
 337                 }
 338         }
 339
 340         public interface IResultFinder<T>
 341         {
 342                 T Process(ISpecification specification);
 343                 IResultFinder<T> Finder { get; }
 344         }
 345
 346         public class CacheResultFinder<T> : IResultFinder<T>
 347         {
 348                 private IResultFinder<T> finder;
 349
 350                 public IResultFinder<T> Finder
 351                 {
 352                         get { return finder; }
 353                 }
 354
 355                 public CacheResultFinder()
 356                 {
 357                 }
 358
 359                 public CacheResultFinder(IResultFinder<T> finder)
 360                 {
 361                         this.finder = finder;
 362                 }
 363
 364                 public T Process(ISpecification specification)
 365                 {
 366                         return default(T);
 367                 }
 368         }
 369
 370         public class DatabaseResultFinder<T> : IResultFinder<T>
 371         {
 372                 private IResultFinder<T> finder;
 373
 374                 public IResultFinder<T> Finder
 375                 {
 376                         get { return finder; }
 377                 }
 378
 379                 public DatabaseResultFinder()
 380                 {
 381                 }
 382
 383                 public DatabaseResultFinder(IResultFinder<T> finder)
 384                 {
 385                         this.finder = finder;
 386                 }
 387
 388                 public T Process(ISpecification specification)
 389                 {
 390                         return default(T);
 391                 }
 392         }
 393
 394         public class WebServiceResultFinder<T> : IResultFinder<T>
 395         {
 396                 private IResultFinder<T> finder;
 397
 398                 public IResultFinder<T> Finder
 399                 {
 400                         get { return finder; }
 401                 }
 402
 403                 public WebServiceResultFinder()
 404                 {
 405                 }
 406
 407                 public WebServiceResultFinder(IResultFinder<T> finder)
 408                 {
 409                         this.finder = finder;
 410                 }
 411
 412                 public T Process(ISpecification specification)
 413                 {
 414                         return default(T);
 415                 }
 416         }
 417
 418         public class FailedResultFinder<T> : IResultFinder<T>
 419         {
 420                 public IResultFinder<T> Finder
 421                 {
 422                         get { return null; }
 423                 }
 424
 425                 public T Process(ISpecification specification)
 426                 {
 427                         return default(T);
 428                 }
 429         }
 430
 431         public class ResultFinderStringDecorator : IResultFinder<string>
 432         {
 433                 private IResultFinder<string> finder;
 434
 435                 public ResultFinderStringDecorator(IResultFinder<string> finder)
 436                 {
 437                         this.finder = finder;
 438                 }
 439
 440                 public IResultFinder<string> Finder
 441                 {
 442                         get { return finder; }
 443                 }
 444
 445                 public String Process(ISpecification specification)
 446                 {
 447                         return String.Empty;
 448                 }
 449         }
 450
 451         public interface ISpecification
 452         {
 453         }
 454 }
 455
 456 #endif