TraderInteractive\Cronus\ProcessRegistryTest

Complexity

Total Complexity

26

Size/Duplication

Total Lines	652
Duplicated Lines	54.14 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes

0

22 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	11	1
A	addEmptyCollection()	15	15	1
B	addExistingDifferentHost()	29	29	1
A	addOverMaxGlobalProcessesOnDifferentHost()	0	12	1
A	addOverMaxGlobalProcessesOnSameHost()	20	20	2
A	addOverMaxHostProcesses()	20	20	2
B	addCleaningNotRunningProcessWithoutExtra()	25	25	1
B	addCleaningNotRunningProcessWithExtra()	41	41	2
B	addCleaningExpiredProcessWithoutExtra()	25	25	1
B	addCleaningExpiredProcessWithExtra()	34	34	1
B	addCleaningRecycledProcessWithoutExtra()	25	25	1
B	addCleaningRecycledProcessWithExtra()	41	41	2
A	addUnderflowMinsBeforeExpire()	12	12	1
B	removeWithExistingProcess()	0	24	1
A	removeWithoutExistingProcess()	19	19	1
B	resetWithoutExtra()	0	25	1
B	resetWithExtra()	0	33	1
A	resetUnderflowMinsBeforeExpire()	22	22	1
B	resetOverflowMinsBeforeExpire()	25	25	1
A	addTooMuchConcurrency()	0	12	1
A	getDevNullProcOpenDescriptors()	0	4	1
A	getProcess()	0	13	1

<?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 method seems to be duplicated in your project.

    {
        $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()

This method seems to be duplicated in your project.

    {
        $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()

This method seems to be duplicated in your project.

    {
        $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()

This method seems to be duplicated in your project.

    {
        $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()

This method seems to be duplicated in your project.

    {
        $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()

This method seems to be duplicated in your project.

    {
        $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()

This method seems to be duplicated in your project.

    {
        $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()

This method seems to be duplicated in your project.

    {
        $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()

This method seems to be duplicated in your project.

    {
        $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()

This method seems to be duplicated in your project.

    {
        $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 method seems to be duplicated in your project.

    {
        $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()

This method seems to be duplicated in your project.

    {
        $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()

This method seems to be duplicated in your project.

    {
        $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()

This method seems to be duplicated in your project.

    {
        $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);

$mockCollection is of type object<PHPUnit\Framework\MockObject\MockObject>, but the function expects a object<MongoDB\Collection>.

        $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';
}