WebPTTest\ZendCouchbaseModule\AbstractCouchbaseBucketFactoryTest

Complexity

Total Complexity

8

Size/Duplication

Total Lines	109
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	13	1
A	testCreateService()	0	6	1
A	testCanCreateFromRequestedName()	0	13	1
A	testGetModuleConfig()	0	7	1
A	testGetBucketOptions()	0	9	1
A	testGetClusterOptions()	0	10	1
A	testCreateCouchbaseCluster()	0	10	1
A	testCreateCouchbaseBucket()	0	10	1

<?php

namespace WebPTTest\ZendCouchbaseModule;

use WebPT\ZendCouchbaseModule\AbstractCouchbaseBucketFactory;
use WebPT\ZendCouchbaseModule\BucketOptions;
use WebPT\ZendCouchbaseModule\ClusterOptions;
use WebPT\ZendCouchbaseModule\Module;
use Zend\Mvc\Service\ServiceManagerConfig;
use Zend\ServiceManager\ServiceLocatorInterface;
use Zend\ServiceManager\ServiceManager;

/**
 * @covers \WebPT\ZendCouchbaseModule\AbstractCouchbaseBucketFactory
 */
class AbstractCouchbaseBucketFactoryTest extends \PHPUnit_Framework_TestCase
{
    /** @var ServiceLocatorInterface */
    private $serviceLocator;
    
    protected function setUp()
    {
        $config = (new Module())->getConfig();
    
        $serviceManager = new ServiceManager();
        
        (new ServiceManagerConfig(\igorw\get_in($config, ['service_manager'], [])))

It seems like $config defined by (new \WebPT\ZendCouchbaseModule\Module())->getConfig() on line 23 can also be of type object<Traversable>; however, igorw\get_in() does only seem to accept array, maybe add an additional type check?

            ->configureServiceManager($serviceManager);
        
        $serviceManager->setService('config', $config);
        
        $this->serviceLocator = $serviceManager;
    }
    
    /**
     * @group integration
     */
    public function testCreateService()
    {
        $bucket = $this->serviceLocator->get('couchbase.localhost.default');

        self::assertInstanceOf(\CouchbaseBucket::class, $bucket);
    }
    
    public function testCanCreateFromRequestedName()
    {
        $name = 'FooBar';
        $requestedName = 'couchbase.localhost.default';
    
        $canCreate = (new AbstractCouchbaseBucketFactory())->canCreateServiceWithName(
            new ServiceManager(),
            $name,
            $requestedName
        );
    
        self::assertTrue($canCreate);
    }
    
    /**
     * @return array
     */
    public function testGetModuleConfig()
    {
        $moduleConfig = (new AbstractCouchbaseBucketFactory())->getModuleConfig($this->serviceLocator);
        self::assertInternalType('array', $moduleConfig);
        
        return $moduleConfig;
    }
    
    /**
     * @return BucketOptions
     */
    public function testGetBucketOptions()
    {
        $moduleConfig = $this->testGetModuleConfig();
        
        $bucketOptions = (new AbstractCouchbaseBucketFactory())->getBucketOptions($moduleConfig, 'default');
        self::assertInstanceOf(BucketOptions::class, $bucketOptions);
        
        return $bucketOptions;
    }
    
    /**
     * @return ClusterOptions
     */
    public function testGetClusterOptions()
    {
        $moduleConfig = $this->testGetModuleConfig();
        
        $clusterOptions = (new AbstractCouchbaseBucketFactory())->getClusterOptions($moduleConfig, 'localhost');
        
        self::assertInstanceOf(ClusterOptions::class, $clusterOptions);
        
        return $clusterOptions;
    }
    
    /**
     * @group integration
     */
    public function testCreateCouchbaseCluster()
    {
        $clusterOptions = $this->testGetClusterOptions();
        
        $cluster = (new AbstractCouchbaseBucketFactory())->createCouchbaseCluster($clusterOptions);
        
        self::assertInstanceOf(\CouchbaseCluster::class, $cluster);
        
        return $cluster;
    }
    
    /**
     * @group integration
     */
    public function testCreateCouchbaseBucket()
    {
        $cluster = $this->testCreateCouchbaseCluster();
    
        $bucketOptions = $this->testGetBucketOptions();
        
        $bucket = (new AbstractCouchbaseBucketFactory())->createCouchbaseBucket($cluster, $bucketOptions);
        
        self::assertInstanceOf(\CouchbaseBucket::class, $bucket);
    }
}