// Stops running the host as soon as the program marks the task as completed.
        private static TResult RunTrigger <TResult>(IStorageAccount account, Type programType,
                                                    Action <TaskCompletionSource <TResult> > setTaskSource, Action <Task> setStartTask, Action <JobHost> callback)
        {
            TaskCompletionSource <object> startTaskSource = new TaskCompletionSource <object>();

            setStartTask.Invoke(startTaskSource.Task);

            // Arrange
            try
            {
                TaskCompletionSource <TResult> taskSource = new TaskCompletionSource <TResult>();
                IServiceProvider serviceProvider          = FunctionalTest.CreateServiceProviderForManualCompletion <TResult>(
                    account, programType, taskSource);
                Task <TResult> task = taskSource.Task;
                setTaskSource.Invoke(taskSource);

                try
                {
                    // Arrange
                    using (JobHost host = new JobHost(serviceProvider))
                    {
                        host.Start();
                        callback.Invoke(host);
                        startTaskSource.TrySetResult(null);

                        // Act
                        bool completed = task.WaitUntilCompleted(3 * 1000);

                        // Assert
                        Assert.True(completed);

                        // Give a nicer test failure message for faulted tasks.
                        if (task.Status == TaskStatus.Faulted)
                        {
                            task.GetAwaiter().GetResult();
                        }

                        Assert.Equal(TaskStatus.RanToCompletion, task.Status);
                        return(task.Result);
                    }
                }
                finally
                {
                    setTaskSource.Invoke(null);
                }
            }
            finally
            {
                setStartTask.Invoke(null);
            }
        }
Exemplo n.º 2
0
        private static TResult CallQueueTrigger <TResult>(object message, Type programType,
                                                          Action <TaskCompletionSource <TResult> > setTaskSource)
        {
            // Arrange
            TaskCompletionSource <TResult> functionTaskSource = new TaskCompletionSource <TResult>();
            IServiceProvider serviceProvider = FunctionalTest.CreateServiceProviderForManualCompletion <TResult>(
                CreateFakeStorageAccount(), programType, functionTaskSource);
            Task <TResult> functionTask = functionTaskSource.Task;

            setTaskSource.Invoke(functionTaskSource);
            Task callTask;
            bool completed;

            using (JobHost host = new JobHost(serviceProvider))
            {
                try
                {
                    callTask = host.CallAsync(programType.GetMethod("Run"), new { message = message });

                    // Act
                    completed = Task.WhenAll(callTask, functionTask).WaitUntilCompleted(3 * 1000);
                }
                finally
                {
                    setTaskSource.Invoke(null);
                }
            }

            // Assert
            Assert.True(completed);

            // Give a nicer test failure message for faulted tasks.
            if (functionTask.Status == TaskStatus.Faulted)
            {
                functionTask.GetAwaiter().GetResult();
            }

            Assert.Equal(TaskStatus.RanToCompletion, functionTask.Status);
            Assert.Equal(TaskStatus.RanToCompletion, callTask.Status);
            return(functionTask.Result);
        }