ContainerTraitTest::testPut() - Code Metrics - Inspection of "Wip" - Jagepard/Rudra-Container - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#9)

by Korotkov
created 2018-05-08 12:50 UTC
ContainerTraitTest::testPut() A

↳ Parent: ContainerTraitTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	5
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	3
nc	1
nop	0
dl	0
loc	5
rs	9.4285
c	0
b	0
f	0
<?php

declare(strict_types=1);

/**
 * @author    : Korotkov Danila <[email protected]>
 * @copyright Copyright (c) 2016, Korotkov Danila
 * @license   http://www.gnu.org/licenses/gpl.html GNU GPLv3.0
 *
 *  phpunit src/tests/ContainerTraitTest --coverage-html src/tests/coverage-html
 */

namespace Rudra\Tests;

use PHPUnit\Framework\TestCase as PHPUnit_Framework_TestCase;
use Rudra\ContainerInterface;
use Rudra\Container;
use Rudra\Tests\Stub\ClassWithContainerTrait;
use Rudra\Tests\Stub\ClassWithDefaultParameters;
use Rudra\Tests\Stub\ClassWithoutConstructor;
use Rudra\Tests\Stub\ClassWithoutParameters;

/**
 * Class ContainerTraitTest
 */
class ContainerTraitTest extends PHPUnit_Framework_TestCase
{

    /**
     * @var ClassWithContainerTrait
     */
    protected $stub;

    /**
     * @var string
     */
    protected $stubNamespace = 'Rudra\\Tests\\Stub\\';

    protected function setUp(): void
    {
        Container::app()->setBinding(ContainerInterface::class, Container::$app);

        $app = [
            'contracts' => [
                ContainerInterface::class => Container::$app
            ],

            'services' => [
                'validation' => [ClassWithoutConstructor::class],
                'redirect'   => [ClassWithoutParameters::class],
                'db'         => [ClassWithDefaultParameters::class, ['param' => '123']],
            ]
        ];

        Container::$app->setServices($app);

        $this->stub = new ClassWithContainerTrait(Container::$app);
    }

    public function testValidation(): void
    {
        $this->assertInstanceOf(ClassWithoutConstructor::class, $this->getStub()->validation());
    }

    public function testRedirect(): void
    {
        $this->assertInstanceOf(ClassWithoutParameters::class, $this->getStub()->redirect());
    }

    public function testDb(): void
    {
        $this->assertInstanceOf(ClassWithDefaultParameters::class, $this->getStub()->db());
    }

    public function testNew(): void
    {
        $newClassWithoutConstructor = $this->getStub()->new(ClassWithoutConstructor::class);
        $this->assertInstanceOf(ClassWithoutConstructor::class, $newClassWithoutConstructor);
    }

    public function testSetPagination(): void
    {
        $this->getMockBuilder('Rudra\Pagination')->getMock();
        $this->getStub()->setPagination(['id' => 1]);
        $this->assertInstanceOf('Rudra\Pagination', $this->getStub()->pagination());
    }

    public function testPost(): void
    {
        Container::$app->setPost(['key' => 'value']);
                         setPost(['key' => 'value']);
        $this->assertEquals('value', $this->getStub()->post('key'));
    }

    public function testPut(): void
    {
        Container::$app->setPut(['key' => 'value']);
                         setPut(['key' => 'value']);
        $this->assertTrue($this->getStub()->container()->hasPut('key'));
        $this->assertTrue($this->getStub()->container()->/** @scrutinizer ignore-call */ hasPut('key'));
        $this->assertEquals('value', $this->getStub()->container()->getPut('key'));
        $this->assertEquals('value', $this->getStub()->container()->/** @scrutinizer ignore-call */ getPut('key'));
    }

    public function testPatch(): void
    {
        Container::$app->setPatch(['key' => 'value']);
                         setPatch(['key' => 'value']);
        $this->assertTrue($this->getStub()->container()->hasPatch('key'));
        $this->assertTrue($this->getStub()->container()->/** @scrutinizer ignore-call */ hasPatch('key'));
        $this->assertEquals('value', $this->getStub()->container()->getPatch('key'));
        $this->assertEquals('value', $this->getStub()->container()->/** @scrutinizer ignore-call */ getPatch('key'));
    }

    public function testDelete(): void
    {
        Container::$app->setDelete(['key' => 'value']);
                         setDelete(['key' => 'value']);
        $this->assertTrue($this->getStub()->container()->hasDelete('key'));
        $this->assertTrue($this->getStub()->container()->/** @scrutinizer ignore-call */ hasDelete('key'));
        $this->assertEquals('value', $this->getStub()->container()->getDelete('key'));
        $this->assertEquals('value', $this->getStub()->container()->/** @scrutinizer ignore-call */ getDelete('key'));
    }

    public function testSessionData(): void
    {
        $this->getStub()->setSession('key', 'value');
        $this->getStub()->setSession('subKey', 'value', 'subSet');
        $this->getStub()->setSession('increment', 'value', 'increment');
        $this->assertEquals('value', Container::$app->getSession('key'));
        $this->assertEquals('value', Container::$app->/** @scrutinizer ignore-call */ getSession('key'));
        $this->assertEquals('value', Container::$app->getSession('subKey', 'subSet'));
        $this->assertEquals('value', Container::$app->getSession('increment', '0'));
        $this->assertNull($this->getStub()->unsetSession('key'));
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        $this->assertNull($this->getStub()->unsetSession('subKey', 'subSet'));
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
        $this->assertFalse(Container::$app->hasSession('key'));
        $this->assertFalse(Container::$app->/** @scrutinizer ignore-call */ hasSession('key'));
        $this->assertFalse(Container::$app->hasSession('subKey', 'subSet'));
    }

    public function testConfig(): void
    {
        Container::$app->setConfig(['key' => ['subKey' => 'value']]);
                         setConfig(['key' => ['subKey' => 'value']]);

        $this->assertInternalType('array', Container::$app->config('key'));
        $this->assertInternalType('array', Container::$app->/** @scrutinizer ignore-call */ config('key'));
        $this->assertEquals('value', Container::$app->config('key', 'subKey'));
    }

    /**
     * @runInSeparateProcess
     */
    public function testJsonResponse(): void
    {
        $data = ['key' => ['subKey' => 'value']];

        ob_start();
        Container::$app->jsonResponse($data);
                         jsonResponse($data);
        $json = ob_get_clean();

        $this->assertEquals(json_encode($data), $json);
    }

    /**
     * @return ClassWithContainerTrait
     */
    public function getStub(): ClassWithContainerTrait
    {
        return $this->stub;
    }
}

Jagepard / Rudra-Container

Pull Request — master (#9)

ContainerTraitTest::testPut() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
