QueueTest - Code Metrics - Inspection of "[WIP] Version 3" - traderinteractive/mongo-queue-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#60)

by Chad

created 2018-03-03 00:53 UTC

QueueTest B

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	726
Duplicated Lines	3.99 %

Coupling/Cohesion

Components	1
Dependencies	6

Importance

Changes	2
Bugs	0	Features	0

Metric	Value
wmc	44
c	2
b	0
f	0
lcom	1
cbo	6
dl	29
loc	726
rs	8

43 Methods

Rating	Name	Duplication	Size	Complexity
A	constructWithNonStringUrl()	0	4	1
A	ensureGetIndexWithTooLongCollectionName()	0	8	1
A	ensureGetIndexWithNonStringBeforeSortKey()	0	4	1
A	ensureGetIndexWithNonStringAfterSortKey()	0	4	1
A	ensureGetIndexWithBadBeforeSortValue()	0	4	1
A	ensureGetIndexWithBadAfterSortValue()	0	4	1
A	ensureIndexCannotBeCreatedAfterFiveAttempts()	0	9	1
A	ensureCountIndex()	0	14	1
A	ensureCountIndexWithPrefixOfPrevious()	0	11	1
A	ensureCountIndexWithNonStringKey()	0	4	1
A	ensureCountIndexWithBadValue()	0	4	1
A	getByBadQuery()	0	9	1
A	getWithNegativePollDuration()	0	5	1
A	getWithCustomPriority()	0	18	1
A	getWithTimeBasedPriority()	0	18	1
A	getWithTimeBasedPriorityWithOldTimestamp()	0	22	1
A	getWait()	0	11	1
A	earliestGet()	0	12	1
A	countWithNonStringKey()	0	4	1
A	testCount()	0	18	1
A	ack()	0	13	1
A	ackBadArg()	0	4	1
A	ackSendWithEarliestGet()	0	11	1
A	ackSendWithWrongIdType()	0	4	1
A	ackSendWithNanPriority()	0	4	1
A	ackSendWithHighEarliestGet()	0	15	1
A	ackSendWithLowEarliestGet()	0	15	1
A	sendWithNanPriority()	0	4	1
A	sendWithHighEarliestGet()	0	12	1
A	assertSingleMessage()	0	14	1
B	ensureGetIndex()	0	25	1
A	getWithNonStringKey()	0	4	1
A	getByFullQuery()	0	14	1
A	getBySubDocQuery()	0	19	1
A	getBeforeAck()	0	13	1
A	ackSend()	0	21	1
A	requeue()	0	15	1
A	requeueBadArg()	0	4	1
A	send()	13	13	1
A	setUp()	0	13	2
B	resetStuck()	0	35	1
A	sendWithLowEarliestGet()	0	12	1
A	constructWithCollection()	16	16	1

How to fix Duplicated Code Complexity

Duplicated Code

Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.

Common duplication problems, and corresponding solutions are:

If you have the same expression in different places: Extract expression to a method
If you have the same method in different sub-classes: Extract method, and pull up field to the parent class
If you have the same code in unrelated classes: Consider extracting the code to a new class, and injecting that class

Complex Class

Tip: Before tackling complexity, make sure that you eliminate any duplication first. This often can reduce the size of classes significantly.

Complex classes like QueueTest often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes. You can also have a look at the cohesion graph to spot any un-connected, or weakly-connected components.

Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.

While breaking up the class, it is a good idea to analyze how other classes use QueueTest, and based on these observations, apply Extract Interface, too.

<?php

namespace TraderInteractive\Mongo;

use MongoDB\BSON\UTCDateTime;
use PHPUnit\Framework\TestCase;

/**
 * @coversDefaultClass \TraderInteractive\Mongo\Queue
 * @covers ::<private>
 * @covers ::__construct
 */
final class QueueTest extends TestCase
{
    private $collection;
    private $mongoUrl;
    private $queue;

    public function setUp()
    {
        $this->mongoUrl = getenv('TESTING_MONGO_URL') ?: 'mongodb://localhost:27017';
        $mongo = new \MongoDB\Client(
            $this->mongoUrl,
            [],
            ['typeMap' => ['root' => 'array', 'document' => 'array', 'array' => 'array']]
        );
        $this->collection = $mongo->selectDatabase('testing')->selectCollection('messages');
        $this->collection->drop();

        $this->queue = new Queue($this->mongoUrl, 'testing', 'messages');
    }

    /**
     * @test
     * @covers ::__construct
     * @expectedException \InvalidArgumentException
     */
    public function constructWithNonStringUrl()
    {
        new Queue(1, 'testing', 'messages');
    }

    /**
     * @test
     * @covers ::ensureGetIndex
     */
    public function ensureGetIndex()
    {
        $this->queue->ensureGetIndex(['type' => 1], ['boo' => -1]);
        $this->queue->ensureGetIndex(['another.sub' => 1]);

        $indexes = iterator_to_array($this->collection->listIndexes());
        $this->assertSame(3, count($indexes));

        $expectedOne = [
            'earliestGet' => 1,
            'payload.type' => 1,
            'priority' => 1,
            'created' => 1,
            'payload.boo' => -1,
        ];
        $this->assertSame($expectedOne, $indexes[1]['key']);

        $expectedTwo = [
            'earliestGet' => 1,
            'payload.another.sub' => 1,
            'priority' => 1,
            'created' => 1,
        ];
        $this->assertSame($expectedTwo, $indexes[2]['key']);
    }

    /**
     * @test
     * @covers ::ensureGetIndex
     * @expectedException \Exception
     */
    public function ensureGetIndexWithTooLongCollectionName()
    {
        $collectionName = 'messages012345678901234567890123456789012345678901234567890123456789';
        $collectionName .= '012345678901234567890123456789012345678901234567890123456789';//128 chars

        $queue = new Queue($this->mongoUrl, 'testing', $collectionName);
        $queue->ensureGetIndex([]);
    }

    /**
     * @test
     * @covers ::ensureGetIndex
     * @expectedException \InvalidArgumentException
     */
    public function ensureGetIndexWithNonStringBeforeSortKey()
    {
        $this->queue->ensureGetIndex([0 => 1]);
    }

    /**
     * @test
     * @covers ::ensureGetIndex
     * @expectedException \InvalidArgumentException
     */
    public function ensureGetIndexWithNonStringAfterSortKey()
    {
        $this->queue->ensureGetIndex(['field' => 1], [0 => 1]);
    }

    /**
     * @test
     * @covers ::ensureGetIndex
     * @expectedException \InvalidArgumentException
     */
    public function ensureGetIndexWithBadBeforeSortValue()
    {
        $this->queue->ensureGetIndex(['field' => 'NotAnInt']);
    }

    /**
     * @test
     * @covers ::ensureGetIndex
     * @expectedException \InvalidArgumentException
     */
    public function ensureGetIndexWithBadAfterSortValue()
    {
        $this->queue->ensureGetIndex([], ['field' => 'NotAnInt']);
    }

    /**
     * Verifies the behaviour of the Queue when it cannot create an index after 5 attempts.
     *
     * @test
     * @covers ::ensureGetIndex
     * @expectedException \Exception
     * @expectedExceptionMessage couldnt create index after 5 attempts
     */
    public function ensureIndexCannotBeCreatedAfterFiveAttempts()
    {
        $mockCollection = $this->getMockBuilder('\MongoDB\Collection')->disableOriginalConstructor()->getMock();

        $mockCollection->method('listIndexes')->willReturn([]);

        $queue = new Queue($mockCollection);
        $queue->ensureCountIndex(['type' => 1], false);
    }

    /**
     * @test
     * @covers ::ensureCountIndex
     */
    public function ensureCountIndex()
    {
        $this->queue->ensureCountIndex(['type' => 1, 'boo' => -1], false);
        $this->queue->ensureCountIndex(['another.sub' => 1], true);

        $indexes = iterator_to_array($this->collection->listIndexes());
        $this->assertSame(3, count($indexes));

        $expectedOne = ['payload.type' => 1, 'payload.boo' => -1];
        $this->assertSame($expectedOne, $indexes[1]['key']);

        $expectedTwo = ['earliestGet' => 1, 'payload.another.sub' => 1];
        $this->assertSame($expectedTwo, $indexes[2]['key']);
    }

    /**
     * @test
     * @covers ::ensureCountIndex
     */
    public function ensureCountIndexWithPrefixOfPrevious()
    {
        $this->queue->ensureCountIndex(['type' => 1, 'boo' => -1], false);
        $this->queue->ensureCountIndex(['type' => 1], false);

        $indexes = iterator_to_array($this->collection->listIndexes());
        $this->assertSame(2, count($indexes));

        $expected = ['payload.type' => 1, 'payload.boo' => -1];
        $this->assertSame($expected, $indexes[1]['key']);
    }

    /**
     * @test
     * @covers ::ensureCountIndex
     * @expectedException \InvalidArgumentException
     */
    public function ensureCountIndexWithNonStringKey()
    {
        $this->queue->ensureCountIndex([0 => 1], false);
    }

    /**
     * @test
     * @covers ::ensureCountIndex
     * @expectedException \InvalidArgumentException
     */
    public function ensureCountIndexWithBadValue()
    {
        $this->queue->ensureCountIndex(['field' => 'NotAnInt'], false);
    }

    /**
     * @test
     * @covers ::get
     */
    public function getByBadQuery()
    {
        $this->queue->send(['key1' => 0, 'key2' => true]);

        $result = $this->queue->get(['key3' => 0], PHP_INT_MAX, 0);
        $this->assertNull($result);

        $this->assertSame(1, $this->collection->count());
    }

    /**
     * @test
     * @covers ::get
     */
    public function getWithNegativePollDuration()
    {
        $this->queue->send(['key1' => 0]);
        $this->assertNotNull($this->queue->get([], 0, 0, -1));
    }

    /**
     * @test
     * @covers ::get
     * @expectedException \InvalidArgumentException
     */
    public function getWithNonStringKey()
    {
        $this->queue->get([0 => 'a value'], 0);
    }

    /**
     * @test
     * @covers ::get
     */
    public function getByFullQuery()
    {
        $messageOne = ['id' => 'SHOULD BE REMOVED', 'key1' => 0, 'key2' => true];

        $this->queue->send($messageOne);
        $this->queue->send(['key' => 'value']);

        $result = $this->queue->get($messageOne, PHP_INT_MAX, 0);

        $this->assertNotSame($messageOne['id'], $result['id']);

        $messageOne['id'] = $result['id'];
        $this->assertSame($messageOne, $result);
    }

    /**
     * @test
     * @covers ::get
     */
    public function getBySubDocQuery()
    {
        $messageTwo = [
            'one' => [
                'two' => [
                    'three' => 5,
                    'notused' => 'notused',
                ],
                'notused' => 'notused',
            ],
            'notused' => 'notused',
        ];

        $this->queue->send(['key1' => 0, 'key2' => true]);
        $this->queue->send($messageTwo);

        $result = $this->queue->get(['one.two.three' => ['$gt' => 4]], PHP_INT_MAX, 0);
        $this->assertSame(['id' => $result['id']] + $messageTwo, $result);
    }

    /**
     * @test
     * @covers ::get
     */
    public function getBeforeAck()
    {
        $messageOne = ['key1' => 0, 'key2' => true];

        $this->queue->send($messageOne);
        $this->queue->send(['key' => 'value']);

        $this->queue->get($messageOne, PHP_INT_MAX, 0);

        //try get message we already have before ack
        $result = $this->queue->get($messageOne, PHP_INT_MAX, 0);
        $this->assertNull($result);
    }

    /**
     * @test
     * @covers ::get
     */
    public function getWithCustomPriority()
    {
        $messageOne = ['key' => 0];
        $messageTwo = ['key' => 1];
        $messageThree = ['key' => 2];

        $this->queue->send($messageOne, 0, 0.5);
        $this->queue->send($messageTwo, 0, 0.4);
        $this->queue->send($messageThree, 0, 0.3);

        $resultOne = $this->queue->get([], PHP_INT_MAX, 0);
        $resultTwo = $this->queue->get([], PHP_INT_MAX, 0);
        $resultThree = $this->queue->get([], PHP_INT_MAX, 0);

        $this->assertSame(['id' => $resultOne['id']] + $messageThree, $resultOne);
        $this->assertSame(['id' => $resultTwo['id']] + $messageTwo, $resultTwo);
        $this->assertSame(['id' => $resultThree['id']] + $messageOne, $resultThree);
    }

    /**
     * @test
     * @covers ::get
     */
    public function getWithTimeBasedPriority()
    {
        $messageOne = ['key' => 0];
        $messageTwo = ['key' => 1];
        $messageThree = ['key' => 2];

        $this->queue->send($messageOne);
        $this->queue->send($messageTwo);
        $this->queue->send($messageThree);

        $resultOne = $this->queue->get([], PHP_INT_MAX, 0);
        $resultTwo = $this->queue->get([], PHP_INT_MAX, 0);
        $resultThree = $this->queue->get([], PHP_INT_MAX, 0);

        $this->assertSame(['id' => $resultOne['id']] + $messageOne, $resultOne);
        $this->assertSame(['id' => $resultTwo['id']] + $messageTwo, $resultTwo);
        $this->assertSame(['id' => $resultThree['id']] + $messageThree, $resultThree);
    }

    /**
     * @test
     * @covers ::get
     */
    public function getWithTimeBasedPriorityWithOldTimestamp()
    {
        $messageOne = ['key' => 0];
        $messageTwo = ['key' => 1];
        $messageThree = ['key' => 2];

        $this->queue->send($messageOne);
        $this->queue->send($messageTwo);
        $this->queue->send($messageThree);

        $resultTwo = $this->queue->get([], PHP_INT_MAX, 0);
        //ensuring using old timestamp shouldn't affect normal time order of send()s
        $this->queue->requeue($resultTwo, 0, 0.0, false);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $resultOne = $this->queue->get([], PHP_INT_MAX, 0);
        $resultTwo = $this->queue->get([], PHP_INT_MAX, 0);
        $resultThree = $this->queue->get([], PHP_INT_MAX, 0);

        $this->assertSame(['id' => $resultOne['id']] + $messageOne, $resultOne);
        $this->assertSame(['id' => $resultTwo['id']] + $messageTwo, $resultTwo);
        $this->assertSame(['id' => $resultThree['id']] + $messageThree, $resultThree);
    }

    /**
     * @test
     * @covers ::get
     */
    public function getWait()
    {
        $start = microtime(true);

        $this->queue->get([], PHP_INT_MAX, 200);

        $end = microtime(true);

        $this->assertTrue($end - $start >= 0.200);
        $this->assertTrue($end - $start < 0.300);
    }

    /**
     * @test
     * @covers ::get
     */
    public function earliestGet()
    {
         $messageOne = ['key1' => 0, 'key2' => true];

         $this->queue->send($messageOne, time() + 1);

         $this->assertNull($this->queue->get($messageOne, PHP_INT_MAX, 0));

         sleep(1);

         $this->assertNotNull($this->queue->get($messageOne, PHP_INT_MAX, 0));
    }

    /**
     * @test
     * @covers ::get
     */
    public function resetStuck()
    {
        $messageOne = ['key' => 0];
        $messageTwo = ['key' => 1];

        $this->queue->send($messageOne);
        $this->queue->send($messageTwo);

        //sets to running
        $this->collection->updateOne(
            ['payload.key' => 0],
            ['$set' => ['earliestGet' => new \MongoDB\BSON\UTCDateTime(time() * 1000)]]
        );
        $this->collection->updateOne(
            ['payload.key' => 1],
            ['$set' => ['earliestGet' => new \MongoDB\BSON\UTCDateTime(time() * 1000)]]
        );

        $this->assertSame(
            2,
            $this->collection->count(
                ['earliestGet' => ['$lte' => new \MongoDB\BSON\UTCDateTime((int)(microtime(true) * 1000))]]
            )
        );

        //resets and gets messageOne
        $this->assertNotNull($this->queue->get($messageOne, PHP_INT_MAX, 0));

        $this->assertSame(
            1,
            $this->collection->count(
                ['earliestGet' => ['$lte' => new \MongoDB\BSON\UTCDateTime((int)(microtime(true) * 1000))]]
            )
        );
    }

    /**
     * @test
     * @covers ::count
     * @expectedException \InvalidArgumentException
     */
    public function countWithNonStringKey()
    {
        $this->queue->count([0 => 'a value']);
    }

    /**
     * @test
     * @covers ::count
     */
    public function testCount()
    {
        $message = ['boo' => 'scary'];

        $this->assertSame(0, $this->queue->count($message, true));
        $this->assertSame(0, $this->queue->count($message, false));
        $this->assertSame(0, $this->queue->count($message));

        $this->queue->send($message);
        $this->assertSame(1, $this->queue->count($message, false));
        $this->assertSame(0, $this->queue->count($message, true));
        $this->assertSame(1, $this->queue->count($message));

        $this->queue->get($message, PHP_INT_MAX, 0);
        $this->assertSame(0, $this->queue->count($message, false));
        $this->assertSame(1, $this->queue->count($message, true));
        $this->assertSame(1, $this->queue->count($message));
    }

    /**
     * @test
     * @covers ::ack
     */
    public function ack()
    {
        $messageOne = ['key1' => 0, 'key2' => true];

        $this->queue->send($messageOne);
        $this->queue->send(['key' => 'value']);

        $result = $this->queue->get($messageOne, PHP_INT_MAX, 0);
        $this->assertSame(2, $this->collection->count());

        $this->queue->ack($result);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $this->assertSame(1, $this->collection->count());
    }

    /**
     * @test
     * @covers ::ack
     * @expectedException \InvalidArgumentException
     */
    public function ackBadArg()
    {
        $this->queue->ack(['id' => new \stdClass()]);
    }

    /**
     * @test
     * @covers ::ackSend
     */
    public function ackSend()
    {
        $messageOne = ['key1' => 0, 'key2' => true];
        $messageThree = ['hi' => 'there', 'rawr' => 2];

        $this->queue->send($messageOne);
        $this->queue->send(['key' => 'value']);

        $resultOne = $this->queue->get($messageOne, PHP_INT_MAX, 0);
        $this->assertSame(2, $this->collection->count());

        $this->queue->ackSend($resultOne, $messageThree);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $this->assertSame(2, $this->collection->count());

        $actual = $this->queue->get(['hi' => 'there'], PHP_INT_MAX, 0);
        $expected = ['id' => $resultOne['id']] + $messageThree;

        $actual['id'] = $actual['id']->__toString();
        $expected['id'] = $expected['id']->__toString();
        $this->assertSame($expected, $actual);
    }

    /**
     * Verify earliestGet with ackSend.
     *
     * @test
     * @covers ::ackSend
     *
     * @return void
     */
    public function ackSendWithEarliestGet()
    {
        $message = ['key1' => 0, 'key2' => true];
        $this->queue->send($message);
        $result = $this->queue->get([], PHP_INT_MAX, 0);
        $this->assertSame($message['key1'], $result['key1']);
        $this->assertSame($message['key2'], $result['key2']);
        $this->queue->ackSend($result, ['key1' => 1, 'key2' => 2], strtotime('+ 1 day'));
        $actual = $this->queue->get([], PHP_INT_MAX, 0);
        $this->assertNull($actual);
    }

    /**
     * @test
     * @covers ::ackSend
     * @expectedException \InvalidArgumentException
     */
    public function ackSendWithWrongIdType()
    {
        $this->queue->ackSend(['id' => 5], []);
    }

    /**
     * @test
     * @covers ::ackSend
     * @expectedException \InvalidArgumentException
     */
    public function ackSendWithNanPriority()
    {
        $this->queue->ackSend(['id' => new \MongoDB\BSON\ObjectID()], [], 0, NAN);
    }

    /**
     * @test
     * @covers ::ackSend
     */
    public function ackSendWithHighEarliestGet()
    {
        $this->queue->send([]);
        $messageToAck = $this->queue->get([], PHP_INT_MAX, 0);

        $this->queue->ackSend($messageToAck, [], PHP_INT_MAX);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $this->assertSingleMessage(
            [
                'payload' => [],
                'earliestGet' => (new UTCDateTime(Queue::MONGO_INT32_MAX))->toDateTime()->getTimestamp(),
                'priority' => 0.0,
            ]
        );
    }

    /**
     * @covers ::ackSend
     */
    public function ackSendWithLowEarliestGet()
    {
        $this->queue->send([]);
        $messageToAck = $this->queue->get([], PHP_INT_MAX, 0);

        $this->queue->ackSend($messageToAck, [], -1);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}

        $this->assertSingleMessage(
            [
                'payload' => [],
                'earliestGet' => 0,
                'priority' => 0.0,
            ]
        );
    }

    /**
     * @test
     * @covers ::requeue
     */
    public function requeue()
    {
        $messageOne = ['key1' => 0, 'key2' => true];

        $this->queue->send($messageOne);
        $this->queue->send(['key' => 'value']);

        $resultBeforeRequeue = $this->queue->get($messageOne, PHP_INT_MAX, 0);

        $this->queue->requeue($resultBeforeRequeue);
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        $this->assertSame(2, $this->collection->count());

        $resultAfterRequeue = $this->queue->get($messageOne, 0);
        $this->assertSame(['id' => $resultAfterRequeue['id']] + $messageOne, $resultAfterRequeue);
    }

    /**
     * @test
     * @covers ::requeue
     * @expectedException \InvalidArgumentException
     */
    public function requeueBadArg()
    {
        $this->queue->requeue(['id' => new \stdClass()]);
    }

    /**
     * @test
     * @covers ::send
     */
    public function send()

    {
        $payload = ['key1' => 0, 'key2' => true];
        $this->queue->send($payload, 34, 0.8);

        $this->assertSingleMessage(
            [
                'payload' => $payload,
                'earliestGet' => 34,
                'priority' => 0.8,
            ]
        );
    }

    /**
     * @test
     * @covers ::send
     * @expectedException \InvalidArgumentException
     */
    public function sendWithNanPriority()
    {
        $this->queue->send([], 0, NAN);
    }

    /**
     * @test
     * @covers ::send
     */
    public function sendWithHighEarliestGet()
    {
        $this->queue->send([], PHP_INT_MAX);

        $this->assertSingleMessage(
            [
                'payload' => [],
                'earliestGet' => (new UTCDateTime(Queue::MONGO_INT32_MAX))->toDateTime()->getTimestamp(),
                'priority' => 0.0,
            ]
        );
    }

    /**
     * @test
     * @covers ::send
     */
    public function sendWithLowEarliestGet()
    {
        $this->queue->send([], -1);

        $this->assertSingleMessage(
            [
                'payload' => [],
                'earliestGet' => 0,
                'priority' => 0.0,
            ]
        );
    }

    /**
     * Verify Queue can be constructed with \MongoDB\Collection
     *
     * @test
     * @covers ::__construct
     *
     * @return void
     */
    public function constructWithCollection()

    {
        $queue = new Queue($this->collection);

        $payload = ['key1' => 0, 'key2' => true];
        $queue->send($payload, 34, 0.8);

        $this->assertSingleMessage(
            [
                'payload' => $payload,
                'earliestGet' => 34,
                'priority' => 0.8,
            ]
        );

    }

    private function assertSingleMessage(array $expected)
    {
        $this->assertSame(1, $this->collection->count());

        $message = $this->collection->findOne();

        $this->assertLessThanOrEqual(time(), $message['created']->toDateTime()->getTimestamp());
        $this->assertGreaterThan(time() - 10, $message['created']->toDateTime()->getTimestamp());

        unset($message['_id'], $message['created']);
        $message['earliestGet'] = (int)$message['earliestGet']->toDateTime()->getTimestamp();

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


traderinteractive / mongo-queue-php