Experiments/Castle.Igloo/Castle.Igloo.Test/ScopeTest/ComponentActivatorInspectorTests.cs

   1
   2 using System;
   3 using Castle.Core;
   4 using Castle.Core.Internal;
   5 using Castle.Igloo.Attributes;
   6 using Castle.Igloo.ComponentActivator;
   7 using Castle.Igloo.Inspectors;
   8 using Castle.Igloo.Interceptors;
   9 using Castle.Igloo.LifestyleManager;
  10 using Castle.Igloo.Test.ScopeTest.Components;
  11 using Castle.MicroKernel;
  12 using Castle.MicroKernel.ModelBuilder;
  13 using Castle.Windsor;
  14 using NUnit.Framework;
  15
  16 namespace Castle.Igloo.Test.ScopeTest
  17 {
  18     [TestFixture]
  19     public class ComponentActivatorTests
  20     {
  21         private IContributeComponentModelConstruction _inspector = null;
  22         private IKernel _kernel = null;
  23         private IWindsorContainer _container = null;
  24
  25         [SetUp]
  26         public void Setup()
  27         {
  28             _kernel = new DefaultKernel();
  29             _inspector = new IglooInspector();
  30             _container = new WindsorContainer();
  31             _container.AddFacility("Igloo.Facility", new IglooFacility());
  32         }
  33
  34         [Test]
  35         public void ProcessModel_NoScopeAttribute()
  36         {
  37             ComponentModel model = new ComponentModel("test", typeof(IComponent), typeof(SingletonScopeComponent));
  38             _inspector.ProcessModel(_kernel, model);
  39             Assert.IsNull(model.CustomComponentActivator);
  40         }
  41
  42         [Test]
  43         public void ProcessModel_ScopeAttributeWithProxy()
  44         {
  45             ComponentModel model = new ComponentModel("test", typeof(IComponent), typeof(SimpleComponent));
  46             _inspector.ProcessModel(_kernel, model);
  47
  48             Assert.IsNotNull(model.CustomComponentActivator);
  49             Assert.AreEqual(typeof(ScopeComponentActivator), model.CustomComponentActivator);
  50
  51             ScopeAttribute scopeAttribute = (ScopeAttribute)model.ExtendedProperties[ScopeInspector.SCOPE_ATTRIBUTE];
  52
  53             Assert.IsTrue(scopeAttribute.UseProxy);
  54             Assert.AreEqual(ScopeType.Singleton ,scopeAttribute.Scope);
  55         }
  56
  57         [Test]
  58         public void ProcessModel_ScopeAttributeWithoutProxy()
  59         {
  60             ComponentModel model = new ComponentModel("test", typeof(IComponent), typeof(TransientScopeComponent));
  61             _inspector.ProcessModel(_kernel, model);
  62
  63             Assert.IsNull(model.CustomComponentActivator);
  64
  65             ScopeAttribute scopeAttribute = (ScopeAttribute)model.ExtendedProperties[ScopeInspector.SCOPE_ATTRIBUTE];
  66
  67             Assert.IsFalse(scopeAttribute.UseProxy);
  68             Assert.AreEqual(ScopeType.Transient, scopeAttribute.Scope);
  69
  70             Assert.AreEqual(LifestyleType.Custom, model.LifestyleType);
  71             Assert.AreEqual(typeof(ScopeLifestyleManager), model.CustomLifestyle);
  72         }
  73
  74         [Test]
  75         public void ProcessModel_ScopeConfigWithProxy()
  76         {
  77             _container.AddComponent("Simple.Component", typeof(IComponent), typeof(SimpleComponent));
  78
  79             IVertex[] vertices = TopologicalSortAlgo.Sort(_container.Kernel.GraphNodes);
  80
  81                         for (int i = 0; i < vertices.Length; i++)
  82                         {
  83                             ComponentModel model = (ComponentModel)vertices[i];
  84                             if (model.Name == "Simple.Component")
  85                             {
  86                     Assert.IsNotNull(model.CustomComponentActivator);
  87                     Assert.AreEqual(typeof(ScopeComponentActivator), model.CustomComponentActivator);
  88
  89                     ScopeAttribute scopeAttribute = (ScopeAttribute)model.ExtendedProperties[ScopeInspector.SCOPE_ATTRIBUTE];
  90
  91                     Assert.IsTrue(scopeAttribute.UseProxy);
  92                     Assert.AreEqual(ScopeType.Singleton, scopeAttribute.Scope);
  93                             }
  94                         }
  95         }
  96
  97         [Test]
  98         public void ProcessModel_ScopeConfigWithoutProxy()
  99         {
 100             _container.AddComponent("Transient.Scope.Component", typeof(IComponent), typeof(TransientScopeComponent));
 101
 102             IVertex[] vertices = TopologicalSortAlgo.Sort(_container.Kernel.GraphNodes);
 103
 104             for (int i = 0; i < vertices.Length; i++)
 105             {
 106                 ComponentModel model = (ComponentModel)vertices[i];
 107                 if (model.Name == "Transient.Scope.Component")
 108                 {
 109                     Assert.IsNull(model.CustomComponentActivator);
 110
 111                     ScopeAttribute scopeAttribute = (ScopeAttribute)model.ExtendedProperties[ScopeInspector.SCOPE_ATTRIBUTE];
 112
 113                     Assert.IsFalse(scopeAttribute.UseProxy);
 114                     Assert.AreEqual(ScopeType.Transient, scopeAttribute.Scope);
 115
 116                     Assert.AreEqual(LifestyleType.Custom, model.LifestyleType);
 117                     Assert.AreEqual(typeof(ScopeLifestyleManager), model.CustomLifestyle);
 118                     Assert.AreEqual(0, model.Interceptors.Count);
 119
 120                     foreach (InterceptorReference interceptorRef in model.Interceptors)
 121                     {
 122                         Assert.AreEqual(interceptorRef.ReferenceType, InterceptorReferenceType.Interface);
 123                         Assert.AreEqual(interceptorRef.ServiceType, typeof(BijectionInterceptor));
 124                     }
 125                 }
 126             }
 127         }
 128
 129         [Test]
 130         public void ProcessModel_WithoutInjectProperties()
 131         {
 132             ComponentModel model = new ComponentModel("test", typeof(IComponent), typeof(TransientScopeComponent));
 133             _inspector.ProcessModel(_kernel, model);
 134
 135             Assert.AreEqual(0, model.Interceptors.Count);
 136         }
 137
 138         [Test]
 139         public void ProcessModel_WithInjectProperties()
 140         {
 141             ComponentModel model = new ComponentModel("test", typeof(IComponent), typeof(ScopeComponentWithInject));
 142             _inspector.ProcessModel(_kernel, model);
 143
 144             Assert.AreEqual(1, model.Interceptors.Count);
 145
 146             foreach (InterceptorReference interceptorRef in model.Interceptors)
 147             {
 148                 Assert.AreEqual(interceptorRef.ReferenceType, InterceptorReferenceType.Interface);
 149                 Assert.AreEqual(interceptorRef.ServiceType, typeof(BijectionInterceptor));
 150             }
 151         }
 152
 153         [Test]
 154         public void ProcessModel_WithOutjectProperties()
 155         {
 156             ComponentModel model = new ComponentModel("test", typeof(IComponent), typeof(TransientScopeComponent));
 157             _inspector.ProcessModel(_kernel, model);
 158
 159             Assert.AreEqual(0, model.Interceptors.Count);
 160         }
 161
 162         [Test]
 163         public void ProcessModel_WithoutOutjectProperties()
 164         {
 165             ComponentModel model = new ComponentModel("test", typeof(IComponent), typeof(ScopeComponentWithOutject));
 166             _inspector.ProcessModel(_kernel, model);
 167
 168             Assert.AreEqual(1, model.Interceptors.Count);
 169
 170             foreach (InterceptorReference interceptorRef in model.Interceptors)
 171             {
 172                 Assert.AreEqual(interceptorRef.ReferenceType, InterceptorReferenceType.Interface);
 173                 Assert.AreEqual(interceptorRef.ServiceType, typeof(BijectionInterceptor));
 174             }
 175         }
 176
 177         [Test]
 178         public void ProcessModel_WithInjectOutjectProperties()
 179         {
 180             ComponentModel model = new ComponentModel("test", typeof(IComponent), typeof(ScopeComponentWithInjectOutject));
 181             _inspector.ProcessModel(_kernel, model);
 182
 183             Assert.AreEqual(1, model.Interceptors.Count);
 184
 185             foreach (InterceptorReference interceptorRef in model.Interceptors)
 186             {
 187                 Assert.AreEqual(interceptorRef.ReferenceType, InterceptorReferenceType.Interface);
 188                 Assert.AreEqual(interceptorRef.ServiceType, typeof(BijectionInterceptor));
 189             }
 190         }
 191
 192         [Scope(Scope = ScopeType.Transient)]
 193         private class ScopeComponentWithInject : IComponent
 194         {
 195             [Inject(Name="Test")]
 196             public string Name
 197             {
 198               set
 199               {
 200                   throw new NotImplementedException("The method or operation is not implemented.");
 201               }
 202             }
 203             #region IComponent Members
 204
 205             public int ID
 206             {
 207                 get { throw new NotImplementedException("The method or operation is not implemented."); }
 208             }
 209
 210             #endregion
 211         }
 212
 213         [Scope(Scope = ScopeType.Transient)]
 214         private class ScopeComponentWithOutject : IComponent
 215         {
 216             [Outject(Name = "Test")]
 217             public string Name
 218             {
 219                 get
 220                 {
 221                     throw new NotImplementedException("The method or operation is not implemented.");
 222                 }
 223             }
 224             #region IComponent Members
 225
 226             public int ID
 227             {
 228                 get { throw new NotImplementedException("The method or operation is not implemented."); }
 229             }
 230
 231             #endregion
 232         }
 233
 234         [Scope(Scope = ScopeType.Transient)]
 235         private class ScopeComponentWithInjectOutject : IComponent
 236         {
 237             [Outject(Name = "Test")]
 238             [Inject(Name = "Test")]
 239             public string Name
 240             {
 241                 get
 242                 {
 243                     throw new NotImplementedException("The method or operation is not implemented.");
 244                 }
 245                 set
 246                 {
 247                     throw new NotImplementedException("The method or operation is not implemented.");
 248                 }
 249             }
 250             #region IComponent Members
 251
 252             public int ID
 253             {
 254                 get { throw new NotImplementedException("The method or operation is not implemented."); }
 255             }
 256
 257             #endregion
 258         }
 259     }
 260 }