MethodNotAllowedExceptionTests.cs


using Juhta.Net.WebApi.Exceptions.ClientErrorExceptions;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Newtonsoft.Json;
using System.Net;

namespace Juhta.Net.WebApi.Exceptions.Tests.ClientErrors
{
    [TestClass]
    public class MethodNotAllowedExceptionTests : WebApiExceptionTests
    {
        #region Test Methods

        [TestMethod]
        public void ThrowAndSerialize_MethodNotAllowedException1_ShouldReturn()
        {
            ClientErrorResponse clientErrorResponse1, clientErrorResponse2;
            MethodNotAllowedException exception1 = null, exception2 = null;

            try
            {
                throw new MethodNotAllowedException();
            }

            catch (MethodNotAllowedException ex)
            {
                AssertException(
                    ex,
                    "ThrowAndSerialize_MethodNotAllowedException1_ShouldReturn",
                    null,
                    "Exception of type 'Juhta.Net.WebApi.Exceptions.ClientErrorExceptions.MethodNotAllowedException' was thrown.",
                    HttpStatusCode.MethodNotAllowed
                );

                clientErrorResponse1 = ex.ToClientErrorResponse();

                exception1 = ex;
            }

            clientErrorResponse2 = JsonConvert.DeserializeObject<ClientErrorResponse>(JsonConvert.SerializeObject(clientErrorResponse1));

            try
            {
                clientErrorResponse2.Throw();
            }

            catch (MethodNotAllowedException ex)
            {
                exception2 = ex;
            }

            AssertExceptions(exception1, exception2);
        }

        [TestMethod]
        public void ThrowAndSerialize_MethodNotAllowedException2_ShouldReturn()
        {
            ClientErrorResponse clientErrorResponse1, clientErrorResponse2;
            MethodNotAllowedException exception1 = null, exception2 = null;

            try
            {
                throw new MethodNotAllowedException(ErrorCode.InvalidOrderNumber);
            }

            catch (MethodNotAllowedException ex)
            {
                AssertException(
                    ex,
                    "ThrowAndSerialize_MethodNotAllowedException2_ShouldReturn",
                    ErrorCode.InvalidOrderNumber.ToString(),
                    "Exception of type 'Juhta.Net.WebApi.Exceptions.ClientErrorExceptions.MethodNotAllowedException' was thrown.",
                    HttpStatusCode.MethodNotAllowed
                );

                clientErrorResponse1 = ex.ToClientErrorResponse();

                exception1 = ex;
            }

            clientErrorResponse2 = JsonConvert.DeserializeObject<ClientErrorResponse>(JsonConvert.SerializeObject(clientErrorResponse1));

            try
            {
                clientErrorResponse2.Throw();
            }

            catch (MethodNotAllowedException ex)
            {
                exception2 = ex;
            }

            AssertExceptions(exception1, exception2);
        }

        [TestMethod]
        public void ThrowAndSerialize_MethodNotAllowedException3_ShouldReturn()
        {
            ClientErrorResponse clientErrorResponse1, clientErrorResponse2;
            MethodNotAllowedException exception1 = null, exception2 = null;

            try
            {
                throw new MethodNotAllowedException("MethodNotAllowedException Specified order number is invalid.");
            }

            catch (MethodNotAllowedException ex)
            {
                AssertException(
                    ex,
                    "ThrowAndSerialize_MethodNotAllowedException3_ShouldReturn",
                    null,
                    "MethodNotAllowedException Specified order number is invalid.",
                    HttpStatusCode.MethodNotAllowed
                );

                clientErrorResponse1 = ex.ToClientErrorResponse();

                exception1 = ex;
            }

            clientErrorResponse2 = JsonConvert.DeserializeObject<ClientErrorResponse>(JsonConvert.SerializeObject(clientErrorResponse1));

            try
            {
                clientErrorResponse2.Throw();
            }

            catch (MethodNotAllowedException ex)
            {
                exception2 = ex;
            }

            AssertExceptions(exception1, exception2);
        }

        [TestMethod]
        public void ThrowAndSerialize_MethodNotAllowedException4_ShouldReturn()
        {
            ClientErrorResponse clientErrorResponse1, clientErrorResponse2;
            MethodNotAllowedException exception1 = null, exception2 = null;

            try
            {
                throw new MethodNotAllowedException(ErrorCode.InvalidOrderNumber, "MethodNotAllowedException Specified order number is invalid.");
            }

            catch (MethodNotAllowedException ex)
            {
                AssertException(
                    ex,
                    "ThrowAndSerialize_MethodNotAllowedException4_ShouldReturn",
                    ErrorCode.InvalidOrderNumber.ToString(),
                    "MethodNotAllowedException Specified order number is invalid.",
                    HttpStatusCode.MethodNotAllowed
                );

                clientErrorResponse1 = ex.ToClientErrorResponse();

                exception1 = ex;
            }

            clientErrorResponse2 = JsonConvert.DeserializeObject<ClientErrorResponse>(JsonConvert.SerializeObject(clientErrorResponse1));

            try
            {
                clientErrorResponse2.Throw();
            }

            catch (MethodNotAllowedException ex)
            {
                exception2 = ex;
            }

            AssertExceptions(exception1, exception2);
        }

        [TestMethod]
        public void ThrowAndSerialize_MethodNotAllowedException5_ShouldReturn()
        {
            ClientError clientError;
            ClientErrorResponse clientErrorResponse1, clientErrorResponse2;
            MethodNotAllowedException exception1 = null, exception2 = null;

            try
            {
                clientError = new ClientError{Code = "MyApiErrorCode.XYZ", Message = "Error XYZ occurred.", Field = "FormX.FieldY", HelpUrl = "http://juhta.net"};

                throw new MethodNotAllowedException(clientError);
            }

            catch (MethodNotAllowedException ex)
            {
                AssertException(
                    ex,
                    "ThrowAndSerialize_MethodNotAllowedException5_ShouldReturn",
                    HttpStatusCode.MethodNotAllowed,
                    "MyApiErrorCode.XYZ",
                    "Error XYZ occurred.",
                    "FormX.FieldY",
                    "http://juhta.net"
                );

                clientErrorResponse1 = ex.ToClientErrorResponse();

                exception1 = ex;
            }

            clientErrorResponse2 = JsonConvert.DeserializeObject<ClientErrorResponse>(JsonConvert.SerializeObject(clientErrorResponse1));

            try
            {
                clientErrorResponse2.Throw();
            }

            catch (MethodNotAllowedException ex)
            {
                exception2 = ex;
            }

            AssertExceptions(exception1, exception2);
        }

        [TestMethod]
        public void ThrowAndSerialize_MethodNotAllowedException6_ShouldReturn()
        {
            ClientError clientError1, clientError2;
            ClientErrorResponse clientErrorResponse1, clientErrorResponse2;
            MethodNotAllowedException exception1 = null, exception2 = null;

            try
            {
                clientError1 = new ClientError{Code = "MyApiErrorCode.XYZ1", Message = "Error XYZ1 occurred.", Field = "FormX.FieldY1", HelpUrl = "http://juhta.net/errorxyz1"};

                clientError2 = new ClientError{Code = "MyApiErrorCode.XYZ2", Message = "Error XYZ2 occurred.", Field = "FormX.FieldY2", HelpUrl = "http://juhta.net/errorxyz2"};

                throw new MethodNotAllowedException(new ClientError[]{clientError1, clientError2});
            }

            catch (MethodNotAllowedException ex)
            {
                AssertException(
                    ex,
                    "ThrowAndSerialize_MethodNotAllowedException6_ShouldReturn",
                    HttpStatusCode.MethodNotAllowed,
                    "MyApiErrorCode.XYZ1",
                    "Error XYZ1 occurred.",
                    "FormX.FieldY1",
                    "http://juhta.net/errorxyz1",
                    "MyApiErrorCode.XYZ2",
                    "Error XYZ2 occurred.",
                    "FormX.FieldY2",
                    "http://juhta.net/errorxyz2"
                );

                clientErrorResponse1 = ex.ToClientErrorResponse();

                exception1 = ex;
            }

            clientErrorResponse2 = JsonConvert.DeserializeObject<ClientErrorResponse>(JsonConvert.SerializeObject(clientErrorResponse1));

            try
            {
                clientErrorResponse2.Throw();
            }

            catch (MethodNotAllowedException ex)
            {
                exception2 = ex;
            }

            AssertExceptions(exception1, exception2);
        }

        [TestMethod]
        public void ThrowAndSerialize_MethodNotAllowedException7_ShouldReturn()
        {
            ClientErrorResponse clientErrorResponse1, clientErrorResponse2;
            MethodNotAllowedException exception1 = null, exception2 = null;

            try
            {
                throw new MethodNotAllowedException(ErrorCode.InvalidOrderNumber, Field.CustomerName);
            }

            catch (MethodNotAllowedException ex)
            {
                AssertException(
                    ex,
                    "ThrowAndSerialize_MethodNotAllowedException7_ShouldReturn",
                    HttpStatusCode.MethodNotAllowed,
                    ErrorCode.InvalidOrderNumber.ToString(),
                    null,
                    Field.CustomerName.ToString(),
                    null
                );

                clientErrorResponse1 = ex.ToClientErrorResponse();

                exception1 = ex;
            }

            clientErrorResponse2 = JsonConvert.DeserializeObject<ClientErrorResponse>(JsonConvert.SerializeObject(clientErrorResponse1));

            try
            {
                clientErrorResponse2.Throw();
            }

            catch (MethodNotAllowedException ex)
            {
                exception2 = ex;
            }

            AssertExceptions(exception1, exception2);
        }

        [TestMethod]
        public void ThrowAndSerialize_MethodNotAllowedException8_ShouldReturn()
        {
            ClientErrorResponse clientErrorResponse1, clientErrorResponse2;
            MethodNotAllowedException exception1 = null, exception2 = null;

            try
            {
                throw new MethodNotAllowedException("This is an error, please consult the help URL.", "http://juhta.net/helpurls/353353");
            }

            catch (MethodNotAllowedException ex)
            {
                AssertException(
                    ex,
                    "ThrowAndSerialize_MethodNotAllowedException8_ShouldReturn",
                    HttpStatusCode.MethodNotAllowed,
                    null,
                    "This is an error, please consult the help URL.",
                    null,
                    "http://juhta.net/helpurls/353353"
                );

                clientErrorResponse1 = ex.ToClientErrorResponse();

                exception1 = ex;
            }

            clientErrorResponse2 = JsonConvert.DeserializeObject<ClientErrorResponse>(JsonConvert.SerializeObject(clientErrorResponse1));

            try
            {
                clientErrorResponse2.Throw();
            }

            catch (MethodNotAllowedException ex)
            {
                exception2 = ex;
            }

            AssertExceptions(exception1, exception2);
        }

        [TestMethod]
        public void ThrowAndSerialize_MethodNotAllowedException9_ShouldReturn()
        {
            ClientErrorResponse clientErrorResponse1, clientErrorResponse2;
            MethodNotAllowedException exception1 = null, exception2 = null;

            try
            {
                throw new MethodNotAllowedException(ErrorCode.InvalidOrderNumber, Field.CustomerName, "The field content is not allowed at all. Please do better.");
            }

            catch (MethodNotAllowedException ex)
            {
                AssertException(
                    ex,
                    "ThrowAndSerialize_MethodNotAllowedException9_ShouldReturn",
                    HttpStatusCode.MethodNotAllowed,
                    ErrorCode.InvalidOrderNumber.ToString(),
                    "The field content is not allowed at all. Please do better.",
                    Field.CustomerName.ToString(),
                    null
                );

                clientErrorResponse1 = ex.ToClientErrorResponse();

                exception1 = ex;
            }

            clientErrorResponse2 = JsonConvert.DeserializeObject<ClientErrorResponse>(JsonConvert.SerializeObject(clientErrorResponse1));

            try
            {
                clientErrorResponse2.Throw();
            }

            catch (MethodNotAllowedException ex)
            {
                exception2 = ex;
            }

            AssertExceptions(exception1, exception2);
        }

        [TestMethod]
        public void ThrowAndSerialize_MethodNotAllowedException10_ShouldReturn()
        {
            ClientErrorResponse clientErrorResponse1, clientErrorResponse2;
            MethodNotAllowedException exception1 = null, exception2 = null;

            try
            {
                throw new MethodNotAllowedException(ErrorCode.InvalidOrderNumber, "MethodNotAllowedExceptionField", "The field content is not allowed at all. Please do better. At least check out the help URL!");
            }

            catch (MethodNotAllowedException ex)
            {
                AssertException(
                    ex,
                    "ThrowAndSerialize_MethodNotAllowedException10_ShouldReturn",
                    HttpStatusCode.MethodNotAllowed,
                    ErrorCode.InvalidOrderNumber.ToString(),
                    "The field content is not allowed at all. Please do better. At least check out the help URL!",
                    "MethodNotAllowedExceptionField",
                    null
                );

                clientErrorResponse1 = ex.ToClientErrorResponse();

                exception1 = ex;
            }

            clientErrorResponse2 = JsonConvert.DeserializeObject<ClientErrorResponse>(JsonConvert.SerializeObject(clientErrorResponse1));

            try
            {
                clientErrorResponse2.Throw();
            }

            catch (MethodNotAllowedException ex)
            {
                exception2 = ex;
            }

            AssertExceptions(exception1, exception2);
        }

        [TestMethod]
        public void ThrowAndSerialize_MethodNotAllowedException11_ShouldReturn()
        {
            ClientErrorResponse clientErrorResponse1, clientErrorResponse2;
            MethodNotAllowedException exception1 = null, exception2 = null;

            try
            {
                throw new MethodNotAllowedException(ErrorCode.InvalidOrderNumber, Field.CustomerName, "The field content is not valid. Please consult the help URL!", "http://juhta.net/helpurls/125533");
            }

            catch (MethodNotAllowedException ex)
            {
                AssertException(
                    ex,
                    "ThrowAndSerialize_MethodNotAllowedException11_ShouldReturn",
                    HttpStatusCode.MethodNotAllowed,
                    ErrorCode.InvalidOrderNumber.ToString(),
                    "The field content is not valid. Please consult the help URL!",
                    Field.CustomerName.ToString(),
                    "http://juhta.net/helpurls/125533"
                );

                clientErrorResponse1 = ex.ToClientErrorResponse();

                exception1 = ex;
            }

            clientErrorResponse2 = JsonConvert.DeserializeObject<ClientErrorResponse>(JsonConvert.SerializeObject(clientErrorResponse1));

            try
            {
                clientErrorResponse2.Throw();
            }

            catch (MethodNotAllowedException ex)
            {
                exception2 = ex;
            }

            AssertExceptions(exception1, exception2);
        }

        #endregion
    }
}