AbacaphiliacTest\Zend\Validator\JsonSchemaTest

Complexity

Total Complexity

13

Size/Duplication

Total Lines	148
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	1
Bugs	0	Features	1

13 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	23	1
A	testNotIsValidDueToUnspecifiedSchemaFile()	0	6	1
A	testNotIsValidDueToInvalidSchemaFile()	0	6	1
A	testNotIsValidDueToInvalidSyntax()	0	8	1
A	testIsValidEncodedJson()	0	6	1
A	testIsValidDecodedJson()	0	6	1
A	testNotIsValidDueToSchemaValidation()	0	8	1
A	testDefaultMessageFormat()	0	10	1
A	testSetFile()	0	10	1
A	testSetErrorKeys()	0	14	1
A	testSetMessagePrefix()	0	8	1
A	testSetMessageSuffix()	0	8	1
A	testSetMessageAttributeDelimiter()	0	8	1

<?php

namespace AbacaphiliacTest\Zend\Validator;

use Abacaphiliac\Zend\Validator\JsonSchema;
use org\bovigo\vfs\vfsStream;
use org\bovigo\vfs\vfsStreamFile;

class JsonSchemaTest extends \PHPUnit_Framework_TestCase
{
    /** @var vfsStreamFile */
    private $schema;
    
    /** @var JsonSchema */
    private $sut;

    protected function setUp()
    {
        parent::setUp();

        $this->schema = vfsStream::newFile('schema.json');

        $schemas = vfsStream::setup('schemas');
        $schemas->addChild($this->schema);

        file_put_contents($this->schema->url(), json_encode(array(
            '$schema' => 'http://json-schema.org/draft-04/schema#',
            'type' => 'object',
            'properties' => array(
                'Foo' => array(
                    'type' => 'string'
                ),
            ),
        )));

        $this->sut = new JsonSchema(array(
            'file' => $this->schema->url(),
        ));
    }

    /**
     * @expectedException \Zend\Validator\Exception\RuntimeException
     */
    public function testNotIsValidDueToUnspecifiedSchemaFile()
    {
        $this->sut->setFile(null);
        
        $this->sut->isValid('{"Foo":"Bar"}');
    }

    /**
     * @expectedException \Zend\Validator\Exception\RuntimeException
     */
    public function testNotIsValidDueToInvalidSchemaFile()
    {
        $this->sut->setFile(__FILE__);
        
        $this->sut->isValid('{"Foo":"Bar"}');
    }

    public function testNotIsValidDueToInvalidSyntax()
    {
        $actual = $this->sut->isValid('InvalidJsonString');

        self::assertFalse($actual);

        self::assertCount(1, $this->sut->getMessages());
    }
    
    public function testIsValidEncodedJson()
    {
        $actual = $this->sut->isValid('{"Foo":"Bar"}');

        self::assertTrue($actual);
    }
    
    public function testIsValidDecodedJson()
    {        
        $actual = $this->sut->isValid(json_decode('{"Foo":"Bar"}'));

        self::assertTrue($actual);
    }
    
    public function testNotIsValidDueToSchemaValidation()
    {
        $actual = $this->sut->isValid('{"Foo":1234}');

        self::assertFalse($actual);

        self::assertCount(1, $this->sut->getMessages());
    }
    
    public function testDefaultMessageFormat()
    {
        $actual = $this->sut->formatError(array(
            'property' => 'foo',
            'constraint' => 'bar',
            'message' => 'error',
        ));
        
        self::assertEquals('[property=foo] [constraint=bar] [message=error]', $actual);
    }
    
    public function testSetFile()
    {
        $sut = new JsonSchema();
        
        self::assertNull($sut->getFile());
        
        $sut->setFile($expected = $this->schema->url());
        
        self::assertEquals($expected, $sut->getFile());
    }
    
    public function testSetErrorKeys()
    {
        self::assertArraySubset(
            array('property', 'constraint', 'message'),
            $this->sut->getErrorKeys()
        );
        
        $this->sut->setErrorKeys(array('foo', 'bar'));

        self::assertArraySubset(
            array('foo', 'bar'),
            $this->sut->getErrorKeys()
        );
    }
    
    public function testSetMessagePrefix()
    {
        self::assertEquals('[', $this->sut->getMessagePrefix());
        
        $this->sut->setMessagePrefix($expected = '{');
        
        self::assertEquals($expected, $this->sut->getMessagePrefix());
    }
    
    public function testSetMessageSuffix()
    {
        self::assertEquals(']', $this->sut->getMessageSuffix());
        
        $this->sut->setMessageSuffix($expected = '}');
        
        self::assertEquals($expected, $this->sut->getMessageSuffix());
    }
    
    public function testSetMessageAttributeDelimiter()
    {
        self::assertEquals('] [', $this->sut->getMessageAttributeDelimiter());
        
        $this->sut->setMessageAttributeDelimiter($expected = '} {');
        
        self::assertEquals($expected, $this->sut->getMessageAttributeDelimiter());
    }
}