Implemented compatibility with sylius 1.8 and added integrations test…

…s for product eligibility
Sylius · Nov 18, 2020 · ec87c8c · ec87c8c
1 parent 775e657
commit ec87c8c
Show file tree

Hide file tree

Showing 38 changed files with 824 additions and 57 deletions.
diff --git a/.gitignore b/.gitignore
@@ -7,3 +7,4 @@
 /phpunit.xml
 
 /.idea/
+/docker/
diff --git a/composer.json b/composer.json
@@ -6,7 +6,7 @@
     "require": {
         "php": "^7.2",
 
-        "sylius/sylius": "^1.4",
+        "sylius/sylius": "^1.8",
         "lexik/jwt-authentication-bundle": "^2.5",
         "symfony/messenger": "^4.3"
     },

diff --git a/spec/Validator/Cart/CartCheckoutItemEligibilityValidatorSpec.php b/spec/Validator/Cart/CartCheckoutItemEligibilityValidatorSpec.php
@@ -0,0 +1,93 @@
+<?php
+
+declare(strict_types=1);
+
+namespace spec\Sylius\ShopApiPlugin\Validator\Cart;
+
+use Doctrine\Common\Collections\ArrayCollection;
+use PhpSpec\ObjectBehavior;
+use Sylius\Component\Core\Model\OrderItemInterface;
+use Sylius\Component\Core\Model\OrderInterface;
+use Sylius\Component\Core\Model\ProductInterface;
+use Sylius\Component\Core\Model\ProductVariantInterface;
+use Sylius\Component\Resource\Repository\RepositoryInterface;
+use Sylius\ShopApiPlugin\Validator\Constraints\CartCheckoutItemEligibility;
+use Symfony\Component\Validator\Context\ExecutionContextInterface;
+
+final class CartCheckoutItemEligibilityValidatorSpec extends ObjectBehavior
+{
+    function let(
+        RepositoryInterface $repository,
+        ExecutionContextInterface $context
+    ): void {
+        $this->beConstructedWith($repository);
+        $this->initialize($context);
+    }
+
+    function it_add_no_violation_if_cart_has_eligible_item(
+        RepositoryInterface $repository,
+        OrderInterface $order,
+        OrderItemInterface $orderItem,
+        ProductVariantInterface $productVariant,
+        ProductInterface $product,
+        ArrayCollection $collection,
+        ExecutionContextInterface $context
+    ): void {
+        $repository->findOneBy(['tokenValue' => 'CART_TOKEN'])->willReturn($order);
+        $order->getItems()->willReturn($collection);
+        $collection->toArray()->willReturn([$orderItem]);
+        $orderItem->getVariant()->willReturn($productVariant);
+        $productVariant->getProduct()->willReturn($product);
+
+        $productVariant->isEnabled()->willReturn(true);
+
+        $product->isEnabled()->willReturn(true);
+
+        $context->addViolation('sylius.shop_api.checkout.cart_item.non_eligible')->shouldNotBeCalled();
+        $context->addViolation('sylius.shop_api.checkout.cart_item_variant.non_eligible')->shouldNotBeCalled();
+
+        $this->validate('CART_TOKEN', new CartCheckoutItemEligibility());
+    }
+
+    function it_add_violation_if_cart_has_non_eligible_item_variant(
+        RepositoryInterface $repository,
+        OrderInterface $order,
+        OrderItemInterface $orderItem,
+        ProductVariantInterface $productVariant,
+        ArrayCollection $collection,
+        ExecutionContextInterface $context
+    ): void {
+        $repository->findOneBy(['tokenValue' => 'CART_TOKEN'])->willReturn($order);
+        $order->getItems()->willReturn($collection);
+        $collection->toArray()->willReturn([$orderItem]);
+        $orderItem->getVariant()->willReturn($productVariant);
+        $productVariant->isEnabled()->willReturn(false);
+
+        $context->addViolation('sylius.shop_api.checkout.cart_item_variant.non_eligible')->shouldBeCalled();
+
+        $this->validate('CART_TOKEN', new CartCheckoutItemEligibility());
+    }
+
+    function it_add_violation_if_cart_has_non_eligible_item(
+        RepositoryInterface $repository,
+        OrderInterface $order,
+        OrderItemInterface $orderItem,
+        ProductVariantInterface $productVariant,
+        ProductInterface $product,
+        ArrayCollection $collection,
+        ExecutionContextInterface $context
+    ): void {
+        $repository->findOneBy(['tokenValue' => 'CART_TOKEN'])->willReturn($order);
+        $order->getItems()->willReturn($collection);
+        $collection->toArray()->willReturn([$orderItem]);
+        $orderItem->getVariant()->willReturn($productVariant);
+        $productVariant->isEnabled()->willReturn(true);
+
+        $productVariant->getProduct()->willReturn($product);
+        $product->isEnabled()->willReturn(false);
+
+        $context->addViolation('sylius.shop_api.checkout.cart_item.non_eligible')->shouldBeCalled();
+
+        $this->validate('CART_TOKEN', new CartCheckoutItemEligibility());
+    }
+}
diff --git a/spec/Validator/Cart/CartItemEligibilityValidatorSpec.php b/spec/Validator/Cart/CartItemEligibilityValidatorSpec.php
@@ -0,0 +1,78 @@
+<?php
+
+declare(strict_types=1);
+
+namespace spec\Sylius\ShopApiPlugin\Validator\Cart;
+
+use PhpSpec\ObjectBehavior;
+use Sylius\Component\Core\Model\OrderItemInterface;
+use Sylius\Component\Core\Model\ProductVariant;
+use Sylius\Component\Order\Repository\OrderItemRepositoryInterface;
+use Sylius\Component\Core\Model\Product;
+use Sylius\ShopApiPlugin\Validator\Constraints\CartItemEligibility;
+use Symfony\Component\Validator\Context\ExecutionContextInterface;
+
+final class CartItemEligibilityValidatorSpec extends ObjectBehavior
+{
+    function let(ExecutionContextInterface $executionContext, OrderItemRepositoryInterface $orderItemRepository): void
+    {
+        $this->beConstructedWith($orderItemRepository);
+
+        $this->initialize($executionContext);
+    }
+
+    function it_does_not_add_constraint_if_order_item_and_order_item_variant_is_eligible(
+        OrderItemRepositoryInterface $orderItemRepository,
+        ExecutionContextInterface $executionContext,
+        OrderItemInterface $orderItem,
+        ProductVariant $productVariant,
+        Product $product
+    ): void {
+        $orderItemRepository->find(1)->willReturn($orderItem);
+        $orderItem->getVariant()->willReturn($productVariant);
+        $productVariant->isEnabled()->willReturn(true);
+
+        $productVariant->getProduct()->willReturn($product);
+        $product->isEnabled()->willReturn(true);
+
+        $executionContext->addViolation('sylius.shop_api.cart_item.product.non_eligible')->shouldNotBeCalled();
+        $executionContext->addViolation('sylius.shop_api.cart_item.product_variant.non_eligible')->shouldNotBeCalled();
+
+        $this->validate(1, new CartItemEligibility());
+    }
+
+    function it_adds_constraint_if_order_item_is_not_eligible(
+        OrderItemRepositoryInterface $orderItemRepository,
+        ExecutionContextInterface $executionContext,
+        OrderItemInterface $orderItem,
+        ProductVariant $productVariant,
+        Product $product
+    ): void {
+        $orderItemRepository->find(1)->willReturn($orderItem);
+        $orderItem->getVariant()->willReturn($productVariant);
+        $productVariant->isEnabled()->willReturn(true);
+
+        $productVariant->getProduct()->willReturn($product);
+        $product->isEnabled()->willReturn(false);
+
+        $executionContext->addViolation('sylius.shop_api.cart_item.product.non_eligible')->shouldBeCalled();
+
+        $this->validate(1, new CartItemEligibility());
+    }
+
+    function it_adds_constraint_if_order_item_variant_is_not_eligible(
+        OrderItemRepositoryInterface $orderItemRepository,
+        ExecutionContextInterface $executionContext,
+        OrderItemInterface $orderItem,
+        ProductVariant $productVariant,
+        Product $product
+    ): void {
+        $orderItemRepository->find(1)->willReturn($orderItem);
+        $orderItem->getVariant()->willReturn($productVariant);
+        $productVariant->isEnabled()->willReturn(false);
+
+        $executionContext->addViolation('sylius.shop_api.cart_item.product_variant.non_eligible')->shouldBeCalled();
+
+        $this->validate(1, new CartItemEligibility());
+    }
+}
diff --git a/spec/Validator/Product/ProductEligibilityValidatorSpec.php b/spec/Validator/Product/ProductEligibilityValidatorSpec.php
@@ -34,7 +34,7 @@ function it_does_not_add_constraint_if_product_enabled(
         $productRepository->findOneByCode('BARBECUE_CODE')->willReturn($product);
         $product->isEnabled()->willReturn(true);
 
-        $executionContext->addViolation('sylius.shop_api.product.eligibility')->shouldNotBeCalled();
+        $executionContext->addViolation('sylius.shop_api.product.non_eligible')->shouldNotBeCalled();
 
         $this->validate('BARBECUE_CODE', new ProductEligibility());
     }
@@ -47,7 +47,7 @@ function it_adds_constraint_if_product_is_disabled(
         $productRepository->findOneByCode('BARBECUE_CODE')->willReturn($product);
         $product->isEnabled()->willReturn(false);
 
-        $executionContext->addViolation('sylius.shop_api.product.eligibility')->shouldBeCalled();
+        $executionContext->addViolation('sylius.shop_api.product.non_eligible')->shouldBeCalled();
 
         $this->validate('BARBECUE_CODE', new ProductEligibility());
     }

diff --git a/spec/Validator/Product/ProductVariantEligibilityValidatorSpec.php b/spec/Validator/Product/ProductVariantEligibilityValidatorSpec.php
@@ -30,7 +30,7 @@ function it_does_not_add_a_violation_if_the_product_variant_is_enabled(
         $productVariantRepository->findOneBy(['code' => 'VARIANT_CODE'])->willReturn($productVariant);
         $productVariant->isEnabled()->willReturn(true);
 
-        $executionContext->addViolation('sylius.shop_api.product_variant.eligibility')->shouldNotBeCalled();
+        $executionContext->addViolation('sylius.shop_api.product_variant.non_eligible')->shouldNotBeCalled();
 
         $this->validate('VARIANT_CODE', new ProductVariantEligibility());
     }
@@ -43,7 +43,7 @@ function it_adds_a_violation_if_the_product_variant_does_not_exist(
         $productVariantRepository->findOneBy(['code' => 'VARIANT_CODE'])->willReturn($productVariant);
         $productVariant->isEnabled()->willReturn(false);
 
-        $executionContext->addViolation('sylius.shop_api.product_variant.eligibility')->shouldBeCalled();
+        $executionContext->addViolation('sylius.shop_api.product_variant.non_eligible')->shouldBeCalled();
 
         $this->validate('VARIANT_CODE', new ProductVariantEligibility());
     }

diff --git a/src/Handler/Cart/PutSimpleItemToCartHandler.php b/src/Handler/Cart/PutSimpleItemToCartHandler.php
@@ -6,6 +6,7 @@
 
 use Sylius\Component\Core\Model\OrderInterface;
 use Sylius\Component\Core\Model\ProductInterface;
+use Sylius\Component\Core\Model\ProductVariant;
 use Sylius\Component\Core\Repository\OrderRepositoryInterface;
 use Sylius\Component\Core\Repository\ProductRepositoryInterface;
 use Sylius\ShopApiPlugin\Checker\ProductInCartChannelCheckerInterface;
@@ -52,6 +53,7 @@ public function __invoke(PutSimpleItemToCart $putSimpleItemToCart): void
         Assert::true($this->channelChecker->isProductInCartChannel($product, $cart), 'Product is not in same channel as cart');
         Assert::true($product->isSimple(), 'Product has to be simple');
 
+        /** @var ProductVariant $productVariant */
         $productVariant = $product->getVariants()[0];
 
         $this->orderModifier->modify($cart, $productVariant, $putSimpleItemToCart->quantity());

diff --git a/src/Resources/config/services/validators/cart.xml b/src/Resources/config/services/validators/cart.xml
@@ -50,5 +50,17 @@
             <argument type="service" id="sylius.shop_api_plugin.checker.promotion_coupon_eligibility_checker" />
             <tag name="validator.constraint_validator" alias="sylius_shop_api_valid_coupon_code_validator" />
         </service>
+
+        <service id="sylius.shop_api_plugin.validator.cart_item_eligibility_validator"
+                 class="Sylius\ShopApiPlugin\Validator\Cart\CartItemEligibilityValidator">
+            <argument type="service" id="sylius.repository.order_item" />
+            <tag name="validator.constraint_validator" alias="sylius_shop_api_cart_item_eligibility_validator" />
+        </service>
+
+        <service id="sylius.shop_api_plugin.validator.cart.cart_checkout_item_eligibility_validator"
+                 class="Sylius\ShopApiPlugin\Validator\Cart\CartCheckoutItemEligibilityValidator">
+            <argument type="service" id="sylius.repository.order" />
+            <tag name="validator.constraint_validator" alias="sylius_shop_api_cart_checkout_item_eligibility_validator" />
+        </service>
     </services>
 </container>
diff --git a/src/Resources/config/validation/cart/ChangeItemQuantityRequest.xml b/src/Resources/config/validation/cart/ChangeItemQuantityRequest.xml
@@ -39,6 +39,7 @@
                 <option name="message">sylius.shop_api.cart_item.not_null</option>
             </constraint>
             <constraint name="Sylius\ShopApiPlugin\Validator\Constraints\CartItemExists" />
+            <constraint name="Sylius\ShopApiPlugin\Validator\Constraints\CartItemEligibility" />
         </property>
     </class>
 </constraint-mapping>
diff --git a/src/Resources/config/validation/checkout/CompleteOrderRequest.xml b/src/Resources/config/validation/checkout/CompleteOrderRequest.xml
@@ -20,6 +20,7 @@
             </constraint>
             <constraint name="Sylius\ShopApiPlugin\Validator\Constraints\CartExists" />
             <constraint name="Sylius\ShopApiPlugin\Validator\Constraints\CartReadyForCheckout" />
+            <constraint name="Sylius\ShopApiPlugin\Validator\Constraints\CartCheckoutItemEligibility" />
         </property>
     </class>
 </constraint-mapping>
diff --git a/src/Validator/Cart/CartCheckoutItemEligibilityValidator.php b/src/Validator/Cart/CartCheckoutItemEligibilityValidator.php
@@ -0,0 +1,62 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sylius\ShopApiPlugin\Validator\Cart;
+
+use Sylius\Component\Core\Model\OrderInterface;
+use Sylius\Component\Core\Model\OrderItemInterface;
+use Sylius\Component\Core\Model\ProductInterface;
+use Sylius\Component\Core\Model\ProductVariantInterface;
+use Sylius\Component\Resource\Repository\RepositoryInterface;
+use Sylius\ShopApiPlugin\Validator\Constraints\CartCheckoutItemEligibility;
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\ConstraintValidator;
+
+final class CartCheckoutItemEligibilityValidator extends ConstraintValidator
+{
+    /** @var RepositoryInterface */
+    private $cartRepository;
+
+    public function __construct(RepositoryInterface $cartRepository)
+    {
+        $this->cartRepository = $cartRepository;
+    }
+
+    /** {@inheritdoc} */
+    public function validate($value, Constraint $constraint): void
+    {
+        /** @var OrderInterface|null $cart */
+        $cart = $this->cartRepository->findOneBy(['tokenValue' => $value]);
+        if ($cart === null) {
+            return;
+        }
+
+        $cartItems = $cart->getItems()->toArray();
+
+        /** @var OrderItemInterface $item */
+        foreach ($cartItems as $item) {
+
+            /** @var ProductVariantInterface $variant */
+            $variant = $item->getVariant();
+
+            if ($variant->isEnabled()) {
+
+                /** @var ProductInterface $product */
+                $product = $variant->getProduct();
+
+                if (!$product->isEnabled()) {
+
+                    /** @var CartCheckoutItemEligibility $constraint */
+                    $this->context->addViolation($constraint->messageOnNonEligibleCartItem);
+                    break;
+                }
+            } else {
+
+                /** @var CartCheckoutItemEligibility $constraint */
+                $this->context->addViolation($constraint->messageOnNonEligibleCartItemVariant);
+                break;
+            }
+        }
+    }
+}
diff --git a/src/Validator/Cart/CartItemEligibilityValidator.php b/src/Validator/Cart/CartItemEligibilityValidator.php
@@ -0,0 +1,57 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Sylius\ShopApiPlugin\Validator\Cart;
+
+use Sylius\Component\Core\Model\OrderItem;
+use Sylius\Component\Core\Model\Product;
+use Sylius\Component\Core\Model\ProductVariant;
+use Sylius\Component\Order\Repository\OrderItemRepositoryInterface;
+use Sylius\ShopApiPlugin\Validator\Constraints\CartItemEligibility;
+use Symfony\Component\Validator\Constraint;
+use Symfony\Component\Validator\ConstraintValidator;
+
+final class CartItemEligibilityValidator extends ConstraintValidator
+{
+    /** @var OrderItemRepositoryInterface */
+    private $orderItemRepository;
+
+    public function __construct(OrderItemRepositoryInterface $orderItemRepository)
+    {
+        $this->orderItemRepository = $orderItemRepository;
+    }
+
+    /** {@inheritdoc} */
+    public function validate($id, Constraint $constraint): void
+    {
+        if (null === $id) {
+            return;
+        }
+
+        /** @var OrderItem|null $orderItem */
+        $orderItem = $this->orderItemRepository->find($id);
+
+        if ($orderItem) {
+
+            /** @var ProductVariant $variant */
+            $variant = $orderItem->getVariant();
+
+            if ($variant->isEnabled()) {
+
+                /** @var Product $product */
+                $product = $variant->getProduct();
+
+                if (!$product->isEnabled()) {
+
+                    /** @var CartItemEligibility $constraint */
+                    $this->context->addViolation($constraint->messageOnNonEligible);
+                }
+            } else {
+
+                /** @var CartItemEligibility $constraint */
+                $this->context->addViolation($constraint->messageOnNonEligibleVariant);
+            }
+        }
+    }
+}