BaseMutableResourceTestSuite.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq.Expressions;
using System.Net;
using AnalyzeRe;
using AnalyzeRe.APITypes;
using AnalyzeRe.Attributes;
using AnalyzeRe.Utilities;
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.Base
{
    [TestClass]
    public abstract class BaseMutableResourceTestSuite<T> : BaseStoredResourceTestSuite<T> where T : IStoredAPIResource
    {
        private const string TypeName = "BaseMutableResourceTest";
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_PUT_NoChanges()
        {
            // Show that PUT succeeds for mutable resources (even if no changes were made)
            PUT_WithChanges_Succeeds(r => r);
        }
        
        #region description
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_PUT_Description()
        {
            PUT_WithValue(a => a.description, "Modified Description", true);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_PUT_Description_Null()
        {
            PUT_Attribute_Null(a => a.description);
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_PUT_Description_Blank()
        {
            PUT_StringAttribute_Empty(a => a.description);
        }
        #endregion description
 
        #region created and modified
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_PUT_CreatedAndModified()
        {
            POST_ForPutTest(TestResource, posted =>
            {
                T put = default(T);
                AssertApi.MethodIsAllowed(delegate { put = posted.Put(); }, "PUT", true);
 
                Assert.IsNotNull(put.created, "Expected a 'created' date to be assigned.");
                Assert.AreEqual(posted.created, put.created,
                    "Created date changed, but it shouldn't have!");
                Assert.IsNotNull(put.modified, "Expected a 'modified' date to be assigned.");
                Assert.AreNotEqual(put.created, put.modified,
                    "Modified date is still the same as created date!");
            });
        }
        #endregion created and modified
 
        #region meta_data
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_PUT_Metadata_Null()
        {
            PUT_Attribute_Null(a => a.meta_data);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_PUT_Metadata_Empty()
        {
            PUT_WithValue(l => l.meta_data, new Dictionary<string, object>(), true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_PUT_Metadata_MixedTypes()
        {
            Dictionary<string, object> mixedTypes = new Dictionary<string, object>
            {
                { "Test1", "TestValue" },
                { "Test2", 2 },
                { "Test 3", 3.33 },
                { "Test 4", true }
            };
            PUT_WithValue(l => l.meta_data, mixedTypes, true);
        }
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_PUT_Metadata_InvalidValues()
        {
            Dictionary<string, object> TestDict(string key, object value) =>
                new Dictionary<string, object> { { key, value } };
 
            PUT_WithValue(l => l.meta_data, TestDict("Test1", TestDict("Nested", "Nested")), false);
            PUT_WithValue(l => l.meta_data, TestDict("Test1", null), false);
            PUT_WithValue(l => l.meta_data, TestDict("Test1", Double.PositiveInfinity), false);
            PUT_WithValue(l => l.meta_data, TestDict("Test1", Double.NaN), false);
        }
        #endregion meta_data
 
        #region PUT Test Method Helpers
        protected virtual T POST_ForPutTest(T validToPost, Action<T> putTest) =>
            GenericTest.POST_ThenDoAction(validToPost, putTest);
 
        public T PUT_WithValue<TProperty>(Expression<Func<T, TProperty>> PropertyExpression,
            TProperty newValue, bool shouldSucceed)
        {
            T ModifyTestResource(T posted) => posted.ShallowCopy().Change(PropertyExpression, newValue);
            return shouldSucceed ? PUT_WithChanges_Succeeds(ModifyTestResource) :
                PUT_WithChanges_Fails(ModifyTestResource);
        }
 
        public virtual T PUT_WithChanges_Succeeds(Func<T, T> modifyTestResource)
        {
            T putResponse = default(T);
            POST_ForPutTest(TestResource, posted =>
            {
                T toPut = modifyTestResource(posted);
                AssertApi.MethodIsAllowed(() => GenericTest.ExecuteWithConsoleErrorLogging(() => putResponse = toPut.Put()), "PUT");
                AssertApi.PutResponseMatches(posted, toPut, putResponse);
                // New: Perform additional validation tests to ensure the new resource
                //      doesn't result in errors that only manifest themselves downstream.
                AdditionalValidResourceTests(putResponse);
            });
            return putResponse;
        }
 
        public T PUT_WithChanges_Fails(Func<T, T> modifyTestResource) =>
            POST_ForPutTest(TestResource, posted =>
                GenericTest.PUT_Fails(modifyTestResource(posted),
                    AssertApi.ApiExceptionTest(HttpStatusCode.BadRequest)));
 
        public void PUT_Attribute_Null<TProperty>(Expression<Func<T, TProperty>> PropertyExpression)
        {
            if (!Equals(default(TProperty), null))
                throw new ArgumentException("Can only be used on properties whose default type is null.");
            bool shouldSucceed = !ReflectionUtilities.PropertyHasAttribute(PropertyExpression, typeof(NotNullAttribute));
            PUT_WithValue(PropertyExpression, default(TProperty), shouldSucceed);
        }
 
        public void PUT_StringAttribute_Empty(Expression<Func<T, string>> PropertyExpression,
            bool? shouldSucceed = null)
        {
            if (!shouldSucceed.HasValue)
                shouldSucceed = !ReflectionUtilities.PropertyHasAttribute(PropertyExpression, typeof(NotEmptyAttribute));
            PUT_WithValue(PropertyExpression, "", shouldSucceed.Value);
            // TODO: Do a message check.
            // Output.MsgMissingAttribute(((MemberExpression)PropertyExpression.Body).Member.Name, validResource._type));
        }
 
        #region List Attribute Test Helpers
        public void PUT_ListAttribute_Empty<TItem>(
            Expression<Func<T, ICollection<TItem>>> PropertyExpression, bool? shouldSucceed = null)
        {
            if (!shouldSucceed.HasValue)
                shouldSucceed = !ReflectionUtilities.PropertyHasAttribute(PropertyExpression, typeof(NotEmptyAttribute));
            ICollection<TItem> newList = NewCollection(PropertyExpression);
            PUT_WithValue(PropertyExpression, newList, shouldSucceed.Value);
            // TODO: Do a message check.
            // Output.MsgMissingAttribute(((MemberExpression)PropertyExpression.Body).Member.Name, validResource._type));
        }
        public void PUT_ListAttribute_Duplicates<TItem, TValue>(
            Expression<Func<T, ICollection<TItem>>> PropertyExpression,
            TValue valueToDuplicate, bool shouldSucceed)
            where TValue : TItem
        {
            ICollection<TItem> newList = NewCollection(PropertyExpression,
                new TItem[] { valueToDuplicate, valueToDuplicate });
            // Perform the PUT
            PUT_WithValue(PropertyExpression, newList, shouldSucceed);
            // TODO: Do a message check.
            // Output.MsgMissingAttribute(((MemberExpression)PropertyExpression.Body).Member.Name, validResource._type));
        }
        #endregion List Attribute Test Helpers
 
        #region Reference Attribute Test Helpers
        public void PUT_Reference_NullId<TRefType>(
            Expression<Func<T, IReference<TRefType>>> PropertyExpression)
            where TRefType : IAPIResource
        {
            IReference<TRefType> reference = new Reference<TRefType>((string)null);
            PUT_WithValue(PropertyExpression, reference, false);
        }
        public void PUT_Reference_EmptyStringId< TRefType>(
            
            Expression<Func<T, IReference<TRefType>>> PropertyExpression)
            where TRefType : IAPIResource
        {
            IReference<TRefType> reference = new Reference<TRefType>("");
            PUT_WithValue(PropertyExpression, reference, false);
        }
        public void PUT_Reference_NonExistantId<TRefType>(
            Expression<Func<T, IReference<TRefType>>> PropertyExpression)
            where TRefType : IAPIResource
        {
            IReference<TRefType> reference = new Reference<TRefType>(Samples.Valid_NonExistant_UUID);
            PUT_WithValue(PropertyExpression, reference, false);
        }
        public void PUT_ReferenceList_NonExistantId<TRefType>(
            Expression<Func<T, ICollection<IReference<TRefType>>>> PropertyExpression)
            where TRefType : IAPIResource
        {
            // Create a new list of the same runtime type to populate with an invalid reference
            ICollection<IReference<TRefType>> newList = NewCollection(PropertyExpression,
                new [] { new Reference<TRefType>(Samples.Valid_NonExistant_UUID) });
            PUT_WithValue(PropertyExpression, newList, false);
        }
        #endregion Reference Attribute Test Helpers
        #endregion Test Method Helpers
    }
}