stefk / JVal

use JVal\Context;

use JVal\Testing\ConstraintTestCase;

class MaxItemsConstraintTest extends ConstraintTestCase

{

    public function testNormalizeThrowsIfMaxItemsIsNotAnInteger()

    {

        $this->expectConstraintException('InvalidTypeException', '/maxItems');

        $schema = $this->loadSchema('invalid/maxItems-not-integer');

        $this->getConstraint()->normalize($schema, new Context(), $this->mockWalker());

    }

    public function testNormalizeThrowsIfMaxItemsIsNotPositive()

    {

        $this->expectConstraintException('LessThanZeroException', '/maxItems');

        $schema = $this->loadSchema('invalid/maxItems-not-positive');

        $this->getConstraint()->normalize($schema, new Context(), $this->mockWalker());

    }

    protected function getConstraint()

    {

        return new MaxItemsConstraint();

    }

    protected function getCaseFileNames()

    {

        return ['maxItems'];

    }

}

use JVal\Context;

use JVal\Testing\ConstraintTestCase;

class MaxLengthConstraintTest extends ConstraintTestCase

{

    public function testNormalizeThrowsIfMaxLengthIsNotAnInteger()

    {

        $this->expectConstraintException('InvalidTypeException', '/maxLength');

        $schema = $this->loadSchema('invalid/maxLength-not-integer');

        $this->getConstraint()->normalize($schema, new Context(), $this->mockWalker());

    }

    public function testNormalizeThrowsIfMaxLengthIsNotPositive()

    {

        $this->expectConstraintException('LessThanZeroException', '/maxLength');

        $schema = $this->loadSchema('invalid/maxLength-not-positive');

        $this->getConstraint()->normalize($schema, new Context(), $this->mockWalker());

    }

    protected function getConstraint()

    {

        return new MaxLengthConstraint();

    }

    protected function getCaseFileNames()

    {

        return ['maxLength'];

    }

}

use JVal\Context;

use JVal\Testing\ConstraintTestCase;

class MaxPropertiesTest extends ConstraintTestCase

{

    public function testNormalizeThrowsIfMaxPropertiesIsNotAnInteger()

    {

        $this->expectConstraintException('InvalidTypeException', '/maxProperties');

        $schema = $this->loadSchema('invalid/maxProperties-not-integer');

        $this->getConstraint()->normalize($schema, new Context(), $this->mockWalker());

    }

    public function testNormalizeThrowsIfMaxPropertiesIsNotPositive()

    {

        $this->expectConstraintException('LessThanZeroException', '/maxProperties');

        $schema = $this->loadSchema('invalid/maxProperties-not-positive');

        $this->getConstraint()->normalize($schema, new Context(), $this->mockWalker());

    }

    protected function getConstraint()

    {

        return new MaxPropertiesConstraint();

    }

    protected function getCaseFileNames()

    {

        return ['maxProperties'];

    }

}

use JVal\Context;

use JVal\Testing\ConstraintTestCase;

class MinItemsConstraintTest extends ConstraintTestCase

{

    public function testNormalizeThrowsIfMinItemsIsNotAnInteger()

    {

        $this->expectConstraintException('InvalidTypeException', '/minItems');

        $schema = $this->loadSchema('invalid/minItems-not-integer');

        $this->getConstraint()->normalize($schema, new Context(), $this->mockWalker());

    }

    public function testNormalizeThrowsIfMinItemsIsNotPositive()

    {

        $this->expectConstraintException('LessThanZeroException', '/minItems');

        $schema = $this->loadSchema('invalid/minItems-not-positive');

        $this->getConstraint()->normalize($schema, new Context(), $this->mockWalker());

    }

    protected function getConstraint()

    {

        return new MinItemsConstraint();

    }

    protected function getCaseFileNames()

    {

        return ['minItems'];

    }

}

use JVal\Context;

use JVal\Testing\ConstraintTestCase;

class MinLengthConstraintTest extends ConstraintTestCase

{

    public function testNormalizeThrowsIfMinLengthIsNotAnInteger()

    {

        $this->expectConstraintException('InvalidTypeException', '/minLength');

        $schema = $this->loadSchema('invalid/minLength-not-integer');

        $this->getConstraint()->normalize($schema, new Context(), $this->mockWalker());

    }

    public function testNormalizeThrowsIfMinLengthIsNotPositive()

    {

        $this->expectConstraintException('LessThanZeroException', '/minLength');

        $schema = $this->loadSchema('invalid/minLength-not-positive');

        $this->getConstraint()->normalize($schema, new Context(), $this->mockWalker());

    }

    protected function getConstraint()

    {

        return new MinLengthConstraint();

    }

    protected function getCaseFileNames()

    {

        return ['minLength'];

    }

}

use JVal\Context;

use JVal\Testing\ConstraintTestCase;

class MinPropertiesConstraintTest extends ConstraintTestCase

{

    public function testNormalizeThrowsIfMinPropertiesIsNotAnInteger()

    {

        $this->expectConstraintException('InvalidTypeException', '/minProperties');

        $schema = $this->loadSchema('invalid/minProperties-not-integer');

        $this->getConstraint()->normalize($schema, new Context(), $this->mockWalker());

    }

    public function testNormalizeThrowsIfMinPropertiesIsNotPositive()

    {

        $this->expectConstraintException('LessThanZeroException', '/minProperties');

        $schema = $this->loadSchema('invalid/minProperties-not-positive');

        $this->getConstraint()->normalize($schema, new Context(), $this->mockWalker());

    }

    protected function getConstraint()

    {

        return new MinPropertiesConstraint();

    }

    protected function getCaseFileNames()

    {

        return ['minProperties'];

    }

}