Updated to Windsor 2.5 Beta 2 and fixed deprecated warnings.

lanwin · Aug 7, 2010 · b33ba20 · b33ba20
1 parent 2322754
commit b33ba20
Show file tree

Hide file tree

Showing 31 changed files with 547 additions and 520 deletions.
diff --git a/Rhino.ServiceBus.Tests/Bugs/Occasional_consumer_resolving_when_not_subscribed.cs b/Rhino.ServiceBus.Tests/Bugs/Occasional_consumer_resolving_when_not_subscribed.cs
@@ -1,57 +1,58 @@
 using System;
 using System.Threading;
+using Castle.MicroKernel.Registration;
 using Castle.Windsor;
 using Castle.Windsor.Configuration.Interpreters;
 using Rhino.ServiceBus.Impl;
 using Xunit;
 
 namespace Rhino.ServiceBus.Tests.Bugs
 {
-	public class Occasional_consumer_resolving_when_not_subscribed : OccasionalConsumerOf<SimpleMessage>
-	{
-		private readonly IWindsorContainer container;
-    	public static ManualResetEvent wait;
-		public static bool GotConsumed;
+    public class Occasional_consumer_resolving_when_not_subscribed : OccasionalConsumerOf<SimpleMessage>
+    {
+        private readonly IWindsorContainer container;
+        public static ManualResetEvent wait;
+        public static bool GotConsumed;
 
-		public Occasional_consumer_resolving_when_not_subscribed()
+        public Occasional_consumer_resolving_when_not_subscribed()
         {
             container = new WindsorContainer(new XmlInterpreter());
             container.Kernel.AddFacility("rhino.esb", new RhinoServiceBusFacility());
-			container.AddComponent<Occasional_consumer_resolving_when_not_subscribed>();
-			container.AddComponent<Not_consumed>();
+            container.Register(Component.For<Occasional_consumer_resolving_when_not_subscribed>());
+            container.Register(Component.For<Not_consumed>());
         }
 
-		[Fact]
-		public void Would_not_gather_occasional_consumer_if_not_instance_subscribed()
-		{
-			using (var bus = container.Resolve<IStartableServiceBus>())
-			{
-				wait = new ManualResetEvent(false);
-				bus.Start();
-				using (bus.AddInstanceSubscription(this))
-				{
-					bus.Send(new SimpleMessage());
-					wait.WaitOne(TimeSpan.FromSeconds(5), false);
-				}
-			}
-			Assert.False(GotConsumed);
-		}
-
-		public void Consume(SimpleMessage message)
-		{
-		}
-	}
-
-	public class SimpleMessage { }
-
-	public class Not_consumed : OccasionalConsumerOf<SimpleMessage>
-	{
-		public void Consume(SimpleMessage message)
-		{
-			Occasional_consumer_resolving_when_not_subscribed.GotConsumed = true;
-			Occasional_consumer_resolving_when_not_subscribed.wait.Set();
-		}
-	}
-
-	
+        [Fact]
+        public void Would_not_gather_occasional_consumer_if_not_instance_subscribed()
+        {
+            using (var bus = container.Resolve<IStartableServiceBus>())
+            {
+                wait = new ManualResetEvent(false);
+                bus.Start();
+                using (bus.AddInstanceSubscription(this))
+                {
+                    bus.Send(new SimpleMessage());
+                    wait.WaitOne(TimeSpan.FromSeconds(5), false);
+                }
+            }
+            Assert.False(GotConsumed);
+        }
+
+        public void Consume(SimpleMessage message)
+        {
+        }
+    }
+
+    public class SimpleMessage { }
+
+    public class Not_consumed : OccasionalConsumerOf<SimpleMessage>
+    {
+        public void Consume(SimpleMessage message)
+        {
+            Occasional_consumer_resolving_when_not_subscribed.GotConsumed = true;
+            Occasional_consumer_resolving_when_not_subscribed.wait.Set();
+        }
+    }
+
+
 }
diff --git a/Rhino.ServiceBus.Tests/Bugs/Resolving_consumer_from_container.cs b/Rhino.ServiceBus.Tests/Bugs/Resolving_consumer_from_container.cs
@@ -1,3 +1,4 @@
+using Castle.MicroKernel.Registration;
 using Castle.Windsor;
 using Castle.Windsor.Configuration.Interpreters;
 using Rhino.ServiceBus.Impl;
@@ -14,7 +15,7 @@ public Resolving_consumer_from_container()
             container = new WindsorContainer(new XmlInterpreter());
             container.Kernel.AddFacility("rhino.esb", new RhinoServiceBusFacility());
 
-            container.AddComponent<SendByMessageOwner.TestHandler>();
+            container.Register(Component.For<SendByMessageOwner.TestHandler>());
         }
 
         [Fact]

diff --git a/Rhino.ServiceBus.Tests/Bugs/Serialization_roundtrip.cs b/Rhino.ServiceBus.Tests/Bugs/Serialization_roundtrip.cs
@@ -10,6 +10,7 @@
 
 namespace Rhino.ServiceBus.Tests.Bugs
 {
+    [CLSCompliant(false)]
     public class Serialization_roundtrip
     {
         public class Foo

diff --git a/Rhino.ServiceBus.Tests/Bugs/WhenTransactionCommitErrors_ShouldNotCrash.cs b/Rhino.ServiceBus.Tests/Bugs/WhenTransactionCommitErrors_ShouldNotCrash.cs
@@ -1,79 +1,80 @@
 using System;
 using System.Messaging;
 using System.Transactions;
+using Castle.MicroKernel.Registration;
 using Castle.Windsor;
 using Castle.Windsor.Configuration.Interpreters;
 using Rhino.ServiceBus.Impl;
 using Xunit;
 
 namespace Rhino.ServiceBus.Tests.Bugs
 {
-	public class WhenTransactionCommitErrors_ShouldNotCrash_Msmq : MsmqTestBase
-	{
-		public class BadEnlistment : IEnlistmentNotification
-		{
-			public BadEnlistment()
-			{
-				Transaction.Current.EnlistVolatile(this, EnlistmentOptions.None);
-			}
+    public class WhenTransactionCommitErrors_ShouldNotCrash_Msmq : MsmqTestBase
+    {
+        public class BadEnlistment : IEnlistmentNotification
+        {
+            public BadEnlistment()
+            {
+                Transaction.Current.EnlistVolatile(this, EnlistmentOptions.None);
+            }
 
-			public void Prepare(PreparingEnlistment preparingEnlistment)
-			{
-				preparingEnlistment.ForceRollback(new InvalidOperationException("blah"));
-			}
+            public void Prepare(PreparingEnlistment preparingEnlistment)
+            {
+                preparingEnlistment.ForceRollback(new InvalidOperationException("blah"));
+            }
 
-			public void Commit(Enlistment enlistment)
-			{
-				enlistment.Done();
-			}
+            public void Commit(Enlistment enlistment)
+            {
+                enlistment.Done();
+            }
 
-			public void Rollback(Enlistment enlistment)
-			{
-				enlistment.Done();
-			}
+            public void Rollback(Enlistment enlistment)
+            {
+                enlistment.Done();
+            }
 
-			public void InDoubt(Enlistment enlistment)
-			{
-				enlistment.Done();
-			}
-		}
+            public void InDoubt(Enlistment enlistment)
+            {
+                enlistment.Done();
+            }
+        }
 
-		public class MsgToCreateBadTxEnlistment{}
+        public class MsgToCreateBadTxEnlistment { }
 
-		public class ConsumerEnlistingInBadTransaction : ConsumerOf<MsgToCreateBadTxEnlistment>
-		{
-			public void Consume(MsgToCreateBadTxEnlistment message)
-			{
-				new BadEnlistment();
-			}
-		}
+        public class ConsumerEnlistingInBadTransaction : ConsumerOf<MsgToCreateBadTxEnlistment>
+        {
+            public void Consume(MsgToCreateBadTxEnlistment message)
+            {
+                new BadEnlistment();
+            }
+        }
 
-		private static IWindsorContainer CreateContainer()
-		{
-			var container = new WindsorContainer(new XmlInterpreter());
-			container.Kernel.AddFacility("rhino.esb", new RhinoServiceBusFacility());
-			container.Kernel.AddComponent<ConsumerEnlistingInBadTransaction>();
-			return container;
-		}
+        private static IWindsorContainer CreateContainer()
+        {
+            var container = new WindsorContainer(new XmlInterpreter());
+            container.Kernel.AddFacility("rhino.esb", new RhinoServiceBusFacility());
+            container.Register(Component.For<ConsumerEnlistingInBadTransaction>());
+            return container;
+        }
 
-		[Fact]
-		public void Can_survive_errors_during_commit_phase()
-		{
-			using(var container = CreateContainer())
-			using(var bus = container.Resolve<IStartableServiceBus>())
-			{
-				bus.Start();
+        [Fact]
+        public void Can_survive_errors_during_commit_phase()
+        {
+            using (var container = CreateContainer())
+            using (var bus = container.Resolve<IStartableServiceBus>())
+            {
+                bus.Start();
 
-				bus.Send(bus.Endpoint, new MsgToCreateBadTxEnlistment());
+                bus.Send(bus.Endpoint, new MsgToCreateBadTxEnlistment());
 
-				using (var errQueue = new MessageQueue(testQueuePath + ";errors"))
-				{
-					var message = errQueue.Receive();
-					Assert.Equal("Rhino.ServiceBus.Tests.Bugs.WhenTransactionCommitErrors_ShouldNotCrash_Msmq+MsgToCreateBadTxEnlistment", message.Label);
-					var err = errQueue.Receive();
-					Assert.Equal("Error description for: Rhino.ServiceBus.Tests.Bugs.WhenTransactionCommitErrors_ShouldNotCrash_Msmq+MsgToCreateBadTxEnlistment", err.Label);
-				}
-			}
-		}
-	}
+                using (var errQueue = new MessageQueue(testQueuePath + ";errors"))
+                {
+                    var message = errQueue.Receive();
+                    Assert.Equal("Rhino.ServiceBus.Tests.Bugs.WhenTransactionCommitErrors_ShouldNotCrash_Msmq+MsgToCreateBadTxEnlistment", message.Label);
+                    var err = errQueue.Receive();
+                    Assert.Equal("Error description for: Rhino.ServiceBus.Tests.Bugs.WhenTransactionCommitErrors_ShouldNotCrash_Msmq+MsgToCreateBadTxEnlistment", err.Label);
+                }
+            }
+        }
+    }
 }
diff --git a/Rhino.ServiceBus.Tests/Bugs/When_cannot_resolve_consumer_should_error.cs b/Rhino.ServiceBus.Tests/Bugs/When_cannot_resolve_consumer_should_error.cs
@@ -1,17 +1,19 @@
+using Castle.MicroKernel.Registration;
+
 namespace Rhino.ServiceBus.Tests.Bugs
 {
-	using System;
-	using Castle.MicroKernel.Handlers;
-	using Castle.Windsor;
-	using Castle.Windsor.Configuration.Interpreters;
-	using Impl;
-	using Xunit;
-
-	public class When_cannot_resolve_consumer_because_of_missing_dependecies: MsmqTestBase
-	{
-		private readonly IWindsorContainer container;
-
-		public When_cannot_resolve_consumer_because_of_missing_dependecies()
+    using System;
+    using Castle.MicroKernel.Handlers;
+    using Castle.Windsor;
+    using Castle.Windsor.Configuration.Interpreters;
+    using Impl;
+    using Xunit;
+
+    public class When_cannot_resolve_consumer_because_of_missing_dependecies : MsmqTestBase
+    {
+        private readonly IWindsorContainer container;
+
+        public When_cannot_resolve_consumer_because_of_missing_dependecies()
         {
             container = new WindsorContainer(new XmlInterpreter());
             container.Kernel.AddFacility("rhino.esb", new RhinoServiceBusFacility());
@@ -20,32 +22,32 @@ public When_cannot_resolve_consumer_because_of_missing_dependecies()
         [Fact]
         public void Should_result_in_error()
         {
-            container.AddComponent<MyHandler2>();
+            container.Register(Component.For<MyHandler2>());
 
             var bus = (DefaultServiceBus)container.Resolve<IServiceBus>();
-        	Assert.Throws<HandlerException>(() =>
-			{
-        		bus.GatherConsumers(new CurrentMessageInformation
-        		{
-					Message = DateTime.Now
-        		});
-
-        	});
+            Assert.Throws<HandlerException>(() =>
+            {
+                bus.GatherConsumers(new CurrentMessageInformation
+                {
+                    Message = DateTime.Now
+                });
+
+            });
         }
 
-		public class MyHandler2 : ConsumerOf<DateTime>
-		{
-			private readonly int port;
-
-			public MyHandler2(int port)
-			{
-				this.port = port;
-			}
-
-			public void Consume(DateTime m )
-			{
-				Console.WriteLine(port);
-			}
-		}
-	}
+        public class MyHandler2 : ConsumerOf<DateTime>
+        {
+            private readonly int port;
+
+            public MyHandler2(int port)
+            {
+                this.port = port;
+            }
+
+            public void Consume(DateTime m)
+            {
+                Console.WriteLine(port);
+            }
+        }
+    }
 }