public void Then_Should_Throw_Exception_After_Tasks_Fail()
        {
            var exceptionToThrow = new ArgumentNullException();
            var firstTask        = new PandaTask();
            var secondTask       = new PandaTask();

            var continiueTask = firstTask.Then(() => secondTask).Fail(_ => throw exceptionToThrow);

            Assert.IsNull(continiueTask.Error);

            Exception finalException = null;

            try
            {
                secondTask.Reject();
                firstTask.Reject();
            }
            catch (Exception e) when(e is ArgumentNullException nullException)
            {
                finalException = nullException;
            }

            Assert.That(exceptionToThrow, Is.EqualTo(finalException));
            Assert.IsAssignableFrom <TaskRejectedException>(continiueTask.Error);
        }
        public void RejectTest()
        {
            //arrange
            var testTask = new PandaTask <int>();

            //act
            Exception testException = new Exception();

            testTask.Reject(testException);

            //assert
            Assert.AreEqual(testException, testTask.Error);

            Exception realException = null;

            try
            {
                var _ = testTask.Result;
            }
            catch (Exception exception)
            {
                realException = exception;
            }

            Assert.AreEqual(testException, realException);
        }
        public void SetValueTest()
        {
            //arrange
            var testTask = new PandaTask <int>();

            int callbackResult = 0;

            testTask.Done(x => callbackResult = x);

            bool rejected = false;

            testTask.Fail(x => rejected = true);

            //act
            const int testValue = 32;

            testTask.SetValue(testValue);

            //assert
            Assert.False(rejected);
            Assert.Null(testTask.Error);
            Assert.AreEqual(testValue, callbackResult);
            Assert.AreEqual(testValue, testTask.Result);
            Assert.AreEqual(PandaTaskStatus.Resolved, testTask.Status);
        }
        public void CatchWithTaskTest()
        {
            //arrange
            Exception  realEception = null;
            IPandaTask nextTask     = new PandaTask();

            IPandaTask NextTaskCallback(Exception ex)
            {
                realEception = ex;
                return(nextTask);
            }

            Exception excpectException = new Exception();

            _task.Reject(excpectException);

            //act
            IPandaTask rejectTask = _task.Catch(NextTaskCallback);
            var        castedTask = rejectTask as ContinuationTaskFromPandaTask;

            var        callback = RuntimeReflection.GetValue <Func <IPandaTask>, ContinuationTaskFromPandaTask>(@"_nextActionDelegate", castedTask);
            IPandaTask realTask = callback();

            //assert
            Assert.NotNull(castedTask);
            Assert.True(castedTask.FromCatch);

            Assert.AreEqual(realTask, nextTask);
            Assert.AreEqual(excpectException, realEception);
        }
        public void SetValueTest()
        {
            //arrange
            PandaTask <int> testTask = ConstructTask <int, int>();

            //act-assert
            Assert.Throws <InvalidOperationException>(() => testTask.SetValue(42));
        }
        public void ResolveTest()
        {
            //arrange
            PandaTask <int> testTask = ConstructTask <int, int>();

            //act-assert
            Assert.Throws <InvalidOperationException>(testTask.Resolve);
        }
Example #7
0
        /// <summary>
        /// Do the lookup!
        /// </summary>
        protected override void ProcessRecord()
        {
            // Setup for verbosity if we need it.
            var listener = new PSListener(this);

            Trace.Listeners.Add(listener);
            try
            {
                PandaTask t            = null;
                bool      needdatasets = OutputContainerNames.IsPresent || InputContainerNames.IsPresent;

                if (ParameterSetName == "TaskID")
                {
                    t = TaskID.FindPandaJobWithTaskName(needdatasets);
                }
                if (ParameterSetName == "TaskObject")
                {
                    t = PandaTaskObject.ID.FindPandaJobWithTaskName(needdatasets);
                }
                if (ParameterSetName == "TaskName")
                {
                    t = TaskName.FindPandaJobWithTaskName(needdatasets);
                }
                if (ParameterSetName == "DatasetGRIDJob")
                {
                    // Get the job and resulting dataset name.
                    var job = JobParser.FindJob(JobName, JobVersion);
                    var ds  = job.ResultingDataSetName(DatasetName.Trim(), JobIteration);

                    // Now, look up the job itself.
                    t = (ds + "/").FindPandaJobWithTaskName();
                }

                // We really can't deal with a bad task below. The returned objects are sufficiently complex.
                if (t == null)
                {
                    throw new ArgumentException("Unable to find the task in panda: was it ever submitted?");
                }

                // Dump the info to the output pipeline as requested.
                if (JobStatus.IsPresent)
                {
                    WriteObject(t.status);
                }
                if (InputContainerNames.IsPresent)
                {
                    WriteObject(t.DataSetNamesIN());
                }
                if (OutputContainerNames.IsPresent)
                {
                    WriteObject(t.DataSetNamesOUT());
                }
            } finally
            {
                Trace.Listeners.Remove(listener);
            }
        }
        public void SetValueAfterRejectTest()
        {
            //arrange
            var testTask = new PandaTask <int>();

            testTask.Reject();

            //act-assert
            Assert.Throws <InvalidOperationException>(() => testTask.SetValue(0));
        }
        public void DoubleRejectTest()
        {
            //arrange
            var testTask = new PandaTask <int>();

            testTask.Reject();

            //act-assert
            Assert.Throws <InvalidOperationException>(testTask.Reject);
        }
        public void DoubleResolveTest()
        {
            //arrange
            var task = new PandaTask();

            task.Resolve();

            //act-assert
            Assert.Throws <InvalidOperationException>(task.Resolve);
        }
        public void Init()
        {
            //create task
            _task = new PandaTask();

            //exception handling
            _taskSuccess   = false;
            _realException = null;
            _task.Fail(x => _realException = _realException == null ? x : null).Done(() => _taskSuccess = true);
        }
        private Tuple <ContinuationTaskFromPandaTask, PandaTask> ConstructTask(bool fromCatch = false, Func <IPandaTask> nextTaskCallback = null)
        {
            var firstTask = new PandaTask();

            if (nextTaskCallback == null)
            {
                nextTaskCallback = () => null;
            }

            return(new Tuple <ContinuationTaskFromPandaTask, PandaTask>(new ContinuationTaskFromPandaTask(firstTask, nextTaskCallback, fromCatch), firstTask));
        }
Example #13
0
        /// <summary>
        /// Do the panda task lookup. Throw if we can't find the job.
        /// </summary>
        /// <param name="ds"></param>
        /// <returns></returns>
        private PandaTask FindPandaJobForDS(string ds)
        {
            PandaTask pandaJob = (ds + "/").FindPandaJobWithTaskName();

            if (pandaJob == null)
            {
                throw new InvalidOperationException(string.Format("Unknown error - submitted job ({0},{1}) on dataset {2}, but no panda task found!", JobName, JobVersion, DatasetName));
            }

            return(pandaJob);
        }
        public void DisposeTest()
        {
            //arrange
            var testTask = new PandaTask <int>();

            //act
            testTask.Dispose();

            //assert
            Assert.AreEqual(PandaTaskStatus.Rejected, testTask.Status);
            Assert.IsInstanceOf <ObjectDisposedException>(testTask.Error);
        }
        public void CreateTest()
        {
            //act
            PandaTask <int> testTask = ConstructTask <int, int>();

            //assert
            Assert.AreEqual(PandaTaskStatus.Pending, testTask.Status);
            Assert.Throws <InvalidOperationException>(() =>
            {
                var _ = testTask.Result;
            });

            Assert.Null(testTask.Error);
        }
        public void RejectFromCatchReolveTest()
        {
            //arrange
            PandaTask nextTask = new PandaTask();
            Tuple <ContinuationTaskFromPandaTask, PandaTask> taskPair = ConstructTask(true, () => nextTask);

            taskPair.Item2.Reject( );

            //act
            nextTask.Resolve();

            //assert
            Assert.Null(taskPair.Item1.Error);
            Assert.AreEqual(PandaTaskStatus.Resolved, taskPair.Item1.Status);
        }
        private PandaTask <TResult> ConstructTask <TFirstResult, TResult>(IPandaTask <TFirstResult> firstTask = null, bool fromCatch = false, Func <IPandaTask <TResult> > nextTaskCallback = null)
        {
            //create default task
            if (firstTask == null)
            {
                firstTask = new PandaTask <TFirstResult>();
            }

            if (nextTaskCallback == null)
            {
                nextTaskCallback = () => null;
            }

            return(new ContinuationTaskFromPandaTask <TResult>(firstTask, nextTaskCallback, fromCatch));
        }
        public void Then_Should_Throw_Exception_After_Tasks_Resolve()
        {
            var firstTask  = new PandaTask();
            var secondTask = new PandaTask();

            var continiueTask = firstTask.Then(() => secondTask).Done(() => throw new ArgumentNullException());

            Assert.Throws <ArgumentNullException>(() =>
            {
                secondTask.Resolve();
                firstTask.Resolve();
            });

            Assert.IsNull(continiueTask.Error);
        }
        public void ChainCatchTest()
        {
            //arrange
            var testTask   = new PandaTask <int>();
            var testTask2  = new PandaTask <int>();
            var resultTask = testTask.Catch(x => testTask2);

            //act
            const int testValue = 1;

            testTask.SetValue(testValue);

            //assert
            Assert.AreEqual(testValue, resultTask.Result);
        }
Example #20
0
        public void ResolveAfterDisposeTest()
        {
            //arrange
            var innerTask = new PandaTask();
            var task      = new WhenAllPandaTask(new[] { innerTask }, CancellationStrategy.Aggregate);

            task.Dispose();

            //act
            innerTask.Resolve();

            //assert
            Assert.AreEqual(PandaTaskStatus.Rejected, task.Status);
            Assert.IsInstanceOf <ObjectDisposedException>(task.Error.GetBaseException());
        }
        public void ThenResultRejectFirstTest()
        {
            //arrange
            var firstTask = new PandaTask();
            var nextTask  = new PandaTask <int>();

            IPandaTask <int> resultTask = firstTask.Then(() => nextTask);

            //act
            var testError = new Exception();

            firstTask.Reject(testError);

            //assert
            Assert.AreEqual(PandaTaskStatus.Rejected, resultTask.Status);
            Assert.AreEqual(testError, resultTask.Error);
        }
        public void Then_Should_Save_Exception_In_Stack_After_Tasks_Fail()
        {
            var rejectException = new Exception("some text");
            var firstTask       = new PandaTask();
            var secondTask      = new PandaTask();

            var continiueTask = firstTask.Then(() => secondTask).Fail(_ => throw new ArgumentNullException());

            try
            {
                secondTask.Reject(rejectException);
                firstTask.Reject(rejectException);
            }
            catch {}

            Assert.That(continiueTask.Error, Is.EqualTo(rejectException));
        }
        public void DisposeTest()
        {
            //arrange
            PandaTask <int> testTask = ConstructTask <int, int>();

            //act
            testTask.Dispose();

            //assert
            Assert.AreEqual(PandaTaskStatus.Rejected, testTask.Status);

            Assert.Throws <ObjectDisposedException>(() =>
            {
                var _ = testTask.Result;
            });
            Assert.IsInstanceOf <ObjectDisposedException>(testTask.Error);
        }
        public void ThenResultResolveTest()
        {
            //arrange
            var firstTask = new PandaTask();
            var nextTask  = new PandaTask <int>();

            IPandaTask <int> resultTask = firstTask.Then(() => nextTask);

            //act
            firstTask.Resolve();
            const int testValue = 1;

            nextTask.SetValue(testValue);

            //assert
            Assert.AreEqual(PandaTaskStatus.Resolved, resultTask.Status);
            Assert.AreEqual(testValue, resultTask.Result);
        }
        public void ResolveFromRejectTest()
        {
            //arrange
            var firstTask  = new PandaTask <int>();
            var secondTask = new PandaTask <int>();

            const int       realResult = 3;
            PandaTask <int> testTask   = ConstructTask(firstTask, true, () =>
            {
                secondTask.SetValue(realResult);
                return(secondTask);
            });

            //act
            firstTask.Reject();

            //assert
            Assert.AreEqual(realResult, testTask.Result);
            Assert.AreEqual(PandaTaskStatus.Resolved, testTask.Status);
        }
        public void ResolveTaskTest()
        {
            //arrange
            var firstTask  = new PandaTask <int>();
            var secondTask = new PandaTask <int>();

            const int       offset   = 3;
            PandaTask <int> testTask = ConstructTask(firstTask, false, () =>
            {
                secondTask.SetValue(firstTask.Result + offset);
                return(secondTask);
            });

            //act
            firstTask.Resolve();

            //assert
            Assert.AreEqual(firstTask.Result + offset, testTask.Result);
            Assert.AreEqual(PandaTaskStatus.Resolved, testTask.Status);
        }
Example #27
0
        public void ChangeCollectionCompleteErrorTest()
        {
            //arrange
            var source = new PandaTask();
            var tasks  = new List <IPandaTask>
            {
                PandaTasksUtilities.CompletedTask,
                source
            };

            var allTask = new WhenAllPandaTask(tasks, CancellationStrategy.Aggregate);

            tasks.Add(PandaTasksUtilities.CanceledTask);

            //act
            source.Resolve();

            //assert
            Assert.AreEqual(PandaTaskStatus.Resolved, allTask.Status);
        }
        public void RejectResultTest()
        {
            //arrange
            var firstTask  = new PandaTask <int>();
            var secondTask = new PandaTask <int>();

            const int       realResult     = 3;
            bool            callbackCalled = false;
            PandaTask <int> testTask       = new ContinuationTaskFromPandaTask <int>(firstTask, () =>
            {
                callbackCalled = true;
                return(secondTask);
            }, true);

            //act
            firstTask.SetValue(realResult);

            //assert
            Assert.False(callbackCalled);
            Assert.AreEqual(realResult, testTask.Result);
            Assert.AreEqual(PandaTaskStatus.Resolved, testTask.Status);
        }
        public void ResolveSecondTest()
        {
            //arrange
            PandaTask nextTask = new PandaTask();
            Tuple <ContinuationTaskFromPandaTask, PandaTask> taskPair = ConstructTask(false, () => nextTask);

            bool doneCall  = false;
            bool catchCall = false;

            taskPair.Item1.Done(() => doneCall = true).Fail(ex => catchCall = true);

            taskPair.Item2.Resolve();

            //act
            nextTask.Resolve();

            //assert
            Assert.True(doneCall);
            Assert.False(catchCall);

            Assert.Null(taskPair.Item1.Error);
            Assert.AreEqual(taskPair.Item1.Status, PandaTaskStatus.Resolved);
        }
Example #30
0
        public void ChangeCollectionCompleteWithErrorTest()
        {
            //arrange
            var source = new PandaTask();
            var tasks  = new List <IPandaTask>
            {
                PandaTasksUtilities.CompletedTask,
                source
            };

            var allTask = new WhenAllPandaTask(tasks, CancellationStrategy.Aggregate);

            tasks.Add(PandaTasksUtilities.CanceledTask);

            //act
            var testError = new Exception();

            source.Reject(testError);

            //assert
            Assert.AreEqual(PandaTaskStatus.Rejected, allTask.Status);
            Assert.IsInstanceOf <AggregateException>(allTask.Error);
            CollectionAssert.AreEqual(new[] { testError }, (( AggregateException )allTask.Error).InnerExceptions);
        }