ProcessRegistryTest::addEmptyCollection() - Code Metrics - Inspection of "[WIP] Version 3" - traderinteractive/cronus - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#14)

by Chad
created 2018-02-22 01:26 UTC
ProcessRegistryTest::addEmptyCollection() A

↳ Parent: ProcessRegistryTest
Complexity

Conditions	1
Paths	1
Size

Total Lines	15
Code Lines	9
Duplication

Lines	15
Ratio	100 %
Importance

Changes
Metric	Value
cc	1
eloc	9
nc	1
nop	0
dl	15
loc	15
rs	9.4285
c	0
b	0
f	0
<?php

namespace TraderInteractive\Cronus;

use MongoDB\BSON\ObjectID;

//encoded hostname from the replaced builtin function
const HOSTNAME = 'my_DOT_host_DOLLAR_name';

/**
 * @coversDefaultClass \TraderInteractive\Cronus\ProcessRegistry
 * @covers ::<private>
 * @covers ::__construct
 */
final class ProcessRegistryTest extends \PHPUnit\Framework\TestCase
{
    /**
     * Mongo collection to use in each test.
     *
     * @var \MongoDB\Collection
     */
    private $collection;

    /**
     * Registry instance to use in each test.
     *
     * @var ProcessRegistry
     */
    private $registry;

    /**
     * Prepare each test.
     *
     * @return void
     */
    public function setUp()
    {
        $mongo = new \MongoDB\Client(
            'mongodb://localhost:27017',
            [],
            ['typeMap' => ['root' => 'array', 'document' => 'array', 'array' => 'array']]
        );
        $this->collection = $mongo->selectDatabase('testing')->selectCollection('processes');
        $this->collection->drop();
        $this->registry = new ProcessRegistry($this->collection);
    }

    /**
     * @test
     * @covers ::add
     *
     * @return void
     */
    public function addEmptyCollection()

    {
        $this->assertTrue($this->registry->add($this->getProcess('testId')));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $expected = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [getmypid() => ProcessRegistry::MONGO_INT32_MAX]],
            'version' => $result['version'],
        ];

        $this->assertSame($expected, $result);
    }

    /**
     * @test
     * @covers ::add
     *
     * @return void
     */
    public function addExistingDifferentHost()

    {
        $expireSecs = time() + 60;
        $initialVersion = new ObjectID();
        $initalTask = [
            '_id' => 'testId',
            'hosts' => ['a host' => ['1' => $expireSecs]],
            'version' => $initialVersion,
        ];

        $this->collection->insertOne($initalTask);

        $this->assertTrue($this->registry->add($this->getProcess('testId', PHP_INT_MAX, 2, 1)));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $expected = [
            '_id' => 'testId',
            'hosts' => [
                'a host' => ['1' => $expireSecs],
                 HOSTNAME => [getmypid() => ProcessRegistry::MONGO_INT32_MAX],
            ],
            'version' => $result['version'],
        ];

        $this->assertSame($expected, $result);
        $this->assertNotSame((string)$initialVersion, (string)$result['version']);
    }

    /**
     * @test
     * @covers ::add
     *
     * @return void
     */
    public function addOverMaxGlobalProcessesOnDifferentHost()
    {
        $initalTask = [
            '_id' => 'testId',
            'hosts' => ['different host' => ['1' => time() + 60]],
            'version' => new ObjectID(),
        ];

        $this->collection->insertOne($initalTask);

        $this->assertFalse($this->registry->add($this->getProcess('testId', PHP_INT_MAX, 1, PHP_INT_MAX)));
    }

    /**
     * @test
     * @covers ::add
     *
     * @return void
     */
    public function addOverMaxGlobalProcessesOnSameHost()

    {
        $pipes = [];
        $process = proc_open('sleep 10 &', self::getDevNullProcOpenDescriptors(), $pipes);
        $status = proc_get_status($process);
        if (!$status['running']) {
            $this->markTestSkipped('Unable to start sleep process.');
            return;
        }

        $initalTask = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [$status['pid'] => time() + 60]],
            'version' => new ObjectID(),
        ];

        $this->collection->insertOne($initalTask);

        $this->assertFalse($this->registry->add($this->getProcess('testId', PHP_INT_MAX, 1, PHP_INT_MAX)));
    }

    /**
     * @test
     * @covers ::add
     *
     * @return void
     */
    public function addOverMaxHostProcesses()

    {
        $pipes = [];
        $process = proc_open('sleep 10 &', self::getDevNullProcOpenDescriptors(), $pipes);
        $status = proc_get_status($process);
        if (!$status['running']) {
            $this->markTestSkipped('Unable to start sleep process.');
            return;
        }

        $initalTask = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [$status['pid'] => time() + 60]],
            'version' => new ObjectID(),
        ];

        $this->collection->insertOne($initalTask);

        $this->assertFalse($this->registry->add($this->getProcess('testId', PHP_INT_MAX, PHP_INT_MAX, 1)));
    }

    /**
     * @test
     * @covers ::add
     *
     * @return void
     */
    public function addCleaningNotRunningProcessWithoutExtra()

    {
        $initialVersion = new ObjectID();
        $initalTask = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => ['9999999' => time() + 60]],
            'version' => $initialVersion,
        ];

        $this->collection->insertOne($initalTask);

        $this->assertTrue($this->registry->add($this->getProcess('testId')));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $expected = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [getmypid() => ProcessRegistry::MONGO_INT32_MAX]],
            'version' => $result['version'],
        ];

        $this->assertSame($expected, $result);
        $this->assertNotSame((string)$initialVersion, (string)$result['version']);
    }

    /**
     * @test
     * @covers ::add
     *
     * @return void
     */
    public function addCleaningNotRunningProcessWithExtra()

    {
        $pipes = [];
        $process = proc_open('sleep 3 &', self::getDevNullProcOpenDescriptors(), $pipes);
        $status = proc_get_status($process);
        if (!$status['running']) {
            $this->markTestSkipped('Unable to start sleep process.');
            return;
        }

        $extraPid = $status['pid'];

        $expireSecs = time() + 60;
        $initialVersion = new ObjectID();
        $initalTask = [
            '_id' => 'testId',
            'hosts' => [
                HOSTNAME => [
                    $extraPid => $expireSecs,
                    '9999999' => $expireSecs,
                ],
            ],
            'version' => $initialVersion,
        ];

        $this->collection->insertOne($initalTask);

        $this->assertTrue($this->registry->add($this->getProcess('testId', PHP_INT_MAX, 2, 2)));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $expected = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [$extraPid => $expireSecs, getmypid() => ProcessRegistry::MONGO_INT32_MAX]],
            'version' => $result['version'],
        ];

        $this->assertSame($expected, $result);
        $this->assertNotSame((string)$initialVersion, (string)$result['version']);
    }

    /**
     * @test
     * @covers ::add
     *
     * @return void
     */
    public function addCleaningExpiredProcessWithoutExtra()

    {
        $initialVersion = new ObjectID();
        $initalTask = [
            '_id' => 'testId',
            'hosts' => ['different host' => ['1' => strtotime('-1 hour')]],
            'version' => $initialVersion,
        ];

        $this->collection->insertOne($initalTask);

        $this->assertTrue($this->registry->add($this->getProcess('testId')));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $expected = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [getmypid() => ProcessRegistry::MONGO_INT32_MAX]],
            'version' => $result['version'],
        ];

        $this->assertSame($expected, $result);
        $this->assertNotSame((string)$initialVersion, (string)$result['version']);
    }

    /**
     * @test
     * @covers ::add
     *
     * @return void
     */
    public function addCleaningExpiredProcessWithExtra()

    {
        $expireSecs = time() + 60;
        $initialVersion = new ObjectID();
        $initalTask = [
            '_id' => 'testId',
            'hosts' => [
                'a host' => [
                    '2' => time() - 1,
                    '1' => $expireSecs,
                ],
            ],
            'version' => $initialVersion,
        ];

        $this->collection->insertOne($initalTask);

        $this->assertTrue($this->registry->add($this->getProcess('testId', PHP_INT_MAX, 2, 2)));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $expected = [
            '_id' => 'testId',
            'hosts' => [
                'a host' => ['1' => $expireSecs],
                HOSTNAME => [getmypid() => ProcessRegistry::MONGO_INT32_MAX]
            ],
            'version' => $result['version'],
        ];

        $this->assertSame($expected, $result);
        $this->assertNotSame((string)$initialVersion, (string)$result['version']);
    }

    /**
     * @test
     * @covers ::add
     *
     * @return void
     */
    public function addCleaningRecycledProcessWithoutExtra()

    {
        $initialVersion = new ObjectID();
        $initalTask = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [getmypid() => time() + 60]],
            'version' => $initialVersion,
        ];

        $this->collection->insertOne($initalTask);

        $this->assertTrue($this->registry->add($this->getProcess('testId')));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $expected = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [getmypid() => ProcessRegistry::MONGO_INT32_MAX]],
            'version' => $result['version'],
        ];

        $this->assertSame($expected, $result);
        $this->assertNotSame((string)$initialVersion, (string)$result['version']);
    }

    /**
     * @test
     * @covers ::add
     *
     * @return void
     */
    public function addCleaningRecycledProcessWithExtra()

    {
        $pipes = [];
        $process = proc_open('sleep 3 &', self::getDevNullProcOpenDescriptors(), $pipes);
        $status = proc_get_status($process);
        if (!$status['running']) {
            $this->markTestSkipped('Unable to start sleep process.');
            return;
        }

        $extraPid = $status['pid'];

        $expireSecs = time() + 60;
        $initialVersion = new ObjectID();
        $initalTask = [
            '_id' => 'testId',
            'hosts' => [
                HOSTNAME => [
                    $extraPid => $expireSecs,
                    getmypid() => $expireSecs,
                ],
            ],
            'version' => $initialVersion,
        ];

        $this->collection->insertOne($initalTask);

        $this->assertTrue($this->registry->add($this->getProcess('testId', PHP_INT_MAX, 2, 2)));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $expected = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [$extraPid => $expireSecs, getmypid() => ProcessRegistry::MONGO_INT32_MAX]],
            'version' => $result['version'],
        ];

        $this->assertSame($expected, $result);
        $this->assertNotSame((string)$initialVersion, (string)$result['version']);
    }

    /**
     * @test
     * @covers ::add
     *
     * @return void
     */
    public function addUnderflowMinsBeforeExpire()

    {
        $this->assertTrue($this->registry->add($this->getProcess('testId', ~PHP_INT_MAX)));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $this->assertSame(
            ['_id' => 'testId', 'hosts' => [HOSTNAME => [getmypid() => 0]], 'version' => $result['version']],
            $result
        );
    }

    /**
     * @test
     * @covers ::remove
     *
     * @return void
     */
    public function removeWithExistingProcess()
    {
        $initialVersion = new ObjectID();
        $initalTask = [
            '_id' => 'testId',
            'hosts' => [
                HOSTNAME => ['1' => 0, getmypid() => time() + 60],
            ],
            'version' => $initialVersion,
        ];

        $this->collection->insertOne($initalTask);

        $this->registry->remove($this->getProcess('testId'));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $this->assertSame(
            ['_id' => 'testId', 'hosts' => [HOSTNAME => ['1' => 0]], 'version' => $result['version']],
            $result
        );
        $this->assertNotSame((string)$initialVersion, (string)$result['version']);
    }

    /**
     * @test
     * @covers ::remove
     *
     * @return void
     */
    public function removeWithoutExistingProcess()

    {
        $initialVersion = new ObjectID();
        $initalTask = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [getmypid() => time() + 60]],
            'version' => $initialVersion,
        ];

        $this->collection->insertOne($initalTask);

        $this->registry->remove($this->getProcess('testId'));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $this->assertSame(['_id' => 'testId', 'hosts' => [HOSTNAME => []], 'version' => $result['version']], $result);
        $this->assertNotSame((string)$initialVersion, (string)$result['version']);
    }

    /**
     * @test
     * @covers ::reset
     *
     * @return void
     */
    public function resetWithoutExtra()
    {
        $initialExpireSecs = time() + 60;
        $initialVersion = new ObjectID();
        $initalTask = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [getmypid() => $initialExpireSecs]],
            'version' => $initialVersion,
        ];

        $this->collection->insertOne($initalTask);

        $this->registry->reset($this->getProcess('testId', 2));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $result['hosts'][HOSTNAME][getmypid()] = null;

        $this->assertSame(
            ['_id' => 'testId', 'hosts' => [HOSTNAME => [getmypid() => null]], 'version' => $result['version']],
            $result
        );
        $this->assertNotSame((string)$initialVersion, (string)$result['version']);
    }

    /**
     * @test
     * @covers ::reset
     *
     * @return void
     */
    public function resetWithExtra()
    {
        $initialExpireSecs = time() + 60;
        $initialVersion = new ObjectID();
        $initalTask = [
            '_id' => 'testId',
            'hosts' => [
                HOSTNAME => [
                    getmypid() => $initialExpireSecs,
                    'extra pid' => 0,
                ],
            ],
            'version' => $initialVersion,
        ];

        $this->collection->insertOne($initalTask);

        $this->registry->reset($this->getProcess('testId', 2));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $result['hosts'][HOSTNAME][getmypid()] = null;

        $expected = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [getmypid() => null, 'extra pid' => 0]],
            'version' => $result['version'],
        ];

        $this->assertSame($expected, $result);
        $this->assertNotSame((string)$initialVersion, (string)$result['version']);
    }

    /**
     * @test
     * @covers ::reset
     *
     * @return void
     */
    public function resetUnderflowMinsBeforeExpire()

    {
        $initialVersion = new ObjectID();
        $initalTask = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [getmypid() => time() + 60]],
            'version' => $initialVersion,
        ];

        $this->collection->insertOne($initalTask);

        $this->registry->reset($this->getProcess('testId', ~PHP_INT_MAX));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $this->assertSame(
            ['_id' => 'testId', 'hosts' => [HOSTNAME => [getmypid() => 0]], 'version' => $result['version']],
            $result
        );
        $this->assertNotSame((string)$initialVersion, (string)$result['version']);
    }

    /**
     * @test
     * @covers ::reset
     *
     * @return void
     */
    public function resetOverflowMinsBeforeExpire()

    {
        $initialVersion = new ObjectID();
        $initalTask = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [getmypid() => time() + 60]],
            'version' => $initialVersion,
        ];

        $this->collection->insertOne($initalTask);

        $this->registry->reset($this->getProcess('testId', PHP_INT_MAX));

        $this->assertSame(1, $this->collection->count());
        $result = $this->collection->findOne();

        $expected = [
            '_id' => 'testId',
            'hosts' => [HOSTNAME => [getmypid() => ProcessRegistry::MONGO_INT32_MAX]],
            'version' => $result['version'],
        ];

        $this->assertSame($expected, $result);
        $this->assertNotSame((string)$initialVersion, (string)$result['version']);
    }

    /**
     * Verify behavior of add() with too much concurrency.
     *
     * @test
     * @covers ::add
     *
     * @return void
     */
    public function addTooMuchConcurrency()
    {
        $mockUpdateResult = $this->getMockBuilder('\\MongoDB\\UpdateResult')->disableOriginalConstructor()->getMock();
        $mockUpdateResult->method('getMatchedCount')->willReturn(0);
        $entry = ['_id' => 'myTask', 'hosts' => [], 'version' => new ObjectID()];
        $mockCollection = $this->getMockBuilder('\\MongoDB\\Collection')->disableOriginalConstructor()->getMock();
        $mockCollection->method('findOne')->willReturn($entry);
        $mockCollection->method('replaceOne')->willReturn($mockUpdateResult);

        $registry = new ProcessRegistry($mockCollection);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        $this->assertFalse($registry->add($this->getProcess('myTask')));
    }

    /**
     * Returns array where the key represents the descriptor number and the value represents how PHP will pass that
     * descriptor to the child process. 0 is stdin, 1 is stdout, while 2 is stderr.
     *
     * @return array
     */
    private static function getDevNullProcOpenDescriptors() : array
    {
        return [0 => ['file', '/dev/null', 'r'], 1 => ['file', '/dev/null', 'w'], 2 => ['file', '/dev/null', 'w']];
    }

    private function getProcess(
        string $name = 'testId',
        int $expire = PHP_INT_MAX,
        int $global = 1,
        int $host = 1
    ) : ProcessInterface {
        $mock = $this->getMockBuilder('\\TraderInteractive\\Cronus\\ProcessInterface')->getMock();
        $mock->method('getName')->willReturn($name);
        $mock->method('getMinsBeforeExpire')->willReturn($expire);
        $mock->method('getMaxGlobalProcesses')->willReturn($global);
        $mock->method('getMaxHostProcesses')->willReturn($host);
        return $mock;
    }
}

/**
 * Override of global gethostname().
 *
 * @return string
 */
function gethostname()
{
    return 'my.host$name';
}

1			<?php
2
3			namespace TraderInteractive\Cronus;
4
5			use MongoDB\BSON\ObjectID;
6
7			//encoded hostname from the replaced builtin function
8			const HOSTNAME = 'my_DOT_host_DOLLAR_name';
9
10			/**
11			* @coversDefaultClass \TraderInteractive\Cronus\ProcessRegistry
12			* @covers ::<private>
13			* @covers ::__construct
14			*/
15			final class ProcessRegistryTest extends \PHPUnit\Framework\TestCase
16			{
17			/**
18			* Mongo collection to use in each test.
19			*
20			* @var \MongoDB\Collection
21			*/
22			private $collection;
23
24			/**
25			* Registry instance to use in each test.
26			*
27			* @var ProcessRegistry
28			*/
29			private $registry;
30
31			/**
32			* Prepare each test.
33			*
34			* @return void
35			*/
36			public function setUp()
37			{
38			$mongo = new \MongoDB\Client(
39			'mongodb://localhost:27017',
40			[],
traderinteractive / cronus

Pull Request — master (#14)

ProcessRegistryTest::addEmptyCollection() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
