Test_API_BugReports.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Net;
 
using AnalyzeRe;
using AnalyzeRe.Layers;
using AnalyzeRe.LossSets;
using AnalyzeRe.Utilities;
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.AnalyzeReAPI
{
    [TestClass]
    public class Test_API_BugReports : BaseServerTestSuite
    {
        private const string Category = "Test API BugReports";
 
        public Test_API_BugReports()
        {
            AddCommonTestInitializeAction(() =>
            {
                // All tests in this class require a connection.
                if (EnvironmentSettings.RUN_OFFLINE)
                    Assert.Inconclusive("RUN_OFFLINE = true");
            });
        }
 
        [TestMethod, TestCategory(Category)]
        public void Test_BUG_ARE_3807_LossSetCache()
        {
            // In this issue, each API thread maintained its own cache instance which was not being
            // cleared between requests - so to increase the odds of hitting a "Dirty" worker thread,
            // we submit the same request multiple times.
            const int api_workers = 4;
 
            // Get the analysis profile that will be used for validation.
            AnalysisProfile ap = Samples.AnalysisProfile.Posted;
            // Post a layer that uses a loss set with the same catalog as the above analysis profile
            CatXL goodLayer = Samples.Layer_CatXL.Posted;
 
            // Post Several QCLS Loss Sets with one event catalog.
            EventCatalog differentCatalog = Samples.EventCatalog.Posted.Post()
                .PollUntilReady(Samples.DataPollingOptions);
            Simulation differentSimulation = Samples.Simulation_StaticSimulation.Posted
                .Change(s => s.event_catalogs,
                        new List<IReference<EventCatalog>> { differentCatalog.ToReference() })
                .Post().PollUntilReady(Samples.DataPollingOptions);
            QCLSLossSet[] qclsLossSets = new QCLSLossSet[api_workers];
 
            // Post QCLS Loss Sets that reference the wrong event catalog.
            for (int i = 0; i < api_workers; i++)
            {
                qclsLossSets[i] = new QCLSLossSet
                {
                    description = "QCLS" + i,
                    simulation = differentSimulation.ToReference(),
                    correlation_coefficient = 1d,
                    distribution = Samples.Distribution_CustomSeverityDistribution.AsReference,
                    currency = "USD"
                }.Post();
 
                // Post nested layer_view(s) that intentionally reference the invalid loss sets.
                try
                {
                    IReference<Filter> CreateInlinedFilter() => new Filter
                    {
                        loss_sets = new List<IReference<LossSet>> { qclsLossSets[i].ToReference() }
                    }.ToReference();
                    new LayerView<Nested>
                    {
                        analysis_profile = ap.ToReference(),
                        layer = new Nested
                        {
                            sink = CreateInlinedFilter(),
                            sources = new Nested.Sources(CreateInlinedFilter())
                        }
                    }.Post();
                }
                // Ignore the error that is raised.
                catch (Exception ex)
                {
                    Console.Write("Expected error:" + ex.Message);
                }
            }
 
            for (int i = 0; i < api_workers; i++)
            {
                // Post a layer_view that references only good things. This post should succeed,
                // but in the issue scenario, it fails due to old information from the previous POST
                new LayerView<Nested>
                {
                    analysis_profile = ap.ToReference(),
                    layer = new Nested
                    {
                        sink = goodLayer.ToReference(),
                        sources = new Nested.Sources(goodLayer.ToReference())
                    }
                }.Post();
            }
        }
 
        [TestMethod, TestCategory(Category)]
        public void Test_BUG_ARE_3821_BadQCLSLossSetLayerReference()
        {
            // Get the analysis profile that will be used for validation.
            AnalysisProfile ap = Samples.AnalysisProfile.Posted;
 
            // Post Several QCLS Loss Sets with one event catalog.
            EventCatalog differentCatalog = Samples.EventCatalog.Posted.Post()
                .PollUntilReady(Samples.DataPollingOptions);
            Simulation differentSimulation = Samples.Simulation_StaticSimulation.Posted
                .Change(s => s.event_catalogs,
                        new List<IReference<EventCatalog>> { differentCatalog.ToReference() })
                .Post().PollUntilReady(Samples.DataPollingOptions);
            QCLSLossSet badQCLSLossSets = new QCLSLossSet
            {
                description = "Bad QCLS",
                simulation = differentSimulation.ToReference(),
                correlation_coefficient = 1d,
                distribution = Samples.Distribution_CustomSeverityDistribution.AsReference,
                currency = "USD"
            }.Post();
 
            QuotaShare quotaShareWithBadLossSet = new QuotaShare
            {
                description = "QS with bad QCLS",
                event_limit = new MonetaryUnit(Double.MaxValue, "USD"),
                participation = 1.0,
                loss_sets = new List<IReference<LossSet>> { badQCLSLossSets.ToReference() }
            }.Post();
 
            // Post nested layer_view(s) that intentionally reference the invalid loss sets.
            ILayerView badLayerView = new LayerView<Nested>
            {
                analysis_profile = ap.ToReference(),
                layer = new Nested
                {
                    sink = quotaShareWithBadLossSet.ToReference(),
                    sources = new Nested.Sources(quotaShareWithBadLossSet.ToReference())
                }
            };
            AssertApi.ExceptionThrown(() => badLayerView.Post(),
                AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest));
        }
 
        [TestMethod, TestCategory(Category), TestCategory("Randomized")]
        public void Test_BUG_ARE_7093_Reflection_GetCollectionName_LossSource()
        {
            // Test against random failures observed when generating references for base types
            // Test at multiple recursion depths in case this is responsible for the behaviour
            Type testType = typeof(ILayerSource);
            for (int i = 0; i < 10; i++)
            {
                object result = Reflection.GetRandomExistingResource(testType,
                    new Reflection.RecursionContext(testType, i));
                if(result is IReference<ILayerSource> randomReference)
                    Console.WriteLine($"Test {i + 1} generated reference: {randomReference.ref_id} " +
                        $"with type {result.GetType().NiceTypeName()}");
                else
                    Assert.Fail($"Test {i + 1} generated a {result?.GetType().NiceTypeName() ?? "null"}");
            }
        }
    }
}