Apicart\FQL\Tests\Generator\Native\RangeTest

Complexity

Total Complexity

9

Size/Duplication

Total Lines	90
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	visitWrongNodeDataprovider()	0	6	1
A	setUp()	0	3	1
A	testVisitWrongNodeFails()	0	4	1
A	testVisit()	0	3	1
A	visitDataprovider()	0	7	1
A	acceptDataprovider()	0	5	1
A	testAccepts()	0	3	1
A	testVisitUnknownRangeEndTypeFails()	0	8	1
A	testVisitUnknownRangeStartTypeFails()	0	8	1

<?php declare(strict_types = 1);

namespace Apicart\FQL\Tests\Generator\Native;

use Apicart\FQL\Generator\Common\AbstractVisitor;
use Apicart\FQL\Generator\Native\Range;
use Apicart\FQL\Token\Node\Mandatory;
use Apicart\FQL\Token\Node\Term;
use Apicart\FQL\Token\Token\Range as RangeToken;
use Apicart\FQL\Token\Token\Word;
use Apicart\FQL\Tokenizer\Tokenizer;
use Apicart\FQL\Value\AbstractNode;
use Apicart\FQL\Value\Token;
use LogicException;
use PHPUnit\Framework\TestCase;

final class RangeTest extends TestCase
{
    /**
     * @var AbstractVisitor
     */
    public $visitor;


    protected function setUp(): void
    {
        $this->visitor = new Range();
    }


    public function acceptDataprovider(): array
    {
        return [
            [true, new Term(new RangeToken('[a TO b]', 0, '', 'a', 'b', 'inclusive', 'inclusive'))],
            [false, new Term(new Word('word', 0, '', 'a'))],
        ];
    }


    /**
     * @dataProvider acceptDataprovider
     */
    public function testAccepts(bool $expected, AbstractNode $node): void
    {
        self::assertSame($expected, $this->visitor->accept($node));
    }


    public function visitDataprovider(): array
    {
        return [
            ['[a TO b]', new Term(new RangeToken('[a TO b]', 0, '', 'a', 'b', 'inclusive', 'inclusive'))],
            ['[a TO b}', new Term(new RangeToken('[a TO b}', 0, '', 'a', 'b', 'inclusive', 'exclusive'))],
            ['{a TO b}', new Term(new RangeToken('{a TO b}', 0, '', 'a', 'b', 'exclusive', 'exclusive'))],
            ['{a TO b]', new Term(new RangeToken('{a TO b]', 0, '', 'a', 'b', 'exclusive', 'inclusive'))],
        ];
    }


    /**
     * @dataProvider visitDataprovider
     */
    public function testVisit(string $expected, AbstractNode $node): void
    {
        self::assertSame($expected, $this->visitor->visit($node));
    }


    public function visitWrongNodeDataprovider(): array
    {
        $operand = $this->getMockForAbstractClass(AbstractNode::class);
        $token = new Token(Tokenizer::TOKEN_TERM, '', 0);

        return [[new Mandatory($operand, $token)], [new Term(new Word('word', 0, '', 'a'))]];
    }


    /**
     * @dataProvider visitWrongNodeDataprovider
     */
    public function testVisitWrongNodeFails(AbstractNode $node): void
    {
        $this->expectException(LogicException::class);
        $this->visitor->visit($node);
    }


    public function testVisitUnknownRangeStartTypeFails(): void
    {
        $token = new RangeToken('{a TO b}', 0, '', 'a', 'b', 'inclusive', 'inclusive');
        $token->setStartType('unknown');
        $node = new Term($token);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Range start type unknown is not supported');
        $this->visitor->visit($node);
    }


    public function testVisitUnknownRangeEndTypeFails(): void
    {
        $token = new RangeToken('{a TO b}', 0, '', 'a', 'b', 'inclusive', 'inclusive');
        $token->setEndType('unknown');
        $node = new Term($token);
        $this->expectException(LogicException::class);
        $this->expectExceptionMessage('Range end type unknown is not supported');
        $this->visitor->visit($node);
    }

}