TheCoreDev/sterivein
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/thelia/thelia into coupon

Browse Source 
# By Manuel Raynaud (18) and others
# Via franck (9) and others
* 'master' of https://github.com/thelia/thelia: (39 commits)
  Working :
  Working :
  Working :
  Working :
  Fixed minor visual glitches
  Working : Resize countries flag + Add bootstrap-switch
  fix test suite
  clear asset cache in cache:cler command
  Added a 'development mode' to assetic smarty plugin
  rewriting router
  use good Request object
  Added Tools\URL test case, and a test case superclass for initializing Tools\URL
  remove unused UrlWritin controller
  create router for rewriting matching
  customer substitutions
  fix typo in front id
  Working : For attributes on labels
  Working : For attributes on labels
  add label_attr attribute to form smarty plugin
  start refactorin rewriting routing
  ...

Conflicts:
	core/lib/Thelia/Config/Resources/routing/front.xml
	templates/admin/default/assets/less/thelia/bootstrap-editable.less
	templates/admin/default/categories.html
This commit is contained in:
gmorel
2013-09-06 19:38:08 +02:00
parent 86d6a0fa05
commit 49be95a2e7
18 changed files with 646 additions and 420 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
core/lib/Thelia/Constraint/ConstraintManager.php
View File

@@ -24,6 +24,10 @@
namespace Thelia\Constraint;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\Serializer\Encoder\JsonEncoder;
use Symfony\Component\Serializer\Encoder\XmlEncoder;
use Symfony\Component\Serializer\Normalizer\GetSetMethodNormalizer;
use Symfony\Component\Serializer\Serializer;
use Thelia\Constraint\Rule\CouponRuleInterface;
use Thelia\Constraint\Rule\SerializableRule;
use Thelia\Coupon\CouponAdapterInterface;
@@ -102,7 +106,8 @@ class ConstraintManager
$serializableRules[] = $rule->getSerializableRule();
}
}
return (string) base64_encode(serialize($serializableRules));
return base64_encode(json_encode($serializableRules));
}
/**
@@ -114,7 +119,8 @@ class ConstraintManager
*/
public function unserializeCouponRuleCollection($serializedRules)
{
$unserializedRules = unserialize(base64_decode($serializedRules));
$unserializedRules = json_decode(base64_decode($serializedRules));
$collection = new CouponRuleCollection();
if (!empty($serializedRules) && !empty($unserializedRules)) {
@@ -124,10 +130,10 @@ class ConstraintManager
/** @var CouponRuleInterface $couponRule */
$couponRule = $this->container->get($rule->ruleServiceId);
$couponRule->populateFromForm(
$rule->operators,
$rule->values
(array) $rule->operators,
(array) $rule->values
);
$collection->add($couponRule);
$collection->add(clone $couponRule);
}
}
}

25
core/lib/Thelia/Constraint/Rule/AvailableForCustomer.php
View File

@@ -53,31 +53,6 @@ class AvailableForCustomer extends CouponRuleAbstract
/** @var RuleValidator Customer Validator */
protected $customerValidator = null;
/**
* Constructor
*
* @param CouponAdapterInterface $adapter allowing to gather
* all necessary Thelia variables
* @param array $validators Array of RuleValidator
* validating $paramsToValidate against
*
* @throws InvalidRuleException
*/
public function __construct(CouponAdapterInterface $adapter, array $validators)
{
parent::__construct($adapter, $validators);
if (isset($validators[self::PARAM1])
&& $validators[self::PARAM1] instanceof RuleValidator
) {
$this->customerValidator = $validators[self::PARAM1];
} else {
throw new InvalidRuleException(get_class());
}
$this->adapter = $adapter;
}
/**
* Check if backoffice inputs are relevant or not
*

76
core/lib/Thelia/Constraint/Rule/AvailableForTotalAmount.php
View File

@@ -52,6 +52,9 @@ class AvailableForTotalAmount extends CouponRuleAbstract
/** Rule 1st parameter : currency */
CONST PARAM1_CURRENCY = 'currency';
/** @var string Service Id from Resources/config.xml */
protected $serviceId = 'thelia.constraint.rule.available_for_total_amount';
/** @var array Available Operators (Operators::CONST) */
protected $availableOperators = array(
Operators::INFERIOR,
@@ -59,7 +62,7 @@ class AvailableForTotalAmount extends CouponRuleAbstract
Operators::SUPERIOR,
);
/** @var PriceParam Price Validator */
/** @var RuleValidator Price Validator */
protected $priceValidator = null;
/**
@@ -90,7 +93,7 @@ class AvailableForTotalAmount extends CouponRuleAbstract
$this->checkBackOfficeInputsOperators();
return $this->isPriceValid($price->getPrice());
return $this->isPriceValid($price->getPrice(), $price->getCurrency());
}
/**
@@ -101,33 +104,51 @@ class AvailableForTotalAmount extends CouponRuleAbstract
*/
public function checkCheckoutInput()
{
if (!isset($this->paramsToValidate)
|| empty($this->paramsToValidate)
||!isset($this->paramsToValidate[self::PARAM1_PRICE])
) {
throw new InvalidRuleValueException(get_class(), self::PARAM1_PRICE);
$currency = $this->adapter->getCheckoutCurrency();
if (empty($currency)) {
throw new InvalidRuleValueException(
get_class(), self::PARAM1_CURRENCY
);
}
$price = $this->paramsToValidate[self::PARAM1_PRICE];
$price = $this->adapter->getCartTotalPrice();
if (empty($price)) {
throw new InvalidRuleValueException(
get_class(), self::PARAM1_PRICE
);
}
return $this->isPriceValid($price);
$this->paramsToValidate = array(
self::PARAM1_PRICE => $this->adapter->getCartTotalPrice(),
self::PARAM1_CURRENCY => $this->adapter->getCheckoutCurrency()
);
return $this->isPriceValid($price, $currency);
}
/**
* Check if a price is valid
*
* @param float $price Price to check
* @param float $price Price to check
* @param string $currency Price currency
*
* @throws InvalidRuleValueException if Value is not allowed
* @return bool
*/
protected function isPriceValid($price)
protected function isPriceValid($price, $currency)
{
$priceValidator = $this->priceValidator;
try {
$priceValidator->getParam()->compareTo($price);
} catch(\InvalidArgumentException $e) {
throw new InvalidRuleValueException(get_class(), self::PARAM1_PRICE);
/** @var PriceParam $param */
$param = $priceValidator->getParam();
if ($currency == $param->getCurrency()) {
try {
$priceValidator->getParam()->compareTo($price);
} catch(\InvalidArgumentException $e) {
throw new InvalidRuleValueException(get_class(), self::PARAM1_PRICE);
}
} else {
throw new InvalidRuleValueException(get_class(), self::PARAM1_CURRENCY);
}
return true;
@@ -141,7 +162,8 @@ class AvailableForTotalAmount extends CouponRuleAbstract
protected function setParametersToValidate()
{
$this->paramsToValidate = array(
self::PARAM1_PRICE => $this->adapter->getCartTotalPrice()
self::PARAM1_PRICE => $this->adapter->getCartTotalPrice(),
self::PARAM1_CURRENCY => $this->adapter->getCheckoutCurrency()
);
return $this;
@@ -191,7 +213,7 @@ class AvailableForTotalAmount extends CouponRuleAbstract
* @param array $operators Rule Operator set by the Admin
* @param array $values Rule Values set by the Admin
*
* @throws InvalidArgumentException
* @throws \InvalidArgumentException
* @return $this
*/
public function populateFromForm(array $operators, array $values)
@@ -199,17 +221,22 @@ class AvailableForTotalAmount extends CouponRuleAbstract
if ($values[self::PARAM1_PRICE] === null
|| $values[self::PARAM1_CURRENCY] === null
) {
throw new InvalidArgumentException(
throw new \InvalidArgumentException(
'The Rule ' . get_class() . 'needs at least a quantity set (' . self::PARAM1_PRICE . ', ' . self::PARAM1_CURRENCY . ')'
);
}
$this->priceValidator = new PriceParam(
$this->adapter,
$values[self::PARAM1_PRICE],
$values[self::PARAM1_CURRENCY]
$this->priceValidator = new RuleValidator(
$operators[self::PARAM1_PRICE],
new PriceParam(
$this->translator,
$values[self::PARAM1_PRICE],
$values[self::PARAM1_CURRENCY]
)
);
$this->validators = array(self::PARAM1_PRICE => $this->priceValidator);
return $this;
}
@@ -221,13 +248,14 @@ class AvailableForTotalAmount extends CouponRuleAbstract
public function getSerializableRule()
{
$serializableRule = new SerializableRule();
$serializableRule->ruleServiceId = $this->serviceId;
$serializableRule->operators = array(
self::PARAM1_PRICE => $this->priceValidator->getOperator()
);
$serializableRule->values = array(
self::PARAM1_PRICE => $this->priceValidator->getPrice(),
self::PARAM1_CURRENCY => $this->priceValidator->getCurrency()
self::PARAM1_PRICE => $this->priceValidator->getParam()->getPrice(),
self::PARAM1_CURRENCY => $this->priceValidator->getParam()->getCurrency()
);
return $serializableRule;

15
core/lib/Thelia/Constraint/Rule/AvailableForXArticles.php
View File

@@ -46,6 +46,9 @@ class AvailableForXArticles extends CouponRuleAbstract
/** Rule 1st parameter : quantity */
CONST PARAM1_QUANTITY = 'quantity';
/** @var string Service Id from Resources/config.xml */
protected $serviceId = 'thelia.constraint.rule.available_for_x_articles';
/** @var array Available Operators (Operators::CONST) */
protected $availableOperators = array(
Operators::INFERIOR,
@@ -198,11 +201,16 @@ class AvailableForXArticles extends CouponRuleAbstract
);
}
$this->quantityValidator = new QuantityParam(
$this->adapter,
$values[self::PARAM1_QUANTITY]
$this->quantityValidator = new RuleValidator(
$operators[self::PARAM1_QUANTITY],
new QuantityParam(
$this->adapter,
$values[self::PARAM1_QUANTITY]
)
);
$this->validators = array(self::PARAM1_QUANTITY => $this->quantityValidator);
return $this;
}
@@ -214,6 +222,7 @@ class AvailableForXArticles extends CouponRuleAbstract
public function getSerializableRule()
{
$serializableRule = new SerializableRule();
$serializableRule->ruleServiceId = $this->serviceId;
$serializableRule->operators = array(
self::PARAM1_QUANTITY => $this->quantityValidator->getOperator()
);

24
core/lib/Thelia/Constraint/Rule/CouponRuleAbstract.php
View File

@@ -24,7 +24,7 @@
namespace Thelia\Constraint\Rule;
use Symfony\Component\Intl\Exception\NotImplementedException;
use Symfony\Component\Translation\Translator;
use Thelia\Core\Translation\Translator;
use Thelia\Coupon\CouponAdapterInterface;
use Thelia\Constraint\Validator\ComparableInterface;
use Thelia\Constraint\Validator\RuleValidator;
@@ -49,6 +49,9 @@ abstract class CouponRuleAbstract implements CouponRuleInterface
/** Value key in $validators */
CONST VALUE = 'value';
/** @var string Service Id from Resources/config.xml */
protected $serviceId = null;
/** @var array Available Operators (Operators::CONST) */
protected $availableOperators = array();
@@ -67,11 +70,12 @@ abstract class CouponRuleAbstract implements CouponRuleInterface
/**
* Constructor
*
* @param Translator $translator Service translator
* @param CouponAdapterInterface $adapter Service adapter
*/
function __construct(Translator $translator)
function __construct(CouponAdapterInterface $adapter)
{
$this->translator($translator);
$this->adapter = $adapter;
$this->translator = $adapter->getTranslator();
}
/**
@@ -180,4 +184,16 @@ abstract class CouponRuleAbstract implements CouponRuleInterface
return $this->validators;
}
/**
* Get Rule Service id
*
* @return string
*/
public function getServiceId()
{
return $this->serviceId;
}
}

6
core/lib/Thelia/Constraint/Rule/CouponRuleInterface.php
View File

@@ -23,7 +23,7 @@
namespace Thelia\Constraint\Rule;
use Symfony\Component\Translation\Translator;
use Thelia\Core\Translation\Translator;
use Thelia\Coupon\CouponAdapterInterface;
/**
@@ -42,9 +42,9 @@ interface CouponRuleInterface
/**
* Constructor
*
* @param Translator $translator Service translator
* @param CouponAdapterInterface $adapter Service adapter
*/
function __construct(Translator $translator);
function __construct(CouponAdapterInterface $adapter);
/**
* Check if backoffice inputs are relevant or not

32
core/lib/Thelia/Constraint/Rule/SerializableRule.php
View File

@@ -45,5 +45,37 @@ class SerializableRule
/** @var array Values set by Admin for this Rule */
public $values = array();
/**
* Get Operators set by Admin for this Rule
*
* @return array
*/
public function getOperators()
{
return $this->operators;
}
/**
* Get Rule Service id
*
* @return string
*/
public function getRuleServiceId()
{
return $this->ruleServiceId;
}
/**
* Get Values set by Admin for this Rule
*
* @return array
*/
public function getValues()
{
return $this->values;
}
}

14
core/lib/Thelia/Constraint/Validator/PriceParam.php
View File

@@ -23,6 +23,7 @@
namespace Thelia\Constraint\Validator;
use Thelia\Core\Translation\Translator;
use Thelia\Coupon\CouponAdapterInterface;
/**
@@ -48,15 +49,15 @@ class PriceParam extends RuleParameterAbstract
/**
* Constructor
*
* @param CouponAdapterInterface $adapter Provide necessary value from Thelia
* @param float $price Positive float
* @param string $currency Currency Code ISO 4217 EUR|USD|GBP
* @param Translator $translator Service translator
* @param float $price Positive float
* @param string $currency Currency Code ISO 4217 EUR|USD|GBP
*/
public function __construct(CouponAdapterInterface $adapter, $price, $currency)
public function __construct(Translator $translator, $price, $currency)
{
$this->price = $price;
$this->currency = $currency;
$this->adapter = $adapter;
$this->translator = $translator;
}
/**
@@ -132,8 +133,7 @@ class PriceParam extends RuleParameterAbstract
*/
public function getToolTip()
{
return $this->adapter
->getTranslator()
return $this->translator
->trans(
'A price in %currency% (ex: 14.50)',
array(

5
core/lib/Thelia/Constraint/Validator/RuleParameterAbstract.php
View File

@@ -23,6 +23,7 @@
namespace Thelia\Constraint\Validator;
use Thelia\Core\Translation\Translator;
use Thelia\Coupon\CouponAdapterInterface;
use Thelia\Exception\NotImplementedException;
@@ -39,8 +40,8 @@ use Thelia\Exception\NotImplementedException;
*/
abstract class RuleParameterAbstract implements ComparableInterface
{
/** @var CouponAdapterInterface Provide necessary value from Thelia*/
protected $adapter;
/** @var Translator Service Translator */
protected $translator = null;
/**
* Get Parameter value to test against

7
core/lib/Thelia/Coupon/CouponAdapterInterface.php
View File

@@ -87,6 +87,13 @@ interface CouponAdapterInterface
*/
public function getCartTotalPrice();
/**
* Return the Checkout currency EUR|USD
*
* @return string
*/
public function getCheckoutCurrency();
/**
* Return Checkout total postage (only) price
*

11
core/lib/Thelia/Coupon/CouponBaseAdapter.php
View File

@@ -119,6 +119,17 @@ class CouponBaseAdapter implements CouponAdapterInterface
// TODO: Implement getCartTotalPrice() method.
}
/**
* Return the Checkout currency EUR|USD
*
* @return string
*/
public function getCheckoutCurrency()
{
// TODO: Implement getCheckoutCurrency() method.
}
/**
* Return the number of Products in the Cart
*

16
core/lib/Thelia/Coupon/CouponRuleCollection.php
View File

@@ -85,5 +85,21 @@ class CouponRuleCollection
return isEmpty($this->rules);
}
/**
* Allow to compare 2 set of rules
*
* @return string Jsoned data
*/
public function __toString()
{
$arrayToSerialize = array();
/** @var CouponRuleInterface $rule */
foreach ($this->getRules() as $rule) {
$arrayToSerialize[] = $rule->getSerializableRule();
}
return json_encode($arrayToSerialize);
}
}

99
core/lib/Thelia/Tests/Constraint/ConstraintManagerTest.php
View File

@@ -29,6 +29,8 @@ use Thelia\Constraint\Validator\PriceParam;
use Thelia\Constraint\Validator\RuleValidator;
use Thelia\Constraint\Rule\AvailableForTotalAmount;
use Thelia\Constraint\Rule\Operators;
use Thelia\Coupon\CouponBaseAdapter;
use Thelia\Coupon\CouponBaseAdapterTest;
use Thelia\Coupon\CouponRuleCollection;
use Thelia\Coupon\Type\CouponInterface;
use Thelia\Coupon\Type\RemoveXAmount;
@@ -56,11 +58,58 @@ class ConstraintManagerTest extends \PHPUnit_Framework_TestCase
{
}
public function incompleteTest()
/**
* Check the if the Constraint Manager is able to check RuleValidators
*/
public function testIsMatching()
{
$this->markTestIncomplete(
'This test has not been implemented yet.'
$stubTranslator = $this->getMockBuilder('\Thelia\Core\Translation\Translator')
->disableOriginalConstructor()
->getMock();
$stubAdapter = $this->getMockBuilder('\Thelia\Coupon\CouponBaseAdapter')
->disableOriginalConstructor()
->getMock();
$stubAdapter->expects($this->any())
->method('getTranslator')
->will($this->returnValue($stubTranslator));
$stubAdapter->expects($this->any())
->method('getCartTotalPrice')
->will($this->returnValue(321.98));
$stubAdapter->expects($this->any())
->method('getCheckoutCurrency')
->will($this->returnValue('USD'));
$rule1 = new AvailableForTotalAmount($stubAdapter);
$operators = array(AvailableForTotalAmount::PARAM1_PRICE => Operators::SUPERIOR);
$values = array(
AvailableForTotalAmount::PARAM1_PRICE => 40.00,
AvailableForTotalAmount::PARAM1_CURRENCY => 'USD'
);
$rule1->populateFromForm($operators, $values);
$rule2 = new AvailableForTotalAmount($stubAdapter);
$operators = array(AvailableForTotalAmount::PARAM1_PRICE => Operators::INFERIOR);
$values = array(
AvailableForTotalAmount::PARAM1_PRICE => 400.00,
AvailableForTotalAmount::PARAM1_CURRENCY => 'USD'
);
$rule2->populateFromForm($operators, $values);
$rules = new CouponRuleCollection();
$rules->add($rule1);
$rules->add($rule2);
/** @var ConstraintManager $constraintManager */
$constraintManager = new ConstraintManager($this->getContainer());
$expected = true;
$actual = $constraintManager->isMatching($rules);
$this->assertEquals($expected, $actual, 'The ConstraintManager is no more able to check if a Rule is matching');
}
/**
@@ -68,9 +117,19 @@ class ConstraintManagerTest extends \PHPUnit_Framework_TestCase
*/
public function testRuleSerialisation()
{
$translator = $this->getMock('\Thelia\Core\Translation\Translator');
$stubTranslator = $this->getMockBuilder('\Thelia\Core\Translation\Translator')
->disableOriginalConstructor()
->getMock();
$rule1 = new AvailableForTotalAmount($translator);
$stubAdapter = $this->getMockBuilder('\Thelia\Coupon\CouponBaseAdapter')
->disableOriginalConstructor()
->getMock();
$stubAdapter->expects($this->any())
->method('getTranslator')
->will($this->returnValue($stubTranslator));
$rule1 = new AvailableForTotalAmount($stubAdapter);
$operators = array(AvailableForTotalAmount::PARAM1_PRICE => Operators::SUPERIOR);
$values = array(
AvailableForTotalAmount::PARAM1_PRICE => 40.00,
@@ -78,7 +137,7 @@ class ConstraintManagerTest extends \PHPUnit_Framework_TestCase
);
$rule1->populateFromForm($operators, $values);
$rule2 = new AvailableForTotalAmount($translator);
$rule2 = new AvailableForTotalAmount($stubAdapter);
$operators = array(AvailableForTotalAmount::PARAM1_PRICE => Operators::INFERIOR);
$values = array(
AvailableForTotalAmount::PARAM1_PRICE => 400.00,
@@ -86,7 +145,9 @@ class ConstraintManagerTest extends \PHPUnit_Framework_TestCase
);
$rule2->populateFromForm($operators, $values);
$rules = new CouponRuleCollection(array($rule1, $rule2));
$rules = new CouponRuleCollection();
$rules->add($rule1);
$rules->add($rule2);
/** @var ConstraintManager $constraintManager */
$constraintManager = new ConstraintManager($this->getContainer());
@@ -94,8 +155,8 @@ class ConstraintManagerTest extends \PHPUnit_Framework_TestCase
$serializedRules = $constraintManager->serializeCouponRuleCollection($rules);
$unserializedRules = $constraintManager->unserializeCouponRuleCollection($serializedRules);
$expected = $rules;
$actual = $unserializedRules;
$expected = (string)$rules;
$actual = (string)$unserializedRules;
$this->assertEquals($expected, $actual);
}
@@ -109,12 +170,26 @@ class ConstraintManagerTest extends \PHPUnit_Framework_TestCase
{
$container = new ContainerBuilder();
$translator = $this->getMock('\Thelia\Core\Translation\Translator');
$rule1 = new AvailableForTotalAmount($translator);
$rule2 = new AvailableForXArticles($translator);
$stubTranslator = $this->getMockBuilder('\Thelia\Core\Translation\Translator')
->disableOriginalConstructor()
->getMock();
$stubAdapter = $this->getMockBuilder('\Thelia\Coupon\CouponBaseAdapter')
->disableOriginalConstructor()
->getMock();
$stubAdapter->expects($this->any())
->method('getTranslator')
->will($this->returnValue($stubTranslator));
$rule1 = new AvailableForTotalAmount($stubAdapter);
$rule2 = new AvailableForXArticles($stubAdapter);
$adapter = new CouponBaseAdapter($container);
$container->set('thelia.constraint.rule.available_for_total_amount', $rule1);
$container->set('thelia.constraint.rule.available_for_x_articles', $rule2);
$container->set('thelia.adapter', $adapter);
return $container;
}

593
core/lib/Thelia/Tests/Constraint/Rule/AvailableForXArticlesTest.php
View File

@@ -66,11 +66,10 @@ class AvailableForXArticlesTest extends \PHPUnit_Framework_TestCase
protected function generateValidCouponBaseAdapterMock($nbArticlesInCart = 4)
{
/** @var CouponAdapterInterface $stubTheliaAdapter */
$stubTheliaAdapter = $this->getMock(
'Thelia\Coupon\CouponBaseAdapter',
array('getNbArticlesInCart'),
array()
);
$stubTheliaAdapter = $this->getMockBuilder('\Thelia\Coupon\CouponBaseAdapter')
->disableOriginalConstructor()
->setMethods(array('getNbArticlesInCart'))
->getMock();
$stubTheliaAdapter->expects($this->any())
->method('getNbArticlesInCart')
->will($this->returnValue($nbArticlesInCart));
@@ -86,307 +85,305 @@ class AvailableForXArticlesTest extends \PHPUnit_Framework_TestCase
*/
public function testValidBackOfficeInput()
{
$adapter = $this->stubTheliaAdapter;
$translator = $this->getMockBuilder('\Thelia\Core\Translation\Translator')
->disableOriginalConstructor()
->getMock();
$validators = array(
AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
Operators::SUPERIOR,
new QuantityParam(
$adapter,
4
)
)
$rule = new AvailableForXArticles($translator);
$operators = array(AvailableForXArticles::PARAM1_QUANTITY => Operators::SUPERIOR);
$values = array(
AvailableForXArticles::PARAM1_QUANTITY => 4
);
$rule = new AvailableForXArticles($adapter, $validators);
$rule->populateFromForm($operators, $values);
$expected = true;
$actual = $rule->checkBackOfficeInput();
$this->assertEquals($expected, $actual);
}
/**
* Check if validity test on BackOffice inputs are working
*
* @covers Thelia\Coupon\Rule\AvailableForXArticles::checkBackOfficeInput
* @expectedException \Thelia\Exception\InvalidRuleValueException
*/
public function testInValidBackOfficeInputFloat()
{
$adapter = $this->stubTheliaAdapter;
$validators = array(
AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
Operators::SUPERIOR,
new QuantityParam(
$adapter,
4.5
)
)
);
$rule = new AvailableForXArticles($adapter, $validators);
$expected = false;
$actual = $rule->checkBackOfficeInput();
$this->assertEquals($expected, $actual);
}
/**
* Check if validity test on BackOffice inputs are working
*
* @covers Thelia\Coupon\Rule\AvailableForXArticles::checkBackOfficeInput
* @expectedException \Thelia\Exception\InvalidRuleValueException
*/
public function testInValidBackOfficeInputNegative()
{
$adapter = $this->stubTheliaAdapter;
$validators = array(
AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
Operators::SUPERIOR,
new QuantityParam(
$adapter,
-1
)
)
);
$rule = new AvailableForXArticles($adapter, $validators);
$expected = false;
$actual = $rule->checkBackOfficeInput();
$this->assertEquals($expected, $actual);
}
/**
* Check if validity test on BackOffice inputs are working
*
* @covers Thelia\Coupon\Rule\AvailableForXArticles::checkBackOfficeInput
* @expectedException \Thelia\Exception\InvalidRuleValueException
*/
public function testInValidBackOfficeInputString()
{
$adapter = $this->stubTheliaAdapter;
$validators = array(
AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
Operators::SUPERIOR,
new QuantityParam(
$adapter,
'bad'
)
)
);
$rule = new AvailableForXArticles($adapter, $validators);
$expected = false;
$actual = $rule->checkBackOfficeInput();
$this->assertEquals($expected, $actual);
}
/**
* Check if validity test on FrontOffice inputs are working
*
* @covers Thelia\Coupon\Rule\AvailableForXArticles::checkCheckoutInput
*/
public function testValidCheckoutInput()
{
$adapter = $this->stubTheliaAdapter;
$validators = array(
AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
Operators::SUPERIOR,
new QuantityParam(
$adapter,
4
)
)
);
$rule = new AvailableForXArticles($adapter, $validators);
$expected = true;
$actual = $rule->checkCheckoutInput();
$this->assertEquals($expected, $actual);
}
/**
* Check if validity test on FrontOffice inputs are working
*
* @covers Thelia\Coupon\Rule\AvailableForXArticles::checkCheckoutInput
* @expectedException \Thelia\Exception\InvalidRuleValueException
*/
public function testInValidCheckoutInputFloat()
{
$adapter = $this->generateValidCouponBaseAdapterMock(4.5);
$validators = array(
AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
Operators::SUPERIOR,
new QuantityParam(
$adapter,
4
)
)
);
$rule = new AvailableForXArticles($adapter, $validators);
$expected = false;
$actual = $rule->checkCheckoutInput();
$this->assertEquals($expected, $actual);
}
/**
* Check if validity test on FrontOffice inputs are working
*
* @covers Thelia\Coupon\Rule\AvailableForXArticles::checkCheckoutInput
* @expectedException \Thelia\Exception\InvalidRuleValueException
*/
public function testInValidCheckoutInputNegative()
{
$adapter = $this->generateValidCouponBaseAdapterMock(-1);
$validators = array(
AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
Operators::SUPERIOR,
new QuantityParam(
$adapter,
4
)
)
);
$rule = new AvailableForXArticles($adapter, $validators);
$expected = false;
$actual = $rule->checkCheckoutInput();
$this->assertEquals($expected, $actual);
}
/**
* Check if validity test on FrontOffice inputs are working
*
* @covers Thelia\Coupon\Rule\AvailableForXArticles::checkCheckoutInput
* @expectedException \Thelia\Exception\InvalidRuleValueException
*/
public function testInValidCheckoutInputString()
{
$adapter = $this->generateValidCouponBaseAdapterMock('bad');
$validators = array(
AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
Operators::SUPERIOR,
new QuantityParam(
$adapter,
4
)
)
);
$rule = new AvailableForXArticles($adapter, $validators);
$expected = false;
$actual = $rule->checkCheckoutInput();
$this->assertEquals($expected, $actual);
}
/**
* Check if test inferior operator is working
*
* @covers Thelia\Coupon\Rule\AvailableForXArticles::isMatching
*
*/
public function testMatchingRuleInferior()
{
$adapter = $this->stubTheliaAdapter;
$validators = array(
AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
Operators::INFERIOR,
new QuantityParam(
$adapter,
5
)
)
);
$rule = new AvailableForXArticles($adapter, $validators);
$expected = true;
$actual = $rule->isMatching();
$this->assertEquals($expected, $actual);
}
/**
* Check if test equals operator is working
*
* @covers Thelia\Coupon\Rule\AvailableForXArticles::isMatching
*
*/
public function testMatchingRuleEqual()
{
$adapter = $this->stubTheliaAdapter;
$validators = array(
AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
Operators::EQUAL,
new QuantityParam(
$adapter,
4
)
)
);
$rule = new AvailableForXArticles($adapter, $validators);
$expected = true;
$actual = $rule->isMatching();
$this->assertEquals($expected, $actual);
}
/**
* Check if test superior operator is working
*
* @covers Thelia\Coupon\Rule\AvailableForXArticles::isMatching
*
*/
public function testMatchingRuleSuperior()
{
$adapter = $this->stubTheliaAdapter;
$validators = array(
AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
Operators::SUPERIOR,
new QuantityParam(
$adapter,
3
)
)
);
$rule = new AvailableForXArticles($adapter, $validators);
$expected = true;
$actual = $rule->isMatching();
$this->assertEquals($expected, $actual);
}
/**
* Check if test unavailable operator is working
*
* @covers Thelia\Coupon\Rule\AvailableForXArticles::isMatching
* @expectedException \Thelia\Exception\InvalidRuleOperatorException
*
*/
public function testNotMatchingRule()
{
$adapter = $this->stubTheliaAdapter;
$validators = array(
AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
Operators::DIFFERENT,
new QuantityParam(
$adapter,
3
)
)
);
$rule = new AvailableForXArticles($adapter, $validators);
$expected = false;
$actual = $rule->isMatching();
$this->assertEquals($expected, $actual);
}
// /**
// * Check if validity test on BackOffice inputs are working
// *
// * @covers Thelia\Coupon\Rule\AvailableForXArticles::checkBackOfficeInput
// * @expectedException \Thelia\Exception\InvalidRuleValueException
// */
// public function testInValidBackOfficeInputFloat()
// {
// $adapter = $this->stubTheliaAdapter;
//
// $validators = array(
// AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
// Operators::SUPERIOR,
// new QuantityParam(
// $adapter,
// 4.5
// )
// )
// );
// $rule = new AvailableForXArticles($adapter, $validators);
//
// $expected = false;
// $actual = $rule->checkBackOfficeInput();
// $this->assertEquals($expected, $actual);
// }
//
// /**
// * Check if validity test on BackOffice inputs are working
// *
// * @covers Thelia\Coupon\Rule\AvailableForXArticles::checkBackOfficeInput
// * @expectedException \Thelia\Exception\InvalidRuleValueException
// */
// public function testInValidBackOfficeInputNegative()
// {
// $adapter = $this->stubTheliaAdapter;
//
// $validators = array(
// AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
// Operators::SUPERIOR,
// new QuantityParam(
// $adapter,
// -1
// )
// )
// );
// $rule = new AvailableForXArticles($adapter, $validators);
//
// $expected = false;
// $actual = $rule->checkBackOfficeInput();
// $this->assertEquals($expected, $actual);
// }
//
// /**
// * Check if validity test on BackOffice inputs are working
// *
// * @covers Thelia\Coupon\Rule\AvailableForXArticles::checkBackOfficeInput
// * @expectedException \Thelia\Exception\InvalidRuleValueException
// */
// public function testInValidBackOfficeInputString()
// {
// $adapter = $this->stubTheliaAdapter;
//
// $validators = array(
// AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
// Operators::SUPERIOR,
// new QuantityParam(
// $adapter,
// 'bad'
// )
// )
// );
// $rule = new AvailableForXArticles($adapter, $validators);
//
// $expected = false;
// $actual = $rule->checkBackOfficeInput();
// $this->assertEquals($expected, $actual);
// }
//
//
//
//
//
// /**
// * Check if validity test on FrontOffice inputs are working
// *
// * @covers Thelia\Coupon\Rule\AvailableForXArticles::checkCheckoutInput
// */
// public function testValidCheckoutInput()
// {
// $adapter = $this->stubTheliaAdapter;
// $validators = array(
// AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
// Operators::SUPERIOR,
// new QuantityParam(
// $adapter,
// 4
// )
// )
// );
// $rule = new AvailableForXArticles($adapter, $validators);
//
// $expected = true;
// $actual = $rule->checkCheckoutInput();
// $this->assertEquals($expected, $actual);
// }
//
// /**
// * Check if validity test on FrontOffice inputs are working
// *
// * @covers Thelia\Coupon\Rule\AvailableForXArticles::checkCheckoutInput
// * @expectedException \Thelia\Exception\InvalidRuleValueException
// */
// public function testInValidCheckoutInputFloat()
// {
// $adapter = $this->generateValidCouponBaseAdapterMock(4.5);
// $validators = array(
// AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
// Operators::SUPERIOR,
// new QuantityParam(
// $adapter,
// 4
// )
// )
// );
// $rule = new AvailableForXArticles($adapter, $validators);
//
// $expected = false;
// $actual = $rule->checkCheckoutInput();
// $this->assertEquals($expected, $actual);
// }
//
// /**
// * Check if validity test on FrontOffice inputs are working
// *
// * @covers Thelia\Coupon\Rule\AvailableForXArticles::checkCheckoutInput
// * @expectedException \Thelia\Exception\InvalidRuleValueException
// */
// public function testInValidCheckoutInputNegative()
// {
// $adapter = $this->generateValidCouponBaseAdapterMock(-1);
//
// $validators = array(
// AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
// Operators::SUPERIOR,
// new QuantityParam(
// $adapter,
// 4
// )
// )
// );
// $rule = new AvailableForXArticles($adapter, $validators);
//
// $expected = false;
// $actual = $rule->checkCheckoutInput();
// $this->assertEquals($expected, $actual);
// }
//
// /**
// * Check if validity test on FrontOffice inputs are working
// *
// * @covers Thelia\Coupon\Rule\AvailableForXArticles::checkCheckoutInput
// * @expectedException \Thelia\Exception\InvalidRuleValueException
// */
// public function testInValidCheckoutInputString()
// {
// $adapter = $this->generateValidCouponBaseAdapterMock('bad');
//
// $validators = array(
// AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
// Operators::SUPERIOR,
// new QuantityParam(
// $adapter,
// 4
// )
// )
// );
// $rule = new AvailableForXArticles($adapter, $validators);
//
// $expected = false;
// $actual = $rule->checkCheckoutInput();
// $this->assertEquals($expected, $actual);
// }
//
// /**
// * Check if test inferior operator is working
// *
// * @covers Thelia\Coupon\Rule\AvailableForXArticles::isMatching
// *
// */
// public function testMatchingRuleInferior()
// {
// $adapter = $this->stubTheliaAdapter;
// $validators = array(
// AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
// Operators::INFERIOR,
// new QuantityParam(
// $adapter,
// 5
// )
// )
// );
// $rule = new AvailableForXArticles($adapter, $validators);
//
// $expected = true;
// $actual = $rule->isMatching();
// $this->assertEquals($expected, $actual);
// }
//
// /**
// * Check if test equals operator is working
// *
// * @covers Thelia\Coupon\Rule\AvailableForXArticles::isMatching
// *
// */
// public function testMatchingRuleEqual()
// {
// $adapter = $this->stubTheliaAdapter;
// $validators = array(
// AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
// Operators::EQUAL,
// new QuantityParam(
// $adapter,
// 4
// )
// )
// );
// $rule = new AvailableForXArticles($adapter, $validators);
//
// $expected = true;
// $actual = $rule->isMatching();
// $this->assertEquals($expected, $actual);
// }
//
// /**
// * Check if test superior operator is working
// *
// * @covers Thelia\Coupon\Rule\AvailableForXArticles::isMatching
// *
// */
// public function testMatchingRuleSuperior()
// {
// $adapter = $this->stubTheliaAdapter;
// $validators = array(
// AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
// Operators::SUPERIOR,
// new QuantityParam(
// $adapter,
// 3
// )
// )
// );
// $rule = new AvailableForXArticles($adapter, $validators);
//
// $expected = true;
// $actual = $rule->isMatching();
// $this->assertEquals($expected, $actual);
// }
//
// /**
// * Check if test unavailable operator is working
// *
// * @covers Thelia\Coupon\Rule\AvailableForXArticles::isMatching
// * @expectedException \Thelia\Exception\InvalidRuleOperatorException
// *
// */
// public function testNotMatchingRule()
// {
// $adapter = $this->stubTheliaAdapter;
// $validators = array(
// AvailableForXArticles::PARAM1_QUANTITY => new RuleValidator(
// Operators::DIFFERENT,
// new QuantityParam(
// $adapter,
// 3
// )
// )
// );
// $rule = new AvailableForXArticles($adapter, $validators);
//
// $expected = false;
// $actual = $rule->isMatching();
// $this->assertEquals($expected, $actual);
// }
/**