ArgumentCompilerTest::shouldGetUploadedFile() - Code Metrics - Inspection of "fixed tests" - addiks/symfony_generics - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b03604...27d676 )

by Gerrit

created 2019-04-15 16:45 UTC

ArgumentCompilerTest::shouldGetUploadedFile() A

↳ Parent: ArgumentCompilerTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	31
rs	9.424
c	0
b	0
f	0
cc	1
nc	1
nop	0

<?php
/**
 * Copyright (C) 2017  Gerrit Addiks.
 * This package (including this file) was released under the terms of the GPL-3.0.
 * You should have received a copy of the GNU General Public License along with this program.
 * If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
 * @license GPL-3.0
 * @author Gerrit Addiks <[email protected]>
 */

namespace Addiks\SymfonyGenerics\Tests\Unit\Services;

use PHPUnit\Framework\TestCase;
use Addiks\SymfonyGenerics\Services\ArgumentCompiler;
use Psr\Container\ContainerInterface;
use Addiks\SymfonyGenerics\Services\EntityRepositoryInterface;
use ReflectionMethod;
use Symfony\Component\HttpFoundation\Request;
use ReflectionParameter;
use ReflectionType;
use stdClass;
use InvalidArgumentException;
use Serializable;
use Addiks\SymfonyGenerics\Tests\Unit\Services\SampleService;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
use Symfony\Component\HttpFoundation\File\UploadedFile;
use Symfony\Component\HttpFoundation\FileBag;

final class ArgumentCompilerTest extends TestCase
{

    /**
     * @var ArgumentCompiler
     */
    private $argumentCompiler;

    /**
     * @var ContainerInterface
     */
    private $container;

    /**
     * @var EntityManagerInterface
     */
    private $entityManager;

    public function setUp()
    {
        $this->container = $this->createMock(ContainerInterface::class);

        $this->entityManager = $this->createMock(EntityManagerInterface::class);


        $this->argumentCompiler = new ArgumentCompiler($this->container, $this->entityManager);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    /**
     * @test
     */
    public function shouldBuildArguments()
    {
        /** @var Request $request */
        $request = $this->createMock(Request::class);
        $request->method('get')->will($this->returnValueMap([

            ['reqFoo', null, 'ipsum'],
        ]));

        $someObject = new stdClass();

        /** @var Serializable $someService */
        $someService = $this->createMock(Serializable::class);
        $someService->method('serialize')->willReturn($someObject);

        $this->container->method('get')->will($this->returnValueMap([

            ['some.service', $someService],
        ]));

        /** @var array<string, mixed> $expectedRouteArguments */
        $expectedRouteArguments = array(
            'foo' => 'ipsum',
            'bar' => $someObject
        );

        /** @var array<string, mixed> $actualRouteArguments */
        $actualRouteArguments = $this->argumentCompiler->buildArguments([
            'foo' => '$reqFoo',
            'bar' => '@some.service::serialize',
        ], $request);

        $this->assertEquals($expectedRouteArguments, $actualRouteArguments);
    }

    /**
     * @test
     */
    public function shouldBuildCallArguments()
    {
        /** @var ReflectionMethod $methodReflection */
        $methodReflection = $this->createMock(ReflectionMethod::class);

        /** @var ReflectionParameter $parameterFooReflection */
        $parameterFooReflection = $this->createMock(ReflectionParameter::class);
        $parameterFooReflection->method('getName')->willReturn("foo");

        /** @var ReflectionParameter $parameterBarReflection */
        $parameterBarReflection = $this->createMock(ReflectionParameter::class);
        $parameterBarReflection->method('getName')->willReturn("bar");

        /** @var ReflectionParameter $parameterBazReflection */
        $parameterBazReflection = $this->createMock(ReflectionParameter::class);
        $parameterBazReflection->method('getName')->willReturn("baz");

        /** @var ReflectionType $parameterType */
        $parameterType = $this->createMock(ReflectionType::class);
        $parameterType->method('__toString')->willReturn(SampleService::class);

        /** @var ReflectionParameter $parameterFazReflection */
        $parameterFazReflection = $this->createMock(ReflectionParameter::class);
        $parameterFazReflection->method('getName')->willReturn("faz");
        $parameterFazReflection->method('hasType')->willReturn(true);
        $parameterFazReflection->method('getType')->willReturn($parameterType);

        $methodReflection->method("getParameters")->willReturn([
            $parameterFooReflection,
            $parameterBarReflection,
            $parameterBazReflection,
            $parameterFazReflection
        ]);

        /** @var Request $request */
        $request = $this->createMock(Request::class);
        $request->method('get')->will($this->returnValueMap([

            ['lorem', null, 'ipsum'],
            ['bar', null, 'blah'],
        ]));

        /** @var array<string, mixed> $argumentsConfiguration */
        $argumentsConfiguration = array(
            "foo" => '$lorem',
            "baz" => '@some.service',
            "faz" => [
                'service-id' => 'some.service',
                'method' => 'someCall',
                'arguments' => [
                    'foo' => '$lorem'
                ]
            ]
        );

        $someService = new SampleService();

        $this->container->method('get')->will($this->returnValueMap([

            ['some.service', $someService],
        ]));

        $this->entityManager->expects($this->once())->method('find')->with(

            $this->equalTo(SampleService::class),
            $this->equalTo('ipsum')
        )->willReturn($someService);

        /** @var array<int, mixed> $expectedCallArguments */
        $expectedCallArguments = array(
            'ipsum',
            'blah',
            $someService,
            $someService
        );

        /** @var array<int, mixed> $actualCallArguments */
        $actualCallArguments = $this->argumentCompiler->buildCallArguments(
            $methodReflection,
            $argumentsConfiguration,
            $request
        );

        $this->assertEquals($expectedCallArguments, $actualCallArguments);
        $this->assertEquals('ipsum', $someService->foo);
    }

    /**
     * @test
     */
    public function shouldRejectNonExistingFactoryMethod()
    {
        $this->expectException(InvalidArgumentException::class);

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        /** @var Serializable $someService */
        $someService = $this->createMock(Serializable::class);

        $this->container->method('get')->will($this->returnValueMap([

            ['some.service', $someService],
        ]));

        $this->argumentCompiler->buildArguments([
            'foo' => '$reqFoo',
            'bar' => '@some.service::doesNotExist',
        ], $request);
    }

    /**
     * @test
     */
    public function shouldRejectNonExistingAdditionalDataKey()

    {
        $this->expectException(InvalidArgumentException::class);

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $this->argumentCompiler->buildArguments([
            'foo' => '%keyFoo',
        ], $request);
    }

    /**
     * @test
     */
    public function shouldGetAdditionalDataKey()

    {
        /** @var Request $request */
        $request = $this->createMock(Request::class);

        /** @var array $actualResult */
        $actualResult = $this->argumentCompiler->buildArguments([
            'foo' => '%keyFoo',
        ], $request, [
            'keyFoo' => 'bar'
        ]);

        $this->assertEquals(['foo' => 'bar'], $actualResult);
    }

    /**
     * @test
     */
    public function shouldRejectMissingMethodOnAdditionalDataKey()

    {
        $this->expectException(InvalidArgumentException::class);

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $this->argumentCompiler->buildArguments([
            'foo' => '%keyFoo.doSomethingImpossible',
        ], $request, [
            'keyFoo' => $this->createMock(stdClass::class)
        ]);
    }

    /**
     * @test
     */
    public function shouldRejectMissingUploadedFile()

    {
        $this->expectException(InvalidArgumentException::class);

        /** @var Request $request */
        $request = $this->createMock(Request::class);
        $request->files = $this->createMock(FileBag::class);


        $this->argumentCompiler->buildArguments([
            'foo' => '$files.something_missing.content',
        ], $request);
    }

    /**
     * @test
     */
    public function shouldGetUploadedFile()
    {
        /** @var UploadedFile $file */
        $file = $this->createMock(UploadedFile::class);
        $file->method('getClientOriginalName')->willReturn('some-original-name');

        $file->method('getFilename')->willReturn('some-file-name');

        $file->method('getPathname')->willReturn('data://,some-content');

        $file->method('getMimeType')->willReturn('some-mime-type');


        /** @var Request $request */
        $request = $this->createMock(Request::class);
        $request->files = $this->createMock(FileBag::class);

        $request->files->expects($this->exactly(5))->method('get')->willReturn($file);

        /** @var array $actualResult */
        $actualResult = $this->argumentCompiler->buildArguments([
            'obj' => '$files.blah.object',
            'ogn' => '$files.blah.originalname',
            'fln' => '$files.blah.filename',
            'cnt' => '$files.blah.content',
            'mmt' => '$files.blah.mimetype',
        ], $request);

        $this->assertEquals([
            'obj' => $file,
            'ogn' => 'some-original-name',
            'fln' => 'some-file-name',
            'cnt' => 'some-content',
            'mmt' => 'some-mime-type',
        ], $actualResult);
    }

    /**
     * @test
     */
    public function shouldGetRequestPayload()
    {
        /** @var Request $request */
        $request = $this->createMock(Request::class);
        $request->expects($this->once())->method('getContent')->with(

            $this->equalTo(false)
        );

        $this->argumentCompiler->buildArguments([
            'foo' => '$',
        ], $request);
    }

    /**
     * @test
     */
    public function shouldResolveLiteralString()

    {
        /** @var Request $request */
        $request = $this->createMock(Request::class);

        /** @var array $actualResult */
        $actualResult = $this->argumentCompiler->buildArguments([
            'foo' => '\'bar\'',
        ], $request);

        $this->assertEquals(['foo' => 'bar'], $actualResult);
    }

    /**
     * @test
     */
    public function shouldThrowExceptionWhenFetchingUnknownService()
    {
        $this->expectException(InvalidArgumentException::class);

        /** @var ReflectionMethod $methodReflection */
        $methodReflection = $this->createMock(ReflectionMethod::class);

        /** @var ReflectionParameter $parameterFazReflection */
        $parameterFazReflection = $this->createMock(ReflectionParameter::class);
        $parameterFazReflection->method('getName')->willReturn("faz");

        $methodReflection->method("getParameters")->willReturn([
            $parameterFazReflection
        ]);

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        /** @var array<string, mixed> $argumentsConfiguration */
        $argumentsConfiguration = array(
            "faz" => [
                'service-id' => 'some.non-existing.service',
            ]
        );

        /** @var array<int, mixed> $actualCallArguments */
        $actualCallArguments = $this->argumentCompiler->buildCallArguments(
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $methodReflection,
            $argumentsConfiguration,
            $request
        );
    }

    /**
     * @test
     */
    public function shouldThrowExceptionWhenCallArgumentIsMissing()
    {
        $this->expectException(InvalidArgumentException::class);
        $this->expectExceptionMessage("Missing argument 'foo' for the call to 'someCall'!");

        /** @var ReflectionMethod $methodReflection */
        $methodReflection = $this->createMock(ReflectionMethod::class);

        /** @var ReflectionParameter $parameterFazReflection */
        $parameterFazReflection = $this->createMock(ReflectionParameter::class);
        $parameterFazReflection->method('getName')->willReturn("faz");

        $methodReflection->method("getParameters")->willReturn([
            $parameterFazReflection
        ]);

        /** @var Request $request */
        $request = $this->createMock(Request::class);

        $someService = new SampleService();

        $this->container->method('get')->will($this->returnValueMap([

            ['some.service', $someService],
        ]));

        /** @var array<string, mixed> $argumentsConfiguration */
        $argumentsConfiguration = array(
            "faz" => [
                'service-id' => 'some.service',
                'method' => 'someCall',
            ]
        );

        /** @var array<int, mixed> $actualCallArguments */
        $actualCallArguments = $this->argumentCompiler->buildCallArguments(
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
            $methodReflection,
            $argumentsConfiguration,
            $request
        );
    }

}


1			<?php
2			/**
3			* Copyright (C) 2017 Gerrit Addiks.
4			* This package (including this file) was released under the terms of the GPL-3.0.
5			* You should have received a copy of the GNU General Public License along with this program.
6			* If not, see <http://www.gnu.org/licenses/> or send me a mail so i can send you a copy.
7			* @license GPL-3.0
8			* @author Gerrit Addiks <[email protected]>
9			*/
10
11			namespace Addiks\SymfonyGenerics\Tests\Unit\Services;
12
13			use PHPUnit\Framework\TestCase;
14			use Addiks\SymfonyGenerics\Services\ArgumentCompiler;
15			use Psr\Container\ContainerInterface;
16			use Addiks\SymfonyGenerics\Services\EntityRepositoryInterface;
17			use ReflectionMethod;
18			use Symfony\Component\HttpFoundation\Request;
19			use ReflectionParameter;
20			use ReflectionType;
21			use stdClass;
22			use InvalidArgumentException;
23			use Serializable;
24			use Addiks\SymfonyGenerics\Tests\Unit\Services\SampleService;
25			use Doctrine\ORM\EntityManagerInterface;
26			use Symfony\Component\DependencyInjection\ParameterBag\ParameterBagInterface;
27			use Symfony\Component\HttpFoundation\File\UploadedFile;
28			use Symfony\Component\HttpFoundation\FileBag;
29
30			final class ArgumentCompilerTest extends TestCase
31			{
32
33			/**
34			* @var ArgumentCompiler
35			*/
36			private $argumentCompiler;
37
38			/**
39			* @var ContainerInterface
40			*/

addiks / symfony_generics

Push — master ( b03604...27d676 )

ArgumentCompilerTest::shouldGetUploadedFile() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like