trunk/tests/testImportSpecific_common.php

<?php
/**
 * Ce script contient la définition de la classe 'ImportSpecificCommon'.
 *
 * @package openads
 * @version SVN : $Id$
 */

require_once "../obj/utils.class.php";
require_once "../obj/import_specific.class.php";

/**
 * Tests unitaires des contrôles et manipulations des données récupérées
 * depuis le fichier CSV; dans l'import spécifique de CSV
 */
abstract class ImportSpecificCommon extends PHPUnit\Framework\TestCase {

    /**
     * Méthode lancée en début de traitement
     */
    public function common_setUp() {
        date_default_timezone_set('Europe/Paris');
        echo ' = '.get_called_class().'.'.str_replace('test_', '', $this->getName())."\r\n";
        $this->init_data_test();
        // Instance de la classe Utils
        require_once "../obj/utils.class.php";
        $_SESSION['collectivite'] = 1;
        $_SESSION['login'] = "admin";
        $_SERVER['REQUEST_URI'] = "";
        $f = new utils("nohtml");
        $GLOBALS['f'] = $f;
        // Instancie la classe à tester
        $this->inst = new import_specific();
    }

    /**
     * Méthode lancée en fin de traitement
     */
    public function common_tearDown() {
    }

    /**
     * Méthode étant appelée lors du fail d'un test.
     *
     * @param $e Exception remontée lors du test
     * @return void
     */
    public function common_onNotSuccessfulTest(Throwable $e) {
        echo 'Line '.$e->getLine().' : '.$e->getMessage()."\r\n";
        parent::onNotSuccessfulTest($e);
    }

    /**
     * Jeu de données : deux tableaux pour chaque test :
     * colonnes et valeurs.
     *
     * Les colonnes sont commentées par un exemple du CSV comme suit :
     * COL (débute à 0) - Libellé header
     */
    function init_data_test() {

        // check_required()
        $this->required_column = array(
            // COL 0 - Type
            "type" => array(
                "require" => true,
                "header" => "Type",
            ),
            // COL 1 - Numéro
            "numero" => array(
                "require" => true,
                "header" => "Numero",
            ),
            // COL 5 - INSEE
            "insee" => array(
                "require" => false,
                "header" => "INSEE",
            ),
        );
        $this->required_row_data = array(
            "type" => "",
            "numero" => "10",
            "insee" => "",
        );

        // check_type()
        $this->type_column = array(
            // COL 38 - Date envoi demande de pièces
            0 => array(
                "type" => "date",
                "header" => "Date envoi demande de pieces",
            ),
            1 => array(
                "type" => "date",
                "header" => "Date envoi demande de pieces",
            ),
            // COL 8 - Projet
            2 => array(
                "type" => "string",
                "header" => "Projet",
            ),
            3 => array(
                "type" => "string",
                "header" => "Projet",
            ),
            // COL 10 - Nb logements
            4 => array(
                "type" => "integer",
                "header" => "Nb logements",
            ),
            5 => array(
                "type" => "integer",
                "header" => "Nb logements",
            ),
            6 => array(
                "type" => "integer",
                "header" => "Nb logements",
            ),
            // COL 11 - Surface terrain
            7 => array(
                "type" => "float",
                "header" => "Surface terrain",
            ),
            8 => array(
                "type" => "float",
                "header" => "Surface terrain",
            ),
            // COL 24 - Lotissement
            9 => array(
                "type" => "boolean",
                "header" => "Lotissement",
            ),
            10 => array(
                "type" => "boolean",
                "header" => "Lotissement",
            ),
        );
        $this->type_row_data = array(
            0 => "10/10/2015",
            1 => "101/5/2015",
            2 => "chaîne valide",
            4 => "50",
            5 => "50a",
            6 => "50,5",
            7 => "50,5",
            8 => "50a",
            9 => "Oui",
            10 => "true",
        );

        $this->type_return_expected = array(
            // Cas 1 : date valide
            0 =>true,
            // Cas 2 : date invalide
            1 =>false,
            // Cas 3 : chaîne de caractères valide
            2 =>true,
            // Cas 5 : nombre entier valide
            4 =>true,
            // Cas 6 : nombre entier invalide
            5 =>false,
            // Cas 7 : nombre entier invalide
            6 =>false,
            // Cas 8 : nombre décimal valide
            7 =>true,
            // Cas 9 : nombre décimal invalide
            8 =>false,
            // Cas 10 : booléen valide
            9 =>true,
            // Cas 11 : booléen invalide
            10 =>false
        );

        // check_foreign_key()
        $this->fk_column = array(
            // COL 0 - Type
            0 => array(
                "foreign_key" => array(
                    "sql"=>"SELECT dossier_autorisation_type_detaille FROM openads.dossier_autorisation_type_detaille WHERE code ='<value>'",
                    "table" => "dossier_autorisation_type_detaille",
                    "field" => "code",
                ),
                "header" => "Type",
            ),
            1 => array(
                "foreign_key" => array(
                    "sql"=>"SELECT dossier_autorisation_type_detaille FROM openads.dossier_autorisation_type_detaille WHERE code ='<value>'",
                    "table" => "dossier_autorisation_type_detaille",
                    "field" => "code",
                ),
                "header" => "Type",
            ),
        );
        $this->fk_row_data = array(
            0 => "PCI",
            1 => "lambda",
        );

        // set_linked_value()
        $this->linked_values_column = array(
            // COL 0 - Type
            0 => array(
                "link" => array(
                    "PC MI" => "PI",
                ),
                "header" => "Type",
            ),
            1 => array(
                "link" => array(
                    "PC MI" => "PI",
                ),
                "header" => "Type",
            ),
        );
        $this->linked_values_row_data = array(
            0 => "PCI",
            1 => "PC MI",
        );
    }

    /**
     * Teste la méthode check_required() de la classe import_specific.
     * Est-ce qu'il y a une valeur si champ obligatoire ?
     * 
     * @param   $key   [integer]  colonne du fichier CSV
     * @param   $value [string]   valeur à tester
     * @return         [string]   message d'erreur ou chaîne vide si succès
     */
    public function test_check_required() {
        // Message d'erreur
        $error = _("La colonne %s est obligatoire");
        // Utilisation du jeu de données
        $this->inst->column = $this->required_column;
        $this->inst->line = $this->required_row_data;
        // Cas 1 : champ requis vide
        $ret = $this->inst->check_required("type");
        $this->assertEquals($ret, false);
        // Cas 2 : champ requis renseigné
        $ret = $this->inst->check_required("numero");
        $this->assertEquals($ret, true);
        // Cas 3 : champ non requis vide
        $ret = $this->inst->check_required("insee");
        $this->assertEquals($ret, true);
    }

    /**
     * Teste la méthode check_type() de la classe import_specific.
     * Est-ce que la valeur est valide pour le type attendu ?
     *
     * @param   $key   [integer]  colonne du fichier CSV
     * @param   $value [string]   valeur à tester
     * @return         [string]   message d'erreur ou chaîne vide si succès
     */
    public function test_check_type() {

        // Utilisation du jeu de données
        $this->inst->column = $this->type_column;
        $this->inst->line = $this->type_row_data;
        // Définition des résultats attendus
        $this->type_return_expected;
        // Pour chaque colonne testée
        foreach ($this->inst->line as $key => $value) {
            // Vérification du retour de la méthode
            $this->assertEquals(
                $this->inst->check_type($key),
                $this->type_return_expected[$key]
            );
        }
    }

    /**
     * Teste la méthode get_foreign_key_id() de la classe import_specific.
     * Est-ce que la clé étrangère existe ?
     *
     * @param   $key   [integer]  colonne du fichier CSV
     * @return         [string]   message d'erreur ou chaîne vide si succès
     */
    public function test_get_foreign_key_id() {

        // Utilisation du jeu de données
        $this->inst->column = $this->fk_column;
        $this->inst->line = $this->fk_row_data;
        // Cas 1 : clé étrangère valide
        $ret = $this->inst->get_foreign_key_id(0);
        $this->assertEquals($ret, true);
        // Cas 2 : clé étrangère invalide
        $ret = $this->inst->get_foreign_key_id(1);
        $this->assertEquals($ret, false);
    }

    /**
     * Teste la méthode explode_address() de la classe import_specific.
     * Doit retourner un tableau d'éléments composant l'adresse fournie.
     *
     * @param   $value [string]  adresse complète
     * @return         [array]   tableau (numéro, rue, CP, ville, ...)
     */
    public function test_explode_address() {
        // Cas 1 : adresse 'normale' à transformer
        $adresse_complete1 = "27 bis Avenue Jules Cantini 13008 Marseille France";
        // Récupération de la transformation
        $adresse_triee1 = $this->inst->explode_address($adresse_complete1);
        // Vérification des éléments
        $this->assertEquals($adresse_triee1['numero'], '27');
        $this->assertEquals($adresse_triee1['voie'], 'bis Avenue Jules Cantini');
        $this->assertEquals($adresse_triee1['complement1'], '');
        $this->assertEquals($adresse_triee1['complement2'], '');
        $this->assertEquals($adresse_triee1['cp'], '13008');
        $this->assertEquals($adresse_triee1['ville'], 'Marseille');
        // Cas 2 : adresse longue (libellée voie supérieur à 30 caractères)
        $adresse_complete2 = "27 bis Avenue Jules Cantini Boulevard de la Blancarde 06001 Nice";
        // Récupération de la transformation
        $adresse_triee2 = $this->inst->explode_address($adresse_complete2);
        // Vérification des éléments
        $this->assertEquals($adresse_triee2['numero'], '27');
        $this->assertEquals($adresse_triee2['voie'], 'bis Avenue Jules Cantini');
        $this->assertEquals($adresse_triee2['complement1'], 'Boulevard de la Blancarde');
        $this->assertEquals($adresse_triee2['complement2'], '');
        $this->assertEquals($adresse_triee2['cp'], '06001');
        $this->assertEquals($adresse_triee2['ville'], 'Nice');
        // Cas 3 : adresse très longue (libellée voie supérieur à 60 caractères)
        // Numéro composé suivi d'une virgule
        $adresse_complete3 = "11-12, Place des grands hommes Boulevard du Panthéon Route de Paris 13380 Plan de Cuques";
        // Récupération de la transformation
        $adresse_triee3 = $this->inst->explode_address($adresse_complete3);
        // Vérification des éléments
        $this->assertEquals($adresse_triee3['numero'], '11-12');
        $this->assertEquals($adresse_triee3['voie'], 'Place des grands hommes');
        $this->assertEquals($adresse_triee3['complement1'], 'Boulevard du Panthéon Route');
        $this->assertEquals($adresse_triee3['complement2'], 'de Paris');
        $this->assertEquals($adresse_triee3['cp'], '13380');
        $this->assertEquals($adresse_triee3['ville'], 'Plan de Cuques');
    }

    /**
     * Teste la méthode set_linked_value() qui subsitue les valeurs du CSV
     * par le paramétrage.
     *
     * @param   $key   [integer]  colonne du fichier CSV
     * @return  [void]
     */
    function test_set_linked_value(){
        // Utilisation du jeu de données
        $this->inst->column = $this->linked_values_column;
        $this->inst->line = $this->linked_values_row_data;
        // Cas 1 : aucune correspondance
        // PCI reste PCI
        $this->inst->set_linked_value(0);
        $this->assertEquals($this->inst->line[0], "PCI");
        // Cas 2 : existance d'une correspondance
        // PC MI devient PI
        $this->inst->set_linked_value(1);
        $this->assertEquals($this->inst->line[1], "PI");
    }
}
1	fmichon	9227	<?php
2			/**
3			* Ce script contient la définition de la classe 'ImportSpecificCommon'.
4			*
5			* @package openads
6			* @version SVN : $Id$
7			*/
8
9			require_once "../obj/utils.class.php";
10			require_once "../obj/import_specific.class.php";
11
12			/**
13			* Tests unitaires des contrôles et manipulations des données récupérées
14			* depuis le fichier CSV; dans l'import spécifique de CSV
15			*/
16			abstract class ImportSpecificCommon extends PHPUnit\Framework\TestCase {
17
18			/**
19			* Méthode lancée en début de traitement
20			*/
21			public function common_setUp() {
22			date_default_timezone_set('Europe/Paris');
23			echo ' = '.get_called_class().'.'.str_replace('test_', '', $this->getName())."\r\n";
24			$this->init_data_test();
25			// Instance de la classe Utils
26			require_once "../obj/utils.class.php";
27			$_SESSION['collectivite'] = 1;
28			$_SESSION['login'] = "admin";
29			$_SERVER['REQUEST_URI'] = "";
30			$f = new utils("nohtml");
31			$GLOBALS['f'] = $f;
32			// Instancie la classe à tester
33			$this->inst = new import_specific();
34			}
35
36			/**
37			* Méthode lancée en fin de traitement
38			*/
39			public function common_tearDown() {
40			}
41
42			/**
43			* Méthode étant appelée lors du fail d'un test.
44			*
45			* @param $e Exception remontée lors du test
46			* @return void
47			*/
48			public function common_onNotSuccessfulTest(Throwable $e) {
49			echo 'Line '.$e->getLine().' : '.$e->getMessage()."\r\n";
50			parent::onNotSuccessfulTest($e);
51			}
52
53			/**
54			* Jeu de données : deux tableaux pour chaque test :
55			* colonnes et valeurs.
56			*
57			* Les colonnes sont commentées par un exemple du CSV comme suit :
58			* COL (débute à 0) - Libellé header
59			*/
60			function init_data_test() {
61
62			// check_required()
63			$this->required_column = array(
64			// COL 0 - Type
65			"type" => array(
66			"require" => true,
67			"header" => "Type",
68			),
69			// COL 1 - Numéro
70			"numero" => array(
71			"require" => true,
72			"header" => "Numero",
73			),
74			// COL 5 - INSEE
75			"insee" => array(
76			"require" => false,
77			"header" => "INSEE",
78			),
79			);
80			$this->required_row_data = array(
81			"type" => "",
82			"numero" => "10",
83			"insee" => "",
84			);
85
86			// check_type()
87			$this->type_column = array(
88			// COL 38 - Date envoi demande de pièces
89			0 => array(
90			"type" => "date",
91			"header" => "Date envoi demande de pieces",
92			),
93			1 => array(
94			"type" => "date",
95			"header" => "Date envoi demande de pieces",
96			),
97			// COL 8 - Projet
98			2 => array(
99			"type" => "string",
100			"header" => "Projet",
101			),
102			3 => array(
103			"type" => "string",
104			"header" => "Projet",
105			),
106			// COL 10 - Nb logements
107			4 => array(
108			"type" => "integer",
109			"header" => "Nb logements",
110			),
111			5 => array(
112			"type" => "integer",
113			"header" => "Nb logements",
114			),
115			6 => array(
116			"type" => "integer",
117			"header" => "Nb logements",
118			),
119			// COL 11 - Surface terrain
120			7 => array(
121			"type" => "float",
122			"header" => "Surface terrain",
123			),
124			8 => array(
125			"type" => "float",
126			"header" => "Surface terrain",
127			),
128			// COL 24 - Lotissement
129			9 => array(
130			"type" => "boolean",
131			"header" => "Lotissement",
132			),
133			10 => array(
134			"type" => "boolean",
135			"header" => "Lotissement",
136			),
137			);
138			$this->type_row_data = array(
139			0 => "10/10/2015",
140			1 => "101/5/2015",
141			2 => "chaîne valide",
142			4 => "50",
143			5 => "50a",
144			6 => "50,5",
145			7 => "50,5",
146			8 => "50a",
147			9 => "Oui",
148			10 => "true",
149			);
150
151			$this->type_return_expected = array(
152			// Cas 1 : date valide
153			0 =>true,
154			// Cas 2 : date invalide
155			1 =>false,
156			// Cas 3 : chaîne de caractères valide
157			2 =>true,
158			// Cas 5 : nombre entier valide
159			4 =>true,
160			// Cas 6 : nombre entier invalide
161			5 =>false,
162			// Cas 7 : nombre entier invalide
163			6 =>false,
164			// Cas 8 : nombre décimal valide
165			7 =>true,
166			// Cas 9 : nombre décimal invalide
167			8 =>false,
168			// Cas 10 : booléen valide
169			9 =>true,
170			// Cas 11 : booléen invalide
171			10 =>false
172			);
173
174			// check_foreign_key()
175			$this->fk_column = array(
176			// COL 0 - Type
177			0 => array(
178			"foreign_key" => array(
179			"sql"=>"SELECT dossier_autorisation_type_detaille FROM openads.dossier_autorisation_type_detaille WHERE code ='<value>'",
180			"table" => "dossier_autorisation_type_detaille",
181			"field" => "code",
182			),
183			"header" => "Type",
184			),
185			1 => array(
186			"foreign_key" => array(
187			"sql"=>"SELECT dossier_autorisation_type_detaille FROM openads.dossier_autorisation_type_detaille WHERE code ='<value>'",
188			"table" => "dossier_autorisation_type_detaille",
189			"field" => "code",
190			),
191			"header" => "Type",
192			),
193			);
194			$this->fk_row_data = array(
195			0 => "PCI",
196			1 => "lambda",
197			);
198
199			// set_linked_value()
200			$this->linked_values_column = array(
201			// COL 0 - Type
202			0 => array(
203			"link" => array(
204			"PC MI" => "PI",
205			),
206			"header" => "Type",
207			),
208			1 => array(
209			"link" => array(
210			"PC MI" => "PI",
211			),
212			"header" => "Type",
213			),
214			);
215			$this->linked_values_row_data = array(
216			0 => "PCI",
217			1 => "PC MI",
218			);
219			}
220
221			/**
222			* Teste la méthode check_required() de la classe import_specific.
223			* Est-ce qu'il y a une valeur si champ obligatoire ?
224			*
225			* @param $key [integer] colonne du fichier CSV
226			* @param $value [string] valeur à tester
227			* @return [string] message d'erreur ou chaîne vide si succès
228			*/
229			public function test_check_required() {
230			// Message d'erreur
231			$error = _("La colonne %s est obligatoire");
232			// Utilisation du jeu de données
233			$this->inst->column = $this->required_column;
234			$this->inst->line = $this->required_row_data;
235			// Cas 1 : champ requis vide
236			$ret = $this->inst->check_required("type");
237			$this->assertEquals($ret, false);
238			// Cas 2 : champ requis renseigné
239			$ret = $this->inst->check_required("numero");
240			$this->assertEquals($ret, true);
241			// Cas 3 : champ non requis vide
242			$ret = $this->inst->check_required("insee");
243			$this->assertEquals($ret, true);
244			}
245
246			/**
247			* Teste la méthode check_type() de la classe import_specific.
248			* Est-ce que la valeur est valide pour le type attendu ?
249			*
250			* @param $key [integer] colonne du fichier CSV
251			* @param $value [string] valeur à tester
252			* @return [string] message d'erreur ou chaîne vide si succès
253			*/
254			public function test_check_type() {
255
256			// Utilisation du jeu de données
257			$this->inst->column = $this->type_column;
258			$this->inst->line = $this->type_row_data;
259			// Définition des résultats attendus
260			$this->type_return_expected;
261			// Pour chaque colonne testée
262			foreach ($this->inst->line as $key => $value) {
263			// Vérification du retour de la méthode
264			$this->assertEquals(
265			$this->inst->check_type($key),
266			$this->type_return_expected[$key]
267			);
268			}
269			}
270
271			/**
272			* Teste la méthode get_foreign_key_id() de la classe import_specific.
273			* Est-ce que la clé étrangère existe ?
274			*
275			* @param $key [integer] colonne du fichier CSV
276			* @return [string] message d'erreur ou chaîne vide si succès
277			*/
278			public function test_get_foreign_key_id() {
279
280			// Utilisation du jeu de données
281			$this->inst->column = $this->fk_column;
282			$this->inst->line = $this->fk_row_data;
283			// Cas 1 : clé étrangère valide
284			$ret = $this->inst->get_foreign_key_id(0);
285			$this->assertEquals($ret, true);
286			// Cas 2 : clé étrangère invalide
287			$ret = $this->inst->get_foreign_key_id(1);
288			$this->assertEquals($ret, false);
289			}
290
291			/**
292			* Teste la méthode explode_address() de la classe import_specific.
293			* Doit retourner un tableau d'éléments composant l'adresse fournie.
294			*
295			* @param $value [string] adresse complète
296			* @return [array] tableau (numéro, rue, CP, ville, ...)
297			*/
298			public function test_explode_address() {
299			// Cas 1 : adresse 'normale' à transformer
300			$adresse_complete1 = "27 bis Avenue Jules Cantini 13008 Marseille France";
301			// Récupération de la transformation
302			$adresse_triee1 = $this->inst->explode_address($adresse_complete1);
303			// Vérification des éléments
304			$this->assertEquals($adresse_triee1['numero'], '27');
305			$this->assertEquals($adresse_triee1['voie'], 'bis Avenue Jules Cantini');
306			$this->assertEquals($adresse_triee1['complement1'], '');
307			$this->assertEquals($adresse_triee1['complement2'], '');
308			$this->assertEquals($adresse_triee1['cp'], '13008');
309			$this->assertEquals($adresse_triee1['ville'], 'Marseille');
310			// Cas 2 : adresse longue (libellée voie supérieur à 30 caractères)
311			$adresse_complete2 = "27 bis Avenue Jules Cantini Boulevard de la Blancarde 06001 Nice";
312			// Récupération de la transformation
313			$adresse_triee2 = $this->inst->explode_address($adresse_complete2);
314			// Vérification des éléments
315			$this->assertEquals($adresse_triee2['numero'], '27');
316			$this->assertEquals($adresse_triee2['voie'], 'bis Avenue Jules Cantini');
317			$this->assertEquals($adresse_triee2['complement1'], 'Boulevard de la Blancarde');
318			$this->assertEquals($adresse_triee2['complement2'], '');
319			$this->assertEquals($adresse_triee2['cp'], '06001');
320			$this->assertEquals($adresse_triee2['ville'], 'Nice');
321			// Cas 3 : adresse très longue (libellée voie supérieur à 60 caractères)
322			// Numéro composé suivi d'une virgule
323			$adresse_complete3 = "11-12, Place des grands hommes Boulevard du Panthéon Route de Paris 13380 Plan de Cuques";
324			// Récupération de la transformation
325			$adresse_triee3 = $this->inst->explode_address($adresse_complete3);
326			// Vérification des éléments
327			$this->assertEquals($adresse_triee3['numero'], '11-12');
328			$this->assertEquals($adresse_triee3['voie'], 'Place des grands hommes');
329			$this->assertEquals($adresse_triee3['complement1'], 'Boulevard du Panthéon Route');
330			$this->assertEquals($adresse_triee3['complement2'], 'de Paris');
331			$this->assertEquals($adresse_triee3['cp'], '13380');
332			$this->assertEquals($adresse_triee3['ville'], 'Plan de Cuques');
333			}
334
335			/**
336			* Teste la méthode set_linked_value() qui subsitue les valeurs du CSV
337			* par le paramétrage.
338			*
339			* @param $key [integer] colonne du fichier CSV
340			* @return [void]
341			*/
342			function test_set_linked_value(){
343			// Utilisation du jeu de données
344			$this->inst->column = $this->linked_values_column;
345			$this->inst->line = $this->linked_values_row_data;
346			// Cas 1 : aucune correspondance
347			// PCI reste PCI
348			$this->inst->set_linked_value(0);
349			$this->assertEquals($this->inst->line[0], "PCI");
350			// Cas 2 : existance d'une correspondance
351			// PC MI devient PI
352			$this->inst->set_linked_value(1);
353			$this->assertEquals($this->inst->line[1], "PI");
354			}
355			}