Facilities/Wcf/Castle.Facilities.WcfIntegration.Tests/ServiceHostFixture.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.Collections.Generic;
  19         using System.ServiceModel;
  20         using Castle.MicroKernel.Registration;
  21         using Castle.Windsor;
  22         using Castle.Windsor.Installer;
  23         using Castle.Facilities.WcfIntegration.Demo;
  24         using NUnit.Framework;
  25         using Castle.Facilities.WcfIntegration.Tests.Behaviors;
  26
  27 #if DOTNET35
  28
  29         [TestFixture]
  30         public class ServiceHostFixture
  31         {
  32                 [Test]
  33                 public void CanCreateServiceHostAndOpenHost()
  34                 {
  35                         using (new WindsorContainer()
  36                                 .AddFacility<WcfFacility>()
  37                                 .Register(Component.For<IOperations>()
  38                                         .ImplementedBy<Operations>()
  39                                         .DependsOn(new { number = 42 } )
  40                                         .ActAs(new DefaultServiceModel().AddEndpoints(
  41                                                 WcfEndpoint.BoundTo(new NetTcpBinding())
  42                                                         .At("net.tcp://localhost/Operations"))
  43                                                 )
  44                                 ))
  45                         {
  46                                 IOperations client = ChannelFactory<IOperations>.CreateChannel(
  47                                         new NetTcpBinding(), new EndpointAddress("net.tcp://localhost/Operations"));
  48                                 Assert.AreEqual(42, client.GetValueFromConstructor());
  49                         }
  50                 }
  51
  52                 [Test]
  53                 public void CanCreateServiceHostAndOpenHostFromConfiguration()
  54                 {
  55                         using (new WindsorContainer()
  56                                 .AddFacility<WcfFacility>()
  57                                 .Register(Component.For<UsingWindsor>()
  58                                         .DependsOn(new { number = 42 } )
  59                                         .ActAs(new DefaultServiceModel())
  60                                 ))
  61                         {
  62                                 IAmUsingWindsor client = ChannelFactory<IAmUsingWindsor>.CreateChannel(
  63                                         new BasicHttpBinding(), new EndpointAddress("http://localhost:27198/UsingWindsor.svc"));
  64                                 Assert.AreEqual(42, client.GetValueFromWindsorConfig());
  65                         }
  66                 }
  67
  68                 [Test]
  69                 public void CanCreateServiceHostAndOpenHostWithMultipleEndpoints()
  70                 {
  71                         using (new WindsorContainer()
  72                                 .AddFacility<WcfFacility>()
  73                                 .Register(Component.For<Operations>()
  74                                         .DependsOn(new { number = 42 })
  75                                         .ActAs(new DefaultServiceModel().AddEndpoints(
  76                                                 WcfEndpoint.ForContract<IOperations>()
  77                                                         .BoundTo(new NetTcpBinding())
  78                                                         .At("net.tcp://localhost/Operations"),
  79                                                 WcfEndpoint.ForContract<IOperationsEx>()
  80                                                         .BoundTo(new BasicHttpBinding())
  81                                                         .At("http://localhost:27198/UsingWindsor.svc")
  82                                                 )
  83                                 )))
  84                         {
  85                                 IOperations client = ChannelFactory<IOperations>.CreateChannel(
  86                                         new NetTcpBinding(), new EndpointAddress("net.tcp://localhost/Operations"));
  87                                 Assert.AreEqual(42, client.GetValueFromConstructor());
  88
  89                                 IOperationsEx clientEx = ChannelFactory<IOperationsEx>.CreateChannel(
  90                                         new BasicHttpBinding(), new EndpointAddress("http://localhost:27198/UsingWindsor.svc"));
  91                                 clientEx.Backup(new Dictionary<string, object>());
  92                         }
  93                 }
  94
  95                 [Test]
  96                 public void CanCreateServiceHostAndOpenHostWithRelativeEndpoints()
  97                 {
  98                         using (new WindsorContainer()
  99                                 .AddFacility<WcfFacility>()
 100                                 .Register(Component.For<Operations>()
 101                                         .DependsOn(new { number = 42 })
 102                                         .ActAs(new DefaultServiceModel()
 103                                                 .AddBaseAddresses(
 104                                                         "net.tcp://localhost/Operations",
 105                                                         "http://localhost:27198/UsingWindsor.svc")
 106                                                 .AddEndpoints(
 107                                                         WcfEndpoint.ForContract<IOperations>()
 108                                                                 .BoundTo(new NetTcpBinding()),
 109                                                         WcfEndpoint.ForContract<IOperationsEx>()
 110                                                                 .BoundTo(new BasicHttpBinding())
 111                                                                 .At("Extended")
 112                                                         )
 113                                         )
 114                                 ))
 115                         {
 116                                 IOperations client = ChannelFactory<IOperations>.CreateChannel(
 117                                         new NetTcpBinding(), new EndpointAddress("net.tcp://localhost/Operations"));
 118                                 Assert.AreEqual(42, client.GetValueFromConstructor());
 119
 120                                 IOperationsEx clientEx = ChannelFactory<IOperationsEx>.CreateChannel(
 121                                         new BasicHttpBinding(), new EndpointAddress("http://localhost:27198/UsingWindsor.svc/Extended"));
 122                                 clientEx.Backup(new Dictionary<string, object>());
 123                         }
 124                 }
 125
 126                 [Test]
 127                 public void CanCreateServiceHostAndOpenHostWithListenAddress()
 128                 {
 129                         using (new WindsorContainer()
 130                                 .AddFacility<WcfFacility>()
 131                                 .Register(Component.For<IOperations>()
 132                                         .ImplementedBy<Operations>()
 133                                         .DependsOn(new { number = 42 })
 134                                         .ActAs(new DefaultServiceModel().AddEndpoints(
 135                                                 WcfEndpoint.BoundTo(new NetTcpBinding())
 136                                                         .At("urn:castle:operations")
 137                                                         .Via("net.tcp://localhost/Operations")
 138                                                         )
 139                                 )))
 140                         {
 141                                 IOperations client = ChannelFactory<IOperations>.CreateChannel(
 142                                         new NetTcpBinding(), new EndpointAddress("urn:castle:operations"),
 143                                         new Uri("net.tcp://localhost/Operations"));
 144                                 Assert.AreEqual(42, client.GetValueFromConstructor());
 145                         }
 146                 }
 147
 148                 [Test]
 149                 public void CanCreateServiceHostAndOpenHostFromXmlConfiguration()
 150                 {
 151                         using (new WindsorContainer()
 152                                         .Install(Configuration.FromXmlFile("..\\..\\ConfigureServices.xml")))
 153                         {
 154                                 IAmUsingWindsor client = ChannelFactory<IAmUsingWindsor>.CreateChannel(
 155                                         new BasicHttpBinding(), new EndpointAddress("http://localhost:27198/UsingWindsor.svc"));
 156                                 Assert.AreEqual(42, client.GetValueFromWindsorConfig());
 157                         }
 158                 }
 159
 160                 [Test]
 161                 public void CanCreateServiceHostAndOpenHostWithMultipleServiceModels()
 162                 {
 163                         using (new WindsorContainer()
 164                                 .AddFacility<WcfFacility>()
 165                                 .Register(Component.For<IOperations>()
 166                                         .ImplementedBy<Operations>()
 167                                         .DependsOn(new { number = 42 })
 168                                         .ActAs(
 169                                                 new DefaultServiceModel().AddEndpoints(
 170                                                         WcfEndpoint.BoundTo(new NetTcpBinding())
 171                                                                 .At("net.tcp://localhost/Operations")
 172                                                                 ),
 173                                                 new DefaultServiceModel()
 174                                                         .AddBaseAddresses(
 175                                                                 "http://localhost:27198/UsingWindsor.svc")
 176                                                         .AddEndpoints(
 177                                                                 WcfEndpoint.ForContract<IOperationsEx>()
 178                                                                         .BoundTo(new BasicHttpBinding())
 179                                                                         .At("Extended")
 180                                                                 )
 181                                                         )
 182                                 ))
 183                         {
 184                                 IOperations client = ChannelFactory<IOperations>.CreateChannel(
 185                                         new NetTcpBinding(), new EndpointAddress("net.tcp://localhost/Operations"));
 186                                 Assert.AreEqual(42, client.GetValueFromConstructor());
 187
 188                                 IOperationsEx clientEx = ChannelFactory<IOperationsEx>.CreateChannel(
 189                                         new BasicHttpBinding(), new EndpointAddress("http://localhost:27198/UsingWindsor.svc/Extended"));
 190                                 clientEx.Backup(new Dictionary<string, object>());
 191                         }
 192                 }
 193
 194                 [Test]
 195                 public void WillApplyServiceScopedBehaviors()
 196                 {
 197                         CallCountServiceBehavior.CallCount = 0;
 198                         Assert.IsFalse(UnitOfWork.initialized, "Should be false before starting");
 199
 200                         using (new WindsorContainer()
 201                                 .AddFacility<WcfFacility>()
 202                                 .Register(
 203                                         Component.For<CallCountServiceBehavior>()
 204                                                 .Configuration(Attrib.ForName("scope").Eq(WcfBehaviorScope.Clients)),
 205                                         Component.For<UnitOfworkEndPointBehavior>()
 206                                                 .Configuration(Attrib.ForName("scope").Eq(WcfBehaviorScope.Services)),
 207                                         Component.For<IOperations>().ImplementedBy<Operations>()
 208                                         .DependsOn(new { number = 42 })
 209                                         .ActAs(new DefaultServiceModel().AddEndpoints(
 210                                                 WcfEndpoint.BoundTo(new NetTcpBinding())
 211                                                         .At("net.tcp://localhost/Operations"))
 212                                                 )
 213                                 ))
 214                         {
 215                                 IOperations client = ChannelFactory<IOperations>.CreateChannel(
 216                                         new NetTcpBinding(), new EndpointAddress("net.tcp://localhost/Operations"));
 217                                 bool unitOfWorkIsInitialized_DuringCall = client.UnitOfWorkIsInitialized();
 218                                 Assert.IsTrue(unitOfWorkIsInitialized_DuringCall);
 219                                 Assert.IsFalse(UnitOfWork.initialized, "Should be false after call");
 220                                 Assert.AreEqual(0, CallCountServiceBehavior.CallCount);
 221                         }
 222                 }
 223
 224                 [Test]
 225                 public void WillApplyExplcitScopedKeyBehaviors()
 226                 {
 227                         CallCountServiceBehavior.CallCount = 0;
 228
 229                         using (new WindsorContainer()
 230                                 .AddFacility<WcfFacility>()
 231                                 .Register(
 232                                         Component.For<CallCountServiceBehavior>()
 233                                                 .Named("callcounts")
 234                                                 .Configuration(Attrib.ForName("scope").Eq(WcfBehaviorScope.Explicit)),
 235                                         Component.For<IOperations>().ImplementedBy<Operations>()
 236                                         .DependsOn(new { number = 42 })
 237                                         .ActAs(new DefaultServiceModel()
 238                                                 .AddEndpoints(
 239                                                         WcfEndpoint.BoundTo(new NetTcpBinding())
 240                                                                 .At("net.tcp://localhost/Operations"))
 241                                                 .AddBehaviors("callcounts")
 242                                                 )
 243                                 ))
 244                         {
 245                                 IOperations client = ChannelFactory<IOperations>.CreateChannel(
 246                                         new NetTcpBinding(), new EndpointAddress("net.tcp://localhost/Operations"));
 247                                 Assert.AreEqual(42, client.GetValueFromConstructor());
 248                                 Assert.AreEqual(1, CallCountServiceBehavior.CallCount);
 249                         }
 250                 }
 251
 252                 [Test]
 253                 public void WillApplyExplcitScopedServiceBehaviors()
 254                 {
 255                         CallCountServiceBehavior.CallCount = 0;
 256
 257                         using (new WindsorContainer()
 258                                 .AddFacility<WcfFacility>()
 259                                 .Register(
 260                                         Component.For<CallCountServiceBehavior>()
 261                                                 .Configuration(Attrib.ForName("scope").Eq(WcfBehaviorScope.Explicit)),
 262                                         Component.For<IOperations>().ImplementedBy<Operations>()
 263                                         .DependsOn(new { number = 42 })
 264                                         .ActAs(new DefaultServiceModel()
 265                                                 .AddEndpoints(
 266                                                         WcfEndpoint.BoundTo(new NetTcpBinding())
 267                                                                 .At("net.tcp://localhost/Operations"))
 268                                                 .AddBehaviors(typeof(CallCountServiceBehavior))
 269                                                 )
 270                                 ))
 271                         {
 272                                 IOperations client = ChannelFactory<IOperations>.CreateChannel(
 273                                         new NetTcpBinding(), new EndpointAddress("net.tcp://localhost/Operations"));
 274                                 Assert.AreEqual(42, client.GetValueFromConstructor());
 275                                 Assert.AreEqual(1, CallCountServiceBehavior.CallCount);
 276                         }
 277                 }
 278
 279                 [Test]
 280                 public void WillApplyInstanceBehaviors()
 281                 {
 282                         CallCountServiceBehavior.CallCount = 0;
 283
 284                         using (new WindsorContainer()
 285                                 .AddFacility<WcfFacility>()
 286                                 .Register(
 287                                         Component.For<IOperations>().ImplementedBy<Operations>()
 288                                         .DependsOn(new { number = 42 })
 289                                         .ActAs(new DefaultServiceModel()
 290                                                 .AddEndpoints(
 291                                                         WcfEndpoint.BoundTo(new NetTcpBinding())
 292                                                                 .At("net.tcp://localhost/Operations"))
 293                                                 .AddBehaviors(new CallCountServiceBehavior(),
 294                                                               new UnitOfworkEndPointBehavior())
 295                                                 )
 296                                 ))
 297                         {
 298                                 IOperations client = ChannelFactory<IOperations>.CreateChannel(
 299                                         new NetTcpBinding(), new EndpointAddress("net.tcp://localhost/Operations"));
 300                                 bool unitOfWorkIsInitialized_DuringCall = client.UnitOfWorkIsInitialized();
 301                                 Assert.IsTrue(unitOfWorkIsInitialized_DuringCall);
 302                                 Assert.IsFalse(UnitOfWork.initialized, "Should be false after call");
 303                                 Assert.AreEqual(1, CallCountServiceBehavior.CallCount);
 304                         }
 305                 }
 306         }
 307
 308 #endif // DOTNET35
 309 }