Test_API_Utilities.cs

Go to the documentation of this file.

using System;
using System.Net;
using System.Security.Authentication;
 
using AnalyzeRe;
using AnalyzeRe.Authentication;
using AnalyzeRe.LossSets;
using AnalyzeRe.Metrics;
using AnalyzeRe.Rest;
using AnalyzeReTesting.Base;
using AnalyzeReTesting.Utilities;
 
using RestSharp;
#if MSTEST
using Microsoft.VisualStudio.TestTools.UnitTesting;
#elif NUNIT
using NUnit.Framework;
using TestClass = NUnit.Framework.TestFixtureAttribute;
using TestMethod = NUnit.Framework.TestAttribute;
using TestCategory = NUnit.Framework.CategoryAttribute;
#endif
 
namespace AnalyzeReTesting.Tests.AnalyzeReAPI
{
    [TestClass]
    public class TestSuite_API_Utilities : BaseServerTestSuite
    {
        private const string TestCategory = "API Utilities";
 
        public TestSuite_API_Utilities()
        {
            AddCommonTestInitializeAction(() =>
            {
                // All tests in this class require a connection.
                if (EnvironmentSettings.RUN_OFFLINE)
                    Assert.Inconclusive("RUN_OFFLINE = true");
            });
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_ValidateResourceId()
        {
            ELTLossSet mock = new ELTLossSet();
            // Test various requests that should check the ID first.
            AssertApi.ExceptionThrown<ArgumentException>(() => mock.Get());
            AssertApi.ExceptionThrown<ArgumentException>(() => mock.Put());
            AssertApi.ExceptionThrown<ArgumentException>(() => mock.PollUntilReady());
            AssertApi.ExceptionThrown<ArgumentException>(() => mock.data.LargeFileUpload(null));
            // POST should go through because no ID is required (but the server will return some other error)
            AssertApi.ExceptionThrown<APIRequestException>(() => mock.Post());
            // If the resource is given an ID, above requests should now work (but the server will now return a NotFound exception)
            mock.id = Samples.Valid_NonExistant_UUID;
            AssertApi.ExceptionThrown<APIRequestException>(() => mock.Get());
 
            // Also test a few of the request methods for views
            ILayerView mock_lv = new LayerView<ILayer>();
            AssertApi.ExceptionThrown<ArgumentException>(() => mock_lv.Get());
            AssertApi.ExceptionThrown<ArgumentException>(() => mock_lv.expected_loss(MetricsOptions.Default));
            AssertApi.ExceptionThrown<ArgumentException>(() => mock_lv.tail_metrics(1, MetricsOptions.Default));
            AssertApi.ExceptionThrown<ArgumentException>(() => mock_lv.tail_metrics_blocking(1, MetricsOptions.Default));
            AssertApi.ExceptionThrown<ArgumentException>(() => mock_lv.window_metrics(ProbabilityWindow.All, MetricsOptions.Default));
            AssertApi.ExceptionThrown<ArgumentException>(() => mock_lv.window_metrics_blocking(ProbabilityWindow.All, MetricsOptions.Default));
            AssertApi.ExceptionThrown<ArgumentException>(() => mock_lv.exceedance_probability(1, ExceedanceProbabilityOptions.Default));
            AssertApi.ExceptionThrown<ArgumentException>(() => mock_lv.co_metrics_blocking(ProbabilityWindow.All, mock_lv.ToReference(), CoMetricsOptions.Default));
            AssertApi.ExceptionThrown<ArgumentException>(() => mock_lv.co_metrics_blocking(ProbabilityWindow.All, mock_lv.ToReference(), CoMetricsOptions.Default));
            AssertApi.ExceptionThrown<ArgumentException>(() => mock_lv.ylt.Get(MetricsOptions.Default));
            AssertApi.ExceptionThrown<ArgumentException>(() => mock_lv.yelt.Get(YELTOptions.Default));
            // Test the legacy back_allocation endpoint
#pragma warning disable 618
            AssertApi.ExceptionThrown<ArgumentException>(() => mock_lv.back_allocations(null));
#pragma warning restore 618
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_Utilities_GetAuthenticationStatus_Authenticated()
        {
            // Test setup will have ensured that authentication credentials have been set up
            Assert.AreEqual(AuthenticationStatus.Authenticated, API.GetAuthenticationStatus());
            Assert.AreEqual(AccessTokenStatus.Valid, API.AuthenticationToken.status);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_Utilities_TryPromptForAuthentication_Authenticated()
        {
            // Test setup will have ensured that authentication credentials have been set up
            // So this method should execute without having any effect.
            API.TryPromptForAuthentication();
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_Utilities_TryHandleAuthenticationErrors_Temp_SSL_Error()
        {
            // When a response comes in with a temporary SSL/TSL error, we expect this method
            // to return "true", indicating that the request should automatically be retried.
            MockResponse mockResponse = MockResponse.Error(
                new WebException("Could not create SSL/TLS secure channel"));
            Assert.IsTrue(API.TryHandleAuthenticationErrors(mockResponse));
            // If, however, this error has happened more than "MaxRequestRetries", it should throw
            AssertApi.ExceptionThrown<AuthenticationException>(
                () => API.TryHandleAuthenticationErrors(mockResponse, API.MaxRequestRetries));
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_Utilities_TryHandleAuthenticationErrors_NoAuthenticationError()
        {
            // When a response is successful, we expect this method to return "false",
            // indicating that there is no authentication related actions to take.
            MockResponse mockResponse = MockResponse.Completed(HttpStatusCode.Accepted);
            Assert.IsFalse(API.TryHandleAuthenticationErrors(mockResponse));
 
            // Similarity, we expect "false" if the response is a non-authentication failure
            IRestResponse authenticatedNotFoundResponse = API.ExecuteRestRequest(
                "non_existant_endpoint", Method.HEAD, returnRawResponse: true);
            Assert.IsFalse(API.TryHandleAuthenticationErrors(authenticatedNotFoundResponse));
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_Utilities_TryHandleAuthenticationErrors_CustomAuthenticationError()
        {
            // We expect the API to raise a particular error message if the user supplied their
            // own authentication header which turned out to be invalid.
            RequestParameters badAuthParameters = new RequestParameters();
            badAuthParameters.AddParameter("Authorization", "BadCredentials", ParameterType.HttpHeader);
            AssertApi.ExceptionThrown<AuthenticationException>(
                () => API.ExecuteRestRequest("", Method.HEAD, badAuthParameters),
                exception => Assert.IsTrue(exception.Message.StartsWith(
                    "The current request included an authentication token (BadCredentials) " +
                    "which was rejected by the server, and which differs from the currently " +
                    "configured default authentication token"),
                    exception.Message));
        }
    }
}