/**
* {@inheritdoc}
*/
public function createForPromotion(PromotionInterface $promotion)
{
Assert::true($promotion->isCouponBased(), sprintf('Promotion with name %s is not coupon based.', $promotion->getName()));
$coupon = $this->factory->createNew();
$coupon->setPromotion($promotion);
return $coupon;
}
/**
* {@inheritdoc}
*/
public function createForPromotion($promotionId)
{
/** @var PromotionInterface $promotion */
Assert::notNull($promotion = $this->promotionRepository->find($promotionId), sprintf('Promotion with id %s does not exist.', $promotionId));
Assert::true($promotion->isCouponBased(), sprintf('Promotion with name %s is not coupon based.', $promotion->getName()));
$coupon = $this->factory->createNew();
$coupon->setPromotion($promotion);
return $coupon;
}
/**
* {@inheritdoc}
*/
public function getSupportedMethods(ShippingSubjectInterface $subject)
{
/** @var ShipmentInterface $subject */
Assert::true($this->supports($subject));
/** @var OrderInterface $order */
$order = $subject->getOrder();
$zones = $this->zoneMatcher->matchAll($order->getShippingAddress());
if (empty($zones)) {
return [];
}
return $this->shippingMethodRepository->findEnabledForZonesAndChannel($zones, $order->getChannel());
}
/**
* {@inheritdoc}
*/
public function generate(ProductInterface $product)
{
Assert::true($product->hasOptions(), 'Cannot generate variants for an object without options.');
$optionSet = [];
$optionMap = [];
foreach ($product->getOptions() as $key => $option) {
foreach ($option->getValues() as $value) {
$optionSet[$key][] = $value->getId();
$optionMap[$value->getId()] = $value;
}
}
$permutations = $this->setBuilder->build($optionSet);
foreach ($permutations as $permutation) {
$variant = $this->createVariant($product, $optionMap, $permutation);
$product->addVariant($variant);
}
}
/**
* {@inheritdoc}
*/
public function getSupportedMethods(ShippingSubjectInterface $subject)
{
/** @var ShipmentInterface $subject */
Assert::true($this->supports($subject));
/** @var OrderInterface $order */
$order = $subject->getOrder();
$zones = $this->zoneMatcher->matchAll($order->getShippingAddress());
if (empty($zones)) {
return [];
}
$methods = [];
$shippingMethods = $this->shippingMethodRepository->findEnabledForZonesAndChannel($zones, $order->getChannel());
foreach ($shippingMethods as $shippingMethod) {
if ($this->eligibilityChecker->isEligible($subject, $shippingMethod)) {
$methods[] = $shippingMethod;
}
}
return $methods;
}
/**
* @param PromotionInterface $promotion
* @param string $field
*/
private function assertIfFieldIsTrue(PromotionInterface $promotion, $field)
{
$this->iWantToModifyAPromotion($promotion);
Assert::true($this->updatePage->hasResourceValues([$field => 1]), sprintf('Promotion %s is not %s, but it should be.', $promotion->getName(), str_replace('_', ' ', $field)));
}
/**
* @param string $type
* @param string $element
* @param string $expectedMessage
*
* @throws \InvalidArgumentException
*/
private function assertElementValidationMessage($type, $element, $expectedMessage)
{
$element = sprintf('%s_%s', $type, implode('_', explode(' ', $element)));
Assert::true($this->addressPage->checkValidationMessageFor($element, $expectedMessage), sprintf('The %s should be required.', $element));
}
/**
* @Then /^the province should still be named "([^"]*)" in (this country)$/
*/
public function thisProvinceShouldStillBeNamed($provinceName, CountryInterface $country)
{
$this->updatePage->open(['id' => $country->getId()]);
Assert::true($this->updatePage->isThereProvince($provinceName), sprintf('%s is not a province of this country.', $provinceName));
}
/**
* @param string $element
* @param string $expectedMessage
*/
private function assertFieldValidationMessage($element, $expectedMessage)
{
$currentPage = $this->currentPageResolver->getCurrentPageWithForm($this->createPage, $this->updatePage);
Assert::true($currentPage->checkValidationMessageFor($element, $expectedMessage), sprintf('Tax rate %s should be required.', $element));
}
/**
* @Then /^I should be notified that province code must be unique$/
*/
public function iShouldBeNotifiedThatProvinceCodeMustBeUnique()
{
Assert::true($this->updatePage->checkValidationMessageFor('code', 'Province code must be unique.'), 'Unique code violation message should appear on page, but it does not.');
}
/**
* @Then /^(this customer group) should still be named "([^"]+)"$/
*/
public function thisChannelNameShouldBe(CustomerGroupInterface $customerGroup, $customerGroupName)
{
$this->iWantToBrowseCustomerGroupsOfTheStore();
Assert::true($this->indexPage->isSingleResourceOnPage(['name' => $customerGroup->getName()]), sprintf('Customer group name %s has not been assigned properly.', $customerGroupName));
}
/**
* @Then I should be notified that :element is required
*/
public function iShouldBeNotifiedThatIsRequired($element)
{
$currentPage = $this->currentPageResolver->getCurrentPageWithForm($this->createPage, $this->updatePage);
Assert::true($currentPage->checkValidationMessageFor($element, sprintf('Please enter tax category %s.', $element)), sprintf('Tax category %s should be required.', $element));
}
/**
* @Then /^I should be notified that generating (\d+) coupons with code length equal to (\d+) is not possible$/
*/
public function iShouldBeNotifiedThatGeneratingCouponsWithCodeLengthIsNotPossible($amount, $codeLength)
{
$message = sprintf('Invalid coupons code length or coupons amount. It is not possible to generate %d unique coupons with code length equals %d. Possible generate amount is 8.', $amount, $codeLength);
Assert::true($this->generatePage->checkGenerationValidation($message), 'Generate violation message should appear on page, but it does not.');
}
/**
* @Then /^I should be notified that (this product) cannot be updated$/
*/
public function iShouldBeNotifiedThatThisProductDoesNotHaveSufficientStock(ProductInterface $product)
{
Assert::true($this->summaryPage->hasProductOutOfStockValidationMessage($product), sprintf('I should see validation message for %s product', $product->getName()));
}
/**
* @Then /^(this product option) should have the "([^"]*)" option value$/
*/
public function thisProductOptionShouldHaveTheOptionValue(ProductOptionInterface $productOption, $optionValue)
{
$this->iWantToModifyAProductOption($productOption);
Assert::true($this->updatePage->isThereOptionValue($optionValue), sprintf('%s is not a value of this product option.', $optionValue));
}
/**
* @Then /^there should still be only one taxon with code "([^"]+)"$/
*/
public function thereShouldStillBeOnlyOneTaxonWithCode($code)
{
Assert::true($this->updatePage->hasResourceValues(['code' => $code]), sprintf('Taxon with code %s cannot be found.', $code));
}
/**
* @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));
}
/**
* @param string $message
* @param string $recipient
*/
private function assertEmailContainsMessageTo($message, $recipient)
{
Assert::true($this->emailChecker->hasMessageTo($message, $recipient), sprintf('Message "%s" was not sent to "%s".', $message, $recipient));
}
/**
* @Then /^(this locale) should be disabled$/
*/
public function thisLocaleShouldBeDisabled(LocaleInterface $locale)
{
Assert::true($this->indexPage->isLocaleDisabled($locale), sprintf('Locale %s should be disabled but it is not', $locale->getCode()));
}
/**
* @param string $element
* @param string $value
*/
private function assertElementValue($element, $value)
{
Assert::true($this->updatePage->hasResourceValues([$element => $value]), sprintf('Product review should have %s with %s value.', $element, $value));
}
/**
* {@inheritdoc}
*/
public function getSupportedMethods(BasePaymentInterface $payment)
{
Assert::true($this->supports($payment), 'This payment method is not support by resolver');
return $this->paymentMethodRepository->findEnabledForChannel($payment->getOrder()->getChannel());
}
/**
* @param ZoneInterface $zone
* @param ZoneMemberInterface $zoneMember
*
* @throws \InvalidArgumentException
*/
private function assertZoneAndItsMember(ZoneInterface $zone, ZoneMemberInterface $zoneMember)
{
Assert::true($this->updatePage->hasResourceValues(['code' => $zone->getCode(), 'name' => $zone->getName()]), sprintf('Zone %s is not valid', $zone->getName()));
Assert::true($this->updatePage->hasMember($zoneMember), sprintf('Zone %s has not %s zone member', $zone->getName(), $zoneMember->getCode()));
}
/**
* @Then I should be redirected back to PayPal Express Checkout page
*/
public function iShouldBeRedirectedToPaypalExpressCheckoutPage()
{
Assert::true($this->paypalExpressCheckoutPage->isOpen());
}
/**
* @Then I should not be able to log in as :username authenticated by :password password
*/
public function iShouldNotBeAbleToLogInAsAuthenticatedByPassword($username, $password)
{
$this->logInAgain($username, $password);
Assert::true($this->loginPage->hasValidationErrorWith('Error Bad credentials.'), 'I should see validation error.');
Assert::false($this->dashboardPage->isOpen(), 'I should not be able to log in.');
}
/**
* @param PageInterface $page
* @param string $element
* @param string $expectedMessage
*/
private function assertFieldValidationMessage(PageInterface $page, $element, $expectedMessage)
{
Assert::true($page->checkValidationMessageFor($element, $expectedMessage), sprintf('There should be a message: "%s".', $expectedMessage));
}
/**
* @Then there should still be only one tax category with :element :code
*/
public function thereShouldStillBeOnlyOneTaxCategoryWith($element, $code)
{
$this->indexPage->open();
Assert::true($this->indexPage->isSingleResourceOnPage([$element => $code]), sprintf('Tax category with %s %s cannot be found.', $element, $code));
}
/**
* @Then this administrator with name :username should appear in the store
* @Then there should still be only one administrator with name :username
*/
public function thisAdministratorWithNameShouldAppearInTheStore($username)
{
$this->indexPage->open();
Assert::true($this->indexPage->isSingleResourceOnPage(['username' => $username]), sprintf('Administrator with %s username does not exist', $username));
}
/**
* @Then I should not have a default address
*/
public function iShouldHaveNoDefaultAddress()
{
Assert::true($this->addressBookIndexPage->hasNoDefaultAddress(), 'There should be no default address.');
}
/**
* @Then I should see :provinceName ad province in the billing address
*/
public function iShouldSeeAdProvinceInTheBillingAddress($provinceName)
{
Assert::true($this->showPage->hasBillingProvinceName($provinceName), sprintf('Cannot find shipping address with province %s', $provinceName));
}
/**
* @Then I should see that the :productVariantName variant has :quantity quantity on hand
*/
public function iShouldSeeThatTheProductVariantHasQuantityOnHand($productVariantName, $quantity)
{
Assert::true($this->indexPage->isSingleResourceOnPage(['name' => $productVariantName, 'inventory' => sprintf('%s Available on hand', $quantity)]), sprintf('This "%s" variant should have %s on hand quantity, but it does not.', $productVariantName, $quantity));
}
