From e8898cd144a7e3ca38a3a02651967f7b90fd11ea Mon Sep 17 00:00:00 2001
From: Toby Henderson <hendersont@gmail.com>
Date: Wed, 9 Aug 2023 17:22:10 +0100
Subject: [PATCH] fix(Moq): Removed Moq and moved tests to FakeItEasy #2773
 (#2775)

* fix(Moq): Removed Moq and moved tests to FakeItEasy

* deleted comments
---
 .../AzureServiceBusConsumerTests.cs           | 263 +++++++++---------
 .../AzureServiceBusMessageProducerTests.cs    | 125 ++++-----
 ...more.Brighter.AzureServiceBus.Tests.csproj |   6 +-
 3 files changed, 200 insertions(+), 194 deletions(-)

diff --git a/tests/Paramore.Brighter.AzureServiceBus.Tests/AzureServiceBusConsumerTests.cs b/tests/Paramore.Brighter.AzureServiceBus.Tests/AzureServiceBusConsumerTests.cs
index 588150e604..5c01e62e2b 100644
--- a/tests/Paramore.Brighter.AzureServiceBus.Tests/AzureServiceBusConsumerTests.cs
+++ b/tests/Paramore.Brighter.AzureServiceBus.Tests/AzureServiceBusConsumerTests.cs
@@ -1,11 +1,10 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.ObjectModel;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using Azure.Messaging.ServiceBus;
-using Moq;
+using FakeItEasy;
 using Paramore.Brighter.MessagingGateway.AzureServiceBus;
 using Paramore.Brighter.MessagingGateway.AzureServiceBus.AzureServiceBusWrappers;
 using Xunit;
@@ -14,47 +13,49 @@ namespace Paramore.Brighter.AzureServiceBus.Tests
 {
     public class AzureServiceBusConsumerTests
     {
-        private readonly Mock<IAdministrationClientWrapper> _nameSpaceManagerWrapper;
+        private readonly IAdministrationClientWrapper _nameSpaceManagerWrapper;
         private readonly AzureServiceBusConsumer _azureServiceBusConsumer;
-        private readonly Mock<IServiceBusReceiverWrapper> _messageReceiver;
-        private readonly Mock<IAmAMessageProducerSync> _mockMessageProducer;
-        private readonly Mock<IServiceBusReceiverProvider> _mockMessageReceiver;
+        private readonly IServiceBusReceiverWrapper _messageReceiver;
+        private readonly IAmAMessageProducerSync _mockMessageProducer;
+        private readonly IServiceBusReceiverProvider _mockMessageReceiver;
 
         private readonly AzureServiceBusSubscriptionConfiguration _subConfig =
             new AzureServiceBusSubscriptionConfiguration();
 
         public AzureServiceBusConsumerTests()
         {
-            _nameSpaceManagerWrapper = new Mock<IAdministrationClientWrapper>();
-            _mockMessageProducer = new Mock<IAmAMessageProducerSync>();
-            _mockMessageReceiver = new Mock<IServiceBusReceiverProvider>();
+            _nameSpaceManagerWrapper = A.Fake<IAdministrationClientWrapper>();
+            _mockMessageProducer = A.Fake<IAmAMessageProducerSync>();
+            _mockMessageReceiver = A.Fake<IServiceBusReceiverProvider>();
 
-            _messageReceiver = new Mock<IServiceBusReceiverWrapper>();
+            _messageReceiver = A.Fake<IServiceBusReceiverWrapper > ();
 
-            _mockMessageReceiver.Setup(x => x.Get("topic", "subscription", ServiceBusReceiveMode.ReceiveAndDelete, false)).Returns(_messageReceiver.Object);
+            A.CallTo(() =>
+                    _mockMessageReceiver.Get("topic", "subscription", ServiceBusReceiveMode.ReceiveAndDelete, false))
+                .Returns(_messageReceiver);
 
-            _azureServiceBusConsumer = new AzureServiceBusConsumer("topic", "subscription", _mockMessageProducer.Object,
-                _nameSpaceManagerWrapper.Object, _mockMessageReceiver.Object, makeChannels: OnMissingChannel.Create, subscriptionConfiguration: _subConfig);
+            _azureServiceBusConsumer = new AzureServiceBusConsumer("topic", "subscription", _mockMessageProducer,
+                _nameSpaceManagerWrapper, _mockMessageReceiver, makeChannels: OnMissingChannel.Create, subscriptionConfiguration: _subConfig);
         }
 
         [Fact]
         public void When_a_subscription_exists_and_messages_are_in_the_queue_the_messages_are_returned()
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Returns(true);
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Returns(true);
 
             var brokeredMessageList = new List<IBrokeredMessageWrapper>();
-            var message1 = new Mock<IBrokeredMessageWrapper>();
+            var message1 = A.Fake<IBrokeredMessageWrapper>();
 
-            message1.Setup(m => m.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
-            message1.Setup(m => m.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
-            var message2 = new Mock<IBrokeredMessageWrapper>();
+            A.CallTo(() => message1.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
+            A.CallTo(() => message1.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
+            var message2 = A.Fake<IBrokeredMessageWrapper>();
 
-            message2.Setup(m => m.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody2"));
-            message2.Setup(m => m.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_DOCUMENT" } });
-            brokeredMessageList.Add(message1.Object);
-            brokeredMessageList.Add(message2.Object);
+            A.CallTo(() => message2.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody2"));
+            A.CallTo(() => message2.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_DOCUMENT" } });
+            brokeredMessageList.Add(message1);
+            brokeredMessageList.Add(message2);
 
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
 
             Message[] result = _azureServiceBusConsumer.Receive(400);
 
@@ -70,35 +71,36 @@ public void When_a_subscription_exists_and_messages_are_in_the_queue_the_message
         [Fact]
         public void When_a_subscription_does_not_exist_and_messages_are_in_the_queue_then_the_subscription_is_created_and_messages_are_returned()
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Returns(false);
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Returns(false);
             var brokeredMessageList = new List<IBrokeredMessageWrapper>();
-            var message1 = new Mock<IBrokeredMessageWrapper>();
+            var message1 = A.Fake<IBrokeredMessageWrapper>();
 
-            message1.Setup(m => m.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
-            message1.Setup(m => m.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
-            brokeredMessageList.Add(message1.Object);
+            A.CallTo(() => message1.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
+            A.CallTo(() => message1.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
+            brokeredMessageList.Add(message1);
 
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
 
             Message[] result = _azureServiceBusConsumer.Receive(400);
 
-            _nameSpaceManagerWrapper.Verify(f => f.CreateSubscription("topic", "subscription", _subConfig));
+            A.CallTo(() => _nameSpaceManagerWrapper.CreateSubscription("topic", "subscription", _subConfig)).MustHaveHappened();
+            //A.CallTo(() => _nameSpaceManagerWrapper.f => f.CreateSubscription("topic", "subscription", _subConfig)).MustHaveHappened();
             Assert.Equal("somebody", result[0].Body.Value);
         }
 
         [Fact]
         public void When_a_message_is_a_command_type_then_the_message_type_is_set_correctly()
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Returns(true);
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Returns(true);
 
             var brokeredMessageList = new List<IBrokeredMessageWrapper>();
-            var message1 = new Mock<IBrokeredMessageWrapper>();
+            var message1 = A.Fake<IBrokeredMessageWrapper>();
 
-            message1.Setup(m => m.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
-            message1.Setup(m => m.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_COMMAND" } });
-            brokeredMessageList.Add(message1.Object);
+            A.CallTo(() => message1.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
+            A.CallTo(() => message1.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_COMMAND" } });
+            brokeredMessageList.Add(message1);
 
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
 
             Message[] result = _azureServiceBusConsumer.Receive(400);
 
@@ -110,15 +112,15 @@ public void When_a_message_is_a_command_type_then_the_message_type_is_set_correc
         [Fact]
         public void When_a_message_is_a_command_type_and_it_is_specified_in_funny_casing_then_the_message_type_is_set_correctly()
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Returns(true);
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Returns(true);
 
             var brokeredMessageList = new List<IBrokeredMessageWrapper>();
-            var message1 = new Mock<IBrokeredMessageWrapper>();
-            message1.Setup(m => m.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
-            message1.Setup(m => m.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "Mt_COmmAND" } });
-            brokeredMessageList.Add(message1.Object);
+            var message1 = A.Fake<IBrokeredMessageWrapper>();
+            A.CallTo(() => message1.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
+            A.CallTo(() => message1.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "Mt_COmmAND" } });
+            brokeredMessageList.Add(message1);
 
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
 
             Message[] result = _azureServiceBusConsumer.Receive(400);
 
@@ -130,16 +132,16 @@ public void When_a_message_is_a_command_type_and_it_is_specified_in_funny_casing
         [Fact]
         public void When_the_specified_message_type_is_unknown_then_it_should_default_to_MT_EVENT()
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Returns(true);
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Returns(true);
 
             var brokeredMessageList = new List<IBrokeredMessageWrapper>();
-            var message1 = new Mock<IBrokeredMessageWrapper>();
+            var message1 = A.Fake<IBrokeredMessageWrapper>();
 
-            message1.Setup(m => m.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
-            message1.Setup(m => m.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "wrong_message_type" } });
-            brokeredMessageList.Add(message1.Object);
+            A.CallTo(() => message1.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
+            A.CallTo(() => message1.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "wrong_message_type" } });
+            brokeredMessageList.Add(message1);
 
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
 
             Message[] result = _azureServiceBusConsumer.Receive(400);
 
@@ -149,15 +151,15 @@ public void When_the_specified_message_type_is_unknown_then_it_should_default_to
         [Fact]
         public void When_the_message_type_is_not_specified_it_should_default_to_MT_EVENT()
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Returns(true);
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Returns(true);
 
             var brokeredMessageList = new List<IBrokeredMessageWrapper>();
-            var message1 = new Mock<IBrokeredMessageWrapper>();
-            message1.Setup(m => m.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
-            message1.Setup(m => m.ApplicationProperties).Returns(new Dictionary<string, object>());
-            brokeredMessageList.Add(message1.Object);
+            var message1 = A.Fake<IBrokeredMessageWrapper>();
+            A.CallTo(() => message1.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
+            A.CallTo(() => message1.ApplicationProperties).Returns(new Dictionary<string, object>());
+            brokeredMessageList.Add(message1);
 
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
 
             Message[] result = _azureServiceBusConsumer.Receive(400);
 
@@ -169,16 +171,16 @@ public void When_the_message_type_is_not_specified_it_should_default_to_MT_EVENT
         [Fact]
         public void When_the_user_properties_on_the_azure_sb_message_is_null_it_should_default_to_message_type_to_MT_EVENT()
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Returns(true);
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Returns(true);
 
 
             var brokeredMessageList = new List<IBrokeredMessageWrapper>();
-            var message1 = new Mock<IBrokeredMessageWrapper>();
-            message1.Setup(m => m.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
-            message1.Setup(m => m.ApplicationProperties).Returns(new Dictionary<string, object>());
-            brokeredMessageList.Add(message1.Object);
+            var message1 = A.Fake<IBrokeredMessageWrapper>();
+            A.CallTo(() => message1.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
+            A.CallTo(() => message1.ApplicationProperties).Returns(new Dictionary<string, object>());
+            brokeredMessageList.Add(message1);
 
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
 
             Message[] result = _azureServiceBusConsumer.Receive(400);
 
@@ -190,10 +192,10 @@ public void When_the_user_properties_on_the_azure_sb_message_is_null_it_should_d
         [Fact]
         public void When_there_are_no_messages_then_it_returns_an_empty_array()
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Returns(true);
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Returns(true);
             var brokeredMessageList = new List<IBrokeredMessageWrapper>();
 
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
 
             Message[] result = _azureServiceBusConsumer.Receive(400);
             Assert.Empty(result);
@@ -202,22 +204,22 @@ public void When_there_are_no_messages_then_it_returns_an_empty_array()
         [Fact]
         public void When_trying_to_create_a_subscription_which_was_already_created_by_another_thread_it_should_ignore_the_error()
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Returns(false);
-            _nameSpaceManagerWrapper.Setup(f => f.CreateSubscription("topic", "subscription", _subConfig))
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Returns(false);
+            A.CallTo(() => _nameSpaceManagerWrapper.CreateSubscription("topic", "subscription", _subConfig))
                 .Throws(new ServiceBusException("whatever", ServiceBusFailureReason.MessagingEntityAlreadyExists));
 
             var brokeredMessageList = new List<IBrokeredMessageWrapper>();
-            var message1 = new Mock<IBrokeredMessageWrapper>();
+            var message1 = A.Fake<IBrokeredMessageWrapper>();
 
-            message1.Setup(m => m.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
-            message1.Setup(m => m.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
-            brokeredMessageList.Add(message1.Object);
+            A.CallTo(() => message1.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
+            A.CallTo(() => message1.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
+            brokeredMessageList.Add(message1);
 
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
 
             Message[] result = _azureServiceBusConsumer.Receive(400);
 
-            _nameSpaceManagerWrapper.Verify(f => f.CreateSubscription("topic", "subscription", _subConfig));
+            A.CallTo(() => _nameSpaceManagerWrapper.CreateSubscription("topic", "subscription", _subConfig)).MustHaveHappened();
             Assert.Equal("somebody", result[0].Body.Value);
         }
 
@@ -226,7 +228,7 @@ public void When_dispose_is_called_the_close_method_is_called()
         {
             _azureServiceBusConsumer.Dispose();
 
-            _messageReceiver.Verify(x => x.Close(), Times.Once);
+            A.CallTo(() => _messageReceiver.Close()).MustHaveHappened(1, Times.Exactly);
         }
 
         [Fact]
@@ -239,7 +241,7 @@ public void When_requeue_is_called_and_the_delay_is_zero_the_send_method_is_call
 
             _azureServiceBusConsumer.Requeue(message, 0);
 
-            _mockMessageProducer.Verify(x => x.Send(message), Times.Once);
+            A.CallTo(() => _mockMessageProducer.Send(message)).MustHaveHappened(1, Times.Exactly);
         }
 
         [Fact]
@@ -252,14 +254,14 @@ public void When_requeue_is_called_and_the_delay_is_more_than_zero_the_sendWithD
 
             _azureServiceBusConsumer.Requeue(message, 100);
 
-            _mockMessageProducer.Verify(x => x.SendWithDelay(message, 100), Times.Once);
+            A.CallTo(() => _mockMessageProducer.SendWithDelay(message, 100)).MustHaveHappened(1, Times.Exactly);
         }
 
         [Fact]
         public void
             When_there_is_an_error_talking_to_servicebus_when_checking_if_subscription_exist_then_a_ChannelFailureException_is_raised()
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Throws(new Exception());
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Throws(new Exception());
 
             Assert.Throws<ChannelFailureException>(() => _azureServiceBusConsumer.Receive(400));
         }
@@ -267,22 +269,25 @@ public void
         [Fact]
         public void When_there_is_an_error_talking_to_servicebus_when_creating_the_subscription_then_a_ChannelFailureException_is_raised_and_ManagementClientWrapper_is_reinitilised()
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Returns(false);
-            _nameSpaceManagerWrapper.Setup(f => f.CreateSubscription("topic", "subscription", _subConfig)).Throws(new Exception());
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Returns(false);
+            A.CallTo(() => _nameSpaceManagerWrapper.CreateSubscription("topic", "subscription", _subConfig)).Throws(new Exception());
 
             Assert.Throws<ChannelFailureException>(() => _azureServiceBusConsumer.Receive(400));
-            _nameSpaceManagerWrapper.Verify(managementClientWrapper => managementClientWrapper.Reset(), Times.Once);
+            A.CallTo(() => _nameSpaceManagerWrapper.Reset()).MustHaveHappenedOnceExactly();
         }
 
+        /// <summary>
+        /// TODO: review 
+        /// </summary>
         [Fact]
         public void When_there_is_an_error_talking_to_servicebus_when_receiving_then_a_ChannelFailureException_is_raised_and_the_messageReceiver_is_recreated()
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Returns(true);
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Returns(true);
 
-            _messageReceiver.Setup(f => f.Receive(It.IsAny<int>(), It.IsAny<TimeSpan>())).Throws(new Exception());
+            A.CallTo(() => _messageReceiver.Receive(A<int>.Ignored, A<TimeSpan>.Ignored)).Throws<Exception>();
 
             Assert.Throws<ChannelFailureException>(() => _azureServiceBusConsumer.Receive(400));
-            _mockMessageReceiver.Verify(x => x.Get(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<ServiceBusReceiveMode>(), false), Times.Exactly(2));
+            A.CallTo(() => _mockMessageReceiver.Get("topic", "subscription", ServiceBusReceiveMode.ReceiveAndDelete, false)).MustHaveHappened(2, Times.Exactly);
         }
 
         [Theory]
@@ -290,63 +295,63 @@ public void When_there_is_an_error_talking_to_servicebus_when_receiving_then_a_C
         [InlineData(false)]
         public void Once_the_subscription_is_created_or_exits_it_does_not_check_if_it_exists_every_time(bool subscriptionExists)
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Returns(subscriptionExists);
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Returns(subscriptionExists);
             var brokeredMessageList = new List<IBrokeredMessageWrapper>();
-            var message1 = new Mock<IBrokeredMessageWrapper>();
-            message1.Setup(m => m.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
-            message1.Setup(m => m.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
-            brokeredMessageList.Add(message1.Object);
+            var message1 = A.Fake<IBrokeredMessageWrapper>();
+            A.CallTo(() => message1.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
+            A.CallTo(() => message1.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
+            brokeredMessageList.Add(message1);
 
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
 
             _azureServiceBusConsumer.Receive(400);
             _azureServiceBusConsumer.Receive(400);
 
             if (subscriptionExists == false)
             {
-                _nameSpaceManagerWrapper.Verify(f => f.CreateSubscription("topic", "subscription", _subConfig), Times.Once);
+                A.CallTo(() => _nameSpaceManagerWrapper.CreateSubscription("topic", "subscription", _subConfig)).MustHaveHappened(1, Times.Exactly);
             }
 
-            _nameSpaceManagerWrapper.Verify(f => f.SubscriptionExists("topic", "subscription"), Times.Once);
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).MustHaveHappened(1, Times.Exactly);
         }
 
         [Fact]
         public void When_MessagingEntityAlreadyExistsException_does_not_check_if_subscription_exists()
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Returns(false);
-            _nameSpaceManagerWrapper.Setup(f => f.CreateSubscription("topic", "subscription", new AzureServiceBusSubscriptionConfiguration()))
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Returns(false);
+            A.CallTo(() => _nameSpaceManagerWrapper.CreateSubscription("topic", "subscription", new AzureServiceBusSubscriptionConfiguration()))
                 .Throws(new ServiceBusException("whatever", ServiceBusFailureReason.MessagingEntityAlreadyExists));
 
             var brokeredMessageList = new List<IBrokeredMessageWrapper>();
-            var message1 = new Mock<IBrokeredMessageWrapper>();
+            var message1 = A.Fake<IBrokeredMessageWrapper>();
 
-            message1.Setup(m => m.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
-            message1.Setup(m => m.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
-            brokeredMessageList.Add(message1.Object);
+            A.CallTo(() => message1.MessageBodyValue).Returns(Encoding.UTF8.GetBytes("somebody"));
+            A.CallTo(() => message1.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
+            brokeredMessageList.Add(message1);
 
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
 
             Message[] result = _azureServiceBusConsumer.Receive(400);
             _azureServiceBusConsumer.Receive(400);
 
-            _nameSpaceManagerWrapper.Verify(f => f.CreateSubscription("topic", "subscription", _subConfig));
+            A.CallTo(() => _nameSpaceManagerWrapper.CreateSubscription("topic", "subscription", _subConfig)).MustHaveHappened();
             Assert.Equal("somebody", result[0].Body.Value);
 
-            _nameSpaceManagerWrapper.Verify(f => f.SubscriptionExists("topic", "subscription"), Times.Once);
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).MustHaveHappened(1, Times.Exactly);
         }
 
         [Fact]
         public void When_a_message_contains_a_null_body_message_is_still_processed()
         {
             var brokeredMessageList = new List<IBrokeredMessageWrapper>();
-            var message1 = new Mock<IBrokeredMessageWrapper>();
+            var message1 = A.Fake<IBrokeredMessageWrapper>();
 
-            message1.Setup(x => x.MessageBodyValue).Returns((byte[])null);
-            message1.Setup(m => m.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
+            A.CallTo(() => message1.MessageBodyValue).Returns((byte[])null);
+            A.CallTo(() => message1.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
 
-            brokeredMessageList.Add(message1.Object);
+            brokeredMessageList.Add(message1);
 
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
 
             Message[] result = _azureServiceBusConsumer.Receive(400);
 
@@ -356,8 +361,8 @@ public void When_a_message_contains_a_null_body_message_is_still_processed()
         [Fact]
         public void When_receiving_messages_and_the_receiver_is_closing_a_MT_QUIT_message_is_sent()
         {
-            _messageReceiver.Setup(x => x.IsClosedOrClosing).Returns(true);
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Throws(new Exception("Closing"));
+            A.CallTo(() => _messageReceiver.IsClosedOrClosing).Returns(true);
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Throws(new Exception("Closing"));
 
             Message[] result = _azureServiceBusConsumer.Receive(400);
 
@@ -368,10 +373,10 @@ public void When_receiving_messages_and_the_receiver_is_closing_a_MT_QUIT_messag
         [Fact]
         public void When_a_subscription_does_not_exist_and_Missing_is_set_to_Validate_a_Channel_Failure_is_Raised()
         {
-            _nameSpaceManagerWrapper.Setup(f => f.SubscriptionExists("topic", "subscription")).Returns(false);
+            A.CallTo(() => _nameSpaceManagerWrapper.SubscriptionExists("topic", "subscription")).Returns(false);
 
-            var azureServiceBusConsumerValidate = new AzureServiceBusConsumer("topic", "subscription", _mockMessageProducer.Object,
-                _nameSpaceManagerWrapper.Object, _mockMessageReceiver.Object, makeChannels: OnMissingChannel.Validate);
+            var azureServiceBusConsumerValidate = new AzureServiceBusConsumer("topic", "subscription", _mockMessageProducer,
+                _nameSpaceManagerWrapper, _mockMessageReceiver, makeChannels: OnMissingChannel.Validate);
 
             Assert.Throws<ChannelFailureException>(() => azureServiceBusConsumerValidate.Receive(400));
         }
@@ -380,24 +385,24 @@ public void When_a_subscription_does_not_exist_and_Missing_is_set_to_Validate_a_
         public void When_ackOnRead_is_Set_and_ack_fails_then_exception_is_thrown()
         {
             var brokeredMessageList = new List<IBrokeredMessageWrapper>();
-            var message1 = new Mock<IBrokeredMessageWrapper>();
-            var mockMessageReceiver = new Mock<IServiceBusReceiverProvider>();
+            var message1 = A.Fake<IBrokeredMessageWrapper>();
+            var mockMessageReceiver = A.Fake<IServiceBusReceiverProvider>();
 
-            mockMessageReceiver.Setup(x => x.Get("topic", "subscription", ServiceBusReceiveMode.PeekLock, false)).Returns(_messageReceiver.Object);
+            A.CallTo(() => mockMessageReceiver.Get("topic", "subscription", ServiceBusReceiveMode.PeekLock, false)).Returns(_messageReceiver);
 
             var lockToken = Guid.NewGuid().ToString();
 
-            message1.Setup(x => x.MessageBodyValue).Returns((byte[])null);
-            message1.Setup(m => m.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
-            message1.Setup(m => m.LockToken).Returns(lockToken);
+            A.CallTo(() => message1.MessageBodyValue).Returns((byte[])null);
+            A.CallTo(() => message1.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
+            A.CallTo(() => message1.LockToken).Returns(lockToken);
 
-            brokeredMessageList.Add(message1.Object);
+            brokeredMessageList.Add(message1);
 
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
-            _messageReceiver.Setup(x => x.Complete(lockToken)).Throws(new Exception());
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
+            A.CallTo(() => _messageReceiver.Complete(lockToken)).Throws(new Exception());
 
-            var azureServiceBusConsumer = new AzureServiceBusConsumer("topic", "subscription", _mockMessageProducer.Object,
-                _nameSpaceManagerWrapper.Object, mockMessageReceiver.Object, makeChannels: OnMissingChannel.Create, receiveMode: ServiceBusReceiveMode.PeekLock);
+            var azureServiceBusConsumer = new AzureServiceBusConsumer("topic", "subscription", _mockMessageProducer,
+                _nameSpaceManagerWrapper, mockMessageReceiver, makeChannels: OnMissingChannel.Create, receiveMode: ServiceBusReceiveMode.PeekLock);
 
             Message[] result = azureServiceBusConsumer.Receive(400);
 
@@ -410,24 +415,24 @@ public void When_ackOnRead_is_Set_and_ack_fails_then_exception_is_thrown()
         public void When_ackOnRead_is_Set_and_DeadLetter_fails_then_exception_is_thrown()
         {
             var brokeredMessageList = new List<IBrokeredMessageWrapper>();
-            var message1 = new Mock<IBrokeredMessageWrapper>();
-            var mockMessageReceiver = new Mock<IServiceBusReceiverProvider>();
+            var message1 = A.Fake<IBrokeredMessageWrapper>();
+            var mockMessageReceiver = A.Fake<IServiceBusReceiverProvider>();
 
-            mockMessageReceiver.Setup(x => x.Get("topic", "subscription", ServiceBusReceiveMode.PeekLock, false)).Returns(_messageReceiver.Object);
+            A.CallTo(() => mockMessageReceiver.Get("topic", "subscription", ServiceBusReceiveMode.PeekLock, false)).Returns(_messageReceiver);
 
             var lockToken = Guid.NewGuid().ToString();
 
-            message1.Setup(x => x.MessageBodyValue).Returns((byte[])null);
-            message1.Setup(m => m.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
-            message1.Setup(m => m.LockToken).Returns(lockToken);
+            A.CallTo(() => message1.MessageBodyValue).Returns((byte[])null);
+            A.CallTo(() => message1.ApplicationProperties).Returns(new Dictionary<string, object> { { "MessageType", "MT_EVENT" } });
+            A.CallTo(() => message1.LockToken).Returns(lockToken);
 
-            brokeredMessageList.Add(message1.Object);
+            brokeredMessageList.Add(message1);
 
-            _messageReceiver.Setup(x => x.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
-            _messageReceiver.Setup(x => x.DeadLetter(lockToken)).Throws(new Exception());
+            A.CallTo(() => _messageReceiver.Receive(10, TimeSpan.FromMilliseconds(400))).Returns(Task.FromResult<IEnumerable<IBrokeredMessageWrapper>>(brokeredMessageList));
+            A.CallTo(() => _messageReceiver.DeadLetter(lockToken)).Throws(new Exception());
 
-            var azureServiceBusConsumer = new AzureServiceBusConsumer("topic", "subscription", _mockMessageProducer.Object,
-                _nameSpaceManagerWrapper.Object, mockMessageReceiver.Object, makeChannels: OnMissingChannel.Create, receiveMode: ServiceBusReceiveMode.PeekLock);
+            var azureServiceBusConsumer = new AzureServiceBusConsumer("topic", "subscription", _mockMessageProducer,
+                _nameSpaceManagerWrapper, mockMessageReceiver, makeChannels: OnMissingChannel.Create, receiveMode: ServiceBusReceiveMode.PeekLock);
 
             Message[] result = azureServiceBusConsumer.Receive(400);
 
diff --git a/tests/Paramore.Brighter.AzureServiceBus.Tests/AzureServiceBusMessageProducerTests.cs b/tests/Paramore.Brighter.AzureServiceBus.Tests/AzureServiceBusMessageProducerTests.cs
index 3abcbbeae0..db387b6c9f 100644
--- a/tests/Paramore.Brighter.AzureServiceBus.Tests/AzureServiceBusMessageProducerTests.cs
+++ b/tests/Paramore.Brighter.AzureServiceBus.Tests/AzureServiceBusMessageProducerTests.cs
@@ -1,8 +1,9 @@
 using System;
 using System.Text;
 using System.Threading;
+using System.Threading.Tasks;
 using Azure.Messaging.ServiceBus;
-using Moq;
+using FakeItEasy;
 using Paramore.Brighter.MessagingGateway.AzureServiceBus;
 using Paramore.Brighter.MessagingGateway.AzureServiceBus.AzureServiceBusWrappers;
 using Xunit;
@@ -11,18 +12,18 @@ namespace Paramore.Brighter.AzureServiceBus.Tests
 {
     public class AzureServiceBusMessageProducerTests
     {
-        private readonly Mock<IAdministrationClientWrapper> _nameSpaceManagerWrapper;
-        private readonly Mock<IServiceBusSenderProvider> _topicClientProvider;
-        private readonly Mock<IServiceBusSenderWrapper> _topicClient;
+        private readonly IAdministrationClientWrapper _nameSpaceManagerWrapper;
+        private readonly IServiceBusSenderProvider _topicClientProvider;
+        private readonly IServiceBusSenderWrapper _topicClient;
         private readonly AzureServiceBusMessageProducer _producer;
 
         public AzureServiceBusMessageProducerTests()
         {
-            _nameSpaceManagerWrapper = new Mock<IAdministrationClientWrapper>();
-            _topicClientProvider = new Mock<IServiceBusSenderProvider>();
-            _topicClient = new Mock<IServiceBusSenderWrapper>();
+            _nameSpaceManagerWrapper = A.Fake<IAdministrationClientWrapper>();
+            _topicClientProvider = A.Fake<IServiceBusSenderProvider>();
+            _topicClient = A.Fake<IServiceBusSenderWrapper>();
 
-            _producer = new AzureServiceBusMessageProducer(_nameSpaceManagerWrapper.Object, _topicClientProvider.Object, OnMissingChannel.Create);
+            _producer = new AzureServiceBusMessageProducer(_nameSpaceManagerWrapper, _topicClientProvider, OnMissingChannel.Create);
         }
 
         [Fact]
@@ -31,16 +32,15 @@ public void When_the_topic_exists_and_sending_a_message_with_no_delay_it_should_
             ServiceBusMessage sentMessage = null;
             var messageBody = Encoding.UTF8.GetBytes("A message body");
 
-            _nameSpaceManagerWrapper.Setup(t => t.TopicExists("topic")).Returns(true);
-            _topicClientProvider.Setup(f => f.Get("topic")).Returns(_topicClient.Object);
-            _topicClient.Setup(f => f.SendAsync(It.IsAny<ServiceBusMessage>(), CancellationToken.None))
-                .Callback((ServiceBusMessage g, CancellationToken ct) => sentMessage = g);
+            A.CallTo(() => _nameSpaceManagerWrapper.TopicExists("topic")).Returns(true);
+            A.CallTo(() => _topicClientProvider.Get("topic")).Returns(_topicClient);
+            A.CallTo(() => _topicClient.SendAsync(A<ServiceBusMessage>.Ignored, CancellationToken.None)).ReturnsLazily((ServiceBusMessage g, CancellationToken ct) => Task.FromResult(sentMessage = g));
 
             _producer.Send(new Message(new MessageHeader(Guid.NewGuid(), "topic", MessageType.MT_EVENT), new MessageBody(messageBody, "JSON")));
 
             Assert.Equal(messageBody, sentMessage.Body.ToArray());
             Assert.Equal("MT_EVENT", sentMessage.ApplicationProperties["MessageType"]);
-            _topicClient.Verify(x => x.CloseAsync(), Times.Once);
+            A.CallTo(() => _topicClient.CloseAsync()).MustHaveHappenedOnceExactly();
         }
 
         [Fact]
@@ -49,16 +49,15 @@ public void When_sending_a_command_message_type_message_with_no_delay_it_should_
             ServiceBusMessage sentMessage = null;
             var messageBody = Encoding.UTF8.GetBytes("A message body");
 
-            _nameSpaceManagerWrapper.Setup(t => t.TopicExists("topic")).Returns(true);
-            _topicClientProvider.Setup(f => f.Get("topic")).Returns(_topicClient.Object);
-            _topicClient.Setup(f => f.SendAsync(It.IsAny<ServiceBusMessage>(), CancellationToken.None))
-                .Callback((ServiceBusMessage g, CancellationToken ct) => sentMessage = g);
+            A.CallTo(() => _nameSpaceManagerWrapper.TopicExists("topic")).Returns(true);
+            A.CallTo(() => _topicClientProvider.Get("topic")).Returns(_topicClient);
+            A.CallTo(() => _topicClient.SendAsync(A<ServiceBusMessage>.Ignored, CancellationToken.None)).ReturnsLazily((ServiceBusMessage g, CancellationToken ct) => Task.FromResult(sentMessage = g));
 
             _producer.Send(new Message(new MessageHeader(Guid.NewGuid(), "topic", MessageType.MT_COMMAND), new MessageBody(messageBody, "JSON")));
 
             Assert.Equal(messageBody, sentMessage.Body.ToArray());
             Assert.Equal("MT_COMMAND", sentMessage.ApplicationProperties["MessageType"]);
-            _topicClient.Verify(x => x.CloseAsync(), Times.Once);
+            A.CallTo(() => _topicClient.CloseAsync()).MustHaveHappenedOnceExactly();
         }
 
         [Fact]
@@ -67,23 +66,23 @@ public void When_the_topic_does_not_exist_it_should_be_created_and_the_message_i
             ServiceBusMessage sentMessage = null;
             var messageBody = Encoding.UTF8.GetBytes("A message body");
 
-            _nameSpaceManagerWrapper.Setup(t => t.TopicExists("topic")).Returns(false);
-            _topicClientProvider.Setup(f => f.Get("topic")).Returns(_topicClient.Object);
-            _topicClient.Setup(f => f.SendAsync(It.IsAny<ServiceBusMessage>(), CancellationToken.None)).Callback((ServiceBusMessage g, CancellationToken ct) => sentMessage = g);
+            A.CallTo(() => _nameSpaceManagerWrapper.TopicExists("topic")).Returns(false);
+            A.CallTo(() => _topicClientProvider.Get("topic")).Returns(_topicClient);
+            A.CallTo(() => _topicClient.SendAsync(A<ServiceBusMessage>.Ignored, CancellationToken.None)).ReturnsLazily((ServiceBusMessage g, CancellationToken ct) => Task.FromResult(sentMessage = g));
 
             _producer.Send(new Message(new MessageHeader(Guid.NewGuid(), "topic", MessageType.MT_NONE), new MessageBody(messageBody, "JSON")));
 
-            _nameSpaceManagerWrapper.Verify(x => x.CreateTopic("topic", null), Times.Once);
+            A.CallTo(() => _nameSpaceManagerWrapper.CreateTopic("topic", null)).MustHaveHappenedOnceExactly();
             Assert.Equal(messageBody, sentMessage.Body.ToArray());
         }
 
         [Fact]
         public void When_a_message_is_send_and_an_exception_occurs_close_is_still_called()
         {
-            _nameSpaceManagerWrapper.Setup(t => t.TopicExists("topic")).Returns(true);
-            _topicClientProvider.Setup(f => f.Get("topic")).Returns(_topicClient.Object);
+            A.CallTo(() => _nameSpaceManagerWrapper.TopicExists("topic")).Returns(true);
+            A.CallTo(() => _topicClientProvider.Get("topic")).Returns(_topicClient);
 
-            _topicClient.Setup(x => x.SendAsync(It.IsAny<ServiceBusMessage>(), CancellationToken.None)).Throws(new Exception("Failed"));
+            A.CallTo(() => _topicClient.SendAsync(A<ServiceBusMessage>.Ignored, CancellationToken.None)).Throws(new Exception("Failed"));
 
             try
             {
@@ -94,27 +93,30 @@ public void When_a_message_is_send_and_an_exception_occurs_close_is_still_called
                 // ignored
             }
 
-            _topicClient.Verify(x => x.CloseAsync(), Times.Once);
+            A.CallTo(() => _topicClient.CloseAsync()).MustHaveHappenedOnceExactly();
         }
 
         [Fact]
-        public void When_the_topic_exists_and_sending_a_message_with_a_delay_it_should_send_the_message_to_the_correct_topicclient()
+        public void
+            When_the_topic_exists_and_sending_a_message_with_a_delay_it_should_send_the_message_to_the_correct_topicclient()
         {
             ServiceBusMessage sentMessage = null;
             var messageBody = Encoding.UTF8.GetBytes("A message body");
 
-            _nameSpaceManagerWrapper.Setup(t => t.TopicExists("topic")).Returns(true);
-            _topicClientProvider.Setup(f => f.Get("topic")).Returns(_topicClient.Object);
-            _topicClient
-                .Setup(f => f.ScheduleMessageAsync(It.IsAny<ServiceBusMessage>(), It.IsAny<DateTimeOffset>(),
-                    CancellationToken.None)).Callback((ServiceBusMessage g, DateTimeOffset d, CancellationToken ct) =>
-                    sentMessage = g);
+            A.CallTo(() => _nameSpaceManagerWrapper.TopicExists("topic")).Returns(true);
+            A.CallTo(() => _topicClientProvider.Get("topic")).Returns(_topicClient);
 
-            _producer.SendWithDelay(new Message(new MessageHeader(Guid.NewGuid(), "topic", MessageType.MT_EVENT), new MessageBody(messageBody, "JSON")), 1);
+            A.CallTo(() => _topicClient.ScheduleMessageAsync(A<ServiceBusMessage>.Ignored, A<DateTimeOffset>.Ignored,
+                CancellationToken.None)).ReturnsLazily((ServiceBusMessage g, DateTimeOffset t, CancellationToken ct) =>
+                Task.FromResult(sentMessage = g));
+
+            _producer.SendWithDelay(
+                new Message(new MessageHeader(Guid.NewGuid(), "topic", MessageType.MT_EVENT),
+                    new MessageBody(messageBody, "JSON")), 1);
 
             Assert.Equal(messageBody, sentMessage.Body.ToArray());
             Assert.Equal("MT_EVENT", sentMessage.ApplicationProperties["MessageType"]);
-            _topicClient.Verify(x => x.CloseAsync(), Times.Once);
+            A.CallTo(() => _topicClient.CloseAsync()).MustHaveHappenedOnceExactly();
         }
 
         [Fact]
@@ -123,18 +125,17 @@ public void When_sending_a_command_message_type_message_with_delay_it_should_set
             ServiceBusMessage sentMessage = null;
             var messageBody = Encoding.UTF8.GetBytes("A message body");
 
-            _nameSpaceManagerWrapper.Setup(t => t.TopicExists("topic")).Returns(true);
-            _topicClientProvider.Setup(f => f.Get("topic")).Returns(_topicClient.Object);
-            _topicClient
-                .Setup(f => f.ScheduleMessageAsync(It.IsAny<ServiceBusMessage>(), It.IsAny<DateTimeOffset>(),
-                    CancellationToken.None)).Callback((ServiceBusMessage g, DateTimeOffset d, CancellationToken ct) =>
-                    sentMessage = g);
+            A.CallTo(() => _nameSpaceManagerWrapper.TopicExists("topic")).Returns(true);
+            A.CallTo(() => _topicClientProvider.Get("topic")).Returns(_topicClient);
+            
+                A.CallTo(() => _topicClient.ScheduleMessageAsync(A<ServiceBusMessage>.Ignored, A<DateTimeOffset>.Ignored,
+                    CancellationToken.None)).ReturnsLazily((ServiceBusMessage g, DateTimeOffset t, CancellationToken ct) => Task.FromResult(sentMessage = g));
 
             _producer.SendWithDelay(new Message(new MessageHeader(Guid.NewGuid(), "topic", MessageType.MT_COMMAND), new MessageBody(messageBody, "JSON")), 1);
 
             Assert.Equal(messageBody, sentMessage.Body.ToArray());
             Assert.Equal("MT_COMMAND", sentMessage.ApplicationProperties["MessageType"]);
-            _topicClient.Verify(x => x.CloseAsync(), Times.Once);
+            A.CallTo(() => _topicClient.CloseAsync()).MustHaveHappenedOnceExactly();
         }
 
         [Fact]
@@ -143,18 +144,17 @@ public void When_the_topic_does_not_exist_and_sending_a_message_with_a_delay_it_
             ServiceBusMessage sentMessage = null;
             var messageBody = Encoding.UTF8.GetBytes("A message body");
 
-            _nameSpaceManagerWrapper.Setup(t => t.TopicExists("topic")).Returns(false);
-            _topicClientProvider.Setup(f => f.Get("topic")).Returns(_topicClient.Object);
-            _topicClient
-                .Setup(f => f.ScheduleMessageAsync(It.IsAny<ServiceBusMessage>(), It.IsAny<DateTimeOffset>(),
-                    CancellationToken.None)).Callback((ServiceBusMessage g, DateTimeOffset d, CancellationToken ct) =>
-                    sentMessage = g);
+            A.CallTo(() => _nameSpaceManagerWrapper.TopicExists("topic")).Returns(false);
+            A.CallTo(() => _topicClientProvider.Get("topic")).Returns(_topicClient);
+            
+                A.CallTo(() => _topicClient.ScheduleMessageAsync(A<ServiceBusMessage>.Ignored, A<DateTimeOffset>.Ignored,
+                    CancellationToken.None)).ReturnsLazily((ServiceBusMessage g, DateTimeOffset t , CancellationToken ct) => Task.FromResult(sentMessage = g));
 
             _producer.SendWithDelay(new Message(new MessageHeader(Guid.NewGuid(), "topic", MessageType.MT_NONE), new MessageBody(messageBody, "JSON")), 1);
 
-            _nameSpaceManagerWrapper.Verify(x => x.CreateTopic("topic", null), Times.Once);
+            A.CallTo(() => _nameSpaceManagerWrapper.CreateTopic("topic", null)).MustHaveHappenedOnceExactly();
             Assert.Equal(messageBody, sentMessage.Body.ToArray());
-            _topicClient.Verify(x => x.CloseAsync(), Times.Once);
+            A.CallTo(() => _topicClient.CloseAsync()).MustHaveHappenedOnceExactly();
         }
 
         [Theory]
@@ -164,19 +164,18 @@ public void Once_the_topic_is_created_it_then_does_not_check_if_it_exists_every_
         {
             var messageBody = Encoding.UTF8.GetBytes("A message body");
 
-            _nameSpaceManagerWrapper.Setup(t => t.TopicExists("topic")).Returns(topicExists);
-            _topicClientProvider.Setup(f => f.Get("topic")).Returns(_topicClient.Object);
-            _topicClient.Setup(f => f.ScheduleMessage(It.IsAny<ServiceBusMessage>(), It.IsAny<DateTimeOffset>())).Callback((ServiceBusMessage g, DateTimeOffset d) => { });
+            A.CallTo(() => _nameSpaceManagerWrapper.TopicExists("topic")).Returns(topicExists);
+            A.CallTo(() => _topicClientProvider.Get("topic")).Returns(_topicClient);
 
             _producer.SendWithDelay(new Message(new MessageHeader(Guid.NewGuid(), "topic", MessageType.MT_NONE), new MessageBody(messageBody, "JSON")), 1);
             _producer.SendWithDelay(new Message(new MessageHeader(Guid.NewGuid(), "topic", MessageType.MT_NONE), new MessageBody(messageBody, "JSON")), 1);
 
             if (topicExists == false)
             {
-                _nameSpaceManagerWrapper.Verify(x => x.CreateTopic("topic", null), Times.Once);
+                A.CallTo(() => _nameSpaceManagerWrapper.CreateTopic("topic", null)).MustHaveHappenedOnceExactly();
             }
 
-            _nameSpaceManagerWrapper.Verify(x => x.TopicExists("topic"), Times.Once);
+            A.CallTo(() => _nameSpaceManagerWrapper.TopicExists("topic")).MustHaveHappenedOnceExactly();
         }
 
         [Fact]
@@ -184,10 +183,10 @@ public void When_there_is_an_error_talking_to_servicebus_when_creating_the_topic
         {
             var messageBody = Encoding.UTF8.GetBytes("A message body");
 
-            _nameSpaceManagerWrapper.Setup(t => t.TopicExists("topic")).Throws(new Exception());
+            A.CallTo(() => _nameSpaceManagerWrapper.TopicExists("topic")).Throws(new Exception());
 
             Assert.ThrowsAsync<Exception>(() => _producer.SendWithDelayAsync(new Message(new MessageHeader(Guid.NewGuid(), "topic", MessageType.MT_NONE), new MessageBody(messageBody, "JSON")), 1));
-            _nameSpaceManagerWrapper.Verify(managementClientWrapper => managementClientWrapper.Reset(), Times.Once);
+            A.CallTo(() => _nameSpaceManagerWrapper.Reset()).MustHaveHappenedOnceExactly();
         }
 
 
@@ -196,15 +195,13 @@ public void When_there_is_an_error_getting_a_topic_client_the_connection_for_top
         {
             var messageBody = Encoding.UTF8.GetBytes("A message body");
 
-            _nameSpaceManagerWrapper.Setup(t => t.TopicExists("topic")).Returns(true);
+            A.CallTo(() => _nameSpaceManagerWrapper.TopicExists("topic")).Returns(true);
 
-            _topicClientProvider.SetupSequence(f => f.Get("topic"))
-                .Throws(new Exception())
-                .Returns(_topicClient.Object);
+            A.CallTo(() => _topicClientProvider.Get("topic")).Throws(new Exception()).Once().Then.Returns(_topicClient);
 
-            _producer.SendWithDelay(new Message(new MessageHeader(Guid.NewGuid(), "topic", MessageType.MT_NONE), new MessageBody(messageBody, "JSON")));
+           _producer.SendWithDelay(new Message(new MessageHeader(Guid.NewGuid(), "topic", MessageType.MT_NONE), new MessageBody(messageBody, "JSON")));
 
-            _topicClient.Verify(topicClient => topicClient.SendAsync(It.IsAny<ServiceBusMessage>(), CancellationToken.None), Times.Once);
+            A.CallTo(() => _topicClient.SendAsync(A<ServiceBusMessage>.Ignored, CancellationToken.None)).MustHaveHappenedOnceExactly();
         }
 
         [Fact]
@@ -212,7 +209,7 @@ public void When_the_topic_does_not_exist_and_Missing_is_set_to_Validate_an_exce
         {
             var messageBody = Encoding.UTF8.GetBytes("A message body");
 
-            var producerValidate = new AzureServiceBusMessageProducer(_nameSpaceManagerWrapper.Object, _topicClientProvider.Object, OnMissingChannel.Validate);
+            var producerValidate = new AzureServiceBusMessageProducer(_nameSpaceManagerWrapper, _topicClientProvider, OnMissingChannel.Validate);
 
             Assert.ThrowsAsync<ChannelFailureException>(() => producerValidate.SendAsync(new Message(new MessageHeader(Guid.NewGuid(), "topic", MessageType.MT_NONE), new MessageBody(messageBody, "JSON"))));
         }
diff --git a/tests/Paramore.Brighter.AzureServiceBus.Tests/Paramore.Brighter.AzureServiceBus.Tests.csproj b/tests/Paramore.Brighter.AzureServiceBus.Tests/Paramore.Brighter.AzureServiceBus.Tests.csproj
index f108a41a51..3cacfe9ed4 100644
--- a/tests/Paramore.Brighter.AzureServiceBus.Tests/Paramore.Brighter.AzureServiceBus.Tests.csproj
+++ b/tests/Paramore.Brighter.AzureServiceBus.Tests/Paramore.Brighter.AzureServiceBus.Tests.csproj
@@ -7,9 +7,13 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FakeItEasy" Version="7.4.0" />
+    <PackageReference Include="FakeItEasy.Analyzer.CSharp" Version="6.1.1">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
     <PackageReference Include="FluentAssertions" Version="6.11.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.0" />
-    <PackageReference Include="Moq" Version="4.20.1" />
     <PackageReference Include="xunit" Version="2.5.0" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0">
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>