public async Task Should_Get_Tasks_Only_With_Given_Tag_And_Status_With_Created_Date_Higher_Than_Given()
        {
            // Arrange
            const string     tag    = "RetrieveMe";
            const TaskStatus status = TaskStatus.WaitingForActivation;
            Expression <Action <TestOperator> > expression1 = x => x.VoidMethod();
            var task1 = TaskInfo.FromTaskInfoResponse(expression1.ToTaskInfo(), Storage.None);

            Expression <Action <TestOperator> > expression2 = x => x.ResultMethod();
            var task2 = TaskInfo.FromTaskInfoResponse(expression2.ToTaskInfo(new[] { tag }), Storage.None);

            task2.Status = status;

            await _context.Tasks.AddRangeAsync(task1, task2).ConfigureAwait(false);

            await _context.SaveChangesAsync().ConfigureAwait(false);

            task1.DateCreated = DateTime.Now.AddYears(-5);
            await _context.SaveChangesAsync().ConfigureAwait(false);

            // Act
            var result = await _sut.GetTasks(DateTime.Now.AddDays(-1), tag, status).ConfigureAwait(false);

            // Assert
            result.Count().ShouldBe(1);
        }
        public async Task Dequeues_The_Earliest_Task_With_No_Tags()
        {
            // Arrange
            Expression <Action <TestOperator> > expression1 = x => x.VoidMethod();
            Expression <Action <TestOperator> > expression2 = x => x.ResultMethod();
            Expression <Action <TestOperator> > expression3 = x => x.VoidMethod();
            var task1 = TaskInfo.FromTaskInfoResponse(expression1.ToTaskInfo(), Storage.None);

            task1.DateCreated     = DateTime.UtcNow;
            task1.DateLastUpdated = task1.DateCreated;

            var task2 = TaskInfo.FromTaskInfoResponse(expression2.ToTaskInfo(), Storage.None);

            task2.DateCreated     = DateTime.UtcNow;
            task2.DateLastUpdated = task2.DateCreated;

            var task3 = TaskInfo.FromTaskInfoResponse(expression3.ToTaskInfo(), Storage.None);

            task3.DateCreated     = DateTime.UtcNow;
            task3.DateLastUpdated = task3.DateCreated;
            task3.Tags            = "Tag1,Tag2";
            await _context.Tasks.AddRangeAsync(task1, task2, task3).ConfigureAwait(false);

            await _context.SaveChangesAsync().ConfigureAwait(false);

            // Act
            var result = await _sut.DequeueSingle(cancellationToken : CancellationToken.None).ConfigureAwait(false);

            // Assert
            result.MethodName.ShouldBe(nameof(TestOperator.VoidMethod));
            result.Tags.ShouldBeNull();
        }
        public async Task Dequeues_All_Waiting_Tasks()
        {
            // Arrange
            Expression <Action <TestOperator> > expression1 = x => x.VoidMethod();
            Expression <Action <TestOperator> > expression2 = x => x.ResultMethod();
            Expression <Action <TestOperator> > expression3 = x => x.VoidMethod();
            var task1 = TaskInfo.FromTaskInfoResponse(expression1.ToTaskInfo(), Storage.None);

            task1.DateCreated     = DateTime.UtcNow;
            task1.DateLastUpdated = task1.DateCreated;

            var task2 = TaskInfo.FromTaskInfoResponse(expression2.ToTaskInfo(), Storage.None);

            task2.DateCreated     = DateTime.UtcNow;
            task2.DateLastUpdated = task2.DateCreated;

            var task3 = TaskInfo.FromTaskInfoResponse(expression3.ToTaskInfo(), Storage.None);

            task3.DateCreated     = DateTime.UtcNow;
            task3.DateLastUpdated = task3.DateCreated;
            await _context.Tasks.AddRangeAsync(task1, task2, task3).ConfigureAwait(false);

            await _context.SaveChangesAsync().ConfigureAwait(false);

            // Act
            var result = await _sut.Dequeue(cancellationToken : CancellationToken.None).ConfigureAwait(false);

            // Assert
            var resultArray = result as ServiceContract.Models.TaskInfo[] ?? result.ToArray();

            resultArray.ShouldNotBeEmpty();
            resultArray.Length.ShouldBe(3);
        }
        public async Task Only_Dequeues_Waiting_Tasks()
        {
            // Arrange
            Expression <Action <TestOperator> > expression1 = x => x.VoidMethod();
            Expression <Action <TestOperator> > expression2 = x => x.ResultMethod();
            var task1 = TaskInfo.FromTaskInfoResponse(expression1.ToTaskInfo(), Storage.None);

            task1.DateCreated     = DateTime.UtcNow;
            task1.DateLastUpdated = task1.DateCreated;

            var task2 = TaskInfo.FromTaskInfoResponse(expression2.ToTaskInfo(), Storage.None);

            task2.Status          = TaskStatus.Faulted;
            task2.DateCreated     = DateTime.UtcNow.AddMinutes(-5);
            task2.DateLastUpdated = DateTime.UtcNow.AddMinutes(-10);
            await _context.Tasks.AddRangeAsync(task1, task2).ConfigureAwait(false);

            await _context.SaveChangesAsync().ConfigureAwait(false);

            // Act
            var result = await _sut.DequeueSingle().ConfigureAwait(false);

            // Assert
            result.MethodName.ShouldBe(nameof(TestOperator.VoidMethod));
        }
        public async Task Should_Get_All_Tasks()
        {
            // Arrange
            Expression <Action <TestOperator> > expression1 = x => x.VoidMethod();
            var task1 = TaskInfo.FromTaskInfoResponse(expression1.ToTaskInfo(), Storage.None);

            Expression <Action <TestOperator> > expression2 = x => x.ResultMethod();
            var task2 = TaskInfo.FromTaskInfoResponse(expression2.ToTaskInfo(), Storage.None);

            await _context.Tasks.AddRangeAsync(task1, task2).ConfigureAwait(false);

            await _context.SaveChangesAsync().ConfigureAwait(false);

            // Act
            var result = await _sut.GetTasks().ConfigureAwait(false);

            // Assert
            result.Count().ShouldBe(2);
        }
        public async Task Should_Get_Tasks_Only_With_Given_Tag()
        {
            // Arrange
            const string tag = "RetrieveMe";
            Expression <Action <TestOperator> > expression1 = x => x.VoidMethod();
            var task1 = TaskInfo.FromTaskInfoResponse(expression1.ToTaskInfo(new[] { tag }), Storage.None);

            Expression <Action <TestOperator> > expression2 = x => x.ResultMethod();
            var task2 = TaskInfo.FromTaskInfoResponse(expression2.ToTaskInfo(), Storage.None);

            await _context.Tasks.AddRangeAsync(task1, task2).ConfigureAwait(false);

            await _context.SaveChangesAsync().ConfigureAwait(false);

            // Act
            var result = await _sut.GetTasks(tag : tag).ConfigureAwait(false);

            // Assert
            result.Count().ShouldBe(1);
        }
        public async Task Should_Get_Tasks_Only_With_Given_Status()
        {
            // Arrange
            const TaskStatus status = TaskStatus.RanToCompletion;
            Expression <Action <TestOperator> > expression1 = x => x.VoidMethod();
            var task1 = TaskInfo.FromTaskInfoResponse(expression1.ToTaskInfo(), Storage.None);

            task1.Status = status;

            Expression <Action <TestOperator> > expression2 = x => x.ResultMethod();
            var task2 = TaskInfo.FromTaskInfoResponse(expression2.ToTaskInfo(), Storage.None);

            await _context.Tasks.AddRangeAsync(task1, task2).ConfigureAwait(false);

            await _context.SaveChangesAsync().ConfigureAwait(false);

            // Act
            var result = await _sut.GetTasks(status : status).ConfigureAwait(false);

            // Assert
            result.Count().ShouldBe(1);
        }
        public async Task Should_Get_Tasks_With_Created_Date_Higher_Than_Given()
        {
            // Arrange
            Expression <Action <TestOperator> > expression1 = x => x.VoidMethod();
            var task1 = TaskInfo.FromTaskInfoResponse(expression1.ToTaskInfo(), Storage.None);

            Expression <Action <TestOperator> > expression2 = x => x.ResultMethod();
            var task2 = TaskInfo.FromTaskInfoResponse(expression2.ToTaskInfo(), Storage.None);

            await _context.Tasks.AddRangeAsync(task1, task2).ConfigureAwait(false);

            await _context.SaveChangesAsync().ConfigureAwait(false);

            task1.DateCreated = DateTime.Now.AddYears(-5);
            await _context.SaveChangesAsync().ConfigureAwait(false);

            // Act
            var result = await _sut.GetTasks(DateTime.Now.AddDays(-1)).ConfigureAwait(false);

            // Assert
            result.Count().ShouldBe(1);
        }
        public async Task Dequeues_The_LastUpdated_Task()
        {
            // Arrange
            Expression <Action <TestOperator> > expression1 = x => x.VoidMethod();
            var task1 = TaskInfo.FromTaskInfoResponse(expression1.ToTaskInfo(), Storage.None);

            Expression <Action <TestOperator> > expression2 = x => x.ResultMethod();
            var task2 = TaskInfo.FromTaskInfoResponse(expression2.ToTaskInfo(), Storage.None);

            await _context.Tasks.AddRangeAsync(task1, task2).ConfigureAwait(false);

            await _context.SaveChangesAsync().ConfigureAwait(false);

            Thread.Sleep(2000);

            task1.Status = TaskStatus.Canceled;
            await _context.SaveChangesAsync().ConfigureAwait(false);

            // Act
            var result = await _sut.DequeueSingle().ConfigureAwait(false);

            // Assert
            result.MethodName.ShouldBe(nameof(TestOperator.ResultMethod));
        }