trunk/tests/base.php

<?php
/**
 * Ce script contient la déclaration des classes BaseTesCase et Base2TestCase.
 *
 * @package openfoncier
 * @version SVN : $Id: base.php 4802 2015-05-27 14:13:05Z nhaye $
 */

class BaseTestCase extends PHPUnit_Extensions_SeleniumTestCase {

    protected function setUp() {
        $this->setBrowser("firefox");
        $this->setBrowserUrl("http://localhost/");
        //$this->setSleep(1);
    }

    protected function tearDown() {
        
    }

    protected function connect($login, $password) {
        $this->open(BASE_PATH_URL);
        $this->type("id=login", $login);
        $this->type("id=password", $password);
        $this->click("name=login.action.connect");
        $this->waitForPageToLoad("30000");
    }

    protected function deconnect() {
        $this->click("link=Déconnexion");
        $this->waitForPageToLoad("30000");
    }

    protected function login($login, $password) {
        // on commence par se connecter
        $this->connect($login,  $password);
        // On vérifie qu'il n'y a pas d'erreur sur l'élément affiché
        $this->verifyNoErrors();
        // On doit être connecté
        $this->assertTrue($this->isTextPresent("Votre session est maintenant ouverte."));
    }

    protected function logout() {
        // puis on se déconnecte
        $this->deconnect();
        // On vérifie qu'il n'y a pas d'erreur sur l'élément affiché
        $this->verifyNoErrors();
        // on doit avoir un message nous indiquant que la session est finie
        $this->assertTrue($this->isTextPresent("Votre session est maintenant terminée."));
        // on ne doit plus avoir de lien de déconnexion
        $this->assertFalse($this->isElementPresent("link=Déconnexion"));
    }

    /**
     * Cette méthode permet de fair un assert sur la NON présence d'un message
     * indiquant une erreur de base de données ou une notice PHP
     */ 
    public function verifyNoErrors() {
        try {
            $this->assertFalse($this->isTextPresent("Erreur de base de données. Contactez votre administrateur."));
        } catch (PHPUnit_Framework_AssertionFailedError $e) {
            array_push($this->verificationErrors, "Erreur de base de données.");
        }
        try {
            $this->assertFalse($this->isTextPresent("Parse error:"));
        } catch (PHPUnit_Framework_AssertionFailedError $e) {
            array_push($this->verificationErrors, "PHP Parse error:");
        }
        try {
            $this->assertFalse($this->isTextPresent("Fatal error:"));
        } catch (PHPUnit_Framework_AssertionFailedError $e) {
            array_push($this->verificationErrors, "PHP Fatal error:");
        }
        try {
            $this->assertFalse($this->isTextPresent("Notice:"));
        } catch (PHPUnit_Framework_AssertionFailedError $e) {
            array_push($this->verificationErrors, "PHP Notice:");
        }
    }

}

/**
 * Cette classe est une classe de base à utiliser par les tests (thèmes)
 * fonctionnels utilisant Selenium2 pour avoir les méthodes communes setUp,
 * tearDown ainsi que certaines méthodes utilitaires comme login, logout, ou
 * verifiynoerrors...
 */
class Base2TestCase extends PHPUnit_Extensions_Selenium2TestCase {

    /**
     * Url de base
     * @var string
     */
    var $url = BASE_PATH_URL;

    /**
     * Chemin dossier des screenshots
     * @var string
     */
    var $screenshotPath = '';

    /**
     * Option capture d'écran
     * @var boolean
     */
    var $screenshotOnFailureAndError = true;

    /**
     * Cette méthode est appelée avant le lancement de chaque test
     * (fonctionnalité).
     */
    protected function setUp() {
        $this->screenshotPath = '/var/www/'.BASE_PATH_URL.'tests/results/';
        // On positionne le navigateur
        $this->setBrowser("firefox");
        //$this->setBrowser("chrome");
        // On positionne l'URL de base
        $this->setBrowserUrl("http://localhost/");
        $this->setPort(SELENIUM_PORT);
        // Instancie la timezone
        date_default_timezone_set('Europe/Paris');
    }

    /**
     * Cette méthode est appelée après le lancement de chaque test
     * (fonctionnalité).
     */
    protected function tearDown() {

        // Récupère le statut
        $status = $this->getStatus();
        // Si l'option capture d'écran est activé et qu'il y a une erreur(error) 
        // ou un echec(failure)
        if ($this->screenshotOnFailureAndError === true
            && ($status == PHPUnit_Runner_BaseTestRunner::STATUS_ERROR
                || $status == PHPUnit_Runner_BaseTestRunner::STATUS_FAILURE)) {
            // Si c'est une erreur
            if ($status == PHPUnit_Runner_BaseTestRunner::STATUS_ERROR) {
                $startFilename = "error_";
            }
            // Si c'est un echec
            if ($status == PHPUnit_Runner_BaseTestRunner::STATUS_FAILURE) {
                $startFilename = "failure_";
            }
            // Nom de l'image
            $filename = $startFilename.$this->getName()."_".date("Ymd_His").".png";
            // Ajout de l'image
            file_put_contents($this->screenshotPath.$filename, 
                $this->currentScreenshot());
        }
    }

    /**
     * Cette méthode permet de connecter l'utilisateur à l'application.
     */
    protected function connect($login, $password) {
        // On ouvre l'url openexemple
        $this->url($this->url);
        $this->timeouts()->implicitWait(2000);
        // On saisit le login dans le champ login
        $this->byId("login")->clear();
        $this->byId("login")->value($login);
        // On saisit le mot de passe dans le champ mot de passe
        $this->byId("password")->clear();
        $this->byId("password")->value($password);
        // On clique sur le bouton de connexion
        $this->byname("login.action.connect")->click();
    }

    /**
     * Cette méthode permet de déconnecter l'utilisateur.
     */
    protected function deconnect() {
        // On clique sur le lien de déconnexion
        $element = $this->bycssselector("a.actions-logout");
        $element->click();
    }

    /**
     * Cette méthode permet de connecter l'utilisateur à l'application et de
     * vérifier que la connecion s'est bien déroulée.
     */
    protected function login($login, $password) {
        // On se connecte
        $this->connect($login,  $password);
        // Allonge le temps d'attente lors de la recherche d'élément
        $this->timeouts()->implicitWait(10000);
        // On vérifie qu'il n'y a pas d'erreur sur l'élément affiché
        $this->verifynoerrors();
        // On vérifie qu'un message nous indique que la session est ouverte
        $element = $this->bycssselector("div.message span.text");
        $this->assertequals("Votre session est maintenant ouverte.", $element->text());
    }

    /**
     * Cette méthode vérifier que la déconnexion s'est bien déroulée.
     */
    protected function verifyDeconnect() {
        // Réduit le temps d'attente lors de la recherche d'élément
        $this->timeouts()->implicitWait(240);
        // On vérifie qu'il n'y a pas d'erreur sur l'élément affiché
        $this->verifynoerrors();
        // On vérifie qu'un message nous indique que la session est terminée
        $element = $this->bycssselector("div.message span.text");
        $this->assertequals("Votre session est maintenant terminée.", $element->text());
        // On vérifie que le lien de déconnexion n'est pas présent
        try {
            $el = $this->bycssselector("a.actions-logout");
            $this->fail("The element shouldn't exist.");
        } catch (RuntimeException $e) {}
        //Ferme la fenêtre
        $this->closeWindow();
    }

    /**
     * Cette méthode permet de déconnecter l'utilisateur et de vérifier que la
     * déconnexion s'est bien déroulée.
     */
    protected function logout() {
        // On se déconnecte
        $this->deconnect();
        // On vérifie que la déconnexion s'est bien déroulée
        $this->verifyDeconnect();
    }

    /**
     * Cette méthode permet de fair un assert sur la NON présence d'un message
     * indiquant une erreur de base de données ou une notice PHP.
     * XXX Remplacer les tests par des expressions régulières pour améliorer
     *     les performances et être plus exhaustif
     */ 
    public function verifynoerrors() {
        // On récupère le contenu du rendu de la page
        $source = $this->source();
        // On vérifie la présence du message d'erreur de base de données
        try {
            $this->assertNotContains("Erreur de base de données. Contactez votre administrateur.", $source);
            $this->assertNotContains("Erreur de base de donnees. Contactez votre administrateur.", $source);
        } catch (PHPUnit_Framework_AssertionFailedError $e) {
            $this->fail("Failed asserting that the source does not contain \"Erreur de base de données\".");
        }
        // On vérifie la présence d'une erreur fatale PHP
        try {
            $this->assertNotContains("Fatal error:", $source);
        } catch (PHPUnit_Framework_AssertionFailedError $e) {
            $this->fail("Failed asserting that the source does not contain \"PHP Fatal error:\".");
        }
        // On vérifie la présence d'une erreur fatale PHP
        try {
            $this->assertNotContains("<b>Fatal error</b>", $source);
        } catch (PHPUnit_Framework_AssertionFailedError $e) {
            $this->fail("Failed asserting that the source does not contain \"PHP Fatal error:\".");
        }
        // On vérifie la présence d'une erreur de syntaxe PHP
        try {
            $this->assertNotContains("Parse error:", $source);
        } catch (PHPUnit_Framework_AssertionFailedError $e) {
            $this->fail("Failed asserting that the source does not contain \"PHP Parse error:\".");
        }
        // On vérifie la présence d'une erreur de syntaxe PHP
        try {
            $this->assertNotContains("<b>Parse error</b>", $source);
        } catch (PHPUnit_Framework_AssertionFailedError $e) {
            $this->fail("Failed asserting that the source does not contain \"PHP Parse error:\".");
        }
        // On vérifie la présence d'une notice PHP
        try {
            $this->assertNotContains("Notice:", $source);
        } catch (PHPUnit_Framework_AssertionFailedError $e) {
            $this->fail("Failed asserting that the source does not contain \"PHP Notice:\".");
        }
        // On vérifie la présence d'une notice PHP
        try {
            $this->assertNotContains("<b>Notice</b>", $source);
        } catch (PHPUnit_Framework_AssertionFailedError $e) {
            $this->fail("Failed asserting that the source does not contain \"PHP Notice:\".");
        }
    }

    /**
     * Cette fonction permet de cliquer sur le menu si celui-ci n'est pas déjà 
     * ouvert de base en fonction de l'utilisateur
     * @param  string   $menu           Titre du menu
     * @param  array    $utilisateur    Login et mdp de l'utilisateur
     */
    public function openMenu($menu, $utilisateur) {
        // Si le menu est 'Guichet Unique'
        if ($menu == 'Guichet Unique') {
            // Vérifie les utilisateurs
            if ($utilisateur["login"] != "guichet") {
                // Clique sur le menu
                $this->byLinkText($menu)->click();
                $this->verifyNoErrors();
            }
        }
        // Si le menu est 'Instruction'
        if ($menu == 'Instruction') {
            // Vérifie les utilisateurs
            if ($utilisateur["login"] != "instr"
                && $utilisateur["login"] != "visudadi"
                && $utilisateur["login"] != "divi"
                && $utilisateur["login"] != "chef"
                && $utilisateur["login"] != "adminfonct") {
                // Clique sur le menu
                $this->byLinkText($menu)->click();
                $this->verifyNoErrors();
            }
        }
        // Si le menu est 'Suivi'
        if ($menu == 'Suivi') {
            // Vérifie les utilisateurs
            if ($utilisateur["login"] != "suivi") {
                // Clique sur le menu
                $this->byLinkText($menu)->click();
                $this->verifyNoErrors();
            }
        }
        // Si le menu est 'Demandes D'avis'
        if ($menu == "Demandes D'avis") {
            //  Vérifie les utilisateurs
            if ($utilisateur["login"] != "consu"
                && $utilisateur["login"] != "consu1"
                && $utilisateur["login"] != "consu2") {
                // Clique sur le menu
                $this->byLinkText($menu)->click();
                $this->verifyNoErrors();
            }
        }
    }

    /**
     * COPIE DE LA FONCTION mois_date() DE LA CLASSE utils
     */
    /**
     * Calcule uen date avec l'ajout ou le soustrait de mois.
     * @param date    $date     Date de base
     * @param integer $delay    Délais à ajouter (en mois)
     * @param string  $operator Opérateur pour le calcul ("-" ou "+")
     * 
     * @return date             Date calculée
     */
    function mois_date($date, $delay, $operator = "+") {

        // Découpage de la date
        $temp = explode("-", $date);
        $day = (int) $temp[2];
        $month = (int) $temp[1];
        $year = (int) $temp[0];

        // Si c'est une addition
        if ($operator == '+') {
            // Année à ajouter
            $year += floor($delay / 12);
            // Mois restant
            $nb_month = ($delay % 12);
            // S'il y a des mois restant
            if ($nb_month != 0) {
                // Ajout des mois restant
                $month += $nb_month;
                // Si ça dépasse le mois 12 (décembre)
                if ($month > 12) {
                    // Soustrait 12 au mois
                    $month -= 12;
                    // Ajoute 1 à l'année
                    $year += 1;
                }
            }
        }

        // Si c'est une soustraction
        if ($operator == "-") {
            // Année à soustraire
            $year -= floor($delay / 12);
            // Mois restant
            $nb_month = ($delay % 12);
            // S'il y a des mois restant
            if ($nb_month != 0) {
                // Soustrait le délais
                $month -= $nb_month;
                // Si ça dépasse le mois 1 (janvier)
                if ($month < 1) {
                    // Soustrait 12 au mois
                    $month += 12;
                    // Ajoute 1 à l'année
                    $year -= 1;
                }
            }
        }

        // Calcul du nombre de jours dans le mois sélectionné
        switch($month) {
            // Mois de février
            case "2":
                if ($year % 4 == 0 && $year % 100 != 0 || $year % 400 == 0) {
                    $day_max = 29;
                } else {
                    $day_max = 28;
                }
            break;
            // Mois d'avril, juin, septembre et novembre
            case "4":
            case "6":
            case "9":
            case "11":
                $day_max = 30;
            break;
            // Mois de janvier, mars, mai, juillet, août, octobre et décembre 
            default:
                $day_max = 31;
        }

        // Si le jour est supérieur au jour maximum du mois
        if ($day > $day_max) {
            // Le jour devient le jour maximum
            $day = $day_max;
        }

        // Compléte le mois et le jour par un 0 à gauche si c'est un chiffre
        $month = str_pad($month, 2, "0", STR_PAD_LEFT);
        $day = str_pad($day, 2, "0", STR_PAD_LEFT);

        // Retourne la date calculée
        return $year."-".$month."-".$day ;
    }

}

?>
1	mbroquet	3730	<?php
2			/**
3			* Ce script contient la déclaration des classes BaseTesCase et Base2TestCase.
4			*
5			* @package openfoncier
6			* @version SVN : $Id: base.php 4802 2015-05-27 14:13:05Z nhaye $
7			*/
8
9			class BaseTestCase extends PHPUnit_Extensions_SeleniumTestCase {
10
11			protected function setUp() {
12			$this->setBrowser("firefox");
13			$this->setBrowserUrl("http://localhost/");
14			//$this->setSleep(1);
15			}
16
17			protected function tearDown() {
18
19			}
20
21			protected function connect($login, $password) {
22			$this->open(BASE_PATH_URL);
23			$this->type("id=login", $login);
24			$this->type("id=password", $password);
25			$this->click("name=login.action.connect");
26			$this->waitForPageToLoad("30000");
27			}
28
29			protected function deconnect() {
30			$this->click("link=Déconnexion");
31			$this->waitForPageToLoad("30000");
32			}
33
34			protected function login($login, $password) {
35			// on commence par se connecter
36			$this->connect($login, $password);
37			// On vérifie qu'il n'y a pas d'erreur sur l'élément affiché
38			$this->verifyNoErrors();
39			// On doit être connecté
40			$this->assertTrue($this->isTextPresent("Votre session est maintenant ouverte."));
41			}
42
43			protected function logout() {
44			// puis on se déconnecte
45			$this->deconnect();
46			// On vérifie qu'il n'y a pas d'erreur sur l'élément affiché
47			$this->verifyNoErrors();
48			// on doit avoir un message nous indiquant que la session est finie
49			$this->assertTrue($this->isTextPresent("Votre session est maintenant terminée."));
50			// on ne doit plus avoir de lien de déconnexion
51			$this->assertFalse($this->isElementPresent("link=Déconnexion"));
52			}
53
54			/**
55			* Cette méthode permet de fair un assert sur la NON présence d'un message
56			* indiquant une erreur de base de données ou une notice PHP
57			*/
58			public function verifyNoErrors() {
59			try {
60			$this->assertFalse($this->isTextPresent("Erreur de base de données. Contactez votre administrateur."));
61			} catch (PHPUnit_Framework_AssertionFailedError $e) {
62			array_push($this->verificationErrors, "Erreur de base de données.");
63			}
64			try {
65			$this->assertFalse($this->isTextPresent("Parse error:"));
66			} catch (PHPUnit_Framework_AssertionFailedError $e) {
67			array_push($this->verificationErrors, "PHP Parse error:");
68			}
69			try {
70			$this->assertFalse($this->isTextPresent("Fatal error:"));
71			} catch (PHPUnit_Framework_AssertionFailedError $e) {
72			array_push($this->verificationErrors, "PHP Fatal error:");
73			}
74			try {
75			$this->assertFalse($this->isTextPresent("Notice:"));
76			} catch (PHPUnit_Framework_AssertionFailedError $e) {
77			array_push($this->verificationErrors, "PHP Notice:");
78			}
79			}
80
81			}
82
83			/**
84			* Cette classe est une classe de base à utiliser par les tests (thèmes)
85			* fonctionnels utilisant Selenium2 pour avoir les méthodes communes setUp,
86			* tearDown ainsi que certaines méthodes utilitaires comme login, logout, ou
87			* verifiynoerrors...
88			*/
89			class Base2TestCase extends PHPUnit_Extensions_Selenium2TestCase {
90
91			/**
92			* Url de base
93			* @var string
94			*/
95			var $url = BASE_PATH_URL;
96
97			/**
98			* Chemin dossier des screenshots
99			* @var string
100			*/
101			var $screenshotPath = '';
102
103			/**
104			* Option capture d'écran
105			* @var boolean
106			*/
107			var $screenshotOnFailureAndError = true;
108
109			/**
110			* Cette méthode est appelée avant le lancement de chaque test
111			* (fonctionnalité).
112			*/
113			protected function setUp() {
114			$this->screenshotPath = '/var/www/'.BASE_PATH_URL.'tests/results/';
115			// On positionne le navigateur
116			$this->setBrowser("firefox");
117			//$this->setBrowser("chrome");
118			// On positionne l'URL de base
119			$this->setBrowserUrl("http://localhost/");
120			$this->setPort(SELENIUM_PORT);
121			// Instancie la timezone
122			date_default_timezone_set('Europe/Paris');
123			}
124
125			/**
126			* Cette méthode est appelée après le lancement de chaque test
127			* (fonctionnalité).
128			*/
129			protected function tearDown() {
130
131			// Récupère le statut
132			$status = $this->getStatus();
133			// Si l'option capture d'écran est activé et qu'il y a une erreur(error)
134			// ou un echec(failure)
135			if ($this->screenshotOnFailureAndError === true
136			&& ($status == PHPUnit_Runner_BaseTestRunner::STATUS_ERROR
137			\|\| $status == PHPUnit_Runner_BaseTestRunner::STATUS_FAILURE)) {
138			// Si c'est une erreur
139			if ($status == PHPUnit_Runner_BaseTestRunner::STATUS_ERROR) {
140			$startFilename = "error_";
141			}
142			// Si c'est un echec
143			if ($status == PHPUnit_Runner_BaseTestRunner::STATUS_FAILURE) {
144			$startFilename = "failure_";
145			}
146			// Nom de l'image
147			$filename = $startFilename.$this->getName()."_".date("Ymd_His").".png";
148			// Ajout de l'image
149			file_put_contents($this->screenshotPath.$filename,
150			$this->currentScreenshot());
151			}
152			}
153
154			/**
155			* Cette méthode permet de connecter l'utilisateur à l'application.
156			*/
157			protected function connect($login, $password) {
158			// On ouvre l'url openexemple
159			$this->url($this->url);
160			$this->timeouts()->implicitWait(2000);
161			// On saisit le login dans le champ login
162			$this->byId("login")->clear();
163			$this->byId("login")->value($login);
164			// On saisit le mot de passe dans le champ mot de passe
165			$this->byId("password")->clear();
166			$this->byId("password")->value($password);
167			// On clique sur le bouton de connexion
168			$this->byname("login.action.connect")->click();
169			}
170
171			/**
172			* Cette méthode permet de déconnecter l'utilisateur.
173			*/
174			protected function deconnect() {
175			// On clique sur le lien de déconnexion
176			$element = $this->bycssselector("a.actions-logout");
177			$element->click();
178			}
179
180			/**
181			* Cette méthode permet de connecter l'utilisateur à l'application et de
182			* vérifier que la connecion s'est bien déroulée.
183			*/
184			protected function login($login, $password) {
185			// On se connecte
186			$this->connect($login, $password);
187			// Allonge le temps d'attente lors de la recherche d'élément
188			$this->timeouts()->implicitWait(10000);
189			// On vérifie qu'il n'y a pas d'erreur sur l'élément affiché
190			$this->verifynoerrors();
191			// On vérifie qu'un message nous indique que la session est ouverte
192			$element = $this->bycssselector("div.message span.text");
193			$this->assertequals("Votre session est maintenant ouverte.", $element->text());
194			}
195
196			/**
197			* Cette méthode vérifier que la déconnexion s'est bien déroulée.
198			*/
199			protected function verifyDeconnect() {
200			// Réduit le temps d'attente lors de la recherche d'élément
201			$this->timeouts()->implicitWait(240);
202			// On vérifie qu'il n'y a pas d'erreur sur l'élément affiché
203			$this->verifynoerrors();
204			// On vérifie qu'un message nous indique que la session est terminée
205			$element = $this->bycssselector("div.message span.text");
206			$this->assertequals("Votre session est maintenant terminée.", $element->text());
207			// On vérifie que le lien de déconnexion n'est pas présent
208			try {
209			$el = $this->bycssselector("a.actions-logout");
210			$this->fail("The element shouldn't exist.");
211			} catch (RuntimeException $e) {}
212			//Ferme la fenêtre
213			$this->closeWindow();
214			}
215
216			/**
217			* Cette méthode permet de déconnecter l'utilisateur et de vérifier que la
218			* déconnexion s'est bien déroulée.
219			*/
220			protected function logout() {
221			// On se déconnecte
222			$this->deconnect();
223			// On vérifie que la déconnexion s'est bien déroulée
224			$this->verifyDeconnect();
225			}
226
227			/**
228			* Cette méthode permet de fair un assert sur la NON présence d'un message
229			* indiquant une erreur de base de données ou une notice PHP.
230			* XXX Remplacer les tests par des expressions régulières pour améliorer
231			* les performances et être plus exhaustif
232			*/
233			public function verifynoerrors() {
234			// On récupère le contenu du rendu de la page
235			$source = $this->source();
236			// On vérifie la présence du message d'erreur de base de données
237			try {
238			$this->assertNotContains("Erreur de base de données. Contactez votre administrateur.", $source);
239			$this->assertNotContains("Erreur de base de donnees. Contactez votre administrateur.", $source);
240			} catch (PHPUnit_Framework_AssertionFailedError $e) {
241			$this->fail("Failed asserting that the source does not contain \"Erreur de base de données\".");
242			}
243			// On vérifie la présence d'une erreur fatale PHP
244			try {
245			$this->assertNotContains("Fatal error:", $source);
246			} catch (PHPUnit_Framework_AssertionFailedError $e) {
247			$this->fail("Failed asserting that the source does not contain \"PHP Fatal error:\".");
248			}
249			// On vérifie la présence d'une erreur fatale PHP
250			try {
251			$this->assertNotContains("<b>Fatal error</b>", $source);
252			} catch (PHPUnit_Framework_AssertionFailedError $e) {
253			$this->fail("Failed asserting that the source does not contain \"PHP Fatal error:\".");
254			}
255			// On vérifie la présence d'une erreur de syntaxe PHP
256			try {
257			$this->assertNotContains("Parse error:", $source);
258			} catch (PHPUnit_Framework_AssertionFailedError $e) {
259			$this->fail("Failed asserting that the source does not contain \"PHP Parse error:\".");
260			}
261			// On vérifie la présence d'une erreur de syntaxe PHP
262			try {
263			$this->assertNotContains("<b>Parse error</b>", $source);
264			} catch (PHPUnit_Framework_AssertionFailedError $e) {
265			$this->fail("Failed asserting that the source does not contain \"PHP Parse error:\".");
266			}
267			// On vérifie la présence d'une notice PHP
268			try {
269			$this->assertNotContains("Notice:", $source);
270			} catch (PHPUnit_Framework_AssertionFailedError $e) {
271			$this->fail("Failed asserting that the source does not contain \"PHP Notice:\".");
272			}
273			// On vérifie la présence d'une notice PHP
274			try {
275			$this->assertNotContains("<b>Notice</b>", $source);
276			} catch (PHPUnit_Framework_AssertionFailedError $e) {
277			$this->fail("Failed asserting that the source does not contain \"PHP Notice:\".");
278			}
279			}
280
281			/**
282			* Cette fonction permet de cliquer sur le menu si celui-ci n'est pas déjà
283			* ouvert de base en fonction de l'utilisateur
284			* @param string $menu Titre du menu
285			* @param array $utilisateur Login et mdp de l'utilisateur
286			*/
287			public function openMenu($menu, $utilisateur) {
288			// Si le menu est 'Guichet Unique'
289			if ($menu == 'Guichet Unique') {
290			// Vérifie les utilisateurs
291			if ($utilisateur["login"] != "guichet") {
292			// Clique sur le menu
293			$this->byLinkText($menu)->click();
294			$this->verifyNoErrors();
295			}
296			}
297			// Si le menu est 'Instruction'
298			if ($menu == 'Instruction') {
299			// Vérifie les utilisateurs
300			if ($utilisateur["login"] != "instr"
301			&& $utilisateur["login"] != "visudadi"
302			&& $utilisateur["login"] != "divi"
303			&& $utilisateur["login"] != "chef"
304			&& $utilisateur["login"] != "adminfonct") {
305			// Clique sur le menu
306			$this->byLinkText($menu)->click();
307			$this->verifyNoErrors();
308			}
309			}
310			// Si le menu est 'Suivi'
311			if ($menu == 'Suivi') {
312			// Vérifie les utilisateurs
313			if ($utilisateur["login"] != "suivi") {
314			// Clique sur le menu
315			$this->byLinkText($menu)->click();
316			$this->verifyNoErrors();
317			}
318			}
319			// Si le menu est 'Demandes D'avis'
320			if ($menu == "Demandes D'avis") {
321			// Vérifie les utilisateurs
322			if ($utilisateur["login"] != "consu"
323			&& $utilisateur["login"] != "consu1"
324			&& $utilisateur["login"] != "consu2") {
325			// Clique sur le menu
326			$this->byLinkText($menu)->click();
327			$this->verifyNoErrors();
328			}
329			}
330			}
331
332			/**
333			* COPIE DE LA FONCTION mois_date() DE LA CLASSE utils
334			*/
335			/**
336			* Calcule uen date avec l'ajout ou le soustrait de mois.
337			* @param date $date Date de base
338			* @param integer $delay Délais à ajouter (en mois)
339			* @param string $operator Opérateur pour le calcul ("-" ou "+")
340			*
341			* @return date Date calculée
342			*/
343			function mois_date($date, $delay, $operator = "+") {
344
345			// Découpage de la date
346			$temp = explode("-", $date);
347			$day = (int) $temp[2];
348			$month = (int) $temp[1];
349			$year = (int) $temp[0];
350
351			// Si c'est une addition
352			if ($operator == '+') {
353			// Année à ajouter
354			$year += floor($delay / 12);
355			// Mois restant
356			$nb_month = ($delay % 12);
357			// S'il y a des mois restant
358			if ($nb_month != 0) {
359			// Ajout des mois restant
360			$month += $nb_month;
361			// Si ça dépasse le mois 12 (décembre)
362			if ($month > 12) {
363			// Soustrait 12 au mois
364			$month -= 12;
365			// Ajoute 1 à l'année
366			$year += 1;
367			}
368			}
369			}
370
371			// Si c'est une soustraction
372			if ($operator == "-") {
373			// Année à soustraire
374			$year -= floor($delay / 12);
375			// Mois restant
376			$nb_month = ($delay % 12);
377			// S'il y a des mois restant
378			if ($nb_month != 0) {
379			// Soustrait le délais
380			$month -= $nb_month;
381			// Si ça dépasse le mois 1 (janvier)
382			if ($month < 1) {
383			// Soustrait 12 au mois
384			$month += 12;
385			// Ajoute 1 à l'année
386			$year -= 1;
387			}
388			}
389			}
390
391			// Calcul du nombre de jours dans le mois sélectionné
392			switch($month) {
393			// Mois de février
394			case "2":
395			if ($year % 4 == 0 && $year % 100 != 0 \|\| $year % 400 == 0) {
396			$day_max = 29;
397			} else {
398			$day_max = 28;
399			}
400			break;
401			// Mois d'avril, juin, septembre et novembre
402			case "4":
403			case "6":
404			case "9":
405			case "11":
406			$day_max = 30;
407			break;
408			// Mois de janvier, mars, mai, juillet, août, octobre et décembre
409			default:
410			$day_max = 31;
411			}
412
413			// Si le jour est supérieur au jour maximum du mois
414			if ($day > $day_max) {
415			// Le jour devient le jour maximum
416			$day = $day_max;
417			}
418
419			// Compléte le mois et le jour par un 0 à gauche si c'est un chiffre
420			$month = str_pad($month, 2, "0", STR_PAD_LEFT);
421			$day = str_pad($day, 2, "0", STR_PAD_LEFT);
422
423			// Retourne la date calculée
424			return $year."-".$month."-".$day ;
425			}
426
427			}
428
429			?>