Test_LossFilter.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
 
using AnalyzeRe;
using AnalyzeRe.APITypes;
using AnalyzeRe.Layers;
using AnalyzeRe.LossFilters;
using AnalyzeReTesting.Base;
using AnalyzeReTesting.Utilities;
 
#if MSTEST
using Microsoft.VisualStudio.TestTools.UnitTesting;
#elif NUNIT
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_LossFilter_Base : BaseAbstractStoredResourceTestSuite<LossFilter>
    {
        protected override IResourceCollection<LossFilter> collection_source => API.LossFilters;
        protected override bool PUT_Allowed => false;
 
        public static void TestFilterInLayerView<T>(T filter) where T : LossFilter
        {
            ILayerView<Filter> withFilter = Samples.GetInjectableLayerView(
                Samples.Layer_Filter.Unposted.Change(l => l.filters,
                    new List<IReference<LossFilter>> { filter.ToReference() })).Unposted;
            GenericTest.POST_ThenDoAction(withFilter,
                TestSuite_APIResourceView.TestMetricsRetrievable);
        }
    }
 
    #region LossFilter Derived Types
    [TestClass]
    public sealed class TestSuite_LossFilter_AndFilter : TestSuite_LossFilter_ExpressionFilter<AndFilter>
    {
        #region Set Up and Configuration
        private const string TypeName = "AndFilter";
        protected override IInjectableResource<AndFilter> TestInjectableResource =>
            Samples.LossFilter_AndFilter;
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_LossFilter_AnyFilter : TestSuite_LossFilter<AnyFilter>
    {
        #region Set Up and Configuration
        private const string TypeName = "AnyFilter";
        protected override IInjectableResource<AnyFilter> TestInjectableResource =>
            Samples.LossFilter_AnyFilter;
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_LossFilter_AnyOfFilter : TestSuite_LossFilter_AttributeFilter<AnyOfFilter>
    {
        #region Set Up and Configuration
        private const string TypeName = "AnyOfFilter";
        protected override IInjectableResource<AnyOfFilter> TestInjectableResource =>
            Samples.LossFilter_AnyOfFilter;
        #endregion Set Up and Configuration
 
        #region POST
        #region values
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnyOfFilter_POST_Values_Null()
        {
            POST_Attribute_Null(e => e.values);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnyOfFilter_POST_Values_Empty()
        {
            POST_ListAttribute_Empty(e => e.values);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_AnyOfFilter_POST_Values_Duplicates()
        {
            POST_ListAttribute_Duplicates(e => e.values, "Duplicate", true);
        }
        [TestMethod, TestCategory(TypeName), TestCategory("Skipped")]
        public void Test_AnyOfFilter_POST_Values_MixedTypes()
        {
            Skip.UntilRelease.Validation("Bug ARE-3378: " +
                "Possible to POST and PUT AnyOfFilter with Mixed types.");
            POST_WithValue(e => e.values, new List<object> { "Modified 1", 2 }, false);
        }
        #endregion values
        #endregion POST
    }
 
    [TestClass]
    public sealed class TestSuite_LossFilter_RecordTypeAnyOfFilter : TestSuite_LossFilter<RecordTypeAnyOfFilter>
    {
        #region Set Up and Configuration
        private const string TypeName = "RecordTypeAnyOfFilter";
        protected override IInjectableResource<RecordTypeAnyOfFilter> TestInjectableResource =>
            Samples.LossFilter_RecordTypeAnyOfFilter;
        #endregion Set Up and Configuration
 
        #region POST
        #region values
        [TestMethod, TestCategory(TypeName)]
        public void Test_RecordTypeAnyOfFilter_POST_Values_Null()
        {
            POST_Attribute_Null(e => e.values);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_RecordTypeAnyOfFilter_POST_Values_Empty()
        {
            POST_ListAttribute_Empty(e => e.values);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_RecordTypeAnyOfFilter_POST_Values_Duplicates()
        {
            POST_ListAttribute_Duplicates(e => e.values, RecordType.SlidingScaleCommission, true);
        }
        #endregion values
        #endregion POST
    }
 
 
    [TestClass]
    public sealed class TestSuite_LossFilter_GTFilter : TestSuite_LossFilter_ComparisonFilter<GTFilter>
    {
        #region Set Up and Configuration
        private const string TypeName = "GTFilter";
        protected override IInjectableResource<GTFilter> TestInjectableResource =>
            Samples.LossFilter_GTFilter;
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_LossFilter_LTFilter : TestSuite_LossFilter_ComparisonFilter<LTFilter>
    {
        #region Set Up and Configuration
        private const string TypeName = "LTFilter";
        protected override IInjectableResource<LTFilter> TestInjectableResource =>
            Samples.LossFilter_LTFilter;
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_LossFilter_OrFilter : TestSuite_LossFilter_ExpressionFilter<OrFilter>
    {
        #region Set Up and Configuration
        private const string TypeName = "OrFilter";
        protected override IInjectableResource<OrFilter> TestInjectableResource =>
            Samples.LossFilter_OrFilter;
        #endregion Set Up and Configuration
    }
 
    [TestClass]
    public sealed class TestSuite_LossFilter_RangeFilter : TestSuite_LossFilter_AttributeFilter<RangeFilter>
    {
        #region Set Up and Configuration
        private const string TypeName = "RangeFilter";
        protected override IInjectableResource<RangeFilter> TestInjectableResource =>
            Samples.LossFilter_RangeFilter;
        #endregion Set Up and Configuration
 
        #region POST
        #region begin_value
        [TestMethod, TestCategory(TypeName)]
        public void Test_RangeFilter_POST_BeginValue_MaxValue()
        {
            // Will fail because this will make begin_value > end_value
            POST_WithValue(l => l.begin_value, Double.MaxValue, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_RangeFilter_POST_BeginValue_MinValue()
        {
            POST_WithValue(l => l.begin_value, Double.MinValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_RangeFilter_POST_BeginValue_NaN()
        {
            POST_WithValue(l => l.begin_value, Double.NaN, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_RangeFilter_POST_BeginValue_Infinity()
        {
            POST_WithValue(l => l.begin_value, Double.PositiveInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_RangeFilter_POST_BeginValue_NegativeInfinity()
        {
            POST_WithValue(l => l.begin_value, Double.NegativeInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_RangeFilter_POST_BeginValue_HighPrecision()
        {
            POST_WithValue(l => l.begin_value, Math.PI / 1E12, true);
        }
        #endregion begin_value
 
        #region begin_inclusive
        // Nothing to test on post, Booleans are pretty simple
        #endregion begin_inclusive
 
        #region end_value
        [TestMethod, TestCategory(TypeName)]
        public void Test_RangeFilter_POST_EndValue_MaxValue()
        {
            POST_WithValue(l => l.end_value, Double.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_RangeFilter_POST_EndValue_MinValue()
        {
            // Will fail because it will make end_value < begin_value
            POST_WithValue(l => l.end_value, Double.MinValue, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_RangeFilter_POST_EndValue_NaN()
        {
            POST_WithValue(l => l.end_value, Double.NaN, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_RangeFilter_POST_EndValue_Infinity()
        {
            POST_WithValue(l => l.end_value, Double.PositiveInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_RangeFilter_POST_EndValue_NegativeInfinity()
        {
            POST_WithValue(l => l.end_value, Double.NegativeInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public void Test_RangeFilter_POST_EndValue_HighPrecision()
        {
            double newEndValue = TestResource.begin_value + Math.PI / 1E12;
            POST_WithValue(l => l.end_value, newEndValue, true);
        }
        #endregion end_value
 
        #region end_inclusive
        // Nothing to test on post, Booleans are pretty simple
        #endregion end_inclusive
        #endregion POST
    }
    #endregion LossFilter Derived Types
 
    #region Abstract Base LossFilter Tests
    [TestClass]
    public abstract class TestSuite_LossFilter_ExpressionFilter<T> : TestSuite_LossFilter<T> where T : ExpressionFilter
    {
        private const string TypeName = "ExpressionFilter";
 
        #region POST
        #region expressions
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ExpressionFilter_POST_Expressions_Null()
        {
            POST_Attribute_Null(l => l.expressions);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ExpressionFilter_POST_Expressions_Empty()
        {
            POST_ListAttribute_Empty(l => l.expressions);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ExpressionFilter_POST_Expressions_Duplicates()
        {
            POST_ListAttribute_Duplicates(
                e => e.expressions, Samples.LossFilter_AnyFilter.AsReference, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ExpressionFilter_POST_Expressions_Invalid()
        {
            POST_ReferenceList_NonExistantId(a => a.expressions);
        }
        #endregion expressions
        #endregion POST
    }
 
    [TestClass]
    public abstract class TestSuite_LossFilter_ComparisonFilter<T> : TestSuite_LossFilter_AttributeFilter<T>
        where T : ComparisonFilter
    {
        private const string TypeName = "ComparisonFilter";
 
        #region POST
        #region value
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ComparisonFilter_POST_Value_MaxValue()
        {
            POST_WithValue(l => l.value, Double.MaxValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ComparisonFilter_POST_Value_MinValue()
        {
            POST_WithValue(l => l.value, Double.MinValue, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ComparisonFilter_POST_Value_NaN()
        {
            POST_WithValue(l => l.value, Double.NaN, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ComparisonFilter_POST_Value_Infinity()
        {
            POST_WithValue(l => l.value, Double.PositiveInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ComparisonFilter_POST_Value_NegativeInfinity()
        {
            POST_WithValue(l => l.value, Double.NegativeInfinity, false);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_ComparisonFilter_POST_Value_HighPrecision()
        {
            POST_WithValue(l => l.value, Math.PI / 1E12, true);
        }
        #endregion value
 
        #region inclusive
        // Nothing to test on post, Booleans are pretty simple
        #endregion inclusive
        #endregion POST
    }
 
    [TestClass]
    public abstract class TestSuite_LossFilter_AttributeFilter<T> : TestSuite_LossFilter<T>
        where T : AttributeFilter
    {
        private const string TypeName = "AttributeFilter";
 
        #region POST
        #region attribute
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_AttributeFilter_POST_Attribute_Null()
        {
            POST_Attribute_Null(l => l.attribute);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_AttributeFilter_POST_Attribute_Blank()
        {
            POST_StringAttribute_Empty(l => l.attribute);
        }
        #endregion attribute
        #endregion POST
    }
 
    [TestClass]
    public abstract class TestSuite_LossFilter<T> : BaseImmutableResourceTestSuite<T> where T : LossFilter
    {
        private const string TypeName = "LossFilter";
 
        public override void AdditionalValidResourceTests(T posted) =>
            TestSuite_LossFilter_Base.TestFilterInLayerView(posted);
 
        #region POST
        #region name
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossFilter_POST_Name_Null()
        {
            POST_Attribute_Null(l => l.name);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_LossFilter_POST_Name_Blank()
        {
            POST_StringAttribute_Empty(l => l.name);
        }
        #endregion name
 
        #region invert
        // Nothing to test on post, Booleans are pretty simple
        #endregion invert
        #endregion POST
    }
    #endregion Abstract Base LossFilter Tests
}