QueueShellTest::testObject() - Code Metrics - Inspection of "WIP - Cakephp 3.x upgrade" - Oefenweb/cakephp-queue - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#35)

unknown
created 2019-05-23 14:51 UTC
QueueShellTest::testObject() A

↳ Parent: QueueShellTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	4
Code Lines	2
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	1
eloc	2
nc	1
nop	0
dl	0
loc	4
rs	10
c	0
b	0
f	0
<?php
namespace Queue\Test\TestCase\Shell;

use Cake\Console\Shell;
use Cake\Core\Configure;
use Cake\Datasource\ConnectionManager;
use Cake\TestSuite\TestCase;
use Queue\Shell\QueueShell;

/**
 * QueueShell Wrapper.
 */
class QueueShellWrapper extends QueueShell
{

    /**
     * A list with error messages.
     *
     * @var array
     */
    protected $_err = [];

    /**
     * A list with out messages.
     *
     * @var array
     */
    protected $_out = [];

    /**
     * Test double of `parent::err`.
     *
     * @return void
     */
    public function err($message = null, $newlines = 1)
    {
        $this->_err[] = $message;
    }

    /**
     * Test double of `parent::out`.
     *
     * @return void
     */
    public function out($message = null, $newlines = 1, $level = Shell::NORMAL)
    {
        $this->_out[] = $message;
    }

    /**
     *
     * {@inheritdoc}
     * @see \Cake\Console\Shell::_stop()
     */
    protected function _stop($status = 0)
    {
        return $status;
    }

    /**
     *
     * {@inheritDoc}
     * @see \Queue\Shell\QueueShell::_timeNeeded()
     */
    public function timeNeeded()
    {
        return parent::_timeNeeded();
    }

    /**
     *
     * {@inheritDoc}
     * @see \Queue\Shell\QueueShell::_memoryUsage()
     */
    public function memoryUsage()
    {
        return parent::_memoryUsage();
    }

    /**
     *
     * {@inheritDoc}
     * @see \Queue\Shell\QueueShell::_stringToArray()
     */
    public function stringToArray($param) {
        return parent::_stringToArray($param);
    }
}

class QueueShellTest extends TestCase
{

    /**
     *
     * @var QueueShellWrapper
     */
    public $QueueShell;

    /**
     * Fixtures to load
     *
     * @var array
     */
    public $fixtures = [
        'plugin.Queue.QueuedTasks'
    ];

    /**
     * Setup Defaults
     *
     * @return void
     */
    public function setUp()
    {
        parent::setUp();

        $this->QueueShell = $this->getMockBuilder(QueueShellWrapper::class)

            ->setMethods([
                'in',
                'err',
                '_stop'
            ])
            ->getMock();

        $this->QueueShell->initialize();
                           initialize();

        Configure::write('Queue', [
            'sleepTime' => 2,
            'defaultWorkerTimeout' => 3,
            'workerMaxRuntime' => 5,
            'cleanupTimeout' => 10,
            'exitWhenNothingToDo' => false,
            'log' => false
        ]);
    }

    /**
     *
     * @return void
     */
    public function testObject()
    {
        $this->assertTrue(is_object($this->QueueShell));
        $this->assertInstanceOf(QueueShell::class, $this->QueueShell);
    }

    /**
     *
     * @return void
     */
    public function testStats()
    {
        $this->_needsConnection();

        $this->QueueShell->stats();
        $this->assertContains('Total unfinished jobs: 0', $this->QueueShell->_out);

    }

    /**
     *
     * @return void
     */
    public function testSettings()
    {
        $this->QueueShell->settings();
        $this->assertContains('* cleanuptimeout: 10', $this->QueueShell->_out);

    }

    /**
     *
     * @return void
     */
    public function testAddInexistent()
    {
        $this->QueueShell->args[] = 'FooBar';
        $this->QueueShell->add();
        $this->assertContains('Error: Task not found: FooBar', $this->QueueShell->_out);

    }

    /**
     *
     * @return void
     */
    public function testAdd()
    {
        $this->QueueShell->args[] = 'Example';
        $this->QueueShell->add();

        $this->assertContains('OK, job created, now run the worker', $this->QueueShell->_out, print_r($this->QueueShell->_out, true));

    }

    /**
     *
     * @return void
     */
    public function testRetry()
    {
        $file = TMP . 'task_retry.txt';
        if (file_exists($file)) {
            unlink($file);
        }

        $this->_needsConnection();

        $this->QueueShell->args[] = 'RetryExample';
        $this->QueueShell->add();

        $expected = 'This is a very simple example of a QueueTask and how retries work';
        $this->assertContains($expected, $this->QueueShell->_out);


        $this->QueueShell->runworker();

        $this->assertContains('Job did not finish, requeued after try 1.', $this->QueueShell->_out);
    }

    /**
     *
     * @return void
     */
    public function testTimeNeeded()
    {
        $this->QueueShell = $this->getMockBuilder(QueueShell::class)

            ->setMethods([
                '_time'
            ])
            ->getMock();

        $first = time();
        $second = $first - HOUR + MINUTE;
        $this->QueueShell->expects($this->at(0))
            ->method('_time')
            ->will($this->returnValue($first));
        $this->QueueShell->expects($this->at(1))
            ->method('_time')
            ->will($this->returnValue($second));
        $this->QueueShell->expects($this->exactly(2))
            ->method('_time')
            ->withAnyParameters();

        $result = $this->QueueShell->timeNeeded();
        $result = $this->QueueShell->timeNeeded();
        $this->assertSame('3540s', $result);
    }

    /**
     *
     * @return void
     */
    public function testMemoryUsage()
    {
        $result = $this->QueueShell->memoryUsage();
        $this->assertRegExp('/^\d+MB/', $result, 'Should be e.g. `17MB` or `17MB/1GB` etc.');
    }

    /**
     *
     * @return void
     */
    public function testStringToArray()
    {
        $string = 'Foo,Bar,';
        $result = $this->QueueShell->stringToArray($string);

        $expected = [
            'Foo',
            'Bar'
        ];
        $this->assertSame($expected, $result);
    }

    /**
     * Helper method for skipping tests that need a real connection.
     *
     * @return void
     */
    protected function _needsConnection()
    {
        $config = ConnectionManager::getConfig('test');
        $this->skipIf(strpos($config['driver'], 'Mysql') === false, 'Only Mysql is working yet for this.');
    }
}

Oefenweb / cakephp-queue

Pull Request — master (#35)

QueueShellTest::testObject() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
