Subversion Repositories eFlore/Applications.eflore-consultation

Rev

Rev 138 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 138 Rev 139
1 
<?php
 1 
<?php
2 
// declare(encoding='UTF-8');
 2 
// declare(encoding='UTF-8');
3 
/**
 3 
/**
4 
 * Classe contenant des méthodes :
 4 
 * Classe contenant des méthodes :
5 
 *  - d'intialisation des tests,
 5 
 *  - d'intialisation des tests,
6 
 *  - refactorisant le code des tests,
 6 
 *  - refactorisant le code des tests,
7 
 *  - facilitant les tests.
 7 
 *  - facilitant les tests.
8 
 *
 8 
 *
9 
 * @category	php 5.3
 9 
 * @category	php 5.3
10 
 * @package		Tests/Services
 10 
 * @package		Tests/Services
11 
 * @author		Jean-Pascal MILCENT <jpm@tela-botanica.org>
 11 
 * @author		Jean-Pascal MILCENT <jpm@tela-botanica.org>
12 
 * @copyright	Copyright (c) 2011, Tela Botanica (accueil@tela-botanica.org)
 12 
 * @copyright	Copyright (c) 2011, Tela Botanica (accueil@tela-botanica.org)
13 
 * @license		http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
 13 
 * @license		http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
14 
 * @license		http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
 14 
 * @license		http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
15 
 * @version		$Id$
 15 
 * @version		$Id$
16 
 */
 16 
 */
17 
abstract class ConsultationEflorePhpUnit extends PHPUnit_Framework_TestCase {
 17 
abstract class ConsultationEflorePhpUnit extends PHPUnit_Framework_TestCase {
18 
 
 18 
 
19 
	//+------------------------------------------------------------------------------------------------------+
 19 
	//+------------------------------------------------------------------------------------------------------+
20 
	// Intialisation
 20 
	// Intialisation
21 
 
 21 
 
22 
	public static function setUpBeforeClass() {
 22 
	public static function setUpBeforeClass() {
23 
		error_reporting(E_ALL);
 23 
		error_reporting(E_ALL);
24 
		self::chargerFramework();
 24 
		self::chargerFramework();
25 
 
 25 
 
26 
		// Enregistrement en première position des autoload de la méthode gérant les classes des services
 26 
		// Enregistrement en première position des autoload de la méthode gérant les classes des services
27 
		spl_autoload_register(array(get_class(), 'chargerClasseAuto'));
 27 
		spl_autoload_register(array(get_class(), 'chargerClasseAuto'));
28 
	}
 28 
	}
29 
 
 29 
 
30 
	public static function chargerClasseAuto($classe) {
 30 
	public static function chargerClasseAuto($classe) {
- 
 
 31 
		//echo $classe."\n";
31 
		if (class_exists($classe)) {
 32 
		if (class_exists($classe)) {
32 
			return null;
 33 
			return null;
33 
		}
 34 
		}
34 
		$cheminBase = realpath(__DIR__.'/../metier/api_0.1').'/';
 - 
 
- 
 
 35
35 
		$cheminsTests = __DIR__.'/';
 36 
		$cheminsTests = __DIR__.'/';
- 
 
 37 
		$cheminMetier = realpath(__DIR__.'/../metier/api_0.1').'/';
- 
 
 38 
		$cheminModule = realpath(__DIR__.'/../modules/').'/';
36 
		$chemins = array($cheminBase, $cheminsTests);
 39 
		$chemins = array($cheminMetier, $cheminModule, $cheminsTests);
37 
		foreach ($chemins as $chemin) {
 40 
		foreach ($chemins as $chemin) {
38 
			$chemin = $chemin.$classe.'.php';
 41 
			$cheminCourt = $chemin.$classe.'.php';
- 
 
 42 
			$module = strtolower(preg_replace('/([A-Z])/', '_\\1', lcfirst($classe)));
- 
 
 43 
			$cheminLong = $chemin.$module.'/'.$classe.'.php';
- 
 
 44 
			//echo $cheminCourt."\n".$cheminLong."\n";
39 
			if (file_exists($chemin)) {
 45 
			if (file_exists($cheminCourt)) {
- 
 
 46 
				require_once $cheminCourt;
- 
 
 47 
			} elseif (file_exists($cheminLong)) {
40 
				require_once $chemin;
 48 
				require_once $cheminLong;
41 
			}
 49 
			}
42 
		}
 50 
		}
43 
	}
 51 
	}
44 
 
 52 
 
45 
	private static function chargerFramework() {
 53 
	private static function chargerFramework() {
46 
		$cheminRacine = realpath(dirname(__FILE__).'/..').'/';
 54 
		$cheminRacine = realpath(dirname(__FILE__).'/..').'/';
47 
		$framework =  $cheminRacine.'framework.php';
 55 
		$framework =  $cheminRacine.'framework.php';
48 
		if (!file_exists($framework)) {
 56 
		if (!file_exists($framework)) {
49 
			$e = "Veuillez paramétrer l'emplacement et la version du Framework dans le fichier $framework";
 57 
			$e = "Veuillez paramétrer l'emplacement et la version du Framework dans le fichier $framework";
50 
			trigger_error($e, E_USER_ERROR);
 58 
			trigger_error($e, E_USER_ERROR);
51 
		} else {
 59 
		} else {
52 
			// Inclusion du Framework
 60 
			// Inclusion du Framework
53 
			require_once $framework;
 61 
			require_once $framework;
54 
 
 62 
 
55 
			// Ajout d'information concernant cette application
 63 
			// Ajout d'information concernant cette application
56 
			Framework::setCheminAppli($cheminRacine);// Obligatoire
 64 
			Framework::setCheminAppli($cheminRacine);// Obligatoire
57 
		}
 65 
		}
58 
	}
 66 
	}
59 
 
 67 
 
60 
	//+------------------------------------------------------------------------------------------------------+
 68 
	//+------------------------------------------------------------------------------------------------------+
61 
	// Refactorisation
 69 
	// Refactorisation
62 
	protected function consulterJson($ressources, $parametres) {
 70 
	protected function consulterJson($ressources, $parametres) {
63 
		$retourJson = $this->consulterBrut($ressources, $parametres);
 71 
		$retourJson = $this->consulterBrut($ressources, $parametres);
64 
		$retour = json_decode($retourJson, true);
 72 
		$retour = json_decode($retourJson, true);
65 
		$this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url");
 73 
		$this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url");
66 
		return $retour;
 74 
		return $retour;
67 
	}
 75 
	}
68 
 
 76 
 
69 
	protected function consulterBrut($ressources, $parametres) {
 77 
	protected function consulterBrut($ressources, $parametres) {
70 
		array_unshift($ressources, $this->service);
 78 
		array_unshift($ressources, $this->service);
71 
		array_unshift($ressources, $this->projet);
 79 
		array_unshift($ressources, $this->projet);
72 
		$projets = new Projets();
 80 
		$projets = new Projets();
73 
		$retourJson = $projets->consulter($ressources, $parametres);
 81 
		$retourJson = $projets->consulter($ressources, $parametres);
74 
		return $retourJson;
 82 
		return $retourJson;
75 
	}
 83 
	}
76 
 
 84 
 
77 
	protected function creerUrl($ressources, $parametres) {
 85 
	protected function creerUrl($ressources, $parametres) {
78 
		$version = '';
 86 
		$version = '';
79 
		$ressourcesUrl = array();
 87 
		$ressourcesUrl = array();
80 
		foreach ($ressources as $ressource) {
 88 
		foreach ($ressources as $ressource) {
81 
			$ressourcesUrl[] = $ressource;
 89 
			$ressourcesUrl[] = $ressource;
82 
		}
 90 
		}
83 
		$ressourcesUrl = count($ressourcesUrl) > 0 ? '/'.implode('/', $ressourcesUrl) : '';
 91 
		$ressourcesUrl = count($ressourcesUrl) > 0 ? '/'.implode('/', $ressourcesUrl) : '';
84 
 
 92 
 
85 
		$parametresUrl = '';
 93 
		$parametresUrl = '';
86 
		if (count($parametres) > 0) {
 94 
		if (count($parametres) > 0) {
87 
			foreach ($parametres as $cle => $valeur) {
 95 
			foreach ($parametres as $cle => $valeur) {
88 
				$parametresUrl[] = $cle.'='.rawurlencode($valeur);
 96 
				$parametresUrl[] = $cle.'='.rawurlencode($valeur);
89 
			}
 97 
			}
90 
			$parametresUrl = '?'.implode('&', $parametresUrl);
 98 
			$parametresUrl = '?'.implode('&', $parametresUrl);
91 
		}
 99 
		}
92 
 
 100 
 
93 
		$url = 'http://localhost/service:eflore:0.1'.$ressourcesUrl.$parametresUrl;
 101 
		$url = 'http://localhost/service:eflore:0.1'.$ressourcesUrl.$parametresUrl;
94 
		return $url;
 102 
		return $url;
95 
	}
 103 
	}
96 
 
 104 
 
97 
	//+------------------------------------------------------------------------------------------------------+
 105 
	//+------------------------------------------------------------------------------------------------------+
98 
	// Méthodes facilitant les tests
 106 
	// Méthodes facilitant les tests
99 
 
 107
100 
	/**
 108 
	/**
101 
	* Récupère un bouchon de classe abstraite.
 109 
	* Récupère un bouchon de classe abstraite.
102 
	* Comment l'utiliser :
 110 
	* Comment l'utiliser :
103 
	* 	$classeAstraite = $this->getClasseAbstraite('MaClasse', array('param1', 'param2'));
 111 
	* 	$classeAstraite = $this->getClasseAbstraite('MaClasse', array('param1', 'param2'));
104 
	*   $foo = $classeAstraite->methodeConcretePublique();
 112 
	*   $foo = $classeAstraite->methodeConcretePublique();
105 
	*
 113 
	*
106 
	* @param String $classeNom Le nom de la classe
 114 
	* @param String $classeNom Le nom de la classe
107 
	* @param Array $parametres Les paramètres à passer au constructeur.
 115 
	* @param Array $parametres Les paramètres à passer au constructeur.
108 
	* @return Object Le bouchon de la classe abstraite
 116 
	* @return Object Le bouchon de la classe abstraite
109 
	*/
 117 
	*/
110 
	public function getClasseAbstraite($classeNom, Array $parametres) {
 118 
	public function getClasseAbstraite($classeNom, Array $parametres) {
111 
		$efloreScript = $this->getMockForAbstractClass($classeNom, $parametres);
 119 
		$efloreScript = $this->getMockForAbstractClass($classeNom, $parametres);
112 
		return $efloreScript;
 120 
		return $efloreScript;
113 
	}
 121 
	}
114 
 
 122 
 
115 
	/**
 123 
	/**
116 
	 * Récupère une méthode privée d'une classe pour tester/documenter.
 124 
	 * Récupère une méthode privée d'une classe pour tester/documenter.
117 
	 * Comment l'utiliser :
 125 
	 * Comment l'utiliser :
118 
	 * 	MyClass->foo():
 126 
	 * 	MyClass->foo():
119 
	 *   $cls = new MyClass();
 127 
	 *   $cls = new MyClass();
120 
	 *   $foo = self::getPrivateMethode($cls, 'foo');
 128 
	 *   $foo = self::getPrivateMethode($cls, 'foo');
121 
	 *   $foo->invoke($cls, $...);
 129 
	 *   $foo->invoke($cls, $...);
122 
	 *
 130 
	 *
123 
	 * @param object $objet Une instance de votre classe
 131 
	 * @param object $objet Une instance de votre classe
124 
	 * @param string $methode Le nom de la méthode private
 132 
	 * @param string $methode Le nom de la méthode private
125 
	 * @return ReflectionMethod La méthode demandée
 133 
	 * @return ReflectionMethod La méthode demandée
126 
	 */
 134 
	 */
127 
	public static function getMethodePrivee($objet, $nomMethode) {
 135 
	public static function getMethodePrivee($objet, $nomMethode) {
128 
		$classe = new ReflectionClass($objet);
 136 
		$classe = new ReflectionClass($objet);
129 
		$methode = $classe->getMethod($nomMethode);
 137 
		$methode = $classe->getMethod($nomMethode);
130 
		$methode->setAccessible(true);
 138 
		$methode->setAccessible(true);
131 
		return $methode;
 139 
		return $methode;
132 
	}
 140 
	}
133 
 
 141 
 
134 
	/**
 142 
	/**
135 
	* Récupère une méthode protégée d'une classe pour tester/documenter.
 143 
	* Récupère une méthode protégée d'une classe pour tester/documenter.
136 
	* Comment l'utiliser :
 144 
	* Comment l'utiliser :
137 
	* 	MyClass->foo():
 145 
	* 	MyClass->foo():
138 
	*   $cls = new MyClass();
 146 
	*   $cls = new MyClass();
139 
	*   $foo = self::getProtectedMethode($cls, 'foo');
 147 
	*   $foo = self::getProtectedMethode($cls, 'foo');
140 
	*   $foo->invoke($cls, $...);
 148 
	*   $foo->invoke($cls, $...);
141 
	* @param object $objet Une instance de votre classe
 149 
	* @param object $objet Une instance de votre classe
142 
	* @param string $methode Le nom de la méthode protected
 150 
	* @param string $methode Le nom de la méthode protected
143 
	* @return ReflectionMethod La méthode demandée
 151 
	* @return ReflectionMethod La méthode demandée
144 
	*/
 152 
	*/
145 
	public static function getMethodeProtegee($objet, $nomMethode) {
 153 
	public static function getMethodeProtegee($objet, $nomMethode) {
146 
		return self::getMethodePrivee($objet, $nomMethode);
 154 
		return self::getMethodePrivee($objet, $nomMethode);
147 
	}
 155 
	}
148 
}
 156 
}
149 
?>
 157 
?>