3.28.x/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	<?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	?>