PhpSpellcheck\Tests\Spellchecker\IspellTest

Complexity

Total Complexity

15

Size/Duplication

Total Lines	98
Duplicated Lines	0 %

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	testBadCheckRequest()	0	4	1
A	assertWorkingSupportedLanguages()	0	7	2
A	testGetSupportedLanguagesFromFakeBinaries()	0	3	1
A	assertWorkingSpellcheck()	0	24	1
A	realShellPath()	0	7	3
A	getTextInput()	0	3	1
A	testGetSupportedLanguagesFromRealBinaries()	0	3	1
A	getFakeDicts()	0	3	1
A	testSpellcheckFromRealBinaries()	0	3	1
A	realBinaryPath()	0	7	2
A	testSpellcheckFromFakeBinaries()	0	3	1

<?php

declare(strict_types=1);

namespace PhpSpellcheck\Tests\Spellchecker;

use PhpSpellcheck\Exception\ProcessHasErrorOutputException;
use PhpSpellcheck\Misspelling;
use PhpSpellcheck\Spellchecker\Ispell;
use PhpSpellcheck\Tests\TextTest;
use PhpSpellcheck\Utils\CommandLine;
use PhpSpellcheck\Utils\TextEncoding;
use PHPUnit\Framework\TestCase;

class IspellTest extends TestCase
{
    private const FAKE_BINARIES_PATH = __DIR__ . '/../Fixtures/Ispell/bin/ispell.sh';
    public const FAKE_BAD_BINARIES_PATH = __DIR__ . '/../Fixtures/Ispell/bin/empty_output.sh';

    public function testSpellcheckFromFakeBinaries()
    {
        $this->assertWorkingSpellcheck(self::FAKE_BINARIES_PATH);
    }

    public function testGetSupportedLanguagesFromFakeBinaries()
    {
        $this->assertWorkingSupportedLanguages(self::FAKE_BINARIES_PATH, self:: FAKE_BINARIES_PATH);
    }

    public function testBadCheckRequest()
    {
        $this->expectException(ProcessHasErrorOutputException::class);
        Ispell::create(self::FAKE_BAD_BINARIES_PATH)->check('bla');
    }

    /**
     * @group integration
     */
    public function testSpellcheckFromRealBinaries()
    {
        $this->assertWorkingSpellcheck(self::realBinaryPath());
    }

    /**
     * @group integration
     */
    public function testGetSupportedLanguagesFromRealBinaries()
    {
        $this->assertWorkingSupportedLanguages(self::realBinaryPath(), self::realShellPath());
    }

    public function getTextInput()
    {
        return TextTest::CONTENT_STUB;
    }

    public function getFakeDicts()
    {
        return explode(PHP_EOL, file_get_contents(__DIR__ . '/../Fixtures/Ispell/dicts.txt'));
    }

    private function assertWorkingSpellcheck($binaries)
    {
        $ispell = new Ispell(new CommandLine($binaries));
        /** @var Misspelling[] $misspellings */
        $misspellings = iterator_to_array(
            $ispell->check(
                $this->getTextInput(),
                ['american'],
                ['ctx'],
                TextEncoding::UTF8
            )
        );

        $this->assertSame($misspellings[0]->getContext(), ['ctx']);
        $this->assertSame($misspellings[0]->getWord(), 'Tigr');
        $this->assertSame($misspellings[0]->getOffset(), 0);
        $this->assertSame($misspellings[0]->getLineNumber(), 1);
        $this->assertNotEmpty($misspellings[0]->getSuggestions());

        $this->assertSame($misspellings[1]->getContext(), ['ctx']);
        $this->assertSame($misspellings[1]->getWord(), 'theforests');
        $this->assertSame($misspellings[1]->getOffset(), 3);
        $this->assertSame($misspellings[1]->getLineNumber(), 2);
        $this->assertNotEmpty($misspellings[1]->getSuggestions());
    }

    public function assertWorkingSupportedLanguages($binaries, $shellEntryPoint = null)
    {
        $ispell = new Ispell(
            new CommandLine($binaries),
            $shellEntryPoint !== null ? new CommandLine($shellEntryPoint) : null
        );
        $this->assertNotFalse(array_search('american', $ispell->getSupportedLanguages()));

It seems like array_search('american', $ispell->getSupportedLanguages()) can also be of type integer and string; however, parameter $condition of PHPUnit\Framework\Assert::assertNotFalse() does only seem to accept boolean, maybe add an additional type check?

    }

    public static function realBinaryPath(): string
    {
        if (getenv('ISPELL_BINARY_PATH') === false) {
            throw new \RuntimeException('"ISPELL_BINARY_PATH" env must be set to find the executable to run tests on');
        }

        return getenv('ISPELL_BINARY_PATH');
    }

    public static function realShellPath(): ?string
    {
        if (getenv('ISPELL_SHELL_PATH') === false) {
            throw new \RuntimeException('"ISPELL_SHELL_PATH" env must be set to find the executable to run tests on');
        }

        return getenv('ISPELL_SHELL_PATH') ? getenv('ISPELL_SHELL_PATH') : null;
    }
}