Test_AnalysisProfile.cs

Go to the documentation of this file.

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
 
using AnalyzeRe;
using AnalyzeRe.APITypes;
using AnalyzeRe.Layers;
using AnalyzeRe.LossFilters;
using AnalyzeReTesting.Base;
using AnalyzeReTesting.Tests.Model.DataTypes;
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_AnalysisProfile_Base : BaseAbstractStoredResourceTestSuite<AnalysisProfile>
    {
        protected override bool PUT_Allowed => false;
        protected override IResourceCollection<AnalysisProfile> collection_source => API.AnalysisProfiles;
 
        // See models.py#AnyFilter.get_default_protobuf, currently
        // at https://github.com/analyzere/are-platform/blob/master/api-v1/loss_filters/models.py#L223
        public static string GetDefaultFilterNameForAnalysisProfile(IReference<AnalysisProfile> analysisProfile) =>
            Reflection.Resolve(Reflection.Resolve(analysisProfile).loss_filters
                .FirstOrDefault(lf => Reflection.Resolve(lf) is AnyFilter))?.name ?? "All Losses";
    }
 
    [TestClass]
    public sealed class TestSuite_AnalysisProfile : BaseImmutableResourceTestSuite<AnalysisProfile>
    {
        #region Set Up and Configuration
 
        private const string TypeName = "AnalysisProfile";
 
        protected override IInjectableResource<AnalysisProfile>
            TestInjectableResource => Samples.AnalysisProfile;
 
        #endregion Set Up and Configuration
 
        #region POST
 
        #region simulation
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_Simulation_Null()
        {
            POST_Attribute_Null(a => a.simulation);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_Simulation_Reference_NullId()
        {
            POST_Reference_NullId(a => a.simulation);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_Simulation_Reference_EmptyStringId()
        {
            POST_Reference_EmptyStringId(a => a.simulation);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_Simulation_Reference_NonExistantId()
        {
            POST_Reference_NonExistantId(a => a.simulation);
        }
 
        #endregion simulation
 
        #region event_catalogs
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_EventCatalogs_Null()
        {
            POST_Attribute_Null(a => a.event_catalogs);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_EventCatalogs_Empty()
        {
            POST_ListAttribute_Empty(a => a.event_catalogs);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_EventCatalogs_Invalid()
        {
            POST_ReferenceList_NonExistantId(a => a.event_catalogs);
        }
 
        #endregion event_catalogs
 
        #region loss_filters
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_LossFilters_Null()
        {
            POST_Attribute_Null(a => a.loss_filters);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_LossFilters_Empty()
        {
            POST_ListAttribute_Empty(a => a.loss_filters);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_LossFilters_Invalid()
        {
            POST_ReferenceList_NonExistantId(a => a.loss_filters);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_LossFilters_AllFilters()
        {
            POST_WithValue(a => a.loss_filters,
                Samples.AnalysisProfile.Unposted.loss_filters, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_LossFilters_UniqueNamesRequired()
        {
            List<IReference<LossFilter>> withDuplicateNames =
                new List<IReference<LossFilter>> { Samples.LossFilter_AnyFilter.AsReference };
            // Create a new filter with the same name (different description though)
            AnyFilter duplicate = Samples.LossFilter_AnyFilter.Unposted
                .Change(f => f.description, "same name, different filter").Post();
            withDuplicateNames.Add(duplicate.ToReference());
 
            POST_WithValue(a => a.loss_filters, withDuplicateNames, false);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_LossFilters_MissingAttribute()
        {
            const string filterName = "NO_MATCH_FILTER";
            POST_WithValue(a => a.loss_filters, new List<IReference<LossFilter>>
            {
                new AnyOfFilter
                {
                    name = filterName,
                    attribute = "Unknown",
                    values = new List<object> { 0d }
                }.Post().ToReference()
            }, false);
        }
 
        #endregion loss_filters
 
        #region exchange_rate_profile
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_ExchangeRateProfile_Null()
        {
            POST_Attribute_Null(a => a.exchange_rate_profile);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_ExchangeRateProfile_Reference_NullId()
        {
            POST_Reference_NullId(a => a.exchange_rate_profile);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_ExchangeRateProfile_Reference_EmptyStringId()
        {
            POST_Reference_EmptyStringId(a => a.exchange_rate_profile);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_ExchangeRateProfile_Reference_NonExistantId()
        {
            POST_Reference_NonExistantId(a => a.exchange_rate_profile);
        }
 
        #endregion exchange_rate_profile
 
        #region yelt_loss_set_simulation_filtering
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_YeltLossSetSimulationFiltering()
        {
            POST_WithValue(a => a.yelt_loss_set_simulation_filtering, true, true);
        }
 
        #endregion yelt_loss_set_simulation_filtering
 
        #region round_sequences
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_RoundSequences()
        {
            POST_WithValue(a => a.round_sequences, true, true);
        }
 
        #endregion round_sequences
 
        #region status
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnalysisProfile_POST_WaitForStatusToBeReady()
        {
            POST_ThenDoAction(TestResource, posted =>
            {
                Assert.IsTrue(posted.status.IsBusy(), "Expected the server behaviour to " +
                    "be one that asynchronously processes new Analysis Profiles.");
                AnalysisProfile ready = posted.PollUntilReady(Samples.DataPollingOptions);
                Assert.AreEqual(TaskStatus.Success, ready.status, "Expected the final " +
                    "Analysis Profile status to be \"processing_succeeded\"");
                // Check that the profile truly is ready by using it in a small layer_view
                ILayerView test = LayerViews.Create(new Filter(), posted).Post();
                Debug.WriteLine(test.id + " posted, so analysis profile must be ready.");
            });
        }
 
        #endregion status
 
        #region default_perspective
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_DefaultPerspective()
        {
            Skip.Indefinitely("ARE-6645: Remove skip and uncomment the AnalysisProfile.default_perspective" +
                "ServerHasDefault attribute once API changes are complete.");
            // Try a complex perspective
            POST_WithValue(l => l.default_perspective, Perspective.LossNetOf(Perspective.Base.ReinstatementPremium), true);
            // Try creating a variation on our analysis profile having every test perspective
            foreach (Perspective persp in TestSuite_Perspective.TestPerspectives)
                POST_WithValue(l => l.default_perspective, persp, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public void Test_LossSet_POST_DefaultPerspective_Null()
        {
            POST_Attribute_Null(l => l.default_perspective);
        }
        #endregion default_perspective
 
        #endregion POST
 
        // Put not allowed, no need for detailed PUT tests.
    }
}