stefk / JVal

use JVal\Context;

use JVal\Testing\ConstraintTestCase;

class AllOfConstraintTest extends ConstraintTestCase

{

    public function testNormalizeIfAllOfIsNotArray()

    {

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

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

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

    }

    public function testNormalizeThrowsIfAllOfIsEmpty()

    {

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

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

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

    }

    public function testNormalizeThrowsIfAllOfElementIsNotObject()

    {

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

        $schema = $this->loadSchema('invalid/allOf-element-not-object');

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

    }

    public function testNormalizeEnsureEverySubSchemaIsValid()

    {

        $schema = $this->loadSchema('valid/allOf-valid-sub-schemas');

        $walker = $this->mockWalker();

        $walker->expects($this->exactly(2))

            ->method('parseSchema')

            ->withConsecutive($schema->allOf[0], $schema->allOf[1]);

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

    }

    protected function getConstraint()

    {

        return new AllOfConstraint();

    }

    protected function getCaseFileNames()

    {

        return ['allOf'];

    }

}

use JVal\Context;

use JVal\Testing\ConstraintTestCase;

class AnyOfConstraintTest extends ConstraintTestCase

{

    public function testNormalizeIfAnyOfIsNotArray()

    {

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

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

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

    }

    public function testNormalizeThrowsIfAnyOfIsEmpty()

    {

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

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

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

    }

    public function testNormalizeThrowsIfAnyOfElementIsNotObject()

    {

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

        $schema = $this->loadSchema('invalid/anyOf-element-not-object');

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

    }

    public function testNormalizeEnsureEverySubSchemaIsValid()

    {

        $schema = $this->loadSchema('valid/anyOf-valid-sub-schemas');

        $walker = $this->mockWalker();

        $walker->expects($this->exactly(2))

            ->method('parseSchema')

            ->withConsecutive($schema->anyOf[0], $schema->anyOf[1]);

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

    }

    protected function getConstraint()

    {

        return new AnyOfConstraint();

    }

    protected function getCaseFileNames()

    {

        return ['anyOf'];

    }

}

use JVal\Context;

use JVal\Testing\ConstraintTestCase;

class OneOfConstraintTest extends ConstraintTestCase

{

    public function testNormalizeIfOneOfIsNotArray()

    {

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

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

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

    }

    public function testNormalizeThrowsIfOneOfIsEmpty()

    {

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

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

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

    }

    public function testNormalizeThrowsIfOneOfElementIsNotObject()

    {

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

        $schema = $this->loadSchema('invalid/oneOf-element-not-object');

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

    }

    public function testNormalizeEnsureEverySubSchemaIsValid()

    {

        $schema = $this->loadSchema('valid/oneOf-valid-sub-schemas');

        $walker = $this->mockWalker();

        $walker->expects($this->exactly(2))

            ->method('parseSchema')

            ->withConsecutive($schema->oneOf[0], $schema->oneOf[1]);

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

    }

    protected function getConstraint()

    {

        return new OneOfConstraint();

    }

    protected function getCaseFileNames()

    {

        return ['oneOf'];

    }

}