CdmHttpClientTest.cs

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.

namespace Microsoft.CommonDataModel.ObjectModel.Tests.Utilities.Network
{
    using Microsoft.CommonDataModel.ObjectModel.Tests.HttpClient;
    using Microsoft.CommonDataModel.ObjectModel.Utilities.Network;
    using Microsoft.VisualStudio.TestTools.UnitTesting;
    using System;
    using System.Net;
    using System.Net.Http;
    using System.Threading;
    using System.Threading.Tasks;
    using FluentAssertions;
    using Microsoft.CommonDataModel.ObjectModel.Utilities;
    using Microsoft.CommonDataModel.ObjectModel.Cdm;

    [TestClass]
    public class CdmHttpClientTest
    {
        private int requestsExecutionCounter = 0;
        
        /// <summary>
        /// The path between TestDataPath and TestName.
        /// </summary>
        private readonly string testsSubpath = "Utilities";

        /// <summary>
        /// Dummy value used for correlation ID testing.
        /// </summary>
        private readonly string DummyCorrelationId = "12345";

        /// <summary>
        /// Declare a blackhole callback. We're focusing on event recorder, don't care about output going to the standard log stream.
        /// </summary>
        private readonly EventCallback eventCallback = new EventCallback
        {
            Invoke = (level, message) =>
            {
                // NOOP
            }
        };


        private async Task<HttpResponseMessage> CompleteResponseMethod(HttpRequestMessage request, CancellationToken token)
        {
            if (request.RequestUri.ToString() == "https://www.example.com/folder1")
            {
                var responseMessage = new HttpResponseMessage(HttpStatusCode.OK)
                {
                    Content = new StringContent("REPLY1")
                };

                return await Task.FromResult(responseMessage);
            }
            else
            {
                throw new HttpRequestException();
            }
        }

        private async Task<HttpResponseMessage> DelayedResponseMethod(HttpRequestMessage request, CancellationToken token)
        {
            var waitTime = requestsExecutionCounter == 0 ? 4 : 2;
            requestsExecutionCounter++;

            var cancelled = token.WaitHandle.WaitOne(TimeSpan.FromSeconds(waitTime));

            if (cancelled)
            {
                throw new TaskCanceledException("The operation was canceled.");
            }

            var responseMessage = new HttpResponseMessage(HttpStatusCode.OK)
            {
                Content = new StringContent("REPLY2")
            };

            return await Task.FromResult(responseMessage);
        }

        /// <summary>
        /// Testing for a result returned immediatelly.
        /// </summary>
        [TestMethod]
        public async Task TestResultReturnedFirstTime()
        {
            using (var cdmHttpClient = new CdmHttpClient("https://www.example.com", new CdmHttpMessageHandlerStub(CompleteResponseMethod)))
            {
                var cdmHttpRequest = new CdmHttpRequest("/folder1")
                {
                    Timeout = TimeSpan.FromSeconds(5),
                    MaximumTimeout = TimeSpan.FromSeconds(9)
                };

                var result = await cdmHttpClient.SendAsync(cdmHttpRequest, null);

                var content = await result.Content.ReadAsStringAsync();

                Assert.AreEqual("REPLY1", content);
            }
        }

        /// <summary>
        /// Testing for a result returned immediatelly when a corpus is defined
        /// </summary>
        [TestMethod]
        public async Task TestResultReturnedFirstTimeWithCorpus()
        {
            CdmCorpusDefinition corpus = TestHelper.GetLocalCorpus(testsSubpath, "TestHttpClient");
            corpus.SetEventCallback(eventCallback, CdmStatusLevel.Warning, DummyCorrelationId);

            using (var cdmHttpClient = new CdmHttpClient("https://www.example.com", new CdmHttpMessageHandlerStub(CompleteResponseMethod)))
            {
                var cdmHttpRequest = new CdmHttpRequest("/folder1")
                {
                    Timeout = TimeSpan.FromSeconds(5),
                    MaximumTimeout = TimeSpan.FromSeconds(9)
                };

                var result = await cdmHttpClient.SendAsync(cdmHttpRequest, null, corpus.Ctx);

                var content = await result.Content.ReadAsStringAsync();

                Assert.AreEqual("REPLY1", content);
            }
        }

        /// <summary>
        /// Testing for an HTTP exception when a wrong path is provided.
        /// </summary>
        [TestMethod]
        public void TestResultHttpExceptionZeroRetry()
        {
            using (var cdmHttpClient = new CdmHttpClient("https://www.example1.com", new CdmHttpMessageHandlerStub(CompleteResponseMethod)))
            {
                var cdmHttpRequest = new CdmHttpRequest("/folder1")
                {
                    Timeout = TimeSpan.FromSeconds(5),
                    MaximumTimeout = TimeSpan.FromSeconds(9)
                };

                Func<Task> func = async () => await cdmHttpClient.SendAsync(cdmHttpRequest, null);

                func.Should().Throw<HttpRequestException>();
            }
        }

        /// <summary>
        /// Testing for a timeout.
        /// </summary>
        [TestMethod]
        public void TestTimeout()
        {
            using (var cdmHttpClient = new CdmHttpClient("https://www.example.com", new CdmHttpMessageHandlerStub(DelayedResponseMethod)))
            {
                var cdmHttpRequest = new CdmHttpRequest("/folder2")
                {
                    Timeout = TimeSpan.FromSeconds(3),
                    MaximumTimeout = TimeSpan.FromSeconds(150),
                    NumberOfRetries = 0
                };

                Func<Task> func = async () => await cdmHttpClient.SendAsync(cdmHttpRequest, DefaultGetWaitTime);

                func.Should().Throw<CdmTimedOutException>();
            }   
        }

        /// <summary>
        /// Testing for a timeout multiple times until the number of retries is exceeded.
        /// </summary>
        [TestMethod]
        public void TestTimeoutMultipleTimes()
        {
            using (var cdmHttpClient = new CdmHttpClient("https://www.example.com", new CdmHttpMessageHandlerStub(DelayedResponseMethod)))
            {
                var cdmHttpRequest = new CdmHttpRequest("/folder2")
                {
                    Timeout = TimeSpan.FromSeconds(1),
                    MaximumTimeout = TimeSpan.FromSeconds(150),
                    NumberOfRetries = 3
                };

                Func<Task> func = async () => await cdmHttpClient.SendAsync(cdmHttpRequest, DefaultGetWaitTime);

                func.Should().Throw<CdmNumberOfRetriesExceededException>();
            }
        }

        /// <summary>
        /// Testing for a maximum timeout.
        /// </summary>
        [TestMethod]
        public void TestMaximumTimeout()
        {
            using (var cdmHttpClient = new CdmHttpClient("https://www.example.com", new CdmHttpMessageHandlerStub(DelayedResponseMethod)))
            {
                var cdmHttpRequest = new CdmHttpRequest("/folder2")
                {
                    Timeout = TimeSpan.FromSeconds(1),
                    MaximumTimeout = TimeSpan.FromSeconds(3),
                    NumberOfRetries = 2
                };

                Func<Task> func = async () => await cdmHttpClient.SendAsync(cdmHttpRequest, DefaultGetWaitTime);

                func.Should().Throw<CdmTimedOutException>("Maximum timeout exceeded.");
            }
        }

        /// <summary>
        /// Testing for a timeout then success.
        /// </summary>
        [TestMethod]
        public async Task TestTimeoutThenSuccessMultipleRetries()
        {
            using (var cdmHttpClient = new CdmHttpClient("https://www.example.com", new CdmHttpMessageHandlerStub(DelayedResponseMethod)))
            {
                var cdmHttpRequest = new CdmHttpRequest("/folder2")
                {
                    Timeout = TimeSpan.FromSeconds(3),
                    MaximumTimeout = TimeSpan.FromSeconds(20),
                    NumberOfRetries = 3
                };

                var result = await cdmHttpClient.SendAsync(cdmHttpRequest, this.DefaultGetWaitTime);

                var content = await result.Content.ReadAsStringAsync();

                Assert.AreEqual("REPLY2", content);
            }    
        }

        private TimeSpan? DefaultGetWaitTime(CdmHttpResponse response, bool hasFailed, int retryNumber)
        {
            if (response != null && response.IsSuccessful && !hasFailed)
            {
                return null;
            }
            else
            {
                Random random = new Random();

                // Default wait time will be using exponential backoff with default shortest wait time.
                double waitTime = random.Next(1 << retryNumber) * 500;
                return TimeSpan.FromMilliseconds(waitTime);
            }
        }

    }
}