Test_Simulation.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
 
using AnalyzeRe;
using AnalyzeRe.APITypes;
using AnalyzeRe.LargeDataUpload;
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_Simulation_Base : BaseAbstractStoredResourceTestSuite<Simulation>
    {
        protected override IResourceCollection<Simulation> collection_source => API.Simulations;
    }
 
    [TestClass]
    public sealed class TestSuite_Simulation_StaticSimulation : TestSuite_Simulation_WithData<StaticSimulation>
    {
        #region Set Up and Configuration
        private const string TypeName = "StaticSimulation";
        protected override IInjectableResource<StaticSimulation> TestInjectableResource =>
            Samples.Simulation_StaticSimulation;
 
        protected override string POSTData => Samples.CSV.Static_Simulation_Data;
        #endregion Set Up and Configuration
 
        [TestMethod, TestCategory(TypeName), TestCategory("Skipped")]
        public override void Test_Resource_Search()
        {
            Skip.Indefinitely("Bug ARE-5472 - Simulations don't support search by description.");
            base.Test_Resource_Search();
        }
 
        #region POST
        #region trial_count
        [TestMethod, TestCategory(TypeName)]
        public void Test_StaticSimulation_POST_TrialCount_LessThanLargestTrialCountInData()
        {
            StaticSimulation invalidTrialCount = TestResource;
            invalidTrialCount.trial_count = 9;
            GenericTest.POST_InvalidResourceWithData_Fails(invalidTrialCount,
                POSTData, (CommitFailedException ex) => { });
        }
        #endregion trial_count
 
        #region notes
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("This tests a now obsolete property for backwards compatibility purposes.")]
        public void Test_StaticSimulation_POST_Notes_Null()
        {
            POST_Attribute_Null(s => s.notes);
        }
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("This tests a now obsolete property for backwards compatibility purposes.")]
        public void Test_StaticSimulation_POST_Notes_Empty()
        {
            POST_WithValue(s => s.notes, new Dictionary<string, object>(), true);
        }
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("This tests a now obsolete property for backwards compatibility purposes.")]
        public void Test_StaticSimulation_POST_Notes_SpecialCharactersInKey()
        {
            POST_WithValue(s => s.notes, new Dictionary<string, object> { { "Test$.", "Test" } }, true);
        }
        #endregion notes
        #endregion POST
 
        #region PUT
        #region trial_count
        [TestMethod, TestCategory(TypeName)]
        public void Test_StaticSimulation_PUT_TrialCount()
        {
            PUT_WithValue(s => s.trial_count, 1234, true);
        }
        #endregion trial_count
 
        #region notes
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("This tests a now obsolete property for backwards compatibility purposes.")]
        public void Test_StaticSimulation_PUT_Notes()
        {
            PUT_WithValue(s => s.notes, new Dictionary<string, object> { { "Modified 1", "String" }, { "Modified 2", 10001 } }, true);
        }
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("This tests a now obsolete property for backwards compatibility purposes.")]
        public void Test_StaticSimulation_PUT_Notes_SpecialCharactersInKey()
        {
            PUT_WithValue(s => s.notes, new Dictionary<string, object> { { "Test$.", "Test" } }, true);
        }
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("This tests a now obsolete property for backwards compatibility purposes.")]
        public void Test_StaticSimulation_PUT_Notes_Null()
        {
            PUT_Attribute_Null(s => s.notes);
        }
        [TestMethod, TestCategory(TypeName)]
        [Obsolete("This tests a now obsolete property for backwards compatibility purposes.")]
        public void Test_StaticSimulation_PUT_Notes_Empty()
        {
            PUT_WithValue(s => s.notes, new Dictionary<string, object>(), true);
        }
        #endregion notes
        #endregion PUT
 
        #region Test Data
        [TestMethod, TestCategory(TypeName)]
        public void Test_StaticSimulation_POST_DataEmpty()
        {
            GenericTest.POST_ValidResourceWithData(TestResource,
                "\"TrialId\",\"Day\",\"EventId\"");
        }
        #endregion Test Data
    }
 
    #region Abstract Base Simulation Tests
    [TestClass]
    public abstract class TestSuite_Simulation_WithData<T> : BaseResourceWithDataTestSuite<T>
        where T : Simulation, IAPIResource_WithDataEndpoint
    {
        private const string TypeName = "Simulation";
 
        #region POST
        #region name
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Simulation_POST_Name_Null()
        {
            POST_Attribute_Null(s => s.name);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Simulation_POST_Name_Blank()
        {
            POST_StringAttribute_Empty(s => s.name);
        }
        #endregion name
        #region start_date
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_StartDate_MinValue()
        {
            DateTime minUtcDateTime = new DateTime(0L, DateTimeKind.Utc);
            POST_WithValue(l => l.start_date, minUtcDateTime, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_POST_StartDate_MaxValue()
        {
            DateTime maxUtcDateTime = new DateTime(DateTime.MaxValue.Ticks, DateTimeKind.Utc);
            POST_WithValue(l => l.start_date, maxUtcDateTime, true);
        }
        #endregion start_date
 
        #region event_catalogs
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Simulation_POST_EventCatalogs_Null()
        {
            POST_Attribute_Null(s => s.event_catalogs);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Simulation_POST_EventCatalogs_Empty()
        {
            POST_ListAttribute_Empty(s => s.event_catalogs);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Simulation_POST_EventCatalogs_Invalid()
        {
            POST_ReferenceList_NonExistantId(a => a.event_catalogs);
        }
        #endregion event_catalogs
        #endregion POST
 
        #region PUT
        #region name
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Simulation_PUT_Name()
        {
            PUT_WithValue(s => s.name, "Modified Name", true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Simulation_PUT_Name_Null()
        {
            PUT_Attribute_Null(s => s.name);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Simulation_PUT_Name_Blank()
        {
            PUT_StringAttribute_Empty(s => s.name);
        }
        #endregion name
 
        #region start_date
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_PUT_StartDate_MinValue()
        {
            DateTime minUtcDateTime = new DateTime(0L, DateTimeKind.Utc);
            PUT_WithValue(l => l.start_date, minUtcDateTime, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Layer_PUT_StartDate_MaxValue()
        {
            DateTime maxUtcDateTime = new DateTime(DateTime.MaxValue.Ticks, DateTimeKind.Utc);
            PUT_WithValue(l => l.start_date, maxUtcDateTime, true);
        }
        #endregion start_date
 
        #region event_catalogs
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Simulation_PUT_EventCatalogs()
        {
            PUT_WithValue(s => s.event_catalogs,
                new List<IReference<EventCatalog>> { Samples.EventCatalog.AsReference }, true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Simulation_PUT_EventCatalogs_Null()
        {
            PUT_Attribute_Null(s => s.event_catalogs);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Simulation_PUT_EventCatalogs_Empty()
        {
            PUT_ListAttribute_Empty(s => s.event_catalogs);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Simulation_PUT_EventCatalogs_Invalid()
        {
            PUT_ReferenceList_NonExistantId(a => a.event_catalogs);
        }
        #endregion event_catalogs
        #endregion PUT
    }
    #endregion Abstract Base Simulation Tests
}