Test_LayerView.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Reflection;
 
using AnalyzeRe;
using AnalyzeRe.APIResourceView;
using AnalyzeRe.APITypes;
using AnalyzeRe.Attributes;
using AnalyzeRe.Layers;
using AnalyzeRe.LossFilters;
using AnalyzeRe.LossSets;
using AnalyzeRe.Metrics;
using AnalyzeRe.Utilities;
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.Model
{
    #region Base LayerView Class Tests
 
    [TestClass]
    public sealed class TestSuite_LayerView_Base : BaseAbstractResourceTestSuite<ILayerView>
    {
        private const string TypeName = "LayerView";
 
        protected override bool PUT_Allowed => false;
        protected override IResourceCollection<ILayerView> collection_source => API.LayerViews;
 
        [TestMethod, TestCategory(TypeName)]
        public override void Test_Resource_PUT_BadlyFormed()
        {
            //base.Test_Resource_PUT_BadlyFormed();
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            AssertApi.ExceptionThrown(
                () => GenericTest.Mock<PortfolioView>("MALFORMED").Put(),
                // Should be MethodNotAllowed like the base class would assert.
                AssertApi.ApiExceptionTest(HttpStatusCode.NotFound));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_LossSet_EventCatalog_Mismatch()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            IInjectableResource<EventCatalog> catalog = Samples.EventCatalog;
            IInjectableResource<ILayerView<CatXL>> layerView = Samples.LayerView_CatXL;
            IInjectableResource<AnyFilter> anyFilter = Samples.LossFilter_AnyFilter;
            IInjectableResource<YELTLossSet> yelt = Samples.LossSet_YELTLossSet;
 
            // Create a valid event catalog that's different from the analysis profile
            EventCatalog badCatalog = catalog.Unposted;
            badCatalog.description = "A Different Event Catalog";
            badCatalog = badCatalog.Post("Event,Rate\n1,0");
            // Create an analysis profile that uses this different event catalog
            ILayerView<CatXL> badLayerView = layerView.Unposted;
            AnalysisProfile badAnalysisProfile = Reflection.Resolve(badLayerView.analysis_profile).ShallowCopy();
            badAnalysisProfile.event_catalogs = new List<IReference<EventCatalog>> { badCatalog.ToReference() };
            badAnalysisProfile.loss_filters = new List<IReference<LossFilter>> { anyFilter.AsReference };
            // Assert that an exception is thrown.
            AssertApi.ExceptionThrown(() => badAnalysisProfile.Post(),
                AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_GET_YeltLossSetFiltering()
        {
            AnalysisProfile filteringProfile = Samples.AnalysisProfile.Unposted
                .Change(a => a.yelt_loss_set_simulation_filtering, true)
                .Post().PollUntilReady(Samples.DataPollingOptions);
 
            // Samples.Layer_CatXL uses YELT loss set which currently 100% matches SimGrid
            ILayerView<CatXL> catXl = LayerViews.Create(
                        Samples.Layer_CatXL.Unposted, Samples.AnalysisProfile.Posted).Post();
 
            double el = catXl.tail_metrics_blocking(1,
                MetricsOptions.Default, TestSuite_APIResourceView.SimulationPolling).mean;
            Assert.AreNotEqual(el, 0, "Expected not zero EL.");
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_GET_SequencesRounding()
        {
            AnalysisProfile filteringProfile = Samples.AnalysisProfile.Unposted
                .Change(a => a.round_sequences, true)
                .Post().PollUntilReady(Samples.DataPollingOptions);
 
            // Samples.Layer_CatXL uses YELT loss set which currently 100% matches SimGrid
            ILayerView<CatXL> catXl = LayerViews.Create(
                        Samples.Layer_CatXL.Unposted, Samples.AnalysisProfile.Posted).Post();
 
            double el = catXl.tail_metrics_blocking(1,
                MetricsOptions.Default, TestSuite_APIResourceView.SimulationPolling).mean;
            Assert.AreNotEqual(el, 0, "Expected not zero EL.");
        }
    }
 
    #endregion Base LayerView Class Tests
 
    #region Instantiable LayerView Types Tests
 
    [TestClass]
    public sealed class TestSuite_LayerView_AggXL : TestSuite_LayerView<AggXL>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<AggXL>";
 
        protected override IInjectableResource<ILayerView<AggXL>> TestInjectableResource =>
            Samples.LayerView_AggXL;
 
        protected override Expression<Func<AggXL, object>> TargetCurrencyProperty =>
            l => l.aggregate_limit;
 
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_CatXL : TestSuite_LayerView<CatXL>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<CatXL>";
 
        protected override IInjectableResource<ILayerView<CatXL>> TestInjectableResource =>
            Samples.LayerView_CatXL;
 
        protected override Expression<Func<CatXL, object>> TargetCurrencyProperty =>
            l => l.limit;
 
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_Generic : TestSuite_LayerView<Generic>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<Generic>";
 
        protected override IInjectableResource<ILayerView<Generic>> TestInjectableResource =>
            Samples.LayerView_Generic;
 
        protected override Expression<Func<Generic, object>> TargetCurrencyProperty =>
            l => l.aggregate_limit;
 
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_QuotaShare : TestSuite_LayerView<QuotaShare>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<QuotaShare>";
 
        protected override IInjectableResource<ILayerView<QuotaShare>> TestInjectableResource =>
            Samples.LayerView_QuotaShare;
 
        protected override Expression<Func<QuotaShare, object>> TargetCurrencyProperty =>
            l => l.event_limit;
 
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_AggregateQuotaShare : TestSuite_LayerView<AggregateQuotaShare>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<AggregateQuotaShare>";
 
        protected override IInjectableResource<ILayerView<AggregateQuotaShare>> TestInjectableResource =>
            Samples.LayerView_AggregateQuotaShare;
 
        protected override Expression<Func<AggregateQuotaShare, object>> TargetCurrencyProperty =>
            l => l.aggregate_limit;
 
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_SurplusShare : TestSuite_LayerView<SurplusShare>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<SurplusShare>";
 
        protected override IInjectableResource<ILayerView<SurplusShare>> TestInjectableResource =>
            Samples.LayerView_SurplusShare;
 
        protected override Expression<Func<SurplusShare, object>> TargetCurrencyProperty =>
            l => l.retained_line;
 
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_IndustryLossWarranty : TestSuite_LayerView<IndustryLossWarranty>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<IndustryLossWarranty>";
 
        protected override IInjectableResource<ILayerView<IndustryLossWarranty>> TestInjectableResource =>
            Samples.LayerView_IndustryLossWarranty;
 
        protected override Expression<Func<IndustryLossWarranty, object>> TargetCurrencyProperty =>
            l => l.payout;
 
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_Nested : TestSuite_LayerView<Nested>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<Nested>";
 
        protected override IInjectableResource<ILayerView<Nested>> TestInjectableResource =>
            Samples.LayerView_Nested;
 
        #endregion Set Up and Configuration
 
        #region Overidden Tests
 
        [TestMethod, TestCategory(TypeName)]
        public override void Test_LayerView_POST_TargetCurrencyDefault()
        {
            // Demonstrate that the target currency comes from the sink layer
            ILayerView<Nested> testNestedLayerView = new LayerView<Nested>
            {
                analysis_profile = Samples.AnalysisProfile.AsReference,
                layer = new Nested
                {
                    sink = new QuotaShare { event_limit = new MonetaryUnit(1, "CAD") }.ToReference()
                }
            };
            // Predict the target currency using the "TargetCurrencyDefault" attribute.
            string predicted = TargetCurrencyDefault.GetDefaultTargetCurrency(testNestedLayerView);
            POST_ThenDoAction(testNestedLayerView, fromServer =>
            {
                // Assert that the currency and prediction are both "CAD"
                Assert.AreEqual("CAD", fromServer.target_currency);
                Assert.AreEqual("CAD", predicted);
            });
 
            // To prove ensure it's not a fluke, change the currency
            ILayerView<Nested> test2 = new LayerView<Nested>
            {
                analysis_profile = Samples.AnalysisProfile.AsReference,
                layer = new Nested
                {
                    sink = new QuotaShare { event_limit = new MonetaryUnit(1, "EUR") }.ToReference()
                }
            };
            // Predict the target currency using the "TargetCurrencyDefault" attribute.
            string predicted2 = TargetCurrencyDefault.GetDefaultTargetCurrency(test2);
            POST_ThenDoAction(test2, fromServer =>
            {
                // Assert that the currency and prediction are now both "EUR"
                Assert.AreEqual("EUR", fromServer.target_currency);
                Assert.AreEqual("EUR", predicted2);
            });
        }
 
        #endregion Overidden Tests
 
        #region Additional LayerView Nested Layer Type Tests
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_Nested_POST_EverySinkAndSourceType_Referenced()
        {
            Test_LayerView_Nested_POST_EverySinkAndSourceType(false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_Nested_POST_EverySinkAndSourceType_Inlined()
        {
            Test_LayerView_Nested_POST_EverySinkAndSourceType(true);
        }
 
        // Helper method to run two nearly identical tests.
        private void Test_LayerView_Nested_POST_EverySinkAndSourceType(bool useInlinedObjects)
        {
            // Loop over each layer type, generate and test POST a testResource with it.
            foreach (IInjectableResource<ILayer> sinkLayer in TestSuite_Layer_Nested.ValidSinkLayerTypesTestList)
            {
                // If the current choice of sinkLayer isn't saveable, and we're testing layer references,
                // we must skip this type, because layers are not saveable.
                if (sinkLayer.UnderlyingType.IsAttributeDefinedFast<NotSaveableAttribute>())
                {
                    Console.WriteLine("Skipping sink layer reference test of un-saveable layer type " +
                        sinkLayer.UnderlyingType.NiceTypeName());
                    continue;
                }
 
                // Change source description so it can be distinguished from the identical source.
                ILayer current = sinkLayer.Unposted;
                current.id = null;
                current.description = "Sink";
                // Create a new LayerView for testing from a new nested layer containing the
                // current sink type, and all source types, using the configured inlining option.
                IInjectableResource<ILayer> sink = InjectableResource.Create(current, sinkLayer.Mocked);
 
                List<IInjectableResource<ILayer>> sources = useInlinedObjects ?
                    Samples.AllLayerTypesTestList : Samples.AllSaveableLayerTypesTestList;
                IInjectableResource<Nested> nestedSink =
                    Samples.GetInjectableNestedLayer(sink, sources, useInlinedObjects);
                POST_WithValue(lv => lv.layer, nestedSink.Unposted, true);
            }
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_Nested_POST_EverySinkAndSourceType_LayerViewReferences()
        {
            // Loop over each layer type, generate a layer_view for it, and test referencing
            // that layer_view in a Nested layer_view layer definition.
            foreach (IInjectableResource<ILayerView> sinkLayerView in TestSuite_Layer_Nested
                .ValidSinkLayerTypesTestList.Select(layer => Samples.GetInjectableLayerView(layer)))
            {
                // Try this layer_view reference as a sink, and all layer_views as the sources
                POST_WithValue(lv => lv.layer, Samples.GetInjectableNestedLayer(sinkLayerView,
                    Samples.AllLayerViewTypesTestList).Unposted, true);
            }
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_Nested_POST_Sink_InvalidType()
        {
            Nested testLayer = TestResource.layer;
            // Test invalid types as layer references
            foreach (IInjectableResource<ILayer> layer in TestSuite_Layer_Nested.ForbiddenSinkLayerTypesTestList)
            {
                // Test invalid types as layer references
                POST_WithValue(lv => lv.layer, testLayer.ShallowCopy().Change(l => l.sink,
                    layer.AsReference), false);
                // Test invalid types as inlined layer definitions
                POST_WithValue(lv => lv.layer, testLayer.ShallowCopy().Change(l => l.sink,
                    layer.AsInlinedReference), false);
                // Test invalid types as layer_view references
                POST_WithValue(lv => lv.layer, testLayer.ShallowCopy().Change(l => l.sink,
                    Samples.GetInjectableLayerView(layer).AsReference), false);
            }
        }
 
        // Test what happens when a LayerView contains an inlined nested layer whose sink also
        // contains an inlined nested layer.
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_Nested_POST_Sink_InlinedNested()
        {
            // An inlined nested layer within the sink of an inlined nested layer.
            IInjectableResource<Nested> nested = Samples.GetInjectableNestedLayer(
                Samples.GetInjectableNestedLayer(Samples.Layer_AggXL,
                    new List<IInjectableResource<ILayer>> { Samples.Layer_CatXL }, true),
                new List<IInjectableResource<ILayer>> { Samples.Layer_QuotaShare }, true);
            POST_WithValue(lv => lv.layer, nested.Unposted, true);
        }
 
        // Test what happens when a LayerView contains an inlined nested layer whose source also
        // contains an inlined nested layer.
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_Nested_POST_Source_InlinedNested()
        {
            // An inlined nested layer within the source of an inlined nested layer.
            IInjectableResource<Nested> nested = Samples.GetInjectableNestedLayer(Samples.Layer_QuotaShare,
                new List<IInjectableResource<ILayer>>
                {
                    Samples.GetInjectableNestedLayer(Samples.Layer_AggXL,
                        new List<IInjectableResource<ILayer>> { Samples.Layer_CatXL }, true)
                }, true);
            POST_WithValue(lv => lv.layer, nested.Unposted, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_Nested_POST_Mixed_SourceAndSink_MixedLossSetTypes()
        {
            // The source and sink layers must all use loss_sets with the same loss_type (for now)
            AggXL layerNetAggDefinition = Samples.Layer_AggXL.Unposted;
            layerNetAggDefinition.loss_sets =
                new List<IReference<LossSet>> { Samples.LossSet_YLTLossSet.AsReference };
            IInjectableResource<AggXL> layerNetAgg = InjectableResource.Create(layerNetAggDefinition);
            IInjectableResource<Nested> nested = Samples.GetInjectableNestedLayer(Samples.Layer_AggXL,
                new List<IInjectableResource<ILayer>> { layerNetAgg }, true);
            // Any LossSet fed into a nested layer source should have no impact on the view's
            // ability to return metrics at gross perspectives, since the Nested Layer sources are
            // treated as gross loss sources when feeding into the sink layer.
            POST_ThenDoAction(Samples.GetInjectableLayerView(nested).Unposted,
                posted => Test_IAPIResourceView_Metrics_MixedLossTypes(posted, Perspective.LossGross));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_Nested_POST_Mixed_SourceAndSink_MixedReferenceTypes()
        {
            // Use an inlined sink, and three sources, one inlined layer, one layer reference,
            // and one layer_view reference.
            POST_WithValue(lv => lv.layer, new Nested
            {
                description = "Nested layer with mixed reference types",
                sink = Samples.Layer_CatXL.Unposted.ToReference(),
                sources = new Nested.Sources(
                    Samples.Layer_AggXL.Posted.ToReference(),
                    Samples.Layer_Generic.Unposted.ToReference(),
                    Samples.LayerView_Nested.Posted.ToReference())
            }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_Nested_POST_MismatchedLayerViewAnalysisProfiles()
        {
            IInjectableResource<AnalysisProfile> ap1 = Samples.AnalysisProfile;
            IInjectableResource<AnalysisProfile> ap2 = Samples.AnalysisProfile_OneFilter;
            // The sink layer_view references a different analysis profile from the root layer_view
            GenericTest.POST_InvalidResource_Fails(Samples.GetInjectableLayerView(
                Samples.GetInjectableNestedLayer(
                    Samples.GetInjectableLayerView(Samples.Layer_CatXL, ap2),
                    Samples.AllSaveableLayerTypesTestList), ap1).Unposted);
        }
 
        #endregion Additional LayerView Nested Layer Type Tests
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_ValueAllocator : TestSuite_LayerView<ValueAllocator>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<ValueAllocator>";
 
        protected override IInjectableResource<ILayerView<ValueAllocator>> TestInjectableResource =>
            Samples.LayerView_ValueAllocator;
 
        #endregion Set Up and Configuration
 
        #region Overidden Tests
 
        [TestMethod, TestCategory(TypeName)]
        public override void Test_LayerView_POST_TargetCurrencyDefault()
        {
            // Demonstrate that the target currency comes from the source layer
            ILayerView<ValueAllocator> testValueAllocatorLayerView = new LayerView<ValueAllocator>
            {
                analysis_profile = Samples.AnalysisProfile.AsReference,
                layer = Samples.Layer_ValueAllocator.Unposted.Change(l => l.source,
                    new QuotaShare { event_limit = new MonetaryUnit(1, "CAD") }.ToReference())
            };
            // Predict the target currency using the "TargetCurrencyDefault" attribute.
            string predicted = TargetCurrencyDefault.GetDefaultTargetCurrency(testValueAllocatorLayerView);
            POST_ThenDoAction(testValueAllocatorLayerView, fromServer =>
            {
                // Assert that the currency and prediction are both "CAD"
                Assert.AreEqual("CAD", fromServer.target_currency);
                Assert.AreEqual("CAD", predicted);
            });
 
            // To prove ensure it's not a fluke, change the currency
            ILayerView<ValueAllocator> test2 = new LayerView<ValueAllocator>
            {
                analysis_profile = Samples.AnalysisProfile.AsReference,
                layer = Samples.Layer_ValueAllocator.Unposted.Change(l => l.source,
                    new QuotaShare { event_limit = new MonetaryUnit(1, "EUR") }.ToReference())
            };
            // Predict the target currency using the "TargetCurrencyDefault" attribute.
            string predicted2 = TargetCurrencyDefault.GetDefaultTargetCurrency(test2);
            POST_ThenDoAction(test2, fromServer =>
            {
                // Assert that the currency and prediction are now both "EUR"
                Assert.AreEqual("EUR", fromServer.target_currency);
                Assert.AreEqual("EUR", predicted2);
            });
        }
 
        #endregion Overidden Tests
 
        #region Additional LayerView ValueAllocator Layer Type Tests
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_ValueAllocator_POST_EveryReferenceType()
        {
            // Loop over each layer type, generate and test POST a testResource with it.
            foreach (IInjectableResource<ILayer> layer in Samples.AllLayerTypesTestList)
            {
                // Test using inlined layer definitions
                IReference<ILayer> asInlinedLayer = layer.AsInlinedReference;
                POST_WithValue(lv => lv.layer, Samples.Layer_ValueAllocator.Unposted
                        .Change(va => va.source, asInlinedLayer)
                        .Change(va => va.target, asInlinedLayer)
                        .Change(va => va.group, asInlinedLayer), true);
 
                // Test again using referenced layers (only if layer type is saveable)
                if (!layer.UnderlyingType.IsAttributeDefinedFast<NotSaveableAttribute>())
                {
                    IReference<ILayer> asLayerRef = layer.AsReference;
                    POST_WithValue(lv => lv.layer, Samples.Layer_ValueAllocator.Unposted
                        .Change(va => va.source, asLayerRef)
                        .Change(va => va.target, asLayerRef)
                        .Change(va => va.group, asLayerRef), true);
                }
 
                // Test once more using referenced layer_views
                IReference<ILayerView<ILayer>> asLayerViewRef =
                    Samples.GetInjectableLayerView(layer).AsReference;
                POST_WithValue(lv => lv.layer, Samples.Layer_ValueAllocator.Unposted
                    .Change(va => va.source, asLayerViewRef)
                    .Change(va => va.target, asLayerViewRef)
                    .Change(va => va.group, asLayerViewRef), true);
            }
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_ValueAllocator_POST_MismatchedLayerViewAnalysisProfiles()
        {
            // The sink layer_view references a different analysis profile from the root layer_view
            GenericTest.POST_InvalidResource_Fails(Samples.GetInjectableLayerView(
                Samples.Layer_ValueAllocator.Unposted.Change(va => va.source,
                    Samples.GetInjectableLayerView(Samples.Layer_CatXL, Samples.AnalysisProfile).AsReference),
                Samples.AnalysisProfile_OneFilter).Unposted);
        }
 
        #endregion Additional LayerView ValueAllocator Layer Type Tests
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_BackAllocatedLayer : TestSuite_LayerView<BackAllocatedLayer>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<BackAllocatedLayer>";
 
        protected override IInjectableResource<ILayerView<BackAllocatedLayer>> TestInjectableResource =>
            Samples.LayerView_BackAllocatedLayer;
 
        #endregion Set Up and Configuration
 
        #region Overidden Tests
 
        [TestMethod, TestCategory(TypeName)]
        public override void Test_LayerView_POST_TargetCurrencyDefault()
        {
            BackAllocatedLayer original = Samples.Layer_BackAllocatedLayer.Unposted;
            // Demonstrate that the target currency comes from the sink layer
            ILayerView<BackAllocatedLayer> testBackAllocatedLayerLayerView = new LayerView<BackAllocatedLayer>
            {
                analysis_profile = Samples.AnalysisProfile.AsReference,
                layer = original.Change(l => l.sink, new QuotaShare
                {
                    event_limit = new MonetaryUnit(1, "CAD"),
                    loss_sets = new List<IReference<LossSet>> { Samples.LossSet_ELTLossSet.AsReference }
                }.ToReference())
            };
            // Predict the target currency using the "TargetCurrencyDefault" attribute.
            string predicted = TargetCurrencyDefault.GetDefaultTargetCurrency(testBackAllocatedLayerLayerView);
            POST_ThenDoAction(testBackAllocatedLayerLayerView, fromServer =>
            {
                // Assert that the currency and prediction are both "CAD"
                Assert.AreEqual("CAD", fromServer.target_currency);
                Assert.AreEqual("CAD", predicted);
            });
 
            // To prove ensure it's not a fluke, change the currency
            ILayerView<BackAllocatedLayer> test2 = new LayerView<BackAllocatedLayer>
            {
                analysis_profile = Samples.AnalysisProfile.AsReference,
                layer = original.Change(l => l.sink, new QuotaShare
                {
                    event_limit = new MonetaryUnit(1, "EUR"),
                    loss_sets = new List<IReference<LossSet>> { Samples.LossSet_ELTLossSet.AsReference }
                }.ToReference())
            };
            // Predict the target currency using the "TargetCurrencyDefault" attribute.
            string predicted2 = TargetCurrencyDefault.GetDefaultTargetCurrency(test2);
            POST_ThenDoAction(test2, fromServer =>
            {
                // Assert that the currency and prediction are now both "EUR"
                Assert.AreEqual("EUR", fromServer.target_currency);
                Assert.AreEqual("EUR", predicted2);
            });
        }
 
        #endregion Overidden Tests
 
        #region Additional LayerView BackAllocatedLayer Layer Type Tests
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_BackAllocatedLayer_POST_EveryReferenceType()
        {
            // Loop over each layer type, generate and test POST a testResource with it.
            foreach (IInjectableResource<ILayer> layer in Samples.AllLayerTypesTestList)
            {
                bool isSupportedType = !TestSuite_Layer_BackAllocatedLayer
                    .UnsupportedBackAllocatedLayerSinkTypes.Contains(layer.UnderlyingType);
 
                // TODO: ARE-7212 - Remove once fixed and these are returning the right error
                if (!isSupportedType && (TestSuite_Layer_Base.PaymentPatternTypes.Contains(layer.UnderlyingType)))
                {
                    Console.WriteLine($"Skipping tests for type {layer.UnderlyingType} until ARE-7212");
                    continue; // Skip.Indefinitely("ARE-7212");
                }
 
                // Test using inlined layer definitions
                IReference<ILayer> asInlinedLayer = layer.AsInlinedReference;
                POST_WithValue(lv => lv.layer, Samples.Layer_BackAllocatedLayer.Unposted
                        .Change(ba => ba.sink, asInlinedLayer), isSupportedType);
 
                // Test again using referenced layers (only if layer type is saveable)
                if (!layer.UnderlyingType.IsAttributeDefinedFast<NotSaveableAttribute>())
                {
                    IReference<ILayer> asLayerRef = layer.AsReference;
                    POST_WithValue(lv => lv.layer, Samples.Layer_BackAllocatedLayer.Unposted
                        .Change(ba => ba.sink, asLayerRef), isSupportedType);
                }
 
                // Test once more using referenced layer_views
                IReference<ILayerView<ILayer>> asLayerViewRef =
                    Samples.GetInjectableLayerView(layer).AsReference;
                POST_WithValue(lv => lv.layer, Samples.Layer_BackAllocatedLayer.Unposted
                    .Change(ba => ba.sink, asLayerViewRef), isSupportedType);
            }
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_BackAllocatedLayer_POST_MismatchedLayerViewAnalysisProfiles()
        {
            // The sink layer_view references a different analysis profile from the root layer_view
            GenericTest.POST_InvalidResource_Fails(Samples.GetInjectableLayerView(
                Samples.Layer_BackAllocatedLayer.Unposted.Change(ba => ba.sink,
                    Samples.GetInjectableLayerView(Samples.Layer_Nested, Samples.AnalysisProfile).AsReference),
                Samples.AnalysisProfile_OneFilter).Unposted);
        }
 
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("This tests a now obsolete class (NestedLayerLossSet) for backwards compatibility purposes.")]
        public void Test_LayerView_BackAllocatedLayer_POST_ARE_6437()
        {
            // Test Bug ARE-6437 which found that the NestedLayerLossSet ids cannot be used as the source_id
            NestedLayerLossSet nlls = Samples.LossSet_NestedLayerLossSet.Posted;
            ILayerView sink = Samples.GetInjectableLayerView(Samples.Layer_CatXL.Unposted
                .Change(l => l.loss_sets, new List<IReference<LossSet>> { nlls.ToReference() })).Posted;
            // This should work (back-allocate to loss set id) but may fail due to ARE-6437.
            GenericTest.POST_ValidResource(Samples.GetInjectableLayerView(new BackAllocatedLayer
            {
                sink = sink.ToReference(),
                source_id = nlls.id,
            }).Unposted);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_BackAllocatedLayer_POST_ARE_6439()
        {
            // Test Bug ARE-6439 which found that the target_currency broke the ability to find the sink.
            ILayerView sink = Samples.LayerView_CatXL.Posted;
            // For this to work, we should be sure that the sink layer_view has its own target currency
            Assert.AreNotEqual("EUR", sink.target_currency);
            // This should work (back-allocate to self) but may fail due to ARE-6439.
            GenericTest.POST_ValidResource(Samples.GetInjectableLayerView(new BackAllocatedLayer
            {
                sink = sink.ToReference(),
                source_id = sink.id,
            }, Samples.AnalysisProfile, "EUR").Unposted);
        }
 
        #endregion Additional LayerView BackAllocatedLayer Layer Type Tests
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_Filter : TestSuite_LayerView<Filter>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<Filter>";
 
        protected override IInjectableResource<ILayerView<Filter>> TestInjectableResource =>
            Samples.LayerView_Filter;
 
        #endregion Set Up and Configuration
 
        #region Additional LayerView Filter Layer Type Tests
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_Filter_Metrics_Decrease()
        {
            POST_ThenDoAction(TestResource, filteredLayerView =>
            {
                ILayerView<Filter> unfilteredLayerView = null, invertedLayerView = null;
                double? filtered_el = null, original_el = null, inverted_el = null;
 
                try
                {
                    // Verify we can get metrics.
                    filtered_el = filteredLayerView.tail_metrics_blocking(1,
                        MetricsOptions.Default, SimulationPolling).mean;
 
                    // Verify these are different from the loss_set's unfiltered EL
                    Filter unfiltered = filteredLayerView.layer.DeepCopy();
                    // Empty filters and invert to include all losses.
                    unfiltered.filters.Clear();
                    unfiltered.invert = true;
                    unfilteredLayerView = LayerViews.Create(
                        unfiltered, filteredLayerView.analysis_profile, filteredLayerView.target_currency).Post();
                    original_el = unfilteredLayerView.tail_metrics_blocking(1,
                        MetricsOptions.Default, SimulationPolling).mean;
 
                    // Now verify that the inverted filter makes up the difference.
                    Filter inverted = filteredLayerView.layer.DeepCopy();
                    inverted.invert = !inverted.invert;
                    invertedLayerView = LayerViews.Create(
                        inverted, filteredLayerView.analysis_profile, filteredLayerView.target_currency).Post();
                    inverted_el = invertedLayerView.tail_metrics_blocking(1,
                        MetricsOptions.Default, SimulationPolling).mean;
 
                    // Assert that the filtered ELs are less than the original EL
                    Assert.AreNotEqual(filtered_el, original_el, "Expected a reduced EL.");
                    Assert.AreNotEqual(0d, filtered_el, "This test assumes a filter has been set up " +
                        "that reduces losses but not to 0.");
                    Assert.AreNotEqual(inverted_el, original_el, "Expected a reduced EL.");
 
                    // The next assertion requires the test data such that the filtered losses
                    // aren't exactly half the unfiltered losses, otherwise we can't check that
                    // the invert flag works.
                    Assert.IsFalse(AssertApi.AlmostEquals(filtered_el.Value, original_el.Value / 2d),
                        "The filtered EL (" + filtered_el + ") is exactly half of the " +
                        "original unfiltered EL (" + original_el + "). This makes it " +
                        "impossible to assert that the inverted filter is working " +
                        "correctly. Please revise the test data or filter used to ensure " +
                        "it doesn't match exactly half of the total losses.");
 
                    // Check that the invert flag is working
                    Assert.AreNotEqual(inverted_el, filtered_el, "According to this test, " +
                        "the inverted filter returned the same EL as the original filter. " +
                        "This indicates that the 'invert' property is not working.");
 
                    // Finally assert that the filtered and unfiltered ELs sum to the original EL
                    AssertApi.DoublesAreEqual(original_el.Value, inverted_el.Value + filtered_el.Value,
                        "Expected filtered ELs to add up to the unfiltered EL.");
                }
                catch (Exception)
                {
                    try
                    {
                        Console.WriteLine("\n\nAn error occurred. Dumping detailed logs.");
                        Console.WriteLine("Filtered EL is: " + filtered_el);
                        Console.WriteLine("Empty Filter (unfiltered) EL is: " + original_el);
                        Console.WriteLine("Inverted Filter EL is: " + inverted_el);
 
                        // Print the full layer_view definition
                        Console.WriteLine("\n\nFilter LayerView Definition:\n" +
                            filteredLayerView.Get_AsType<IRestResponse>().PrettyPrint());
                        Console.WriteLine("\nEmpty Filter Full Definition:\n" +
                            unfilteredLayerView.Get_AsType<IRestResponse>().PrettyPrint());
                        Console.WriteLine("\nInverted Filter Full Definition:\n" +
                            invertedLayerView.Get_AsType<IRestResponse>().PrettyPrint());
 
                        // And information about the resources they reference
                        Console.WriteLine("\n\nFilter Definition:\n" +
                            filteredLayerView.layer.filters.First().GetValue().Get_AsType<IRestResponse>().PrettyPrint());
                        Console.WriteLine("\nFull Loss Set Data:\n" +
                            (filteredLayerView.layer.loss_sets.First().GetValue() as IAPIResource_WithDataEndpoint).data.Get());
                        Console.WriteLine("\n\nAnalysis Profile Definition:\n" +
                            filteredLayerView.analysis_profile.GetValue().Get_AsType<IRestResponse>(
                                API.Parameters.ExpandReferences()).PrettyPrint());
                        Console.WriteLine("\nFull Catalog Data:\n" +
                            filteredLayerView.analysis_profile.GetValue().event_catalogs.First().GetValue().data.Get());
                    }
                    catch (Exception)
                    {
                        Console.WriteLine("\nAnother error occurred while dumping detailed logs.");
                        /* Regardless, we want to re-throw the original exception */
                    }
                    Console.WriteLine("\nRe-throwing original error.");
                    throw;
                }
            });
        }
 
        #endregion Additional LayerView Filter Layer Type Tests
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_FixedRateCurrencyConverter
        : TestSuite_LayerView<FixedRateCurrencyConverter>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<FixedRateCurrencyConverter>";
 
        protected override IInjectableResource<ILayerView<FixedRateCurrencyConverter>>
            TestInjectableResource => Samples.LayerView_FixedRateCurrencyConverter;
 
        protected override Expression<Func<FixedRateCurrencyConverter, object>>
            TargetCurrencyProperty => l => l.out_currency;
 
        #endregion Set Up and Configuration
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LayerView_FixedRateCurrencyConverter_Results()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            ILayerView<CatXL> original = Samples.LayerView_CatXL.Posted;
            TailMetrics original_metrics = original.tail_metrics_blocking(1,
                MetricsOptions.Default, SimulationPolling);
            // Metrics are 100% - have to apply participation (Nested layer will do the same)
            double original_mean = original_metrics.mean * original.layer.participation;
            Console.WriteLine($"Original mean is: {original_mean} {original_metrics.context.currency}");
 
            // We should be able to convert to any currency, since we supply the rate
            string in_currency = original_metrics.context.currency;
            string out_currency = "ZZZ";
            double rate = 1000;
            Console.WriteLine($"Rate is: {rate} {out_currency} to 1 {in_currency}");
 
            // Put the source layer through the fixed rate currency converter
            GenericTest.POST_ThenDoAction(LayerViews.Create(new Nested
            {
                sink = new FixedRateCurrencyConverter
                {
                    in_currency = in_currency,
                    out_currency = out_currency,
                    rate = rate
                }.ToReference(),
                sources = new Nested.Sources(original.layer.ToReference())
            }, original.analysis_profile, out_currency), converted =>
            {
                TailMetrics converted_metrics =
                    converted.tail_metrics_blocking(1, MetricsOptions.Default);
                Console.WriteLine("Resulting mean is: " + converted_metrics.mean +
                    " " + converted_metrics.context.currency);
 
                // Verify the metrics have the new currency, and the rate was applied
                Assert.AreEqual(out_currency, converted.target_currency);
                Assert.AreEqual(out_currency, converted_metrics.context.currency);
                AssertApi.DoublesAreEqual(original_mean * rate, converted_metrics.mean);
            });
        }
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_LossRank : TestSuite_LayerView<LossRank>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<LossRank>";
 
        protected override IInjectableResource<ILayerView<LossRank>> TestInjectableResource =>
            Samples.LayerView_LossRank;
 
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_NoClaimsBonus : TestSuite_LayerView<NoClaimsBonus>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<NoClaimsBonus>";
 
        protected override IInjectableResource<ILayerView<NoClaimsBonus>> TestInjectableResource =>
            Samples.LayerView_NoClaimsBonus;
 
        protected override Expression<Func<NoClaimsBonus, object>> TargetCurrencyProperty =>
            l => l.payout_amount;
 
        #endregion Set Up and Configuration
 
        #region Overidden Tests
 
        [TestMethod, TestCategory(TypeName), Obsolete("Tests the legacy back_allocations endpoint")]
        public override void Test_IAPIResourceView_GET_BackAllocations_Self()
        {
            Skip.Indefinitely("ARE-4335 - Back Allocation of NoClaimsBonus with ELT Loss Set Results in Error");
 
            base.Test_IAPIResourceView_GET_BackAllocations_Self();
        }
 
        #endregion Overidden Tests
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_DelayedPayment : TestSuite_LayerView<DelayedPayment>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<DelayedPayment>";
 
        protected override IInjectableResource<ILayerView<DelayedPayment>> TestInjectableResource =>
            Samples.LayerView_DelayedPayment;
 
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_LayerView_FixedDatePayment : TestSuite_LayerView<FixedDatePayment>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView<FixedDatePayment>";
 
        protected override IInjectableResource<ILayerView<FixedDatePayment>> TestInjectableResource =>
            Samples.LayerView_FixedDatePayment;
 
        #endregion Set Up and Configuration
    }
 
    #endregion Instantiable LayerView Types Tests
 
    #region Abstract Base LayerView Tests
 
    [TestClass]
    public abstract class TestSuite_LayerView<T> : TestSuite_APIResourceView<ILayerView<T>>
        where T : ILayer
    {
        #region Set Up and Configuration
 
        private const string TypeName = "LayerView";
 
        #endregion Set Up and Configuration
 
        protected virtual Expression<Func<T, object>> TargetCurrencyProperty => null;
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LayerView_POST_Layer_MixedLossSetTypes()
        {
            ILayerView<T> modifiedResource = TestResource;
            if (!(modifiedResource.layer is ILayer_WithLossSets layer))
                return; //Test does not apply when layer type isn't an ILayer_WithLossSets
 
            layer.loss_sets = Samples.AllLossSetTypesTestList.Select(ls => ls.AsReference).ToList();
            POST_ThenDoAction(modifiedResource, posted =>
                Test_IAPIResourceView_Metrics_MixedLossTypes(posted, Perspective.LossGross));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LayerView_POST_TargetCurrencyDefault()
        {
            // If the inheiting method hasn't overriden this test or specified the TargetCurrencyProperty,
            // Proceed under the assumption that associated Analysis Profile is responsible.
            if (TargetCurrencyProperty == null)
            {
                AssertTargetCurrencyMatchesAnalysisProfile();
                return;
            }
 
            string targetPropertyName = ReflectionUtilities.GetMemberInfo(TargetCurrencyProperty).Name;
            PropertyInfo[] monetaryUnitProperties = typeof(T).GetUserFacingProperties(true, true)
                .Where(pi => pi.PropertyType == typeof(MonetaryUnit)).ToArray();
            PropertyInfo[] stringProperties = typeof(T).GetUserFacingProperties(true, true)
                .Where(pi => pi.PropertyType == typeof(string)).ToArray();
 
            // First make sure all monetaryUnits are set to a single currency
            ILayerView<T> allUSD = TestResource;
            allUSD.target_currency = null;
            foreach (PropertyInfo monetaryUnit in monetaryUnitProperties)
                monetaryUnit.SetValue(allUSD.layer, new MonetaryUnit(1, "USD"));
            // Set all strings to this too, in case one of those strings impact currency
            foreach (PropertyInfo stringProperty in stringProperties)
                stringProperty.SetValue(allUSD.layer, "USD");
 
            // Post this all-USD layer and ensure the target currency is USD:
            POST_ThenDoAction(allUSD, postResult =>
            {
                Assert.AreEqual("USD", postResult.target_currency, "Expected a target currency of USD");
                // Now change each property one at a time and assert that only
                // the expected property affects the target currency of the layer.
                foreach (PropertyInfo property in monetaryUnitProperties.Union(stringProperties))
                {
                    // Make a copy of the layer_view and its layer, and unset target currency.
                    ILayerView modified = postResult.ShallowCopy();
                    modified.layer = modified.layer.ShallowCopy();
                    modified.target_currency = null;
 
                    bool is_monetary_unit = typeof(MonetaryUnit).IsAssignableFrom(property.PropertyType);
                    property.SetValue(modified.layer, is_monetary_unit ? new MonetaryUnit(1, "CAD") : (object)"CAD");
                    // Predict the target currency using the "TargetCurrencyDefault" attribute.
                    string predicted = TargetCurrencyDefault.GetDefaultTargetCurrency(modified);
                    GenericTest.POST_ThenDoAction(modified, modifiedResult =>
                    {
                        if (property.Name == targetPropertyName)
                            Assert.AreEqual("CAD", modifiedResult.target_currency, "Expected changing the " +
                                targetPropertyName + " currency to change the target currency.");
                        else
                            Assert.AreEqual("USD", modifiedResult.target_currency, "Expected the " +
                                property.Name + " currency to have no impact on the target currency.");
                        // Check that the predicted currency matched the resulting currency
                        Assert.AreEqual(modifiedResult.target_currency, predicted,
                            "The TargetCurrencyDefault attribute failed to predict the correct currency");
                    });
                }
            });
        }
 
        private void AssertTargetCurrencyMatchesAnalysisProfile()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            // Test that the target currency matches the analysis profile
            string expected_currency = Reflection.Resolve(Reflection.Resolve(Reflection.Resolve(
                TestResource.analysis_profile).exchange_rate_profile).exchange_rate_table).base_currency;
            Assert.AreEqual(expected_currency, TestResource_Existing.target_currency);
            // Also check that the correct target currency was predicted by our TargetCurrencyDefault attribute
            Assert.AreEqual(expected_currency, TargetCurrencyDefault.GetDefaultTargetCurrency(TestResource));
 
            // Show that if we use a new analysis profile with a different base currency, the target_currency changes.
            // Pick CAD as the new currency (unless it was the original, then pick EUR)
            string newCCY = expected_currency == "CAD" ? "EUR" : "CAD";
            AnalysisProfile newProfile = Samples.AnalysisProfile_OneFilter.Unposted
                .Change(ap => ap.exchange_rate_profile, Samples.ExchangeRateProfile.Unposted
                    .Change(ep => ep.exchange_rate_table, Samples.ExchangeRateTable.Unposted
                        .Change(fx => fx.base_currency, newCCY).Post(Samples.CSV.Exchange_Rate_Table
                            // Change the CSV data to swap the old target_currency for the new one
                            .Replace(newCCY, expected_currency)).PollUntilReady(Samples.DataPollingOptions).ToReference())
                    .Post().ToReference())
                .Post().PollUntilReady(Samples.DataPollingOptions);
            ILayerView layerView = LayerViews.Create(TestResource.layer, newProfile);
            // Check that the correct target currency is predicted by our TargetCurrencyDefault attribute
            Assert.AreEqual(newCCY, TargetCurrencyDefault.GetDefaultTargetCurrency(layerView));
            // Post the new layerView and check that the expected target_currency is set by the server
            Assert.AreEqual(newCCY, layerView.Post().target_currency);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LayerView_GET_ExceedanceProbability_Filter_ZeroParticipation()
        {
            bool expect_error = true;
            ILayerView<T> modifiedResource = TestResource;
 
            // If this layer has a participation, we will set it to zero
            if (modifiedResource.layer is ILayer_WithTerms layer)
            {
                if (layer is SurplusShare surplusShare)
                    surplusShare.number_of_lines = 0;
                else
                    layer.participation = 0.0;
            }
            else
                // Layers that do not have participation
                expect_error = false;
 
            double threshold = 1.0;
            ExceedanceProbabilityOptions options =
                new ExceedanceProbabilityOptions(threshold_includes_participation: true);
 
            if (expect_error)
                POST_ThenDoAction(modifiedResource, view => AssertApi.ExceptionThrown(
                    () => _ = view.exceedance_probability_blocking(threshold, options, SimulationPolling),
                    AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest)));
            else
                // We expect this to succeed with the unmodified layer
                Test_IAPIResourceView_GET_ExceedanceProbability_Succeeds(threshold, options);
        }
 
        [TestMethod, TestCategory(TypeName), Obsolete("Tests the legacy back_allocations endpoint")]
        public override void Test_IAPIResourceView_GET_BackAllocations_Self()
        {
            if (TestSuite_Layer_BackAllocatedLayer.UnsupportedBackAllocatedLayerSinkTypes.Contains(typeof(T)))
            {
                Skip.Indefinitely("ARE-7212: BackAllocating Payment Patterns cause Internal Server Errors");
                Test_IAPIResourceView_Action_Fails(
                    view => view.back_allocations_blocking(view.id, SimulationPolling),
                    AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest));
            }
            else
                base.Test_IAPIResourceView_GET_BackAllocations_Self();
        }
 
        [TestMethod, TestCategory(TypeName), Obsolete("Tests the legacy back_allocations endpoint")]
        public override void Test_IAPIResourceView_GET_BackAllocations_SourceID_Invalid()
        {
            if (TestSuite_Layer_BackAllocatedLayer.UnsupportedBackAllocatedLayerSinkTypes.Contains(typeof(T)))
                Skip.Indefinitely("ARE-7212: BackAllocating Payment Patterns cause Internal Server Errors");
            base.Test_IAPIResourceView_GET_BackAllocations_SourceID_Invalid();
        }
    }
 
    #endregion Abstract Base LayerView Tests
 
}