DaveLiddament\StaticAnalysisResultsBaseliner\Tests\Unit\Core\BaseLiner\BaseLineAnalysisResultTest

Complexity

Total Complexity

10

Size/Duplication

Total Lines	160
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	invalidArrayDataProvider()	0	29	1
A	testIsMatchDifferentLineNumber()	0	8	1
A	testIsMatchDifferentFileName()	0	8	1
A	testIsActualMatch()	0	5	1
A	testBuild()	0	8	1
A	setUp()	0	6	1
A	testIsMatchDifferentType()	0	5	1
A	testConvertToAndFromArray()	0	17	1
A	testInvalidArray()	0	4	1
A	createBaseLineResult()	0	11	1

<?php

declare(strict_types=1);

namespace DaveLiddament\StaticAnalysisResultsBaseliner\Tests\Unit\Core\BaseLiner;

use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\BaseLiner\BaseLineAnalysisResult;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\LineNumber;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\PreviousLocation;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\RelativeFileName;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\Severity;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Common\Type;
use DaveLiddament\StaticAnalysisResultsBaseliner\Domain\Utils\ArrayParseException;
use PHPUnit\Framework\TestCase;

final class BaseLineAnalysisResultTest extends TestCase
{
    private const FILE_NAME_1 = 'fileName1';
    private const FILE_NAME_2 = 'fileName2';
    private const LINE_NUMBER_1 = 1;
    private const LINE_NUMBER_2 = 2;
    private const TYPE_1 = 'TYPE_1';
    private const TYPE_2 = 'TYPE_2';
    private const MESSAGE_1 = 'MESSAGE_1';

    /**
     * @var RelativeFileName
     */
    private $relativeFileName;

    /**
     * @var LineNumber
     */
    private $lineNumber;

    /**
     * @var Type
     */
    private $type;

    /**
     * @var Severity
     */
    private $severity;

    protected function setUp(): void
    {
        $this->relativeFileName = new RelativeFileName(self::FILE_NAME_1);
        $this->lineNumber = new LineNumber(self::LINE_NUMBER_1);
        $this->type = new Type(self::TYPE_1);
        $this->severity = Severity::error();
    }

    public function testBuild(): void
    {
        $baseLineAnalysisResult = $this->createBaseLineResult();

        $this->assertSame($this->relativeFileName, $baseLineAnalysisResult->getFileName());
        $this->assertSame($this->lineNumber, $baseLineAnalysisResult->getLineNumber());
        $this->assertSame($this->type, $baseLineAnalysisResult->getType());
        $this->assertSame(self::MESSAGE_1, $baseLineAnalysisResult->getMessage());
    }

    public function testConvertToAndFromArray(): void
    {
        $originalResult = $this->createBaseLineResult();

        $asArray = $originalResult->asArray();
        $unserialisedBaseLineAnalysisResult = BaseLineAnalysisResult::fromArray($asArray);

        // Should not be identical objects
        $this->assertNotSame($this->relativeFileName, $unserialisedBaseLineAnalysisResult->getFileName());
        $this->assertNotSame($this->lineNumber, $unserialisedBaseLineAnalysisResult->getLineNumber());
        $this->assertNotSame($this->type, $unserialisedBaseLineAnalysisResult->getType());

        // Values should be the same though
        $this->assertTrue($this->relativeFileName->isEqual($unserialisedBaseLineAnalysisResult->getFileName()));
        $this->assertTrue($this->lineNumber->isEqual($unserialisedBaseLineAnalysisResult->getLineNumber()));
        $this->assertTrue($this->type->isEqual($unserialisedBaseLineAnalysisResult->getType()));
        $this->assertSame(self::MESSAGE_1, $unserialisedBaseLineAnalysisResult->getMessage());
    }

    public function testIsActualMatch(): void
    {
        $baseLineAnalysisResult = $this->createBaseLineResult();
        $location = PreviousLocation::fromFileNameAndLineNumber($this->relativeFileName, $this->lineNumber);
        $this->assertTrue($baseLineAnalysisResult->isMatch($location, new Type(self::TYPE_1)));
    }

    public function testIsMatchDifferentType(): void
    {
        $baseLineAnalysisResult = $this->createBaseLineResult();
        $location = PreviousLocation::fromFileNameAndLineNumber($this->relativeFileName, $this->lineNumber);
        $this->assertFalse($baseLineAnalysisResult->isMatch($location, new Type(self::TYPE_2)));
    }

    public function testIsMatchDifferentFileName(): void
    {
        $baseLineAnalysisResult = $this->createBaseLineResult();
        $previousLocation = PreviousLocation::fromFileNameAndLineNumber(
            new RelativeFileName(self::FILE_NAME_2),
            $this->lineNumber,
        );
        $this->assertFalse($baseLineAnalysisResult->isMatch($previousLocation, new Type(self::TYPE_1)));
    }

    public function testIsMatchDifferentLineNumber(): void
    {
        $baseLineAnalysisResult = $this->createBaseLineResult();
        $previousLocation = PreviousLocation::fromFileNameAndLineNumber(
            $this->relativeFileName,
            new LineNumber(self::LINE_NUMBER_2),
        );
        $this->assertFalse($baseLineAnalysisResult->isMatch($previousLocation, new Type(self::TYPE_1)));
    }

    /**
     * @return array<string,array{array<mixed>}>

The doc comment array<string,array{array<mixed>}> at position 6 could not be parsed: Expected ':' at position 6, but found 'array'.

     */
    public function invalidArrayDataProvider(): array
    {
        return [
            'missingLineNumber' => [
                [
                    'fileName' => self::FILE_NAME_1,
                    'type' => self::TYPE_1,
                    'message' => self::MESSAGE_1,
                ],
            ],
            'missingFileName' => [
                [
                    'lineNumber' => self::LINE_NUMBER_1,
                    'type' => self::TYPE_1,
                    'message' => self::MESSAGE_1,
                ],
            ],
            'missingType' => [
                [
                    'lineNumber' => self::LINE_NUMBER_1,
                    'fileName' => self::FILE_NAME_1,
                    'message' => self::MESSAGE_1,
                ],
            ],
            'missingMessage' => [
                [
                    'lineNumber' => self::LINE_NUMBER_1,
                    'fileName' => self::FILE_NAME_1,
                    'type' => self::TYPE_1,
                ],
            ],
        ];
    }

    /**
     * @dataProvider invalidArrayDataProvider
     *
     * @param array<mixed> $asArray
     */
    public function testInvalidArray(array $asArray): void
    {
        $this->expectException(ArrayParseException::class);
        BaseLineAnalysisResult::fromArray($asArray);
    }

    private function createBaseLineResult(): BaseLineAnalysisResult
    {
        $baseLineAnalysisResult = BaseLineAnalysisResult::make(
            $this->relativeFileName,
            $this->lineNumber,
            $this->type,
            self::MESSAGE_1,
            $this->severity,
        );

        return $baseLineAnalysisResult;
    }
}