Esempio n. 1
0
        public void Arrange()
        {
            _request = new GetDataLockEventsQueryRequest
            {
                PageNumber   = 0,
                SinceEventId = 1,
                SinceTime    = DateTime.Now
            };

            _pageNumberMustBeAtLeastOneRule = new Mock <PageNumberMustBeAtLeastOneRule>();
            _pageNumberMustBeAtLeastOneRule
            .Setup(r => r.Validate(It.IsAny <int>()))
            .ReturnsAsync(PageNumberMessage);

            _validator = new Application.DataLock.GetDataLockEventsQuery.GetDataLockEventsQueryRequestValidator(_pageNumberMustBeAtLeastOneRule.Object);
        }
Esempio n. 2
0
        public async Task AndNoRulesFailThenItShouldReturnAValidResponse()
        {
            // Arrange
            _pageNumberMustBeAtLeastOneRule
            .Setup(r => r.Validate(It.IsAny <int>()))
            .ReturnsAsync(null);

            _request = new GetDataLockEventsQueryRequest
            {
                PageNumber = 1
            };

            // Act
            var actual = await _validator.Validate(_request);

            // Assert
            Assert.IsNotNull(actual);
            Assert.IsTrue(actual.IsValid);
        }
        public void Arrange()
        {
            _validator = new Mock <IValidator <GetDataLockEventsQueryRequest> >();
            _validator
            .Setup(v => v.Validate(It.IsAny <GetDataLockEventsQueryRequest>()))
            .ReturnsAsync(new ValidationResult());

            _dataLockEventsRepository = new Mock <IDataLockRepository>();
            _dataLockEventsRepository
            .Setup(r => r.GetDataLockEventsSinceId(It.IsAny <long>(), It.IsAny <int>(), It.IsAny <int>()))
            .ReturnsAsync(new PageOfResults <DataLockEventEntity>
            {
                PageNumber         = 1,
                TotalNumberOfPages = 2,
                Items = new[]
                {
                    new DataLockEventEntity {
                        Id = 1, HasErrors = true
                    }
                }
            });

            _dataLockEventsRepository
            .Setup(r => r.GetDataLockEventsSinceTime(It.IsAny <DateTime>(), It.IsAny <int>(), It.IsAny <int>()))
            .ReturnsAsync(new PageOfResults <DataLockEventEntity>
            {
                PageNumber         = 2,
                TotalNumberOfPages = 3,
                Items = new[]
                {
                    new DataLockEventEntity {
                        Id = 2, HasErrors = true
                    }
                }
            });

            _dataLockEventsRepository
            .Setup(r => r.GetDataLockEventsForAccountSinceId(It.IsAny <string>(), It.IsAny <long>(), It.IsAny <int>(), It.IsAny <int>()))
            .ReturnsAsync(new PageOfResults <DataLockEventEntity>
            {
                PageNumber         = 3,
                TotalNumberOfPages = 4,
                Items = new[]
                {
                    new DataLockEventEntity {
                        Id = 3, HasErrors = true
                    }
                }
            });

            _dataLockEventsRepository
            .Setup(r => r.GetDataLockEventsForAccountSinceTime(It.IsAny <string>(), It.IsAny <DateTime>(), It.IsAny <int>(), It.IsAny <int>()))
            .ReturnsAsync(new PageOfResults <DataLockEventEntity>
            {
                PageNumber         = 4,
                TotalNumberOfPages = 5,
                Items = new[]
                {
                    new DataLockEventEntity {
                        Id = 4, HasErrors = true
                    }
                }
            });

            _dataLockEventsRepository
            .Setup(r => r.GetDataLockEventsForProviderSinceId(It.IsAny <long>(), It.IsAny <long>(), It.IsAny <int>(), It.IsAny <int>()))
            .ReturnsAsync(new PageOfResults <DataLockEventEntity>
            {
                PageNumber         = 5,
                TotalNumberOfPages = 6,
                Items = new[]
                {
                    new DataLockEventEntity {
                        Id = 5, HasErrors = true
                    }
                }
            });

            _dataLockEventsRepository
            .Setup(r => r.GetDataLockEventsForProviderSinceTime(It.IsAny <long>(), It.IsAny <DateTime>(), It.IsAny <int>(), It.IsAny <int>()))
            .ReturnsAsync(new PageOfResults <DataLockEventEntity>
            {
                PageNumber         = 6,
                TotalNumberOfPages = 7,
                Items = new[]
                {
                    new DataLockEventEntity {
                        Id = 6, HasErrors = true
                    }
                }
            });

            _dataLockEventsRepository
            .Setup(r => r.GetDataLockEventsForAccountAndProviderSinceId(It.IsAny <string>(), It.IsAny <long>(), It.IsAny <long>(), It.IsAny <int>(), It.IsAny <int>()))
            .ReturnsAsync(new PageOfResults <DataLockEventEntity>
            {
                PageNumber         = 7,
                TotalNumberOfPages = 8,
                Items = new[]
                {
                    new DataLockEventEntity {
                        Id = 7, HasErrors = true
                    }
                }
            });

            _dataLockEventsRepository
            .Setup(r => r.GetDataLockEventsForAccountAndProviderSinceTime(It.IsAny <string>(), It.IsAny <long>(), It.IsAny <DateTime>(), It.IsAny <int>(), It.IsAny <int>()))
            .ReturnsAsync(new PageOfResults <DataLockEventEntity>
            {
                PageNumber         = 8,
                TotalNumberOfPages = 9,
                Items = new[]
                {
                    new DataLockEventEntity {
                        Id = 8, HasErrors = true
                    }
                }
            });

            _dataLockEventsRepository
            .Setup(r => r.GetDataLockErrorsForEvents(It.IsAny <string[]>()))
            .ReturnsAsync(new[]
            {
                new DataLockEventErrorEntity
                {
                    ErrorCode         = "Err1",
                    SystemDescription = "Error 1"
                }
            });

            _mapper = new Mock <IMapper>();
            _mapper
            .Setup(m => m.Map <PageOfResults <DataLockEvent> >(It.IsAny <PageOfResults <DataLockEventEntity> >()))
            .Returns((PageOfResults <DataLockEventEntity> source) =>
            {
                return(new PageOfResults <DataLockEvent>
                {
                    PageNumber = source.PageNumber,
                    TotalNumberOfPages = source.TotalNumberOfPages,
                    Items = source.Items.Select(e => new DataLockEvent
                    {
                        Id = e.Id
                    }).ToArray()
                });
            });

            _handler = new Application.DataLock.GetDataLockEventsQuery.GetDataLockEventsQueryHandler(_validator.Object, _dataLockEventsRepository.Object, _mapper.Object);

            _request = new GetDataLockEventsQueryRequest();
        }