InjectableResource[T].cs

Go to the documentation of this file.

using System;
using AnalyzeRe;
using AnalyzeRe.APITypes;
using AnalyzeRe.Optimization;
 
#if MSTEST
using Microsoft.VisualStudio.TestTools.UnitTesting;
#elif NUNIT
using NUnit.Framework;
#endif
 
namespace AnalyzeReTesting
{
    public interface IInjectableResource<out T> where T : IAPIResource
    {
        bool Mocked { get; set; }
 
        T Posted { get; }
 
        T Unposted { get; }
 
        IReference<T> AsReference { get; }
 
        IReference<T> AsInlinedReference { get; }
        
        Type UnderlyingType { get; }
    }
 
    public sealed class InjectableResource<T> : IInjectableResource<T>
        where T : IAPIResource
    {
        #region Public Properties
        public bool Mocked { get; set; }
 
        public T Unposted => _unPOSTedResource.DeepCopy();
 
        public T Posted => (_posted ? _postedResource : _postedResource = Post()).DeepCopy();
 
        public IReference<T> AsReference => Posted.ToReference(true);
 
        public IReference<T> AsInlinedReference => Unposted.ToReference(true);
 
        public Type UnderlyingType => _unPOSTedResource.GetType();
        #endregion Public Properties
 
        #region Private Fields
        // The resource before it was posted.
        private readonly T _unPOSTedResource;
 
        // The data to upload at Post time.
        private readonly string _postData;
 
        // A lock taken when posting the resource for the first time.
        private readonly object _postLock = new object();
 
        // Set to true once the resource has been posted.
        private bool _posted;
 
        // The resource after it was posted.
        private T _postedResource;
        #endregion Private Fields
 
        #region Constructors
        public InjectableResource(T unPOSTedResource)
        {
            if (unPOSTedResource.id != null)
                throw new ArgumentException("An attempt was made to create a disposable " +
                    "resource using a resource that was already posted elsewhere.");
            _unPOSTedResource = unPOSTedResource;
        }
 
        public InjectableResource(T unPOSTedResource, string data) : this(unPOSTedResource)
        {
            if (!(unPOSTedResource is IAPIResource_WithDataEndpoint))
                throw new ArgumentException("data cannot be used on resources without a data endpoint.");
            _postData = data;
        }
        #endregion Constructors
 
        #region Public Methods
        private T Post()
        {
            try
            {
                // Immediately return a copy of this resource if it's already been posted.
                if (_posted) return _postedResource;
                // Ensure multiple threads don't concurrently post this resource
                lock (_postLock)
                {
                    // If the resource has been posted by another thread since taking the lock, return
                    if (_posted) return _postedResource;
                    // if this is a mocked resource, simply fake assign it an id.
                    if (Mocked)
                    {
                        _postedResource = Unposted;
                        _postedResource.id = Samples.Valid_NonExistant_UUID;
                        if (_postedResource is IStoredAPIResource_WithStatus asWithStatus)
                            asWithStatus.status = TaskStatus.Success;
                        _posted = true;
                        return _postedResource;
                    }
 
                    // Resources with data endpoints need to have their data uploaded
                    if (_postData != null && _unPOSTedResource is IAPIResource_WithDataEndpoint)
                    {
                        _postedResource = (T)((IAPIResource_WithDataEndpoint)_unPOSTedResource)
                            .Post(_postData, upload_parameters: Samples.UploadParams);
                    }
                    else
                        _postedResource = _unPOSTedResource.Post();
 
                    // HACK: Some resources must be 'polled' until they are ready to be considered
                    //       successfully posted (Analysis Profiles)
                    // HACK: Exclude OptimizationViews because they aren't "ready" until both
                    //       validation has completed (which we care about) and the optimization_view
                    //       has completed running (which we don't care about at post time).
                    //       There's no way to distinguish, so don't bother polling these
                    //       (tests using these resources should accordingly ensure they're "ready"
                    //        before using them i.e. to retrieve results)
                    // TODO: Revise if this is necessary.
                    if (_postedResource is IStoredAPIResource_WithStatus &&
                        !(_postedResource is OptimizationView))
                    {
                        _postedResource = (T)(_postedResource as IStoredAPIResource_WithStatus)
                            .PollUntilReady(Samples.DataPollingOptions);
                    }
                    _posted = true;
                }
                return _postedResource;
            }
            catch (Exception e)
            {
                Assert.Fail("An error occurred while posting one of the supporting " +
                    "resources required to run this test:\n" + e);
                throw;
            }
        }
        #endregion Public Methods
    }
 
    public static class InjectableResource
    {
        public static IInjectableResource<T> Create<T>(T resource, bool mocked = false)
            where T : IAPIResource
        {
            return new InjectableResource<T>(resource) { Mocked = mocked };
        }
 
        public static IInjectableResource<T> Create<T>(T resource, string data, bool mocked = false)
            where T : IAPIResource_WithDataEndpoint
        {
            return new InjectableResource<T>(resource, data) { Mocked = mocked };
        }
    }
}