BaseAbstractResourceTestsSuite.cs

Go to the documentation of this file.

using System;
using System.Linq;
using System.Net;
using AnalyzeRe;
using AnalyzeRe.APITypes;
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 BaseAbstractStoredResourceTestSuite<T> : BaseAbstractResourceTestSuite<T>
        where T : IStoredAPIResource
    {
        private const string TypeName = "BaseAbstractStoredResourceTestSuite";
 
        [TestMethod, TestCategory(TypeName), TestCategory("Randomized")]
        public virtual void Test_Resource_GET_Collection_AllTypes_ResolveReferences()
        {
            if (!EnvironmentSettings.RANDOMIZED_TESTS_ENABLED)
                Assert.Inconclusive("RANDOMIZED_TESTS_ENABLED = false");
            // Get a collection with one of each type and verify that references were resolved.
            GenericTest.GET_Collection_AllSubtypes(collection_source, Reflection,
                additionalParameters: API.Parameters.ExpandReferences(),
                additionalActions: list => list.items.ToList().ForEach(res => AssertApi.ReferencesResolved(res)),
                // Resolving references can be much slower than a normal request, so...
                timeout: EnvironmentSettings.COLLECTION_REQUEST_TIMEOUT * 10);
        }
    }
 
    [TestClass]
    public abstract class BaseAbstractResourceTestSuite<T> : BaseServerTestSuite
        where T : IAPIResource
    {
        #region Properties
        private const string TypeName = "BaseAbstractResourceTest";
 
        protected virtual bool PUT_Allowed => true;
 
        protected abstract IResourceCollection<T> collection_source { get; }
        #endregion Properties
 
        #region GET
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_GET_Collection()
        {
            GenericTest.GET_Collection(collection_source);
        }
 
        [TestMethod, TestCategory(TypeName), TestCategory("Randomized")]
        public virtual void Test_Resource_GET_Collection_AllTypes()
        {
            if (!EnvironmentSettings.RANDOMIZED_TESTS_ENABLED)
                Assert.Inconclusive("RANDOMIZED_TESTS_ENABLED = false");
            GenericTest.GET_Collection_AllSubtypes(collection_source, Reflection);
        }
 
 
        [TestMethod, TestCategory(TypeName), TestCategory("Randomized")]
        public virtual void Test_Resource_GET_Collection_AllTypes_Pagination()
        {
            if (!EnvironmentSettings.RANDOMIZED_TESTS_ENABLED)
                Assert.Inconclusive("RANDOMIZED_TESTS_ENABLED = false");
            // Request an offset of 1, and get 2 items in the page, and verify 2 or less were returned
            GenericTest.GET_Collection_AllSubtypes(collection_source, Reflection, 1, 2,
                additionalActions: delegate (ICollectionResponse<T> pagedList)
                {
                    // Look at the meta to determine how many items existed in the collection
                    // when this request was made.
                    long total_available = pagedList.meta.total_count;
                    int returned = pagedList.items.Count();
                    // If only one item was added, the pagedList should be empty (since we skipped one item)
                    if (total_available == 1)
                        Assert.AreEqual(0, returned, "Only one item existed in the collection, " +
                            "so getting offset of 1 should have yielded an empty list.");
                    if (total_available >= 2)
                        Assert.IsTrue(returned > 0, "More than one item existed in the collection, " +
                            "so getting offset of 1 should have yielded a non-empty list.");
                    if (total_available >= 3)
                        Assert.AreEqual(2, returned, "The pagedList limit was set to 2, " +
                            "so there should be exactly 2 results.");
                });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_GET_NonExistant()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            AssertApi.ExceptionThrown(
                () => GenericTest.Mock<T>(Samples.Valid_NonExistant_UUID).Get(),
                AssertApi.ApiExceptionTest(HttpStatusCode.NotFound));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_GET_BadlyFormed()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            AssertApi.ExceptionThrown(
                () => GenericTest.Mock<T>("MALFORMED").Get(),
                AssertApi.ApiExceptionTest(HttpStatusCode.NotFound));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_GET_EmptyID()
        {
            // TODO: Since the C# client throws this, assert the error message is nice.
            AssertApi.ExceptionThrown<ArgumentException>(
                () => GenericTest.Mock<T>("").Get());
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_GET_NullID()
        {
            // TODO: Since the C# client throws this, assert the error message is nice.
            AssertApi.ExceptionThrown<ArgumentException>(
                () => GenericTest.Mock<T>(null).Get());
        }
        #endregion GET
 
        #region POST
        [TestMethod, TestCategory(TypeName), TestCategory("Randomized")]
        public virtual void Test_Resource_POST_AllTypes()
        {
            if (!EnvironmentSettings.RANDOMIZED_TESTS_ENABLED)
                Assert.Inconclusive("RANDOMIZED_TESTS_ENABLED = false");
            GenericTest.POST_AllSubtypes_Succeeds<T>(Reflection);
        }
        #endregion POST
 
        #region PUT
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_PUT_NonExistant()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            HttpStatusCode expectedStatus =
                PUT_Allowed ? HttpStatusCode.NotFound : HttpStatusCode.MethodNotAllowed;
            AssertApi.ExceptionThrown(
                () => GenericTest.Mock<T>(Samples.Valid_NonExistant_UUID).Put(),
                AssertApi.ApiExceptionTest(expectedStatus));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_PUT_BadlyFormed()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            HttpStatusCode expectedStatus =
                PUT_Allowed ? HttpStatusCode.NotFound : HttpStatusCode.MethodNotAllowed;
            AssertApi.ExceptionThrown(
                () => GenericTest.Mock<T>("MALFORMED").Put(),
                AssertApi.ApiExceptionTest(expectedStatus));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_PUT_EmptyID()
        {
            // TODO: Since the C# client throws this, assert the error message is nice.
            AssertApi.ExceptionThrown<ArgumentException>(
                () => GenericTest.Mock<T>("").Put());
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_PUT_NullID()
        {
            // TODO: Since the C# client throws this, assert the error message is nice.
            AssertApi.ExceptionThrown<ArgumentException>(
                () => GenericTest.Mock<T>(null).Put());
        }
        #endregion PUT
    }
}