BaseResourceWithDataTestSuite.cs

Go to the documentation of this file.

using System;
using System.Net;
using System.Text;
 
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 BaseResourceWithDataTestSuite<T> : BaseMutableResourceTestSuite<T>
        where T : IAPIResource_WithDataEndpoint
    {
        #region Properties
        private const string TypeName = "BaseResourceWithLargeDataTest";
 
        #region Overrideable Protected Properties
        // Deriving class should override the below if the default behaviour isn't desired.
        protected virtual bool DELETE_Allowed_BeforeData => DELETE_Allowed;
        protected abstract string POSTData { get; }
 
        // Since we now perform additional validation of resources after PUT,
        // we must first ensure they are finalized.
        public sealed override void AdditionalValidResourceTests(T posted)
        {
            if (posted.status != TaskStatus.Success)
            {
                posted.Get();
                if (posted.data_file == null)
                    GenericTest.UploadData(posted, POSTData);
                posted.PollUntilReady();
            }
            AdditionalValidResourceWithDataTests(posted);
        }
 
        public virtual void AdditionalValidResourceWithDataTests(T posted) { }
        #endregion Overrideable Protected Properties
        #endregion Properties
 
        #region Test Methods
        #region POST
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_GET_Data()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            string dataFromGet = null;
 
            AssertApi.MethodIsAllowed(() => dataFromGet = TestResource_Existing.data.Get(), "GET");
            Assert.IsTrue(AssertApi.FileContentsAreEqual(POSTData, dataFromGet),
                "GET on the /data endpoint appears to have succeeded, " +
                "but didn't match the data uploaded.");
        }
 
        public sealed override void POST_ThenDoAction(T validToPost, Action<T> toExecute)
        {
            // If the current test resource has no data_file reference,
            // upload data following the POST to finalize the resource.
            if (validToPost.data_file == null)
                GenericTest.POST_WithData_ThenDoAction(validToPost, POSTData, toExecute);
            else
                GenericTest.POST_ThenDoAction(validToPost, toExecute);
        }
 
        [TestMethod, TestCategory(TypeName), TestCategory("Post Valid")]
        public sealed override void Test_Resource_POST_Valid()
        {
            POST_ThenDoAction(TestResource, obj =>
            {
                Assert.IsNotNull(obj.data_file, "Missing the data file for this resource.");
                Assert.IsNotNull(obj.data_file.ref_id, "Missing a data file ref_id");
                AdditionalValidResourceTests(obj);
            });
        }
 
        #region CreatedAndModified
        [TestMethod, TestCategory(TypeName)]
        public override void Test_Resource_POST_CreatedAndModified()
        {
            POST_ForPutTest(TestResource, posted =>
            {
                Assert.IsNotNull(posted.created, "Expected a 'created' date to be assigned.");
                Assert.IsNotNull(posted.modified, "Expected a 'modified' date to be assigned.");
                Assert.AreEqual(posted.created, posted.modified,
                    "Expected the created and modified date to be equal on a newly posted resource.");
            });
        }
        #endregion CreatedAndModified
        #endregion POST
 
        #region PUT
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_PUT_Data_EmptyString()
        {
            // The server doesn't like empty files (at this time).
            // This will ensure that the DataUpload library doesn't blow up on an empty string,
            // and that the resulting error comes from the server.
            GenericTest.POST_InvalidResourceWithData_Fails(TestResource, "");
        }
 
        [TestMethod, TestCategory(TypeName)]
        public override void Test_Resource_PUT_NoChanges()
        {
            // PUT is allowed before data upload (before resource is finalized)
            PUT_WithChanges_Succeeds(r => r);
            // PUT is forbidden on a finalized resource, even if there are no changes
            GenericTest.PUT_Fails(TestResource_Existing,
                AssertApi.ApiExceptionTest(HttpStatusCode.MethodNotAllowed));
        }
        #endregion PUT
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_DELETE_Before_Uploading_Data()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            POST_ForPutTest(TestResource,
                posted => TestResourceDeleteHelper(posted, DELETE_Allowed_BeforeData));
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_Data_SegmentedUpload()
        {
            POST_ForPutTest(TestResource, posted =>
            {
                LargeDataSubResource data = posted.data;
 
                // Otherwise, Initiate the large file upload
                AssertApi.MethodIsAllowed(() => data.Post(Encoding.UTF8.GetByteCount(POSTData)),
                    "/data POST", true);
                // Upload the file in several parts
                int chunkLength = POSTData.Length / 4 + 1;
                int bytesOffset = 0;
                for (int startIndex = 0; startIndex < POSTData.Length; startIndex += chunkLength)
                {
                    int nextChunkSize = Math.Min(chunkLength, POSTData.Length - startIndex);
                    string chunk = POSTData.Substring(startIndex, nextChunkSize);
                    AssertApi.MethodIsAllowed(() => data.Patch(chunk, bytesOffset), "/data PATCH", true);
                    bytesOffset += Encoding.UTF8.GetByteCount(chunk);
                }
 
                // Commit the large file upload
                AssertApi.MethodIsAllowed(() => data.commit.POST(), "/data/commit POST", true);
                // Poll the /status endpoint with GET until the upload is complete.
                AnalyzeRe.LargeDataUpload.Utilities.PollUntilDataProcessed(data, Samples.UploadParams);
 
                // Assert that the data is uploaded by doing a get.
                Assert.AreEqual(POSTData, data.Get(), "Downloaded data did not match uploaded data.");
            });
        }
 
        [TestMethod, TestCategory(TypeName)]
        public virtual void Test_Resource_Data_LargeStreamUpload()
        {
            POST_ForPutTest(TestResource, posted =>
            {
                LargeDataSubResource data = posted.data;
 
                // Otherwise, Initiate the large file upload
                data.LargeStreamUpload(
                    AnalyzeRe.LargeDataUpload.Utilities.GetStringStream(POSTData),
                    Samples.UploadParams);
 
                // Assert that the data is uploaded by doing a get.
                Assert.AreEqual(POSTData, data.Get(), "Downloaded data did not match uploaded data.");
            });
        }
        #endregion Test Methods
    }
}