public async Task IdOfNonExistentShipper_UpdateShipperOrder_ReturnNotFound()
        {
            const int shipperId         = -1;
            const int orderId           = 4;
            var       shipperOrderModel = new ShipperOrderModel();

            var exception = await Assert.ThrowsAsync <ProblemDetailsException>(() =>
                                                                               _shipperController.UpdateShipperOrder(shipperId, orderId, shipperOrderModel));

            Assert.Equal(StatusCodes.Status404NotFound, exception.Details.Status);
            Assert.Contains("shipper", exception.Details.Title, StringComparison.OrdinalIgnoreCase);
        }
Пример #2
0
        public void ShipperOrderModel_ShipperOrderModelToOrder_ReturnOrder()
        {
            var shipperOrderModel = new ShipperOrderModel
            {
                ShippedDate = DateTimeOffset.Parse("2020-08-22T15:00:00-04:00"),
                ShipName    = "Providence"
            };

            var order = _mapper.Map <Order>(shipperOrderModel);

            Assert.Equal(new DateTimeOffset(2020, 8, 22, 15, 0, 0, new TimeSpan(-4, 0, 0)), order.ShippedDate);
            Assert.Equal("Providence", order.ShipName);
        }
        public async Task FailedToSaveUpdatedOrder_UpdateShipperOrder_ReturnBadRequest()
        {
            const int shipperId         = 3;
            const int orderId           = 8;
            var       shipperOrderModel = new ShipperOrderModel();

            _shipperService.Setup(sh => sh.GetById(shipperId)).ReturnsAsync(new Shipper());
            _shipperService.Setup(sh => sh.GetOrderById(orderId)).ReturnsAsync(new Order());

            var response = await _shipperController.UpdateShipperOrder(shipperId, orderId,
                                                                       shipperOrderModel);

            Assert.IsType <ActionResult <OrderResponseModel> >(response);
            Assert.IsType <BadRequestResult>(response.Result);
            _shipperService.Verify(sh => sh.UpdateEntity(shipperId, It.IsAny <Order>()));
        }
        public async Task <ActionResult <OrderResponseModel> > UpdateShipperOrder(int shipperId, int orderId,
                                                                                  ShipperOrderModel orderModel)
        {
            await DoesShipperExist(shipperId);

            var oldOrder = await _shipperService.GetOrderById(orderId);

            if (oldOrder == null)
            {
                throw new ProblemDetailsException(StatusCodes.Status404NotFound,
                                                  $"Order with id {orderId} not found");
            }

            var newOrder = _mapper.Map(orderModel, oldOrder);

            _shipperService.UpdateEntity(shipperId, newOrder);

            if (await _shipperService.IsSavedToDb())
            {
                return(Ok(_mapper.Map <OrderResponseModel>(newOrder)));
            }

            return(BadRequest());
        }