UrlReplacementTest

Complexity

Total Complexity

29

Size/Duplication

Total Lines	160
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

24 Methods

Rating	Name	Duplication	Size	Complexity
A	testToString()	0	7	1
A	testFromString()	0	4	1
A	testFromStringInvalidString()	0	9	2
A	testToStringAndFromStringWithInsert()	0	4	1
A	testToStringAndFromStringWithSwap()	0	4	1
A	testToStringAndFromStringWithDash()	0	4	1
A	testParseQueryString()	0	4	1
A	testParseQueryStringWithInserts()	0	4	1
A	testParseQueryStringWithDash()	0	4	1
A	testParseQueryStringWithDash2()	0	4	1
A	testParseQueryStringWithDashMismatch()	0	9	2
A	testSimpleApplyReplace()	0	4	1
A	testSimpleApplyReplaceAtStart()	0	4	1
A	testSimpleApplyReplaceAtStartBadIndex()	0	4	1
A	testSimpleApplyReplaceAtEnd()	0	4	1
A	testSimpleApplyReplaceAtEndBadIndex()	0	4	1
A	testSimpleApplyInsertAtEnd()	0	4	1
A	testSimpleApplyInsertAtStart()	0	4	1
A	testSimpleApplyInsertAtStartBadIndex()	0	4	1
A	testSimpleApplyInsertAtEndBadIndex()	0	4	1
A	assertBadApply()	0	6	1
A	assertApply()	0	6	1
A	assertParseQuery()	0	20	4
A	assertToAndFromString()	0	8	1

<?php

use GroupByInc\API\Url\UrlReplacement;
use GroupByInc\API\Url\OperationType;
use GroupByInc\API\Url\ParserException;
use GroupByInc\API\Util\StringBuilder;

class UrlReplacementTest extends PHPUnit_Framework_TestCase

PSR1 recommends that each class must be in a namespace of at least one level to avoid collisions.

{

    public function testToString()
    {
        $replacement = new UrlReplacement(2, "a", OperationType::Swap);
        $this->assertEquals("2-a", $replacement);
        $replacement = new UrlReplacement(20, "%", OperationType::Insert);
        $this->assertEquals("i20-%", $replacement);
    }

    public function testFromString()
    {
        UrlReplacement::fromString("2-a");
    }

    public function testFromStringInvalidString()
    {
        try {
            UrlReplacement::fromString("a2-a");
            $this->fail("Exception not thrown");
        } catch (ParserException $e) {
            // expected
        }
    }

    public function testToStringAndFromStringWithInsert()
    {
        $this->assertToAndFromString("i2-/");
    }

    public function testToStringAndFromStringWithSwap()
    {
        $this->assertToAndFromString("35-9");
    }

    public function testToStringAndFromStringWithDash()
    {
        $this->assertToAndFromString("35--");
    }

    public function testParseQueryString()
    {
        $this->assertParseQuery("2-a", "3-b", "4-c");
    }

    public function testParseQueryStringWithInserts()
    {
        $this->assertParseQuery("2-a", "i3-b", "4-c");
    }

    public function testParseQueryStringWithDash()
    {
        $this->assertParseQuery("2--", "i3-b", "4-c");
    }

    public function testParseQueryStringWithDash2()
    {
        $this->assertParseQuery("2--", "i3-b", "4--");
    }

    public function testParseQueryStringWithDashMismatch()
    {
        try {
            UrlReplacement::parseQueryString("2-a-i3-b--4-c");
            $this->fail("Exception not thrown");
        } catch (ParserException $e) {
            // expected
        }
    }

    public function testSimpleApplyReplace()
    {
        $this->assertApply("avc123", "abc123", new UrlReplacement(1, "b", OperationType::Swap));
    }

    public function testSimpleApplyReplaceAtStart()
    {
        $this->assertApply("zbc123", "abc123", new UrlReplacement(0, "a", OperationType::Swap));
    }

    public function testSimpleApplyReplaceAtStartBadIndex()
    {
        $this->assertBadApply("zbc123", new UrlReplacement(-1, "a", OperationType::Swap));
    }

    public function testSimpleApplyReplaceAtEnd()
    {
        $this->assertApply("abc124", "abc123", new UrlReplacement(5, "3", OperationType::Swap));
    }

    public function testSimpleApplyReplaceAtEndBadIndex()
    {
        $this->assertBadApply("abc124", new UrlReplacement(6, "3", OperationType::Swap));
    }

    public function testSimpleApplyInsertAtEnd()
    {
        $this->assertApply("abc12", "abc123", new UrlReplacement(5, "3", OperationType::Insert));
    }

    public function testSimpleApplyInsertAtStart()
    {
        $this->assertApply("bc123", "abc123", new UrlReplacement(0, "a", OperationType::Insert));
    }

    public function testSimpleApplyInsertAtStartBadIndex()
    {
        $this->assertBadApply("bc123", new UrlReplacement(-1, "a", OperationType::Insert));
    }

    public function testSimpleApplyInsertAtEndBadIndex()
    {
        $this->assertBadApply("abc12", new UrlReplacement(6, "3", OperationType::Insert));
    }

    private function assertBadApply($input, UrlReplacement $replacement)
    {
        $builder = new StringBuilder($input);
        $replacement->apply($builder, 0);
        $this->assertEquals($input, $builder);
    }

    private function assertApply($input, $expected, UrlReplacement $replacement)
    {
        $builder = new StringBuilder($input);
        $replacement->apply($builder, 0);
        $this->assertEquals($expected, $builder);
    }

    private function assertParseQuery()
    {
        $builder = new StringBuilder();
        $args = func_get_args();
        /** @var string $replacement */
        foreach ($args as $j => $replacement) {
            if ($builder->length() != 0) {
                $builder->append("-");
            }
            $builder->append($replacement);
        }

        $replacements = UrlReplacement::parseQueryString($builder->__toString());

        $this->assertEquals(strlen($replacement), count($replacements));

The variable $replacement seems to be defined by a foreach iteration on line 143. Are you sure the iterator is never empty, otherwise this variable is not defined?

        for ($i = 0; $i < count($replacements); $i++) {

It seems like you are calling the size function count() as part of the test condition. You might want to compute the size beforehand, and not on each iteration.

            $this->assertEquals($args[strlen($replacement) - ($i + 1)], $replacements[$i]->__toString());
        }
    }

    private function assertToAndFromString($replacementString)
    {
        $replacement1 = UrlReplacement::fromString($replacementString);
        $urlReplacementString = (string)$replacement1;
        $replacement2 = UrlReplacement::fromString($urlReplacementString);
        $this->assertEquals($replacement1, $replacement2);
        $this->assertEquals((string)$replacement2, $replacementString);
    }
}