Subversion Repositories eFlore/Projets.eflore-projets

<?php
// declare(encoding='UTF-8');
/**
 * 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              Jean-Pascal MILCENT <jpm@tela-botanica.org>
 * @copyright   Copyright (c) 2011, 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
 * @version             $Id$
 */

abstract class ServiceEflorePhpUnit extends PHPUnit_Framework_TestCase {

        /** Définir la valeur de cet attribut dans le constructeur de la classe de test.*/
        protected $projet = '';
        /** Définir la valeur de cet attribut dans le constructeur de la classe de test.*/
        protected $service = '';

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

        public static function setUpBeforeClass() {
                error_reporting(E_ALL);

                self::chargerFramework();

                // Enregistrement en première position des autoload de la méthode gérant les classes des services
                spl_autoload_register(array(get_class(), 'chargerClasseAuto'));
        }

        public static function chargerClasseAuto($classe) {
                if (class_exists($classe)) {
                        return null;
                }
                $cheminBase = realpath(__DIR__.'/../../modules/0.1').'/';
                $cheminsTests = __DIR__.'/';
                $chemins = array($cheminBase, $cheminsTests);
                foreach ($chemins as $chemin) {
                        $chemin = $chemin.$classe.'.php';
                        if (file_exists($chemin)) {
                                require_once $chemin;
                        }
                }
        }

        private static function chargerFramework() {
                static $cheminRacine;
                if(!$cheminRacine) {
                        $cheminRacine = realpath(dirname(__FILE__).'/../..').'/';
                        $framework = $cheminRacine.'framework.php';
                        if (!file_exists($framework)) {
                                $e = "Veuillez paramétrer l'emplacement et la version du Framework dans le fichier $framework";
                                trigger_error($e, E_USER_ERROR);
                        } else {
                                // Inclusion du Framework
                                require_once $framework;
                                // Ajout d'information concernant cette application
                                Framework::setCheminAppli($cheminRacine);// Obligatoire
                        }
                }
        }

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

        static function consulterBrut($service, $projet, $ressources, $parametres = NULL) {
                if(is_null($ressources)) $ressources = array();
                array_unshift($ressources, $projet, $service);
                $projets = new Projets();
                $retourJson = $projets->consulter($ressources, $parametres);
                return $retourJson;
        }

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

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

                return Config::get('url_service') . '/' . $service . $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) {
                $efloreScript = $this->getMockForAbstractClass($classeNom, $parametres);
                return $efloreScript;
        }

        /**
         * 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);
        }

        public function assertArrayHasKeys(array $keys, array $array, $message = null) {
                foreach ($keys as $key) {
                        $this->assertArrayHasKey($key, $array, $message);
                }
        }
}

/*
sed -i 's/$this->consulterBrut(/ServiceEflorePhpUnit::consulterBrut($this->service, $this->projet, /' $(grep -rl consulterBrut)
sed -i 's/$this->consulterJson(/$this->consulterJson($this->service, $this->projet, /' $(grep -rl consulterJson)
sed -i 's/$this->creerUrl(/ServiceEflorePhpUnit::creerUrl($this->service, /' $(grep -rl creerUrl) 
*/
?>