Esempio n. 1
0
        public async void Returns_Valid_Order()
        {
            //Arrange
            Guid orderId       = Context.Orders.First().Id;
            var  queryGetOrder = new GetOrderQuery(orderId);

            Mediator.Setup(x => x.Send(It.IsAny <GetOrderQuery>(), new CancellationToken()))
            .ReturnsAsync(new Order());

            //Act
            var handler = new GetOrderQueryHandler(Context);
            var result  = await handler.Handle(queryGetOrder, new CancellationToken());

            //Assert
            result.Should()
            .BeOfType <Order>();
            result.ClientId.Should()
            .NotBeNull();
            result.Amount.Should()
            .BeGreaterThan(0);
            result.Price.Should()
            .BeGreaterThan(0);

            DbContextFactory.Destroy(Context);
        }
        public async Task GetOrderQueryHandler_OrderDoesNotExist_ShouldThrowNotFoundException()
        {
            var sut = new GetOrderQueryHandler(_context, _mapper);

            await sut.Handle(new GetOrderQuery { Id = Guid.NewGuid() }, CancellationToken.None)

            .ShouldThrowAsync <NotFoundException>();
        }
        public async Task GetOrderQueryHandler_WhenCalled_ShouldReturnOrderListViewModel()
        {
            var sut       = new GetOrderQueryHandler(_context, _mapper);
            var orderInDb = _context.Order.First();

            var result = await sut.Handle(new GetOrderQuery { Id = orderInDb.Id }, CancellationToken.None);

            result.ShouldBeOfType <OrderDto>();
        }
        public async Task GetOrderQueryHandler_Success()
        {
            //Arrange
            orderRepository.Setup(x => x.GetByConditionWithIncludeFirst(It.IsAny <Expression <Func <Order, bool> > >(),
                                                                        It.IsAny <Expression <Func <Order, ICollection <OrderItem> > > >())).Returns(Task.FromResult(order));

            mapper.Setup(x => x.Map <GetOrderDto>(order)).Returns(orderDto);

            //Act
            var action = await queryHandler.Handle(query, It.IsAny <CancellationToken>());

            //Assert
            Assert.Equal(orderId, action.OrderId);
        }
Esempio n. 5
0
        public async Task GetAsync()
        {
            var dataAccess = new OrderDataAccess(this.Context);

            //Act
            var sutCreate    = new CreateOrderCommandHandler(dataAccess);
            var resultCreate = await sutCreate.Handle(new CreateOrderCommand
            {
                Data = OrderTestData.OrderDataDTO
            }, CancellationToken.None);

            //Act
            var sutGet    = new GetOrderQueryHandler(dataAccess);
            var resultGet = await sutGet.Handle(new GetOrderQuery
            {
                Id = resultCreate.Data.Id
            }, CancellationToken.None);

            Assert.IsTrue(resultGet?.Data != null);
        }