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