InversionOfControl/Castle.Windsor.Tests/Proxy/ProxyBehaviorTestCase.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.Windsor.Tests.Proxy
  16 {
  17         using System;
  18         using Castle.Core.Interceptor;
  19         using Castle.Windsor.Tests.Components;
  20         using NUnit.Framework;
  21
  22         [TestFixture]
  23         public class ProxyBehaviorTestCase
  24         {
  25                 [Test]
  26                 public void DefaultProxyBehaviorFromConfiguration()
  27                 {
  28                         IWindsorContainer container;
  29
  30                         container = new WindsorContainer(ConfigHelper.ResolveConfigPath("Proxy/proxyBehavior.xml"));
  31
  32                         ICalcService calcService = (ICalcService) container["default"];
  33                         Assert.IsNotNull(calcService);
  34                         Assert.IsTrue(calcService is IDisposable, "Service proxy should expose the IDisposable interface");
  35                 }
  36
  37                 [Test]
  38                 public void NoSingleInterfaceProxyBehaviorFromConfiguration()
  39                 {
  40                         IWindsorContainer container;
  41
  42                         container = new WindsorContainer(ConfigHelper.ResolveConfigPath("Proxy/proxyBehavior.xml"));
  43
  44                         ICalcService calcService = (ICalcService) container["noSingle"];
  45                         Assert.IsNotNull(calcService);
  46                         Assert.IsTrue(calcService is IDisposable, "Service proxy should expose the IDisposable interface");
  47                 }
  48
  49                 [Test]
  50                 public void UseSingleInterfaceProxyBehaviorFromConfiguration()
  51                 {
  52                         IWindsorContainer container;
  53
  54                         container = new WindsorContainer(ConfigHelper.ResolveConfigPath("Proxy/proxyBehavior.xml"));
  55
  56                         ICalcService calcService = (ICalcService) container["useSingle"];
  57                         Assert.IsNotNull(calcService);
  58                         Assert.IsFalse(calcService is IDisposable, "Service proxy should not expose the IDisposable interface");
  59                 }
  60
  61                 [Test]
  62                 public void UseSingleInterfaceProxyBehaviorFromAttribute()
  63                 {
  64                         IWindsorContainer container;
  65
  66                         container = new WindsorContainer(ConfigHelper.ResolveConfigPath("Proxy/proxyBehavior.xml"));
  67
  68                         ICalcService calcService = (ICalcService) container["useSingleAttribute"];
  69                         Assert.IsFalse(calcService is IDisposable, "Service proxy should not expose the IDisposable interface");
  70                 }
  71
  72                 [Test]
  73                 public void RequestSingleInterfaceProxyWithAttribute()
  74                 {
  75                         IWindsorContainer container = new WindsorContainer();
  76
  77                         container.AddComponent("standard.interceptor", typeof(StandardInterceptor));
  78                         container.AddComponent("useSingle", typeof(ICalcService), typeof(CalculatorServiceWithSingleProxyBehavior));
  79
  80                         ICalcService calcService = (ICalcService) container["useSingle"];
  81                         Assert.IsNotNull(calcService);
  82                         Assert.IsFalse(calcService is IDisposable, "Service proxy should not expose the IDisposable interface");
  83                 }
  84
  85                 [Test]
  86                 public void NoSingleInterfaceProxyWithAttribute()
  87                 {
  88                         IWindsorContainer container = new WindsorContainer();
  89
  90                         container.AddComponent("standard.interceptor", typeof(StandardInterceptor));
  91                         container.AddComponent("noSingle", typeof(ICalcService), typeof(CalculatorServiceWithoutSingleProxyBehavior));
  92
  93                         ICalcService calcService = (ICalcService) container["noSingle"];
  94                         Assert.IsNotNull(calcService);
  95                         Assert.IsTrue(calcService is IDisposable, "Service proxy should expose the IDisposable interface");
  96                 }
  97
  98                 [Test]
  99                 public void RequestMarshalByRefProxyWithAttribute()
 100                 {
 101                         IWindsorContainer container = new WindsorContainer();
 102
 103                         container.AddComponent("standard.interceptor", typeof(StandardInterceptor));
 104                         container.AddComponent("useMarshal", typeof(ICalcService), typeof(CalculatorServiceWithMarshalByRefProxyBehavior));
 105
 106                         ICalcService calcService = (ICalcService)container["useMarshal"];
 107                         Assert.IsNotNull(calcService);
 108                         Assert.IsFalse(calcService is CalculatorServiceWithMarshalByRefProxyBehavior, "Service proxy should not expose CalculatorServiceWithMarshalByRefProxyBehavior");
 109                         Assert.IsTrue(calcService is MarshalByRefObject, "Service proxy should expose MarshalByRefObject");
 110                         Assert.IsTrue(calcService is IDisposable, "Service proxy should expose the IDisposable interface");
 111                 }
 112         }
 113 }