TomCizek\SymfonyInteropContainer\Tests\Configurators\SymfonyInteropContainerTest

Complexity

Total Complexity

17

Size/Duplication

Total Lines	131
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Importance

Changes

0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	14	1
A	testHas_WithBadType_ShouldThrowContainerException()	0	6	1
A	testHas_NotExistingService_ShouldReturnFalse()	0	6	1
A	testHas_ConfigKey_ShouldReturnTrue()	0	6	1
A	testHas_ExistingService_ShouldReturnTrue()	0	6	1
A	testGet_WithBadType_ShouldThrowContainerException()	0	6	1
A	testGet_NotExistingService_ShouldThrowNotFoundException()	0	6	1
A	testGet_ExistingTestServiceFromConfig_ShouldBeInstanceOfTestService()	0	6	1
A	testGet_ConfigKey_ShouldContainTestExtensionConfig()	0	6	1
A	givenInteropContainerFromBootedKernelWith()	0	5	1
A	willThrowException()	0	4	1
A	whenAskInteropContainerWhetherHasKey()	0	4	1
A	thenResultIsTrue()	0	4	1
A	thenResultIsFalse()	0	4	1
A	whenGetFromInteropContainerByKey()	0	4	1
A	thenIsInstanceOf()	0	5	1
A	thenIsexpecteedConfig()	0	9	1

<?php declare(strict_types = 1);

namespace TomCizek\SymfonyInteropContainer\Tests\Configurators;

use DateTime;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\NotFoundExceptionInterface;
use TomCizek\SymfonyInteropContainer\SymfonyInteropContainer;
use TomCizek\SymfonyInteropContainer\SymfonyInteropContainerBundle;
use TomCizek\SymfonyInteropContainer\Tests\TestBundle\TestBundle;
use TomCizek\SymfonyInteropContainer\Tests\TestBundle\TestService;

class SymfonyInteropContainerTest extends SymfonyInteropContainerTestCase
{
	const FIXTURE_CONGIGS_DIR = __DIR__ . '/fixtures/';

	/** @var SymfonyInteropContainer */
	private $interopContainer;

	public function setUp()
	{
		parent::setUp();

		$this->givenInteropContainerFromBootedKernelWith(
			[
				SymfonyInteropContainerBundle::class,
				TestBundle::class,
			],
			[
				ConfigFile::record(self::FIXTURE_CONGIGS_DIR . 'TestExtensionConfig.yml', 'yml'),
			]
		);
	}

	public function testHas_WithBadType_ShouldThrowContainerException()
	{
		$this->willThrowException(ContainerExceptionInterface::class);

		$this->whenAskInteropContainerWhetherHasKey(new DateTime());
	}

	public function testHas_NotExistingService_ShouldReturnFalse()
	{
		$hasConfig = $this->whenAskInteropContainerWhetherHasKey('not_existing_service');

		$this->thenResultIsFalse($hasConfig);
	}

	public function testHas_ConfigKey_ShouldReturnTrue()
	{
		$hasConfig = $this->whenAskInteropContainerWhetherHasKey('config');

		$this->thenResultIsTrue($hasConfig);
	}

	public function testHas_ExistingService_ShouldReturnTrue()
	{
		$hasConfig = $this->whenAskInteropContainerWhetherHasKey('test_service');

		$this->thenResultIsTrue($hasConfig);
	}

	public function testGet_WithBadType_ShouldThrowContainerException()
	{
		$this->willThrowException(ContainerExceptionInterface::class);

		$this->whenGetFromInteropContainerByKey(new DateTime());
	}

	public function testGet_NotExistingService_ShouldThrowNotFoundException()
	{
		$this->willThrowException(NotFoundExceptionInterface::class);

		$this->whenGetFromInteropContainerByKey('not_existing_service');
	}

	public function testGet_ExistingTestServiceFromConfig_ShouldBeInstanceOfTestService()
	{
		$testService = $this->whenGetFromInteropContainerByKey('test_service');

		$this->thenIsInstanceOf(TestService::class, $testService);
	}

	public function testGet_ConfigKey_ShouldContainTestExtensionConfig()
	{
		$config = $this->whenGetFromInteropContainerByKey('config');

		$this->thenIsexpecteedConfig($config);
	}

	/**
	 * @param string[]     $bundles
	 * @param ConfigFile[] $configFiles
	 *
	 * @return void
	 */
	private function givenInteropContainerFromBootedKernelWith(array $bundles = [], array $configFiles = []): void
	{
		$container = $this->getContainerFromBootedKernelWith($bundles, $configFiles);
		$this->interopContainer = $container->get(SymfonyInteropContainer::class);
	}

	private function willThrowException($class): void
	{
		$this->expectException($class);
	}

	private function whenAskInteropContainerWhetherHasKey($key)
	{
		return $this->interopContainer->has($key);
	}

	private function thenResultIsTrue($has): void
	{
		self::assertTrue($has);
	}

	private function thenResultIsFalse($has): void
	{
		self::assertFalse($has);
	}

	private function whenGetFromInteropContainerByKey($key)
	{
		return $this->interopContainer->get($key);
	}

	private function thenIsInstanceOf($expectedClass, $instance): void
	{
		self::assertInstanceOf($expectedClass, $instance);

	}

	private function thenIsexpecteedConfig(array $config): void
	{
		$expectedConfig = [
			'test' => [
				'foo' => 'bar',
			],
		];
		self::assertEquals($expectedConfig, $config);
	}
}