Test_API_HTTPS.cs

Go to the documentation of this file.

using System;
using System.Diagnostics;
using System.IO;
using System.Security.Authentication;
 
using AnalyzeRe;
using AnalyzeRe.Authentication;
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_HTTPS : BaseClientTestSuite
    {
        private const string TestCategory = "HTTPS API Server";
 
        private readonly string _httpsUrl = EnvironmentSettings.API_URL;
 
        #region Test Setup
        public TestSuite_API_HTTPS()
        {
            AddCommonTestInitializeAction(() =>
            {
                // Cannot test different API configurations in parallel with a static API
                // These tests are all disabled because changing the API's authentication settings
                // while tests are running in parallel will cause other running tests to fail
                Assert.Inconclusive("ARE-939 - non-static API");
 
                API.ClearCachedAuthenticationCredentials(_httpsUrl);
            });
            // Purge the automatically cached authentication credentials for the test server.
            AddCommonTestCleanupAction(() => API.ClearCachedAuthenticationCredentials(_httpsUrl));
        }
        #endregion Test Setup
 
        #region Test Valid Credentials
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_BasicAuthenticationToken_Valid()
        {
            API.AuthenticationToken = GetCorrectCredentials();
            TestSuccessfulRequest();
            Assert.AreEqual(AccessTokenStatus.Valid, API.AuthenticationToken.status);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_AuthenticationRequestedEvent_ValidAccessToken()
        {
            API.AuthenticationRequested += ValidAuthenticationRequestedHandler;
            TestSuccessfulRequest();
            Assert.AreEqual(AccessTokenStatus.Valid, API.AuthenticationToken.status);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_AuthenticationRequestedEvent_MultipleHandlers()
        {
            API.AuthenticationRequested += (ref IAccessToken authenticate, string auth) =>
                Console.WriteLine("I'm just an AuthenticationRequested logger.");
            API.AuthenticationRequested += ValidAuthenticationRequestedHandler;
            API.AuthenticationRequested += (ref IAccessToken authenticate, string auth) =>
                Console.WriteLine("I'm just an AuthenticationRequested logger too.");
            TestSuccessfulRequest();
            Assert.AreEqual(AccessTokenStatus.Valid, API.AuthenticationToken.status);
        }
        #endregion Test Valid Credentials
 
        #region Test Invalid AuthenticationToken Credentials
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_BasicAuthenticationToken_Null()
        {
            API.AuthenticationToken = null;
            TestUnauthorizedRequest("The server requires authorization, but no authentication " +
                                    "settings have been configured. Please either handle the " +
                                    "API.AuthenticationRequested event appropriately, or set " +
                                    "the global default AnalyzeRe.API.AuthenticationToken directly.");
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_BasicAuthenticationToken_Invalid()
        {
            API.AuthenticationToken = new BasicAuthenticationToken("bad", "bad");
            Assert.AreEqual(AccessTokenStatus.Unknown, API.AuthenticationToken.status);
            TestUnauthorizedRequest("The server requires authentication, and the current " +
                                    "authentication token " + @"(Basic YmFkOmJhZA==)" +
                                    " was rejected. Please verify the credentials supplied.");
            Assert.AreEqual(AccessTokenStatus.Unauthorized, API.AuthenticationToken.status);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_BasicAuthenticationToken_Empty()
        {
            API.AuthenticationToken = new BasicAuthenticationToken();
            Assert.AreEqual(AccessTokenStatus.Unknown, API.AuthenticationToken.status);
            TestUnauthorizedRequest("The server requires authentication, and the current " +
                                    "authentication token " + @"(Basic )" +
                                    " was rejected. Please verify the credentials supplied.");
            Assert.AreEqual(AccessTokenStatus.Unauthorized, API.AuthenticationToken.status);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_BasicAuthenticationToken_NullUserNamePassword()
        {
            API.AuthenticationToken = new BasicAuthenticationToken(null, null);
            Assert.AreEqual(AccessTokenStatus.Unknown, API.AuthenticationToken.status);
            TestUnauthorizedRequest("The server requires authentication, and the current " +
                                    "authentication token " + @"(Basic Og==)" +
                                    " was rejected. Please verify the credentials supplied.");
            Assert.AreEqual(AccessTokenStatus.Unauthorized, API.AuthenticationToken.status);
        }
        #endregion Test Invalid AuthenticationToken Credentials
 
        #region Test Invalid AuthenticationRequested Event
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_AuthenticationRequestedEvent_Invalid()
        {
            API.AuthenticationRequested += (ref IAccessToken authenticate, string auth) =>
                ((BasicAuthenticationToken)authenticate).GenerateAccessToken("bad", "bad");
            TestUnauthorizedRequest("Request failed after " + API.MaxRequestRetries +
                                    " failed authentication attempts.");
            Assert.AreEqual(AccessTokenStatus.Unauthorized, API.AuthenticationToken.status);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_AuthenticationRequestedEvent_NotHandled()
        {
            TestUnauthorizedRequest("The server requires authorization, but no authentication " +
                                    "settings have been configured. Please either handle the " +
                                    "API.AuthenticationRequested event appropriately, or set " +
                                    "the global default AnalyzeRe.API.AuthenticationToken directly.");
            Assert.IsNull(API.AuthenticationToken);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_AuthenticationRequestedEvent_HandledEmpty()
        {
            API.AuthenticationRequested += (ref IAccessToken authenticate, string auth) => { };
            TestUnauthorizedRequest("The server requires authentication.");
            Assert.IsNull(API.AuthenticationToken);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_AuthenticationRequestedEvent_Exception()
        {
            API.AuthenticationRequested += (ref IAccessToken authenticate, string auth) =>
                { throw new Exception("I don't know what I'm doing"); };
            TestUnauthorizedRequest("Error while invoking the AuthenticationRequested event: " +
                                    "I don't know what I'm doing");
            Assert.IsNull(API.AuthenticationToken);
        }
        #endregion Test Invalid AuthenticationRequested Event
 
        #region Test GetAuthenticationStatus
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_GetAuthenticationStatus_AuthenticationRequired()
        {
            API.AuthenticationToken = null;
            Assert.AreEqual(AuthenticationStatus.AuthenticationRequired, API.GetAuthenticationStatus());
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_GetAuthenticationStatus_Authenticated()
        {
            API.AuthenticationToken = GetCorrectCredentials();
            Assert.AreEqual(AuthenticationStatus.Authenticated, API.GetAuthenticationStatus());
            Assert.AreEqual(AccessTokenStatus.Valid, API.AuthenticationToken.status);
        }
 
        [TestMethod, TestCategory(TestCategory), TestCategory("Skipped")]
        public void Test_API_HTTPS_Server_GetAuthenticationStatus_NoAuthenticationRequired()
        {
            // With API v1, we only support HTTPS & BasicAuth. This test can be removed when
            // AuthenticationStatus.NoAuthenticationRequired is eliminated as a possible enumeration value.
            Skip.Indefinitely("The default test URL requires authentication, so we " +
                "cannot test the response when a server doesn't require authentication.");
            API.ServerURL = _httpsUrl;
            Assert.AreEqual(AuthenticationStatus.NoAuthenticationRequired, API.GetAuthenticationStatus());
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_GetAuthenticationStatus_InvalidCredentials()
        {
            API.AuthenticationToken = new BasicAuthenticationToken("bad", "bad");
            Assert.AreEqual(AuthenticationStatus.InvalidCredentials, API.GetAuthenticationStatus());
            Assert.AreEqual(AccessTokenStatus.Unauthorized, API.AuthenticationToken.status);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_GetAuthenticationStatus_Error()
        {
            API.ServerURL = "Invalid";
            Assert.AreEqual(AuthenticationStatus.Error, API.GetAuthenticationStatus());
        }
        #endregion Test GetAuthenticationStatus
 
        #region Test Credential Caching
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_Credentials_Cached()
        {
            API.AuthenticationRequested += ValidAuthenticationRequestedHandler;
            TestSuccessfulRequest();
            API.AuthenticationRequested -= ValidAuthenticationRequestedHandler;
            Assert.AreEqual(AccessTokenStatus.Valid, API.AuthenticationToken.status);
            // Reset the server URL. The API will automatically reset the AuthenticationToken as well.
            API.ServerURL = null;
            Assert.IsNull(API.AuthenticationToken);
            // ReSharper disable HeuristicUnreachableCode (API alters AuthenticationToken)
            API.ServerURL = _httpsUrl;
            Assert.IsNotNull(API.AuthenticationToken);
            Assert.AreEqual(AccessTokenStatus.Valid, API.AuthenticationToken.status);
            TestSuccessfulRequest();
            // ReSharper restore HeuristicUnreachableCode
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_CachedCredentialsCleared()
        {
            API.AuthenticationRequested += ValidAuthenticationRequestedHandler;
            TestSuccessfulRequest();
            API.AuthenticationRequested -= ValidAuthenticationRequestedHandler;
            Assert.AreEqual(AccessTokenStatus.Valid, API.AuthenticationToken.status);
            // Reset the server URL. The API will automatically reset the AuthenticationToken as well.
            API.ServerURL = null;
            Assert.IsNull(API.AuthenticationToken);
            // ReSharper disable HeuristicUnreachableCode (API alters AuthenticationToken)
            // Same as previous test but now we clear the cache:
            API.ClearCachedAuthenticationCredentials(_httpsUrl);
            API.ServerURL = _httpsUrl;
            Assert.IsNull(API.AuthenticationToken);
            TestUnauthorizedRequest("The server requires authorization, but no authentication " +
                                    "settings have been configured. Please either handle the " +
                                    "API.AuthenticationRequested event appropriately, or set " +
                                    "the global default AnalyzeRe.API.AuthenticationToken directly.");
            // ReSharper restore HeuristicUnreachableCode
        }
 
        #endregion Test Credential Caching
 
        #region Miscellaneous Tests
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_Active()
        {
            Assert.IsTrue(API.IsAReServerActive(_httpsUrl),
                          "No active server found at " + _httpsUrl);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_AuthenticationRequestedEvent_GetStream()
        {
            // First, set up the valid credentials
            API.AuthenticationRequested += ValidAuthenticationRequestedHandler;
            // Now inject a resource with data
            EventCatalog eventCatalog = Samples.EventCatalog.Posted;
 
            // Next, delete the credentials so that the next request is unauthorized
            API.AuthenticationToken = null;
            void StreamReader(Stream stream) =>
                Console.WriteLine("Stream contained:\n" + new StreamReader(stream).ReadToEnd());
            void TestGetStream() => eventCatalog.data.GetStream(StreamReader);
            // Now request a stream, expecting to get an authentication error
            AssertApi.ExceptionThrown<APIRequestException>(TestGetStream, ex => Assert.AreEqual(
                "The initial request could not be completed due to an authentication error. " +
                "Please reset the stream and try again."
                , ex.Message));
            // This should still have fired the event, setting up credentials for us,
            // but these credentials haven't been validated yet.
            Assert.IsNotNull(API.AuthenticationToken);
            Assert.AreEqual(AccessTokenStatus.Unauthorized, API.AuthenticationToken.status);
            // We should be authenticated now, so a second call shouldn't raise an exception
            TestGetStream();
            Assert.AreEqual(AccessTokenStatus.Valid, API.AuthenticationToken.status);
 
            TestSuccessfulRequest();
        }
        #endregion Miscellaneous Tests
 
        #region Test Override Authentication
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_OverrideAuthentication_Valid()
        {
            API.GetResourceList<AnalysisProfile>(new[]{ new Parameter
            {
                Name = "Authorization",
                Value = GetCorrectCredentials().ToString(),
                Type = ParameterType.HttpHeader
            }});
            // The global default authentication token should still not be set
            Assert.IsNull(API.AuthenticationToken);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_OverrideAuthentication_Invalid_NoDefaultAuth()
        {
            AssertApi.ExceptionThrown<AuthenticationException>(() =>
                API.GetResourceList<AnalysisProfile>(new[]{ new Parameter
                {
                    Name = "Authorization",
                    Value = "bad",
                    Type = ParameterType.HttpHeader
                }}),
                ex => Assert.AreEqual(
                    "The current request included an authentication token (bad) " +
                    "which was rejected by the server. Either correct the \"Authorization\" " +
                    "header parameter supplied to this request, or exclude it entirely and use " +
                    "the 'API.AuthenticationRequested' event or 'API.AuthenticationToken' to " +
                    "automatically handle authentication for Analyze Re API requests."
                , ex.Message));
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_OverrideAuthentication_Invalid_MatchingDefaultAuth()
        {
            BasicAuthenticationToken token = new BasicAuthenticationToken("bad", "bad");
            API.AuthenticationToken = token;
            AssertApi.ExceptionThrown<AuthenticationException>(() =>
                API.GetResourceList<AnalysisProfile>(new[]{ new Parameter
                {
                    Name = "Authorization",
                    Value = token.ToString(),
                    Type = ParameterType.HttpHeader
                }}),
                ex => Assert.AreEqual(
                    "The current request included an authentication token (Basic YmFkOmJhZA==) " +
                    "which was rejected by the server. Either correct the \"Authorization\" " +
                    "header parameter supplied to this request, or exclude it entirely and use " +
                    "the 'API.AuthenticationRequested' event or 'API.AuthenticationToken' to " +
                    "automatically handle authentication for Analyze Re API requests."
                , ex.Message));
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_HTTPS_Server_OverrideAuthentication_Invalid_NotMatchingDefaultAuth()
        {
            API.AuthenticationToken = GetCorrectCredentials();
            AssertApi.ExceptionThrown<AuthenticationException>(() =>
                API.GetResourceList<AnalysisProfile>(new[]{ new Parameter
                {
                    Name = "Authorization",
                    Value = "bad",
                    Type = ParameterType.HttpHeader
                }}),
                ex => Assert.AreEqual(
                    "The current request included an authentication token (bad) which was rejected " +
                    "by the server, and which differs from the currently configured default " +
                    "authentication token (" + GetCorrectCredentials().ToString() + "). Either " +
                    "correct the \"Authorization\" header parameter supplied to this request, " +
                    "or exclude it entirely and the default authentication token will be used."
                , ex.Message));
        }
        #endregion Test Override Authentication
 
        #region Helper Methods
        private void ValidAuthenticationRequestedHandler(ref IAccessToken authenticate, string auth)
        {
            ((BasicAuthenticationToken)authenticate).GenerateAccessToken(
                EnvironmentSettings.HTTPS_USER, EnvironmentSettings.HTTPS_PASSWORD);
        }
 
        public IAccessToken GetCorrectCredentials()
        {
            BasicAuthenticationToken token = new BasicAuthenticationToken(
                EnvironmentSettings.HTTPS_USER, EnvironmentSettings.HTTPS_PASSWORD);
            return token;
        }
 
        public void TestSuccessfulRequest()
        {
            API.GetResourceList<AnalysisProfile>();
        }
 
        public void TestUnauthorizedRequest(string expectedMessage)
        {
            AssertApi.ExceptionThrown<AuthenticationException>(
                () => API.GetResourceList<AnalysisProfile>(), ex =>
                {
                    Assert.AreEqual(expectedMessage, ex.Message);
                    Debug.WriteLine("Caught expected exception: " + ex);
                });
        }
        #endregion Helper Methods
    }
}