CodeExplorer
You are a developer and looking for Shopware projects?
Apply Now!
getConstraints example
use Symfony\Component\Validator\Mapping\ClassMetadata;
use Symfony\Component\Validator\Mapping\Loader\AttributeLoader;
class IsbnTest extends TestCase
{
public function testAttributes()
{
$metadata = new ClassMetadata(IsbnDummy::class);
$loader = new AttributeLoader();
self::assertTrue($loader->loadClassMetadata($metadata));
[$aConstraint] = $metadata->properties['a']->getConstraints();
self::assertNull($aConstraint->type);
[$bConstraint] = $metadata->properties['b']->getConstraints();
self::assertSame(Isbn::ISBN_13, $bConstraint->type);
self::assertSame('myMessage', $bConstraint->message);
self::assertSame(['Default', 'IsbnDummy'], $bConstraint->groups);
[$cConstraint] = $metadata->properties['c']->getConstraints();
self::assertSame(['my_group'], $cConstraint->groups);
self::assertSame('some attached data', $cConstraint->payload);
}
}
use Symfony\Component\Validator\Mapping\Loader\AttributeLoader;
class IsbnTest extends TestCase
{
public function testAttributes()
{
$metadata = new ClassMetadata(IsbnDummy::class);
$loader = new AttributeLoader();
self::assertTrue($loader->loadClassMetadata($metadata));
[$aConstraint] = $metadata->properties['a']->getConstraints();
self::assertNull($aConstraint->type);
[$bConstraint] = $metadata->properties['b']->getConstraints();
self::assertSame(Isbn::ISBN_13, $bConstraint->type);
self::assertSame('myMessage', $bConstraint->message);
self::assertSame(['Default', 'IsbnDummy'], $bConstraint->groups);
[$cConstraint] = $metadata->properties['c']->getConstraints();
self::assertSame(['my_group'], $cConstraint->groups);
self::assertSame('some attached data', $cConstraint->payload);
}
}
return array('numeric' => array(), 'branches' => array('names' => array(), 'exclude' => false));
}
if ($constraint instanceof Constraint) {
return self::generateSingleConstraintIntervals($constraint);
}
if (!$constraint instanceof MultiConstraint) {
throw new \UnexpectedValueException('The constraint passed in should be an MatchAllConstraint, Constraint or MultiConstraint instance, got '.\get_class($constraint).'.');
}
$constraints = $constraint->getConstraints();
$numericGroups = array();
$constraintBranches = array();
foreach ($constraints as $c) {
$res = self::get($c);
$numericGroups[] = $res['numeric'];
$constraintBranches[] = $res['branches'];
}
if ($constraint->isDisjunctive()) {
$branches = Interval::noDev();
}
if ($constraint instanceof Constraint) {
return self::generateSingleConstraintIntervals($constraint);
}
if (!$constraint instanceof MultiConstraint) {
throw new \UnexpectedValueException('The constraint passed in should be an MatchAllConstraint, Constraint or MultiConstraint instance, got '.\get_class($constraint).'.');
}
$constraints = $constraint->getConstraints();
$numericGroups = array();
$constraintBranches = array();
foreach ($constraints as $c) {
$res = self::get($c);
$numericGroups[] = $res['numeric'];
$constraintBranches[] = $res['branches'];
}
if ($constraint->isDisjunctive()) {
$branches = Interval::noDev();
$metadata = new ClassMetadata(ExpressionSyntaxDummy::class);
self::assertTrue((new AttributeLoader())->loadClassMetadata($metadata));
yield 'attribute' => [$metadata->properties['b']->constraints[0]];
}
public function testAttributes()
{
$metadata = new ClassMetadata(ExpressionSyntaxDummy::class);
self::assertTrue((new AttributeLoader())->loadClassMetadata($metadata));
[$aConstraint] = $metadata->properties['a']->getConstraints();
self::assertNull($aConstraint->service);
self::assertNull($aConstraint->allowedVariables);
[$bConstraint] = $metadata->properties['b']->getConstraints();
self::assertSame('my_service', $bConstraint->service);
self::assertSame('myMessage', $bConstraint->message);
self::assertSame(['Default', 'ExpressionSyntaxDummy'], $bConstraint->groups);
[$cConstraint] = $metadata->properties['c']->getConstraints();
self::assertSame(['foo', 'bar'], $cConstraint->allowedVariables);
self::assertSame(['my_group'], $cConstraint->groups);
}
self::assertTrue((new AttributeLoader())->loadClassMetadata($metadata));
yield 'attribute' => [$metadata->properties['b']->constraints[0]];
}
public function testAttributes()
{
$metadata = new ClassMetadata(ExpressionSyntaxDummy::class);
self::assertTrue((new AttributeLoader())->loadClassMetadata($metadata));
[$aConstraint] = $metadata->properties['a']->getConstraints();
self::assertNull($aConstraint->service);
self::assertNull($aConstraint->allowedVariables);
[$bConstraint] = $metadata->properties['b']->getConstraints();
self::assertSame('my_service', $bConstraint->service);
self::assertSame('myMessage', $bConstraint->message);
self::assertSame(['Default', 'ExpressionSyntaxDummy'], $bConstraint->groups);
[$cConstraint] = $metadata->properties['c']->getConstraints();
self::assertSame(['foo', 'bar'], $cConstraint->allowedVariables);
self::assertSame(['my_group'], $cConstraint->groups);
}
use Symfony\Component\Validator\Mapping\ClassMetadata;
use Symfony\Component\Validator\Mapping\Loader\AttributeLoader;
class DivisibleByTest extends TestCase
{
public function testAttributes()
{
$metadata = new ClassMetadata(DivisibleByDummy::class);
$loader = new AttributeLoader();
self::assertTrue($loader->loadClassMetadata($metadata));
[$aConstraint] = $metadata->properties['a']->getConstraints();
self::assertSame(2, $aConstraint->value);
self::assertNull($aConstraint->propertyPath);
[$bConstraint] = $metadata->properties['b']->getConstraints();
self::assertSame(4711, $bConstraint->value);
self::assertSame('myMessage', $bConstraint->message);
self::assertSame(['Default', 'DivisibleByDummy'], $bConstraint->groups);
[$cConstraint] = $metadata->properties['c']->getConstraints();
self::assertNull($cConstraint->value);
self::assertSame('b', $cConstraint->propertyPath);
use Symfony\Component\Validator\Mapping\Loader\AttributeLoader;
class DivisibleByTest extends TestCase
{
public function testAttributes()
{
$metadata = new ClassMetadata(DivisibleByDummy::class);
$loader = new AttributeLoader();
self::assertTrue($loader->loadClassMetadata($metadata));
[$aConstraint] = $metadata->properties['a']->getConstraints();
self::assertSame(2, $aConstraint->value);
self::assertNull($aConstraint->propertyPath);
[$bConstraint] = $metadata->properties['b']->getConstraints();
self::assertSame(4711, $bConstraint->value);
self::assertSame('myMessage', $bConstraint->message);
self::assertSame(['Default', 'DivisibleByDummy'], $bConstraint->groups);
[$cConstraint] = $metadata->properties['c']->getConstraints();
self::assertNull($cConstraint->value);
self::assertSame('b', $cConstraint->propertyPath);
$expectedOperators = [
Rule::OPERATOR_EQ,
Rule::OPERATOR_NEQ,
Rule::OPERATOR_EMPTY,
Rule::OPERATOR_GTE,
Rule::OPERATOR_LTE,
Rule::OPERATOR_GT,
Rule::OPERATOR_LT,
];
$ruleConstraints = $this->rule->getConstraints();
static::assertArrayHasKey('operator', $ruleConstraints, 'Constraint operator not found in Rule');
$operators = $ruleConstraints['operator'];
static::assertEquals(new NotBlank(), $operators[0]);
static::assertEquals(new Choice($expectedOperators), $operators[1]);
$this->rule->assign(['operator' => Rule::OPERATOR_EQ]);
static::assertArrayHasKey('zipCodes', $ruleConstraints, 'Constraint zipCodes not found in Rule');
$zipCodes = $ruleConstraints['zipCodes'];
static::assertEquals(new NotBlank(), $zipCodes[0]);
static::assertEquals(new ArrayOfType('string'), $zipCodes[1]);
}
use Symfony\Component\Validator\Mapping\ClassMetadata;
use Symfony\Component\Validator\Mapping\Loader\AttributeLoader;
class JsonTest extends TestCase
{
public function testAttributes()
{
$metadata = new ClassMetadata(JsonDummy::class);
$loader = new AttributeLoader();
self::assertTrue($loader->loadClassMetadata($metadata));
[$bConstraint] = $metadata->properties['b']->getConstraints();
self::assertSame('myMessage', $bConstraint->message);
self::assertSame(['Default', 'JsonDummy'], $bConstraint->groups);
[$cConstraint] = $metadata->properties['c']->getConstraints();
self::assertSame(['my_group'], $cConstraint->groups);
self::assertSame('some attached data', $cConstraint->payload);
}
}
class JsonDummy
{
use Symfony\Component\Validator\Mapping\Loader\AttributeLoader;
class JsonTest extends TestCase
{
public function testAttributes()
{
$metadata = new ClassMetadata(JsonDummy::class);
$loader = new AttributeLoader();
self::assertTrue($loader->loadClassMetadata($metadata));
[$bConstraint] = $metadata->properties['b']->getConstraints();
self::assertSame('myMessage', $bConstraint->message);
self::assertSame(['Default', 'JsonDummy'], $bConstraint->groups);
[$cConstraint] = $metadata->properties['c']->getConstraints();
self::assertSame(['my_group'], $cConstraint->groups);
self::assertSame('some attached data', $cConstraint->payload);
}
}
class JsonDummy
{
public function testConstraints(): void
{
$expectedOperators = [
Rule::OPERATOR_NEQ,
Rule::OPERATOR_GTE,
Rule::OPERATOR_LTE,
Rule::OPERATOR_EQ,
Rule::OPERATOR_GT,
Rule::OPERATOR_LT,
];
$ruleConstraints = $this->rule->getConstraints();
static::assertArrayHasKey('lineItemCreationDate', $ruleConstraints, 'Constraint lineItemCreationDate not found in Rule');
static::assertArrayHasKey('operator', $ruleConstraints, 'Constraint operator not found in Rule');
$date = $ruleConstraints['lineItemCreationDate'];
$operators = $ruleConstraints['operator'];
static::assertEquals(new NotBlank(), $date[0]);
static::assertEquals(new Type(['type' => 'string']), $date[1]);
static::assertEquals(new NotBlank(), $operators[0]);
{
$expectedOperators = [
Rule::OPERATOR_NEQ,
Rule::OPERATOR_GTE,
Rule::OPERATOR_LTE,
Rule::OPERATOR_EQ,
Rule::OPERATOR_GT,
Rule::OPERATOR_LT,
];
$ruleConstraints = $this->rule->getConstraints();
static::assertArrayHasKey('lineItemCreationDate', $ruleConstraints, 'Constraint lineItemCreationDate not found in Rule');
static::assertArrayHasKey('operator', $ruleConstraints, 'Constraint operator not found in Rule');
$date = $ruleConstraints['lineItemCreationDate'];
$operators = $ruleConstraints['operator'];
static::assertEquals(new NotBlank(), $date[0]);
static::assertEquals(new Type(['type' => 'string']), $date[1]);
static::assertEquals(new NotBlank(), $operators[0]);
public function getConstraints() {
// @todo Apply defaults. return $this->constraints;
}
/** * {@inheritdoc} */
public function getConstraint($constraint_name) {
$constraints = $this->getConstraints();
return $constraints[$constraint_name] ?? NULL;
}
/** * {@inheritdoc} */
public function setConstraints(array $constraints) {
$this->constraints = $constraints;
return $this;
}
use Symfony\Component\Validator\Mapping\ClassMetadata;
use Symfony\Component\Validator\Mapping\Loader\AttributeLoader;
class LuhnTest extends TestCase
{
public function testAttributes()
{
$metadata = new ClassMetadata(LuhnDummy::class);
$loader = new AttributeLoader();
self::assertTrue($loader->loadClassMetadata($metadata));
[$bConstraint] = $metadata->properties['b']->getConstraints();
self::assertSame('myMessage', $bConstraint->message);
self::assertSame(['Default', 'LuhnDummy'], $bConstraint->groups);
[$cConstraint] = $metadata->properties['c']->getConstraints();
self::assertSame(['my_group'], $cConstraint->groups);
self::assertSame('some attached data', $cConstraint->payload);
}
}
class LuhnDummy
{
use Symfony\Component\Validator\Mapping\Loader\AttributeLoader;
class LuhnTest extends TestCase
{
public function testAttributes()
{
$metadata = new ClassMetadata(LuhnDummy::class);
$loader = new AttributeLoader();
self::assertTrue($loader->loadClassMetadata($metadata));
[$bConstraint] = $metadata->properties['b']->getConstraints();
self::assertSame('myMessage', $bConstraint->message);
self::assertSame(['Default', 'LuhnDummy'], $bConstraint->groups);
[$cConstraint] = $metadata->properties['c']->getConstraints();
self::assertSame(['my_group'], $cConstraint->groups);
self::assertSame('some attached data', $cConstraint->payload);
}
}
class LuhnDummy
{
$this->rule = new LineItemDimensionWeightRule();
}
public function testGetName(): void
{
static::assertSame('cartLineItemDimensionWeight', $this->rule->getName());
}
public function testGetConstraints(): void
{
$ruleConstraints = $this->rule->getConstraints();
static::assertArrayHasKey('amount', $ruleConstraints, 'Rule Constraint amount is not defined');
static::assertArrayHasKey('operator', $ruleConstraints, 'Rule Constraint operator is not defined');
}
/** * @dataProvider getMatchingRuleTestData */
public function testIfMatchesCorrectWithLineItem(
string $operator,
float $weight,
#[Package('business-ops')] class CustomFieldRuleTest extends TestCase
{
private const CUSTOM_FIELD_NAME = 'custom_test';
public function testGetConstraints(): void
{
$ruleConstraints = CustomFieldRule::getConstraints([]);
static::assertArrayHasKey('operator', $ruleConstraints, 'Rule Constraint operator is not defined');
static::assertArrayHasKey('renderedField', $ruleConstraints, 'Rule Constraint renderedField is not defined');
static::assertArrayHasKey('renderedFieldValue', $ruleConstraints, 'Rule Constraint renderedFieldValue is not defined');
static::assertArrayHasKey('selectedField', $ruleConstraints, 'Rule Constraint selectedField is not defined');
static::assertArrayHasKey('selectedFieldSet', $ruleConstraints, 'Rule Constraint selectedFieldSet is not defined');
}
public function testGetConstraintsWithRenderedField(): void
{
$ruleConstraints = CustomFieldRule::getConstraints(['type' => 'string']);
$this->expectException(InvalidArgumentException::class);
$this->expectExceptionMessage('The "normalizer" option must be a valid callable ("stdClass" given).');
new Regex(['pattern' => '/^[0-9]+$/', 'normalizer' => new \stdClass()]);
}
public function testAttributes()
{
$metadata = new ClassMetadata(RegexDummy::class);
$loader = new AttributeLoader();
self::assertTrue($loader->loadClassMetadata($metadata));
[$aConstraint] = $metadata->properties['a']->getConstraints();
self::assertSame('/^[0-9]+$/', $aConstraint->pattern);
self::assertTrue($aConstraint->match);
self::assertNull($aConstraint->normalizer);
[$bConstraint] = $metadata->properties['b']->getConstraints();
self::assertSame('myMessage', $bConstraint->message);
self::assertSame('/^[0-9]+$/', $bConstraint->pattern);
self::assertSame('[0-9]+', $bConstraint->htmlPattern);
self::assertFalse($bConstraint->match);
self::assertSame(['Default', 'RegexDummy'], $bConstraint->groups);
[
$this->expectExceptionMessage('The "normalizer" option must be a valid callable ("stdClass" given).');
new Regex(['pattern' => '/^[0-9]+$/', 'normalizer' => new \stdClass()]);
}
public function testAttributes()
{
$metadata = new ClassMetadata(RegexDummy::class);
$loader = new AttributeLoader();
self::assertTrue($loader->loadClassMetadata($metadata));
[$aConstraint] = $metadata->properties['a']->getConstraints();
self::assertSame('/^[0-9]+$/', $aConstraint->pattern);
self::assertTrue($aConstraint->match);
self::assertNull($aConstraint->normalizer);
[$bConstraint] = $metadata->properties['b']->getConstraints();
self::assertSame('myMessage', $bConstraint->message);
self::assertSame('/^[0-9]+$/', $bConstraint->pattern);
self::assertSame('[0-9]+', $bConstraint->htmlPattern);
self::assertFalse($bConstraint->match);
self::assertSame(['Default', 'RegexDummy'], $bConstraint->groups);
[
$properties['value'] = DataDefinition::create('integer')
->setLabel(new TranslatableMarkup('Integer value'))
->setRequired(TRUE);
return $properties;
}
/** * {@inheritdoc} */
public function getConstraints() {
$constraints = parent::getConstraints();
// If this is an unsigned integer, add a validation constraint for the // integer to be positive. if ($this->getSetting('unsigned')) {
$constraint_manager = \Drupal::typedDataManager()->getValidationConstraintManager();
$constraints[] = $constraint_manager->create('ComplexData', [
'value' => [
'Range' => [
'min' => 0,
'minMessage' => $this->t('%name: The integer must be larger or equal to %min.', [
'%name' => $this->getFieldDefinition()->getLabel(),
->setLabel(new TranslatableMarkup('Integer value'))
->setRequired(TRUE);
return $properties;
}
/** * {@inheritdoc} */
public function getConstraints() {
$constraints = parent::getConstraints();
// If this is an unsigned integer, add a validation constraint for the // integer to be positive. if ($this->getSetting('unsigned')) {
$constraint_manager = \Drupal::typedDataManager()->getValidationConstraintManager();
$constraints[] = $constraint_manager->create('ComplexData', [
'value' => [
'Range' => [
'min' => 0,
'minMessage' => $this->t('%name: The integer must be larger or equal to %min.', [
'%name' => $this->getFieldDefinition()->getLabel(),
if (empty($this->value) && (string) $this->value !== '0') {
return TRUE;
}
return FALSE;
}
/** * {@inheritdoc} */
public function getConstraints() {
$constraint_manager = \Drupal::typedDataManager()->getValidationConstraintManager();
$constraints = parent::getConstraints();
$settings = $this->getSettings();
$label = $this->getFieldDefinition()->getLabel();
if (isset($settings['min']) && $settings['min'] !== '') {
$min = $settings['min'];
$constraints[] = $constraint_manager->create('ComplexData', [
'value' => [
'Range' => [
'min' => $min,
'minMessage' => $this->t('%name: the value may be no less than %min.', ['%name' => $label, '%min' => $min]),
],
return TRUE;
}
return FALSE;
}
/** * {@inheritdoc} */
public function getConstraints() {
$constraint_manager = \Drupal::typedDataManager()->getValidationConstraintManager();
$constraints = parent::getConstraints();
$settings = $this->getSettings();
$label = $this->getFieldDefinition()->getLabel();
if (isset($settings['min']) && $settings['min'] !== '') {
$min = $settings['min'];
$constraints[] = $constraint_manager->create('ComplexData', [
'value' => [
'Range' => [
'min' => $min,
'minMessage' => $this->t('%name: the value may be no less than %min.', ['%name' => $label, '%min' => $min]),
],
static::assertFalse((new LineItemStockRule(Rule::OPERATOR_EQ, 5))->match($cartScope));
static::assertTrue((new LineItemStockRule(Rule::OPERATOR_NEQ, 5))->match($lineItemScope));
static::assertTrue((new LineItemStockRule(Rule::OPERATOR_NEQ, 5))->match($cartScope));
static::assertTrue((new LineItemStockRule(Rule::OPERATOR_EMPTY, 5))->match($lineItemScope));
static::assertTrue((new LineItemStockRule(Rule::OPERATOR_EMPTY, 5))->match($cartScope));
}
public function testConstraintsIncludesOperatorAndStock(): void
{
$constraints = (new LineItemStockRule())->getConstraints();
static::assertEquals([
'operator' => [new NotBlank(),
new Choice([
Rule::OPERATOR_EQ,
Rule::OPERATOR_LTE,
Rule::OPERATOR_GTE,
Rule::OPERATOR_NEQ,
Rule::OPERATOR_GT,
Rule::OPERATOR_LT,
]),
],
static::assertTrue((new LineItemStockRule(Rule::OPERATOR_NEQ, 5))->match($lineItemScope));
static::assertTrue((new LineItemStockRule(Rule::OPERATOR_NEQ, 5))->match($cartScope));
static::assertTrue((new LineItemStockRule(Rule::OPERATOR_EMPTY, 5))->match($lineItemScope));
static::assertTrue((new LineItemStockRule(Rule::OPERATOR_EMPTY, 5))->match($cartScope));
}
public function testConstraintsIncludesOperatorAndStock(): void
{
$constraints = (new LineItemStockRule())->getConstraints();
static::assertEquals([
'operator' => [new NotBlank(),
new Choice([
Rule::OPERATOR_EQ,
Rule::OPERATOR_LTE,
Rule::OPERATOR_GTE,
Rule::OPERATOR_NEQ,
Rule::OPERATOR_GT,
Rule::OPERATOR_LT,
]),
],