stefk / JVal

use JVal\Context;

use JVal\Testing\ConstraintTestCase;

class MaximumConstraintTest extends ConstraintTestCase

{

    public function testNormalizeThrowsIfMaxNotPresent()

    {

        $this->expectConstraintException('MissingKeywordException', '', 'maximum');

        $schema = $this->loadSchema('invalid/maximum-not-present');

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

    }

    public function testNormalizeSetsExclusiveMaxToFalseIfNotPresent()

    {

        $schema = $this->loadSchema('valid/exclusiveMaximum-not-present');

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

        $this->assertObjectHasAttribute('exclusiveMaximum', $schema);

        $this->assertEquals(false, $schema->exclusiveMaximum);

    }

    public function testNormalizeThrowsIfMaximumIsNotANumber()

    {

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

        $schema = $this->loadSchema('invalid/maximum-not-number');

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

    }

    public function testNormalizeThrowsIfExclusiveMaximumIsNotABoolean()

    {

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

        $schema = $this->loadSchema('invalid/exclusiveMaximum-not-boolean');

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

    }

    protected function getConstraint()

    {

        return new MaximumConstraint();

    }

    protected function getCaseFileNames()

    {

        return ['maximum'];

    }

}

use JVal\Context;

use JVal\Testing\ConstraintTestCase;

class MinimumConstraintTest extends ConstraintTestCase

{

    public function testNormalizeThrowsIfMaxNotPresent()

    {

        $this->expectConstraintException('MissingKeywordException', '', 'minimum');

        $schema = $this->loadSchema('invalid/minimum-not-present');

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

    }

    public function testNormalizeSetsExclusiveMaxToFalseIfNotPresent()

    {

        $schema = $this->loadSchema('valid/exclusiveMinimum-not-present');

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

        $this->assertObjectHasAttribute('exclusiveMinimum', $schema);

        $this->assertEquals(false, $schema->exclusiveMinimum);

    }

    public function testNormalizeThrowsIfMinimumIsNotANumber()

    {

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

        $schema = $this->loadSchema('invalid/minimum-not-number');

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

    }

    public function testNormalizeThrowsIfExclusiveMinimumIsNotABoolean()

    {

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

        $schema = $this->loadSchema('invalid/exclusiveMinimum-not-boolean');

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

    }

    protected function getConstraint()

    {

        return new MinimumConstraint();

    }

    protected function getCaseFileNames()

    {

        return ['minimum'];

    }

}

use JVal\Context;

use JVal\Testing\ConstraintTestCase;

class RequiredConstraintTest extends ConstraintTestCase

{

    public function testNormalizeThrowsIfRequiredIsNotArray()

    {

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

        $schema = $this->loadSchema('invalid/required-not-array');

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

    }

    public function testNormalizeThrowsIfRequiredIsEmpty()

    {

        $this->expectConstraintException('EmptyArrayException', '/required');

        $schema = $this->loadSchema('invalid/required-empty');

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

    }

    public function testNormalizeThrowsIfRequiredPropertyIsNotString()

    {

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

        $schema = $this->loadSchema('invalid/required-property-not-string');

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

    }

    public function testNormalizeThrowsIfRequiredPropertyIsNotUnique()

    {

        $this->expectConstraintException('NotUniqueException', '/required');

        $schema = $this->loadSchema('invalid/required-property-not-unique');

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

    }

    protected function getConstraint()

    {

        return new RequiredConstraint();

    }

    protected function getCaseFileNames()

    {

        return ['required'];

    }

}