Subversion Repositories eFlore/Applications.eflore-consultation

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

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