Subversion Repositories eFlore/Projets.eflore-projets

Rev

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

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