Test_MonetaryUnit.cs

Go to the documentation of this file.

using System;
using System.Globalization;
 
using AnalyzeRe;
using AnalyzeRe.Layers;
using AnalyzeReTesting.Base;
 
#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.Model.DataTypes
{
    [TestClass]
    public sealed class TestSuite_MonetaryUnit : BaseMutableResourceTestSuite<SurplusShare>
    {
        #region Set Up and Configuration
        private const string TypeName = "MonetaryUnit";
        protected override IInjectableResource<SurplusShare>
            TestInjectableResource => Samples.Layer_SurplusShare;
        #endregion Set Up and Configuration
 
        #region ToString
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_ToString()
        {
            string t = CultureInfo.CurrentCulture.NumberFormat.NumberGroupSeparator;
            string d = CultureInfo.CurrentCulture.NumberFormat.NumberDecimalSeparator;
            string neg = CultureInfo.CurrentCulture.NumberFormat.NegativeSign;
 
            // Simple monetary units for sane amounts
            Assert.AreEqual($"USD 123{d}45",
                new MonetaryUnit(123.45, "USD").ToString());
            Assert.AreEqual($"USD 12{t}345{t}678{t}901{d}57",
                new MonetaryUnit(12345678901.5678, "USD").ToString());
            Assert.AreEqual($"USD 0{d}01234",
                new MonetaryUnit(0.01234, "USD").ToString());
 
            // No currency is okay
            Assert.AreEqual($"123{d}45",
                new MonetaryUnit(123.45, null).ToString());
 
            // Small amounts, very large numbers, and special values
            Assert.AreEqual($"CAD 1{d}234E{neg}06",
                new MonetaryUnit(0.000001234, "CAD").ToString());
            Assert.AreEqual($"CAD 1{d}2345678E+55",
                new MonetaryUnit(1.2345678e55, "CAD").ToString());
            Assert.AreEqual($"CAD 1{d}79769313486232E+308",
                new MonetaryUnit(Double.MaxValue, "CAD").ToString());
            Assert.AreEqual($"CAD {CultureInfo.CurrentCulture.NumberFormat.PositiveInfinitySymbol}",
                new MonetaryUnit(Double.PositiveInfinity, "CAD").ToString());
 
            // Fixed date and fixed rate monetary units.
            DateTime aTime = new DateTime(2017, 8, 16, 1, 2, 3, DateTimeKind.Utc);
            Assert.AreEqual($"USD 123{d}45 FX rate fixed to 2017-08-16T01:02:03.0000000Z",
                new MonetaryUnit(123.45, "USD", aTime).ToString());
            Assert.AreEqual($"USD 123{d}45 FX rate fixed to EUR 0{d}998877",
                new MonetaryUnit(123.45, "USD", 0.998877, "EUR").ToString());
            // The user wouldn't allow this so the string representation doesn't matter too much
            Assert.AreEqual($"123{d}45 FX rate fixed to  1{d}3344",
                new MonetaryUnit(123.45, null, 1.3344, null).ToString());
 
            // Negative amounts should follow the same behaviour
            Assert.AreEqual($"USD {neg}123{d}45",
                new MonetaryUnit(-123.45, "USD").ToString());
            Assert.AreEqual($"USD {neg}12{t}345{t}678{t}901{d}57",
                new MonetaryUnit(-12345678901.5678, "USD").ToString());
            Assert.AreEqual($"USD {neg}0{d}01234",
                new MonetaryUnit(-0.01234, "USD").ToString());
            Assert.AreEqual($"CAD {neg}1{d}234E{neg}06",
                new MonetaryUnit(-0.000001234, "CAD").ToString());
            Assert.AreEqual($"CAD {neg}1{d}2345678E+55",
                new MonetaryUnit(-1.2345678e55, "CAD").ToString());
            Assert.AreEqual($"CAD {neg}1{d}79769313486232E+308",
                new MonetaryUnit(Double.MinValue, "CAD").ToString());
            Assert.AreEqual($"CAD {CultureInfo.CurrentCulture.NumberFormat.NegativeInfinitySymbol}",
                new MonetaryUnit(Double.NegativeInfinity, "CAD").ToString());
 
            // Representation of NaN isn't so important, just ensuring it doesn't throw
            Assert.AreEqual($"USD {CultureInfo.CurrentCulture.NumberFormat.NaNSymbol}",
                new MonetaryUnit(Double.NaN, "USD").ToString());
        }
        #endregion ToString
 
        #region Test Helper Methods
        private void TestPOSTValue(double value, bool shouldSucceed)
        {
            PUT_WithValue(l => l.premium, new MonetaryUnit(value, "USD"), shouldSucceed);
        }
        private void TestPOSTCurrency(string currency, bool shouldSucceed)
        {
            POST_WithValue(l => l.premium, new MonetaryUnit(0, currency), shouldSucceed);
        }
        private void TestPUTValue(double value, bool shouldSucceed)
        {
            PUT_WithValue(l => l.premium, new MonetaryUnit(value, "USD"), shouldSucceed);
        }
        private void TestPUTCurrency(string currency, bool shouldSucceed)
        {
            PUT_WithValue(l => l.premium, new MonetaryUnit(0, currency), shouldSucceed);
        }
        #endregion Test Helper Methods
 
        #region POST
        #region MonetaryUnit.value
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_MaxValue()
        {
            TestPOSTValue(Double.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_MinValue()
        {
            TestPOSTValue(Double.MinValue, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_Zero()
        {
            TestPOSTValue(0d, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_Negative()
        {
            TestPOSTValue(-1d, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_NaN()
        {
            TestPOSTValue(Double.NaN, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_Infinity()
        {
            TestPOSTValue(Double.PositiveInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_NegativeInfinity()
        {
            TestPOSTValue(Double.NegativeInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_HighPrecision()
        {
            TestPOSTValue(Math.PI / 1E12, true);
        }
        #endregion MonetaryUnit.value
 
        #region MonetaryUnit.currency
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_CurrencyNull()
        {
            TestPOSTCurrency(null, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_CurrencyEmpty()
        {
            TestPOSTCurrency("", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_CurrencyTooShort()
        {
            TestPOSTCurrency("AU", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_CurrencyTooLong()
        {
            TestPOSTCurrency("asdf", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_CurrencyValidISO()
        {
            TestPOSTCurrency("EUR", true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_CurrencyInvalidISO()
        {
            TestPOSTCurrency("AAA", true);
        }
        #endregion MonetaryUnit.currency
 
        #region MonetaryUnit.value_date
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_Date()
        {
            POST_WithValue(l => l.premium, new MonetaryUnit(0, "USD",
                new DateTime(2015, 01, 02, 3, 4, 5)), true);
        }
        #endregion MonetaryUnit.value_date
 
        #region MonetaryUnit.rate
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_Rate()
        {
            POST_WithValue(l => l.premium, new MonetaryUnit(0, "USD", 1.23, "CAD"), true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_Rate_Zero()
        {
            POST_WithValue(l => l.premium, new MonetaryUnit(0, "USD", 0, "CAD"), true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_Rate_Negative()
        {
            POST_WithValue(l => l.premium, new MonetaryUnit(0, "USD", -1.23, "CAD"), false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_Rate_No_RateCurrency()
        {
            POST_WithValue(l => l.premium, new MonetaryUnit(0, "USD", 1.23, null), false);
        }
        #endregion MonetaryUnit.rate
 
        #region MonetaryUnit.rate and .value_date
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_POST_DateAndRate()
        {
            MonetaryUnit toSupply = new MonetaryUnit(0, "USD", 1.23, "CAD")
            {
                // Set the value_date property (shouldn't be supported if rate was set)
                value_date = new DateTime(2015, 01, 02, 3, 4, 5)
            };
            POST_WithValue(l => l.premium, toSupply, false);
        }
        #endregion MonetaryUnit.rate and .value_date
        #endregion POST
 
        #region PUT
        #region MonetaryUnit.value
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_MaxValue()
        {
            TestPUTValue(Double.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_MinValue()
        {
            TestPUTValue(Double.MinValue, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_Zero()
        {
            TestPUTValue(0d, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_Negative()
        {
            TestPUTValue(-1d, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_NaN()
        {
            TestPUTValue(Double.NaN, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_Infinity()
        {
            TestPUTValue(Double.PositiveInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_NegativeInfinity()
        {
            TestPUTValue(Double.NegativeInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_HighPrecision()
        {
            TestPUTValue(Math.PI / 1E12, true);
        }
        #endregion MonetaryUnit.value
 
        #region MonetaryUnit.currency
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_CurrencyNull()
        {
            // Monetary Unit structures are updated atomically - which means the new
            // object must specify all required values. Thus, currency cannot be omitted.
            TestPUTCurrency(null, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_CurrencyEmpty()
        {
            TestPUTCurrency("", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_CurrencyTooShort()
        {
            TestPUTCurrency("AU", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_CurrencyTooLong()
        {
            TestPUTCurrency("asdf", false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_CurrencyValidISO()
        {
            TestPUTCurrency("EUR", true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_CurrencyInvalidISO()
        {
            TestPUTCurrency("AAA", true);
        }
        #endregion MonetaryUnit.currency
 
        #region MonetaryUnit.value_date
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_Date()
        {
            PUT_WithValue(l => l.premium, new MonetaryUnit(0, "USD",
                new DateTime(2015, 01, 02, 3, 4, 5)), true);
        }
        #endregion MonetaryUnit.value_date
 
        #region MonetaryUnit.rate
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_Rate()
        {
            PUT_WithValue(l => l.premium, new MonetaryUnit(0, "USD", 1.23, "CAD"), true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_Rate_Zero()
        {
            PUT_WithValue(l => l.premium, new MonetaryUnit(0, "USD", 0, "CAD"), true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_Rate_Negative()
        {
            PUT_WithValue(l => l.premium, new MonetaryUnit(0, "USD", -1.23, "CAD"), false);
        }
        #endregion MonetaryUnit.rate
 
        #region MonetaryUnit.rate and .value_date
        [TestMethod, TestCategory(TypeName)]
        public void Test_MonetaryUnit_PUT_DateAndRate()
        {
            MonetaryUnit toSupply = new MonetaryUnit(0, "USD", 1.23, "CAD")
            {
                // Set the value_date property (shouldn't be supported if rate was set)
                value_date = new DateTime(2015, 01, 02, 3, 4, 5)
            };
            PUT_WithValue(l => l.premium, toSupply, false);
        }
        #endregion MonetaryUnit.rate and .value_date
        #endregion PUT
 
        // TODO: Test application of exchange rates including behaviour around override rate/date
    }
}