ProductContext::__construct() - Code Metrics - Inspection of "Remove ContentBundle" - pamil/Sylius - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — remove-content-bundle ( 201341...8d07b3 )

by Kamil

created 2016-11-14 09:52 UTC

ProductContext::__construct() A

↳ Parent: ProductContext

Complexity

Conditions	1
Paths	1

Size

Total Lines	9
Code Lines	7

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	9
rs	9.6666
c	0
b	0
f	0
cc	1
eloc	7
nc	1
nop	3

<?php

/*
 * This file is part of the Sylius package.
 *
 * (c) Paweł Jędrzejewski
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Sylius\Behat\Context\Ui\Shop;

use Behat\Behat\Context\Context;
use Sylius\Behat\Page\Shop\Product\ShowPageInterface;
use Sylius\Behat\Page\Shop\ProductReview\IndexPageInterface;
use Sylius\Behat\Page\Shop\Taxon\ShowPageInterface as TaxonShowPageInterface;
use Sylius\Component\Core\Model\ProductInterface;
use Sylius\Component\Core\Model\TaxonInterface;
use Webmozart\Assert\Assert;

/**
 * @author Kamil Kokot <[email protected]>
 * @author Magdalena Banasiak <[email protected]>
 * @author Anna Walasek <[email protected]>
 */
final class ProductContext implements Context
{
    /**
     * @var ShowPageInterface
     */
    private $showPage;

    /**
     * @var TaxonShowPageInterface
     */
    private $taxonShowPage;

    /**
     * @var IndexPageInterface
     */
    private $productReviewsIndexPage;

    /**
     * @param ShowPageInterface $showPage
     * @param TaxonShowPageInterface $taxonShowPage
     * @param IndexPageInterface $productReviewsIndexPage
     */
    public function __construct(
        ShowPageInterface $showPage,
        TaxonShowPageInterface $taxonShowPage,
        IndexPageInterface $productReviewsIndexPage
    ) {
        $this->showPage = $showPage;
        $this->taxonShowPage = $taxonShowPage;
        $this->productReviewsIndexPage = $productReviewsIndexPage;
    }

    /**
     * @Then I should be able to access product :product
     */
    public function iShouldBeAbleToAccessProduct(ProductInterface $product)
    {
        $this->showPage->tryToOpen(['slug' => $product->getSlug()]);

        Assert::true(
            $this->showPage->isOpen(['slug' => $product->getSlug()]),
            'Product show page should be open, but it does not.'
        );
    }

    /**
     * @Then I should not be able to access product :product
     */
    public function iShouldNotBeAbleToAccessProduct(ProductInterface $product)
    {
        $this->showPage->tryToOpen(['slug' => $product->getSlug()]);

        Assert::false(
            $this->showPage->isOpen(['slug' => $product->getSlug()]),
            'Product show page should not be open, but it does.'
        );
    }

    /**
     * @When /^I check (this product)'s details/
     * @When I view product :product
     */
    public function iOpenProductPage(ProductInterface $product)
    {
        $this->showPage->open(['slug' => $product->getSlug()]);
    }

    /**
     * @Given I should see the product name :name
     */
    public function iShouldSeeProductName($name)
    {
        Assert::same(
            $name,
            $this->showPage->getName(),
            'Product should have name %2$s, but it has %s'
        );
    }

    /**
     * @When I open page :url
     */
    public function iOpenPage($url)
    {
        $this->showPage->visit($url);
    }

    /**
     * @Then I should be on :product product detailed page
     * @Then I should still be on product :product page
     */
    public function iShouldBeOnProductDetailedPage(ProductInterface $product)
    {
        Assert::true(
            $this->showPage->isOpen(['slug' => $product->getSlug()]),
            sprintf('Product %s show page should be open, but it does not.', $product->getName())
        );
    }

    /**
     * @Then I should see the product attribute :attributeName with value :AttributeValue
     */
    public function iShouldSeeTheProductAttributeWithValue($attributeName, $AttributeValue)

    {
        Assert::true(
            $this->showPage->hasAttributeWithValue($attributeName, $AttributeValue),

            sprintf('Product should have attribute %s with value %s, but it does not.', $attributeName, $AttributeValue)

        );
    }

    /**
     * @When /^I browse products from (taxon "([^"]+)")$/
     */
    public function iCheckListOfProductsForTaxon(TaxonInterface $taxon)
    {
        $this->taxonShowPage->open(['slug' => $taxon->getSlug()]);
    }

    /**
     * @When I search for products with name :name
     */
    public function iSearchForProductsWithName($name)
    {
        $this->taxonShowPage->search($name);
    }

    /**
     * @When I clear filter
     */
    public function iClearFilter()
    {
        $this->taxonShowPage->clearFilter();
    }

    /**
     * @Then I should see the product :productName
     */
    public function iShouldSeeProduct($productName)
    {
        Assert::true(
            $this->taxonShowPage->isProductOnList($productName),
            sprintf("The product %s should appear on page, but it does not.", $productName)
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
        );
    }

    /**
     * @Then I should not see the product :productName
     */
    public function iShouldNotSeeProduct($productName)
    {
        Assert::false(
            $this->taxonShowPage->isProductOnList($productName),
            sprintf("The product %s should not appear on page, but it does.", $productName)
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
        );
    }

    /**
     * @Then I should see empty list of products
     */
    public function iShouldSeeEmptyListOfProducts()
    {
        Assert::true(
            $this->taxonShowPage->isEmpty(),
            'There should appear information about empty list of products, but it does not.'
        );
    }

    /**
     * @Then I should see that it is out of stock
     */
    public function iShouldSeeItIsOutOfStock()
    {
        Assert::true(
            $this->showPage->isOutOfStock(),
            'Out of stock label should be visible.'
        );
    }

    /**
     * @Then I should be unable to add it to the cart
     */
    public function iShouldBeUnableToAddItToTheCart()
    {
        Assert::false(
            $this->showPage->hasAddToCartButton(),
            'Add to cart button should not be visible.'
        );
    }

    /**
     * @Then the product price should be :price
     * @Then I should see the product price :price
     */
    public function iShouldSeeTheProductPrice($price)
    {
        Assert::same(
            $price,
            $this->showPage->getPrice(),
            'Product should have price %2$s, but it has %s'
        );
    }

    /**
     * @When I set its :optionName to :optionValue
     */
    public function iSetItsOptionTo($optionName, $optionValue)
    {
        $this->showPage->selectOption($optionName, $optionValue);
    }

    /**
     * @When I select :variantName variant
     */
    public function iSelectVariant($variantName)
    {
        $this->showPage->selectVariant($variantName);
    }

    /**
     * @Then I should see the product :productName with price :productPrice
     */
    public function iShouldSeeTheProductWithPrice($productName, $productPrice)
    {
        Assert::true(
            $this->taxonShowPage->isProductWithPriceOnList($productName, $productPrice),
            sprintf("The product %s with price %s should appear on page, but it does not.", $productName, $productPrice)
<?php

$singleQuoted = 'Value';
$doubleQuoted = "\tSingle is $singleQuoted";

print $doubleQuoted;
        );
    }

    /**
     * @Then /^I should be notified that (this product) does not have sufficient stock$/
     */
    public function iShouldBeNotifiedThatThisProductDoesNotHaveSufficientStock(ProductInterface $product)
    {
       $this->showPage->waitForValidationErrors(3);

        Assert::true(
            $this->showPage->hasProductOutOfStockValidationMessage($product),
            sprintf('I should see validation message for %s product', $product->getName())
        );
    }

    /**
     * @Then /^I should not be notified that (this product) does not have sufficient stock$/
     */
    public function iShouldNotBeNotifiedThatThisProductDoesNotHaveSufficientStock(ProductInterface $product)
    {
        Assert::false(
            $this->showPage->hasProductOutOfStockValidationMessage($product),
            sprintf('I should see validation message for %s product', $product->getName())
        );
    }

    /**
     * @Then I should see a main image
     */
    public function iShouldSeeAMainImage()
    {
        Assert::true(
            $this->showPage->isMainImageDisplayed(),
            'The main image should have been displayed.'
        );
    }

    /**
     * @When /^I view (oldest|newest) products from (taxon "([^"]+)")$/
     */
    public function iViewSortedProductsFromTaxon($sortDirection, TaxonInterface $taxon)
    {
        $sorting = ['createdAt' => 'oldest' === $sortDirection ? 'asc' : 'desc'];

        $this->taxonShowPage->open(['slug' => $taxon->getSlug(), 'sorting' => $sorting]);
    }

    /**
     * @Then I should see :numberOfProducts products in the list
     */
    public function iShouldSeeProductsInTheList($numberOfProducts)
    {
        $foundRows = $this->taxonShowPage->countProductsItems();

        Assert::same(
            (int) $numberOfProducts,
            $foundRows,
            '%s rows with products should appear on page, %s rows has been found'
        );
    }

    /**
     * @Then I should see a product with name :name
     */
    public function iShouldSeeProductWithName($name)
    {
        Assert::true(
            $this->taxonShowPage->isProductOnPageWithName($name),
            sprintf('The product with name "%s" has not been found.', $name)
        );
    }

    /**
     * @Then the first product on the list should have name :name
     */
    public function theFirstProductOnTheListShouldHaveName($name)
    {
        $actualName = $this->taxonShowPage->getFirstProductNameFromList();

        Assert::same(
            $actualName,
            $name,
            sprintf('Expected first product\'s name to be "%s", but it is "%s".', $name, $actualName)
        );
    }

    /**
     * @Then I should see :count product reviews
     */
    public function iShouldSeeProductReviews($count)
    {
        Assert::same(
            (int) $count,
            $this->showPage->countReviews(),
            'Product has %2$s reviews, but should have %s.'
        );
    }

    /**
     * @Then I should see reviews titled :firstReview, :secondReview and :thirdReview
     */
    public function iShouldSeeReviewsTitled(...$reviews)
    {
        foreach ($reviews as $review) {
            Assert::true(
                $this->showPage->hasReviewTitled($review),
                sprintf('Product should have review titled "%s" but it does not.', $review)
            );
        }
    }

    /**
     * @Then I should not see review titled :title
     */
    public function iShouldNotSeeReviewTitled($title)
    {
        Assert::false(
            $this->showPage->hasReviewTitled($title),
            sprintf('Product should not have review titled "%s" but it does.', $title)
        );
    }

    /**
     * @When /^I check (this product)'s reviews$/
     */
    public function iCheckThisProductSReviews(ProductInterface $product)
    {
        $this->productReviewsIndexPage->open(['slug' => $product->getSlug()]);
    }

    /**
     * @Then /^I should see (\d+) product reviews in the list$/
     */
    public function iShouldSeeNumberOfProductReviewsInTheList($count)
    {
        Assert::same(
            (int) $count,
            $this->productReviewsIndexPage->countReviews(),
            'Product has %2$s reviews in the list, but should have %s.'
        );
    }

    /**
     * @Then I should not see review titled :title in the list
     */
    public function iShouldNotSeeReviewTitledInTheList($title)
    {
        Assert::false(
            $this->productReviewsIndexPage->hasReviewTitled($title),
            sprintf('Product should not have review titled "%s" but it does.', $title)
        );
    }

    /**
     * @Then /^I should be notified that there are no reviews$/
     */
    public function iShouldBeNotifiedThatThereAreNoReviews()
    {
        Assert::true(
            $this->productReviewsIndexPage->hasNoReviewMessage(),
            'There should be message about no reviews but there is not.'
        );
    }

    /**
     * @Then I should see :rating as its average rating
     */
    public function iShouldSeeAsItsAverageRating($rating)
    {
        $averageRating = $this->showPage->getAverageRating();

        Assert::same(
            (float) $rating,
            $averageRating,
            'Product should have average rating %2$s but has %s.'
        );
    }

    /**
     * @Then /^I should(?:| also) see the product association "([^"]+)" with (products "[^"]+" and "[^"]+")$/
     */
    public function iShouldSeeTheProductAssociationWithProducts($productAssociationName, array $products)
    {
        Assert::true(
            $this->showPage->hasAssociation($productAssociationName),
            sprintf('There should be an association named "%s" but it does not.', $productAssociationName)
        );

        foreach ($products as $product) {
            $this->assertIsProductIsInAssociation($product->getName(), $productAssociationName);
        }
    }

    /**
     * @param string $productName
     * @param string $productAssociationName
     *
     * @throws \InvalidArgumentException
     */
    private function assertIsProductIsInAssociation($productName, $productAssociationName)
    {
        Assert::true(
            $this->showPage->hasProductInAssociation($productName, $productAssociationName),
            sprintf(
                'There should be an associated product "%s" under association "%s" but it does not.',
                $productName,
                $productAssociationName
            )
        );
    }

    /**
     * @Then /^average rating of (product "[^"]+") should be (\d+)$/
     */
    public function thisProductAverageRatingShouldBe(ProductInterface $product, $averageRating)
    {
        $this->showPage->tryToOpen(['slug' => $product->getSlug()]);
        $this->iShouldSeeAsItsAverageRating($averageRating);
    }
}


1			<?php
2
3			/*
4			* This file is part of the Sylius package.
5			*
6			* (c) Paweł Jędrzejewski
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Sylius\Behat\Context\Ui\Shop;
13
14			use Behat\Behat\Context\Context;
15			use Sylius\Behat\Page\Shop\Product\ShowPageInterface;
16			use Sylius\Behat\Page\Shop\ProductReview\IndexPageInterface;
17			use Sylius\Behat\Page\Shop\Taxon\ShowPageInterface as TaxonShowPageInterface;
18			use Sylius\Component\Core\Model\ProductInterface;
19			use Sylius\Component\Core\Model\TaxonInterface;
20			use Webmozart\Assert\Assert;
21
22			/**
23			* @author Kamil Kokot <[email protected]>
24			* @author Magdalena Banasiak <[email protected]>
25			* @author Anna Walasek <[email protected]>
26			*/
27			final class ProductContext implements Context
28			{
29			/**
30			* @var ShowPageInterface
31			*/
32			private $showPage;
33
34			/**
35			* @var TaxonShowPageInterface
36			*/
37			private $taxonShowPage;
38
39			/**
40			* @var IndexPageInterface
41			*/
42			private $productReviewsIndexPage;
43
44			/**
45			* @param ShowPageInterface $showPage
46			* @param TaxonShowPageInterface $taxonShowPage
47			* @param IndexPageInterface $productReviewsIndexPage
48			*/
49			public function __construct(
50			ShowPageInterface $showPage,
51			TaxonShowPageInterface $taxonShowPage,
52			IndexPageInterface $productReviewsIndexPage
53			) {
54			$this->showPage = $showPage;
55			$this->taxonShowPage = $taxonShowPage;
56			$this->productReviewsIndexPage = $productReviewsIndexPage;
57			}
58
59			/**
60			* @Then I should be able to access product :product
61			*/
62			public function iShouldBeAbleToAccessProduct(ProductInterface $product)
63			{
64			$this->showPage->tryToOpen(['slug' => $product->getSlug()]);
65
66			Assert::true(
67			$this->showPage->isOpen(['slug' => $product->getSlug()]),
68			'Product show page should be open, but it does not.'
69			);
70			}
71
72			/**
73			* @Then I should not be able to access product :product
74			*/
75			public function iShouldNotBeAbleToAccessProduct(ProductInterface $product)
76			{
77			$this->showPage->tryToOpen(['slug' => $product->getSlug()]);
78
79			Assert::false(
80			$this->showPage->isOpen(['slug' => $product->getSlug()]),
81			'Product show page should not be open, but it does.'
82			);
83			}
84
85			/**
86			* @When /^I check (this product)'s details/
87			* @When I view product :product
88			*/
89			public function iOpenProductPage(ProductInterface $product)
90			{
91			$this->showPage->open(['slug' => $product->getSlug()]);
92			}
93
94			/**
95			* @Given I should see the product name :name
96			*/
97			public function iShouldSeeProductName($name)
98			{
99			Assert::same(
100			$name,
101			$this->showPage->getName(),
102			'Product should have name %2$s, but it has %s'
103			);
104			}
105
106			/**
107			* @When I open page :url
108			*/
109			public function iOpenPage($url)
110			{
111			$this->showPage->visit($url);
112			}
113
114			/**
115			* @Then I should be on :product product detailed page
116			* @Then I should still be on product :product page
117			*/
118			public function iShouldBeOnProductDetailedPage(ProductInterface $product)
119			{
120			Assert::true(
121			$this->showPage->isOpen(['slug' => $product->getSlug()]),
122			sprintf('Product %s show page should be open, but it does not.', $product->getName())
123			);
124			}
125
126			/**
127			* @Then I should see the product attribute :attributeName with value :AttributeValue
128			*/
129			public function iShouldSeeTheProductAttributeWithValue($attributeName, $AttributeValue)
			0 ignored issues – show Coding Style introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report `$AttributeValue` does not seem to conform to the naming convention (`^[a-z][a-zA-Z0-9]*$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
130			{
131			Assert::true(
132			$this->showPage->hasAttributeWithValue($attributeName, $AttributeValue),
			0 ignored issues – show Coding Style introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report `$AttributeValue` does not seem to conform to the naming convention (`^[a-z][a-zA-Z0-9]*$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
133			sprintf('Product should have attribute %s with value %s, but it does not.', $attributeName, $AttributeValue)
			0 ignored issues – show Coding Style introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report `$AttributeValue` does not seem to conform to the naming convention (`^[a-z][a-zA-Z0-9]*$`). This check examines a number of code elements and verifies that they conform to the given naming conventions. You can set conventions for local variables, abstract classes, utility classes, constant, properties, methods, parameters, interfaces, classes, exceptions and special methods. Loading history...
134			);
135			}
136
137			/**
138			* @When /^I browse products from (taxon "([^"]+)")$/
139			*/
140			public function iCheckListOfProductsForTaxon(TaxonInterface $taxon)
141			{
142			$this->taxonShowPage->open(['slug' => $taxon->getSlug()]);
143			}
144
145			/**
146			* @When I search for products with name :name
147			*/
148			public function iSearchForProductsWithName($name)
149			{
150			$this->taxonShowPage->search($name);
151			}
152
153			/**
154			* @When I clear filter
155			*/
156			public function iClearFilter()
157			{
158			$this->taxonShowPage->clearFilter();
159			}
160
161			/**
162			* @Then I should see the product :productName
163			*/
164			public function iShouldSeeProduct($productName)
165			{
166			Assert::true(
167			$this->taxonShowPage->isProductOnList($productName),
168			sprintf("The product %s should appear on page, but it does not.", $productName)
			0 ignored issues – show Coding Style Comprehensibility introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report The string literal `The product %s should ap... page, but it does not.` does not require double quotes, as per coding-style, please use single quotes. PHP provides two ways to mark string literals. Either with single quotes `'literal'` or with double quotes `"literal"`. The difference between these is that string literals in double quotes may contain variables with are evaluated at run-time as well as escape sequences. String literals in single quotes on the other hand are evaluated very literally and the only two characters that needs escaping in the literal are the single quote itself (`\'`) and the backslash (`\\`). Every other character is displayed as is. Double quoted string literals may contain other variables or more complex escape sequences. <?php $singleQuoted = 'Value'; $doubleQuoted = "\tSingle is $singleQuoted"; print $doubleQuoted; will print an indented: `Single is Value` If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
169			);
170			}
171
172			/**
173			* @Then I should not see the product :productName
174			*/
175			public function iShouldNotSeeProduct($productName)
176			{
177			Assert::false(
178			$this->taxonShowPage->isProductOnList($productName),
179			sprintf("The product %s should not appear on page, but it does.", $productName)
			0 ignored issues – show Coding Style Comprehensibility introduced 2016-06-24 14:31 UTC by Report Bug Copy Issue Report The string literal `The product %s should no...r on page, but it does.` does not require double quotes, as per coding-style, please use single quotes. PHP provides two ways to mark string literals. Either with single quotes `'literal'` or with double quotes `"literal"`. The difference between these is that string literals in double quotes may contain variables with are evaluated at run-time as well as escape sequences. String literals in single quotes on the other hand are evaluated very literally and the only two characters that needs escaping in the literal are the single quote itself (`\'`) and the backslash (`\\`). Every other character is displayed as is. Double quoted string literals may contain other variables or more complex escape sequences. <?php $singleQuoted = 'Value'; $doubleQuoted = "\tSingle is $singleQuoted"; print $doubleQuoted; will print an indented: `Single is Value` If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
180			);
181			}
182
183			/**
184			* @Then I should see empty list of products
185			*/
186			public function iShouldSeeEmptyListOfProducts()
187			{
188			Assert::true(
189			$this->taxonShowPage->isEmpty(),
190			'There should appear information about empty list of products, but it does not.'
191			);
192			}
193
194			/**
195			* @Then I should see that it is out of stock
196			*/
197			public function iShouldSeeItIsOutOfStock()
198			{
199			Assert::true(
200			$this->showPage->isOutOfStock(),
201			'Out of stock label should be visible.'
202			);
203			}
204
205			/**
206			* @Then I should be unable to add it to the cart
207			*/
208			public function iShouldBeUnableToAddItToTheCart()
209			{
210			Assert::false(
211			$this->showPage->hasAddToCartButton(),
212			'Add to cart button should not be visible.'
213			);
214			}
215
216			/**
217			* @Then the product price should be :price
218			* @Then I should see the product price :price
219			*/
220			public function iShouldSeeTheProductPrice($price)
221			{
222			Assert::same(
223			$price,
224			$this->showPage->getPrice(),
225			'Product should have price %2$s, but it has %s'
226			);
227			}
228
229			/**
230			* @When I set its :optionName to :optionValue
231			*/
232			public function iSetItsOptionTo($optionName, $optionValue)
233			{
234			$this->showPage->selectOption($optionName, $optionValue);
235			}
236
237			/**
238			* @When I select :variantName variant
239			*/
240			public function iSelectVariant($variantName)
241			{
242			$this->showPage->selectVariant($variantName);
243			}
244
245			/**
246			* @Then I should see the product :productName with price :productPrice
247			*/
248			public function iShouldSeeTheProductWithPrice($productName, $productPrice)
249			{
250			Assert::true(
251			$this->taxonShowPage->isProductWithPriceOnList($productName, $productPrice),
252			sprintf("The product %s with price %s should appear on page, but it does not.", $productName, $productPrice)
			0 ignored issues – show Coding Style Comprehensibility introduced 2016-10-20 17:46 UTC by Report Bug Copy Issue Report The string literal `The product %s with pric... page, but it does not.` does not require double quotes, as per coding-style, please use single quotes. PHP provides two ways to mark string literals. Either with single quotes `'literal'` or with double quotes `"literal"`. The difference between these is that string literals in double quotes may contain variables with are evaluated at run-time as well as escape sequences. String literals in single quotes on the other hand are evaluated very literally and the only two characters that needs escaping in the literal are the single quote itself (`\'`) and the backslash (`\\`). Every other character is displayed as is. Double quoted string literals may contain other variables or more complex escape sequences. <?php $singleQuoted = 'Value'; $doubleQuoted = "\tSingle is $singleQuoted"; print $doubleQuoted; will print an indented: `Single is Value` If your string literal does not contain variables or escape sequences, it should be defined using single quotes to make that fact clear. For more information on PHP string literals and available escape sequences see the PHP core documentation. Loading history...
253			);
254			}
255
256			/**
257			* @Then /^I should be notified that (this product) does not have sufficient stock$/
258			*/
259			public function iShouldBeNotifiedThatThisProductDoesNotHaveSufficientStock(ProductInterface $product)
260			{
261			$this->showPage->waitForValidationErrors(3);
262
263			Assert::true(
264			$this->showPage->hasProductOutOfStockValidationMessage($product),
265			sprintf('I should see validation message for %s product', $product->getName())
266			);
267			}
268
269			/**
270			* @Then /^I should not be notified that (this product) does not have sufficient stock$/
271			*/
272			public function iShouldNotBeNotifiedThatThisProductDoesNotHaveSufficientStock(ProductInterface $product)
273			{
274			Assert::false(
275			$this->showPage->hasProductOutOfStockValidationMessage($product),
276			sprintf('I should see validation message for %s product', $product->getName())
277			);
278			}
279
280			/**
281			* @Then I should see a main image
282			*/
283			public function iShouldSeeAMainImage()
284			{
285			Assert::true(
286			$this->showPage->isMainImageDisplayed(),
287			'The main image should have been displayed.'
288			);
289			}
290
291			/**
292			* @When /^I view (oldest\|newest) products from (taxon "([^"]+)")$/
293			*/
294			public function iViewSortedProductsFromTaxon($sortDirection, TaxonInterface $taxon)
295			{
296			$sorting = ['createdAt' => 'oldest' === $sortDirection ? 'asc' : 'desc'];
297
298			$this->taxonShowPage->open(['slug' => $taxon->getSlug(), 'sorting' => $sorting]);
299			}
300
301			/**
302			* @Then I should see :numberOfProducts products in the list
303			*/
304			public function iShouldSeeProductsInTheList($numberOfProducts)
305			{
306			$foundRows = $this->taxonShowPage->countProductsItems();
307
308			Assert::same(
309			(int) $numberOfProducts,
310			$foundRows,
311			'%s rows with products should appear on page, %s rows has been found'
312			);
313			}
314
315			/**
316			* @Then I should see a product with name :name
317			*/
318			public function iShouldSeeProductWithName($name)
319			{
320			Assert::true(
321			$this->taxonShowPage->isProductOnPageWithName($name),
322			sprintf('The product with name "%s" has not been found.', $name)
323			);
324			}
325
326			/**
327			* @Then the first product on the list should have name :name
328			*/
329			public function theFirstProductOnTheListShouldHaveName($name)
330			{
331			$actualName = $this->taxonShowPage->getFirstProductNameFromList();
332
333			Assert::same(
334			$actualName,
335			$name,
336			sprintf('Expected first product\'s name to be "%s", but it is "%s".', $name, $actualName)
337			);
338			}
339
340			/**
341			* @Then I should see :count product reviews
342			*/
343			public function iShouldSeeProductReviews($count)
344			{
345			Assert::same(
346			(int) $count,
347			$this->showPage->countReviews(),
348			'Product has %2$s reviews, but should have %s.'
349			);
350			}
351
352			/**
353			* @Then I should see reviews titled :firstReview, :secondReview and :thirdReview
354			*/
355			public function iShouldSeeReviewsTitled(...$reviews)
356			{
357			foreach ($reviews as $review) {
358			Assert::true(
359			$this->showPage->hasReviewTitled($review),
360			sprintf('Product should have review titled "%s" but it does not.', $review)
361			);
362			}
363			}
364
365			/**
366			* @Then I should not see review titled :title
367			*/
368			public function iShouldNotSeeReviewTitled($title)
369			{
370			Assert::false(
371			$this->showPage->hasReviewTitled($title),
372			sprintf('Product should not have review titled "%s" but it does.', $title)
373			);
374			}
375
376			/**
377			* @When /^I check (this product)'s reviews$/
378			*/
379			public function iCheckThisProductSReviews(ProductInterface $product)
380			{
381			$this->productReviewsIndexPage->open(['slug' => $product->getSlug()]);
382			}
383
384			/**
385			* @Then /^I should see (\d+) product reviews in the list$/
386			*/
387			public function iShouldSeeNumberOfProductReviewsInTheList($count)
388			{
389			Assert::same(
390			(int) $count,
391			$this->productReviewsIndexPage->countReviews(),
392			'Product has %2$s reviews in the list, but should have %s.'
393			);
394			}
395
396			/**
397			* @Then I should not see review titled :title in the list
398			*/
399			public function iShouldNotSeeReviewTitledInTheList($title)
400			{
401			Assert::false(
402			$this->productReviewsIndexPage->hasReviewTitled($title),
403			sprintf('Product should not have review titled "%s" but it does.', $title)
404			);
405			}
406
407			/**
408			* @Then /^I should be notified that there are no reviews$/
409			*/
410			public function iShouldBeNotifiedThatThereAreNoReviews()
411			{
412			Assert::true(
413			$this->productReviewsIndexPage->hasNoReviewMessage(),
414			'There should be message about no reviews but there is not.'
415			);
416			}
417
418			/**
419			* @Then I should see :rating as its average rating
420			*/
421			public function iShouldSeeAsItsAverageRating($rating)
422			{
423			$averageRating = $this->showPage->getAverageRating();
424
425			Assert::same(
426			(float) $rating,
427			$averageRating,
428			'Product should have average rating %2$s but has %s.'
429			);
430			}
431
432			/**
433			* @Then /^I should(?:\| also) see the product association "([^"]+)" with (products "[^"]+" and "[^"]+")$/
434			*/
435			public function iShouldSeeTheProductAssociationWithProducts($productAssociationName, array $products)
436			{
437			Assert::true(
438			$this->showPage->hasAssociation($productAssociationName),
439			sprintf('There should be an association named "%s" but it does not.', $productAssociationName)
440			);
441
442			foreach ($products as $product) {
443			$this->assertIsProductIsInAssociation($product->getName(), $productAssociationName);
444			}
445			}
446
447			/**
448			* @param string $productName
449			* @param string $productAssociationName
450			*
451			* @throws \InvalidArgumentException
452			*/
453			private function assertIsProductIsInAssociation($productName, $productAssociationName)
454			{
455			Assert::true(
456			$this->showPage->hasProductInAssociation($productName, $productAssociationName),
457			sprintf(
458			'There should be an associated product "%s" under association "%s" but it does not.',
459			$productName,
460			$productAssociationName
461			)
462			);
463			}
464
465			/**
466			* @Then /^average rating of (product "[^"]+") should be (\d+)$/
467			*/
468			public function thisProductAverageRatingShouldBe(ProductInterface $product, $averageRating)
469			{
470			$this->showPage->tryToOpen(['slug' => $product->getSlug()]);
471			$this->iShouldSeeAsItsAverageRating($averageRating);
472			}
473			}
474

pamil / Sylius

Push — remove-content-bundle ( 201341...8d07b3 )

ProductContext::__construct() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like