Phive\Queue\Tests\Queue\SysVQueueTest

Complexity

Total Complexity

19

Size/Duplication

Total Lines	152
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	7

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	getUnsupportedItemTypes()	0	4	1
A	testUnsupportedItemType()	0	4	1
A	testSupportItemTypeWithSerializerLoose()	0	10	1
A	testThrowExceptionOnMissingResource()	0	18	3
A	testThrowExceptionOnInabilityToCreateResource()	0	23	4
A	testSetPermissions()	0	14	1
A	testSetItemMaxLength()	0	15	4
A	testPushPopPerformance()	0	23	3
A	createHandler()	0	6	1

<?php

/*
 * This file is part of the Phive Queue package.
 *
 * (c) Eugene Leonovich <gen.work@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Phive\Queue\Tests\Queue;

use Phive\Queue\NoItemAvailableException;
use Phive\Queue\QueueException;
use Phive\Queue\SysVQueue;
use Phive\Queue\Tests\Handler\SysVHandler;

/**
 * @requires extension sysvmsg
 */
class SysVQueueTest extends QueueTest
{
    use Performance {
        Performance::testPushPopPerformance as baseTestPushPopPerformance;
    }
    use Concurrency;

    protected function getUnsupportedItemTypes()
    {
        return [Types::TYPE_NULL, Types::TYPE_ARRAY, Types::TYPE_OBJECT];
    }

    /**
     * @dataProvider provideItemsOfUnsupportedTypes
     * @expectedException Phive\Queue\QueueException
     * @expectedExceptionMessageRegExp /^Message parameter must be either a string or a number\./
     */
    public function testUnsupportedItemType($item)
    {
        @$this->queue->push($item);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

    }

    /**
     * @dataProvider provideItemsOfVariousTypes
     */
    public function testSupportItemTypeWithSerializerLoose($item)
    {
        $handler = self::getHandler();
        $key = $handler->getOption('key');

        $queue = new SysVQueue($key, true);

        $queue->push($item);
        $this->assertEquals($item, $queue->pop());
    }

    /**
     * @dataProvider provideQueueInterfaceMethods
     */
    public function testThrowExceptionOnMissingResource($method)
    {
        // force a resource creation
        $this->queue->count();

        self::getHandler()->clear();

        try {
            // suppress notices/warnings triggered by msg_* functions
            // to avoid a PHPUnit_Framework_Error_Notice to be thrown
            @$this->callQueueMethod($this->queue, $method);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

        } catch (NoItemAvailableException $e) {

Consider adding a comment why this CATCH block is empty.

        } catch (QueueException $e) {
            return;
        }

        $this->fail();
    }

    /**
     * @requires extension uopz
     * @dataProvider provideQueueInterfaceMethods
     */
    public function testThrowExceptionOnInabilityToCreateResource($method)
    {
        uopz_backup('msg_get_queue');
        uopz_function('msg_get_queue', function () { return false; });

        $passed = false;

        try {
            // suppress notices/warnings triggered by msg_* functions
            // to avoid a PHPUnit_Framework_Error_Notice to be thrown
            @$this->callQueueMethod($this->queue, $method);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

        } catch (NoItemAvailableException $e) {
        } catch (QueueException $e) {
            $this->assertSame('Failed to create/attach to the queue.', $e->getMessage());
            $passed = true;
        }

        uopz_restore('msg_get_queue');

        if (!$passed) {
            $this->fail();
        }
    }

    public function testSetPermissions()
    {
        $handler = self::getHandler();
        $key = $handler->getOption('key');

        $queue = new SysVQueue($key, null, 0606);

        // force a resource creation
        $queue->count();

        $meta = $handler->getMeta();

        $this->assertEquals(0606, $meta['msg_perm.mode']);
    }

    public function testSetItemMaxLength()
    {
        $this->queue->push('xx');
        $this->queue->setItemMaxLength(1);

It seems like you code against a concrete implementation and not the interface Phive\Queue\Queue as the method setItemMaxLength() does only exist in the following implementations of said interface: Phive\Queue\SysVQueue.

        try {
            $this->queue->pop();
        } catch (\Exception $e) {
            if (7 === $e->getCode() && 'Argument list too long.' === $e->getMessage()) {
                return;
            }
        }

        $this->fail();
    }

    /**
     * @group performance
     * @dataProvider providePerformancePopDelay
     */
    public function testPushPopPerformance($delay)
    {
        exec('sysctl kernel.msgmnb 2> /dev/null', $output);

        if (!$output) {
            $this->markTestSkipped('Unable to determine the maximum size of the System V queue.');
        }

        $maxSizeInBytes = (int) str_replace('kernel.msgmnb = ', '', $output[0]);
        $queueSize = static::getPerformanceQueueSize();
        $itemLength = static::getPerformanceItemLength();

        if ($itemLength * $queueSize > $maxSizeInBytes) {
            $this->markTestSkipped(sprintf(
                'The System V queue size is too small (%d bytes) to run this test. '.
                'Try to decrease the "PHIVE_PERF_QUEUE_SIZE" environment variable to %d.',
                $maxSizeInBytes,
                floor($maxSizeInBytes / $itemLength)
            ));
        }

        self::baseTestPushPopPerformance($delay);
    }

    public static function createHandler(array $config)
    {
        return new SysVHandler([
            'key' => $config['PHIVE_SYSV_KEY'],
        ]);
    }
}