Test_PortfolioView.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Net;
 
using AnalyzeRe;
using AnalyzeRe.APITypes;
using AnalyzeRe.Distributions;
using AnalyzeRe.Layers;
using AnalyzeRe.LossSets;
using AnalyzeRe.Metrics;
using AnalyzeReTesting.Base;
using AnalyzeReTesting.Utilities;
 
#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
{
    [TestClass]
    public sealed class TestSuite_PortfolioView_Base : BaseAbstractResourceTestSuite<PortfolioView>
    {
        private const string TypeName = "PortfolioView";
 
        protected override bool PUT_Allowed => false;
        protected override IResourceCollection<PortfolioView> collection_source => API.PortfolioViews;
 
        [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_PortfolioView_BothLayerViewsAndPortfolio()
        {
            PortfolioView invalid = Samples.PortfolioView_WithLayerViews.Unposted;
            invalid.portfolio = Samples.Portfolio.AsReference;
            //"layer_views or portfolio must be provided, but not both."
            GenericTest.POST_InvalidResource_Fails(invalid);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_Marginal()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            PortfolioView basePortfolio = Samples.PortfolioView_WithLayerViews.Posted;
            ILayerView added = Samples.LayerView_Generic.Posted;
            IReference<ILayerView> removed = basePortfolio.layer_views.First();
            IReference<PortfolioView> result = API.PortfolioViewMarginals.Post(
                basePortfolio.ToReference(),
                new[] { added.ToReference() },
                new[] { removed });
            // Check that the new marginal portfolio looks like what we would expect.
            PortfolioView resolved = result.GetValue();
            // Added layer now exists
            Assert.IsTrue(resolved.layer_views.Any(lv => lv.ref_id == added.id));
            // Removed layer is gone
            Assert.IsFalse(resolved.layer_views.Any(lv => lv.ref_id == removed.ref_id));
            // All other layers from the original portfolio still exist.
            Assert.IsTrue(basePortfolio.layer_views.Skip(1)
                .All(lv => resolved.layer_views.Any(newlv => newlv.ref_id == lv.ref_id)));
        }
 
        #region Target Currency
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_TargetCurrency_MatchesPortfolioLayers()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            CatXL baseLayer = Samples.Layer_CatXL.Unposted;
            // Create two USD and one EUR layer.
            baseLayer.limit = new MonetaryUnit(baseLayer.limit.value, "USD");
            CatXL l1_usd = baseLayer.Post();
            CatXL l5_usd = baseLayer.Post();
            baseLayer.limit = new MonetaryUnit(baseLayer.limit.value, "EUR");
            CatXL l2_eur = baseLayer.Post();
            CatXL l3_eur = baseLayer.Post();
            CatXL l4_eur = baseLayer.Post();
            // Create a portfolio that references all these layers.
            StaticPortfolio toReference = new StaticPortfolio
            {
                layers = new HashSet<IReference<ILayer>>
                {
                    l1_usd.ToReference(), l2_eur.ToReference(), l3_eur.ToReference(),
                    l4_eur.ToReference(), l5_usd.ToReference()
                },
                name = "5 layers",
                description = "5 layers"
            }.Post();
            // Now post as a portfolio view.
            IReference<AnalysisProfile> analysis_profile =
                Samples.AnalysisProfile.AsReference;
            GenericTest.POST_ThenDoAction(
                new PortfolioView
                {
                    analysis_profile = analysis_profile,
                    portfolio = toReference.ToReference()
                },
                // Assert that the target currency returned by the server is EUR
                pv => Assert.AreEqual("EUR", pv.target_currency));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_TargetCurrency_MatchesLayerViews()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            CatXL baseLayer = Samples.Layer_CatXL.Unposted;
            IReference<AnalysisProfile> analysis_profile =
                Samples.AnalysisProfile.AsReference;
            PortfolioView toPost = new PortfolioView { analysis_profile = analysis_profile };
            // Create a USD layer_view, then 3 EUR layer_views, then another USD layer_view.
            toPost.layer_views.Add(LayerViews.Create(baseLayer, analysis_profile, "USD").Post().ToReference());
            baseLayer.description = "Layer 2";
            toPost.layer_views.Add(LayerViews.Create(baseLayer, analysis_profile, "EUR").Post().ToReference());
            baseLayer.description = "Layer 3";
            toPost.layer_views.Add(LayerViews.Create(baseLayer, analysis_profile, "EUR").Post().ToReference());
            baseLayer.description = "Layer 4";
            toPost.layer_views.Add(LayerViews.Create(baseLayer, analysis_profile, "EUR").Post().ToReference());
            baseLayer.description = "Layer 5";
            toPost.layer_views.Add(LayerViews.Create(baseLayer, analysis_profile, "USD").Post().ToReference());
            // Now test that the majority target currency got set on the PortfolioView
            GenericTest.POST_ThenDoAction(toPost, pv => Assert.AreEqual("EUR", pv.target_currency));
        }
        #endregion Target Currency
    }
 
    [TestClass]
    public sealed class TestSuite_PortfolioView_WithPortfolio : TestSuite_PortfolioView
    {
        #region Set Up and Configuration
        private const string TypeName = "PortfolioView";
        protected override IInjectableResource<PortfolioView> TestInjectableResource =>
            Samples.PortfolioView_WithPortfolio;
        #endregion Set Up and Configuration
 
        #region POST
        #region portfolio
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_Portfolio_Null()
        {
            POST_WithValue(l => l.portfolio, null, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_Portfolio_Reference_NullId()
        {
            POST_Reference_NullId(l => l.portfolio);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_Portfolio_Reference_EmptyStringId()
        {
            POST_Reference_EmptyStringId(l => l.portfolio);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_Portfolio_Reference_NonExistantId()
        {
            POST_Reference_NonExistantId(l => l.portfolio);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_Portfolio_Reference_AllLayerTypes()
        {
            GenericTest.POST_ThenDoAction(
                new StaticPortfolio
                {
                    name = "All Layer Types",
                    description = "All Layer Types",
                    layers = new HashSet<IReference<ILayer>>(
                        Samples.AllSaveableLayerTypesTestList.Select(ly => ly.AsReference))
                }, allLayerTypes =>
                    POST_WithValue(l => l.portfolio, allLayerTypes.ToReference(), true));
        }
        #endregion portfolio
 
        #region MixedLossSetTypes
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_Portfolio_Reference_Layers_MixedLossSetTypes()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            // Not all metrics are available for a PortfolioView whose layerViews reference
            // a mixture of loss_set loss_types
            AggXL layerNetAggDefinition = Samples.Layer_AggXL.Unposted;
            layerNetAggDefinition.loss_sets =
                new List<IReference<LossSet>> { Samples.LossSet_YLTLossSet.AsReference };
            IInjectableResource<ILayer> layerNetAgg =
                InjectableResource.Create(layerNetAggDefinition);
            IInjectableResource<StaticPortfolio> mixedPortfolio =
                InjectableResource.Create(new StaticPortfolio
                {
                    name = "Profile of Mixed Layer LossSet Types",
                    description = "Profile of Mixed Layer LossSet Types",
                    layers = new HashSet<IReference<ILayer>>
                    {
                        Samples.Layer_AggXL.AsReference,
                        layerNetAgg.AsReference
                    }
                });
            POST_ThenDoAction(TestResource.Change(pv => pv.portfolio, mixedPortfolio.AsReference),
                posted => Test_IAPIResourceView_Metrics_MixedLossTypes(posted));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_Portfolio_Reference_OneLayer_MixedLossSetTypes()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            // A layer may be posted such that it contains mixed loss set types, but this
            // the resulting portfolio_view metrics must only support perspectives corresponding
            // to the highest granularity source loss data supplied.
            IInjectableResource<StaticPortfolio> mixedPortfolio =
                InjectableResource.Create(new StaticPortfolio
                {
                    name = "Profile of Mixed Layer LossSet Types",
                    description = "Profile of Mixed Layer LossSet Types",
                    layers = new HashSet<IReference<ILayer>>
                    {
                        InjectableResource.Create(Samples.Layer_AggXL.Unposted
                            .Change(l => l.loss_sets, Samples.AllLossSetTypesTestList
                                .Select(ls => ls.AsReference).ToList())).AsReference
                    }
                });
            POST_ThenDoAction(TestResource.Change(pv => pv.portfolio, mixedPortfolio.AsReference),
                posted => Test_IAPIResourceView_Metrics_MixedLossTypes(posted));
        }
        #endregion MixedLossSetTypes
 
        [TestMethod, TestCategory(TypeName)]
        public override void Test_Resource_POST_ExistingId()
        {
            PortfolioView original = TestResource_Existing;
            Console.WriteLine($"Test resource unposted: {TestResource.Serialize()}");
            Console.WriteLine($"Test resource posted:   {original.Serialize()}");
            // Test posting a resource with the same id, same list of layer_views
            PortfolioView test1 = original.DeepCopy().Change(pv => pv.layer_views, null);
            POST_ThenDoAction(test1, copy =>
            {
                Assert.AreEqual(original.ylt_id, copy.ylt_id, "Expected the same portfolio_view ylt_id " +
                    "regardless of whether it's created with a portfolio reference or layer_views.");
                // Bug: ARE-6210 - Server-Generated properties (ylt_id) impact  portfolio_view id on POST
                //Assert.AreEqual(original.id, copy.id, "Expected the same portfolio_view id " +
                //    "because the original was also posted using a portfolio reference.");
                Assert.AreNotEqual(original.id, copy.id, "Bug ARE-6210 changes the id even though the " +
                    "resources are identical. Let us know when this is no longer the case.");
            });
            // ARE-6210 can be avoided by further stripping out server-generated properties
            PortfolioView test2 = original.DeepCopy().Change(pv => pv.layer_views, null)
                .Change(pv => pv.target_currency, null).Change(pv => pv.ylt_id, null).Change(pv => pv.id, null);
            POST_ThenDoAction(test2, copy =>
            {
                Assert.AreEqual(original.ylt_id, copy.ylt_id, "Expected the same portfolio_view ylt_id " +
                    "regardless of whether it's created with a portfolio reference or layer_views.");
                Assert.AreEqual(original.id, copy.id, "Expected the same portfolio_view id " +
                    "because all server generated properties were removed for ARE-6210.");
            });
 
            PortfolioView test3 = original.DeepCopy().Change(pv => pv.portfolio, null);
            POST_ThenDoAction(test3, copy =>
            {
                Assert.AreEqual(original.ylt_id, copy.ylt_id, "Expected the same portfolio_view ylt_id " +
                    "regardless of whether it's created with a portfolio reference or layer_views.");
                Assert.AreNotEqual(original.id, copy.id, "The server currently does not return the " +
                    "same id when a portfolio_view is posted from the equivalent set of layer_views. " +
                    "If this changes, great! - we just want to know about it.");
            });
        }
        #endregion POST
    }
 
    [TestClass]
    public sealed class TestSuite_PortfolioView_WithLayerViews : TestSuite_PortfolioView
    {
        #region Set Up and Configuration
        private const string TypeName = "PortfolioView";
        protected override IInjectableResource<PortfolioView> TestInjectableResource =>
            Samples.PortfolioView_WithLayerViews;
        #endregion Set Up and Configuration
 
        #region POST
        #region layer_views
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_LayerViews_Null()
        {
            POST_WithValue(l => l.layer_views, null, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_LayerViews_Empty()
        {
            POST_WithValue(a => a.layer_views, new HashSet<IReference<ILayerView>>(), false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_LayerViews_Invalid()
        {
            HashSet<IReference<ILayerView>> reference =
                new HashSet<IReference<ILayerView>> { new Reference<ILayerView>(Samples.Valid_NonExistant_UUID) };
            POST_WithValue(a => a.layer_views, reference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_LayerViews_BadlyFormed()
        {
            HashSet<IReference<ILayerView>> reference =
                new HashSet<IReference<ILayerView>> { new Reference<ILayerView>("Invalid") };
            POST_WithValue(a => a.layer_views, reference, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_LayerView_AllLayerTypes()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            IReference<AnalysisProfile> ap = TestResource.analysis_profile;
            HashSet<IReference<ILayerView>> allLayerTypes = new HashSet<IReference<ILayerView>>(
                Samples.AllLayerTypesTestList.Select(ly =>
                    LayerViews.Create(ly.Unposted, ap).Post().ToReference()));
            POST_WithValue(l => l.layer_views, allLayerTypes, true);
        }
        #endregion layer_views
 
        #region MixedLossSetTypes
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_LayerViews_MixedLossSetTypes()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            IReference<AnalysisProfile>analysis_profile = TestResource.analysis_profile;
            ILayerView<ILayer_WithLossSets> layerViewGross =
                LayerViews.Create(Samples.Layer_AggXL.Unposted, analysis_profile).Post();
            ILayer_WithLossSets layerNetAgg = layerViewGross.layer.ShallowCopy();
            layerNetAgg.loss_sets =
                new List<IReference<LossSet>> { Samples.LossSet_YLTLossSet.AsReference };
            IInjectableResource<ILayerView> layerViewNetAgg =
                InjectableResource.Create(new LayerView<ILayer>
                {
                    layer = layerNetAgg,
                    analysis_profile = analysis_profile
                });
            HashSet<IReference<ILayerView>> references = new HashSet<IReference<ILayerView>>
            {
                layerViewGross.ToReference(),
                layerViewNetAgg.AsReference
            };
            POST_ThenDoAction(TestResource.Change(pv => pv.layer_views, references),
                posted => Test_IAPIResourceView_Metrics_MixedLossTypes(posted));
        }
 
        // This test is needed as a result of a Bug (ARE-1330) that was (behind the scenes)
        // changing the loss type of NestedLayer losses when converting them to a NestedLayerLossSet.
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_LayerViews_LossGross_NestedLayer()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            IReference<AnalysisProfile> analysis_profile = TestResource.analysis_profile;
            // Create a simple DiracDistribution that returns a loss of 1
            DiracDistribution oneDistribution = new DiracDistribution { description = "One", value = 1 }.Post();
            // Create a simple LossNetOfAggregateTerms Parametric LossSet
            ParametricLossSet oneLoss = new ParametricLossSet
            {
                currency = "USD",
                description = "Gross Loss of 1",
                frequency = oneDistribution.ToReference(),
                seasonality = oneDistribution.ToReference(),
                severity = oneDistribution.ToReference(),
                loss_type = LossType.LossGross
            }.Post();
            // Create a simple QuotaShare layerView that uses this lossSet
            QuotaShare qsLayer = Samples.Layer_QuotaShare.Unposted;
            qsLayer.description = "Simple 1 loss layer";
            qsLayer.loss_sets = new List<IReference<LossSet>> { oneLoss.ToReference() };
            qsLayer = qsLayer.Post();
            QuotaShare qsLayer2 = qsLayer.Post();
            // Create a simple NestedLayer that uses 2 (identical) QuotaShare layers.
            Nested nestedLayer = new Nested
            {
                description = "Simple nested layer",
                sources = new List<IReference<ILayer>> { qsLayer.ToReference(), qsLayer2.ToReference() },
                sink = qsLayer.ToReference()
            }.Post();
            // Turn both layers into layerViews
            ILayerView<Nested> nestedLayerView = LayerViews.Create(nestedLayer, analysis_profile).Post();
 
            // Create a PortfolioView that references these two LayerViews
            HashSet<IReference<ILayerView>> layer_views = new HashSet<IReference<ILayerView>>
            {
                nestedLayerView.ToReference()
            };
            new PortfolioView { layer_views = layer_views, analysis_profile = analysis_profile }.Post();
            POST_WithValue(a => a.layer_views, layer_views, true);
        }
        #endregion MixedLossSetTypes
        #endregion POST
    }
 
    #region Abstract Base Test Class
    [TestClass]
    public abstract class TestSuite_PortfolioView : TestSuite_APIResourceView<PortfolioView>
    {
        private const string TypeName = "PortfolioView";
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_PortfolioView_Premium()
        {
            // Assert that the server computes and returns the correct premium for the portfolio_view
            PortfolioView portfolioView = TestResource_Existing;
            Assert.IsNotNull(portfolioView.premium);
            Console.WriteLine($"PortfolioView Premium: {portfolioView.premium}");
            Assert.AreEqual(portfolioView.target_currency, portfolioView.premium.currency);
            // To compute premium we need to get all referenced layer_views.
            List<ILayer_WithTerms> constituentsWithPremium = portfolioView.layer_views
                .Select(lv => Reflection.Resolve(lv).layer).OfType<ILayer_WithTerms>().ToList();
            Console.WriteLine("Constituents:\n" + String.Join("\n", constituentsWithPremium
                .Select(l => $"- Premium: {l.premium} Share: {l.participation}")));
 
            // This simple test is only designed to work if all premiums are in the same currency.
            // API unit tests should verify that currency conversion is working as expected.
            Assert.IsTrue(constituentsWithPremium.All(lyr => lyr.premium.currency == portfolioView.target_currency),
                "Expected all constituent layer premiums to have the same currency. Test cannot proceed.");
            // Compute the premium
            double expectedPremium = constituentsWithPremium.Sum(lyr => lyr.premium.value * lyr.participation);
            AssertApi.DoublesAreEqual(expectedPremium, portfolioView.premium.value);
        }
 
        #region BackAllocations
        [TestMethod, TestCategory(TypeName), Obsolete("Tests the legacy back_allocations endpoint")]
        public override void Test_IAPIResourceView_GET_BackAllocations_Self()
        {
            // TODO: PortfolioViews currently can't be used as a back-allocation target.
            Skip.Indefinitely("ARE-5129: 'Source not found' erroneously raised when back-allocating to self.");
            base.Test_IAPIResourceView_GET_BackAllocations_Self();
        }
 
        [TestMethod, TestCategory(TypeName), Obsolete("Tests the legacy back_allocations endpoint")]
        public virtual void Test_PortfolioView_GET_BackAllocations_ToLayer()
        {
            Test_IAPIResourceView_Action_Succeeds(view =>
            {
                BackAllocations result = view.back_allocations_blocking(
                    view.layer_views.First().ref_id, SimulationPolling);
                VerifyBackAllocationSuccess(result);
            });
        }
        #endregion BackAllocations
 
        #region PostMarginalPortfolioView
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_Marginal_AddLayerView()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            PortfolioView portfolioView = TestResource_Existing;
            IReference<ILayerView> layer_view_to_add = Samples.LayerView_Nested.Unposted
                .Change(lv => lv.analysis_profile, portfolioView.analysis_profile)
                .Post().ToReference();
            IReference<PortfolioView> newPv = portfolioView.PostMarginalPortfolio(
                new[] { layer_view_to_add });
 
            PortfolioView created = newPv.GetValue();
            // The new layer_view should appear in the new portfolio_view
            Assert.AreEqual(portfolioView.layer_views.Count + 1, created.layer_views.Count);
            Assert.IsTrue(created.layer_views.Any(lv => lv.ref_id == layer_view_to_add.ref_id));
        }
 
        [TestMethod, TestCategory(TypeName), TestCategory("Skipped")]
        public void Test_PortfolioView_POST_Marginal_AddDuplicateLayerView()
        {
            Skip.Indefinitely("ARE-2767 - " +
                "Support Duplicate Layers in Portfolios and LayerViews in PortfolioViews");
            PortfolioView portfolioView = TestResource_Existing;
            IReference<ILayerView> existing = portfolioView.layer_views.First();
            IReference<PortfolioView> newPv = portfolioView.PostMarginalPortfolio(
                new[] { existing });
 
            PortfolioView created = newPv.GetValue();
            // The layer_view should appear in the new portfolio_view twice
            Assert.AreEqual(portfolioView.layer_views.Count + 1, created.layer_views.Count);
            Assert.AreEqual(2, created.layer_views.Count(lv => lv.ref_id == existing.ref_id));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_Marginal_RemoveLayerView()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            PortfolioView portfolioView = TestResource_Existing;
            IReference<ILayerView> existing = portfolioView.layer_views.First();
            IReference<PortfolioView> newPv = portfolioView.PostMarginalPortfolio(
                layerViewsToRemove: new[] { existing });
 
            PortfolioView created = newPv.GetValue();
            // The layer_view should no longer appear in the new portfolio_view
            Assert.AreEqual(portfolioView.layer_views.Count - 1, created.layer_views.Count);
            Assert.IsFalse(created.layer_views.Any(lv => lv.ref_id == existing.ref_id));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_Marginal_NoChange()
        {
            AssertApi.ExceptionThrown(() => TestResource_Existing.PostMarginalPortfolio(),
                (ArgumentException ex) => Assert.AreEqual(
                    "You must specify either layers to add or layers to remove, or both.", ex.Message));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_PortfolioView_POST_Marginal_NoId()
        {
            AssertApi.ExceptionThrown(() => TestResource.PostMarginalPortfolio(),
                (ArgumentException ex) => Assert.AreEqual(
                    "The referenced base portfolio_view reference has no id.", ex.Message));
        }
        #endregion PostMarginalPortfolioView
    }
    #endregion Abstract Base Test Class
}