3.14.x/tests/base.php

<?php
/**
 * Ce script contient la déclaration des classes BaseTesCase et Base2TestCase.
 *
 * @package openfoncier
 * @version SVN : $Id$
 */

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/");
        // 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$
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	// Instancie la timezone
121	date_default_timezone_set('Europe/Paris');
122	}
123
124	/**
125	* Cette méthode est appelée après le lancement de chaque test
126	* (fonctionnalité).
127	*/
128	protected function tearDown() {
129
130	// Récupère le statut
131	$status = $this->getStatus();
132	// Si l'option capture d'écran est activé et qu'il y a une erreur(error)
133	// ou un echec(failure)
134	if ($this->screenshotOnFailureAndError === true
135	&& ($status == PHPUnit_Runner_BaseTestRunner::STATUS_ERROR
136	\|\| $status == PHPUnit_Runner_BaseTestRunner::STATUS_FAILURE)) {
137	// Si c'est une erreur
138	if ($status == PHPUnit_Runner_BaseTestRunner::STATUS_ERROR) {
139	$startFilename = "error_";
140	}
141	// Si c'est un echec
142	if ($status == PHPUnit_Runner_BaseTestRunner::STATUS_FAILURE) {
143	$startFilename = "failure_";
144	}
145	// Nom de l'image
146	$filename = $startFilename.$this->getName()."_".date("Ymd_His").".png";
147	// Ajout de l'image
148	file_put_contents($this->screenshotPath.$filename,
149	$this->currentScreenshot());
150	}
151	}
152
153	/**
154	* Cette méthode permet de connecter l'utilisateur à l'application.
155	*/
156	protected function connect($login, $password) {
157	// On ouvre l'url openexemple
158	$this->url($this->url);
159	$this->timeouts()->implicitWait(2000);
160	// On saisit le login dans le champ login
161	$this->byId("login")->clear();
162	$this->byId("login")->value($login);
163	// On saisit le mot de passe dans le champ mot de passe
164	$this->byId("password")->clear();
165	$this->byId("password")->value($password);
166	// On clique sur le bouton de connexion
167	$this->byname("login.action.connect")->click();
168	}
169
170	/**
171	* Cette méthode permet de déconnecter l'utilisateur.
172	*/
173	protected function deconnect() {
174	// On clique sur le lien de déconnexion
175	$element = $this->bycssselector("a.actions-logout");
176	$element->click();
177	}
178
179	/**
180	* Cette méthode permet de connecter l'utilisateur à l'application et de
181	* vérifier que la connecion s'est bien déroulée.
182	*/
183	protected function login($login, $password) {
184	// On se connecte
185	$this->connect($login, $password);
186	// Allonge le temps d'attente lors de la recherche d'élément
187	$this->timeouts()->implicitWait(10000);
188	// On vérifie qu'il n'y a pas d'erreur sur l'élément affiché
189	$this->verifynoerrors();
190	// On vérifie qu'un message nous indique que la session est ouverte
191	$element = $this->bycssselector("div.message span.text");
192	$this->assertequals("Votre session est maintenant ouverte.", $element->text());
193	}
194
195	/**
196	* Cette méthode vérifier que la déconnexion s'est bien déroulée.
197	*/
198	protected function verifyDeconnect() {
199	// Réduit le temps d'attente lors de la recherche d'élément
200	$this->timeouts()->implicitWait(240);
201	// On vérifie qu'il n'y a pas d'erreur sur l'élément affiché
202	$this->verifynoerrors();
203	// On vérifie qu'un message nous indique que la session est terminée
204	$element = $this->bycssselector("div.message span.text");
205	$this->assertequals("Votre session est maintenant terminée.", $element->text());
206	// On vérifie que le lien de déconnexion n'est pas présent
207	try {
208	$el = $this->bycssselector("a.actions-logout");
209	$this->fail("The element shouldn't exist.");
210	} catch (RuntimeException $e) {}
211	//Ferme la fenêtre
212	$this->closeWindow();
213	}
214
215	/**
216	* Cette méthode permet de déconnecter l'utilisateur et de vérifier que la
217	* déconnexion s'est bien déroulée.
218	*/
219	protected function logout() {
220	// On se déconnecte
221	$this->deconnect();
222	// On vérifie que la déconnexion s'est bien déroulée
223	$this->verifyDeconnect();
224	}
225
226	/**
227	* Cette méthode permet de fair un assert sur la NON présence d'un message
228	* indiquant une erreur de base de données ou une notice PHP.
229	* XXX Remplacer les tests par des expressions régulières pour améliorer
230	* les performances et être plus exhaustif
231	*/
232	public function verifynoerrors() {
233	// On récupère le contenu du rendu de la page
234	$source = $this->source();
235	// On vérifie la présence du message d'erreur de base de données
236	try {
237	$this->assertNotContains("Erreur de base de données. Contactez votre administrateur.", $source);
238	$this->assertNotContains("Erreur de base de donnees. Contactez votre administrateur.", $source);
239	} catch (PHPUnit_Framework_AssertionFailedError $e) {
240	$this->fail("Failed asserting that the source does not contain \"Erreur de base de données\".");
241	}
242	// On vérifie la présence d'une erreur fatale PHP
243	try {
244	$this->assertNotContains("Fatal error:", $source);
245	} catch (PHPUnit_Framework_AssertionFailedError $e) {
246	$this->fail("Failed asserting that the source does not contain \"PHP Fatal error:\".");
247	}
248	// On vérifie la présence d'une erreur fatale PHP
249	try {
250	$this->assertNotContains("<b>Fatal error</b>", $source);
251	} catch (PHPUnit_Framework_AssertionFailedError $e) {
252	$this->fail("Failed asserting that the source does not contain \"PHP Fatal error:\".");
253	}
254	// On vérifie la présence d'une erreur de syntaxe PHP
255	try {
256	$this->assertNotContains("Parse error:", $source);
257	} catch (PHPUnit_Framework_AssertionFailedError $e) {
258	$this->fail("Failed asserting that the source does not contain \"PHP Parse error:\".");
259	}
260	// On vérifie la présence d'une erreur de syntaxe PHP
261	try {
262	$this->assertNotContains("<b>Parse error</b>", $source);
263	} catch (PHPUnit_Framework_AssertionFailedError $e) {
264	$this->fail("Failed asserting that the source does not contain \"PHP Parse error:\".");
265	}
266	// On vérifie la présence d'une notice PHP
267	try {
268	$this->assertNotContains("Notice:", $source);
269	} catch (PHPUnit_Framework_AssertionFailedError $e) {
270	$this->fail("Failed asserting that the source does not contain \"PHP Notice:\".");
271	}
272	// On vérifie la présence d'une notice PHP
273	try {
274	$this->assertNotContains("<b>Notice</b>", $source);
275	} catch (PHPUnit_Framework_AssertionFailedError $e) {
276	$this->fail("Failed asserting that the source does not contain \"PHP Notice:\".");
277	}
278	}
279
280	/**
281	* Cette fonction permet de cliquer sur le menu si celui-ci n'est pas déjà
282	* ouvert de base en fonction de l'utilisateur
283	* @param string $menu Titre du menu
284	* @param array $utilisateur Login et mdp de l'utilisateur
285	*/
286	public function openMenu($menu, $utilisateur) {
287	// Si le menu est 'Guichet Unique'
288	if ($menu == 'Guichet Unique') {
289	// Vérifie les utilisateurs
290	if ($utilisateur["login"] != "guichet") {
291	// Clique sur le menu
292	$this->byLinkText($menu)->click();
293	$this->verifyNoErrors();
294	}
295	}
296	// Si le menu est 'Instruction'
297	if ($menu == 'Instruction') {
298	// Vérifie les utilisateurs
299	if ($utilisateur["login"] != "instr"
300	&& $utilisateur["login"] != "visudadi"
301	&& $utilisateur["login"] != "divi"
302	&& $utilisateur["login"] != "chef"
303	&& $utilisateur["login"] != "adminfonct") {
304	// Clique sur le menu
305	$this->byLinkText($menu)->click();
306	$this->verifyNoErrors();
307	}
308	}
309	// Si le menu est 'Suivi'
310	if ($menu == 'Suivi') {
311	// Vérifie les utilisateurs
312	if ($utilisateur["login"] != "suivi") {
313	// Clique sur le menu
314	$this->byLinkText($menu)->click();
315	$this->verifyNoErrors();
316	}
317	}
318	// Si le menu est 'Demandes D'avis'
319	if ($menu == "Demandes D'avis") {
320	// Vérifie les utilisateurs
321	if ($utilisateur["login"] != "consu"
322	&& $utilisateur["login"] != "consu1"
323	&& $utilisateur["login"] != "consu2") {
324	// Clique sur le menu
325	$this->byLinkText($menu)->click();
326	$this->verifyNoErrors();
327	}
328	}
329	}
330
331	/**
332	* COPIE DE LA FONCTION mois_date() DE LA CLASSE utils
333	*/
334	/**
335	* Calcule uen date avec l'ajout ou le soustrait de mois.
336	* @param date $date Date de base
337	* @param integer $delay Délais à ajouter (en mois)
338	* @param string $operator Opérateur pour le calcul ("-" ou "+")
339	*
340	* @return date Date calculée
341	*/
342	function mois_date($date, $delay, $operator = "+") {
343
344	// Découpage de la date
345	$temp = explode("-", $date);
346	$day = (int) $temp[2];
347	$month = (int) $temp[1];
348	$year = (int) $temp[0];
349
350	// Si c'est une addition
351	if ($operator == '+') {
352	// Année à ajouter
353	$year += floor($delay / 12);
354	// Mois restant
355	$nb_month = ($delay % 12);
356	// S'il y a des mois restant
357	if ($nb_month != 0) {
358	// Ajout des mois restant
359	$month += $nb_month;
360	// Si ça dépasse le mois 12 (décembre)
361	if ($month > 12) {
362	// Soustrait 12 au mois
363	$month -= 12;
364	// Ajoute 1 à l'année
365	$year += 1;
366	}
367	}
368	}
369
370	// Si c'est une soustraction
371	if ($operator == "-") {
372	// Année à soustraire
373	$year -= floor($delay / 12);
374	// Mois restant
375	$nb_month = ($delay % 12);
376	// S'il y a des mois restant
377	if ($nb_month != 0) {
378	// Soustrait le délais
379	$month -= $nb_month;
380	// Si ça dépasse le mois 1 (janvier)
381	if ($month < 1) {
382	// Soustrait 12 au mois
383	$month += 12;
384	// Ajoute 1 à l'année
385	$year -= 1;
386	}
387	}
388	}
389
390	// Calcul du nombre de jours dans le mois sélectionné
391	switch($month) {
392	// Mois de février
393	case "2":
394	if ($year % 4 == 0 && $year % 100 != 0 \|\| $year % 400 == 0) {
395	$day_max = 29;
396	} else {
397	$day_max = 28;
398	}
399	break;
400	// Mois d'avril, juin, septembre et novembre
401	case "4":
402	case "6":
403	case "9":
404	case "11":
405	$day_max = 30;
406	break;
407	// Mois de janvier, mars, mai, juillet, août, octobre et décembre
408	default:
409	$day_max = 31;
410	}
411
412	// Si le jour est supérieur au jour maximum du mois
413	if ($day > $day_max) {
414	// Le jour devient le jour maximum
415	$day = $day_max;
416	}
417
418	// Compléte le mois et le jour par un 0 à gauche si c'est un chiffre
419	$month = str_pad($month, 2, "0", STR_PAD_LEFT);
420	$day = str_pad($day, 2, "0", STR_PAD_LEFT);
421
422	// Retourne la date calculée
423	return $year."-".$month."-".$day ;
424	}
425
426	}
427
428	?>