ContainerTest::testHas() - Code Metrics - Inspection of "Updated" - Jagepard/Rudra-Container - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 3e54b5...727765 )

by Korotkov

created 2018-05-08 18:48 UTC

ContainerTest::testHas() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	6
nc	1
nop	0
dl	0
loc	8
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/ContainerTest --coverage-html src/tests/coverage-html
 */

namespace Rudra\Tests;

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

/**
 * Class ContainerTest
 */
class ContainerTest extends PHPUnit_Framework_TestCase
{

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

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

    /**
     * Проверяем синглтон
     */
    public function testCallSingleton(): void
    {
        $this->assertInstanceOf(Container::class, Container::app());
        $this->assertInstanceOf(Container::class, $this->container);
    }

    public function testGet(): void
    {
        $this->assertTrue(empty($this->container->get()));
    }

    public function testSetServices(): void
    {
        $this->container->setServices([
            'contracts' => [
                ContainerInterface::class => $this->container
            ],

            'services' => [
                'CWC'  => [ClassWithoutConstructor::class],
                'CWP'  => [ClassWithoutParameters::class],
                'CWDP' => [ClassWithDefaultParameters::class, ['param' => '123']],
            ]
        ]);
        $this->assertInstanceOf(ClassWithoutConstructor::class, $this->container->get('CWC'));
        $this->assertInstanceOf(ClassWithoutParameters::class, $this->container->get('CWP'));
        $this->assertInstanceOf(ClassWithDefaultParameters::class, $this->container->get('CWDP'));
    }

    public function testSetRaw(): void
    {
        $this->container->set(ContainerTest::class, $this, 'raw');
        $this->assertInstanceOf(ContainerTest::class, $this->container->get(ContainerTest::class));
    }

    public function testGetArrayHasKey(): void
    {
        $this->assertArrayHasKey(ContainerTest::class, $this->container->get());
    }

    public function testIoCClassWithoutConstructor(): void
    {
        $newClassWithoutConstructor = $this->container->new(ClassWithoutConstructor::class);
        $this->assertInstanceOf(ClassWithoutConstructor::class, $newClassWithoutConstructor);

        $this->container->set('ClassWithoutConstructor', $newClassWithoutConstructor);
        $this->assertInstanceOf(ClassWithoutConstructor::class, $this->container->get('ClassWithoutConstructor'));
    }

    public function testIoCwithoutParameters(): void
    {
        $newClassWithoutParameters = $this->container->new(ClassWithoutParameters::class);
        $this->assertInstanceOf(ClassWithoutParameters::class, $newClassWithoutParameters);

        $this->container->set('ClassWithoutParameters', $newClassWithoutParameters);
        $this->assertInstanceOf(ClassWithoutParameters::class, $this->container->get('ClassWithoutParameters'));
    }

    public function testIoCwithDefaultParameters(): void
    {
        $newClassWithDefaultParameters = $this->container->new(ClassWithDefaultParameters::class);
        $this->assertInstanceOf(ClassWithDefaultParameters::class, $newClassWithDefaultParameters);

        $this->container->set('ClassWithDefaultParameters', $newClassWithDefaultParameters);
        $this->assertInstanceOf(ClassWithDefaultParameters::class, $this->container->get('ClassWithDefaultParameters'));
    }

    public function testIoCwithDependency(): void
    {
        $newClassWithDependency = $this->container->new(ClassWithDependency::class);
        $this->assertInstanceOf(ClassWithDependency::class, $newClassWithDependency);

        $this->container->set('ClassWithDependency', $newClassWithDependency);
        $this->assertInstanceOf(ClassWithDependency::class, $this->container->get('ClassWithDependency'));
    }

    public function testHas(): void
    {
        $this->assertTrue($this->container->has(ContainerTest::class));
        $this->assertTrue($this->container->has('ClassWithoutConstructor'));
        $this->assertTrue($this->container->has('ClassWithoutParameters'));
        $this->assertTrue($this->container->has('ClassWithDefaultParameters'));
        $this->assertTrue($this->container->has('ClassWithDependency'));
        $this->assertFalse($this->container->has('SomeClass'));
    }

    public function testSetParam(): void
    {
        $param = 'value';
        $this->container->setParam('ClassWithDependency', 'param', $param);
        $this->assertEquals($param, $this->container->getParam('ClassWithDependency', 'param'));
    }

    public function testHasParam(): void
    {
        $this->assertTrue($this->container->hasParam('ClassWithDependency', 'param'));
        $this->assertNull($this->container->hasParam('SomeClass', 'param'));
    }

    public function testFailureGetParam(): void
    {
        $this->assertNull($this->container->getParam('SomeClass', 'param'));
    }

    public function testGetData(): void
    {
        $this->container->setGet(['key' => 'value']);
        $this->assertEquals('value', $this->container->getGet('key'));
        $this->assertContains('value', $this->container->getGet());
        $this->assertTrue($this->container->hasGet('key'));
        $this->assertFalse($this->container->hasGet('false'));
    }

    public function testPostData(): void
    {
        $this->container->setPost(['key' => 'value']);
        $this->assertEquals('value', $this->container->getPost('key'));
        $this->assertContains('value', $this->container->getPost());
        $this->assertTrue($this->container->hasPost('key'));
        $this->assertFalse($this->container->hasPost('false'));
    }

    public function testServerData(): void
    {
        $this->container->setServer('key', 'value');
        $this->assertEquals('value', $this->container->getServer('key'));
        $this->assertArrayHasKey('key', $this->container->getServer());
    }

    public function testSessionData(): void
    {
        $this->container->setSession('key', 'value');
        $this->container->setSession('subKey', 'value', 'subSet');
        $this->container->setSession('increment', 'value', 'increment');
        $this->assertEquals('value', $this->container->getSession('key'));
        $this->assertEquals('value', $this->container->getSession('subKey', 'subSet'));
        $this->assertEquals('value', $this->container->getSession('increment', '0'));
        $this->assertTrue($this->container->hasSession('key'));
        $this->assertTrue($this->container->hasSession('subKey', 'subSet'));
        $this->assertNull($this->container->unsetSession('key'));
        $this->assertNull($this->container->unsetSession('subKey', 'subSet'));
        $this->assertFalse($this->container->hasSession('key'));
        $this->assertFalse($this->container->hasSession('subKey', 'subSet'));
        $this->assertNull($this->container->clearSession());
    }

    public function testCookieData(): void
    {
        $this->container->setCookie('key', 'value');
        $this->assertEquals('value', $this->container->getCookie('key'));
        $this->assertTrue($this->container->hasCookie('key'));
        $this->assertFalse($this->container->hasCookie('false'));
    }

    public function testFilesData(): void
    {
        $this->container->setFiles(
            [
                'upload' => ['name' => ['img' => '41146.png']],
                'type'   => ['img' => 'image/png'],
            ]
        );

        $this->assertTrue($this->container->isUploaded('img'));
        $this->assertTrue($this->container->isFileType('img', 'image/png'));
        $this->assertEquals('41146.png', $this->container->getUpload('img', 'name'));
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/**
6			* @author : Korotkov Danila <[email protected]>
7			* @copyright Copyright (c) 2016, Korotkov Danila
8			* @license http://www.gnu.org/licenses/gpl.html GNU GPLv3.0
9			*
10			* phpunit src/tests/ContainerTest --coverage-html src/tests/coverage-html
11			*/
12
13			namespace Rudra\Tests;
14
15			use Rudra\Container;
16			use Rudra\Interfaces\ContainerInterface;
17			use Rudra\Tests\Stub\ClassWithDefaultParameters;
18			use Rudra\Tests\Stub\ClassWithDependency;
19			use Rudra\Tests\Stub\ClassWithoutConstructor;
20			use Rudra\Tests\Stub\ClassWithoutParameters;
21			use PHPUnit\Framework\TestCase as PHPUnit_Framework_TestCase;
22
23			/**
24			* Class ContainerTest
25			*/
26			class ContainerTest extends PHPUnit_Framework_TestCase
27			{
28
29			/**
30			* @var ContainerInterface
31			*/
32			protected $container;
33
34			protected function setUp(): void
35			{
36			$this->container = Container::app();
37			$this->container->setBinding(ContainerInterface::class, $this->container);
38			}
39
40			/**
41			* Проверяем синглтон
42			*/
43			public function testCallSingleton(): void
44			{
45			$this->assertInstanceOf(Container::class, Container::app());
46			$this->assertInstanceOf(Container::class, $this->container);
47			}
48
49			public function testGet(): void
50			{
51			$this->assertTrue(empty($this->container->get()));
52			}
53
54			public function testSetServices(): void
55			{
56			$this->container->setServices([
57			'contracts' => [
58			ContainerInterface::class => $this->container
59			],
60
61			'services' => [
62			'CWC' => [ClassWithoutConstructor::class],
63			'CWP' => [ClassWithoutParameters::class],
64			'CWDP' => [ClassWithDefaultParameters::class, ['param' => '123']],
65			]
66			]);
67			$this->assertInstanceOf(ClassWithoutConstructor::class, $this->container->get('CWC'));
68			$this->assertInstanceOf(ClassWithoutParameters::class, $this->container->get('CWP'));
69			$this->assertInstanceOf(ClassWithDefaultParameters::class, $this->container->get('CWDP'));
70			}
71
72			public function testSetRaw(): void
73			{
74			$this->container->set(ContainerTest::class, $this, 'raw');
75			$this->assertInstanceOf(ContainerTest::class, $this->container->get(ContainerTest::class));
76			}
77
78			public function testGetArrayHasKey(): void
79			{
80			$this->assertArrayHasKey(ContainerTest::class, $this->container->get());
81			}
82
83			public function testIoCClassWithoutConstructor(): void
84			{
85			$newClassWithoutConstructor = $this->container->new(ClassWithoutConstructor::class);
86			$this->assertInstanceOf(ClassWithoutConstructor::class, $newClassWithoutConstructor);
87
88			$this->container->set('ClassWithoutConstructor', $newClassWithoutConstructor);
89			$this->assertInstanceOf(ClassWithoutConstructor::class, $this->container->get('ClassWithoutConstructor'));
90			}
91
92			public function testIoCwithoutParameters(): void
93			{
94			$newClassWithoutParameters = $this->container->new(ClassWithoutParameters::class);
95			$this->assertInstanceOf(ClassWithoutParameters::class, $newClassWithoutParameters);
96
97			$this->container->set('ClassWithoutParameters', $newClassWithoutParameters);
98			$this->assertInstanceOf(ClassWithoutParameters::class, $this->container->get('ClassWithoutParameters'));
99			}
100
101			public function testIoCwithDefaultParameters(): void
102			{
103			$newClassWithDefaultParameters = $this->container->new(ClassWithDefaultParameters::class);
104			$this->assertInstanceOf(ClassWithDefaultParameters::class, $newClassWithDefaultParameters);
105
106			$this->container->set('ClassWithDefaultParameters', $newClassWithDefaultParameters);
107			$this->assertInstanceOf(ClassWithDefaultParameters::class, $this->container->get('ClassWithDefaultParameters'));
108			}
109
110			public function testIoCwithDependency(): void
111			{
112			$newClassWithDependency = $this->container->new(ClassWithDependency::class);
113			$this->assertInstanceOf(ClassWithDependency::class, $newClassWithDependency);
114
115			$this->container->set('ClassWithDependency', $newClassWithDependency);
116			$this->assertInstanceOf(ClassWithDependency::class, $this->container->get('ClassWithDependency'));
117			}
118
119			public function testHas(): void
120			{
121			$this->assertTrue($this->container->has(ContainerTest::class));
122			$this->assertTrue($this->container->has('ClassWithoutConstructor'));
123			$this->assertTrue($this->container->has('ClassWithoutParameters'));
124			$this->assertTrue($this->container->has('ClassWithDefaultParameters'));
125			$this->assertTrue($this->container->has('ClassWithDependency'));
126			$this->assertFalse($this->container->has('SomeClass'));
127			}
128
129			public function testSetParam(): void
130			{
131			$param = 'value';
132			$this->container->setParam('ClassWithDependency', 'param', $param);
133			$this->assertEquals($param, $this->container->getParam('ClassWithDependency', 'param'));
134			}
135
136			public function testHasParam(): void
137			{
138			$this->assertTrue($this->container->hasParam('ClassWithDependency', 'param'));
139			$this->assertNull($this->container->hasParam('SomeClass', 'param'));
140			}
141
142			public function testFailureGetParam(): void
143			{
144			$this->assertNull($this->container->getParam('SomeClass', 'param'));
145			}
146
147			public function testGetData(): void
148			{
149			$this->container->setGet(['key' => 'value']);
150			$this->assertEquals('value', $this->container->getGet('key'));
151			$this->assertContains('value', $this->container->getGet());
152			$this->assertTrue($this->container->hasGet('key'));
153			$this->assertFalse($this->container->hasGet('false'));
154			}
155
156			public function testPostData(): void
157			{
158			$this->container->setPost(['key' => 'value']);
159			$this->assertEquals('value', $this->container->getPost('key'));
160			$this->assertContains('value', $this->container->getPost());
161			$this->assertTrue($this->container->hasPost('key'));
162			$this->assertFalse($this->container->hasPost('false'));
163			}
164
165			public function testServerData(): void
166			{
167			$this->container->setServer('key', 'value');
168			$this->assertEquals('value', $this->container->getServer('key'));
169			$this->assertArrayHasKey('key', $this->container->getServer());
170			}
171
172			public function testSessionData(): void
173			{
174			$this->container->setSession('key', 'value');
175			$this->container->setSession('subKey', 'value', 'subSet');
176			$this->container->setSession('increment', 'value', 'increment');
177			$this->assertEquals('value', $this->container->getSession('key'));
178			$this->assertEquals('value', $this->container->getSession('subKey', 'subSet'));
179			$this->assertEquals('value', $this->container->getSession('increment', '0'));
180			$this->assertTrue($this->container->hasSession('key'));
181			$this->assertTrue($this->container->hasSession('subKey', 'subSet'));
182			$this->assertNull($this->container->unsetSession('key'));
183			$this->assertNull($this->container->unsetSession('subKey', 'subSet'));
184			$this->assertFalse($this->container->hasSession('key'));
185			$this->assertFalse($this->container->hasSession('subKey', 'subSet'));
186			$this->assertNull($this->container->clearSession());
187			}
188
189			public function testCookieData(): void
190			{
191			$this->container->setCookie('key', 'value');
192			$this->assertEquals('value', $this->container->getCookie('key'));
193			$this->assertTrue($this->container->hasCookie('key'));
194			$this->assertFalse($this->container->hasCookie('false'));
195			}
196
197			public function testFilesData(): void
198			{
199			$this->container->setFiles(
200			[
201			'upload' => ['name' => ['img' => '41146.png']],
202			'type' => ['img' => 'image/png'],
203			]
204			);
205
206			$this->assertTrue($this->container->isUploaded('img'));
207			$this->assertTrue($this->container->isFileType('img', 'image/png'));
208			$this->assertEquals('41146.png', $this->container->getUpload('img', 'name'));
209			}
210			}
211

Jagepard / Rudra-Container

Push — master ( 3e54b5...727765 )

ContainerTest::testHas() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like