private async Task SendMessageAsync(Mocks.CloudBlobStorageProviderMock cloudStorage, Mocks.InboxHttpHandlerMock inboxMock, CryptoSettings senderCrypto, OwnEndpoint senderEndpoint, Endpoint receiverEndpoint)
        {
            Requires.NotNull(cloudStorage, "cloudStorage");
            Requires.NotNull(senderCrypto, "senderCrypto");
            Requires.NotNull(senderEndpoint, "senderEndpoint");
            Requires.NotNull(receiverEndpoint, "receiverEndpoint");

            var httpHandler = new Mocks.HttpMessageHandlerMock();

            cloudStorage.AddHttpHandler(httpHandler);

            inboxMock.Register(httpHandler);

            var sentMessage = Valid.Message;

            var channel = new Channel()
            {
                HttpClient = new HttpClient(httpHandler),
                CloudBlobStorage = cloudStorage,
                CryptoServices = senderCrypto,
                Endpoint = senderEndpoint,
                Logger = this.logger,
            };

            await channel.PostAsync(sentMessage, new[] { receiverEndpoint }, Valid.ExpirationUtc);
        }

        private async Task ReceiveMessageAsync(Mocks.CloudBlobStorageProviderMock cloudStorage, Mocks.InboxHttpHandlerMock inboxMock, CryptoSettings receiverCrypto, OwnEndpoint receiverEndpoint)
        {
            Requires.NotNull(cloudStorage, "cloudStorage");
            Requires.NotNull(receiverCrypto, "receiverCrypto");
            Requires.NotNull(receiverEndpoint, "receiverEndpoint");

            var httpHandler = new Mocks.HttpMessageHandlerMock();

            cloudStorage.AddHttpHandler(httpHandler);
            inboxMock.Register(httpHandler);

            var channel = new Channel
            {
                HttpClient = new HttpClient(httpHandler),
                HttpClientLongPoll = new HttpClient(httpHandler),
                CloudBlobStorage = cloudStorage,
                CryptoServices = receiverCrypto,
                Endpoint = receiverEndpoint,
                Logger = this.logger,
            };

            var messages = await channel.ReceiveAsync();
            Assert.Equal(1, messages.Count);
            Assert.Equal(Valid.Message, messages[0].Payload);
        }

        private async Task TestGoodDataAsync(string[] messageData, string expectedData, bool eightBitClean)
        {
            Mocks mocks = new Mocks();

            if (eightBitClean)
            {
                mocks.Connection.SetupGet(c => c.ReaderEncoding).Returns(Encoding.UTF8);
            }

            MemoryMessage.Builder messageBuilder = new MemoryMessage.Builder();
            mocks.Connection.SetupGet(c => c.CurrentMessage).Returns(messageBuilder);
            mocks.ServerBehaviour.Setup(b => b.GetMaximumMessageSize(It.IsAny<IConnection>())).Returns((long?)null);

            int messageLine = 0;
            mocks.Connection.Setup(c => c.ReadLineAsync()).Returns(() => Task.FromResult(messageData[messageLine++]));

            DataVerb verb = new DataVerb();
            await verb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("DATA"));

            mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.StartMailInputEndWithDot);
            mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.OK);

            using (StreamReader dataReader = new StreamReader(messageBuilder.GetData(), eightBitClean ? Encoding.UTF8 : new ASCIISevenBitTruncatingEncoding()))
            {
                Assert.Equal(expectedData, dataReader.ReadToEnd());
            }
        }

        public void ForceBuild_when_using_weburl_should_call_api_with_parameters()
        {
            Mocks mocks = new Mocks();
            SetupDefaultMockState(mocks);

            var target = CreateTestTarget(mocks);

            target.WebURL = new Uri(@"http://test");

            target.Initialize(new BuildServer(), "TestProjectName", new Settings());

            Dictionary<string, string> parameters = new Dictionary<string, string>()
            {
                {"SomeParameter", "SomeValue"}
            };

            string userName = "TestUser";

            // Act
            target.ForceBuild("", parameters, userName);

            // Assert
            mocks.MockJenkinsApi
                .Verify(x => x.ForceBuild(It.IsAny<Uri>(),
                    parameters),
                    Times.Once);
        }

 public void BlogCategory()
 {
     var category = new CategoryModel { Id = 1, Title = "Test Category", Slug = "test-category" };
     var mocks = new Mocks();
     Assert.AreEqual("/blog/category/test-category", BlogUrlHelperExtensions.BlogCategory(mocks.UrlHelper, category, 1));
     Assert.AreEqual("/blog/category/test-category/page-2", BlogUrlHelperExtensions.BlogCategory(mocks.UrlHelper, category, 2));
 }

        public async Task Process_RecordsClientName()
        {
            Mocks mocks = new Mocks();
            EhloVerb ehloVerb = new EhloVerb();
            await ehloVerb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("EHLO foobar"));

            mocks.Session.VerifySet(s => s.ClientName = "foobar");
        }

 public void ShouldProperlyInitializeMembers()
 {
     var mocks = new Mocks();
     var repl = GetRepl(mocks);
     repl.FileSystem.ShouldEqual(mocks.FileSystem.Object);
     repl.ScriptEngine.ShouldEqual(mocks.ScriptEngine.Object);
     repl.Console.ShouldEqual(mocks.Console.Object);
 }

		public void ExecuteWithLargerStackIfRequiredWithNoNewThread()
		{
			var mocks = new Mocks();
			var environment = mocks.CreateReactEnvironment();

			environment.ExecuteWithLargerStackIfRequired<int>("1+1");
			mocks.Engine.Verify(x => x.Evaluate<int>("1+1"));
		}

		public void ExecuteWithLargerStackIfRequiredWithNoNewThread()
		{
			var mocks = new Mocks();
			var environment = mocks.CreateReactEnvironment();

			environment.ExecuteWithLargerStackIfRequired<int>("foo");
			mocks.Engine.Verify(x => x.CallFunction<int>("foo"), Times.Exactly(1));
		}

		public void ShouldNotTransformJsxIfNoAnnotationPresent()
		{
			var mocks = new Mocks();
			var environment = mocks.CreateReactEnvironment();
			var input = "<div>Hello World</div>";

			var output = environment.TransformJsx(input);
			Assert.Equal(input, output);
		}

		public void Init()
		{
			_left = new AGSEdge { Value = 100 };
			_right = new AGSEdge { Value = 200 };
			_top = new AGSEdge  { Value = 200 };
			_bottom = new AGSEdge { Value = 100 };
			_edges = new AGSEdges (_left, _right, _top, _bottom);
			_mocks = Mocks.Init();
		}

        public async Task Process_NoArguments_Accepted()
        {
            Mocks mocks = new Mocks();
            EhloVerb ehloVerb = new EhloVerb();
            await ehloVerb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("EHLO"));
            mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.OK);

            mocks.Session.VerifySet(s => s.ClientName = "");
        }

        public async Task Noop()
        {
            Mocks mocks = new Mocks();

            NoopVerb verb = new NoopVerb();
            await verb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("NOOP"));

            mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.OK);
        }

        public async Task Quit_RespondsWithClosingChannel()
        {
            Mocks mocks = new Mocks();

            QuitVerb quitVerb = new QuitVerb();
            await quitVerb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("QUIT"));

            mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.ClosingTransmissionChannel);
        }

        public void Noop()
        {
            Mocks mocks = new Mocks();

            NoopVerb verb = new NoopVerb();
            verb.Process(mocks.Connection.Object, new SmtpCommand("NOOP"));

            mocks.VerifyWriteResponse(StandardSmtpResponseCode.OK);
        }

            public TheInitializeMethod()
            {
                _tempPath = Path.GetTempPath();

                _mocks = new Mocks();
                _repl = GetRepl(_mocks);
                _mocks.FileSystem.Setup(x => x.CurrentDirectory).Returns(_tempPath);
                var paths = new[] { Path.Combine(_tempPath, "path" ) };
                _repl.Initialize(paths, new[] { _mocks.ScriptPack.Object });
            }

        public async Task ProcessAsync_UnregisteredSubCommand_ErrorResponse()
        {
            Mocks mocks = new Mocks();

            Mock<VerbWithSubCommands> verbWithSubCommands = new Mock<VerbWithSubCommands>() { CallBase = true };

            await verbWithSubCommands.Object.ProcessAsync(mocks.Connection.Object, new SmtpCommand("VERB SUBCOMMAND1"));

            mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.CommandParameterNotImplemented);
        }

        public async Task SayHeloTwice_ReturnsError()
        {
            Mocks mocks = new Mocks();
            mocks.Session.SetupGet(s => s.ClientName).Returns("already.said.helo");

            HeloVerb verb = new HeloVerb();
            await verb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("HELO foo.blah"));

            mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.BadSequenceOfCommands);
        }

        public async Task SayHelo()
        {
            Mocks mocks = new Mocks();

            HeloVerb verb = new HeloVerb();
            await verb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("HELO foo.blah"));

            mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.OK);
            mocks.Session.VerifySet(s => s.ClientName = "foo.blah");
        }

        public async Task ProcessAsync()
        {
            Mocks mocks = new Mocks();

            RsetVerb verb = new RsetVerb();
            await verb.ProcessAsync(mocks.Connection.Object, new SmtpCommand("RSET"));

            mocks.VerifyWriteResponseAsync(StandardSmtpResponseCode.OK);
            mocks.Connection.Verify(c => c.AbortMessage());
        }