WebSVN – Applications.referentiel – Diff – /trunk/scripts/modules/tests/Tests.php

 */
 // +-------------------------------------------------------------------------------------------------------------------+
 class Tests extends ScriptCommande {
+	private $projet = null;
-	private $projet = null;
+	private $traitement = null;
+	private $manuel = null;
+	private $resultatDao = null;
+	private $traitementDao = null;
 	private $tableStructureDao = null;
-	private $manuel = null;
+	private $referentielDao = null;
 	public function executer() {
+		// Récupération de paramêtres
-		// Récupération de paramêtres
+		$this->projet = $this->getParam('p');
+		$this->manuel = parse_ini_file($this->getModuleChemin().DS.'configurations'.DS.'referentiel_v2.1.ini');
-		$this->projet = $this->getParam('p');
+		$this->resultatDao = new ResultatDao();
-		$this->manuel = parse_ini_file($this->getModuleChemin().DS.'configurations'.DS.'referentiel_v2.1.ini');
+		$this->traitementDao = new TraitementDao();
+		// Récupération du dernier traitement demandé
+		$this->traitement = $this->traitementDao->getDernierTraitement($this->projet);
+		Debug::printr($this->traitement);
-		$traitementDao = new TraitementDao();
+		// Écriture de la date de début du traitement
-		$traitement = $traitementDao->getDernierTraitement($this->projet);
+		Debug::printr('Debute:'.$this->traitementDao->debuterTraitement($this->traitement['id_traitement']));
+		// Nettoyage des traitements obsolètes
-		Debug::printr($traitement);
+		$traitements_obsoletes = $this->traitementDao->getTraitementsObsoletes($this->projet);
-		Debug::printr('Debute:'.$traitementDao->debuterTraitement($traitement['id_traitement']));
+		Debug::printr('Supp. obsoletes:'.$this->traitementDao->supprimer($traitements_obsoletes));
 		$traitements_obsoletes = $traitementDao->getTraitementsObsoletes($this->projet);
-		Debug::printr('Supp. obsoletes:'.$traitementDao->supprimer($traitements_obsoletes));
+		// TODO : Nettoyage des tratiements (et de leurs résultats) avortés
+		// Lancement du test demandé
 		$cmd = $this->getParam('a');
-		// Lancement du test demandé
+    	switch ($cmd) {
-		$cmd = $this->getParam('a');
+			case 'tout' :
-    	switch ($cmd) {
+				$this->tableStructureDao = new TableStructureDao();
-			case 'tout' :
+				$this->referentielDao = new ReferentielDao();
+				$this->lancerTests();
+				break;
-				$this->lancerTests();
+			default :
-				break;
+				$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
 			default :
-				$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
+		// Écriture de la date de fin du traitement
-		}
-    }
 		Debug::printr('Debute:'.$this->traitementDao->terminerTraitement($this->traitement['id_traitement']));
     public function lancerTests() {
 		$donnees = array();
-		$donnees['tests'] = array();
+    public function lancerTests() {
 		$donnees = array();
 		$donnees['tests'] = array();
 		/*
 		// Récupération des données à tester
 		$colonnes = $this->tableStructureDao->getColonnes($this->projet);
 		$analyses = $this->tableStructureDao->getAnalyse($this->projet);
 		$noms = $this->referentielDao->getTout($this->projet);
 		$noms = $this->classerNomsParNumNom($noms);
 		$noms_homonymie = $this->classerNomsParNomComplet($noms);
 		// Lancement des tests unitaires
-		$donnees['tests'][] = $this->testerNombreDeChamps($colonnes);
+		$this->testerNombreDeChamps($colonnes);
-		$donnees['tests'][] = $this->testerNomDesChamps($colonnes);
+		$this->testerNomDesChamps($colonnes);
-		$donnees['tests'][] = $this->testerTypeDesChamps($colonnes);
+		$this->testerTypeDesChamps($colonnes);
-		$donnees['tests'][] = $this->testerTailleDesChamps($colonnes, $analyses);
+		$this->testerTailleDesChamps($colonnes, $analyses);
-		$donnees['tests'][] = $this->testerNumNomClePrimaire($colonnes);
+		$this->testerNumNomClePrimaire($colonnes);
-		$donnees['tests'][] = $this->testerNumNomSuperieurAZero($noms);
+		$this->testerNumNomSuperieurAZero($noms);
-		$donnees['tests'][] = $this->testerNumNomRetenuSuperieurAZero($noms);
+		$this->testerNumNomRetenuSuperieurAZero($noms);
-		$donnees['tests'][] = $this->testerNumTaxSupEgalZeroUnique($noms);
+		$this->testerNumTaxSupEgalZeroUnique($noms);
-		$donnees['tests'][] = $this->testerTaxSupPourTaxon($noms);
+		$this->testerTaxSupPourTaxon($noms);
-		$donnees['tests'][] = $this->testerExitenceTaxonSuperieur($noms);
+		$this->testerExitenceTaxonSuperieur($noms);
-		$donnees['tests'][] = $this->testerClassificationRang($noms);
+		$this->testerClassificationRang($noms);
-		$donnees['tests'][] = $this->testerClassification($noms);
+		$this->testerClassification($noms);
-		$donnees['tests'][] = $this->testerRang($noms);
+		$this->testerRang($noms);
-		$donnees['tests'][] = $this->testerNomCompletSupraGenerique($noms);
+		$this->testerNomCompletSupraGenerique($noms);
-		$donnees['tests'][] = $this->testerNomCompletGenre($noms);
+		$this->testerNomCompletGenre($noms);
-		$donnees['tests'][] = $this->testerNomCompletInfraGenre($noms);
+		$this->testerNomCompletInfraGenre($noms);
-		$donnees['tests'][] = $this->testerNomCompletEspece($noms);
+		$this->testerNomCompletEspece($noms);
-		$donnees['tests'][] = $this->testerNomCompletInfraSpecifique($noms);
+		$this->testerNomCompletInfraSpecifique($noms);
-		$donnees['tests'][] = $this->testerNomSupraGeneriqueEspaces($noms);
+		$this->testerNomSupraGeneriqueEspaces($noms);
-		$donnees['tests'][] = $this->testerNomSupraGeneriqueSyntaxe($noms);
+		$this->testerNomSupraGeneriqueSyntaxe($noms);
-		$donnees['tests'][] = $this->testerNomSupraGeneriqueRang($noms);
+		$this->testerNomSupraGeneriqueRang($noms);
-		$donnees['tests'][] = $this->testerGenreEspaces($noms);
+		$this->testerGenreEspaces($noms);
-		$donnees['tests'][] = $this->testerGenreSyntaxe($noms);
+		$this->testerGenreSyntaxe($noms);
-		$donnees['tests'][] = $this->testerGenreRang($noms);
+		$this->testerGenreRang($noms);
-		$donnees['tests'][] = $this->testerEpitheteInfraGeneriqueEspaces($noms);
+		$this->testerEpitheteInfraGeneriqueEspaces($noms);
-		$donnees['tests'][] = $this->testerEpitheteInfraGeneriqueSyntaxe($noms);
+		$this->testerEpitheteInfraGeneriqueSyntaxe($noms);
-		$donnees['tests'][] = $this->testerEpitheteInfraGeneriqueRang($noms);
+		$this->testerEpitheteInfraGeneriqueRang($noms);
-		$donnees['tests'][] = $this->testerEpitheteSpEspaces($noms);
+		$this->testerEpitheteSpEspaces($noms);
-		$donnees['tests'][] = $this->testerEpitheteSpSyntaxe($noms);
+		$this->testerEpitheteSpSyntaxe($noms);
-		$donnees['tests'][] = $this->testerEpitheteSpRang($noms);
+		$this->testerEpitheteSpRang($noms);
-		$donnees['tests'][] = $this->testerTypeEpitheteEspaces($noms);
+		$this->testerTypeEpitheteEspaces($noms);
-		$donnees['tests'][] = $this->testerTypeEpitheteSyntaxe($noms);
+		$this->testerTypeEpitheteSyntaxe($noms);
-		$donnees['tests'][] = $this->testerTypeEpitheteHybridite($noms);
+		$this->testerTypeEpitheteHybridite($noms);
-		$donnees['tests'][] = $this->testerEpitheteInfraSpEspaces($noms);
+		$this->testerEpitheteInfraSpEspaces($noms);
-		$donnees['tests'][] = $this->testerEpitheteInfraSpSyntaxe($noms);
+		$this->testerEpitheteInfraSpSyntaxe($noms);
-		$donnees['tests'][] = $this->testerEpitheteInfraSpRang($noms);
+		$this->testerEpitheteInfraSpRang($noms);
-		$donnees['tests'][] = $this->testerGroupeCultivarSyntaxe($noms);
+		$this->testerGroupeCultivarSyntaxe($noms);
-		$donnees['tests'][] = $this->testerGroupeCultivarRang($noms);
+		$this->testerGroupeCultivarRang($noms);
-		$donnees['tests'][] = $this->testerCultivarSyntaxe($noms);
+		$this->testerCultivarSyntaxe($noms);
-		$donnees['tests'][] = $this->testerCultivarRang($noms);
+		$this->testerCultivarRang($noms);
-		$donnees['tests'][] = $this->testerNomCommercialSyntaxe($noms);
+		$this->testerNomCommercialSyntaxe($noms);
-		$donnees['tests'][] = $this->testerNomCommercialPresenceCultivar($noms);
+		$this->testerNomCommercialPresenceCultivar($noms);
-		$donnees['tests'][] = $this->testerAuteurSyntaxe($noms);
+		$this->testerAuteurSyntaxe($noms);
-		$donnees['tests'][] = $this->testerAnneeSyntaxe($noms);
+		$this->testerAnneeSyntaxe($noms);
+		$this->testerBiblioOrigineSyntaxe($noms);
+		$this->testerHomonymieSyntaxe($noms);
+		$this->testerHomonymieExistence($noms, $noms_homonymie);
+		$this->testerBasionymeSyntaxe($noms);
+		$this->testerBasionymeExistence($noms);
+		$this->testerSynonymeProparteSyntaxe($noms);
+		$this->testerSynonymeProparteExistence($noms);
-		$donnees['tests'][] = $this->testerBiblioOrigineSyntaxe($noms);
+		$this->testerSynonymeDouteuxSyntaxe($noms);
-		$donnees['tests'][] = $this->testerHomonymieSyntaxe($noms);
+		$this->testerSynonymeMalAppliqueSyntaxe($noms);
 		$donnees['tests'][] = $this->testerHomonymieExistence($noms, $noms_homonymie);
+		$this->testerSynonymeOrthographiqueSyntaxe($noms);
-		$donnees['tests'][] = $this->testerBasionymeSyntaxe($noms);
+		$this->testerSynonymeOrthographiqueExistence($noms);
 		$donnees['tests'][] = $this->testerBasionymeExistence($noms);
 		$this->testerHybrideParent01Syntaxe($noms);
-		$donnees['tests'][] = $this->testerSynonymeProparteSyntaxe($noms);
+		$this->testerHybrideParent01Existence($noms);
-		$donnees['tests'][] = $this->testerSynonymeProparteExistence($noms);
+		$this->testerHybrideParent02Syntaxe($noms);
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerStatutIntroductionSyntaxe($noms) {
-		$info = array('titre' => 'statut_introduction -> syntaxe',
+		$info = array('nom' => 'statut_introduction -> syntaxe',
 			'description' => "Le champ statut_introduction peut contenir :\n".
 			" - le symbole tiret «-» une autre information non référencée...\n".
 			" - une première lettre en majuscule indiquant le code standard attribué à ce taxon.\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerStatutOrigineSyntaxe($noms) {
-		$info = array('titre' => 'statut_origine -> syntaxe',
+		$info = array('nom' => 'statut_origine -> syntaxe',
 			'description' => "Le champ statut_origine peut contenir :\n".
 			" - le symbole tiret «-» une autre information non référencée...\n".
 			" - une première lettre en majuscule indiquant le code standard attribué à ce taxon.\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerPresenceSyntaxe($noms) {
-		$info = array('titre' => 'presence -> syntaxe',
+		$info = array('nom' => 'presence -> syntaxe',
 			'description' => "Le champ presence contient soit :\n".
 			" - le symbole tiret «-» une autre information non référencée...\n".
 			" - une première lettre en majuscule indiquant le code standard attribué à ce taxon.\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerHybrideParent02Existence($noms) {
-		$info = array('titre' => 'hybride_parent_02 -> existence',
+		$info = array('nom' => 'hybride_parent_02 -> existence',
 			'description' => "Si le champ hybride_parent_02 contient un nombre alors il doit correspondre à une valeur du champ ".
 			"num_nom.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerHybrideParent02Syntaxe($noms) {
-		$info = array('titre' => 'hybride_parent_02 -> syntaxe',
+		$info = array('nom' => 'hybride_parent_02 -> syntaxe',
 			'description' => "Le champ hybride_parent_02 contient soit :\n".
 			" - une valeur vide.\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerHybrideParent01Existence($noms) {
-		$info = array('titre' => 'hybride_parent_01 -> existence',
+		$info = array('nom' => 'hybride_parent_01 -> existence',
 			'description' => "Si le champ hybride_parent_01 contient un nombre alors il doit correspondre à une valeur du champ ".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerHybrideParent01Syntaxe($noms) {
-		$info = array('titre' => 'hybride_parent_01 -> syntaxe',
+		$info = array('nom' => 'hybride_parent_01 -> syntaxe',
 			'description' => "Le champ hybride_parent_01 contient soit :\n".
 			" - une valeur vide.\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerSynonymeOrthographiqueExistence($noms) {
-		$info = array('titre' => 'synonyme_orthographique -> existence',
+		$info = array('nom' => 'synonyme_orthographique -> existence',
 			'description' => "Si le champ synonyme_orthographique contient un nombre alors il doit correspondre à une valeur du champ ".
 			"num_nom.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerSynonymeOrthographiqueSyntaxe($noms) {
-		$info = array('titre' => 'synonyme_orthographique -> syntaxe',
+		$info = array('nom' => 'synonyme_orthographique -> syntaxe',
 			'description' => "Le champ synonyme_orthographique contient soit :\n".
 			" - une valeur vide.\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerSynonymeMalAppliqueSyntaxe($noms) {
-		$info = array('titre' => 'synonyme_mal_applique -> syntaxe',
+		$info = array('nom' => 'synonyme_mal_applique -> syntaxe',
 			'description' => "Le champ synonyme_mal_applique contient soit :\n".
 			" - une valeur vide.\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerSynonymeDouteuxSyntaxe($noms) {
-		$info = array('titre' => 'synonyme_douteux -> syntaxe',
+		$info = array('nom' => 'synonyme_douteux -> syntaxe',
 			'description' => "Le champ synonyme_douteux contient soit :\n".
 			" - une valeur vide.\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerSynonymeProparteExistence($noms) {
-		$info = array('titre' => 'synonyme_proparte -> existence',
+		$info = array('nom' => 'synonyme_proparte -> existence',
 			'description' => "Si le champ synonyme_proparte contient un ou plusieurs nombres alors chacun d'entre eux ".
 			"doit correspondre à une valeur du champ num_nom.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerSynonymeProparteSyntaxe($noms) {
-		$info = array('titre' => 'synonyme_proparte -> syntaxe',
+		$info = array('nom' => 'synonyme_proparte -> syntaxe',
 			'description' => "Le champ synonyme_proparte contient soit :\n".
 			" - une valeur vide.\n".
 			" - un nombre.\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerBasionymeExistence($noms) {
-		$info = array('titre' => 'basionyme -> existence',
+		$info = array('nom' => 'basionyme -> existence',
 			'description' => "Si le champ basionyme contient un nombre alors il doit correspondre à une valeur du champ ".
 			"num_nom.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerBasionymeSyntaxe($noms) {
-		$info = array('titre' => 'basionyme -> syntaxe',
+		$info = array('nom' => 'basionyme -> syntaxe',
 			'description' => "Le champ basionyme contient :\n".
 			" - un nombre ou une valeur vide.\n",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerHomonymieExistence($noms, $noms_homonymie) {
-		$info = array('titre' => 'homonyme -> existence',
+		$info = array('nom' => 'homonyme -> existence',
 			'description' => "Si le champ homonyme contient «1» alors plusieurs noms doivent posséder la même valeur ".
 			"dans le champ nom_complet.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerHomonymieSyntaxe($noms) {
-		$info = array('titre' => 'homonyme -> syntaxe',
+		$info = array('nom' => 'homonyme -> syntaxe',
 			'description' => "Le champ homonyme contient :\n".
 			" - le chiffre 1 ou une valeur vide.\n",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerBiblioOrigineSyntaxe($noms) {
-		$info = array('titre' => 'biblio_origine -> syntaxe',
+		$info = array('nom' => 'biblio_origine -> syntaxe',
 			'description' => "Le champ biblio_origine se compose de plusieurs parties séparées par des caractères ".
 			"précis qui sont dans l'ordre de gauche à droite :\n".
 			" - Éventuellement le mot « in » suivi d'un intitulé auteur (utilisé pour indiquer l'intitulé auteur de ".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerAnneeSyntaxe($noms) {
-		$info = array('titre' => 'annee -> syntaxe',
+		$info = array('nom' => 'annee -> syntaxe',
 			'description' => "Le champ annee doit :\n".
 			" - contenir un nombre de 4 chiffre\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerAuteurSyntaxe($noms) {
-		$info = array('titre' => 'auteur -> syntaxe',
+		$info = array('nom' => 'auteur -> syntaxe',
 			'description' => "Le champ auteur doit :\n".
 			" - contenir l'intitulé complet des noms de l'auteur ou des auteurs ayant publiés à l'origine la combinaison latine courante.\n".
     		" - ou débuter par le mot « sensu » et contient l'intitulé complet des noms de l'auteur ou des auteurs ayant publiés un nom dont la description ne correspond pas à celle de l'auteur ou des auteurs d'origine.\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNomCommercialSyntaxe($noms) {
-		$info = array('titre' => 'nom_commercial -> syntaxe',
+		$info = array('nom' => 'nom_commercial -> syntaxe',
 			'description' => "Le champ nom_commercial doit contenir un nom commercial conforme aux règles du ".
 				"Code Internationnal de Nomenclature des Plantes Cultivées (CINPC) ".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNomCommercialPresenceCultivar($noms) {
-		$info = array('titre' => 'nom_commercial -> groupe_cultivar OU cultivar non vide',
+		$info = array('nom' => 'nom_commercial -> groupe_cultivar OU cultivar non vide',
 			'description' => "Si le champ nom_commercial contier un nom commercial alors le champ cultivar OU ".
 				"cultivar_groupe ne doit pas être vide.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerCultivarSyntaxe($noms) {
-		$info = array('titre' => 'cultivar -> syntaxe',
+		$info = array('nom' => 'cultivar -> syntaxe',
 			'description' => "Le champ cultivar_groupe doit contenir :\n".
 				" - un nom de cultivar conforme aux règles du Code Internationnal de Nomenclature des Plantes ".
 				"Cultivées (CINPC) qui se compose de caractères alphanumériques (A-Z,a-z et 0-9) incluant ".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerCultivarRang($noms) {
-		$info = array('titre' => "cultivar -> rang >= {$this->manuel['rang_genre']}",
+		$info = array('nom' => "cultivar -> rang >= {$this->manuel['rang_genre']}",
 			'description' => "Si le champ cultivar n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_genre']}.",
 			'resultat' => false);
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerGroupeCultivarSyntaxe($noms) {
-		$info = array('titre' => 'cultivar_groupe -> syntaxe',
+		$info = array('nom' => 'cultivar_groupe -> syntaxe',
 			'description' => "Le champ cultivar_groupe doit contenir un nom de groupe de cultivar conforme aux règles ".
 				"du code des plantes cultivées qui se compose de caractères alphanumériques (A-Z,a-z et 0-9) incluant ".
 				"signes diacritiques et marques de ponctuations.\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerGroupeCultivarRang($noms) {
-		$info = array('titre' => "cultivar_groupe -> rang >= {$this->manuel['rang_genre']}",
+		$info = array('nom' => "cultivar_groupe -> rang >= {$this->manuel['rang_genre']}",
 			'description' => "Si le champ cultivar_groupe n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_genre']}.",
 			'resultat' => false);
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerEpitheteInfraSpEspaces($noms) {
-		$info = array('titre' => 'epithete_infra_sp -> espaces en trop',
+		$info = array('nom' => 'epithete_infra_sp -> espaces en trop',
 			'description' => "Le champ epithete_infra_sp ne doit pas contenir d'espace avant ou aprés le nom.\n".
 				"Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerEpitheteInfraSpSyntaxe($noms) {
-		$info = array('titre' => 'epithete_infra_sp -> syntaxe',
+		$info = array('nom' => 'epithete_infra_sp -> syntaxe',
 			'description' => "Le champ epithete_infra_sp peut contenir :\n".
 			 	" - un mot unique composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
 				"	Il commence par une lettre minuscule (avec ou sans tréma).\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerEpitheteInfraSpRang($noms) {
-		$info = array('titre' => "epithete_infra_sp -> rang > {$this->manuel['rang_sp']}",
+		$info = array('nom' => "epithete_infra_sp -> rang > {$this->manuel['rang_sp']}",
 			'description' => "Si le champ epithete_infra_sp n'est pas vide alors le rang du nom doit être supérieur à {$this->manuel['rang_sp']}.",
 			'resultat' => false);
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerTypeEpitheteEspaces($noms) {
-		$info = array('titre' => 'type_epithete -> espaces en trop',
+		$info = array('nom' => 'type_epithete -> espaces en trop',
 			'description' => "Le champ type_epithete ne doit pas contenir d'espace.",
 			'resultat' => false);
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerTypeEpitheteSyntaxe($noms) {
-		$info = array('titre' => 'type_epithete -> syntaxe',
+		$info = array('nom' => 'type_epithete -> syntaxe',
 			'description' => "Le champ type_epithete doit contenir un mot unique composé de lettres minuscules sans ".
 				" accents et de tirets (-). Il commence par une lettre minuscule sans accent.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerTypeEpitheteHybridite($noms) {
-		$info = array('titre' => 'type_epithete -> hybridité',
+		$info = array('nom' => 'type_epithete -> hybridité',
 			'description' => "Le champ type_epithete ne doit pas contenir de préfixe indiquant l'hybridité comme : \n".
 				" - «n-» \n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNombreDeChamps($colonnes) {
-		$info = array('titre' => 'Structure -> nombre de champs : %s',
+		$info = array('nom' => 'Structure -> nombre de champs',
 			'description' => 'Le nombre de champs présent dans la table doit être supérieur ou égal à 35.',
 			'resultat' => false);
 		$nbre_colonnes = count($colonnes);
-		$info['titre'] = sprintf($info['titre'], $nbre_colonnes);
+		$info['message'] = $nbre_colonnes;
 		if ($nbre_colonnes >= 35) {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNomDesChamps($colonnes) {
-		$info = array('titre' => 'Structure -> noms des champs',
+		$info = array('nom' => 'Structure -> noms des champs',
 		$info['resultat'] = $ok;
 		if (!$ok) {
 			$info['message'] = 'Champs manquant : '.implode(', ', $champs_manquant).'.';
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerTypeDesChamps($colonnes) {
-		$info = array('titre' => 'Structure -> types des champs',
+		$info = array('nom' => 'Structure -> types des champs',
 			'description' => 'Les types des champs de la table contenant le référentiel doivent être conforme à ceux définit par le manuel technique.',
 			'resultat' => false);
 			$info['message'] = "Champs n'ayant pas un bon type : ".implode(', ', $champs_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerTailleDesChamps($colonnes, $analyses) {
-		$info = array('titre' => 'Structure -> champs tronqués',
+		$info = array('nom' => 'Structure -> champs tronqués',
 			'description' => "Vérifie que les données de type texte insérées dans la table n'ont pas été tronquées lors de leur insertion.",
 			'resultat' => false);
 			$info['message'] = "Champs possédant des enregistrements avec une taille maximum : ".implode(', ', $champs_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNumNomClePrimaire($colonnes) {
-		$info = array('titre' => 'Structure -> num_nom est clé primaire',
+		$info = array('nom' => 'Structure -> num_nom est clé primaire',
 			'description' => "Vérifie que le champ num_nom est bien la clé primaire de la table.",
 			'resultat' => false);
 		foreach ($colonnes as $colonne) {
 			if ($colonne['Field'] == 'num_nom' && $colonne['Key'] == 'PRI') {
 				$info['resultat'] = true;
+			}
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNumNomSuperieurAZero($noms) {
 			$info['message'] = count($noms_erreur)." enregistrements contiennent dans le champ num_nom une valeur inférieure ou égale à 0.";
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNumNomRetenuSuperieurAZero($noms) {
-		$info = array('titre' => 'num_nom_retenu -> supérieur à 0',
+		$info = array('nom' => 'num_nom_retenu -> supérieur à 0',
 			'description' => "Le champ num_nom_retenu doit contenir des nombres entiers supérieurs à 0.",
 			'resultat' => false);
 			$info['message'] = count($noms_erreur)." enregistrements dont le champ num_nom_retenu est inférieur ou égal à 0 : ".implode(', ', $noms_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNumTaxSupEgalZeroUnique($noms) {
-		$info = array('titre' => 'num_tax_sup -> égal à 0 unique',
+		$info = array('nom' => 'num_tax_sup -> égal à 0 unique',
 			'description' => "Un seul enregistrement doit posséder la valeur 0 dans le champ num_tax_sup. Il correspond au premier taxon de la classification.",
 			'resultat' => false);
 			$info['message'] = count($noms_erreur)." enregistrements ont une valeur de 0 dans le champ num_tax_sup : ".implode(', ', $noms_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerTaxSupPourTaxon($noms) {
-		$info = array('titre' => 'Classification -> uniquement pour les taxons',
+		$info = array('nom' => 'Classification -> uniquement pour les taxons',
 			'description' => "Seul les enregistrements représentant un taxon doivent posséder une valeur dans le champ num_tax_sup.",
 			'resultat' => false);
 			$info['message'] = count($noms_erreur)." enregistrements qui n'est pas un taxon et qui possède une valeur dans num_tax_sup : ".implode(', ', $noms_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerExitenceTaxonSuperieur($noms) {
-		$info = array('titre' => 'Classification -> existence du taxon supérieur',
+		$info = array('nom' => 'Classification -> existence du taxon supérieur',
 			'description' => "Pour chaque enregistrement représentant un taxon doit posséder un taxon supérieur sauf la racine de la classification.",
 			'resultat' => false);
 			$info['message'] = count($noms_erreur)." enregistrements dont le taxon supérieur n'existe pas : ".implode(', ', $noms_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerClassificationRang($noms) {
-		$info = array('titre' => 'Classification -> taxon supérieur avec rang inférieur',
+		$info = array('nom' => 'Classification -> taxon supérieur avec rang inférieur',
 			'description' => "Pour chaque enregistrement représentant un taxon, chaque taxon supérieur doit avoir un rang inférieur au taxon courant.",
 			'resultat' => false);
 			$info['message'] = count($noms_erreur)." enregistrements avec un problème : ".implode(', ', $noms_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerClassification($noms) {
-		$info = array('titre' => 'Classification -> racine liée à chaque noeud',
+		$info = array('nom' => 'Classification -> racine liée à chaque noeud',
 			'description' => "Pour chaque enregistrement, la classification doit pouvoir être remonté jusqu'à un même nom unique possédant une valeur num_tax_sup de 0.",
 			'resultat' => false);
 			$info['message'] = count($noms_erreur)." taxons dont la classification n'est pas bonne : ".implode(', ', $noms_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function remonterClassif(&$noms, $nom) {
 			return $this->remonterClassif($noms, $noms[$nom['num_tax_sup']]);
+		}
+	}
 	private function testerRang($noms) {
-		$info = array('titre' => 'rang',
+		$info = array('nom' => 'rang',
 			'description' => "Le rang doit correspondre à un valeur numérique définit dans le manuel.",
 			'resultat' => false);
 			$info['message'] = count($noms_erreur)." noms dont le rang n'est pas bon : ".implode(', ', $noms_erreur).'.';
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNomCompletSupraGenerique($noms) {
-		$info = array('titre' => 'nom_complet -> noms supra-génériques',
+		$info = array('nom' => 'nom_complet -> noms supra-génériques',
 			'description' => "Si le rang est < à {$this->manuel['rang_genre']} le nom_complet doit correspondre à la valeur du champ nom_supra_generique. ".
 				"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNomCompletGenre($noms) {
-		$info = array('titre' => 'nom_complet -> noms de genres',
+		$info = array('nom' => 'nom_complet -> noms de genres',
 			'description' => "Si le rang est = à {$this->manuel['rang_genre']} le nom_complet doit correspondre à la valeur du champ genre. ".
 				"Les valeurs des champs cultivar_groupe, cultivar et nom_commercial peuvent s'y ajouter.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNomCompletInfraGenre($noms) {
-		$info = array('titre' => 'nom_complet -> noms infra-génériques',
+		$info = array('nom' => 'nom_complet -> noms infra-génériques',
 			'description' => "Si le rang est > à {$this->manuel['rang_genre']} et < à {$this->manuel['rang_sp']} le nom_complet doit correspondre à une des formules suivantes : \n".
 			" genre + ' ' + type_epithete + ' ' + epithete_infra_generique \n".
 			" genre + ' ' + epithete_infra_generique + ' ' + type_epithete=agg. \n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNomCompletEspece($noms) {
-		$info = array('titre' => "nom_complet -> noms d'espèce",
+		$info = array('nom' => "nom_complet -> noms d'espèce",
 			'description' => "Si le rang est = à {$this->manuel['rang_sp']} le nom_complet doit correspondre à la formule : \n".
 				" genre + ' ' + epithete_sp \n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNomCompletInfraSpecifique($noms) {
-		$info = array('titre' => 'nom_complet -> noms infra-spécifiques',
+		$info = array('nom' => 'nom_complet -> noms infra-spécifiques',
 			'description' => "Si le rang est > à {$this->manuel['rang_sp']} le nom_complet doit correspondre à la formule : \n".
 				" genre + ' ' + epithete_sp + ' ' + type_epithete + ' ' + epithete_infra_generique\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNomSupraGeneriqueEspaces($noms) {
-		$info = array('titre' => 'nom_supra_generique -> espaces en trop',
+		$info = array('nom' => 'nom_supra_generique -> espaces en trop',
 			'description' => "Le champ nom_supra_generique ne doit pas contenir d'espace avant ou aprés le nom.",
 			'resultat' => false);
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNomSupraGeneriqueSyntaxe($noms) {
-		$info = array('titre' => 'nom_supra_generique -> syntaxe',
+		$info = array('nom' => 'nom_supra_generique -> syntaxe',
 			'description' => "Le champ nom_supra_generique contient un mot composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
 				"La première lettre (avec ou sans tréma) du mot doit être en majuscule.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerNomSupraGeneriqueRang($noms) {
-		$info = array('titre' => "nom_supra_generique -> rang < {$this->manuel['rang_genre']}",
+		$info = array('nom' => "nom_supra_generique -> rang < {$this->manuel['rang_genre']}",
 			'description' => "Si le champ nom_supra_generique n'est pas vide alors le rang du nom doit être inférieur à {$this->manuel['rang_genre']}.",
 			'resultat' => false);
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerGenreEspaces($noms) {
-		$info = array('titre' => 'genre -> espaces en trop',
+		$info = array('nom' => 'genre -> espaces en trop',
 			'description' => "Le champ genre ne doit pas contenir d'espace avant ou aprés le nom.\n".
 				"Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerGenreSyntaxe($noms) {
-		$info = array('titre' => 'genre -> syntaxe',
+		$info = array('nom' => 'genre -> syntaxe',
 			'description' => "Le champ genre peut contenir :\n".
 			 	" - un mot unique composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
 				"	Il commence par une lettre majuscule (avec ou sans tréma).".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerGenreRang($noms) {
-		$info = array('titre' => "genre -> rang >= {$this->manuel['rang_genre']}",
+		$info = array('nom' => "genre -> rang >= {$this->manuel['rang_genre']}",
 			'description' => "Si le champ genre n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_genre']}.",
 			'resultat' => false);
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerEpitheteInfraGeneriqueSyntaxe($noms) {
-		$info = array('titre' => 'epithete_infra_generique -> syntaxe',
+		$info = array('nom' => 'epithete_infra_generique -> syntaxe',
 			'description' => "Le champ epithete_infra_generique est composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n".
 				"La première lettre (avec ou sans tréma) doit être en majuscule.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerEpitheteInfraGeneriqueRang($noms) {
-		$info = array('titre' => "epithete_infra_generique -> {$this->manuel['rang_genre']} < rang < {$this->manuel['rang_sp']}",
+		$info = array('nom' => "epithete_infra_generique -> {$this->manuel['rang_genre']} < rang < {$this->manuel['rang_sp']}",
 			'description' => "Si le champ epithete_infra_generique n'est pas vide alors le rang du nom doit être compris \n".
 				"entre {$this->manuel['rang_genre']} et {$this->manuel['rang_sp']}.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerEpitheteInfraGeneriqueEspaces($noms) {
-		$info = array('titre' => 'epithete_infra_generique -> espaces en trop',
+		$info = array('nom' => 'epithete_infra_generique -> espaces en trop',
 			'description' => "Le champ epithete_infra_generique ne doit pas contenir d'espace avant ou aprés sa valeur.",
 			'resultat' => false);
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerEpitheteSpEspaces($noms) {
-		$info = array('titre' => 'epithete_sp -> espaces en trop',
+		$info = array('nom' => 'epithete_sp -> espaces en trop',
 			'description' => "Le champ epithete_sp ne doit pas contenir d'espace avant ou aprés le nom.\n".
 				"Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.",
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerEpitheteSpSyntaxe($noms) {
-		$info = array('titre' => 'epithete_sp -> syntaxe',
+		$info = array('nom' => 'epithete_sp -> syntaxe',
 			'description' => "Le champ epithete_sp peut contenir :\n".
 			 	" - un mot unique composé de lettres minuscules [a-z] incluant les caractères [ëï-]. \n".
 				"	Il commence par une lettre minuscule [a-zëï].\n".
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}
 	private function testerEpitheteSpRang($noms) {
-		$info = array('titre' => "epithete_sp -> rang >= {$this->manuel['rang_sp']}",
+		$info = array('nom' => "epithete_sp -> rang >= {$this->manuel['rang_sp']}",
 			'description' => "Si le champ epithete_sp n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_sp']}.",
 			'resultat' => false);
 			$info['message']['lignes'] = $noms_erreur;
 		} else {
 			$info['resultat'] = true;
+		}
-		return $info;
+		$this->traiterResultatTest($info);
+	}

Subversion Repositories Applications.referentiel

(root)/trunk/scripts/modules/tests/Tests.php – Rev 26 → 30