SettingsManagerTest::testHas() - Code Metrics - Inspection of "enable profile via link" - ongr-io/SettingsBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#171)

by Simonas
created 2016-09-22 08:29 UTC
SettingsManagerTest::testHas() A

↳ Parent: SettingsManagerTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	17
Code Lines	11
Duplication

Lines	13
Ratio	76.47 %
Importance

Changes
Metric	Value
c	0
b	0
f	0
dl	13
loc	17
rs	9.4285
cc	1
eloc	11
nc	1
nop	0
<?php

/*
 * This file is part of the ONGR package.
 *
 * (c) NFQ Technologies UAB <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace ONGR\SettingsBundle\Tests\Unit\Service;

use Doctrine\Common\Cache\PhpFileCache;
use ONGR\CookiesBundle\Cookie\Model\GenericCookie;
use ONGR\ElasticsearchBundle\Result\DocumentIterator;
use ONGR\ElasticsearchBundle\Service\Manager;
use ONGR\ElasticsearchBundle\Service\Repository;
use ONGR\ElasticsearchDSL\Search;
use ONGR\SettingsBundle\Document\Setting;
use ONGR\SettingsBundle\Service\SettingsManager;

class SettingsManagerTest extends \PHPUnit_Framework_TestCase
{

    /**
     * @var Manager|\PHPUnit_Framework_MockObject_MockObject
     */
    private $manager;

    /**
     * @var Repository|\PHPUnit_Framework_MockObject_MockObject
     */
    private $repository;

    /**
     * @var PhpFileCache|\PHPUnit_Framework_MockObject_MockObject
     */
    private $cache;

    /**
     * @var GenericCookie|\PHPUnit_Framework_MockObject_MockObject
     */
    private $cookie;

    public function setUp()
    {
        $this->manager = $this->getMockBuilder('ONGR\ElasticsearchBundle\Service\Manager')
            ->disableOriginalConstructor()
            ->setMethods(['persist', 'commit'])
            ->getMock();
        $this->cache = $this->getMockBuilder('Doctrine\Common\Cache\PhpFileCache')
            ->disableOriginalConstructor()
            ->setMethods(['contains', 'fetch', 'save'])
            ->getMock();
        $this->cookie = $this->getMockBuilder('ONGR\CookiesBundle\Cookie\Model\GenericCookie')
            ->disableOriginalConstructor()
            ->setMethods(['getValue'])
            ->getMock();
        $this->repository = $this->getMockBuilder('ONGR\ElasticsearchBundle\Service\Repository')
            ->disableOriginalConstructor()
            ->setMethods(
                [
                    'findOneBy', 'remove', 'createSearch', 'execute', 'getClassName', 'getManager', 'getAggregation'
                ]
            )
            ->getMock();

        $this->repository->expects($this->any())->method('getClassName')->willReturn(Setting::class);
        $this->repository->expects($this->any())->method('getManager')->willReturn($this->manager);
        $this->repository->expects($this->any())->method('createSearch')->willReturn(new Search());
    }

    /**
     * Test get cache getter.
     */
    public function testGetCache()
    {
        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );
        $manager->setCache($this->cache);

        $this->assertInstanceOf('Doctrine\Common\Cache\PhpFileCache', $manager->getCache());
    }

    /**
     * Test get cookie getter.
     */
    public function testGetActiveProfilesCookie()
    {
        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );
        $manager->setActiveProfilesCookie($this->cookie);

        $this->assertInstanceOf('ONGR\CookiesBundle\Cookie\Model\GenericCookie', $manager->getActiveProfilesCookie());
    }

    /**
     * Test get cookie getter.
     */
    public function testGetActiveProfilesSettingName()
    {
        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );
        $manager->setActiveProfilesSettingName('ongr');

        $this->assertEquals('ongr', $manager->getActiveProfilesSettingName());
    }

    /**
     * Test setting create function.
     */
    public function testCreate()
    {
        $data = [
            'name' => 'acme',
            'type' => 'string',
            'value' => 'foo',
        ];

        $this->manager->expects($this->once())->method('persist')->with($this->callback(function ($obj) {
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            return $obj instanceof Setting;
        }))->willReturn(null);
        $this->manager->expects($this->once())->method('persist')->willReturn(null);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );
        $document = $manager->create($data);

        foreach ($data as $key => $value) {
            $this->assertEquals($value, $document->{'get' . ucfirst($key)}());
        }
    }

    /**
     * @expectedException \LogicException
     * @expectedExceptionMessage Missing one of the mandatory field!
     */
    public function testCreateMandatoryParameters()
    {
        $data = ['bar' => 'foo'];

        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );
        $manager->create($data);
    }

    /**
     * @expectedException \LogicException
     * @expectedExceptionMessage Setting acme already exists.
     */
    public function testCreateWhenSettingExists()
    {
        $data = [
            'name' => 'acme',
            'type' => 'string',
            'value' => 'foo',
        ];

        $this->repository->expects($this->once())->method('findOneBy')->willReturn(new Setting());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );
        $manager->create($data);
    }

    /**
     * Tests setting create without value set. Should be set to 0 by default.
     */
    public function testWithoutDataValueSet()
    {
        $data = [
            'name' => 'acme',
            'type' => 'string',
        ];

        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );
        $document = $manager->create($data);

        $this->assertEquals(0, $document->getValue());
    }

    /**
     * Tests setting update.
     */
    public function testUpdate()
    {
        $setting = new Setting();
        $setting->setName('acme');
        $setting->setValue('foo');

        $this->repository->expects($this->once())->method('findOneBy')->willReturn($setting);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );

        $document = $manager->update('acme', ['value' => 'bar']);
        $this->assertEquals('acme', $document->getName());
        $this->assertEquals('bar', $document->getValue());
    }

    /**
     * @expectedException \LogicException
     * @expectedExceptionMessage Setting acme not exist.
     */
    public function testUpdateWhenSettingNotExists()
    {
        $this->repository->expects($this->once())->method('findOneBy')->willReturn(null);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );
        $manager->update('acme', ['value' => 'foo']);
    }

    /**
     * Tests setting delete.
     */
    public function testDelete()

    {
        $setting = new Setting();
        $setting->setId('acme');
        $setting->setName('acme');

        $this->repository->expects($this->any())
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->method('findOneBy')->with($this->equalTo(['name' => 'acme']))->willReturn($setting);
        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );

        $manager->delete('acme');
    }

    public function testHas()

    {
        $setting = new Setting();
        $setting->setName('acme');
        $setting->setValue('foo');

        $this->repository->expects($this->once())
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->method('findOneBy')->with($this->equalTo(['name' => 'acme']))->willReturn($setting);
        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );

        $result = $manager->has('acme');

        $this->assertTrue($result);
    }

    /**
     * Test has method when there is no setting.
     */
    public function testHasWhenThereIsNoSetting()
    {
        $this->repository->expects($this->once())
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            ->method('findOneBy')->with($this->equalTo(['name' => 'acme']))->willReturn(null);
        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );

        $result = $manager->has('acme');

        $this->assertFalse($result);
    }

    /**
     * Tests setting update.
     */
    public function testGetValue()

    {
        $setting = new Setting();
        $setting->setName('acme');
        $setting->setValue('foo');

        $this->repository->expects($this->once())->method('findOneBy')->willReturn($setting);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );

        $result = $manager->getValue('acme');
        $this->assertEquals('foo', $result);
    }

    /**
     * Tests setting update.
     */
    public function testGetValueWhenThereIsNoSetting()
    {
        $this->repository->expects($this->once())->method('findOneBy')->willReturn(null);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );

        $result = $manager->getValue('acme', 'bar');
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertEquals('bar', $result);
    }

    /**
     * Returns document iterator with pre-loaded aggregations.
     *
     * @return DocumentIterator
     */
    private function getDocumentIterator()
    {
        $rawData = [
            'aggregations' => [
                'profiles' => [
                    'buckets' => [
                        [
                            'key' => 'default',
                            'doc_count' => 2,
                            'documents' => [
                                'hits' => [
                                    'total' => 2,
                                    'max_score' => 1,
                                    'hits' => [
                                        [
                                            '_index' => 'settings',
                                            '_type' => 'setting',
                                            '_id' => 'kk',
                                            '_score' => 1,
                                            '_source' => [
                                                'name' => 'foo',
                                                'profile' => [
                                                    'bar'
                                                ],
                                                'type' => 'bool',
                                                'value' => 1
                                            ]
                                        ],
                                        [
                                            '_index' => 'settings',
                                            '_type' => 'setting',
                                            '_id' => 'xx',
                                            '_score' => 1,
                                            '_source' => [
                                                'name' => 'kk',
                                                'profile' => [
                                                    'kk'
                                                ],
                                                'type' => 'bool',
                                                'value' => 1
                                            ]
                                        ]
                                    ]
                                ]
                            ],
                            'key' => 'foo',
                            'doc_count' => 1,
                            'documents' => [
                                'hits' => [
                                    'total' => 1,
                                    'max_score' => 1,
                                    'hits' => [
                                        [
                                            '_index' => 'settings',
                                            '_type' => 'setting',
                                            '_id' => 'kk',
                                            '_score' => 1,
                                            '_source' => [
                                                'name' => 'foo',
                                                'profile' => [
                                                    'bar'
                                                ],
                                                'type' => 'bool',
                                                'value' => 1
                                            ]
                                        ]
                                    ]
                                ]
                            ],
                            'key' => 'kk',
                            'doc_count' => 1,
                            'documents' => [
                                'hits' => [
                                    'total' => 1,
                                    'max_score' => 1,
                                    'hits' => [
                                        [
                                            '_index' => 'settings',
                                            '_type' => 'setting',
                                            '_id' => 'kk',
                                            '_score' => 1,
                                            '_source' => [
                                                'name' => 'foo',
                                                'profile' => [
                                                    'bar'
                                                ],
                                                'type' => 'bool',
                                                'value' => 1
                                            ]
                                        ]
                                    ]
                                ]
                            ]
                        ]
                    ]
                ]
            ]
        ];

        return new DocumentIterator($rawData, $this->manager);
    }

    /**
     * Tests setting update.
     */
    public function testGetCachedValue()
    {

        $activeProfilesSetting = 'active_profiles';

        $this->repository->expects($this->any())->method('findOneBy')->willReturnCallback(
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
            function ($arg) use ($activeProfilesSetting) {
                $settingName = $arg['name'];
                $setting = new Setting();
                switch ($settingName) {
                    case 'active_profiles':
                        $setting->setName($activeProfilesSetting);
                        $setting->setValue(['bar', 'foo']);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
                        return $setting;
                        break;
switch ($x) {
    case 1:
        return 'foo';
        break; // This break is not necessary and can be left off.
}
                    case 'acme':
                        $setting->setName('acme');
                        $setting->setValue('foo');
                        $setting->setProfile(['foo', 'default']);
                        break;
                }
                return $setting;
            }
        );

        $this->repository->expects($this->any())->method('execute')->willReturn($this->getDocumentIterator());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->cookie->expects($this->any())->method('getValue')->willReturn(['foo']);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}

        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );
        $manager->setCache($this->cache);
        $manager->setActiveProfilesSettingName($activeProfilesSetting);
        $manager->setActiveProfilesCookie($this->cookie);
        $manager->setActiveProfilesList(['default']);

        $result = $manager->getCachedValue('acme');
        $this->assertEquals('foo', $result);
    }

    /**
     * Tests setting update.
     */
    public function testGetCachedValueFromCache()
    {

        $activeProfilesSetting = 'active_profiles';

        $this->repository->expects($this->any())->method('execute')->willReturn($this->getDocumentIterator());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->cookie->expects($this->any())->method('getValue')->willReturn(['foo']);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->cache->expects($this->any())->method('contains')->willReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->cache->expects($this->any())->method('fetch')->willReturnCallback(
            function ($arg) use ($activeProfilesSetting) {
                if ($arg == $activeProfilesSetting) {
                    return ['foo'];
                }
                return ['value' => 'foo', 'profiles' => ['foo']];
            }
        );

        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );
        $manager->setCache($this->cache);
        $manager->setActiveProfilesSettingName($activeProfilesSetting);
        $manager->setActiveProfilesCookie($this->cookie);

        $result = $manager->getCachedValue('acme');
        $this->assertEquals('foo', $result);
    }

    /**
     * Tests setting update.
     */
    public function testGetCachedValueWithoutActiveProfiles()
    {
        $activeProfilesSetting = 'active_profiles';
        $this->repository->expects($this->any())->method('execute')->willReturn($this->getDocumentIterator());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->cookie->expects($this->any())->method('getValue')->willReturn(['foo']);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->cache->expects($this->any())->method('contains')->willReturn(true);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->cache->expects($this->any())->method('fetch')->willReturn(['value' => 'foo', 'profiles' => ['foo']]);

        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );
        $manager->setCache($this->cache);
        $manager->setActiveProfilesSettingName($activeProfilesSetting);
        $manager->setActiveProfilesCookie($this->cookie);

        $result = $manager->getCachedValue('acme', false);
        $this->assertEquals('foo', $result);
    }

    /**
     * Tests if there is no setting.
     */
    public function testGetCachedValueWhenItsNotExist()
    {
        $activeProfilesSetting = 'active_profiles';
        $this->repository->expects($this->any())->method('execute')->willReturn($this->getDocumentIterator());
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );
        $manager->setCache($this->cache);
        $manager->setActiveProfilesSettingName($activeProfilesSetting);

        $value = $manager->getCachedValue('acme');
        $this->assertNull($value);
    }

    public function testGetAllActiveProfilesNameList()
    {
        $document = new Setting();
        $document->setName('active_profiles');
        $document->setValue(['kk']);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->repository->expects($this->any())->method('findOneBy')->willReturn($document);
class A
{
    public function foo() { }
}

class B extends A
{
    public function bar() { }
}

/**
 * @param A|B $x
 */
function someFunction($x)
{
    $x->foo(); // This call is fine as the method exists in A and B.
    $x->bar(); // This method only exists in B and might cause an error.
}
        $this->repository->expects($this->any())->method('execute')->willReturn($this->getDocumentIterator());
        $manager = new SettingsManager(
            $this->repository,
            $this->getMock('Symfony\Component\EventDispatcher\EventDispatcherInterface')
        );
        $manager->setCache($this->cache);

        $value = $manager->getActiveProfiles();
        $this->assertEquals(['kk'], $value);
    }
}

Pull Request — master (#171)

SettingsManagerTest::testHas() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

ongr-io / SettingsBundle

Pull Request — master (#171)

SettingsManagerTest::testHas() A

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like
