tests/Galette/Entity/tests/units/FieldsConfig.php

   1 <?php
   2
   3 /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
   4
   5 /**
   6  * FieldsConfig tests
   7  *
   8  * PHP version 5
   9  *
  10  * Copyright © 2013-2014 The Galette Team
  11  *
  12  * This file is part of Galette (http://galette.tuxfamily.org).
  13  *
  14  * Galette is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU General Public License as published by
  16  * the Free Software Foundation, either version 3 of the License, or
  17  * (at your option) any later version.
  18  *
  19  * Galette is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *  GNU General Public License for more details.
  23  *
  24  * You should have received a copy of the GNU General Public License
  25  * along with Galette. If not, see <http://www.gnu.org/licenses/>.
  26  *
  27  * @category  Entity
  28  * @package   GaletteTests
  29  *
  30  * @author    Johan Cwiklinski <johan@x-tnd.be>
  31  * @copyright 2016 The Galette Team
  32  * @license   http://www.gnu.org/licenses/gpl-3.0.html GPL License 3.0 or (at your option) any later version
  33  * @version   SVN: $Id$
  34  * @link      http://galette.tuxfamily.org
  35  * @since     2016-09-24
  36  */
  37
  38 namespace Galette\Entity\test\units;
  39
  40 use atoum;
  41
  42 /**
  43  * Preferences tests class
  44  *
  45  * @category  Entity
  46  * @name      FieldsConfig
  47  * @package   GaletteTests
  48  * @author    Johan Cwiklinski <johan@x-tnd.be>
  49  * @copyright 2016 The Galette Team
  50  * @license   http://www.gnu.org/licenses/gpl-3.0.html GPL License 3.0 or (at your option) any later version
  51  * @link      http://galette.tuxfamily.org
  52  * @since     2016-09-24
  53  */
  54 class FieldsConfig extends atoum
  55 {
  56     private $fields_config = null;
  57     private $zdb;
  58     private $members_fields;
  59     private $members_fields_cats;
  60
  61     /**
  62      * Set up tests
  63      *
  64      * @param string $testMethod Calling method
  65      *
  66      * @return void
  67      */
  68     public function beforeTestMethod($testMethod)
  69     {
  70         $this->zdb = new \Galette\Core\Db();
  71
  72         include_once GALETTE_ROOT . 'includes/fields_defs/members_fields.php';
  73         $this->members_fields = $members_fields;
  74         include_once GALETTE_ROOT . 'includes/fields_defs/members_fields_cats.php';
  75         $this->members_fields_cats = $members_fields_cats;
  76
  77         $this->fields_config = new \Galette\Entity\FieldsConfig(
  78             $this->zdb,
  79             \Galette\Entity\Adherent::TABLE,
  80             $this->members_fields,
  81             $this->members_fields_cats,
  82             true
  83         );
  84     }
  85
  86     /**
  87      * Test non required fields
  88      *
  89      * @return void
  90      */
  91     public function testNonRequired()
  92     {
  93         $nrequired = $this->fields_config->getNonRequired();
  94         $expected = [
  95             'id_adh',
  96             'date_echeance',
  97             'bool_display_info',
  98             'bool_exempt_adh',
  99             'bool_admin_adh',
 100             'activite_adh',
 101             'date_crea_adh',
 102             'date_modif_adh',
 103             'societe_adh',
 104             'id_statut',
 105             'pref_lang',
 106             'sexe_adh',
 107             'parent_id'
 108         ];
 109         $this->array($nrequired)->isIdenticalTo($expected);
 110     }
 111
 112     /**
 113      * Test FieldsConfig initialization
 114      *
 115      * @return void
 116      */
 117     public function testInstallInit()
 118     {
 119         $result = $this->fields_config->installInit(
 120             $this->zdb
 121         );
 122         $this->boolean($result)->isTrue();
 123
 124         //new object with values loaded from database to compare
 125         $fields_config = new \Galette\Entity\FieldsConfig(
 126             $this->zdb,
 127             \Galette\Entity\Adherent::TABLE,
 128             $this->members_fields,
 129             $this->members_fields_cats
 130         );
 131
 132         $categorized = $fields_config->getCategorizedFields();
 133         $this->countCategorizedFields($categorized);
 134
 135         $required = $fields_config->getRequired();
 136         $expected = [
 137             'nom_adh'       => 1,
 138             'login_adh'     => 1,
 139             'mdp_adh'       => 1,
 140             'adresse_adh'   => 1,
 141             'cp_adh'        => 1,
 142             'ville_adh'     => 1
 143         ];
 144         $this->array($required)->isEqualTo($expected);
 145
 146         $isrequired = $fields_config->isRequired('login_adh');
 147         $this->boolean($isrequired)->isTrue();
 148
 149         $isrequired = $fields_config->isRequired('info_adh');
 150         $this->boolean($isrequired)->isFalse();
 151
 152         $lists_config = new \Galette\Entity\ListsConfig(
 153             $this->zdb,
 154             \Galette\Entity\Adherent::TABLE,
 155             $this->members_fields,
 156             $this->members_fields_cats,
 157             true
 158         );
 159         $this->boolean($lists_config->load())->isTrue();
 160
 161         $visibles = $fields_config->getVisibilities();
 162         $this->array($visibles)
 163              ->hasSize(
 164                  count($categorized[\Galette\Entity\FieldsCategories::ADH_CATEGORY_IDENTITY]) +
 165                  count($categorized[\Galette\Entity\FieldsCategories::ADH_CATEGORY_GALETTE]) +
 166                  count($categorized[\Galette\Entity\FieldsCategories::ADH_CATEGORY_CONTACT]) +
 167                  count($lists_config->getAclMapping())
 168              )
 169             ->integer['id_adh']->isIdenticalTo(0)
 170             ->integer['nom_adh']->isIdenticalTo(1);
 171     }
 172
 173     /**
 174      * Count categorized_fields
 175      *
 176      * @param array $categorized Categorized fields
 177      *
 178      * @return void
 179      */
 180     private function countCategorizedFields($categorized)
 181     {
 182         $this->array($categorized)
 183             ->hasSize(3);
 184         $this->array($categorized[\Galette\Entity\FieldsCategories::ADH_CATEGORY_IDENTITY])
 185             ->hasSize(12);
 186         $this->array($categorized[\Galette\Entity\FieldsCategories::ADH_CATEGORY_GALETTE])
 187             ->hasSize(11);
 188         $this->array($categorized[\Galette\Entity\FieldsCategories::ADH_CATEGORY_CONTACT])
 189             ->hasSize(15);
 190     }
 191
 192     /**
 193      * Test setNotRequired
 194      *
 195      * @return void
 196      */
 197     public function testSetNotRequired()
 198     {
 199         $fields_config = $this->fields_config;
 200         $fields_config->load();
 201
 202         $required_mdp = $fields_config->getRequired()['mdp_adh'];
 203         $this->boolean($required_mdp)->isTrue();
 204
 205         $cat = \Galette\Entity\FieldsCategories::ADH_CATEGORY_GALETTE;
 206         $required_mdp = $fields_config->getCategorizedFields()[$cat][6]['required'];
 207         $this->boolean($required_mdp)->isTrue();
 208
 209         $fields_config->setNotRequired('mdp_adh');
 210
 211         $required_mdp = $fields_config->getRequired();
 212         $this->array($required_mdp)->notHasKey('mdp_adh');
 213
 214         $required_mdp = $fields_config->getCategorizedFields()[$cat][6]['required'];
 215         $this->boolean($required_mdp)->isFalse();
 216     }
 217
 218     /**
 219      * Test getVisibility
 220      *
 221      * @return void
 222      */
 223     public function testGetVisibility()
 224     {
 225         $this->fields_config->load();
 226
 227         $visible = $this->fields_config->getVisibility('nom_adh');
 228         $this->integer($visible)->isIdenticalTo(\Galette\Entity\FieldsConfig::USER_WRITE);
 229
 230         $visible = $this->fields_config->getVisibility('id_adh');
 231         $this->integer($visible)->isIdenticalTo(\Galette\Entity\FieldsConfig::NOBODY);
 232
 233         $visible = $this->fields_config->getVisibility('info_adh');
 234         $this->integer($visible)->isIdenticalTo(\Galette\Entity\FieldsConfig::STAFF);
 235     }
 236
 237     /**
 238      * Test setFields and storage
 239      *
 240      * @return void
 241      */
 242     public function testSetFields()
 243     {
 244         $fields_config = $this->fields_config;
 245         $fields_config->installInit();
 246         $fields_config->load();
 247
 248         $fields = $fields_config->getCategorizedFields();
 249
 250         //town
 251         $town = &$fields[\Galette\Entity\FieldsCategories::ADH_CATEGORY_CONTACT][3];
 252         $this->boolean($town['required'])->isTrue();
 253         $this->integer($town['visible'])->isIdenticalTo(\Galette\Entity\FieldsConfig::USER_WRITE);
 254
 255         $town['required'] = false;
 256         $town['visible'] = \Galette\Entity\FieldsConfig::NOBODY;
 257
 258         //jabber
 259         $jabber = $fields[\Galette\Entity\FieldsCategories::ADH_CATEGORY_CONTACT][10];
 260         $jabber['position'] = count($fields[1]);
 261         unset($fields[\Galette\Entity\FieldsCategories::ADH_CATEGORY_CONTACT][10]);
 262         $jabber['category'] = \Galette\Entity\FieldsCategories::ADH_CATEGORY_IDENTITY;
 263         $fields[\Galette\Entity\FieldsCategories::ADH_CATEGORY_IDENTITY][] = $jabber;
 264
 265         $this->boolean($fields_config->setFields($fields))->isTrue();
 266
 267         $fields_config->load();
 268         $fields = $fields_config->getCategorizedFields();
 269
 270         $town = $fields[\Galette\Entity\FieldsCategories::ADH_CATEGORY_CONTACT][3];
 271         $this->boolean($town['required'])->isFalse();
 272         $this->integer($town['visible'])->isIdenticalTo(\Galette\Entity\FieldsConfig::NOBODY);
 273
 274         $jabber2 = $fields[\Galette\Entity\FieldsCategories::ADH_CATEGORY_IDENTITY][12];
 275         $this->array($jabber2)->isIdenticalTo($jabber);
 276     }
 277
 278     /**
 279      * Test isSelfExcluded
 280      *
 281      * @return void
 282      */
 283     public function testIsSelfExcluded()
 284     {
 285         $this->boolean($this->fields_config->isSelfExcluded('bool_admin_adh'))->isTrue();
 286         $this->boolean($this->fields_config->isSelfExcluded('info_adh'))->isTrue();
 287         $this->boolean($this->fields_config->isSelfExcluded('nom_adh'))->isFalse();
 288     }
 289
 290     /**
 291      * Test checkUpdate
 292      *
 293      * @return void
 294      */
 295     public function testCheckUpdate()
 296     {
 297         $fields_config = $this->fields_config;
 298         $fields_config->load();
 299
 300         $categorized_init = $fields_config->getCategorizedFields();
 301
 302         $exists = false;
 303         foreach ($categorized_init[1] as $field) {
 304             if ($field['field_id'] === 'nom_adh') {
 305                 $exists = true;
 306                 break;
 307             }
 308         }
 309         $this->boolean($exists)->isTrue();
 310
 311         $delete = $this->zdb->delete(\Galette\Entity\FieldsConfig::TABLE);
 312         $delete->where(
 313             [
 314                 'table_name'    => \Galette\Entity\Adherent::TABLE,
 315                 'field_id'      => 'nom_adh'
 316             ]
 317         );
 318         $res = $this->zdb->execute($delete);
 319         $this->integer($res->count())->isIdenticalTo(1);
 320
 321         $fields_config->load();
 322
 323         $categorized = $fields_config->getCategorizedFields();
 324         $this->integer(
 325             count($categorized[\Galette\Entity\FieldsCategories::ADH_CATEGORY_IDENTITY])
 326         )->isIdenticalTo(12);
 327
 328         //new object instanciation should add missing field back
 329         $fields_config = new \Galette\Entity\FieldsConfig(
 330             $this->zdb,
 331             \Galette\Entity\Adherent::TABLE,
 332             $this->members_fields,
 333             $this->members_fields_cats
 334         );
 335
 336         $categorized = $fields_config->getCategorizedFields();
 337         $this->array($categorized)->isIdenticalTo($categorized_init);
 338     }
 339
 340     /**
 341      * Test check update when all is empty
 342      *
 343      * @return void
 344      */
 345     public function testCheckUpdateWhenEmpty()
 346     {
 347         $this->zdb->db->query(
 348             'TRUNCATE ' . PREFIX_DB . \Galette\Entity\FieldsConfig::TABLE,
 349             \Zend\Db\Adapter\Adapter::QUERY_MODE_EXECUTE
 350         );
 351         $this->zdb->db->query(
 352             'DELETE FROM ' . PREFIX_DB . \Galette\Entity\FieldsCategories::TABLE,
 353             \Zend\Db\Adapter\Adapter::QUERY_MODE_EXECUTE
 354         );
 355
 356         //new object instanciation should add missing fieldis and categories
 357         $fields_config = new \Galette\Entity\FieldsConfig(
 358             $this->zdb,
 359             \Galette\Entity\Adherent::TABLE,
 360             $this->members_fields,
 361             $this->members_fields_cats
 362         );
 363
 364         $categorized = $fields_config->getCategorizedFields();
 365         $this->countCategorizedFields($categorized);
 366     }
 367
 368     /**
 369      * Test get display elements
 370      *
 371      * @return void
 372      */
 373     public function testGetDisplayElements()
 374     {
 375         $fields_config = $this->fields_config;
 376         $fields_config->load();
 377
 378         $session = new \RKA\Session();
 379         $admin_login = new \mock\Galette\Core\Login(
 380             $this->zdb,
 381             new \Galette\Core\I18n(),
 382             $session
 383         );
 384         $this->calling($admin_login)->isAdmin = true;
 385
 386         $elements = $fields_config->getDisplayElements($admin_login);
 387         $this->array($elements)
 388             ->hasSize(3);
 389
 390         $this->object($elements[0])->isInstanceOf('\stdClass');
 391         $this->integer($elements[0]->id)->isIdenticalTo(1);
 392         $this->array($elements[0]->elements)->hasSize(7);
 393
 394         $this->object($elements[1])->isInstanceOf('\stdClass');
 395         $this->integer($elements[1]->id)->isIdenticalTo(3);
 396         $this->array($elements[1]->elements)->hasSize(10);
 397
 398         $this->object($elements[2])->isInstanceOf('\stdClass');
 399         $this->integer($elements[2]->id)->isIdenticalTo(2);
 400         $this->array($elements[2]->elements)
 401             ->hasSize(10)
 402             ->hasKey('info_adh');
 403
 404         $user_login = new \mock\Galette\Core\Login(
 405             $this->zdb,
 406             new \Galette\Core\I18n(),
 407             $session
 408         );
 409         $this->calling($user_login)->isUp2Date = true;
 410
 411         $elements = $fields_config->getDisplayElements($user_login);
 412         $this->array($elements)
 413             ->hasSize(3);
 414
 415         $this->object($elements[0])->isInstanceOf('\stdClass');
 416         $this->integer($elements[0]->id)->isIdenticalTo(1);
 417         $this->array($elements[0]->elements)->hasSize(7);
 418
 419         $this->object($elements[1])->isInstanceOf('\stdClass');
 420         $this->integer($elements[1]->id)->isIdenticalTo(3);
 421         $this->array($elements[1]->elements)->hasSize(10);
 422
 423         $this->object($elements[2])->isInstanceOf('\stdClass');
 424         $this->integer($elements[2]->id)->isIdenticalTo(2);
 425         $this->array($elements[2]->elements)
 426             ->hasSize(4)
 427             ->notHasKey('info_adh');
 428     }
 429
 430     /**
 431      * Test get form elements
 432      *
 433      * @return void
 434      */
 435     public function testGetFormElements()
 436     {
 437         $fields_config = $this->fields_config;
 438         $fields_config->load();
 439
 440         $session = new \RKA\Session();
 441         $admin_login = new \mock\Galette\Core\Login(
 442             $this->zdb,
 443             new \Galette\Core\I18n(),
 444             $session
 445         );
 446         $this->calling($admin_login)->isAdmin = true;
 447
 448         $elements = $fields_config->getFormElements($admin_login, false);
 449         $this->array($elements)
 450             ->hasSize(2)
 451             ->hasKeys(['fieldsets', 'hiddens']);
 452
 453         $this->array($elements['fieldsets'])
 454             ->hasSize(3);
 455
 456         $this->object($elements['fieldsets'][0])->isInstanceOf('\stdClass');
 457         $this->integer($elements['fieldsets'][0]->id)->isIdenticalTo(1);
 458         $this->array($elements['fieldsets'][0]->elements)->hasSize(10);
 459
 460         $this->object($elements['fieldsets'][1])->isInstanceOf('\stdClass');
 461         $this->integer($elements['fieldsets'][1]->id)->isIdenticalTo(3);
 462         $this->array($elements['fieldsets'][1]->elements)->hasSize(11);
 463
 464         $this->object($elements['fieldsets'][2])->isInstanceOf('\stdClass');
 465         $this->integer($elements['fieldsets'][2]->id)->isIdenticalTo(2);
 466         $this->array($elements['fieldsets'][2]->elements)
 467             ->hasSize(10)
 468             ->hasKey('info_adh');
 469
 470         $this->array($elements['hiddens'])
 471             ->hasSize(2);
 472
 473         $user_login = new \mock\Galette\Core\Login(
 474             $this->zdb,
 475             new \Galette\Core\I18n(),
 476             $session
 477         );
 478         $this->calling($user_login)->isUp2Date = true;
 479
 480         $elements = $fields_config->getFormElements($user_login, false);
 481         $this->array($elements)
 482             ->hasSize(2)
 483             ->hasKeys(['fieldsets', 'hiddens']);
 484
 485         $this->array($elements['fieldsets'])
 486             ->hasSize(3);
 487
 488         $this->object($elements['fieldsets'][0])->isInstanceOf('\stdClass');
 489         $this->integer($elements['fieldsets'][0]->id)->isIdenticalTo(1);
 490         $this->array($elements['fieldsets'][0]->elements)->hasSize(10);
 491
 492         $this->object($elements['fieldsets'][1])->isInstanceOf('\stdClass');
 493         $this->integer($elements['fieldsets'][1]->id)->isIdenticalTo(3);
 494         $this->array($elements['fieldsets'][1]->elements)->hasSize(11);
 495
 496         $this->object($elements['fieldsets'][2])->isInstanceOf('\stdClass');
 497         $this->integer($elements['fieldsets'][2]->id)->isIdenticalTo(2);
 498         $this->array($elements['fieldsets'][2]->elements)
 499             ->hasSize(4)
 500             ->notHasKey('info_adh');
 501
 502         $this->array($elements['hiddens'])
 503             ->hasSize(2);
 504     }
 505 }