Test_API_REST_Methods.cs

Go to the documentation of this file.

using System;
using System.Diagnostics;
using System.IO;
using System.Linq;
 
using AnalyzeRe;
using AnalyzeRe.APITypes;
using AnalyzeRe.Layers;
using AnalyzeRe.Metrics;
using AnalyzeRe.Rest;
using AnalyzeRe.Utilities;
using AnalyzeReTesting.Base;
using AnalyzeReTesting.Tests.Model;
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.Tests.AnalyzeReAPI
{
    // TODO: Update these test methods to dispose of the resources they create
    //       if resource DELETE is ever supported.
    [TestClass]
    public class TestSuite_REST_Methods : BaseServerTestSuite
    {
        private const string TestCategory = "REST Methods";
 
        #region OPTIONS
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_OPTIONS()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            OptionsResponse options = API.Options();
            Assert.IsNotNull(options, "Options response body was null.");
            Assert.IsNotNull(options.features, "Options response was missing the features list.");
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_OPTIONS_Optimization_Supported()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            OptionsResponse options = API.Options();
            Assert.IsTrue(options.is_optimization_enabled,
                "Expected Optimization to be supported for integration tests.");
        }
        #endregion OPTIONS
 
        #region GET
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GET_ResolveReferences()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            AnalysisProfile response = Samples.AnalysisProfile.Posted.Get(
                API.Parameters.ExpandReferences());
            AssertApi.ReferencesResolved(response);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GET_WithoutInstance()
        {
            string id = Samples.LayerView_CatXL.AsReference.ref_id;
            // Test the compile-time-typed overload (using the most-derived type)
            LayerView<CatXL> retrievedTyped = API.Get<LayerView<CatXL>>(id);
            Assert.AreEqual(id, retrievedTyped.id);
 
            // Test the compile-time-typed overload (using a non-trivial base interface)
            ILayerView retrievedBase = API.Get<ILayerView>(id);
            // The deserializer should have built an instance of the strong type
            Assert.IsTrue(retrievedBase is LayerView<CatXL>);
            Assert.AreEqual(id, retrievedBase.id);
 
            // Test the runtime-typed overload (using the most-derived type)
            object resource = API.Get(typeof(LayerView<CatXL>), id);
            Assert.IsTrue(retrievedBase is LayerView<CatXL>);
            Assert.AreEqual(id, ((LayerView<CatXL>)resource).id);
 
            // Test the runtime-typed overload (using a non-trivial base interface)
            resource = API.Get(typeof(ILayerView), id);
            Assert.IsTrue(retrievedBase is LayerView<CatXL>);
            Assert.AreEqual(id, ((LayerView<CatXL>)resource).id);
        }
 
        #region Type Resolution Tests
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GET_NoParams_Basic()
        {
            Test_API_GET_and_Parse<EventCatalog, EventCatalog>(Samples.EventCatalog.Posted);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GET_SpecifiedType_AbstractBase()
        {
            Test_API_GET_and_Parse<CatXL, Layer>(Samples.Layer_CatXL.Posted);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GET_SpecifiedType_Interface()
        {
            Test_API_GET_and_Parse<CatXL, ILayer>(Samples.Layer_CatXL.Posted);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GET_GenericType_Interface()
        {
            Test_API_GET_and_Parse<LayerView<CatXL>, ILayerView>(
                (LayerView<CatXL>)Samples.LayerView_CatXL.Posted);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GET_GenericType_GenericInterface()
        {
            Test_API_GET_and_Parse<LayerView<CatXL>, ILayerView<ILayer>>(
                (LayerView<CatXL>)Samples.LayerView_CatXL.Posted);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GET_GenericType_GenericInterface_SpecifiedType()
        {
            Test_API_GET_and_Parse<LayerView<CatXL>, ILayerView<CatXL>>(
                (LayerView<CatXL>)Samples.LayerView_CatXL.Posted);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GET_Interface()
        {
            Test_API_GET_and_Parse<ILayerView, ILayerView>(
                Samples.LayerView_CatXL.Posted);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GET_GenericInterface()
        {
            Test_API_GET_and_Parse<ILayerView<ILayer>, ILayerView<ILayer>>(
                Samples.LayerView_CatXL.Posted);
        }
        #endregion Type Resolution Tests
 
        #region Test Helper Methods
        private void Test_API_GET_and_Parse<TGET, TResponse>(TGET toGet)
            where TGET : TResponse, IAPIResource
            where TResponse : IAPIResource
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            // Test GET generic method using (implied) derived compile time type.
            AssertApi.AllPropertiesEqual(toGet, toGet.Get());
            // Test GET generic method using (implied) base compile time type.
            TResponse toGetAsBase = toGet;
            AssertApi.AllPropertiesEqual(toGet, toGetAsBase.Get());
            // Test GET generic method using explicit base compile time type.
            AssertApi.AllPropertiesEqual(toGet, toGet.Get_AsType<TResponse>());
            // Test GET method using derived run-time type.
            AssertApi.AllPropertiesEqual(toGet, (TGET)toGet.Get(typeof(TGET)));
            // Test GET method using base run-time type.
            AssertApi.AllPropertiesEqual(toGet, (TResponse)toGet.Get(typeof(TResponse)));
        }
        #endregion Test Helper Methods
        #endregion GET
 
        #region POST
        #region Type Resolution Tests
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_POST_NoParams_Basic()
        {
            Test_API_POST_and_Parse<EventCatalog, EventCatalog>(Samples.EventCatalog.Unposted);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_POST_SpecifiedType_AbstractBase()
        {
            Test_API_POST_and_Parse<CatXL, Layer>(Samples.Layer_CatXL.Unposted);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_POST_SpecifiedType_Interface()
        {
            Test_API_POST_and_Parse<CatXL, ILayer>(Samples.Layer_CatXL.Unposted);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_POST_GenericType_Interface()
        {
            Test_API_POST_and_Parse<LayerView<CatXL>,
                ILayerView>((LayerView<CatXL>)Samples.LayerView_CatXL.Unposted);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_POST_GenericType_GenericInterface()
        {
            Test_API_POST_and_Parse<LayerView<CatXL>,
                ILayerView<ILayer>>((LayerView<CatXL>)Samples.LayerView_CatXL.Unposted);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_POST_GenericType_GenericInterface_SpecifiedType()
        {
            Test_API_POST_and_Parse<LayerView<CatXL>,
                ILayerView<CatXL>>((LayerView<CatXL>)Samples.LayerView_CatXL.Unposted);
        }
        #endregion Type Resolution Tests
 
        #region Test Helper Methods
        private static void Test_API_POST_and_Parse<T, TResponse>(T toPost)
            where T : TResponse, IAPIResource
            where TResponse : IAPIResource
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            // Test POST generic method using (implied) derived compile time type.
            AssertApi.PostResponseMatches(toPost, GenericTest.POST_ValidResource(toPost));
            // Test POST generic method using (implied) base compile time type.
            TResponse toPostAsBase = toPost;
            AssertApi.PostResponseMatches(toPost, toPostAsBase.Post());
            // Test POST generic method using explicit base compile time type.
            AssertApi.PostResponseMatches(toPost, toPost.Post_AsType<TResponse>());
            // Test POST method using derived run-time type.
            AssertApi.PostResponseMatches(toPost, (T)toPost.Post(typeof(T)));
            // Test POST method using base run-time type.
            AssertApi.PostResponseMatches(toPost, (TResponse)toPost.Post(typeof(TResponse)));
        }
        #endregion Test Helper Methods
        #endregion POST
 
        #region PUT
        #region Type Resolution Tests
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_PUT_NoParams_Basic()
        {
            Test_API_PUT_and_Parse<EventCatalog, EventCatalog>(
                // Post a copy of our sample event catalog that has not yet
                // been finalized, so that it is still mutable.
                Samples.EventCatalog.Unposted.Post());
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_PUT_SpecifiedType_AbstractBase()
        {
            Test_API_PUT_and_Parse<CatXL, Layer>(Samples.Layer_CatXL.Posted);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_PUT_SpecifiedType_Interface()
        {
            Test_API_PUT_and_Parse<CatXL, ILayer>(Samples.Layer_CatXL.Posted);
        }
        #endregion Type Resolution Tests
 
        #region Test Helper Methods
        private void Test_API_PUT_and_Parse<TPUT, TResponse>(TPUT toPut)
            where TPUT : TResponse, IAPIResource
            where TResponse : IAPIResource
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            TPUT original = toPut.Get();
            // Test PUT generic method using (implied) derived compile time type.
            AssertApi.PutResponseMatches(original, toPut, original = toPut.Put());
            // Test PUT generic method using explicit base compile time type.
            AssertApi.PutResponseMatches(original, toPut, toPut.Put_AsType<TResponse>());
            // Test PUT method using derived run-time type.
            AssertApi.PutResponseMatches(original, toPut, (TPUT)toPut.Put(typeof(TPUT)));
            // Test PUT method using base run-time type.
            AssertApi.PutResponseMatches(original, toPut, (TResponse)toPut.Put(typeof(TResponse)));
            // Test PUT generic method using (implied) base compile time type.
            TResponse toPutAsBase = toPut;
            AssertApi.PutResponseMatches(original, toPut, toPutAsBase.Put());
        }
        #endregion Test Helper Methods
        #endregion PUT
 
        #region DELETE
        // Currently not implemented on the server.
        #endregion DELETE
 
        // Test the multitude of complex uses of GetResourceList
        #region GetResourceList
        #region Basic Tests
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GetResourceList_NoParams_Basic()
        {
            string id = Samples.EventCatalog.Posted.id;
            Test_API_GetResourceList_SpecifiedType_Helper<EventCatalog>(new[] { id }, null);
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GetResourceList_CollectionNameOverride()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            PostAggXLandCatXLLayers(out string aggId, out string catId);
            ICollectionResponse<IAPIResource> result =
                API.GetResourceList<IAPIResource>(collectionNameOverride: "layers");
            Debug.WriteLine("Layers List contains this many items: " + result.items.Count());
        }
        #endregion Basic Tests
 
        // Test that using both abstract and derived types, we can successfully
        // make a collection request and deserialize it to the correct type.
        #region Involving Inheritance
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GetResourceList_SpecifiedType_Derived()
        {
            PostAggXLandCatXLLayers(out string aggId, out string catId);
            Test_API_GetResourceList_SpecifiedType_Helper<CatXL>(
                new[] { catId }, new[] { aggId });
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GetResourceList_SpecifiedType_UninstantiableAbstractBase()
        {
            PostAggXLandCatXLLayers(out string aggId, out string catId);
            Test_API_GetResourceList_SpecifiedType_Helper<Layer>(
                new[] { catId, aggId });
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GetResourceList_SpecifiedType_UninstantiableInterface()
        {
            PostAggXLandCatXLLayers(out string aggId, out string catId);
            Test_API_GetResourceList_SpecifiedType_Helper<ILayer>(
                new[] { catId, aggId });
        }
        #endregion Involving Inheritance
 
        // Test that using covariant generic types (like LayerView[T]), defined in a variety of
        // ways using abstract base classes, interfaces, and instantiable types, we can successfully make
        // a collection request and deserialize it to the correct type.
        #region Involving Generics
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GetResourceList_GenericType_Interface()
        {
            PostAggXLandCatXLLayerViews(out string aggId, out string catId);
            Test_API_GetResourceList_SpecifiedType_Helper<ILayerView>(
                new[] { aggId, catId });
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GetResourceList_GenericType_GenericInterface()
        {
            PostAggXLandCatXLLayerViews(out string aggId, out string catId);
            Test_API_GetResourceList_SpecifiedType_Helper<ILayerView<ILayer>>(
                new[] { aggId, catId });
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GetResourceList_GenericType_GenericInterface_TypeSpecified()
        {
            PostAggXLandCatXLLayerViews(out string aggId, out string catId);
            Test_API_GetResourceList_SpecifiedType_Helper<ILayerView<CatXL>>(
                new[] { catId }, new[] { aggId });
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GetResourceList_GenericType_GenericType_TypeSpecified()
        {
            PostAggXLandCatXLLayerViews(out string aggId, out string catId);
            Test_API_GetResourceList_SpecifiedType_Helper<LayerView<CatXL>>(
                new[] { catId }, new[] { aggId });
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GetResourceList_GenericType_GenericType_CovariantlyInvalid()
        {
            PostAggXLandCatXLLayerViews(out string aggId, out string catId);
            // Will always return an empty list because objects assignable to LayerView<ILayer>
            // cannot be covariantly placed in a List of that type
            Test_API_GetResourceList_SpecifiedType_Helper<LayerView<ILayer>>(
                null, new[] { catId, aggId });
        }
        #endregion Involving Generics
 
        #region Test Helper Methods
        // Mini set-up for most variations of the above collection tests.
        private static void PostAggXLandCatXLLayers(out string aggId, out string catId)
        {
            aggId = Samples.Layer_AggXL.Posted.id;
            catId = Samples.Layer_CatXL.Posted.id;
        }
 
        // Mini set-up for most variations of the above collection tests.
        private static void PostAggXLandCatXLLayerViews(out string aggId, out string catId)
        {
            aggId = Samples.LayerView_AggXL.Posted.id;
            catId = Samples.LayerView_CatXL.Posted.id;
        }
 
        private static void Test_API_GetResourceList_SpecifiedType_Helper<T>(
            string[] expectedIds = null, string[] excludedIds = null)
            where T : IAPIResource
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            if (expectedIds == null)
                expectedIds = new string[] { };
            if (excludedIds == null)
                excludedIds = new string[] { };
            int expectedCount = expectedIds.Length;
            
            // Parameter to request the expected ids in bulk from the collection
            RequestParameters page = API.Parameters.Ids(expectedIds);
 
            // Test GetResourceList generic method using compile time type and runtime type
            ICollectionResponse<IAPIResource> result1 = (ICollectionResponse<IAPIResource>)API.GetResourceList<T>(page);
            ICollectionResponse<IAPIResource> result2 = API.GetResourceList(typeof(T), page);
            int count1 = result1.items.Count(r => expectedIds.Contains(r.id));
            int count2 = result2.items.Count(r => expectedIds.Contains(r.id));
            Debug.WriteLine($"Layer List contains this many items: " +
                $"{count1} (method 1)   {count2} (method 2)");
            Assert.AreEqual(count1, count2, "GetResourceList returned different results " +
                "using equivalent method signatures.");
            
            Assert.IsNotNull(result1, "Expected " + expectedCount + " " +
                typeof(T).NiceTypeName() + "s to be returned. Got null instead.");
            // Ensure all the expectedIds exist in the results
            Assert.AreEqual(expectedCount, count1, expectedCount - count1 + " " +
                typeof(T).NiceTypeName() + "(s) posted not retrieved using compile-time types.");
            // Ensure that none of the excludedIds exist in the results
            int countEx1 = result1.items.Count(r => excludedIds.Contains(r.id));
            Assert.AreEqual(0, countEx1, countEx1 + " " + typeof(T).NiceTypeName() +
                "(s) posted included using compile-time types that were explicitly meant to be ignored.");
 
            // test GetResourceList using run-time type.
            Assert.IsNotNull(result2, "Expected " + expectedCount + " " +
                typeof(T).NiceTypeName() + "(s) to be returned. Got null instead.");
            // Ensure all the expectedIds exist in the results
            Assert.AreEqual(expectedCount, count2, expectedCount - count2 + " " +
                typeof(T).NiceTypeName() + "(s) posted not retrieved using run-time types.");
            // Ensure that none of the excludedIds exist in the results
            int countEx2 = result2.items.Count(r => excludedIds.Contains(r.id));
            Assert.AreEqual(0, countEx2, countEx2 + " " + typeof(T).NiceTypeName() +
                "(s) posted included using compile-time types that were explicitly meant to be ignored.");
        }
 
        // TODO: test ability to deserialize resolved references.
        #endregion Test Helper Methods
        #endregion GetResourceList
 
        #region SearchResourceList
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_SearchResourceList()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            string myGuid = Guid.NewGuid().ToString();
            StaticPortfolio portfolio = Samples.Portfolio.Unposted.DeepCopy();
            portfolio.meta_data["key1"] = "val5";
            portfolio.meta_data["theGuid"] = myGuid;
            StaticPortfolio posted = portfolio.Post();
            ICollectionResponse<Portfolio> result = API.SearchResourceList<Portfolio>(
                $"meta_data[key1]=\"val5\" AND meta_data[theGuid]=\"{myGuid}\"",
                searchType: API.SearchType.Advanced);
 
            Portfolio resultPortfolio = result.items.FirstOrDefault();
            Assert.IsNotNull(resultPortfolio, "The server returned no matching portfolios.");
 
            string postedText = String.Join(Environment.NewLine,
                posted.meta_data.Select(kvp => $"{kvp.Key}: {kvp.Value.ToString()}"));
            string resultPortfolioText = String.Join(Environment.NewLine,
                resultPortfolio.meta_data.Select(kvp => $"{kvp.Key}: {kvp.Value.ToString()}"));
 
            CollectionAssert.AreEqual(posted.meta_data, resultPortfolio.meta_data,
                $"posted.meta_data: {postedText}{Environment.NewLine}" +
                $"resultPortfolio.meta_data: {resultPortfolioText}");
        }
        #endregion SearchResourceList
 
        #region Batch Get Items By Id
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_BatchListItems()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            // Get two posted loss set ids.
            LossSet ls1 = Samples.LossSet_YELTLossSet.Posted;
            LossSet ls2 = Samples.LossSet_YLTLossSet.Posted;
 
            // Retrieve these two in a batch using their ids.
            ICollectionResponse<LossSet> result = API.BatchGet<LossSet>(new[] { ls1.id, ls2.id });
            Assert.AreEqual(2, result.meta.total_count, "Expected exactly two results.");
            Assert.AreEqual(1, result.items.Count(ls => ls.id == ls1.id), "A loss set was not found.");
            Assert.AreEqual(1, result.items.Count(ls => ls.id == ls2.id), "A loss set was not found.");
 
            // Test the same using a runtime type
            ICollectionResponse<IAPIResource> result2 = API.BatchGet(typeof(LossSet), new[] { ls1.id, ls2.id });
            Assert.AreEqual(2, result2.meta.total_count, "Expected exactly two results.");
            Assert.AreEqual(1, result2.items.Count(ls => ls.id == ls1.id), "A loss set was not found.");
            Assert.AreEqual(1, result2.items.Count(ls => ls.id == ls2.id), "A loss set was not found.");
 
            // Use the collection method to test the same
            result = API.LossSets.GetItems(new[] { ls1.id, ls2.id });
            Assert.AreEqual(2, result.meta.total_count, "Expected exactly two results.");
            Assert.AreEqual(1, result.items.Count(ls => ls.id == ls1.id), "A loss set was not found.");
            Assert.AreEqual(1, result.items.Count(ls => ls.id == ls2.id), "A loss set was not found.");
 
            // Use the Ids parameter directly to test the same
            result = API.GetResourceList<LossSet>(API.Parameters.Ids(new[] { ls1.id, ls2.id }));
            Assert.AreEqual(2, result.meta.total_count, "Expected exactly two results.");
            Assert.AreEqual(1, result.items.Count(ls => ls.id == ls1.id), "A loss set was not found.");
            Assert.AreEqual(1, result.items.Count(ls => ls.id == ls2.id), "A loss set was not found.");
        }
        #endregion Batch Get Items By Id
 
        #region Get Stream
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GetStream_Matches_Get()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            StaticSimulation posted = Samples.Simulation_StaticSimulation.Posted;
            string originalSimulationData = posted.data.Get();
            string fromStream = null;
            try
            {
                posted.data.GetStream(stream =>
                {
                    using (StreamReader reader = new StreamReader(stream))
                    {
                        fromStream = reader.ReadToEnd();
                    }
                });
            }
            catch (APIRequestException ex)
            {
                Assert.Fail("Error: " + ex +
                            "\n\nStream contained:\n" + fromStream);
            }
            Assert.AreEqual(originalSimulationData, fromStream,
                            "Data from GET did not match data from stream.");
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GetStream_ToLargeFileUpload()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            IInjectableResource<StaticSimulation> staticSimulation =
                Samples.Simulation_StaticSimulation;
 
            StaticSimulation posted = staticSimulation.Posted;
            StaticSimulation copy = null;
            // Download the original resource's data file as a stream
            posted.data.GetStream(stream =>
            {
                // Create a new resource (a copy of the original will suffice).
                copy = posted.DeepCopy();
                copy.description = "Copy Of " + posted.description;
                // We must wipe the data file reference to test streaming to the new resource
                copy.data_file = null;
                copy = copy.Post();
                // This function will consume the stream as it's downloaded and
                // upload it against the new resource's data endpoint.
                copy.data.LargeStreamUpload(stream,
                    // As part of the Large Data Upload protocol, we need to know the length
                    // of the file, which the API conveniently supplies if we make
                    // a HEAD request to the original resource's data sub-resource.
                    dataSize: posted.data.Head().ContentLength);
            });
            Assert.AreEqual(posted.data.Get(), copy.data.Get(),
                            "Data from copy did not match original data.");
        }
        #endregion Get Stream
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GET_Metrics_Probabilities()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            ILayerView<CatXL> layer_view = Samples.LayerView_CatXL.Posted;
            for (int i = 1; i < 10000000; i = i * 7 - 1)
            {
                double prob = 1d / i;
                Debug.WriteLine("Requesting metrics for return period " + i +
                    " (probability " + prob + ")");
                TailMetrics result = layer_view.tail_metrics_blocking(prob,
                    MetricsOptions.Default, TestSuite_APIResourceView.SimulationPolling);
                AssertApi.DoublesAreEqual(1d / prob, 1d / result.context.probability,
                    "The return period did not survive a round trip conversion to probability.");
            }
        }
 
        [TestMethod, TestCategory(TestCategory)]
        public void Test_API_GET_Exceedance_Probability_Thresholds()
        {
            if (EnvironmentSettings.RUN_OFFLINE)
                Assert.Inconclusive("RUN_OFFLINE = true");
            ILayerView<CatXL> layer_view = Samples.LayerView_CatXL.Posted;
            void TestThreshold(double threshold)
            {
                Debug.WriteLine($"Requesting metrics for threshold {threshold}");
                ExceedanceProbability result = layer_view.exceedance_probability_blocking(
                    threshold, ExceedanceProbabilityOptions.Default, TestSuite_APIResourceView.SimulationPolling);
                AssertApi.DoublesAreEqual(threshold, result.context.threshold,
                    "The threshold did not survive a round trip conversion to probability.");
            }
 
            TestThreshold(0d);
            TestThreshold(Math.PI);
            TestThreshold(Math.E);
            TestThreshold(Double.Epsilon);
            // Test the issue reported in ARE-5666
            TestThreshold(Double.MaxValue);
            // Test a hundred or so random high-precision numbers
            Random rand = new Random();
            Enumerable.Range(0,100).ToList().ForEach(i =>
                TestThreshold(rand.NextDouble() * Double.MaxValue));
        }
    }
}