MockModules - Code Metrics - Inspection of "fix #69 : htmlentities ne doit pas forcer le chars..." - bfw-systems/bfw - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 2.2 ( f4c653...5ece81 )

by Vermeulen

created 2016-08-05 04:57 UTC

MockModules A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	15
Duplicated Lines	0 %

Coupling/Cohesion

Components	0
Dependencies	1

Importance

Changes	3
Bugs	0	Features	1

Metric	Value
wmc	2
c	3
b	0
f	1
lcom	0
cbo	1
dl	0
loc	15
rs	10

<?php
/**
 * Fichier de test pour une class
 */

namespace BFW\test\unit;
use \atoum;

require_once(__DIR__.'/../common.php');

/**
 * Test de la class Modules
 */
class Modules extends atoum
{
    /**
     * @var $class : Instance de la class Modules
     */
    protected $class;

    /**
     * @var $mock : Instance du mock pour la class Modules
     */
    protected $mock;

    /**
     * Instanciation de la class avant chaque méthode de test
     */
    public function beforeTestMethod($testMethod)
    {
        //$this->class = new \BFW\Modules();
        $this->mock  = new MockModules();
    }

    /**
     * Test du constructeur : Modules()
     */
    public function testModules()
    {
        $this->mock  = new MockModules();
        $this->object($this->mock->_kernel)->isInstanceOf('\BFW\Kernel');
    }

    /**
     * Test de la méthode newMod($name, $params=array())
     */
    public function testNewMod()
    {
        $this->mock->newMod('test');
        
        $this->array($this->mock->modList['test'])->isEqualTo(array(
            'name' => 'test',
            'time' => modulesLoadTime_EndInit,
            'require' => array(),
            'runFile' => 'inclus.php',
            'priority' => 0
        ));
        
        $this->mock->newMod('test2', array(
            'require' => 'test',
            'time'    => modulesLoadTime_Visiteur,
            'priority' => 1
        ));
        $this->array($this->mock->modList['test2'])->isEqualTo(array(
            'name' => 'test2',
            'time' => modulesLoadTime_Visiteur,
            'require' => array('test'),
            'runFile' => 'inclus.php',
            'priority' => 1
        ));
        
        $mock = $this->mock;
        $this->exception(function() use($mock)
        {
            $mock->newMod('test');
        })->message->contains('Le module test existe déjà.');
        
        $this->exception(function() use($mock)
        {
            $mock->newMod('testFail', 'test');
        })->message->contains('Les options du module testFail doivent être déclarer sous la forme d\'un array.');
    }

    /**
     * Test de la méthode exists($name)
     */
    public function testExists()
    {
        $this->mock->newMod('test');
        $this->boolean($this->mock->exists('test'))->isTrue();
        $this->boolean($this->mock->exists('test2'))->isFalse();
    }

    /**
     * Test de la méthode isLoad($name)
     */
    public function testIsLoad()
    {
        $this->mock->newMod('test');
        $this->boolean($this->mock->isLoad('test'))->isFalse();
        $this->boolean($this->mock->isLoad('test2'))->isFalse();
        
        $this->mock->loaded('test');
        $this->boolean($this->mock->isLoad('test'))->isTrue();
    }

    /**
     * Test de la méthode loaded($name)
     */
    public function testLoaded()
    {
        $this->mock->newMod('test');
        $this->mock->loaded('test');
        
        $this->array($this->mock->modLoad)->isEqualTo(array(0 => 'test'));
        
        $mock = $this->mock;
        $this->exception(function() use($mock)
        {
            $mock->loaded('test2');
        })->message->contains('Module test2 not exists.');
    }

    /**
     * Test de la méthode addPath($name, $path)
     */
    public function testAddPath()
    {
        $mock = $this->mock;
        $this->exception(function() use($mock)
        {
            $mock->addPath('test', 'path');
        })->message->contains('Le module test n\'existe pas.');
        
        $this->mock->newMod('test');
        $mock->addPath('test', 'path');
        $this->string($this->mock->modList['test']['path'])->isEqualTo('path');
    }

    /**
     * Test de la méthode listToLoad($timeToLoad)
     */
    public function testListToLoad()
    {
        $this->array($this->mock->listToLoad('time'))->isEqualTo(array());
        $this->mock->newMod('test');
        
        $this->array($this->mock->listToLoad(modulesLoadTime_EndInit))->isEqualTo(array('test'));
    }

    /**
     * Test de la méthode modToLoad($mod, &$arrayToLoad)
     */
    public function testModToLoad()
    {
        $arrayToLoad = array();
        $this->mock->newMod('test');
        
        //Test d'un module sans dépendance et non chargé
        $testModInfos = $this->mock->modList['test'];
        $this->boolean($this->mock->modToLoad($testModInfos, $arrayToLoad))->isTrue();
        
        //Test d'un module sans dépendance et déjà chargé
        $testModInfos = $this->mock->modList['test'];
        $this->boolean($this->mock->modToLoad($testModInfos, $arrayToLoad))->isTrue();
        
        //Test d'un module avec dépendance sans erreur
        $this->mock->newMod('test2', array('require' => 'test'));
        $test2ModInfos = $this->mock->modList['test'];
        $this->boolean($this->mock->modToLoad($test2ModInfos, $arrayToLoad))->isTrue();
        
        $mock = &$this->mock;
        
        //Test d'un module avec une dépendance qui n'existe pas dans la liste des modules
        $this->mock->newMod('test3', array('require' => 'notExist'));
        $this->exception(function() use($mock, $arrayToLoad)
        {
            $test3ModInfos = $mock->modList['test3'];
            $mock->modToLoad($test3ModInfos, $arrayToLoad);
        })->message->contains('La dépendance notExist du module test3 n\'a pas été trouvé.');
        
        //Test d'un module avec une dépendance qui existe mais qui n'est pas chargé.
        $this->mock->newMod('test4', array('time' => modulesLoadTime_EndInit));
        $this->mock->newMod('test5', array(
            'time'    => modulesLoadTime_Visiteur,
            'require' => 'test4'
        ));
    }

    /**
     * Test de la méthode listNotLoad($regen=false)
     */
    public function testListNotLoad()
    {
        //Aucun module existe, donc la liste est vide et automatiquement généré
        $this->array($this->mock->listNotLoad())->isEqualTo(array());
        
        $this->mock->newMod('test');
        
        //La liste est toujours vide car non regénéré
        $this->array($this->mock->listNotLoad())->isEqualTo(array());
        
        //La liste est regénéré
        $this->array($this->mock->listNotLoad(true))->isEqualTo(array(
            'test' => array(
                'name'    => 'test',
                'time'    => 'endInit',
                'require' => array(),
                'runFile' => 'inclus.php',
                'priority' => 0
            )
        ));
    }

    /**
     * Test de la méthode isModulesNotLoad()
     */
    public function testIsModulesNotLoad()
    {
        $this->boolean($this->mock->isModulesNotLoad())->isFalse();
        
        $this->mock->newMod('test');
        $this->boolean($this->mock->isModulesNotLoad())->isFalse(); //Cache
        
        $this->mock->listNotLoad(true); //Kill le cache
        $this->boolean($this->mock->isModulesNotLoad())->isTrue();
    }

    /**
     * Test de la méthode getModuleInfos($name)
     */
    public function testGetModuleInfos()
    {
        $this->mock->newMod('test');
        $this->array($this->mock->getModuleInfos('test'))->isEqualTo(array(
            'name'    => 'test',
            'time'    => 'endInit',
            'require' => array(),
            'runFile' => 'inclus.php',
            'priority' => 0
        ));
        
        $mock = $this->mock;
        $this->exception(function() use($mock)
        {
            $mock->getModuleInfos('test2');
        })->message->contains('Le module test2 n\'existe pas.');
    }

}

/**
 * Mock pour la classe Modules
 */
class MockModules extends \BFW\Modules
{
    /**
     * Accesseur get
     */
    public function __get($name) {return $this->$name;}

    /**
     * Test de la méthode modToLoad(&$mod, &$arrayToLoad, $waitToLoad)
     */
    public function modToLoad(&$mod, &$arrayToLoad, $waitToLoad=array())
    {
        return parent::modToLoad($mod, $arrayToLoad, $waitToLoad);
    }
}


1			<?php
2			/**
3			* Fichier de test pour une class
4			*/
5
6			namespace BFW\test\unit;
7			use \atoum;
8
9			require_once(__DIR__.'/../common.php');
10
11			/**
12			* Test de la class Modules
13			*/
14			class Modules extends atoum
15			{
16			/**
17			* @var $class : Instance de la class Modules
18			*/
19			protected $class;
20
21			/**
22			* @var $mock : Instance du mock pour la class Modules
23			*/
24			protected $mock;
25
26			/**
27			* Instanciation de la class avant chaque méthode de test
28			*/
29			public function beforeTestMethod($testMethod)
30			{
31			//$this->class = new \BFW\Modules();
32			$this->mock = new MockModules();
33			}
34
35			/**
36			* Test du constructeur : Modules()
37			*/
38			public function testModules()
39			{
40			$this->mock = new MockModules();
41			$this->object($this->mock->_kernel)->isInstanceOf('\BFW\Kernel');
42			}
43
44			/**
45			* Test de la méthode newMod($name, $params=array())
46			*/
47			public function testNewMod()
48			{
49			$this->mock->newMod('test');
50
51			$this->array($this->mock->modList['test'])->isEqualTo(array(
52			'name' => 'test',
53			'time' => modulesLoadTime_EndInit,
54			'require' => array(),
55			'runFile' => 'inclus.php',
56			'priority' => 0
57			));
58
59			$this->mock->newMod('test2', array(
60			'require' => 'test',
61			'time' => modulesLoadTime_Visiteur,
62			'priority' => 1
63			));
64			$this->array($this->mock->modList['test2'])->isEqualTo(array(
65			'name' => 'test2',
66			'time' => modulesLoadTime_Visiteur,
67			'require' => array('test'),
68			'runFile' => 'inclus.php',
69			'priority' => 1
70			));
71
72			$mock = $this->mock;
73			$this->exception(function() use($mock)
74			{
75			$mock->newMod('test');
76			})->message->contains('Le module test existe déjà.');
77
78			$this->exception(function() use($mock)
79			{
80			$mock->newMod('testFail', 'test');
81			})->message->contains('Les options du module testFail doivent être déclarer sous la forme d\'un array.');
82			}
83
84			/**
85			* Test de la méthode exists($name)
86			*/
87			public function testExists()
88			{
89			$this->mock->newMod('test');
90			$this->boolean($this->mock->exists('test'))->isTrue();
91			$this->boolean($this->mock->exists('test2'))->isFalse();
92			}
93
94			/**
95			* Test de la méthode isLoad($name)
96			*/
97			public function testIsLoad()
98			{
99			$this->mock->newMod('test');
100			$this->boolean($this->mock->isLoad('test'))->isFalse();
101			$this->boolean($this->mock->isLoad('test2'))->isFalse();
102
103			$this->mock->loaded('test');
104			$this->boolean($this->mock->isLoad('test'))->isTrue();
105			}
106
107			/**
108			* Test de la méthode loaded($name)
109			*/
110			public function testLoaded()
111			{
112			$this->mock->newMod('test');
113			$this->mock->loaded('test');
114
115			$this->array($this->mock->modLoad)->isEqualTo(array(0 => 'test'));
116
117			$mock = $this->mock;
118			$this->exception(function() use($mock)
119			{
120			$mock->loaded('test2');
121			})->message->contains('Module test2 not exists.');
122			}
123
124			/**
125			* Test de la méthode addPath($name, $path)
126			*/
127			public function testAddPath()
128			{
129			$mock = $this->mock;
130			$this->exception(function() use($mock)
131			{
132			$mock->addPath('test', 'path');
133			})->message->contains('Le module test n\'existe pas.');
134
135			$this->mock->newMod('test');
136			$mock->addPath('test', 'path');
137			$this->string($this->mock->modList['test']['path'])->isEqualTo('path');
138			}
139
140			/**
141			* Test de la méthode listToLoad($timeToLoad)
142			*/
143			public function testListToLoad()
144			{
145			$this->array($this->mock->listToLoad('time'))->isEqualTo(array());
146			$this->mock->newMod('test');
147
148			$this->array($this->mock->listToLoad(modulesLoadTime_EndInit))->isEqualTo(array('test'));
149			}
150
151			/**
152			* Test de la méthode modToLoad($mod, &$arrayToLoad)
153			*/
154			public function testModToLoad()
155			{
156			$arrayToLoad = array();
157			$this->mock->newMod('test');
158
159			//Test d'un module sans dépendance et non chargé
160			$testModInfos = $this->mock->modList['test'];
161			$this->boolean($this->mock->modToLoad($testModInfos, $arrayToLoad))->isTrue();
162
163			//Test d'un module sans dépendance et déjà chargé
164			$testModInfos = $this->mock->modList['test'];
165			$this->boolean($this->mock->modToLoad($testModInfos, $arrayToLoad))->isTrue();
166
167			//Test d'un module avec dépendance sans erreur
168			$this->mock->newMod('test2', array('require' => 'test'));
169			$test2ModInfos = $this->mock->modList['test'];
170			$this->boolean($this->mock->modToLoad($test2ModInfos, $arrayToLoad))->isTrue();
171
172			$mock = &$this->mock;
173
174			//Test d'un module avec une dépendance qui n'existe pas dans la liste des modules
175			$this->mock->newMod('test3', array('require' => 'notExist'));
176			$this->exception(function() use($mock, $arrayToLoad)
177			{
178			$test3ModInfos = $mock->modList['test3'];
179			$mock->modToLoad($test3ModInfos, $arrayToLoad);
180			})->message->contains('La dépendance notExist du module test3 n\'a pas été trouvé.');
181
182			//Test d'un module avec une dépendance qui existe mais qui n'est pas chargé.
183			$this->mock->newMod('test4', array('time' => modulesLoadTime_EndInit));
184			$this->mock->newMod('test5', array(
185			'time' => modulesLoadTime_Visiteur,
186			'require' => 'test4'
187			));
188			}
189
190			/**
191			* Test de la méthode listNotLoad($regen=false)
192			*/
193			public function testListNotLoad()
194			{
195			//Aucun module existe, donc la liste est vide et automatiquement généré
196			$this->array($this->mock->listNotLoad())->isEqualTo(array());
197
198			$this->mock->newMod('test');
199
200			//La liste est toujours vide car non regénéré
201			$this->array($this->mock->listNotLoad())->isEqualTo(array());
202
203			//La liste est regénéré
204			$this->array($this->mock->listNotLoad(true))->isEqualTo(array(
205			'test' => array(
206			'name' => 'test',
207			'time' => 'endInit',
208			'require' => array(),
209			'runFile' => 'inclus.php',
210			'priority' => 0
211			)
212			));
213			}
214
215			/**
216			* Test de la méthode isModulesNotLoad()
217			*/
218			public function testIsModulesNotLoad()
219			{
220			$this->boolean($this->mock->isModulesNotLoad())->isFalse();
221
222			$this->mock->newMod('test');
223			$this->boolean($this->mock->isModulesNotLoad())->isFalse(); //Cache
224
225			$this->mock->listNotLoad(true); //Kill le cache
226			$this->boolean($this->mock->isModulesNotLoad())->isTrue();
227			}
228
229			/**
230			* Test de la méthode getModuleInfos($name)
231			*/
232			public function testGetModuleInfos()
233			{
234			$this->mock->newMod('test');
235			$this->array($this->mock->getModuleInfos('test'))->isEqualTo(array(
236			'name' => 'test',
237			'time' => 'endInit',
238			'require' => array(),
239			'runFile' => 'inclus.php',
240			'priority' => 0
241			));
242
243			$mock = $this->mock;
244			$this->exception(function() use($mock)
245			{
246			$mock->getModuleInfos('test2');
247			})->message->contains('Le module test2 n\'existe pas.');
248			}
249
250			}
251
252			/**
253			* Mock pour la classe Modules
254			*/
255			class MockModules extends \BFW\Modules
256			{
257			/**
258			* Accesseur get
259			*/
260			public function __get($name) {return $this->$name;}
261
262			/**
263			* Test de la méthode modToLoad(&$mod, &$arrayToLoad, $waitToLoad)
264			*/
265			public function modToLoad(&$mod, &$arrayToLoad, $waitToLoad=array())
266			{
267			return parent::modToLoad($mod, $arrayToLoad, $waitToLoad);
268			}
269			}
270

bfw-systems / bfw

GitHub Access Token became invalid

Push — 2.2 ( f4c653...5ece81 )

MockModules A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

Duplication Side-by-Side

Filter issues like