Exemple #1
0
            public async Task GetSalesOrders_ShouldReturnSalesOrders_WhenGivenSalesOrders(
                [Frozen] Mock <IMediator> mockMediator,
                List <Core.Handlers.GetSalesOrders.SalesOrderDto> salesOrders,
                [Greedy] SalesOrderController sut,
                GetSalesOrdersQuery query
                )
            {
                //Arrange
                var dto = new GetSalesOrdersDto
                {
                    SalesOrders      = salesOrders,
                    TotalSalesOrders = salesOrders.Count
                };

                mockMediator.Setup(x => x.Send(
                                       It.IsAny <GetSalesOrdersQuery>(),
                                       It.IsAny <CancellationToken>()
                                       ))
                .ReturnsAsync(dto);

                //Act
                var actionResult = await sut.GetSalesOrders(query);

                //Assert
                var okObjectResult = actionResult as OkObjectResult;

                okObjectResult.Should().NotBeNull();

                var result = okObjectResult.Value as Core.Models.SalesOrdersResult;

                result.SalesOrders.Count.Should().Be(salesOrders.Count);
            }
        public async Task Handle_SalesOrdersExists_ReturnSalesOrders(
            List <Core.Entities.SalesOrder> salesOrders,
            [Frozen] Mock <IRepository <Core.Entities.SalesOrder> > salesOrderRepoMock,
            GetSalesOrdersQueryHandler sut,
            GetSalesOrdersQuery query
            )
        {
            //Arrange
            salesOrderRepoMock.Setup(x => x.ListAsync(
                                         It.IsAny <GetSalesOrdersPaginatedSpecification>(),
                                         It.IsAny <CancellationToken>()
                                         ))
            .ReturnsAsync(salesOrders);

            salesOrderRepoMock.Setup(x => x.CountAsync(
                                         It.IsAny <CountSalesOrdersSpecification>(),
                                         It.IsAny <CancellationToken>()
                                         ))
            .ReturnsAsync(salesOrders.Count);

            //Act
            var result = await sut.Handle(query, CancellationToken.None);

            //Assert
            result.Should().NotBeNull();
            salesOrderRepoMock.Verify(x => x.ListAsync(
                                          It.IsAny <GetSalesOrdersPaginatedSpecification>(),
                                          It.IsAny <CancellationToken>()
                                          ));

            for (int i = 0; i < result.SalesOrders.Count; i++)
            {
                result.SalesOrders[i].SalesOrderNumber.Should().Be(salesOrders[i].SalesOrderNumber);
            }
        }
        public void TestValidate_WithValidPageSize_NoValidationError(
            GetSalesOrdersQueryValidator sut,
            GetSalesOrdersQuery query
            )
        {
            //Act
            var result = sut.TestValidate(query);

            //Assert
            result.ShouldNotHaveValidationErrorFor(query => query.PageSize);
            result.ShouldNotHaveValidationErrorFor(query => query.PageIndex);
        }
Exemple #4
0
            public async Task GetSalesOrders_ShouldReturnNotFound_WhenGivenNoSalesOrders(
                [Greedy] SalesOrderController sut,
                GetSalesOrdersQuery query
                )
            {
                //Act
                var actionResult = await sut.GetSalesOrders(query);

                //Assert
                var notFoundResult = actionResult as NotFoundResult;

                notFoundResult.Should().NotBeNull();
            }
        public void TestValidate_WithInvalidPageIndex_ValidationError(
            GetSalesOrdersQueryValidator sut,
            GetSalesOrdersQuery query
            )
        {
            //Arrange
            query.PageIndex = -1;

            //Act
            var result = sut.TestValidate(query);

            //Assert
            result.ShouldHaveValidationErrorFor(query => query.PageIndex)
            .WithErrorMessage("Page index must be 0 or positive");
        }
        public void TestValidate_WithInvalidPageSize_ValidationError(
            GetSalesOrdersQueryValidator sut,
            GetSalesOrdersQuery query
            )
        {
            //Arrange
            query.PageSize = 0;

            //Act
            var result = sut.TestValidate(query);

            //Assert
            result.ShouldHaveValidationErrorFor(query => query.PageSize)
            .WithErrorMessage("Page size must be positive");
        }
        public async Task <List <SalesOrderListDto> > Handle(GetSalesOrdersQuery request, CancellationToken cancellationToken)
        {
            var result = (
                from salesOrders in _context.SalesOrders.ToList()
                join customers in _context.Customers on salesOrders.CustomerId equals customers.Id
                join statuses in _context.Statuses on salesOrders.StatusId equals statuses.Id
                join quantityStatuses in _context.QuantityStatuses on salesOrders.QuantityStatusId equals quantityStatuses.Id
                join shippingStatuses in _context.ShippingStatuses on salesOrders.ShippingStatusId equals shippingStatuses.Id
                join paymentStatuses in _context.PaymentStatuses on salesOrders.PaymentStatusId equals paymentStatuses.Id
                join wareHouses in _context.WareHouses on salesOrders.WareHouseId equals wareHouses.Id

                select new SalesOrderListDto
            {
                Id = salesOrders.Id,
                Tag = salesOrders.Tag,
                Date = salesOrders.Date,
                CustomerId = salesOrders.CustomerId,
                CustomerName = customers.Name,
                StatusId = salesOrders.StatusId,
                StatusName = statuses.Name,
                QuantityStatusId = salesOrders.QuantityStatusId,
                QuantityStatusName = quantityStatuses.Name,
                ShippingStatusId = shippingStatuses.Id,
                PaymentStatusId = paymentStatuses.Id,
                PaymentStatusName = paymentStatuses.Name,
                Amount = salesOrders.Amount,
                AmountTaxIncl = salesOrders.AmountTaxIncl,
                UnpaidAmount = salesOrders.UnpaidAmount,
                AdvancePayment = salesOrders.AdvancePayment,
                WareHouseId = wareHouses.Id,
                WareHouseName = wareHouses.Name,
                Cash = salesOrders.Cash,
                CreditCard = salesOrders.CreditCard
            }).ToList();

            return(result);
        }