ProcessQueueTest::testConstructWithArgs() - Code Metrics - Inspection of "Added invalid current working directory exception..." - epfremmer/process-queue - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Branch — develop (ff0d26)

by Edward

created 2015-12-22 19:42 UTC

ProcessQueueTest::testConstructWithArgs() A

↳ Parent: ProcessQueueTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	7
rs	9.4286
cc	1
eloc	4
nc	1
nop	0

<?php
/**
 * File ProcessQueueTest.php
 *
 * @author Edward Pfremmer <[email protected]>
 */
namespace Epfremme\ProcessQueue\Tests\Process;

use Epfremme\Collection\Collection;
use Epfremme\ProcessQueue\System\ProcessorCounter;
use Epfremme\ProcessQueue\Process\ProcessQueue;
use GuzzleHttp\Promise\Promise;
use Symfony\Component\Process\Process;

/**
 * Class ProcessQueueTest
 *
 * @package Epfremme\ProcessQueue\Tests\Process
 */
class ProcessQueueTest extends \PHPUnit_Framework_TestCase
{
    /**
     * Add optional promise to process options
     *
     * @param Process $process
     * @return Promise
     */
    private function addPromise(Process $process)
    {
        /** @var Promise $promise */
        $promise = new Promise(function() use ($process, &$promise) {
            $process->wait();
            $promise->resolve($process);
        });

        $process->setOptions([ProcessQueue::PROMISE_KEY => $promise]);

        return $promise;
    }

    public function testConstruct()
    {
        $queue = new ProcessQueue();
        $counter = new ProcessorCounter();

        $this->assertInstanceOf(\Countable::class, $queue);
        $this->assertAttributeEquals($counter->getCpuCount(), 'limit', $queue);
    }

    public function testConstructWithArgs()
    {
        $queue = new ProcessQueue(4);

        $this->assertInstanceOf(\Countable::class, $queue);
        $this->assertAttributeEquals(4, 'limit', $queue);
    }

    /** @expectedException \InvalidArgumentException */
    public function testConstructException()
    {
        new ProcessQueue([new \ArrayObject()]);
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
    }

    public function testAdd()
    {
        $queue = new ProcessQueue();
        $process = new Process('pwd');

        $queue->add($process);

        $this->assertNotEmpty($queue);
        $this->assertCount(1, $queue);
    }

    /** @depends testAdd */
    public function testGetPending()
    {
        $queue = new ProcessQueue();
        $process = new Process('pwd');

        $queue->add($process);

        $pending = $queue->getPending();

        $this->assertInstanceOf(Collection::class, $pending);
        $this->assertContainsOnly(Process::class, $pending);
        $this->assertInstanceOf(Process::class, $pending->get(0));
        $this->assertSame($process, $pending->get(0));
    }

    /** @depends testAdd */
    public function testGetRunning()

    {
        $queue = new ProcessQueue();
        $process = new Process('sleep 0.1');

        $queue->add($process);

        $this->assertEmpty($queue->getRunning());

        $process->start();

        $running = $queue->getRunning();

        $this->assertInstanceOf(Collection::class, $running);
        $this->assertContainsOnly(Process::class, $running);
        $this->assertInstanceOf(Process::class, $running->get(0));
        $this->assertSame($process, $running->get(0));
    }

    /** @depends testAdd */
    public function testGetCompleted()

    {
        $queue = new ProcessQueue();
        $process = new Process('pwd');

        $queue->add($process);

        $this->assertEmpty($queue->getCompleted());

        $process->run();

        $completed = $queue->getCompleted();

        $this->assertInstanceOf(Collection::class, $completed);
        $this->assertContainsOnly(Process::class, $completed);
        $this->assertInstanceOf(Process::class, $completed->get(0));
        $this->assertSame($process, $completed->get(0));
    }

    /** @depends testAdd */
    public function testResolve()
    {
        $queue = new ProcessQueue();
        $process = new Process('pwd');

        $queue->add($process);
        $process->run();
        $queue->resolve($process);

        $this->assertEmpty($queue);
        $this->assertCount(0, $queue);
        $this->assertTrue($process->isTerminated());
    }

    /** @depends testAdd */
    public function testResolveWithPromise()
    {
        $queue = new ProcessQueue();
        $process = new Process('pwd');
        $promise = $this->addPromise($process);

        $isResolved = false;
        $promise->then(function() use (&$isResolved) {
            $isResolved = true;
        });

        $this->assertFalse($isResolved);

        $queue->add($process);
        $process->run();
        $queue->resolve($process);

        $this->assertEmpty($queue);
        $this->assertCount(0, $queue);
        $this->assertTrue($isResolved);
        $this->assertTrue($process->isTerminated());
    }

    /** @depends testAdd */
    public function testInvoke()
    {
        $queue = new ProcessQueue();
        $process = new Process('pwd');

        $queue->add($process);

        /** @var Process $pending */
        foreach ($queue() as $pending) {
            $this->assertInstanceOf(Process::class, $pending);
            $this->assertFalse($pending->isStarted());

            $pending->start();
        }

        $this->assertEmpty($queue);
        $this->assertCount(0, $queue);
        $this->assertTrue($process->isTerminated());
    }
}


1		<?php
2		/**
3		* File ProcessQueueTest.php
4		*
5		* @author Edward Pfremmer <[email protected]>
6		*/
7		namespace Epfremme\ProcessQueue\Tests\Process;
8
9		use Epfremme\Collection\Collection;
10		use Epfremme\ProcessQueue\System\ProcessorCounter;
11		use Epfremme\ProcessQueue\Process\ProcessQueue;
12		use GuzzleHttp\Promise\Promise;
13		use Symfony\Component\Process\Process;
14
15		/**
16		* Class ProcessQueueTest
17		*
18		* @package Epfremme\ProcessQueue\Tests\Process
19		*/
20		class ProcessQueueTest extends \PHPUnit_Framework_TestCase
21		{
22		/**
23		* Add optional promise to process options
24		*
25		* @param Process $process
26		* @return Promise
27		*/
28		private function addPromise(Process $process)
29		{
30		/** @var Promise $promise */
31		$promise = new Promise(function() use ($process, &$promise) {
32		$process->wait();
33		$promise->resolve($process);
34		});
35
36		$process->setOptions([ProcessQueue::PROMISE_KEY => $promise]);
37
38		return $promise;
39		}
40
41		public function testConstruct()
42		{
43		$queue = new ProcessQueue();
44		$counter = new ProcessorCounter();
45
46		$this->assertInstanceOf(\Countable::class, $queue);
47		$this->assertAttributeEquals($counter->getCpuCount(), 'limit', $queue);
48		}
49
50		public function testConstructWithArgs()
51		{
52		$queue = new ProcessQueue(4);
53
54		$this->assertInstanceOf(\Countable::class, $queue);
55		$this->assertAttributeEquals(4, 'limit', $queue);
56		}
57
58		/** @expectedException \InvalidArgumentException */
59		public function testConstructException()
60		{
61		new ProcessQueue([new \ArrayObject()]);
		0 ignored issues – show Documentation introduced 2015-12-22 19:45 UTC by Report Bug Copy Issue Report `array(new \ArrayObject())` is of type `array<integer,object<Arr..."object<ArrayObject>"}>`, but the function expects a `integer\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
62		}
63
64		public function testAdd()
65		{
66		$queue = new ProcessQueue();
67		$process = new Process('pwd');
68
69		$queue->add($process);
70
71		$this->assertNotEmpty($queue);
72		$this->assertCount(1, $queue);
73		}
74
75		/** @depends testAdd */
76		public function testGetPending()
77		{
78		$queue = new ProcessQueue();
79		$process = new Process('pwd');
80
81		$queue->add($process);
82
83		$pending = $queue->getPending();
84
85		$this->assertInstanceOf(Collection::class, $pending);
86		$this->assertContainsOnly(Process::class, $pending);
87		$this->assertInstanceOf(Process::class, $pending->get(0));
88		$this->assertSame($process, $pending->get(0));
89		}
90
91		/** @depends testAdd */
92	View Code Duplication	public function testGetRunning()
		0 ignored issues – show Duplication introduced 2015-12-22 19:45 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
93		{
94		$queue = new ProcessQueue();
95		$process = new Process('sleep 0.1');
96
97		$queue->add($process);
98
99		$this->assertEmpty($queue->getRunning());
100
101		$process->start();
102
103		$running = $queue->getRunning();
104
105		$this->assertInstanceOf(Collection::class, $running);
106		$this->assertContainsOnly(Process::class, $running);
107		$this->assertInstanceOf(Process::class, $running->get(0));
108		$this->assertSame($process, $running->get(0));
109		}
110
111		/** @depends testAdd */
112	View Code Duplication	public function testGetCompleted()
		0 ignored issues – show Duplication introduced 2015-12-22 19:45 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
113		{
114		$queue = new ProcessQueue();
115		$process = new Process('pwd');
116
117		$queue->add($process);
118
119		$this->assertEmpty($queue->getCompleted());
120
121		$process->run();
122
123		$completed = $queue->getCompleted();
124
125		$this->assertInstanceOf(Collection::class, $completed);
126		$this->assertContainsOnly(Process::class, $completed);
127		$this->assertInstanceOf(Process::class, $completed->get(0));
128		$this->assertSame($process, $completed->get(0));
129		}
130
131		/** @depends testAdd */
132		public function testResolve()
133		{
134		$queue = new ProcessQueue();
135		$process = new Process('pwd');
136
137		$queue->add($process);
138		$process->run();
139		$queue->resolve($process);
140
141		$this->assertEmpty($queue);
142		$this->assertCount(0, $queue);
143		$this->assertTrue($process->isTerminated());
144		}
145
146		/** @depends testAdd */
147		public function testResolveWithPromise()
148		{
149		$queue = new ProcessQueue();
150		$process = new Process('pwd');
151		$promise = $this->addPromise($process);
152
153		$isResolved = false;
154		$promise->then(function() use (&$isResolved) {
155		$isResolved = true;
156		});
157
158		$this->assertFalse($isResolved);
159
160		$queue->add($process);
161		$process->run();
162		$queue->resolve($process);
163
164		$this->assertEmpty($queue);
165		$this->assertCount(0, $queue);
166		$this->assertTrue($isResolved);
167		$this->assertTrue($process->isTerminated());
168		}
169
170		/** @depends testAdd */
171		public function testInvoke()
172		{
173		$queue = new ProcessQueue();
174		$process = new Process('pwd');
175
176		$queue->add($process);
177
178		/** @var Process $pending */
179		foreach ($queue() as $pending) {
180		$this->assertInstanceOf(Process::class, $pending);
181		$this->assertFalse($pending->isStarted());
182
183		$pending->start();
184		}
185
186		$this->assertEmpty($queue);
187		$this->assertCount(0, $queue);
188		$this->assertTrue($process->isTerminated());
189		}
190		}
191

epfremmer / process-queue

Branch — develop (ff0d26)

ProcessQueueTest::testConstructWithArgs() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like