InMemoryRulesTest::rulesLimitProcessorAndMemoryUsage() - Code Metrics - asyncphp/doorman - Measure and Improve Code Quality continuously with Scrutinizer

rulesLimitProcessorAndMemoryUsage() A
last analyzed 2020-05-18 21:01 UTC

↳ Parent: InMemoryRulesTest

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	54
rs	9.0036
c	0
b	0
f	0
cc	1
nc	1
nop	0

How to fix Long Method

<?php

namespace AsyncPHP\Doorman\Tests\Rules;

use AsyncPHP\Doorman\Profile\InMemoryProfile;
use AsyncPHP\Doorman\Rule\InMemoryRule;
use AsyncPHP\Doorman\Rules\InMemoryRules;
use AsyncPHP\Doorman\Task\ProcessCallbackTask;
use AsyncPHP\Doorman\Tests\Test;

/**
 * @covers AsyncPHP\Doorman\Rules\InMemoryRules
 */
class InMemoryRulesTest extends Test
{
    /**
     * @var InMemoryRules
     */
    protected $rules;

    /**
     * @inheritdoc
     */
    public function setUp()
    {
        parent::setUp();

        $this->rules = new InMemoryRules();
    }

    /**
     * @test
     */
    public function rulesLimitParallelProcesses()
    {
        $task1 = new ProcessCallbackTask(function () {
            return;
        });

        $task2 = new ProcessCallbackTask(function () {
            return;
        });

        $profile1 = new InMemoryProfile();
        $profile1->setProcesses(array());

        $profile2 = new InMemoryProfile();
        $profile2->setProcesses(array($task1));

        $this->assertTrue($this->rules->canRunTask($task2, $profile2));

        $rule1 = new InMemoryRule();
        $rule1->setProcesses(null);
        $rule1->setMinimumProcessorUsage(0);
        $rule1->setMaximumProcessorUsage(100);

        $this->rules->addRule($rule1);

        $this->assertTrue($this->rules->canRunTask($task2, $profile2));

        $this->assertTrue($this->rules->canRunTask($task2, $profile1));

        $rule2 = new InMemoryRule();
        $rule2->setProcesses(1);
        $rule2->setMinimumProcessorUsage(0);
        $rule2->setMaximumProcessorUsage(100);

        $this->rules->removeRule($rule1)->addRule($rule2);

        $this->assertFalse($this->rules->canRunTask($task2, $profile2));

        $rule3 = new InMemoryRule();
        $rule3->setProcesses(2);
        $rule3->setMinimumProcessorUsage(0);
        $rule3->setMaximumProcessorUsage(100);

        $this->rules->removeRule($rule2)->addRule($rule3);

        $this->assertTrue($this->rules->canRunTask($task2, $profile2));
    }

    /**
     * @test
     */
    public function rulesLimitProcessorAndMemoryUsage()
    {
        $task1 = new ProcessCallbackTask(function () {
            return;
        });

        $task2 = new ProcessCallbackTask(function () {
            return;
        });

        $rule1 = new InMemoryRule();
        $rule1->setProcesses(1);
        $rule1->setMinimumProcessorUsage(50);
        $rule1->setMaximumProcessorUsage(100);

        $profile1 = new InMemoryProfile();
        $profile1->setProcesses(array($task1));
        $profile1->setProcessorLoad(75);

        $this->assertFalse($this->rules->addRule($rule1)->canRunTask($task2, $profile1));

        $rule2 = new InMemoryRule();
        $rule2->setProcesses(1);
        $rule2->setMinimumMemoryUsage(50);
        $rule2->setMaximumMemoryUsage(100);

        $profile2 = new InMemoryProfile();
        $profile2->setProcesses(array($task1));
        $profile2->setMemoryLoad(75);

        $this->assertFalse($this->rules->removeRule($rule1)->addRule($rule2)->canRunTask($task2, $profile2));

        $rule3 = new InMemoryRule();
        $rule3->setProcesses(1);
        $rule3->setMinimumSiblingProcessorUsage(50);
        $rule3->setMaximumSiblingProcessorUsage(100);

        $profile3 = new InMemoryProfile();
        $profile3->setSiblingProcesses(array($task1));
        $profile3->setSiblingProcessorLoad(75);

        $this->assertFalse($this->rules->removeRule($rule2)->addRule($rule3)->canRunTask($task2, $profile3));

        $rule4 = new InMemoryRule();
        $rule4->setProcesses(1);
        $rule4->setMinimumSiblingMemoryUsage(50);
        $rule4->setMaximumSiblingMemoryUsage(100);

        $profile4 = new InMemoryProfile();
        $profile4->setSiblingProcesses(array($task1));
        $profile4->setSiblingMemoryLoad(75);

        $this->assertFalse($this->rules->removeRule($rule3)->addRule($rule4)->canRunTask($task2, $profile4));
    }
}


1			<?php
2
3			namespace AsyncPHP\Doorman\Tests\Rules;
4
5			use AsyncPHP\Doorman\Profile\InMemoryProfile;
6			use AsyncPHP\Doorman\Rule\InMemoryRule;
7			use AsyncPHP\Doorman\Rules\InMemoryRules;
8			use AsyncPHP\Doorman\Task\ProcessCallbackTask;
9			use AsyncPHP\Doorman\Tests\Test;
10
11			/**
12			* @covers AsyncPHP\Doorman\Rules\InMemoryRules
13			*/
14			class InMemoryRulesTest extends Test
15			{
16			/**
17			* @var InMemoryRules
18			*/
19			protected $rules;
20
21			/**
22			* @inheritdoc
23			*/
24			public function setUp()
25			{
26			parent::setUp();
27
28			$this->rules = new InMemoryRules();
29			}
30
31			/**
32			* @test
33			*/
34			public function rulesLimitParallelProcesses()
35			{
36			$task1 = new ProcessCallbackTask(function () {
37			return;
38			});
39
40			$task2 = new ProcessCallbackTask(function () {
41			return;
42			});
43
44			$profile1 = new InMemoryProfile();
45			$profile1->setProcesses(array());
46
47			$profile2 = new InMemoryProfile();
48			$profile2->setProcesses(array($task1));
49
50			$this->assertTrue($this->rules->canRunTask($task2, $profile2));
51
52			$rule1 = new InMemoryRule();
53			$rule1->setProcesses(null);
54			$rule1->setMinimumProcessorUsage(0);
55			$rule1->setMaximumProcessorUsage(100);
56
57			$this->rules->addRule($rule1);
58
59			$this->assertTrue($this->rules->canRunTask($task2, $profile2));
60
61			$this->assertTrue($this->rules->canRunTask($task2, $profile1));
62
63			$rule2 = new InMemoryRule();
64			$rule2->setProcesses(1);
65			$rule2->setMinimumProcessorUsage(0);
66			$rule2->setMaximumProcessorUsage(100);
67
68			$this->rules->removeRule($rule1)->addRule($rule2);
69
70			$this->assertFalse($this->rules->canRunTask($task2, $profile2));
71
72			$rule3 = new InMemoryRule();
73			$rule3->setProcesses(2);
74			$rule3->setMinimumProcessorUsage(0);
75			$rule3->setMaximumProcessorUsage(100);
76
77			$this->rules->removeRule($rule2)->addRule($rule3);
78
79			$this->assertTrue($this->rules->canRunTask($task2, $profile2));
80			}
81
82			/**
83			* @test
84			*/
85			public function rulesLimitProcessorAndMemoryUsage()
86			{
87			$task1 = new ProcessCallbackTask(function () {
88			return;
89			});
90
91			$task2 = new ProcessCallbackTask(function () {
92			return;
93			});
94
95			$rule1 = new InMemoryRule();
96			$rule1->setProcesses(1);
97			$rule1->setMinimumProcessorUsage(50);
98			$rule1->setMaximumProcessorUsage(100);
99
100			$profile1 = new InMemoryProfile();
101			$profile1->setProcesses(array($task1));
102			$profile1->setProcessorLoad(75);
103
104			$this->assertFalse($this->rules->addRule($rule1)->canRunTask($task2, $profile1));
105
106			$rule2 = new InMemoryRule();
107			$rule2->setProcesses(1);
108			$rule2->setMinimumMemoryUsage(50);
109			$rule2->setMaximumMemoryUsage(100);
110
111			$profile2 = new InMemoryProfile();
112			$profile2->setProcesses(array($task1));
113			$profile2->setMemoryLoad(75);
114
115			$this->assertFalse($this->rules->removeRule($rule1)->addRule($rule2)->canRunTask($task2, $profile2));
116
117			$rule3 = new InMemoryRule();
118			$rule3->setProcesses(1);
119			$rule3->setMinimumSiblingProcessorUsage(50);
120			$rule3->setMaximumSiblingProcessorUsage(100);
121
122			$profile3 = new InMemoryProfile();
123			$profile3->setSiblingProcesses(array($task1));
124			$profile3->setSiblingProcessorLoad(75);
125
126			$this->assertFalse($this->rules->removeRule($rule2)->addRule($rule3)->canRunTask($task2, $profile3));
127
128			$rule4 = new InMemoryRule();
129			$rule4->setProcesses(1);
130			$rule4->setMinimumSiblingMemoryUsage(50);
131			$rule4->setMaximumSiblingMemoryUsage(100);
132
133			$profile4 = new InMemoryProfile();
134			$profile4->setSiblingProcesses(array($task1));
135			$profile4->setSiblingMemoryLoad(75);
136
137			$this->assertFalse($this->rules->removeRule($rule3)->addRule($rule4)->canRunTask($task2, $profile4));
138			}
139			}
140

asyncphp / doorman

rulesLimitProcessorAndMemoryUsage() A last analyzed 2020-05-18 21:01 UTC

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

rulesLimitProcessorAndMemoryUsage() A
last analyzed 2020-05-18 21:01 UTC