SixtyNine\Cloud\Tests\Filters\FiltersTest

Complexity

Total Complexity

7

Size/Duplication

Total Lines	91
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	9

Importance

Changes

0

4 Methods

Rating	Name	Duplication	Size	Complexity
A	testTest()	0	4	1
A	wordsProvider()	0	33	1
A	assertFilteredWord()	0	24	4
A	getWord()	0	4	1

<?php


namespace SixtyNine\Cloud\Tests\Filters;


use SixtyNine\Cloud\Filters\ChangeCase;
use SixtyNine\Cloud\Filters\FilterInterface;
use SixtyNine\Cloud\Filters\Filters;
use SixtyNine\Cloud\Filters\RemoveCharacters;
use SixtyNine\Cloud\Filters\RemoveNumbers;
use SixtyNine\Cloud\Filters\RemoveTrailingCharacters;
use SixtyNine\Cloud\Filters\RemoveWords;
use SixtyNine\Cloud\Model\Word;
use PHPUnit\Framework\TestCase;

class FiltersTest extends TestCase
{
    /**
     * @param $filter
     * @param $word
     * @param $expectedKeepWord
     * @param null $expectedWord
     * @dataProvider wordsProvider
     */
    public function testTest($filter, $word, $expectedKeepWord, $expectedWord = null)
    {
        $this->assertFilteredWord($filter, $word, $expectedKeepWord, $expectedWord);
    }

    /**
     * @return array
     */
    public function wordsProvider()
    {
        return array(
            [new ChangeCase(ChangeCase::LOWERCASE), 'foobar', true, 'foobar'],
            [new ChangeCase(ChangeCase::UPPERCASE), 'foobar', true, 'FOOBAR'],
            [new ChangeCase(ChangeCase::UCFIRST), 'foobar', true, 'Foobar'],
            [new RemoveWords(array('and')), 'foobar', true],
            [new RemoveWords(array('and')), 'and', false],
            [new RemoveNumbers(), '1234abcd5678', true, 'abcd'],
            [new RemoveNumbers(), '1234567890', true, ''],
            [new RemoveTrailingCharacters(), '1234', true, '1234'],
            [new RemoveTrailingCharacters(), '12345.', true, '12345'],
            [new RemoveTrailingCharacters(), '12345.,', true, '12345'],
            [new RemoveTrailingCharacters(), '12345!?', true, '12345'],
            [new RemoveTrailingCharacters(), '1234', true, '1234'],
            [new RemoveWords(), 'and', false],
            [new RemoveWords(), 'our', false],
            [new RemoveWords(), 'yours', false],
            [new RemoveWords(), 'such', false],
            [new RemoveWords(), 'some', true, 'some'],
            [new RemoveWords(), 'other', true, 'other'],
            [new RemoveWords(), 'words', true, 'words'],
            [new RemoveCharacters(), '12345', true, '12345'],
            [new RemoveCharacters(), '123?4', true, '1234'],
            [new RemoveCharacters(), '12345"', true, '12345'],
            [new RemoveCharacters(), '\'12345\'', true, '12345'],
            [new RemoveCharacters(), '?!1234!?', true, '1234'],
            [new RemoveTrailingCharacters(), '1234', true, '1234'],
            [new RemoveTrailingCharacters(), '12345.', true, '12345'],
            [new RemoveTrailingCharacters(), '12345,.', true, '12345'],
            [new RemoveTrailingCharacters(), '12345!?', true, '12345'],
        );
    }

    /**
     * @param FilterInterface $filter
     * @param string $word
     * @param bool $expectedKeepWord
     * @param null $expectedFiltered
     */
    protected function assertFilteredWord(FilterInterface $filter, $word, $expectedKeepWord, $expectedFiltered = null)
    {
        $filters = new Filters(array($filter));
        $filtered = $filters->apply($word);
        $filteredWord = $filter->filterWord($word);

        if ($expectedKeepWord) {
            if ($filtered !== '') {
                $this->assertTrue((bool)$filtered);
                $this->assertTrue((bool)$filteredWord);
            } else {
                $this->assertEquals('', $filtered);
                $this->assertEquals('', $filteredWord);
            }
        } else {
            $this->assertFalse($filtered, 'Expected the word to be filtered out');

It seems like $filtered defined by $filters->apply($word) on line 77 can also be of type string; however, PHPUnit\Framework\Assert::assertFalse() does only seem to accept boolean, maybe add an additional type check?

            $this->assertFalse($filter->keepWord($word));
        }

        if ($expectedFiltered) {
            $this->assertEquals($expectedFiltered, $filtered, 'Unexpected filtered value');
            $this->assertEquals($expectedFiltered, $filteredWord, 'Unexpected filtered word');
        }
    }

    /**
     * @param string $text
     * @return Word
     */
    protected function getWord($text)
    {
        return (new Word())->setText($text);
    }
}