Sylius · GSadee · May 17, 2021 · May 17, 2021 · May 17, 2021 · AdamKasp
diff --git a/...es/inventory/cart_inventory/inability_of_adding_a_product_with_insufficient_stock.feature b/...es/inventory/cart_inventory/inability_of_adding_a_product_with_insufficient_stock.feature
@@ -6,9 +6,9 @@ Feature: Inability to add a specific product to the cart when it is out of stock
 
     Background:
         Given the store operates on a single channel in "United States"
-        And the store has a product "T-shirt banana" priced at "$12.54"
+        And the store has a product "T-shirt banana"
 
-    @ui
+    @ui @api
     Scenario: Not being able to add a product to the cart when it is out of stock
         Given the product "T-shirt banana" is out of stock
         When I check this product's details

diff --git a/src/Sylius/Behat/Context/Api/Shop/CartContext.php b/src/Sylius/Behat/Context/Api/Shop/CartContext.php
@@ -509,6 +509,21 @@ public function iShouldHaveEmptyCart(string $tokenValue): void
         Assert::same(count($items), 0, 'There should be an empty cart');
     }
 
+    /**
+     * @Then I should be unable to add it to the cart
+     */
+    public function iShouldBeUnableToAddItToTheCart(): void
+    {
+        /** @var ProductVariantInterface $productVariant */
+        $productVariant = $this->sharedStorage->get('productVariant');
+
+        $tokenValue = $this->pickupCart();
+        $this->putProductVariantToCart($productVariant, $tokenValue);
+
+        $response = $this->cartsClient->getLastResponse();
+        Assert::same($response->getStatusCode(), 422);
+    }
+
     /**
      * @Then /^(this product) should have ([^"]+) "([^"]+)"$/
      */

diff --git a/src/Sylius/Behat/Context/Api/Shop/ProductContext.php b/src/Sylius/Behat/Context/Api/Shop/ProductContext.php
@@ -21,6 +21,7 @@
 use Sylius\Behat\Client\ResponseCheckerInterface;
 use Sylius\Behat\Service\SharedStorageInterface;
 use Sylius\Component\Core\Model\ProductInterface;
+use Sylius\Component\Product\Model\ProductVariantInterface;
 use Sylius\Component\Taxonomy\Model\TaxonInterface;
 use Symfony\Component\HttpFoundation\Request as HttpRequest;
 use Webmozart\Assert\Assert;
@@ -58,6 +59,7 @@ public function __construct(
     public function iOpenProductPage(ProductInterface $product): void
     {
         $this->client->show($product->getCode());
+        $this->sharedStorage->set('productVariant', current($product->getVariants()->getValues()));
     }
 
     /**
@@ -107,6 +109,19 @@ public function iShouldSeeTheProduct(string $name): void
         ));
     }
 
+    /**
+     * @Then I should see that it is out of stock
+     */
+    public function iShouldSeeItIsOutOfStock(): void
+    {
+        /** @var ProductVariantInterface $productVariant */
+        $productVariant = $this->sharedStorage->get('productVariant');
+
+        $variantResponse = $this->client->showByIri($this->iriConverter->getIriFromItem($productVariant));
+
+        Assert::false($this->responseChecker->getValue($variantResponse, 'inStock'));
+    }
+
     /**
      * @Then I should not see the product :name
      */

diff --git a/src/Sylius/Behat/Resources/config/suites.yml b/src/Sylius/Behat/Resources/config/suites.yml
@@ -19,6 +19,7 @@ imports:
     - suites/api/currency/managing_currencies.yml
     - suites/api/currency/managing_exchange_rates.yml
     - suites/api/homepage/viewing_products.yml
+    - suites/api/inventory/cart_inventory.yml
     - suites/api/locale/managing_locales.yml
     - suites/api/order/managing_orders.yml
     - suites/api/payment/managing_payments.yml

diff --git a/src/Sylius/Behat/Resources/config/suites/api/inventory/cart_inventory.yml b/src/Sylius/Behat/Resources/config/suites/api/inventory/cart_inventory.yml
@@ -0,0 +1,21 @@
+# This file is part of the Sylius package.
+# (c) Paweł Jędrzejewski
+
+default:
+    suites:
+        api_cart_inventory:
+            contexts:
+                - sylius.behat.context.hook.doctrine_orm
+
+                - sylius.behat.context.setup.channel
+                - sylius.behat.context.setup.product
+
+                - sylius.behat.context.transform.lexical
+                - sylius.behat.context.transform.product
+                - sylius.behat.context.transform.shared_storage
+
+                - sylius.behat.context.api.shop.cart
+                - sylius.behat.context.api.shop.product
+
+            filters:
+                tags: "@cart_inventory && @api"
diff --git a/src/Sylius/Bundle/ApiBundle/Resources/config/services.xml b/src/Sylius/Bundle/ApiBundle/Resources/config/services.xml
@@ -141,6 +141,7 @@
             <argument type="service" id="api_platform.serializer.normalizer.item" />
             <argument type="service" id="sylius.calculator.product_variant_price" />
             <argument type="service" id="sylius.context.channel" />
+            <argument type="service" id="sylius.availability_checker" />
             <tag name="serializer.normalizer" priority="64" />
         </service>
 

diff --git a/src/Sylius/Bundle/ApiBundle/Resources/config/services/validator.xml b/src/Sylius/Bundle/ApiBundle/Resources/config/services/validator.xml
@@ -41,6 +41,7 @@
         <service id="sylius.api.validator.adding_eligible_product_variant_to_cart" class="Sylius\Bundle\ApiBundle\Validator\Constraints\AddingEligibleProductVariantToCartValidator">
             <argument type="service" id="sylius.repository.product_variant" />
             <argument type="service" id="sylius.repository.order" />
+            <argument type="service" id="sylius.availability_checker" />
             <tag name="validator.constraint_validator" alias="sylius_api_validator_adding_eligible_product_variant_to_cart" />
         </service>
 

diff --git a/src/Sylius/Bundle/ApiBundle/Resources/translations/validators.en.yaml b/src/Sylius/Bundle/ApiBundle/Resources/translations/validators.en.yaml
@@ -9,5 +9,6 @@ sylius:
         not_exist: 'The product %productName% does not exist.'
     product_variant:
         not_exist: 'The product variant with %productVariantCode% does not exist.'
+        not_sufficient: 'The product variant with %productVariantCode% code does not have sufficient stock.'
     shipment:
         shipped: 'You cannot ship a shipment that was shipped before.'
diff --git a/src/Sylius/Bundle/ApiBundle/Serializer/ProductVariantSerializer.php b/src/Sylius/Bundle/ApiBundle/Serializer/ProductVariantSerializer.php
@@ -6,8 +6,9 @@
 
 use Sylius\Component\Channel\Context\ChannelContextInterface;
 use Sylius\Component\Channel\Context\ChannelNotFoundException;
-use Sylius\Component\Core\Calculator\ProductVariantPriceCalculatorInterface;
+use Sylius\Component\Core\Calculator\ProductVariantPricesCalculatorInterface;
 use Sylius\Component\Core\Model\ProductVariantInterface;
+use Sylius\Component\Inventory\Checker\AvailabilityCheckerInterface;
 use Symfony\Component\Serializer\Normalizer\ContextAwareNormalizerInterface;
 use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
 use Webmozart\Assert\Assert;
@@ -17,20 +18,25 @@ final class ProductVariantSerializer implements ContextAwareNormalizerInterface
     /** @var NormalizerInterface */
     private $objectNormalizer;
 
-    /** @var ProductVariantPriceCalculatorInterface */
+    /** @var ProductVariantPricesCalculatorInterface */
     private $priceCalculator;
 
     /** @var ChannelContextInterface */
     private $channelContext;
 
+    /** @var AvailabilityCheckerInterface */
+    private $availabilityChecker;
+
     public function __construct(
         NormalizerInterface $objectNormalizer,
-        ProductVariantPriceCalculatorInterface $priceCalculator,
-        ChannelContextInterface $channelContext
+        ProductVariantPricesCalculatorInterface $priceCalculator,
+        ChannelContextInterface $channelContext,
+        AvailabilityCheckerInterface $availabilityChecker
     ) {
         $this->objectNormalizer = $objectNormalizer;
         $this->priceCalculator = $priceCalculator;
         $this->channelContext = $channelContext;
+        $this->availabilityChecker = $availabilityChecker;
     }
 
     public function normalize($object, $format = null, array $context = [])
@@ -45,15 +51,17 @@ public function normalize($object, $format = null, array $context = [])
             unset($data['price']);
         }
 
+        $data['inStock'] = $this->availabilityChecker->isStockAvailable($object);
+
         return $data;
     }
 
     public function supportsNormalization($data, $format = null, $context = []): bool
     {
-        return $data instanceof ProductVariantInterface && $this->isAdminGetOperation($context);
+        return $data instanceof ProductVariantInterface && $this->isNotAdminGetOperation($context);
     }
 
-    private function isAdminGetOperation(array $context): bool
+    private function isNotAdminGetOperation(array $context): bool
     {
         return !isset($context['item_operation_name']) || !($context['item_operation_name'] === 'admin_get');
     }

diff --git a/src/Sylius/Bundle/ApiBundle/Validator/Constraints/AddingEligibleProductVariantToCart.php b/src/Sylius/Bundle/ApiBundle/Validator/Constraints/AddingEligibleProductVariantToCart.php
@@ -24,6 +24,9 @@ final class AddingEligibleProductVariantToCart extends Constraint
     /** @var string */
     public $productVariantNotExistMessage = 'sylius.product_variant.not_exist';
 
+    /** @var string */
+    public $productVariantNotSufficient = 'sylius.product_variant.not_sufficient';
+
     public function validatedBy(): string
     {
         return 'sylius_api_validator_adding_eligible_product_variant_to_cart';

diff --git a/...us/Bundle/ApiBundle/Validator/Constraints/AddingEligibleProductVariantToCartValidator.php b/...us/Bundle/ApiBundle/Validator/Constraints/AddingEligibleProductVariantToCartValidator.php
@@ -18,6 +18,7 @@
 use Sylius\Component\Core\Model\ProductInterface;
 use Sylius\Component\Core\Model\ProductVariantInterface;
 use Sylius\Component\Core\Repository\OrderRepositoryInterface;
+use Sylius\Component\Inventory\Checker\AvailabilityCheckerInterface;
 use Sylius\Component\Product\Repository\ProductVariantRepositoryInterface;
 use Symfony\Component\Validator\Constraint;
 use Symfony\Component\Validator\ConstraintValidator;
@@ -32,12 +33,17 @@ final class AddingEligibleProductVariantToCartValidator extends ConstraintValida
     /** @var OrderRepositoryInterface */
     private $orderRepository;
 
+    /** @var AvailabilityCheckerInterface  */
+    private $availabilityChecker;
+
     public function __construct(
         ProductVariantRepositoryInterface $productVariantRepository,
-        OrderRepositoryInterface $orderRepository
+        OrderRepositoryInterface $orderRepository,
+        AvailabilityCheckerInterface $availabilityChecker
     ) {
         $this->productVariantRepository = $productVariantRepository;
         $this->orderRepository = $orderRepository;
+        $this->availabilityChecker = $availabilityChecker;
     }
 
     public function validate($value, Constraint $constraint)
@@ -79,6 +85,15 @@ public function validate($value, Constraint $constraint)
             return;
         }
 
+        if (!$this->availabilityChecker->isStockSufficient($productVariant, $value->quantity)) {
+            $this->context->addViolation(
+                $constraint->productVariantNotSufficient,
+                ['%productVariantCode%' => $productVariant->getCode()]
+            );
+
+            return;
+        }
+
         /** @var OrderInterface|null $cart */
         $cart = $this->orderRepository->findCartByTokenValue($value->getOrderTokenValue());
         Assert::notNull($cart);

diff --git a/src/Sylius/Bundle/ApiBundle/spec/Serializer/ProductVariantSerializerSpec.php b/src/Sylius/Bundle/ApiBundle/spec/Serializer/ProductVariantSerializerSpec.php
@@ -18,6 +18,7 @@
 use Sylius\Component\Core\Calculator\ProductVariantPricesCalculatorInterface;
 use Sylius\Component\Core\Model\ChannelInterface;
 use Sylius\Component\Core\Model\ProductVariant;
+use Sylius\Component\Inventory\Checker\AvailabilityCheckerInterface;
 use Sylius\Component\Order\Model\Order;
 use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
 
@@ -26,9 +27,10 @@ final class ProductVariantSerializerSpec extends ObjectBehavior
     function let(
         NormalizerInterface $objectNormalizer,
         ProductVariantPricesCalculatorInterface $pricesCalculator,
-        ChannelContextInterface $channelContext
+        ChannelContextInterface $channelContext,
+        AvailabilityCheckerInterface $availabilityChecker
     ): void {
-        $this->beConstructedWith($objectNormalizer, $pricesCalculator, $channelContext);
+        $this->beConstructedWith($objectNormalizer, $pricesCalculator, $channelContext, $availabilityChecker);
     }
 
     function it_supports_only_product_variant_interface(): void
@@ -50,15 +52,17 @@ function it_serializes_product_variant_if_item_operation_name_is_different_that_
         NormalizerInterface $objectNormalizer,
         ProductVariantPricesCalculatorInterface $pricesCalculator,
         ChannelInterface $channel,
-        ChannelContextInterface $channelContext
+        ChannelContextInterface $channelContext,
+        AvailabilityCheckerInterface $availabilityChecker
     ): void {
         $variant = new ProductVariant();
 
         $objectNormalizer->normalize($variant, null, [])->willReturn([]);
 
         $channelContext->getChannel()->willReturn($channel);
         $pricesCalculator->calculate($variant, ['channel' => $channel])->willReturn(1000);
+        $availabilityChecker->isStockAvailable($variant)->willReturn(true);
 
-        $this->normalize($variant, null, [])->shouldReturn(['price' => 1000]);
+        $this->normalize($variant, null, [])->shouldReturn(['price' => 1000, 'inStock' => true]);
     }
 }
diff --git a/.../ApiBundle/spec/Validator/Constraints/AddingEligibleProductVariantToCartValidatorSpec.php b/.../ApiBundle/spec/Validator/Constraints/AddingEligibleProductVariantToCartValidatorSpec.php
@@ -23,6 +23,7 @@
 use Sylius\Component\Core\Model\ProductVariantInterface;
 use Sylius\Component\Core\Repository\OrderRepositoryInterface;
 use Sylius\Component\Core\Repository\ProductVariantRepositoryInterface;
+use Sylius\Component\Inventory\Checker\AvailabilityCheckerInterface;
 use Symfony\Component\Validator\Constraint;
 use Symfony\Component\Validator\ConstraintValidatorInterface;
 use Symfony\Component\Validator\Context\ExecutionContextInterface;
@@ -31,9 +32,10 @@ final class AddingEligibleProductVariantToCartValidatorSpec extends ObjectBehavi
 {
     function let(
         ProductVariantRepositoryInterface $productVariantRepository,
-        OrderRepositoryInterface $orderRepository
+        OrderRepositoryInterface $orderRepository,
+        AvailabilityCheckerInterface $availabilityChecker
     ): void {
-        $this->beConstructedWith($productVariantRepository, $orderRepository);
+        $this->beConstructedWith($productVariantRepository, $orderRepository, $availabilityChecker);
     }
 
     function it_is_a_constraint_validator(): void
@@ -129,14 +131,43 @@ function it_adds_violation_if_product_variant_is_disabled(
         );
     }
 
+    function it_adds_violation_if_product_variant_stock_is_not_sufficient(
+        ProductVariantRepositoryInterface $productVariantRepository,
+        ExecutionContextInterface $executionContext,
+        ProductVariantInterface $productVariant,
+        ProductInterface $product,
+        AvailabilityCheckerInterface $availabilityChecker
+    ): void {
+        $this->initialize($executionContext);
+
+        $productVariantRepository->findOneBy(['code' => 'productVariantCode'])->willReturn($productVariant);
+        $productVariant->getCode()->willReturn('productVariantCode');
+        $productVariant->isEnabled()->willReturn(true);
+        $productVariant->getProduct()->willReturn($product);
+        $product->isEnabled()->willReturn(true);
+
+        $availabilityChecker->isStockSufficient($productVariant, 1)->willReturn(false);
+
+        $executionContext
+            ->addViolation('sylius.product_variant.not_sufficient', ['%productVariantCode%' => 'productVariantCode'])
+            ->shouldBeCalled()
+        ;
+
+        $this->validate(
+            new AddItemToCart( 'productVariantCode', 1),
+            new AddingEligibleProductVariantToCart()
+        );
+    }
+
     function it_adds_violation_if_product_is_not_available_in_channel(
         ProductVariantRepositoryInterface $productVariantRepository,
         OrderRepositoryInterface $orderRepository,
         ExecutionContextInterface $executionContext,
         ChannelInterface $channel,
         ProductVariantInterface $productVariant,
         ProductInterface $product,
-        OrderInterface $cart
+        OrderInterface $cart,
+        AvailabilityCheckerInterface $availabilityChecker
     ): void {
         $this->initialize($executionContext);
 
@@ -149,6 +180,8 @@ function it_adds_violation_if_product_is_not_available_in_channel(
         $productVariant->getProduct()->willReturn($product);
 
         $product->isEnabled()->willReturn(true);
+        $availabilityChecker->isStockSufficient($productVariant, 1)->willReturn(true);
+
         $product->hasChannel($channel)->willReturn(false);
         $product->getName()->willReturn('PRODUCT NAME');
 
@@ -170,7 +203,8 @@ function it_does_nothing_if_product_and_variant_are_enabled_and_available_in_cha
         ChannelInterface $channel,
         ProductVariantInterface $productVariant,
         ProductInterface $product,
-        OrderInterface $cart
+        OrderInterface $cart,
+        AvailabilityCheckerInterface $availabilityChecker
     ): void {
         $this->initialize($executionContext);
 
@@ -183,6 +217,8 @@ function it_does_nothing_if_product_and_variant_are_enabled_and_available_in_cha
         $productVariant->getProduct()->willReturn($product);
 
         $product->isEnabled()->willReturn(true);
+        $availabilityChecker->isStockSufficient($productVariant, 1)->willReturn(true);
+
         $product->hasChannel($channel)->willReturn(true);
         $product->getName()->willReturn('PRODUCT NAME');
 
@@ -197,6 +233,10 @@ function it_does_nothing_if_product_and_variant_are_enabled_and_available_in_cha
             ->addViolation('sylius.product.not_exist', ['%productName%' => 'PRODUCT NAME'])
             ->shouldNotBeCalled()
         ;
+        $executionContext
+            ->addViolation('sylius.product_variant.not_sufficient', ['%productVariantCode%' => 'productVariantCode'])
+            ->shouldNotBeCalled()
+        ;
 
         $this->validate($command, new AddingEligibleProductVariantToCart());
     }