Subversion Repositories eFlore/Applications.eflore-consultation

<?php
/**
 * Classe contenant des méthodes :
 *      - d'intialisation des tests,
 *      - refactorisant le code des tests,
 *      - facilitant les tests.
 *
 * @category    php 5.3
 * @package             Tests/Services
 * @author              Raphaël Droz <raphael@tela-botanica.org>
 * @author              Jean-Pascal MILCENT <jpm@tela-botanica.org>
 * @copyright   Copyright (c) 2011, 2013 Tela Botanica (accueil@tela-botanica.org)
 * @license             http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
 * @license             http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
 */

define('CONFIG_DIR', __DIR__ . '/../configurations');
require_once __DIR__ . '/../framework.php';
abstract class ConsultationEflorePhpUnit extends PHPUnit_Framework_TestCase {
    const URL_API = 'http://localhost/service:eflore:0.1';
        const TPL_URL_BASE = 'http://localhost/consultation/index_botanique.php?referentiel=bdtfx';
        const TPL_URL_BASE_DOSSIER = 'http://localhost/consultation/';
        const TPL_URL_FICHE = 'http://localhost/consultation/index_botanique.php?referentiel=bdtfx&module=fiche&action=fiche&nn=%s';

        //+------------------------------------------------------------------------------------------------------+
        // Intialisation

    /* absolument nécessaire pour que Registre::$statics et Config::$statics soient réinitialisés lors
       de multiples tests successifs (notamment pour le moteur de recherche).
       *Et* l'annotation de setUpBeforeClass()
       *et* l'attribut $backupStaticAttributes
       *et* l'accès fictif @Registre::get(NULL);
       sont tous trois nécessaires */
    protected $backupStaticAttributes = true;

    /**
     * @backupStaticAttributes enabled
     */
        public static function setUpBeforeClass() {
                error_reporting(E_ALL);
        if(!Framework::getCheminAppli()) {
            Framework::setCheminAppli(__DIR__ . '/../');
            // Enregistrement en première position des autoload de la méthode gérant les classes des services
            spl_autoload_register(array(get_class(), 'chargerClasseAuto'));
        }
        Registre::get(NULL);
        }

        public static function chargerClasseAuto($classe) {
                //echo $classe."\n";
                if (class_exists($classe)) {
                        return null;
                }
                
                $cheminsTests = __DIR__.'/';
                // $cheminBibliotheque = realpath(__DIR__.'/../bibliotheque/').'/';
                $cheminMetier = realpath(__DIR__.'/../metier/api_0.1').'/';
                $cheminModule = realpath(__DIR__.'/../modules/').'/';
                $cheminFormateurs = realpath(__DIR__.'/../modules/fiche/formateurs/').'/'; // pour FicheTest::testExecuterFiche()
                $chemins = array(/* $cheminBibliotheque, */ $cheminMetier, $cheminModule, $cheminsTests, $cheminFormateurs);
                foreach ($chemins as $chemin) {
                        $cheminCourt = $chemin.$classe.'.php';
                        $module = strtolower(preg_replace('/([A-Z])/', '_\\1', lcfirst($classe)));
                        $cheminLong = $chemin.$module.'/'.$classe.'.php';
                        //echo $cheminCourt."\n".$cheminLong."\n";
                        if (file_exists($cheminCourt)) {
                                require_once $cheminCourt;
                        } elseif (file_exists($cheminLong)) {
                                require_once $cheminLong;
                        }
                }
        }

        //+------------------------------------------------------------------------------------------------------+
        // Refactorisation
        protected function consulterJson($ressources, $parametres) {
                $retourJson = $this->consulterBrut($ressources, $parametres);
                $retour = json_decode($retourJson, true);
                $this->assertEquals(JSON_ERROR_NONE, json_last_error(), "Le json contient des erreurs qui bloquent le décodage. Voir : $url");
                return $retour;
        }

        protected function consulterBrut($ressources, $parametres) {
                array_unshift($ressources, $this->service);
                array_unshift($ressources, $this->projet);
                $projets = new Projets();
                $retourJson = $projets->consulter($ressources, $parametres);
                return $retourJson;
        }

        protected function creerUrl($ressources, $parametres) {
                $version = '';
                $ressourcesUrl = array();
                foreach ($ressources as $ressource) {
                        $ressourcesUrl[] = $ressource;
                }
                $ressourcesUrl = count($ressourcesUrl) > 0 ? '/'.implode('/', $ressourcesUrl) : '';

                $parametresUrl = '';
                if (count($parametres) > 0) {
                        foreach ($parametres as $cle => $valeur) {
                                $parametresUrl[] = $cle.'='.rawurlencode($valeur);
                        }
                        $parametresUrl = '?'.implode('&', $parametresUrl);
                }

                return self::URL_API.$ressourcesUrl.$parametresUrl;
        }

        //+------------------------------------------------------------------------------------------------------+
        // Méthodes facilitant les tests
        
        /**
        * Récupère un bouchon de classe abstraite.
        * Comment l'utiliser :
        *       $classeAstraite = $this->getClasseAbstraite('MaClasse', array('param1', 'param2'));
        *       $foo = $classeAstraite->methodeConcretePublique();
        *
        * @param String $classeNom Le nom de la classe
        * @param Array $parametres Les paramètres à passer au constructeur.
        * @return Object Le bouchon de la classe abstraite
        */
        public function getClasseAbstraite($classeNom, Array $parametres) {
                return $this->getMockForAbstractClass($classeNom, $parametres);
        }

        /**
         * Récupère une méthode privée d'une classe pour tester/documenter.
         * Comment l'utiliser :
         *      MyClass->foo():
         *       $cls = new MyClass();
         *       $foo = self::getPrivateMethode($cls, 'foo');
         *       $foo->invoke($cls, $...);
         *
         * @param object $objet Une instance de votre classe
         * @param string $methode Le nom de la méthode private
         * @return ReflectionMethod La méthode demandée
         */
        public static function getMethodePrivee($objet, $nomMethode) {
                $classe = new ReflectionClass($objet);
                $methode = $classe->getMethod($nomMethode);
                $methode->setAccessible(true);
                return $methode;
        }

        /**
        * Récupère une méthode protégée d'une classe pour tester/documenter.
        * Comment l'utiliser :
        *       MyClass->foo():
        *       $cls = new MyClass();
        *       $foo = self::getProtectedMethode($cls, 'foo');
        *       $foo->invoke($cls, $...);
        * @param object $objet Une instance de votre classe
        * @param string $methode Le nom de la méthode protected
        * @return ReflectionMethod La méthode demandée
        */
        public static function getMethodeProtegee($objet, $nomMethode) {
                return self::getMethodePrivee($objet, $nomMethode);
        }
}
?>