Subversion Repositories eFlore/Projets.eflore-projets

Rev

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

Rev 520 Rev 554
1 
<?php
 1 
<?php
2 
 
 2 
 
3 
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
 3 
require_once dirname(__FILE__).'/../ServiceEflorePhpUnit.php';
4 
 
 4 
 
5 
class InformationsBaseflorTest extends ServiceEflorePhpUnit {
 5 
class InformationsBaseflorTest extends ServiceEflorePhpUnit {
6
6
7 
	public function __construct() {
 7 
	public function __construct() {
8 
		$this->projet = 'baseflor';
 8 
		$this->projet = 'baseflor';
9 
		$this->service = 'informations';
 9 
		$this->service = 'informations';
10 
	}
 10 
	}
11
11
12
12
13 
	//++ ------------------------------------Test des ressources -----------------------------++
 13 
	//++ ------------------------------------Test des ressources -----------------------------++
14
14
15 
	public function testRessourceReferentielInconnu() {
 15 
	public function testRessourceReferentielInconnu() {
16 
		$ressources = array('dgoju.nn:73256');
 16 
		$ressources = array('dgoju.nn:73256');
17 
		$parametres = array();
 17 
		$parametres = array();
18 
		$retour = $this->consulterBrut($ressources, $parametres);
 18 
		$retour = $this->consulterBrut($ressources, $parametres);
19 
		$messageAttendu =
 19 
		$messageAttendu =
20 
			  "Erreur dans l'url de votre requête :".
 20 
			  "Erreur dans l'url de votre requête :".
21 
				" </br> Le référentiel \" ". dgoju . " \" n'existe pas.";
 21 
				" </br> Le référentiel \" ". dgoju . " \" n'existe pas.";
22 
		$this->assertEquals($messageAttendu, $retour,
 22 
		$this->assertEquals($messageAttendu, $retour,
23 
						"Il faut indiquer un référentiel inconnu.");
 23 
						"Il faut indiquer un référentiel inconnu.");
24 
	}
 24 
	}
25
25
26 
	public function testRessourceInconnue() {
 26 
	public function testRessourceInconnue() {
27 
		$ressources = array('inconnue');
 27 
		$ressources = array('inconnue');
28 
		$parametres = array();
 28 
		$parametres = array();
29 
		$retour = $this->consulterBrut($ressources, $parametres);
 29 
		$retour = $this->consulterBrut($ressources, $parametres);
30 
		$messageAttendu =
 30 
		$messageAttendu =
31 
				  "Erreur dans l'url de votre requête : </br> La ressource demandée n'existe pas.";
 31 
				  "Erreur dans l'url de votre requête : </br> La ressource demandée n'existe pas.";
32 
		$this->assertEquals($messageAttendu, $retour,
 32 
		$this->assertEquals($messageAttendu, $retour,
33 
							"Il faut indiquer si une ressource est eronnée.");
 33 
							"Il faut indiquer si une ressource est eronnée.");
34 
	}
 34 
	}
35
35
36 
	public function testRessourceNNInconnu() {
 36 
	public function testRessourceNNInconnu() {
37 
		$ressources = array('bdtfx.nn:3');
 37 
		$ressources = array('bdtfx.nn:3');
38 
		$parametres = array();
 38 
		$parametres = array();
39 
		$retour = $this->consulterBrut($ressources, $parametres);
 39 
		$retour = $this->consulterBrut($ressources, $parametres);
40 
		$messageAttendu = "Les données recherchées sont introuvables.";
 40 
		$messageAttendu = "Les données recherchées sont introuvables.";
41 
		$this->assertEquals($messageAttendu, $retour,
 41 
		$this->assertEquals($messageAttendu, $retour,
42 
			"Il faut indiquer si une requête ne renvoie pas de résultats.");
 42 
			"Il faut indiquer si une requête ne renvoie pas de résultats.");
43 
	}
 43 
	}
44
44
45 
	//++ ------------------------------------Test des paramètres -----------------------------++
 45 
	//++ ------------------------------------Test des paramètres -----------------------------++
46
46
47 
	public function testParametreInconnu() {
 47 
	public function testParametreInconnu() {
48 
		$ressourcesList = array(
 48 
		$ressourcesList = array(
49 
			array('bdtfx.nn:73256'),
 49 
			array('bdtfx.nn:73256'),
50 
			array('bdtfx.nn:101128'));
 50 
			array('bdtfx.nn:101128'));
51 
		$parametres = array('paramatre' => 'image/jpeg');
 51 
		$parametres = array('paramatre' => 'image/jpeg');
52 
		foreach ($ressourcesList as $ressources) {
 52 
		foreach ($ressourcesList as $ressources) {
53 
			$retour = $this->consulterBrut($ressources, $parametres);
 53 
			$retour = $this->consulterBrut($ressources, $parametres);
54 
			$messageAttendu = "Erreur dans les parametres de votre requête :".
 54 
			$messageAttendu = "Erreur dans les parametres de votre requête :".
55 
										" </br> Le paramètre \" paramatre \" n'existe pas.";
 55 
										" </br> Le paramètre \" paramatre \" n'existe pas.";
56 
			$this->assertEquals($messageAttendu, $retour,
 56 
			$this->assertEquals($messageAttendu, $retour,
57 
				"Il faut indiquer si un paramètre  est inconnu.");
 57 
				"Il faut indiquer si un paramètre  est inconnu.");
58 
		}
 58 
		}
59
59
60 
	}
 60 
	}
61
61
62 
	public function testParametreCategorieInconnue() {
 62 
	public function testParametreCategorieInconnue() {
63 
		$ressourcesList = array(
 63 
		$ressourcesList = array(
64 
			array('bdtfx.nn:73256'),
 64 
			array('bdtfx.nn:73256'),
65 
			array('bdtfx.nn:101128'));
 65 
			array('bdtfx.nn:101128'));
66 
		$parametres = array('categorie' => 'inventé');
 66 
		$parametres = array('categorie' => 'inventé');
67 
		foreach ($ressourcesList as $ressources) {
 67 
		foreach ($ressourcesList as $ressources) {
68 
			$retour = $this->consulterBrut($ressources, $parametres);
 68 
			$retour = $this->consulterBrut($ressources, $parametres);
69 
			$messageAttendu = "Valeur de paramètre inconnue pour 'categorie'.";
 69 
			$messageAttendu = "Valeur de paramètre inconnue pour 'categorie'.";
70 
			$this->assertEquals($messageAttendu, $retour,
 70 
			$this->assertEquals($messageAttendu, $retour,
71 
				"Il faut indiquer si la valeur du  paramètre categorie est inconnue pour $ressources . ");
 71 
				"Il faut indiquer si la valeur du  paramètre categorie est inconnue pour $ressources . ");
72 
		}
 72 
		}
73 
	}
 73 
	}
74
74
75 
	public function testParametreNavigationLimiteSansDepart() {
 75 
	public function testParametreNavigationLimiteSansDepart() {
76 
		$ressources = array();
 76 
		$ressources = array();
77 
		$parametresList = array(
 77 
		$parametresList = array(
78 
			array('navigation.depart' => 10),
78 
			array('navigation.depart' => 10),
79 
			array('navigation.limite' => 68));
 79 
			array('navigation.limite' => 68));
80 
		foreach ($parametresList as $parametres) {
 80 
		foreach ($parametresList as $parametres) {
81 
			$retour = $this->consulterBrut($ressources, $parametres);
 81 
			$retour = $this->consulterBrut($ressources, $parametres);
82 
			$param = isset($parametres['navigation.limite']) ? 'navigation.depart' : 'navigation.limite';
 82 
			$param = isset($parametres['navigation.limite']) ? 'navigation.depart' : 'navigation.limite';
83 
			$messageAttendu = "indiquez également la valeur pour le paramètre $param.";
 83 
			$messageAttendu = "indiquez également la valeur pour le paramètre $param.";
84 
			$this->assertEquals($messageAttendu, $retour,
 84 
			$this->assertEquals($messageAttendu, $retour,
85 
					"Navigation.depart et navigation.limite doivent être présents ensemble.");
 85 
					"Navigation.depart et navigation.limite doivent être présents ensemble.");
86 
		}
 86 
		}
87 
	}
 87 
	}
88
88
89 
	public function testParametreDepartSuperieurTotalResultats() {
 89 
	public function testParametreDepartSuperieurTotalResultats() {
90 
		$ressources = array();
 90 
		$ressources = array();
91 
		$parametres = array('navigation.depart' => 20000, 'navigation.limite' => 10 );
 91 
		$parametres = array('navigation.depart' => 20000, 'navigation.limite' => 10 );
92 
			$retour = $this->consulterBrut($ressources, $parametres);
 92 
			$retour = $this->consulterBrut($ressources, $parametres);
93 
			$messageAttendu =
93 
			$messageAttendu =
94 
				"Erreur : la valeur pour le paramètre navigation.départ est supérieure".
 94 
				"Erreur : la valeur pour le paramètre navigation.départ est supérieure".
95 
				" au nombre total de résultats.";
 95 
				" au nombre total de résultats.";
96 
			$this->assertEquals($messageAttendu, $retour,
 96 
			$this->assertEquals($messageAttendu, $retour,
97 
						"Il faut indiquer si la valeur de départ est supérieure au nombre de résultats.");
 97 
						"Il faut indiquer si la valeur de départ est supérieure au nombre de résultats.");
98 
	}
 98 
	}
99
99
100
100
101 
	public function testParametreNavigationErrone() {
 101 
	public function testParametreNavigationErrone() {
102 
		$ressources = array();
 102 
		$ressources = array();
103 
		$parametresList = array(
 103 
		$parametresList = array(
104 
			array('navigation.depart' => -5, 'navigation.limite' => 10 ),
 104 
			array('navigation.depart' => -5, 'navigation.limite' => 10 ),
105 
			array('navigation.depart' => 0, 'navigation.limite' => abc ));
 105 
			array('navigation.depart' => 0, 'navigation.limite' => abc ));
106 
		$cles = array('navigation.depart','navigation.limite');
 106 
		$cles = array('navigation.depart','navigation.limite');
107 
		$i = 0 ;
 107 
		$i = 0 ;
108 
		foreach ($parametresList as $parametres) {
 108 
		foreach ($parametresList as $parametres) {
109 
			$retour = $this->consulterBrut($ressources, $parametres);
 109 
			$retour = $this->consulterBrut($ressources, $parametres);
110 
			$messageAttendu = "Erreur : valeur erronnée pour le paramètre {$cles[$i]}.";
 110 
			$messageAttendu = "Erreur : valeur erronnée pour le paramètre {$cles[$i]}.";
111 
			$this->assertEquals($messageAttendu, $retour,
 111 
			$this->assertEquals($messageAttendu, $retour,
112 
						"il faut indiquer lorsque qu'un des paramètres de navigation a une valeur impossible.");
 112 
						"il faut indiquer lorsque qu'un des paramètres de navigation a une valeur impossible.");
113 
			$i++;
 113 
			$i++;
114 
		}
 114 
		}
115 
	}
 115 
	}
116
116
117 
	public function testParametreRetourFormatErrone() {
 117 
	public function testParametreRetourFormatErrone() {
118 
		$ressourcesList = array(
 118 
		$ressourcesList = array(
119 
			array('bdtfx.nn:73256'),
 119 
			array('bdtfx.nn:73256'),
120 
			array('bdtfx.nn:101128'));
 120 
			array('bdtfx.nn:101128'));
121 
		$parametres = array('retour.format' => 'pdf');
 121 
		$parametres = array('retour.format' => 'pdf');
122 
		foreach ($ressourcesList as $ressources) {
 122 
		foreach ($ressourcesList as $ressources) {
123 
			$retour = $this->consulterBrut($ressources, $parametres);
 123 
			$retour = $this->consulterBrut($ressources, $parametres);
124 
			$messageAttendu = "Valeur de paramètre inconnue pour 'retour.format'.";
 124 
			$messageAttendu = "Valeur de paramètre inconnue pour 'retour.format'.";
125 
			$this->assertEquals($messageAttendu, $retour,
 125 
			$this->assertEquals($messageAttendu, $retour,
126 
							"il faut indiquer lorsque que le paramètre retour.format a une valeur impossible.");
 126 
							"il faut indiquer lorsque que le paramètre retour.format a une valeur impossible.");
127 
		}
 127 
		}
128 
	}
 128 
	}
129
129
130 
	public function testParametreVersionProjetInconnu() {
 130 
	public function testParametreVersionProjetInconnu() {
131 
		$ressourcesList = array(
 131 
		$ressourcesList = array(
132 
			array('bdtfx.nn:73256'),
 132 
			array('bdtfx.nn:73256'),
133 
			array('bdtfx.nn:101128'));
 133 
			array('bdtfx.nn:101128'));
134 
		$parametres = array('version.projet' => 'dhgkg22');
 134 
		$parametres = array('version.projet' => 'dhgkg22');
135 
		foreach ($ressourcesList as $ressources){
 135 
		foreach ($ressourcesList as $ressources){
136 
			$retour = $this->consulterBrut($ressources, $parametres);
 136 
			$retour = $this->consulterBrut($ressources, $parametres);
137 
			$messageAttendu = "Erreur : La version est inconnue.";
 137 
			$messageAttendu = "Erreur : La version est inconnue.";
138 
			$this->assertEquals($messageAttendu, $retour,
 138 
			$this->assertEquals($messageAttendu, $retour,
139 
									"Il faut indiquer si la valeur du  paramètre version.projet est inconnue.");
 139 
									"Il faut indiquer si la valeur du  paramètre version.projet est inconnue.");
140 
		}
 140 
		}
141 
	}
 141 
	}
142
142
143 
	//++ ------------------------------------Test du retour json correct -----------------------------++
 143 
	//++ ------------------------------------Test du retour json correct -----------------------------++
144
144
145 
	//++ ---Informations ----++
 145 
	//++ ---Informations ----++
146
146
147 
	public function testJsonBienFormeInformations() {
 147 
	public function testJsonBienFormeInformations() {
148 
		$ressources = array();
 148 
		$ressources = array();
149 
		$parametres = array('navigation.depart' => 10, 'navigation.limite' => 15);
 149 
		$parametres = array('navigation.depart' => 10, 'navigation.limite' => 15);
150 
			$url = $this->creerUrl($ressources, $parametres);
 150 
			$url = $this->creerUrl($ressources, $parametres);
151 
			$retour = $this->consulterJson($ressources, $parametres);
 151 
			$retour = $this->consulterJson($ressources, $parametres);
152 
			$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url");
 152 
			$this->assertArrayHasKey('entete', $retour, "Le json ne contient pas d'attribut : entete. Voir : $url");
153 
			$this->assertArrayHasKey('resultats', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url");
 153 
			$this->assertArrayHasKey('resultats', $retour, "Le json ne contient pas d'attribut : resultat. Voir : $url");
154 
			$this->verifierJsonEnteteBienFormeInformations($retour, $parametres);
 154 
			$this->verifierJsonEnteteBienFormeInformations($retour, $parametres);
155 
	}
 155 
	}
156
156
157 
	private function verifierJsonEnteteBienFormeInformations($retour, $parametres) {
 157 
	private function verifierJsonEnteteBienFormeInformations($retour, $parametres) {
158 
		//depart
 158 
		//depart
159 
		$this->assertArrayHasKey('depart', $retour['entete'],
 159 
		$this->assertArrayHasKey('depart', $retour['entete'],
160 
					"L'en-tête ne contient pas d'attribut : depart ");
 160 
					"L'en-tête ne contient pas d'attribut : depart ");
161 
		$this->assertEquals($retour['entete']['depart'], $parametres['navigation.depart'],
 161 
		$this->assertEquals($retour['entete']['depart'], $parametres['navigation.depart'],
162 
					"La valeur de départ est incorrecte dans l'en-tête.");
 162 
					"La valeur de départ est incorrecte dans l'en-tête.");
163 
		//limite
 163 
		//limite
164 
		$this->assertArrayHasKey('limite', $retour['entete'],
 164 
		$this->assertArrayHasKey('limite', $retour['entete'],
165 
					"L'en-tête ne contient pas d'attribut : limite");
 165 
					"L'en-tête ne contient pas d'attribut : limite");
166 
		$this->assertEquals($retour['entete']['limite'], $parametres['navigation.limite'],
 166 
		$this->assertEquals($retour['entete']['limite'], $parametres['navigation.limite'],
167 
					"La valeur de limite est incorrecte dans l'en-tête.");
 167 
					"La valeur de limite est incorrecte dans l'en-tête.");
168 
		//total
 168 
		//total
169 
		$this->assertArrayHasKey('total', $retour['entete'],
 169 
		$this->assertArrayHasKey('total', $retour['entete'],
170 
					"L'en-tête ne contient pas d'attribut : total ");
 170 
					"L'en-tête ne contient pas d'attribut : total ");
171 
		$this->assertNotEquals('', $retour['entete']['total'],
 171 
		$this->assertNotEquals('', $retour['entete']['total'],
172 
							"La valeur de total est vide dans l'en-tête.");
 172 
							"La valeur de total est vide dans l'en-tête.");
173 
		//href
 173 
		//href
174 
		$this->assertArrayHasKey('href.suivant', $retour['entete'],
 174 
		$this->assertArrayHasKey('href.suivant', $retour['entete'],
175 
					"L'en-tête ne contient pas d'attribut : href.suivant ");
 175 
					"L'en-tête ne contient pas d'attribut : href.suivant ");
176 
		$this->assertArrayHasKey('href.precedent', $retour['entete'],
 176 
		$this->assertArrayHasKey('href.precedent', $retour['entete'],
177 
							"L'en-tête ne contient pas d'attribut : href.precedent ");
 177 
							"L'en-tête ne contient pas d'attribut : href.precedent ");
178 
		$parametres_url =
 178 
		$parametres_url =
179 
		array('navigation.depart' => ($retour['entete']['limite']+$retour['entete']['depart']),
 179 
		array('navigation.depart' => ($retour['entete']['limite']+$retour['entete']['depart']),
180 
						 'navigation.limite' => $retour['entete']['limite'] );
 180 
						 'navigation.limite' => $retour['entete']['limite'] );
181 
		$urlsuivant = $this->creerUrl($ressources, $parametres_url);
 181 
		$urlsuivant = $this->creerUrl($ressources, $parametres_url);
182 
		$this->assertEquals($urlsuivant, $retour['entete']['href.suivant'],
 182 
		$this->assertEquals($urlsuivant, $retour['entete']['href.suivant'],
183 
												"L' url $urlsuivant de l'entete est incorrecte.");
 183 
												"L' url $urlsuivant de l'entete est incorrecte.");
184 
	}
 184 
	}
185
185
186 
	public function testJsonResultatsHrefInformations() {
 186 
	public function testJsonResultatsHrefInformations() {
187 
		$ressources = array();
 187 
		$ressources = array();
188 
		$parametres = array('navigation.depart' => 370, 'navigation.limite' => 5);
 188 
		$parametres = array('navigation.depart' => 370, 'navigation.limite' => 5);
189 
		$url = $this->creerUrl($ressources, $parametres);
 189 
		$url = $this->creerUrl($ressources, $parametres);
190 
		$retour = $this->consulterJson($ressources, $parametres);
 190 
		$retour = $this->consulterJson($ressources, $parametres);
191 
		foreach ($retour as $id => $valeurs) {
 191 
		foreach ($retour as $id => $valeurs) {
192 
			if ( empty($valeurs['resultats']['num_nomen']) ) {
 192 
			if ( empty($valeurs['resultats']['num_nomen']) ) {
193 
				$this->assertArrayNotHasKey('href', $valeurs['resultats'],
 193 
				$this->assertArrayNotHasKey('href', $valeurs['resultats'],
194 
							"Il ne doit pas avoir de lien s'il n'y a pas de numéro nomenclatural (=0). Voir $url ");
 194 
							"Il ne doit pas avoir de lien s'il n'y a pas de numéro nomenclatural (=0). Voir $url ");
195 
			}
 195 
			}
196 
		}
 196 
		}
197 
	}
 197 
	}
198
198
199 
	public function testJsonNombreLimiteDemande() {
 199 
	public function testJsonNombreLimiteDemande() {
200 
		$ressources = array();
 200 
		$ressources = array();
201 
		$parametresList = array('navigation.depart' => 10, 'navigation.limite' => 15 );
 201 
		$parametresList = array('navigation.depart' => 10, 'navigation.limite' => 15 );
202 
			$url = $this->creerUrl($ressources, $parametres);
 202 
			$url = $this->creerUrl($ressources, $parametres);
203 
			$retour = $this->consulterJson($ressources, $parametres);
 203 
			$retour = $this->consulterJson($ressources, $parametres);
204 
			$this->assertLessThanOrEqual(15, count($retour),
204 
			$this->assertLessThanOrEqual(15, count($retour),
205 
				"Le json renvoie un nombre de résultats trop important : entete. Voir : $url");
 205 
				"Le json renvoie un nombre de résultats trop important : entete. Voir : $url");
206 
	}
 206 
	}
207
207
208 
	//++ ---Informations.nn ----++
 208 
	//++ ---Informations.nn ----++
209
209
210 
	public function testJsonInformationsNN_min() {
 210 
	public function testJsonInformationsNN_min() {
211 
		$ressourcesList = array(
 211 
		$ressourcesList = array(
212 
			array('bdtfx.nn:73256'),
 212 
			array('bdtfx.nn:73256'),
213 
			array('bdtfx.nn:101128'));
 213 
			array('bdtfx.nn:101128'));
214 
		$parametres = array('retour.format' => 'min' );
 214 
		$parametres = array('retour.format' => 'min' );
215 
		foreach ($ressourcesList as $ressources) {
 215 
		foreach ($ressourcesList as $ressources) {
216 
			$retour = $this->consulterJson($ressources, $parametres);
 216 
			$retour = $this->consulterJson($ressources, $parametres);
217 
			$this->assertArrayNotHasKey('type_bio.code',$retour,
 217 
			$this->assertArrayNotHasKey('type_bio.code',$retour,
218 
				"Le champs 'type_bio.code' ne doit pas être présent si retour.format=min. ");
 218 
				"Le champs 'type_bio.code' ne doit pas être présent si retour.format=min. ");
219 
			$this->assertArrayNotHasKey('type_bio.libelle',$retour,
 219 
			$this->assertArrayNotHasKey('type_bio.libelle',$retour,
220 
				"Le champs 'type_bio.libelle' ne doit pas être présent si retour.format=min.");
 220 
				"Le champs 'type_bio.libelle' ne doit pas être présent si retour.format=min.");
221 
			$this->assertArrayNotHasKey('type_bio.detail',$retour,
 221 
			$this->assertArrayNotHasKey('type_bio.detail',$retour,
222 
				"Le champs 'type_bio.detail' ne doit pas être présent si retour.format=min.");
 222 
				"Le champs 'type_bio.detail' ne doit pas être présent si retour.format=min.");
223 
			$champs = array_keys(config::get('champs_ontologiques'));
 223 
			$champs = array_keys(config::get('champs_ontologiques'));
224 
			foreach ($champs as $chps) {
 224 
			foreach ($champs as $chps) {
225 
				$this->assertArrayNotHasKey($chps.'.libelle', $retour,
 225 
				$this->assertArrayNotHasKey($chps.'.libelle', $retour,
226 
					"Le champs '{$chps}.libelle' ne doit pas être présent si retour.format=min.");
 226 
					"Le champs '{$chps}.libelle' ne doit pas être présent si retour.format=min.");
227 
				$this->assertArrayNotHasKey($chps.'.code', $retour,
 227 
				$this->assertArrayNotHasKey($chps.'.code', $retour,
228 
					"Le champs '{$chps}.code' ne doit pas être présent si retour.format=min.");
 228 
					"Le champs '{$chps}.code' ne doit pas être présent si retour.format=min.");
229 
				$this->assertArrayNotHasKey($chps.'.href', $retour,
 229 
				$this->assertArrayNotHasKey($chps.'.href', $retour,
230 
					"Le champs '{$chps}.href' ne doit pas être présent si retour.format=min.");
 230 
					"Le champs '{$chps}.href' ne doit pas être présent si retour.format=min.");
231 
			}
 231 
			}
232 
			foreach ($champs as $chps) {
 232 
			foreach ($champs as $chps) {
233 
				$this->assertArrayNotHasKey($chps.'_min.libelle', $retour,
 233 
				$this->assertArrayNotHasKey($chps.'_min.libelle', $retour,
234 
								"Le champs '{$chps}_min.libelle' ne doit pas être présent si retour.format=min.");
 234 
								"Le champs '{$chps}_min.libelle' ne doit pas être présent si retour.format=min.");
235 
				$this->assertArrayNotHasKey($chps.'_min.code', $retour,
 235 
				$this->assertArrayNotHasKey($chps.'_min.code', $retour,
236 
								"Le champs '{$chps}_min.code' ne doit pas être présent si retour.format=min.");
 236 
								"Le champs '{$chps}_min.code' ne doit pas être présent si retour.format=min.");
237 
				$this->assertArrayNotHasKey($chps.'_min.href', $retour,
 237 
				$this->assertArrayNotHasKey($chps.'_min.href', $retour,
238 
								"Le champs '{$chps}_min.href' ne doit pas être présent si retour.format=min.");
 238 
								"Le champs '{$chps}_min.href' ne doit pas être présent si retour.format=min.");
239 
				$this->assertArrayNotHasKey($chps.'_max.libelle', $retour,
 239 
				$this->assertArrayNotHasKey($chps.'_max.libelle', $retour,
240 
								"Le champs '{$chps}_max.libelle' ne doit pas être présent si retour.format=min.");
 240 
								"Le champs '{$chps}_max.libelle' ne doit pas être présent si retour.format=min.");
241 
				$this->assertArrayNotHasKey($chps.'_max.code', $retour,
 241 
				$this->assertArrayNotHasKey($chps.'_max.code', $retour,
242 
								"Le champs '{$chps}_max.code' ne doit pas être présent si retour.format=min.");
 242 
								"Le champs '{$chps}_max.code' ne doit pas être présent si retour.format=min.");
243 
				$this->assertArrayNotHasKey($chps.'_max.href', $retour,
 243 
				$this->assertArrayNotHasKey($chps.'_max.href', $retour,
244 
								"Le champs '{$chps}_max.href' ne doit pas être présent si retour.format=min.");
 244 
								"Le champs '{$chps}_max.href' ne doit pas être présent si retour.format=min.");
245 
			}
 245 
			}
246
246
247 
		}
 247 
		}
248 
	}
 248 
	}
249
249
250
250
251 
	public function testJsonInformationsNNBasefor_max() {
 251 
	public function testJsonInformationsNNBasefor_max() {
252 
		$ressources = array('bdtfx.nn:73256');
 252 
		$ressources = array('bdtfx.nn:73256');
253 
		$parametresList = array(
 253 
		$parametresList = array(
254 
			array('retour.format' => 'max', 'categorie' => 'description'),
 254 
			array('retour.format' => 'max', 'categorie' => 'description'),
255 
			array('retour.format' => 'max' , 'categorie' => 'ecologie'));
 255 
			array('retour.format' => 'max' , 'categorie' => 'ecologie'));
256 
			foreach ($parametresList  as $parametres) {
 256 
			foreach ($parametresList  as $parametres) {
257 
				$retour = $this->consulterJson($ressources, $parametres);
 257 
				$retour = $this->consulterJson($ressources, $parametres);
258 
				if ($parametres['categorie'] == 'description') {
 258 
				if ($parametres['categorie'] == 'description') {
259 
					$this->verifierParametresDescription_max($retour);
 259 
					$this->verifierParametresDescription_max($retour);
260 
				} else {
 260 
				} else {
261 
					$this->verifierParametresEcologie_max($retour, 'baseflor');
 261 
					$this->verifierParametresEcologie_max($retour, 'baseflor');
262 
				}
 262 
				}
263 
			}
 263 
			}
264 
	}
 264 
	}
265
265
266 
	public function testJsonInformationsNNRangSup_max() {
 266 
	public function testJsonInformationsNNRangSup_max() {
267 
		$ressources = array('bdtfx.nn:101128');
 267 
		$ressources = array('bdtfx.nn:101128');
268 
		$parametres = array('retour.format' => 'max' , 'categorie' => 'ecologie');
 268 
		$parametres = array('retour.format' => 'max' , 'categorie' => 'ecologie');
269 
			$retour = $this->consulterJson($ressources, $parametres);
 269 
			$retour = $this->consulterJson($ressources, $parametres);
270 
			if ($parametres['categorie'] == 'description') {
 270 
			if ($parametres['categorie'] == 'description') {
271 
				$this->verifierParametresDescription_max();
 271 
				$this->verifierParametresDescription_max();
272 
			} else {
 272 
			} else {
273 
				$this->verifierParametresEcologie_max($retour, 'rangSup');
 273 
				$this->verifierParametresEcologie_max($retour, 'rangSup');
274 
			}
 274 
			}
275 
	}
 275 
	}
276 
 
 276 
 
277 
	private function verifierParametresDescription_max($retour) {
 277 
	private function verifierParametresDescription_max($retour) {
278 
		$this->assertArrayHasKey('type_bio.code',$retour,
 278 
		$this->assertArrayHasKey('type_bio.code',$retour,
279 
									"Le champs 'type_bio.code'  doit  être présent si retour.format=max. ");
 279 
									"Le champs 'type_bio.code'  doit  être présent si retour.format=max. ");
280 
		$this->assertArrayHasKey('type_bio.libelle',$retour,
 280 
		$this->assertArrayHasKey('type_bio.libelle',$retour,
281 
									"Le champs 'type_bio.libelle' doit  être présent si retour.format=max.");
 281 
									"Le champs 'type_bio.libelle' doit  être présent si retour.format=max.");
282 
		$this->assertArrayHasKey('type_bio.detail',$retour,
 282 
		$this->assertArrayHasKey('type_bio.detail',$retour,
283 
									"Le champs 'type_bio.detail' doit  être présent si retour.format=max.");
 283 
									"Le champs 'type_bio.detail' doit  être présent si retour.format=max.");
284 
	}
 284 
	}
285
285
286 
	private function verifierParametresEcologie_max($retour,$type) {
 286 
	private function verifierParametresEcologie_max($retour,$type) {
287 
		$champs = array_keys(config::get('champs_ontologiques'));
 287 
		$champs = array_keys(config::get('champs_ontologiques'));
288 
		if ($type == 'baseflor') {
 288 
		if ($type == 'baseflor') {
289 
			foreach ($champs as $chps) {
 289 
			foreach ($champs as $chps) {
290 
				$this->assertArrayHasKey($chps.'.libelle', $retour,
 290 
				$this->assertArrayHasKey($chps.'.libelle', $retour,
291 
													"Le champs '{$chps}.libelle'  doit  être présent si retour.format=max.");
 291 
													"Le champs '{$chps}.libelle'  doit  être présent si retour.format=max.");
292 
				$this->assertArrayHasKey($chps.'.code', $retour,
 292 
				$this->assertArrayHasKey($chps.'.code', $retour,
293 
													"Le champs '{$chps}.code'  doit  être présent si retour.format=max.");
 293 
													"Le champs '{$chps}.code'  doit  être présent si retour.format=max.");
294 
				$this->assertArrayHasKey($chps.'.href', $retour,
 294 
				$this->assertArrayHasKey($chps.'.href', $retour,
295 
													"Le champs '{$chps}.href'  doit  être présent si retour.format=max.");
 295 
													"Le champs '{$chps}.href'  doit  être présent si retour.format=max.");
296 
			}
 296 
			}
297 
		} elseif ($type == 'rangSup') {
 297 
		} elseif ($type == 'rangSup') {
298 
			foreach ($champs as $chps) {
 298 
			foreach ($champs as $chps) {
299 
				$this->assertArrayHasKey($chps.'_min.libelle', $retour,
 299 
				$this->assertArrayHasKey($chps.'_min.libelle', $retour,
300 
											"Le champs '{$chps}_min.libelle'  doit  être présent si retour.format=max.");
 300 
											"Le champs '{$chps}_min.libelle'  doit  être présent si retour.format=max.");
301 
				$this->assertArrayHasKey($chps.'_min.code', $retour,
 301 
				$this->assertArrayHasKey($chps.'_min.code', $retour,
302 
											"Le champs '{$chps}_min.code' doit  être présent si retour.format=max.");
 302 
											"Le champs '{$chps}_min.code' doit  être présent si retour.format=max.");
303 
				$this->assertArrayHasKey($chps.'_min.href', $retour,
 303 
				$this->assertArrayHasKey($chps.'_min.href', $retour,
304 
											"Le champs '{$chps}_min.href' doit  être présent si retour.format=max.");
 304 
											"Le champs '{$chps}_min.href' doit  être présent si retour.format=max.");
305 
				$this->assertArrayHasKey($chps.'_max.libelle', $retour,
 305 
				$this->assertArrayHasKey($chps.'_max.libelle', $retour,
306 
											"Le champs '{$chps}_max.libelle' doit  être présent si retour.format=max.");
 306 
											"Le champs '{$chps}_max.libelle' doit  être présent si retour.format=max.");
307 
				$this->assertArrayHasKey($chps.'_max.code', $retour,
 307 
				$this->assertArrayHasKey($chps.'_max.code', $retour,
308 
											"Le champs '{$chps}_max.code' doit  être présent si retour.format=max.");
 308 
											"Le champs '{$chps}_max.code' doit  être présent si retour.format=max.");
309 
				$this->assertArrayHasKey($chps.'_max.href', $retour,
 309 
				$this->assertArrayHasKey($chps.'_max.href', $retour,
310 
											"Le champs '{$chps}_max.href' doit  être présent si retour.format=max.");
 310 
											"Le champs '{$chps}_max.href' doit  être présent si retour.format=max.");
311 
			}
 311 
			}
312 
		}
 312 
		}
313
- 
 
314 
	}
 313 
	}
- 
 
 314
- 
 
 315 
	//++ ------------------------------------Test du champs type biologique  -----------------------------++
- 
 
 316
- 
 
 317 
	public function testJsonTypeBioOntologies() {
- 
 
 318 
		$ressourcesList = array(array("bdtfx.nn:73256"),array("bdtfx.nn:70441"),array("bdtfx.nn:62911"),array("bdtfx.nn:72496"),
- 
 
 319 
							array("bdtfx.nn:6446"),array("bdtfx.nn:8373"), array("bdafx.nn:35574"), array("bdtfx.nn:62443"),
- 
 
 320 
							array("bdtfx.nn:62442"));
- 
 
 321 
		$parametres = array();
- 
 
 322 
		$resultats_attendus = array ('Grhi-aqua' => 'Géophytes (>= 1m) à rhizome  (plantes aquatiques) ' ,
- 
 
 323 
				'test-aqua-car' => 'Thérophytes (< 1m) estivaux  (plantes aquatiques, carnivores) ',
- 
 
 324 
				'grhi' => 'Géophytes (< 1m) à rhizome ',
- 
 
 325 
				'hsto(test)' => 'Hémicryptophytes (< 1m) stolonifères , Thérophytes (< 1m) estivaux ',
- 
 
 326 
				'Hsto-lia(Grhi-lia)' => 'Hémicryptophytes (>= 1m) stolonifères  (lianes) , Géophytes (>= 1m) à rhizome (lianes) ',
- 
 
 327 
				'Cfru(b-cad)' => 'Chaméphytes (>= 1m) frutescents , Nanophanérophytes (2 à 4m) (caducifoliées) ',
- 
 
 328 
				'test-aqua(heri)' => 'Thérophytes (< 1m) estivaux  (plantes aquatiques) , Hémicryptophytes (< 1m) érigé ',
- 
 
 329 
				'hbis(hsto,test)-suc' => 'Hémicryptophytes (< 1m) bisannuels  (succulentes) , Hémicryptophytes (< 1m) stolonifères, Thérophytes (< 1m) estivaux ',
- 
 
 330 
				'hbis(hsto)-suc' => 'Hémicryptophytes (< 1m) bisannuels  (succulentes) , Hémicryptophytes (< 1m) stolonifères ');
- 
 
 331 
		foreach ($ressourcesList as $ressources) {
- 
 
 332 
			$retour = $this->consulterJson($ressources, $parametres);
- 
 
 333 
			$code = $retour['type_bio.code'];
- 
 
 334 
			$this->assertEquals($resultats_attendus[$code], $retour['type_bio.libelle'],
- 
 
 335 
										"le traitement de l'ontologie pour les types biologiques est erroné pour $ressources[0] . ");
315
336 
		}
316
337 
	}
317
338
318 
}
 339 
}
319 
?>
 340 
?>