Facilities/Wcf/Castle.Facilities.WcfIntegration.Tests/WcfClientFixture.cs

   1 // Copyright 2004-2008 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.Facilities.WcfIntegration.Tests
  16 {
  17         using System;
  18         using System.ServiceModel;
  19         using Castle.Core;
  20         using Castle.MicroKernel.Registration;
  21         using Castle.Windsor;
  22         using Castle.Facilities.WcfIntegration.Demo;
  23         using NUnit.Framework;
  24
  25         [TestFixture]
  26         public class WcfClientFixture
  27         {
  28                 #region Setup/Teardown
  29
  30                 [SetUp]
  31                 public void TestInitialize()
  32                 {
  33                         windsorContainer = new WindsorContainer()
  34                                 .AddFacility("wcf_facility", new WcfFacility(
  35                                         new WcfClientModel()
  36                                         {
  37                                                 Endpoint = WcfEndpoint.ForContract<IOperations>()
  38                                                         .BoundTo(new NetTcpBinding())
  39                                                         .At("net.tcp://localhost/Operations")
  40                                         }))
  41                                 .Register(
  42                                         Component.For<IOperations>().ImplementedBy<Operations>()
  43                                                 .CustomDependencies(new
  44                                                 {
  45                                                         number = 42,
  46                                                         serviceModel = new WcfServiceModel()
  47                                                                 .AddEndpoints(
  48                                                                         WcfEndpoint.BoundTo(new NetTcpBinding())
  49                                                                                 .At("net.tcp://localhost/Operations")
  50                                                                                 )
  51                                                 }),
  52                                         Component.For<IAmUsingWindsor>().ImplementedBy<UsingWindsor>()
  53                                                 .CustomDependencies(new
  54                                                 {
  55                                                         number = 42,
  56                                                         serviceModel = new WcfServiceModel()
  57                                                 })
  58                                 );
  59                 }
  60
  61                 [TearDown]
  62                 public void TestCleanup()
  63                 {
  64                         windsorContainer.Dispose();
  65                 }
  66
  67                 #endregion
  68
  69                 private IWindsorContainer windsorContainer;
  70
  71                 [Test]
  72                 public void CanResolveClientAssociatedWithChannel()
  73                 {
  74                         windsorContainer.Register(
  75                                 Component.For<IOperations>()
  76                                         .Named("operations")
  77                                         .CustomDependencies(new
  78                                                 {
  79                                                         clientModel = new WcfClientModel()
  80                                                         {
  81                                                                 Endpoint = WcfEndpoint
  82                                                                         .BoundTo(new NetTcpBinding())
  83                                                                         .At("net.tcp://localhost/Operations")
  84                                                         }
  85                                                 })
  86                                 );
  87
  88                         IOperations client = windsorContainer.Resolve<IOperations>("operations");
  89                         Assert.AreEqual(42, client.GetValueFromConstructor());
  90                 }
  91
  92                 [Test]
  93                 public void CanResolveClientAssociatedWithChannelFromConfiguration()
  94                 {
  95                         windsorContainer.Register(Component.For<IAmUsingWindsor>()
  96                                 .Named("usingWindsor")
  97                                 .CustomDependencies(new
  98                                 {
  99                                         clientModel = new WcfClientModel()
 100                                         {
 101                                                 Endpoint = WcfEndpoint
 102                                                         .FromConfiguration("WSHttpBinding_IAmUsingWindsor")
 103                                         }
 104                                 }));
 105
 106                         IAmUsingWindsor client = windsorContainer.Resolve<IAmUsingWindsor>("usingWindsor");
 107                         Assert.AreEqual(42, client.GetValueFromWindsorConfig());
 108                 }
 109
 110                 [Test]
 111                 public void CanResolveClientWhenListedInTheFacility()
 112                 {
 113                         windsorContainer.Register(Component.For<ClassNeedingService>());
 114                         ClassNeedingService component = windsorContainer.Resolve<ClassNeedingService>();
 115                         Assert.IsNotNull(component.Operations);
 116                         Assert.AreEqual(42, component.Operations.GetValueFromConstructor());
 117                 }
 118
 119                 [Test]
 120                 public void CanResolveClientAssociatedWithChannelWithContextOverride()
 121                 {
 122                         windsorContainer.Register(
 123                                 Component.For<IOperations>()
 124                                         .Named("operations")
 125                                         .CustomDependencies(new
 126                                         {
 127                                                 clientModel = new WcfClientModel()
 128                                                 {
 129                                                         Endpoint = WcfEndpoint
 130                                                                 .BoundTo(new BasicHttpBinding())
 131                                                                 .At("http://localhost/BadOperations")
 132                                                 }
 133                                         })
 134                                 );
 135
 136                         IOperations client = windsorContainer.Resolve<IOperations>(
 137                                 "operations", new
 138                                 {
 139                                         clientModel = new WcfClientModel()
 140                                         {
 141                                                 Endpoint = WcfEndpoint
 142                                                         .BoundTo(new NetTcpBinding())
 143                                                         .At("net.tcp://localhost/Operations")
 144                                         }
 145                                 });
 146
 147                         Assert.AreEqual(42, client.GetValueFromConstructor());
 148                 }
 149
 150                 [Test]
 151                 public void CanResolveClientAssociatedWithChannelUsingViaAddress()
 152                 {
 153                         using (IWindsorContainer localContainer = new WindsorContainer()
 154                                 .AddFacility("wcf_facility", new WcfFacility())
 155                                 .Register(
 156                                         Component.For<IOperations>().ImplementedBy<Operations>()
 157                                                 .CustomDependencies(new
 158                                                 {
 159                                                         number = 22,
 160                                                         serviceModel = new WcfServiceModel()
 161                                                                 .AddEndpoints(
 162                                                                         WcfEndpoint.BoundTo(new NetTcpBinding())
 163                                                                                 .At("urn:castle:operations")
 164                                                                                 .Via("net.tcp://localhost/OperationsVia")
 165                                                                                 )
 166                                                 }),
 167                                         Component.For<IOperations>()
 168                                                 .Named("operations")
 169                                                 .CustomDependencies(new
 170                                                 {
 171                                                         clientModel = new WcfClientModel()
 172                                                         {
 173                                                                 Endpoint = WcfEndpoint
 174                                                                         .BoundTo(new NetTcpBinding())
 175                                                                         .At("urn:castle:operations")
 176                                                                         .Via("net.tcp://localhost/OperationsVia")
 177                                                         }
 178                                                 })
 179                                         ))
 180                         {
 181                                 IOperations client = localContainer.Resolve<IOperations>("operations");
 182                                 Assert.AreEqual(22, client.GetValueFromConstructor());
 183                         }
 184                 }
 185         }
 186 }