LeagueTest\Uri\UriTemplate\TemplateTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	125
Duplicated Lines	23.2 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	testItCanBeInstantiatedWithAValidNotation()	0	5	1
A	providesValidNotation()	0	8	1
A	testItFailsToInstantiatedWithAnInvalidNotation()	0	6	1
A	providesInvalidNotation()	0	10	1
A	testSetState()	8	8	1
A	testGetVariableNames()	0	4	1
A	expectedVariableNames()	21	21	1
A	testExpandAcceptsOnlyStringAndStringableObject()	0	6	1
A	testItCanExpandVariables()	0	4	1
A	providesExpansion()	0	15	1

<?php

/**
 * League.Uri (https://uri.thephpleague.com)
 *
 * (c) Ignace Nyamagana Butera <nyamsprod@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

declare(strict_types=1);

namespace LeagueTest\Uri\UriTemplate;

use League\Uri\Exceptions\SyntaxError;
use League\Uri\UriTemplate\Template;
use League\Uri\UriTemplate\VariableBag;
use PHPUnit\Framework\TestCase;
use function var_export;

/**
 * @coversDefaultClass \League\Uri\UriTemplate\Template
 */
final class TemplateTest extends TestCase
{
    /**
     * @covers ::createFromString
     * @covers ::__construct
     * @covers ::toString
     *
     * @dataProvider providesValidNotation
     */
    public function testItCanBeInstantiatedWithAValidNotation(string $notation): void
    {
        $template = Template::createFromString($notation);
        self::assertSame($notation, $template->toString());
    }

    public function providesValidNotation(): iterable
    {
        return [
            'complex template' => ['http://example.com{+path}{/segments}{?query,more*,foo[]*}'],
            'template without expression' => ['foobar'],

        ];
    }

    /**
     * @covers ::createFromString
     *
     * @dataProvider providesInvalidNotation
     */
    public function testItFailsToInstantiatedWithAnInvalidNotation(string $notation): void
    {
        self::expectException(SyntaxError::class);

        Template::createFromString($notation);
    }

    public function providesInvalidNotation(): iterable
    {
        return [
            ['fooba{r'],
            ['fooba}r'],
            ['fooba}{r'],
            ['{foo{bar'],
            ['{foo}}bar'],
        ];
    }

    /**
     * @covers ::__set_state
     */
    public function testSetState(): void

This method seems to be duplicated in your project.

    {
        $notation = '{foo}{bar}';

        $template = Template::createFromString($notation);

        self::assertEquals($template, eval('return '.var_export($template, true).';'));
    }

    /**
     * @covers ::variableNames
     *
     * @dataProvider expectedVariableNames
     */
    public function testGetVariableNames(string $template, array $expected): void
    {
        self::assertSame($expected, Template::createFromString($template)->variableNames());
    }

    public function expectedVariableNames(): iterable

This method seems to be duplicated in your project.

    {
        return [
            [
                'template' => '',
                'expected' => [],
            ],
            [
                'template' => '{foo}{bar}',
                'expected' => ['foo', 'bar'],
            ],
            [
                'template' => '{foo}{foo:2}{+foo}',
                'expected' => ['foo'],
            ],
            [
                'template' => '{bar}{foo}',
                'expected' => ['bar', 'foo'],
            ],
        ];
    }

    /**
     * @covers ::createFromString
     */
    public function testExpandAcceptsOnlyStringAndStringableObject(): void
    {
        self::expectException(\TypeError::class);

        Template::createFromString(new \stdClass());
    }

    /**
     * @dataProvider providesExpansion
     */
    public function testItCanExpandVariables(string $notation, array $variables, string $expected): void
    {
        self::assertSame($expected, Template::createFromString($notation)->expand(new VariableBag($variables)));
    }

    public function providesExpansion(): iterable
    {
        return [
            'with variables' => [
                'notation' => 'foobar{var}',
                'variables' => ['var' => 'yolo'],
                'expected' => 'foobaryolo',
            ],
            'with no variables' => [
                'notation' => 'foobar',
                'variables' => [],
                'expected' => 'foobar',
            ],
        ];
    }
}