<?php
namespace App\Test\TestCase\Controller;

//use App\Test\TestCase\Controller\General;
use App\Controller\MaterielsController;
//use Cake\TestSuite\IntegrationTestCase;
use Cake\ORM\TableRegistry;
//use phpDocumentor\Reflection\Types\Self_;
use Cake\Core\Configure;
use App\Controller\AppController;
use Cake\Utility\Inflector;

//use phpDocumentor\Reflection\Types\Boolean;


// Mettre ici les memes constantes que celles utilisées dans MaterielsFixture
use const App\Test\Fixture\yyyy0mmdd1;
use const App\Test\Fixture\yyyy1mmdd1;
use const App\Test\Fixture\yyyy1mmdd2;
use const App\Test\Fixture\yyyy2mmdd1;
use const App\Test\Fixture\yyyy2mmdd2;
use const App\Test\Fixture\yyyy3mmdd2;
use const App\Test\Fixture\yyyy1_highest_num;
use const App\Test\Fixture\yyyy2_highest_num;
use const App\Model\Entity\MAX_DIFF_YEARS;
//use const App\Model\Table\MAX_DIFF_YEARS;
/* marche pas, why ???
use const App\Test\Fixture\yyyy0;
use const App\Test\Fixture\yyyy1;
use const App\Test\Fixture\yyyy2;
use const App\Test\Fixture\yyyy3;
*/
const yyyy0 = 2020; // Année en cours
const yyyy1 = yyyy0-1; // max : 'TEST-'.yyyy1.'-0002' => donc prochain créé doit être en -0003
const yyyy2 = yyyy0-2; // max : 'TEST-'.yyyy2.'-0010' => donc prochain créé doit être en -0010
const yyyy3 = yyyy0-3;

// AVIRER
//private $nb_matos_in_fixture = 7;
const nb_matos_in_fixture = 7;


/**
 * App\Controller\MaterielsController Test Case
 */
class MaterielsControllerTest extends General {
//class MaterielsControllerTest extends IntegrationTestCase {

    // Si DEBUG, affiche plus d'infos
    //private $DEBUG=false;
    //private $DEBUG=true;
    
    /**
     * Fixtures
     *
     * @var array
     */
    public $fixtures = [
        'app.materiels',
        
        'app.configurations',

        'app.sur_categories',
        'app.categories',
        'app.sous_categories',
        
        'app.groupes_thematiques',
        'app.groupes_metiers',
        
        'app.fakeldapusers',
        'app.users',
        
        'app.organismes',
        'app.sites',
        
        'app.documents',
        'app.type_documents',
        'app.suivis',
        'app.type_suivis',
        'app.emprunts',
        
        'app.fournisseurs',
        'app.unites'
    ];

    /*
    private $statuses = [
        'CREATED',
        'VALIDATED',
        'TOBEARCHIVED',
        'ARCHIVED'
    ];
    */
    private $STATUSES = MaterielsController::statuses;
    protected $MATOS_STATUSES = [
        ['CREATED'],
        ['VALIDATED'],
        ['TOBEARCHIVED'],
        ['ARCHIVED']
        /*
        */
    ];
    
 
    const mandatoryFieldsForCreation = [
        //'id',
        'designation',
        'sur_categorie_id',
        'categorie_id',
        //'materiel_administratif', 'materiel_technique',
        //'status' => 'CREATED',
        'date_acquisition'
    ];
    
    private $newMaterielWithAllMandatoryFields = [
        //'id' => 16,
        //'designation' => 'Test 15',
        'designation' => 'Test '.(nb_matos_in_fixture+1),
        'sur_categorie_id' => 1,
        'categorie_id' => 1,
        'materiel_administratif' => 0,
        'materiel_technique' => 1,
        //'date_acquisition' => '19-04-2020', //+4
        //'date_acquisition' => '19-04-2019',
        // Ca marche pas dans le sens US yyyy-mm-dd alors que ça marche dans la fixture, WHY ???
        //'date_acquisition' => yyyy1.'-04-19', //+4
        // Donc format FR dd-mm-yyyy
        //'date_acquisition' => '19-04-'.yyyy1,
        'date_acquisition' => '19/04/'.yyyy1,
        // pas obligatoire, mais plus cohérent car c'est le statut minimum
        ////'status' => 'CREATED',
        /*
         'nom_responsable' => 'Jacques Utilisateur',
         'email_responsable' => 'Jacques.Utilisateur@irap.omp.eu'
         'nom_createur' => 'Pallier Etienne',
         'nom_modificateur' => 'Jean Administration',
         */
        
        // CHAMPS NECESSAIRES POUR MATERIEL VALIDATED :
        /*
        'date_reception' => '2016-04-19',
        'nom_responsable' => 'Lorem ipsum dolor sit amet',
        'fournisseur_id' => 1
        'organisme_id' => 1,
        'prix_ht' => 75,
        'numero_commande' => 'Lorem ipsum dolor sit amet',
        */
    ];
    
    /*
    //@override parent
    protected function getEntitiesName() {
        return 'Materiels';
    }
    */


    //@Override parent
    // PAS le 1 (ni le 3 ni le 12) car il a des suivis et donc on ne pourra pas le supprimer !!!
    static protected function _getEntityIdOkForTesting() {
        return 2;
    }
    
    
    private function _getNextNum4DigitsAfter($num4digits) {
        $num4digits_next = intval($num4digits)+1;
        //debug($num4digits, $num4digits_next);
        $num4digits_next = sprintf('%04d',$num4digits_next);
        //debug($num4digits, $num4digits_next);
        return $num4digits_next;
    }
    
    protected function getNewEntityWithAllMandatoryFields() {
        return $this->newMaterielWithAllMandatoryFields;
    }
    
    //private function _getNbMaterielsInIndexViewForRole($role) {
    protected function _getNbMaterielsInIndexViewForCurrentRole() {
        // ADMIN(+) : tous
        if ($this->USER_IS_ADMIN_AT_LEAST()) return $this->getNbEntitiesInFixture();
        // Sinon : tous sauf le matos archived
        return $this->getNbEntitiesInFixture()-1;
    }
    
    protected function getNbEntitiesExpectedInIndexView() {
     return $this->_getNbMaterielsInIndexViewForCurrentRole();
    }
        
    
    /* 
     * 
     * FONCTIONS UTILITAIRES UTILISÉES PAR LES TESTS
     * 
     */

    /**
     * setUp method
     *
     * @return void
     */
    public function setUp() {
        parent::setUp();

        // Initialisation du tableau $this->is_authorized_action
        ///$this->_setAuthorizations();
        
        $config = TableRegistry::exists('Materiels') ? [] : [
            'className' => 'App\Model\Table\MaterielsTable'
        ];
        $this->Materiels = TableRegistry::getTableLocator()->get('Materiels', $config);

        /*
        $config = TableRegistry::exists('Suivis') ? [] : [
            'className' => 'App\Model\Table\SuivisTable'
        ];
        $this->Suivis = TableRegistry::get('Suivis', $config);
        */

        //$this->ControllerMateriels = new MaterielsController();
    }

    /**
     * tearDown method
     *
     * @return void
     */
    public function tearDown() {
        unset($this->Materiels);
        //unset($this->Suivis);
        //unset($this->ControllerMateriels);

        parent::tearDown();
    }

    /* (EP 20200515) moved to General.php
    // This are data providers used for a lot of tests
    // See https://jtreminio.com/2013/03/unit-testing-tutorial-part-2-assertions-writing-a-useful-test-and-dataprovider
    public function dataProviderRoles5() { return $this->ROLES5; }
    // Idem dataProviderRoles5 mais avec USER_from_ldap en plus:
    public function dataProviderRoles6() { return $this->ROLES6; }
    */
    //public function dataProviderStatuses4() { return $this->MATOS_STATUSES; }
    /*
    public function dataProviderRoles4AndStatuses4() {
        $roles_and_statuses = [];
        foreach ($this->ROLES4 as $user_role) {
            //debug($user_role[0]);
            foreach ($this->MATOS_STATUSES as $matos_status)
                $roles_and_statuses[] = [$user_role[0], $matos_status[0]];
        }
        $this->d($roles_and_statuses);
        return $roles_and_statuses;
    }
    */
    
    /*
    protected function getController() {
        if (!$this->controller_instance) $this->controller_instance = new MaterielsController();
        return $this->controller_instance;
    }
    */
    
    // (EP) moved to parent
    /*
    public function dataProviderActionsAndRoles4() {
        $actions_and_roles = [];
        $actions = MaterielsController::getActions();
        debug("Liste des Actions à tester:");debug($actions);
        //foreach ($actions as $a) echo("$a\n");
        /S
        $actions = [
            // CRUD
            'add','add_by_copy', 'view','index','edit','delete',
            //'view',
            //'index',
            // Autres
            'statusCreated',
        ];
        S/
        $roles4 = [
            'user',
            'resp',
            'admin',
            'super',
        ];
        foreach ($actions as $action)
            //foreach ([0] as $i) {
            //foreach ([0,1] as $i) {
            foreach ([0,1,2,3] as $i) {
                $item = [ $action, $roles4[$i], $this->ROLES4[$i][0] ];
                //debug($item);
                $actions_and_roles[] = $item;
            }
        return $actions_and_roles;
    }
    */

    /*
    private function _checkMaterielExistsInViewsIndexAndViewAndInDatabase($role, $id, $designation=NULL, $num_inventaire=NULL) {}
    private function _checkMaterielExistsInViewsIndexAndView($role, $id, $designation=NULL, $num_inventaire=NULL) {}
    private function _checkMaterielExistsInViewIndex($role, $id, $designation=NULL, $num_inventaire=NULL) {}
    private function _checkMaterielExistsInViewView($role, $id, $designation=NULL, $num_inventaire=NULL) {}
    private function _checkMaterielExistsInDatabase($role, $id, $designation=NULL, $num_inventaire=NULL) {}
    private function _checkMaterielViewIsOK($role, $id, $designation=NULL, $num_inventaire=NULL) {}
    */
    private function _checkNbMaterielInIndexViewIs($SHOUD_BE_ADDED, $role, $nbmat, $designation=NULL, $num_inventaire=NULL) {
        $this->get('/materiels/index');
        if (! $SHOUD_BE_ADDED) {
            //$this->assertResponseNotContains("Liste des matériels (".$nbmat.")", $role);
            $nbmat--;
            $this->assertResponseContains("Liste des matériels ($nbmat)", $role);
        }
        else {
            $this->assertResponseContains("Liste des matériels ($nbmat)", "Nb matériels incorrect ($role)");
            if (isset($designation)) $this->assertResponseContains($designation, "Le matériel ne s'ajoute pas correctement.");
            if (isset($num_inventaire)) $this->assertResponseContains($num_inventaire, "La génération du n°de labo n'est pas bonne.");
        }
    }
    private function _checkNbMaterielInIndexViewAfterActionIsOK($authorized, $action, $nbmat_awaited, $role) {
        $this->get('/materiels/index');
        $this->assertResponseContains("Liste des matériels ($nbmat_awaited)", "Nb matériels incorrect dans la vue 'index' : L'action $action ne s'est pas déroulée comme prévu (autorisée ? ".(int)$authorized.") ! (rôle = $role)");
    }
    
    // (EP) moved to parent
    /*
    private function _MAT_checkNbEntitiesInIndexViewIsAsAwaited($entity_name,$nbmat_awaited) {
        $entity_name = strtolower($entity_name);
        //$this->get('/materiels/index');
        $this->get("/$entity_name/index");
        if ($entity_name=='materiels') $entity_name = 'matériels';
        //debug($_SESSION);return;
        $this->assertResponseOk();
        $this->assertResponseContains("Liste des $entity_name ($nbmat_awaited)", "Le nombre d'entités dans la vue 'index' est incorrect");
    }
    */
    private function _checkNbMaterielInIndexViewIsAsAwaited($nbmat_awaited) {
        $this->get('/materiels/index');
        //debug($_SESSION);return;
        $this->assertResponseOk();
        $this->assertResponseContains("Liste des matériels ($nbmat_awaited)", "Le nombre de matériels dans la vue 'index' est incorrect");
    }
    
    
    /*
     * Tests organisés par (CONTROLEUR puis par) ACTION
     *  
     * Ici, on teste les ACTIONS du controleur MaterielsController
     * Voir https://docs.google.com/document/d/1-OhEeoi96j6ueUl5NQCQ9ZsTfbJTFw3ZVaWU2iYly_o/edit#heading=h.bxuswhw2zzwt
     * 
     * Chaque test d'une ACTION doit tester l'appel de cette action pour chaque ROLE
     * 
     */

    /*
     * *****************************************************************************
     * Basic ACL testing ($easyACL array rules)
     * *****************************************************************************
     */
    public function testOLDEasyACL() {
        $matCont = new MaterielsController();
        $appCont = new AppController();
        /*
        $role = 'USER_from_ldap';
        $this->authAs($role);
        $roleLong = $appCont->getUserRole();
        */

        /*
         * SCHOOL CASES
         */
        
        $roleLong = 'Utilisateur';
        // CAS1
        $this->_testEasyACL($matCont, $roleLong, 'action_CAS1_Y', 'Y');
        $this->_testEasyACL($matCont, $roleLong, 'action_CAS1_N', 'N');
        // CAS2
        $this->_testEasyACL($matCont, $roleLong, 'action_CAS2_Y', 'Y');
        $this->_testEasyACL($matCont, $roleLong, 'action_CAS2_N', 'N');
        // CAS3
        $this->_testEasyACL($matCont, $roleLong, 'action_CAS3_Y', 'Y');
        $this->_testEasyACL($matCont, $roleLong, 'action_CAS3_N', 'N');
        // CAS4
        $this->_testEasyACL($matCont, $roleLong, 'action_CAS4_Y', 'Y');
        $this->_testEasyACL($matCont, $roleLong, 'action_CAS4_N', 'N');
        // CAS5
        $this->_testEasyACL($matCont, $roleLong, 'action_unknown_CAS5_Y', 'Y');
        
        // CAS6
        /*
        $role = 'RESP';
        $this->authAs($role);
        $roleLong = $appCont->getUserRole();
        */
        $roleLong = 'Responsable';
        $this->_testEasyACL($matCont, $roleLong, 'action_CAS6_resp_Y', 'Y');
        $this->_testEasyACL($matCont, $roleLong, 'action_CAS6_resp_N', 'N');
        /*
        $role = 'ADMIN';
        $this->authAs($role);
        $roleLong = $appCont->getUserRole();
        */
        $roleLong = 'Administration';
        $this->_testEasyACL($matCont, $roleLong, 'action_CAS6_admin_Y', 'Y');
        $this->_testEasyACL($matCont, $roleLong, 'action_CAS6_admin_N', 'N');
        
        /*
         * REAL CASES
         */
        
        $roleLong = 'Utilisateur';
        // add as USER
        $this->_testEasyACL($matCont, $roleLong, 'add', 'Y');
        
        // edit
        $this->_testEasyACL($matCont, 'Utilisateur', 'edit', '(status == CREATED || status == VALIDATED) && (is_creator || is_user)');
        $this->_testEasyACL($matCont, 'Responsable', 'edit', '(status == CREATED || status == VALIDATED) && is_resp');
        $this->_testEasyACL($matCont, 'Administration', 'edit', '(status == CREATED || status == VALIDATED)');
        $this->_testEasyACL($matCont, 'Administration Plus', 'edit', '(status == CREATED || status == VALIDATED)');
        $this->_testEasyACL($matCont, 'Super Administrateur', 'edit', '(status == CREATED || status == VALIDATED)');
        
        // delete
        $this->_testEasyACL($matCont, 'Utilisateur', 'delete', '(status == CREATED) && is_owner');
        $this->_testEasyACL($matCont, 'Responsable', 'delete', '(status == CREATED)');
        $this->_testEasyACL($matCont, 'Administration', 'delete', '(status == CREATED)');
        $this->_testEasyACL($matCont, 'Administration Plus', 'delete', '(status == CREATED)');
        $this->_testEasyACL($matCont, 'Super Administrateur', 'delete', '(status == CREATED)');
        
        // statusCreated
        $this->_testEasyACL($matCont, 'Utilisateur', 'statusCreated', 'N');
        $this->_testEasyACL($matCont, 'Responsable', 'statusCreated', 'N');
        $this->_testEasyACL($matCont, 'Administration', 'statusCreated', 'Y');
        $this->_testEasyACL($matCont, 'Administration Plus', 'statusCreated', 'Y');
        $this->_testEasyACL($matCont, 'Super Administrateur', 'statusCreated', 'Y');
        
        /*
        $action='autre4';
        $rule = $matCont->isAuthorizedAction($matCont, $roleLong, $action);
        $this->assertEquals('N', $rule, $roleLong.' do '.$action);
        */
    }
    private function _testEasyACL(AppController $controller, $roleLong, $action, $expectedRule) {
        $rule = $controller->OLD_isAuthorizedAction2($controller, $roleLong, $action);
        $this->assertEquals($expectedRule, $rule, $roleLong.' do '.$action);
    }
    
    
    /* 
     * *****************************************************************************
     * ACTION READ
     * (1) READ ALL (index) : Voir la liste des matériels
     * *****************************************************************************
     */
    
    /**
     * Test index method
     *
     * @return void
     */
    // test INDEX action
    /*
    public function testMat20ReadAll() { 
        foreach ($this->ROLES as $role) $this->_testMatReadAllAs($role);
    }
    */
    /*
    public function testMat20ReadAllAsUserFromLdap() { $this->_testMatReadAllAs('USER_from_ldap'); }
    public function testMat20ReadAllAsUserFromTable() { $this->_testMatReadAllAs('USER'); }
    public function testMat20ReadAllAsResp() { $this->_testMatReadAllAs('RESP'); }
    public function testMat20ReadAllAsAdmin() { $this->_testMatReadAllAs('ADMIN'); }
    public function testMat20ReadAllAsAdminP() { $this->_testMatReadAllAs('ADMINP'); }
    public function testMat20ReadAllAsSuperAdmin() { $this->_testMatReadAllAs('SUPER'); }
    private function _testMatReadAllAs($role)
    */
    /**
     * @dataProvider dataProviderRoles4
     */
    public function testMat20ReadAllAs($role)
    {
        //$this->setUp();
        
        // On doit pouvoir accéder à la page une fois authentifié
        $this->authAs($role);
        // - 5 ans
        $this->get('/materiels/index');
        // Tous
        //$this->get('/materiels/index?age=0');
        $this->assertNoRedirect("Authentifié mais redirection vers /users/login.");

        // Seul admin+ peut voir les materiels archivés et a accès à des filtres par statut + bouton exporter + cases à cocher
        //if ( in_array($role, ['ADMIN','ADMINP','SUPER']) ) {
        if ($this->USER_IS_ADMIN_AT_LEAST()) { 
            $this->assertResponseContains('Liste des matériels (7)', 'Le profil '.$role.' devrait voir les matériels archivés.');
            $this->assertResponseContains("A valider", 'Le profil '.$role.' devrait avoir accès à des filtres par statut.');
            $this->assertResponseContains("A sortir", 'Le profil '.$role.' devrait avoir accès à des filtres par statut.');
        }
        else { 
            $this->assertResponseContains("Liste des matériels (6)", 'Le profil '.$role.' ne devrait PAS voir les matériels archivés.');
            $this->assertResponseNotContains("A valider", 'Le profil '.$role.' ne devrait PAS avoir accès à des filtres par statut.');
        }
        $this->assertResponseContainsIf($role, ($this->getUserRole() != 'Utilisateur'), ["Exporter la liste complete"=>"un bouton Exporter"]);
        
        $this->get('/materiels/index/CREATED');
        //TODO: il faudrait remplacer "false" par "true" dans ce test
        $this->assertResponseContainsIf(
            $role, 
            //in_array($role,['ADMIN','ADMINP','SUPER']),
            $this->USER_IS_ADMIN_AT_LEAST(),
            [
                "checkbox" => "à des checkboxes",
                "Exporter la liste des matériels cochés" => "au bouton d'exportation de liste",
                "Valider les matériels cochés" => "au bouton de validation de liste"
            ],
            false
        );
        /*
        if ( in_array($role, ['ADMIN','ADMINP','SUPER']) ) {
            $this->assertResponseContains('checkbox', 'Le profil '.$role.' devrait avoir accès à des checkboxes');
            $this->assertResponseContains("Exporter la liste des matériels cochés", 'Le profil '.$role.' devrait avoir accès au bouton d\'exportation de liste');
            $this->assertResponseContains("Valider les matériels cochés", 'Le profil '.$role.' devrait avoir accès au bouton de validation de liste');
        }
        else {
        }
        */
        
        //$this->tearDown();
    }
    public function testMat21ReadAllAsAnonymous() { // test INDEX action
        // On ne doit pas avoir accès sans authentification
        $this->get('/materiels/index');
        // 		$this->assertRedirect('/users/login', 'Problème : Accès à materiels/index SANS AUTHENTIFICATION');
        // Le changement est dû au changement de version de cakephp 3.2 vers 3.4
        $this->assertRedirect('/users/login?redirect=%2Fmateriels%2Findex', 'Problème : Accès à materiels/index SANS AUTHENTIFICATION');
    }
    
    
    /*
     * *****************************************************************************
     * ACTION READ
     * (2) READ ONE (view/id) : Voir le détail d'un matériel
     * *****************************************************************************
     */
    
    /**
     * Test view method
     *
     * @group failing
     * @return void
     */
    /*
    public function testMat10ReadOne() { // test VIEW action
        foreach ($this->ROLES as $role) $this->_testMatReadOneAs($role);
    }
    */
    // test VIEW action
    /*
    public function testMat10ReadOneAsUserFromLdap() { $this->_testMatReadOneAs('USER_from_ldap'); }
    public function testMat10ReadOneAsUserFromTable() { $this->_testMatReadOneAs('USER'); }
    public function testMat10ReadOneAsResp() { $this->_testMatReadOneAs('RESP'); }
    public function testMat10ReadOneAsAdmin() { $this->_testMatReadOneAs('ADMIN'); }
    public function testMat10ReadOneAsAdminPlus() { $this->_testMatReadOneAs('ADMINP'); }
    public function testMat10ReadOneAsSuperAdmin() { $this->_testMatReadOneAs('SUPER'); }
    private function _testMatReadOneAs($role)
    */
    /**
     * @dataProvider dataProviderRoles4
     */
    public function testMat10ReadOneAs($role)
    {
        //$this->setUp();

        //$this->authSuperAdmin();
        $this->authAs($role);
        /*
        $myrole = $this->getUserRole();
        $this->assertEquals('Super Administrateur', $myrole);
        */
        $this->get('/materiels/view/3');
        $this->assertResponseContains("Test 3", "Le matériel retourné n'est pas celui demandé.");
        $this->assertResponseContains('alt="QrCode', "Le QRCode n'est pas sur la vue matériel.");
        $this->assertResponseContains("Suivi(s) du matériel (1)", "Le nb de suivis liés au matériel est incorrect.");
        $this->assertResponseContains("Informations", "Le nb de suivis liés au matériel est incorrect.");
        $this->assertResponseContains("Suivi(s)", "Le nb de suivis liés au matériel est incorrect.");
        $this->assertResponseContains("Suivi(s) du matériel (", "Le nb de suivis liés au matériel est incorrect.");
        $this->assertResponseContains("Emprunt(s) du matériel (1)", "Le nb d'emprunts liés au matériel est incorrect.");
        $this->assertResponseContains("Emprunt", "Le nb d'emprunts liés au matériel est incorrect.");
        //$this->assertResponseContains("Fichier(s) lié(s) au matériel (1)", "Le nb de fichiers liés au matériel est incorrect.");
        // Only admin+ see admin section:
        //if ( in_array($role, ['ADMIN','ADMINP','SUPER']) ) {
        if ($this->USER_IS_ADMIN_AT_LEAST()) {
            $this->assertResponseContains("Informations administratives");
            $this->assertResponseContains("CentreFinancier/EOTP");
        }
        else $this->assertResponseNotContains("Informations administratives");
        
        //$this->tearDown();
    }

    
    /*
     * *****************************************************************************
     * ACTION CREATE (add) : Créer un matériel
     * *****************************************************************************
     */
    
    /**
     * Test testMat30AccessCreateForm
     *
     * @return void
     */
    /*
    public function testMat30AccessCreateForm() {
        foreach ($this->ROLES as $role) $this->_testMatAccessCreateFormAs($role);
    }
    */
    /*
    public function testMat30AccessCreateFormAsUserFromLdap() { $this->_testMatAccessCreateFormAs('USER_from_ldap'); }
    public function testMat30AccessCreateFormAsUser() { $this->_testMatAccessCreateFormAs('USER'); }
    public function testMat30AccessCreateFormAsResp() { $this->_testMatAccessCreateFormAs('RESP'); }
    public function testMat30AccessCreateFormAsAdmin() { $this->_testMatAccessCreateFormAs('ADMIN'); }
    public function testMat30AccessCreateFormAsAdminPlus() { $this->_testMatAccessCreateFormAs('ADMINP'); }
    public function testMat30AccessCreateFormAsSuperAdmin() { $this->_testMatAccessCreateFormAs('SUPER'); }
    private function _testMatAccessCreateFormAs($role)
    */
    /**
     * @dataProvider dataProviderRoles4
     */
    public function testMat30AccessCreateFormAs($role) {
        //$this->setUp();
        
        // On doit pouvoir accéder à la page une fois authentifié
        $this->authAs($role);
        $this->get('/materiels/add');
        $this->assertResponseContains('Ajouter', 'La page n\'existe pas');
        $this->assertResponseContainsIf(
            $role, 
            //in_array($role,['ADMIN', 'ADMINP', 'SUPER']), 
            $this->USER_IS_ADMIN_AT_LEAST(),
            ["EOTP" => "à la partie administrative sur le formulaire add"]
        );
        /*
        $this->assertResponseNotContains('EOTP', 'Le profil utilisateur a accès à la partie administrative sur le formulaire add.');
        $this->assertResponseContains('EOTP', 'Le profil admin+ n\'a pas accès à la partie administrative sur le formulaire add.');
        */
    
        //$this->tearDown();
    }

    
    /**
     * Test testMat31Create
     *
     * @return void
     */
    /*
    public function testMat31CreateAsSuper() { $this->_testMatCreateAs('SUPER'); }
    public function testMat31CreateAsAdminp() { $this->_testMatCreateAs('ADMINP'); }
    public function testMat31CreateAsAdmin() { $this->_testMatCreateAs('ADMIN'); }
    public function testMat31CreateAsResp() { $this->_testMatCreateAs('RESP'); }
    public function testMat31CreateAsUser() { $this->_testMatCreateAs('USER'); }
    public function testMat31CreateAsUserFromLdap() { $this->_testMatCreateAs('USER_from_ldap'); }
    */

    /*
    public function testMat32CreateAdministratifOrTechnicalAsSuper() { $this->_testMatCreateAdministratifOrTechnicalAs('SUPER'); }
    private function _testMatCreateAdministratifOrTechnicalAs($role) {
    */
    /**
     * @dataProvider dataProviderRoles4
     */
    public function testMat32CreateAdministratifOrTechnicalAs($role) {
        $newMateriel = $this->newMaterielWithAllMandatoryFields;
        $fields = ['materiel_administratif','materiel_technique'];
        // test with materiel_administratif and materiel_technique, all combinations from (0,0) to (1,1)
        //for ($i=0,$j=0; $i<=1,$j<=1 ; $i++,$j++) {
        //for ($i=0; $i<=1 ; $i++) {
        $materiels = $this->Materiels;
        //foreach ([0] as $i) {
        foreach ([0,1] as $i) {
            //for ($j=0; $j<=1 ; $j++) {
            //foreach ([1] as $j) {
            foreach ([0,1] as $j) {
                $newMateriel["$fields[0]"] = $i;
                $newMateriel["$fields[1]"] = $j;
                $combination = [$i,$j];
                $this->d($combination);
                
                // KO: ni administratif ni technique
                if ($combination == [0,0]) 
                    $this->_testMatCreate1FailsAs($role, $newMateriel, implode(',',$combination));
                
                // OK : technique only
                if ($combination == [0,1]) {
                    continue;
                    // cree un nouveau materiel
                    //$this->_testMatCreateAs($role, $newMateriel, implode(',',$combination));
                    //$this->testMat31CreateAs($role, $newMateriel, implode(',',$combination));
                    /*
                    $this->authAs($role);
                    $this->get('/materiels/index');
                    $this->assertResponseContains("Liste des matériels (6)", $role.','.implode($combination));
                    */
                    $this->testMat31CreateAs($role, $newMateriel);
                    //$matos = $this->Materiels->get(11);
                    // supprimer un materiel pour avoir toujours le meme nombre
                    //TODO: impossible de supprimer le matos 1, why ???
                    //$this->post('/materiels/delete/1');
                    //$this->post('/materiels/delete/11');
                    // marche pas, pourquoi ???
                    //$matos = $this->Materiels->get(11);
                    $matos = $materiels->get(11); 
                    //pr($matos);
                    $materiels->delete($matos);
                    $this->get('/materiels/index');
                    $nbmat = $this->USER_IS_ADMIN_AT_LEAST() ? 7 : 6;
                    $this->assertResponseContains("Liste des matériels (".$nbmat.")", "Le matériel (11) n'a pas été supprimé comme attendu ! (".$role.', combinaison '.implode($combination).')');
                }
                
                // Administratif : (1,0) et (1,1) : ok si prix > 800
                // No need to test the case [1,1] because same as [1,0]
                if ($combination == [1,0]) {
                //if ($i == 1) {
                     
                     // prix null => fails
                     $this->_testMatCreate1FailsAs($role, $newMateriel, implode(',',$combination));
                     
                     // prix < 800 => fails
                     $newMateriel['prix_ht'] = 799;
                     $this->_testMatCreate1FailsAs($role, $newMateriel, implode(',',$combination));
                     
                     // prix >= 800 => ok
                     $newMateriel['prix_ht'] = 800; // 1000
                     //debug($newMateriel);
                     $this->testMat31CreateAs($role, $newMateriel, implode(',',$combination));
                     /*
                     // supprimer un materiel pour avoir toujours le meme nombre
                     //TODO: impossible de supprimer le matos 1, why ???
                     //$this->post('/materiels/delete/1');
                     $this->post('/materiels/delete/2');
                     $this->get('/materiels/index');
                     $nbmat = $this->USER_IS_ADMIN_AT_LEAST($role) ? 7 : 6;
                     $this->assertResponseContains("Liste des matériels (".$nbmat.")", $role.','.implode($combination));
                     */
                 }
            } // j
        } // i
    } // testMat32CreateAdministratifOrTechnicalAs(role)
    
    
    /**
     * @dataProvider dataProviderRoles4
     */
    //private function _testMatCreateAs($role, $materiel=null) { $this->testMat31CreateAs($role, $materiel); }
    public function testMat31CreateAs($role, $materiel=null) {
        //debug("************* in testMat31CreateAs(role, matos) avec role $role");
        //$materiel = $materiel ? $this->newMaterielWithAllMandatoryFields : $materiel;
        if (is_null($materiel)) $materiel = $this->newMaterielWithAllMandatoryFields;
        //debug($materiel);
        //$this->setUp();
        // On doit pouvoir accéder à la page une fois authentifié
        $this->authAs($role);
        
        // AVANT add
        $this->get('/materiels/index');
        // USER ne voit pas les materiels ARCHIVED
        //debug($this->USER_IS_ADMIN_AT_LEAST());
        $nbmat = $this->USER_IS_ADMIN_AT_LEAST() ? 7 : 6;
        $this->assertResponseContains("Liste des matériels (".$nbmat.")", $role);
        //debug("bef $nbmat");
        
        // ADD
        //debug($materiel);
        //$this->post('/materiels/add', $this->newMaterielWithAllMandatoryFields);
        $this->post('/materiels/add', $materiel);
        $nbmat++;
        //debug("after $nbmat");

        // APRES add
        $this->get('/materiels/index');
        // VOIR LE HTML DE LA PAGE WEB
        //var_dump($this->_getBodyAsString());
        $this->assertResponseContains("Liste des matériels (".$nbmat.")", "(testMat31CreateAs): Le matériel ne s'ajoute pas correctement (avec le profil $role)");
        //$this->assertResponseContains("Liste des matériels (", "(testMat31CreateAs): Le matériel ne s'ajoute pas correctement avec le profil $role");
        //$this->assertResponseContains("Test 15", "Le matériel ne s'ajoute pas correctement.");
        $this->assertResponseContains('Test '.(nb_matos_in_fixture+1), "Le matériel ne s'ajoute pas correctement.");
        //$nummat = $this->USER_IS_ADMIN_AT_LEAST() ? '15' : '13';
        //$this->assertResponseContains("TEST-2020-00$nummat", "La génération du n°de labo n'est pas bonne."); //+4
        $new_yyyy_highest_num = $this->_getNextNum4DigitsAfter(yyyy1_highest_num);
        $this->assertResponseContains('TEST-'.yyyy1.'-'.$new_yyyy_highest_num, "La génération du n°de labo n'est pas bonne."); //+4
        //$this->assertResponseContains("TEST-2020-0015", "La génération du n°de labo n'est pas bonne."); //+4
        //$this->tearDown();
    }
    
    
    /*    
    public function testValueNeccessaryNotEmpty() {
        $this->authSuperAdmin();
        
        $data = [
            'id' => 16,
            'designation' => 'Test 16',
            'sur_categorie_id' => '',
            'categorie_id' => '',
            'materiel_administratif' => 0,
            'materiel_technique' => 1,
            'status' => 'CREATED',
            'date_acquisition' => '19-04-2016',
            'nom_createur' => 'Pallier Etienne',
            'nom_modificateur' => 'Jean Administration',
            'nom_responsable' => 'Jacques Utilisateur',
            'email_responsable' => 'Jacques.Utilisateur@irap.omp.eu'
        ];
        $this->post('/materiels/add', $data);
        
        $this->get('/materiels/index');
        $this->assertResponseContains("Liste des matériels (7)", "Le matériel s'ajoute alors que les champs obligatoires ne sont pas rempli.");
    }
    */
    
    /**
     * Test testMat32CreateFails
     *
     * @return void
     */
    /*
    public function testMat33CreateFailsAsSuper() { $this->_testMatCreateFailsAs('SUPER'); }
    public function testMat33CreateFailsAsUser() { $this->_testMatCreateFailsAs('USER'); }
    public function testMat33CreateFailsAsUserFromLdap() { $this->_testMatCreateFailsAs('USER_from_ldap'); }
    private function _testMatCreateFailsAs($role) {
    */
    /**
     * @dataProvider dataProviderRoles4
     */
    public function testMat33CreateFailsAs($role) {
        // test with each mandatory field except materiel_administratif and materiel_technique
        foreach (self::mandatoryFieldsForCreation as $mandatoryField) {
            $newMaterielWithMissingMandatoryFields = $this->newMaterielWithAllMandatoryFields;
            $newMaterielWithMissingMandatoryFields[$mandatoryField] = null;
            $this->_testMatCreate1FailsAs($role, $newMaterielWithMissingMandatoryFields, $mandatoryField); 
        }
        // test with missing materiel_administratif AND materiel_technique null (equivalent to 0,0)
        $newMaterielWithMissingMandatoryFields = $this->newMaterielWithAllMandatoryFields;
        $fields = ['materiel_administratif','materiel_technique'];
        foreach ($fields as $f) $newMaterielWithMissingMandatoryFields["$f"] = null;
        $this->_testMatCreate1FailsAs($role, $newMaterielWithMissingMandatoryFields, implode(',',$fields));
    }
    private function _testMatCreate1FailsAs($role, $newMaterielWithMissingMandatoryFields, $mandatoryField) {
        ////$this->setUp();
        
        //$newMaterielWithMissingMandatoryFields = $this->newMaterielWithAllMandatoryFields;
        //$newMaterielWithMissingMandatoryFields['sur_categorie_id'] = null;
        /* Mandatory fields :
        'id' => 15,
        'designation' => 'Test 15',
        'sur_categorie_id' => 1,
        'categorie_id' => 1,
        'materiel_administratif' => 0,
        'materiel_technique' => 1,
        //'status' => 'CREATED',
        'date_acquisition' => '19-04-2016',
        */
        //$this->setUp();
        // On doit pouvoir accéder à la page une fois authentifié
        $this->authAs($role);
        $this->get('/materiels/index');
        $nbmat = $this->userHasRoleAtLeast('Administration') ? 7 : 6;
        $this->assertResponseContains("Liste des matériels (".$nbmat.")", $role.','.$mandatoryField);
        $this->post('/materiels/add', $newMaterielWithMissingMandatoryFields);
        $this->get('/materiels/index');
        $this->assertResponseContains("Liste des matériels (".$nbmat.")", $role." Le matériel s'ajoute alors que le champ obligatoire ".$mandatoryField." n'est pas rempli");
        
        ////$this->tearDown();
    }
    
    // Test de l'action "Copier ce materiel" (= materiel/add/id) sur tous les roles
    /**
     * @dataProvider dataProviderRoles4
     */
    public function testMatCopy($role) {
        
        /*
        $role="USER";
        $role="SUPER";
        $role="ADMIN";
        */
        // On doit pouvoir accéder à la page une fois authentifié
        $this->authAs($role);
        
        $do1=1;
        $do2=1;
        $do3=1;
        $do4=1;
        
        // 1) RULE MATERIEL.COPY.1 : 
        // Copie d'un matos (CREATED) à l'IDENTIQUE (tel quel sans rien changer, 
        // sauf ce qui changera automatiquement: id, numlab)
        //if ($do1) $this->_testMatCopy(1, true, $role, 1, [], 'TEST-2018-0001'); //+4
        //if ($do1) $this->_testMatCopy(1, true, $role, 1, [], 'TEST-'.yyyy1.'-0003'); //+4
        if ($do1) $this->_testMatCopy(1, true, $role, 1, [], 'TEST-'.yyyy1.'-'.$this->_getNextNum4DigitsAfter(yyyy1_highest_num));
        
        // 2) RULE MATERIEL.COPY.2 :
        // Copie d'un matos (CREATED) en changeant quelques données
        $new_designation = 'matos 1 USER (C) modified';
        $modified_data = [
            'designation' => $new_designation,
            //'sur_categorie_id' => 1,
            //'categorie_id' => 1,
            //'materiel_administratif' => 0,
            //'materiel_technique' => 1,
            //'status' => 'CREATED',
            //'date_acquisition' => '19-04-2016',
            'date_acquisition' => '19/04/'.yyyy0,
            'date_reception' => '', // sinon, il FAUT qu'elle soit >= date achat
            //'nom_createur' => 'Pallier Etienne',
            //'nom_modificateur' => 'Jean Administration',
            //'nom_responsable' => 'Jacques Utilisateur',
            //'email_responsable' => 'Jacques.Utilisateur@irap.omp.eu',
            //'fournisseur_id' => 2
        ];
        //if ($do2) $this->_testMatCopy(2, true, $role, 1, $modified_data, 'TEST-2016-0015');
        //if ($do2) $this->_testMatCopy(2, true, $role, 1, $modified_data, 'TEST-'.yyyy2.'-'.$this->_getNextNum4DigitsAfter(yyyy2_highest_num));
        if ($do2) $this->_testMatCopy(2, true, $role, 1, $modified_data, 'TEST-'.yyyy0.'-'.'0001');
        
        // 3) RULE MATERIEL.COPY.3 :
        // Impossible de copier un matos de statut superieur à CREATED (même pas pour SUPERADMIN)
        $do3 && $this->_testMatCopy(3, false, $role, 3);
        // Impossible de copier un matos de statut superieur à CREATED (sauf pour SUPERADMIN)
        //if ($do3) $this->_testMatCopy(3, $role=="SUPER", $role, 3);

        // 4) RULE MATERIEL.COPY.4 :
        // Pour un USER: Impossible de copier un matos CREATED dont je ne suis pas propriétaire
        // Pour les autres, c'est ok
        //$this->_testMatCopy(4, !in_array($role, ["USER", "USER_from_ldap"]), $role, 2);
        if ($do4) $this->_testMatCopy(4, !$this->USER_IS_USER(), $role, 2);
        
    }
    
    // Called by testMatCopy() just above
    //if ($do1) $this->_testMatCopy(1, true, $role, 1, [], 'TEST-2014-0001');
    
    private function _testMatCopy($testnum, $COPIED, $role, $id, array $materiel_new_data=[], $num_inventaire=NULL) {
        //debug("_testMatCopy numéro ".$testnum);
        $designation = isset($materiel_new_data->designation) ? $materiel_new_data->designation : 'matos 1 USER (C)';
        
        // AVANT add
        // USER ne voit pas les materiels ARCHIVED
        $nbmat = $this->USER_IS_ADMIN_AT_LEAST() ? 7 : 6;
        if ($this->DEBUG) {
            echo("\n _testMatCopy (avec role $role et test numéro $testnum) :");
            echo("\n designation: $designation");
            echo("\n nb matos: $nbmat");
        }
        $this->_checkNbMaterielInIndexViewIs(true, $role, $nbmat);
        /*
        $this->get('/materiels/index');
        // USER ne voit pas les materiels ARCHIVED
        $nbmat = $this->USER_IS_ADMIN_AT_LEAST() ? 7 : 6;
        $this->assertResponseContains("Liste des matériels (".$nbmat.")", $role);
        */
        $this->post('/materiels/add/'.$id, $materiel_new_data);
        $nbmat++;
        //debug($nbmat);
        
        // APRES add
        $this->_checkNbMaterielInIndexViewIs($COPIED, $role, $nbmat, $designation, $num_inventaire);
/*
        $this->get('/materiels/index');
        // VOIR LE HTML DE LA PAGE WEB
        //var_dump($this->_getBodyAsString());
        $this->assertResponseContains("Liste des matériels (".$nbmat.")", "(testMat31CreateAs): Le matériel ne s'ajoute pas correctement (avec le profil $role)");
        $this->assertResponseContains($designation, "Le matériel ne s'ajoute pas correctement.");
        $this->assertResponseContains($num_inventaire, "La génération du n°de labo n'est pas bonne.");
        */
        //$this->tearDown();
        /*
        $this->get('/materiels/view/15');
        $this->assertResponseContains($designation, "Le matériel ne s'ajoute pas correctement.");
        */
        /*
        $matos1 = TableRegistry::getTableLocator()->get('Materiels')->find()->where([
            'id =' => 15
        ])->first();
        assert($matos1->id == 15, "not one");
        */
        if ($COPIED) {
            // On supprime le dernier materiel pour garder toujours la meme fixture de départ
            //debug(TableRegistry::getTableLocator()->get('Materiels')->find()->last()->id);
            //$matos_last = TableRegistry::getTableLocator()->get('Materiels')->find()->last();
            $matos_last = $this->Materiels->find()->last();
            $this->Materiels->delete($matos_last);
            // Ca marche aussi comme ça, mais c'est moins rapide:
            //$this->post('/materiels/delete/'.$matos_last->id);
            //$this->post('/materiels/delete/15');
            //$this->get('/materiels/view/15');
        }
    }
    
    
    /*
     * III - ACTION UPDATE
     * ACTION "materiels/edit/id" : Editer un matériel
     */
    /**
     * Test edit method
     *
     * @return void
     */

    // ACTION 'edit'
    /*
    public function testUpdate() { // ACTION 'edit'
        foreach ($this->ROLES as $role) { 
            $this->authAs($role);
            if ($role=='USER') continue;
            $this->_testUpdates($role);
        } // foreach
    }
    */
    /*
    //public function testUpdateAsUser() { $this->_testUpdatesAs('USER'); }
    public function testUpdateAsResp() { $this->_testUpdatesAs('RESP'); }
    public function testUpdateAsAdmin() { $this->_testUpdatesAs('ADMIN'); }
    public function testUpdateAsAdminPlus() { $this->_testUpdatesAs('ADMINP'); }
    public function testUpdateAsSuperAdmin() { $this->_testUpdatesAs('SUPER'); }
    private function _testUpdatesAs($role) {
    */
    /**
     * @dataProvider dataProviderRoles4
     */
    public function testUpdatesAs($role) {
        //$role="RESP";
        //@todo: test as USER
        if ($role == 'USER' || $role == 'USER_from_ldap') return;
        $this->authAs($role);

        // 1) Test qu'on peut modifier un materiel CREATED
        // Toutes les donnees passees sont modifiees
        $data = [
            'designation' => 'Matos Test 2 CREATED modified',
            //'sur_categorie_id' => 1,
            //'categorie_id' => 1,
            'materiel_administratif' => 0,
            //'materiel_technique' => 1,
            //'status' => 'CREATED',
            //'date_acquisition' => '19-04-2016',
            //'date_acquisition' => '19/04/2016',
            'date_acquisition' => '19/04/'.yyyy0,
            'date_reception' => '', // sinon FAUT qu'elle soit >= date_acquisition
            'nom_createur' => 'Pallier Etienne',
            'nom_modificateur' => 'Jean Administration',
            'nom_responsable' => 'Jacques Utilisateur',
            'email_responsable' => 'Jacques.Utilisateur@irap.omp.eu',
            'fournisseur_id' => 2
        ];
        $this->post('/materiels/edit/2', $data);
        $this->get('/materiels/index');
        $this->assertResponseContains("Matos Test 2 CREATED modified", "Le matériel CREATED édité n'a pas pu etre enregistré");
        
        // Le numero d'inventaire doit avoir été mis à jour avec la nouvelle année de la date d'achat
        $new_num_inventaire = 'TEST-'.yyyy0.'-0001';
        $this->assertResponseContains($new_num_inventaire, "Le numéro d'inventaire n'a pas été régénéré");
        $m = $this->Materiels->get(2);
        assert($m->numero_laboratoire == $new_num_inventaire, "Le numéro d'inventaire n'a pas été régénéré");
        
        
        // 2) Passe le status à VALIDATED
        $data = [
            'designation' => 'Matos Test 2 VALIDATED',
            //'sur_categorie_id' => 1,
            //'categorie_id' => 1,
            //'materiel_administratif' => 0,
            //'materiel_technique' => 1,
            'status' => 'VALIDATED',
            //'date_acquisition' => '19-04-2016',
            //'nom_createur' => 'Pallier Etienne',
            //'nom_modificateur' => 'Jean Administration',
            //'nom_responsable' => 'Jacques Utilisateur',
            //'email_responsable' => 'Jacques.Utilisateur@irap.omp.eu',
            //'fournisseur_id' => 2
        ];
        $this->post('/materiels/edit/2', $data);
        $this->get('/materiels/index');
        $this->assertResponseContains("Matos Test 2 VALIDATED", "Le matériel CREATED édité n'a pas pu etre passé à VALIDATED");
        
        // 3) Test qu'on NE PEUT PAS modifier un materiel VALIDATED (certains champs, a completer TODO:)
        $data = [
            'designation' => 'Matos Test 2 VALIDATED updated',
            //'sur_categorie_id' => 1,
            //'categorie_id' => 1,
            //'materiel_administratif' => 0,
            //'materiel_technique' => 1,
            //'status' => 'VALIDATED',
            //'date_acquisition' => '19-04-2016',
            //'nom_createur' => 'Pallier Etienne',
            //'nom_modificateur' => 'Jean Administration',
            //'nom_responsable' => 'Jacques Utilisateur',
            //'email_responsable' => 'Jacques.Utilisateur@irap.omp.eu',
            //'fournisseur_id' => 2
        ];
        $this->post('/materiels/edit/2', $data);
        $this->get('/materiels/index');
        /* Exception pour Superadmin ? NON
        if ($role=="SUPER") $this->assertResponseContains("Matos Test 2 VALIDATED updated", "Le matériel VALIDATED édité n'a pas pu etre enregistré");
        else $this->assertResponseNotContains("Matos Test 2 VALIDATED updated", "Un matériel VALIDATED ne devrait pas pouvoir être modifié");
        */
        $this->assertResponseNotContains("Matos Test 2 VALIDATED updated", "Un matériel VALIDATED ne devrait pas pouvoir être modifié");
        
        // 4) Test que un edit anormal ne fonctionne pas (erreur sur champ status)
        $data = [
            'designation' => 'Matos Test 9',
            /*
            'sur_categorie_id' => 1,
            'categorie_id' => 1,
            'materiel_administratif' => 0,
            'materiel_technique' => 1,
            */
            'status' => 'xxx',
            /*
            'date_acquisition' => '19-04-2016',
            'nom_createur' => 'Pallier Etienne',
            'nom_modificateur' => 'Jean Administration',
            'nom_responsable' => 'Jacques Utilisateur',
            'email_responsable' => 'Jacques.Utilisateur@irap.omp.eu',
            */
        ];
        $this->post('/materiels/edit/2', $data);
        $this->get('/materiels/index');
        $this->assertResponseNotContains("Matos Test 9", "Le matériel édité a pu etre enregistré alors que le statut n'est pas valide");
    }
    
    
    /*
     * ACTION "materiels/delete" : (D) Supprimer un materiel
     */
    
    /*
     * IV - ACTION Delete
     */
    
    /**
     * Test delete method
     *
     * @return void
     */
    public function STRICTER_matos_mustbeownedby_superadmin___testDelete() {
        $this->authSuperAdmin();

        //TODO: impossible de supprimer le matos 1, why ???
        //$this->post('/materiels/delete/1');
        $this->post('/materiels/delete/2');
        $this->get('/materiels/index');
        $this->assertResponseContains("Liste des matériels (6)", "Le matériel n'as pas été supprimé.");
        $this->assertResponseNotContains("Test 2", "Le matériel n'as pas été supprimé.");
        //$this->assertResponseNotContains("matos 1 USER", "Le matériel n'as pas été supprimé.");
    }
    
    
    /**
     * Test ACLEditAdmin
     *
     * @return void
     */
    public function testACLEditAdmin() {
        $this->authAdmin();
        
        $this->get('/materiels/edit/11');
        
        $this->assertResponseContains('EOTP', 'Le profil admin+ n\'a pas accès à la partie administrative sur le formulaire edit.');
    }
    
    /**
     * Test ACLDeleteUtilisateur
     *
     * @return void
     */
    public function testACLDeleteAsUtilisateur() {
        $this->authUtilisateur();
        
        $this->post('/materiels/delete/2');
        $this->get('/materiels/index');
        $this->assertResponseContains('Liste des matériels (6)', 'Le profil utilisateur a accès à la suppression, alors que le matériel ne lui appartient pas.');
        
        $this->post('/materiels/delete/11');
        $this->get('/materiels/index');
        $this->assertResponseContains('Liste des matériels (5)', 'Le profil utilisateur n\'a pas accès à la suppression, alors que le matériel lui appartient.');
    }
    
    /**
     * Test ACLDeleteAdmin
     *
     * @return void
     */
    public function STRICTER_testACLDeleteAsAdmin() {
        $this->authAdmin();
        
        //$nb = $this->nb_matos_in_fixture;
        $nb = nb_matos_in_fixture;
        
        // matos TBA => KO
        $this->post('/materiels/delete/13');
        $this->get('/materiels/index');
        $this->assertResponseContains("Liste des matériels ($nb)", 'Le profil admin(+) a accès à la suppression alors que le statut est TOBEARCHIVED.');
        
        // matos CREATED => KO
        $this->post('/materiels/delete/2');
        $this->get('/materiels/index');
        $this->assertResponseContains("Liste des matériels ($nb)", 'Le profil admin(+) a accès à la suppression alors que le statut est TOBEARCHIVED.');
        
        // matos ARCHIVED => OK
        $this->post('/materiels/delete/14');
        $nb--;
        $this->get('/materiels/index');
        $this->assertResponseContains("Liste des matériels ($nb)", "Le profil admin(+) n'a pas accès à la suppression d'un matériel ARCHIVED comme attendu !");
    }
    
    
    /**
     * Test action 'delete' avec tous les profils (roles)
     *
     * @return void
     *
     * @dataProvider dataProviderRoles4AndStatuses4
     */
    /*
    public function testDeleteForRole($user_role, $matos_status) {
        // Force le rechargement des entités materiel en BD (car on les modifie en cours de route)
        //AppController::forceReload();
        
        $this->d("*******************");
        $this->d("    ROLE = ".$user_role);
        $this->d("*******************");
        //$this->setUp();
        
        //$this->authSuperAdmin();
        $this->authAs($user_role);
        
        // POUR CHAQUE statut matériel :
        // CREATED, puis VALIDATED, puis TBA, puis ARCHIVED
        //foreach (['CREATED'] as $matos_status) {
        //foreach (['VALIDATED'] as $matos_status) {
        //foreach (['ARCHIVED'] as $matos_status) {
        ///////foreach (array_keys($this->STATUSES) as $matos_status) {
        
        $this->d("**** ".$matos_status." ****");
        // On recupère le tout 1er matos de la BD (fixture), peu importe ce que c'est car on va le modifier
        $matos = $this->Materiels->get(1);
        $matos->status = $matos_status;
        //debug($matos);
        
        // POUR CHAQUE numéro de matériel (0 ou 1) :
        // matos_CREATED0 puis matos_CREATED1 puis matos_VALIDATED0 puis matos_VALIDATED1 puis matos_TOBEARCHIVED0...
        foreach ([0,1] as $i) {
            
            $matos_name = "matos_${matos_status}$i";
            $this->d("* ".$matos_name." :");
            // i=0
            // Le materiel matos_XXXXXX0 doit appartenir à un utilisateur quelconque
            // et à un groupe (métier et thématique) quelconque
            if ($i==0) {
                $matos->nom_responsable = 'inconnu';
                $matos->nom_createur = 'inconnu';
                $matos->groupes_thematique_id = 2;
                $matos->groupes_metier_id = 2;
                //pr("modif matos pour i=0");
            }
            // i=1
            // Le materiel matos_XXXXXX1 doit appartenir à l'utilisateur qui a le role UTILISATEUR dans les tests
            // et au groupe (métier et thématique) de l'utilisateur utilisé pour le role RESPONSABLE dans les tests
            else {
                $matos->nom_responsable = 'user5 USER';
                $matos->nom_createur = 'user5 USER';
                $matos->groupes_thematique_id = 1;
                $matos->groupes_metier_id = 1;
                //pr("modif matos pour i=1");
            }
            //pr($matos->getDirty());
            //$fields_changed = ['nom_responsable', 'nom_createur'];
            //$matos->setDirty('*',true);
            //$matos->setDirty('nom_responsable',true);
            //$matos->setDirty('nom_createur',true);
            // On sauvegarde le matos modifié
            // pour pouvoir l'afficher avec /materiels/view/1
            //pr("nom bef is ".$matos->nom_responsable);
            if (! $this->Materiels->save($matos))
                throw new \Exception("La sauvegarde du materiel modifié ne se fait pas !!!");
            /S
             $m = $this->Materiels->get(1);
             pr("new nom is ".$m->nom_responsable);
             S/
            
            // Et maintenant, le test qui tue
            $this->post('/materiels/delete/1');
            $authorized = $this->isAuthorizedAction('delete', $role, $matos_status, $i);
            $this->d("isAuthorizedAction $action pour $role sur materiel $matos_status,$i ? : " . (int)$authorized);
            $content = "Supprimer ce matériel";
            //$content = "<i class=icon-pencil></i> Editer ce matériel";
            $elem = "Editer";
            $this->assertResponseOk();
            if ($authorized)
                $this->assertResponseContains($content, "La vue détaillée du matériel (/materiels/view/1) ne contient pas de bouton $elem comme attendu !");
                else
                    $this->assertResponseNotContains($content, "La vue du matériel (/materiels/view/1) contient le bouton $elem, alors qu'elle ne devrait PAS !");
                    
            $action = 'delete';
            $authorized = $this->isAuthorizedAction($action, $role, $matos_status, $i);
            $this->d("isAuthorizedAction $action pour $role sur materiel $matos_status,$i ? : ". (int)$authorized);
            //$content = "<i class=icon-trash></i> Supprimer ce matériel";
            $content = "Supprimer ce matériel";
            $elem = "Supprimer";
            $this->assertResponseOk();
            if ($authorized)
                $this->assertResponseContains($content, "La vue du matériel (/materiels/view/1) ne contient pas de bouton $elem attendu !");
                else
                    $this->assertResponseNotContains($content, "La vue du matériel (/materiels/view/1) contient le bouton $elem, alors qu'elle ne devrait PAS !");
                
        } // matos num : 0,1
        
        //////} // matos status : CREATED, VALIDATED, ...
        
    } // _testViewForRole(role)
    */
    
    
    /*
     * V - OTHER ACTIONS
     */
    
    /**
     * Test find method
     *
     * @return void
     */
    private function get_specific_fields() {
        return [
            //'s_designation' => 'Test',
            's_designation' => '',
            's_matostype' => '',
            's_sur_categorie_id' => '',
            's_categorie_id' => '',
            's_sous_categorie_id' => '',
            's_status' => '',
            's_groupes_metier_id' => '',
            's_groupes_thematique_id' => '',
            's_numero_commande' => '',
            's_numero_laboratoire' => '',
            's_organisme_id' => '',
            's_nom_responsable' => '',
            's_numero_inventaire_organisme' => '',
            's_numero_inventaire_old' => '',
            's_date_acquisition' => '',
            's_periode_acquisition1' => '',
            's_periode_acquisition2' => '',
            's_prix_ht' => '',
            's_prix_ht_sup' => '',
            's_prix_ht_inf' => '',
            's_fournisseur_id' => '',
            's_salle' => ''
        ];
        
    }
    public function testFind() {
        $this->authSuperAdmin();

        $dataSearch = $this->get_specific_fields();

        /* 
         * 1. Test sans aucun champ
         */
        $this->get('/materiels/find');
        $this->assertResponseContains("Aucun résultats pour cette recherche.", "Le contenu de la recherche devrait être vide.");

        
        /*
         * 2. Test champ global "s_all_2" dans le menu latéral de gauche
         */
        // Recherche en majuscules
        //$this->post( '/materiels/find', ['s_all_2' => 'TEST-2020-0002'] ); //+4
        $this->post( '/materiels/find', ['s_all_2' => 'TEST-'.yyyy2.'-0002'] );
        $this->assertResponseContains("Résultats (1)", "Le nb de materiels pour la recherche générale du menu latéral est incorrect.");
        // Recherche en minuscules
        //$this->post( '/materiels/find', ['s_all_2' => 'test-2020-0002'] ); //+4
        $this->post( '/materiels/find', ['s_all_2' => 'test-'.yyyy2.'-0002'] ); //+4
        $this->assertResponseContains("Résultats (1)", "Le nb de materiels pour la recherche générale du menu latéral est incorrect.");
        
        
        /*
         * 3. Test champ général "s_all" en haut du formulaire
         */
        //$this->post( '/materiels/find', ['s_all' => 'TEST-2020-0002'] ); //+4
        $this->post( '/materiels/find', ['s_all_2' => 'TEST-'.yyyy2.'-0002'] );
        $this->assertResponseContains("Résultats (1)", "Le nb de materiels pour la recherche générale du formulaire est incorrect.");

        $this->post( '/materiels/find', ['s_all' => 'Fournisseur'] );
        $this->assertResponseContains("Résultats (7)", "Le nb de materiels pour la recherche générale du formulaire est incorrect.");
        
        $this->post( '/materiels/find', ['s_all' => 'Fournisseur1'] );
        $this->assertResponseContains("Résultats (4)", "Le nb de materiels pour la recherche générale du formulaire est incorrect.");
        $this->post( '/materiels/find', ['s_all' => 'Fournisseur2'] );
        $this->assertResponseContains("Résultats (3)", "Le nb de materiels pour la recherche générale du formulaire est incorrect.");

        $this->post( '/materiels/find', ['s_all' => 'Fournisseur Test'] );
        $this->assertResponseContains("Résultats (7)", "Le nb de materiels pour la recherche générale du formulaire est incorrect.");

        // les matériels trouvés doivent contenir "Fournisseur" ET "Test" ET "(C)"
        $this->post( '/materiels/find', ['s_all' => 'Fournisseur Test (C)'] );
        $this->assertResponseContains("Résultats (3)", "Le nb de materiels pour la recherche générale du formulaire est incorrect.");
        
        
        /*
         * 4. Recherche dans les champs spécifiques du formulaire
         */

        // 4.1 Test champs individuels (un seul champ)
        
        // - Test champ designation
        
        // -- un mot
        // --- tel quel
        $dataSearch['s_designation'] = 'Test';
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (6)", "Le nb de materiels pour la recherche par désignation est incorrect.");
        // --- en minuscules
        $dataSearch['s_designation'] = 'test';
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (6)", "Le nb de materiels pour la recherche par désignation est incorrect.");
        // --- en majuscules
        $dataSearch['s_designation'] = 'TEST';
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (6)", "Le nb de materiels pour la recherche par désignation est incorrect.");
        
        // -- N mots
        $dataSearch['s_designation'] = 'Test TBA'; // = contient "Test" ET "TBA" => devrait trouver "Test 13 (TBA)"
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (1)", "Le nb de materiels pour la recherche par désignation est incorrect.");
        $dataSearch['s_designation'] = 'Test 13 TBA'; // = contient "Test" ET "TBA" => devrait trouver "Test 13 (TBA)"
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (1)", "Le nb de materiels pour la recherche par désignation est incorrect.");
        $dataSearch['s_designation'] = '';
        
        // - Test champ numero_laboratoire
        //$dataSearch['s_numero_laboratoire'] = 'TEST-2020-0003'; //+4
        $dataSearch['s_numero_laboratoire'] = 'TEST-'.yyyy1.'-0002';
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (1)", "Le nb de materiels pour la recherche par numero de laboratoire est incorrect.");
        $dataSearch['s_numero_laboratoire'] = '';

        // - Test champ status
        $dataSearch['s_status'] = 'CREATED';
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (3)", "Le nb de materiels pour la recherche par statut est incorrect.");
        $dataSearch['s_status'] = '';

        // - Test champ date_acquisition
        //$dataSearch['s_date_acquisition'] = '2016-05-11';
        $dataSearch['s_date_acquisition'] = yyyy2mmdd1;
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (1)", "Le nb de materiels pour la recherche par date d'acquisition est incorrect.");
        $dataSearch['s_date_acquisition'] = yyyy2mmdd2;
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (4)", "Le nb de materiels pour la recherche par date d'acquisition est incorrect.");
        $dataSearch['s_date_acquisition'] = '';
        
        // - Test champ fournisseur_id
        $dataSearch['s_fournisseur_id'] = 1;
        //$dataSearch['s_date_acquisition'] = '2016-05-11';
        $dataSearch['s_date_acquisition'] = yyyy2mmdd2;
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (3)", "Le nb de materiels pour la recherche par fournisseur_id est incorrect.");
        $dataSearch['s_date_acquisition'] = '';
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (4)", "Le nb de materiels pour la recherche par fournisseur_id est incorrect.");
        $dataSearch['s_fournisseur_id'] = '';
        $dataSearch['s_date_acquisition'] = '';
        
        //- Test champ salle
        /* 
         * $dataSearch['s_salle'] = 'I203';
         * $this->post('/materiels/find', $dataSearch);
         * $this->assertResponseContains("Résultats (2)", "Le nb de materiels pour la recherche par detaille lieu est incorrect.");
        */
        
        
        //
        // Test sur Période de temps (intervalle)
        //
        
        // - Test [champ periode_acquisition1 - +infini]
        
        //$dataSearch['s_periode_acquisition1'] = '2015-01-01';
        $dataSearch['s_periode_acquisition1'] = yyyy1mmdd1; // search [yyyy1mmdd1 - ]
        $this->post('/materiels/find', $dataSearch);
        //$this->assertResponseContains("Résultats (6)", "Le nb de materiels pour la recherche par debut de periode d'acquisition est incorrect.");
        $this->assertResponseContains("Résultats (1)", "Le nb de materiels pour la recherche par debut de periode d'acquisition est incorrect.");

        $dataSearch['s_periode_acquisition1'] = yyyy1mmdd2; // search [yyyy1mmdd2 - ]
        $this->post('/materiels/find', $dataSearch);
        //$this->assertResponseContains("Résultats (6)", "Le nb de materiels pour la recherche par debut de periode d'acquisition est incorrect.");
        $this->assertResponseContains("Résultats (2)", "Le nb de materiels pour la recherche par debut de periode d'acquisition est incorrect.");
        
        $dataSearch['s_periode_acquisition1'] = yyyy2mmdd2; // search [yyyy2mmdd2 - ]
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains('Résultats ('.nb_matos_in_fixture.')', "Le nb de materiels pour la recherche par debut de periode d'acquisition est incorrect.");

        $dataSearch['s_periode_acquisition1'] = yyyy2mmdd1; // search [yyyy2mmdd1 - ]
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains('Résultats (3)', "Le nb de materiels pour la recherche par debut de periode d'acquisition est incorrect.");
        
        $dataSearch['s_periode_acquisition1'] = yyyy0mmdd1; // search [yyyy0mmdd1 - ]
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains('Résultats (0)', "Le nb de materiels pour la recherche par debut de periode d'acquisition est incorrect.");
        
        // - Test [champ periode_acquisition1 - champ periode_acquisition2]
        
        //$dataSearch['s_periode_acquisition2'] = '2016-01-01';
        $dataSearch['s_periode_acquisition1'] = yyyy2mmdd2;
        $dataSearch['s_periode_acquisition2'] = yyyy1mmdd1; // search [yyyy2mmdd2 - yyyy1mmdd1] (plus ancien au plus récent)
        $this->post('/materiels/find', $dataSearch);
        //$this->assertResponseContains("Résultats (1)", "Le nb de materiels pour la recherche par intervalle entre la periode d'acquisition (debut) et la periode d'acquisition (fin) est incorrect.");
        $this->assertResponseContains('Résultats ('.nb_matos_in_fixture.')', "Le nb de materiels pour la recherche par intervalle entre la periode d'acquisition (debut) et la periode d'acquisition (fin) est incorrect.");
        
        $dataSearch['s_periode_acquisition1'] = yyyy1mmdd1;
        $dataSearch['s_periode_acquisition2'] = yyyy2mmdd2; // search [yyyy1mmdd1 - yyyy2mmdd2]
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains('Résultats (0)', "Le nb de materiels pour la recherche par intervalle entre la periode d'acquisition (debut) et la periode d'acquisition (fin) est incorrect.");
        
        $dataSearch['s_periode_acquisition1'] = yyyy2mmdd2;
        $dataSearch['s_periode_acquisition2'] = yyyy2mmdd2; // search [yyyy2mmdd2 - yyyy2mmdd2]
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains('Résultats (4)', "Le nb de materiels pour la recherche par intervalle entre la periode d'acquisition (debut) et la periode d'acquisition (fin) est incorrect.");

        $dataSearch['s_periode_acquisition1'] = yyyy2mmdd1;
        $dataSearch['s_periode_acquisition2'] = yyyy1mmdd2; // search [yyyy2mmdd1 - yyyy1mmdd2]
        $this->post('/materiels/find', $dataSearch);
        $nb = nb_matos_in_fixture - 4 - 1;
        $this->assertResponseContains('Résultats ('.$nb.')', "Le nb de materiels pour la recherche par intervalle entre la periode d'acquisition (debut) et la periode d'acquisition (fin) est incorrect.");
        
        // - Test [-infini - champ periode_acquisition2]
        
        $dataSearch['s_periode_acquisition1'] = '';
        $dataSearch['s_periode_acquisition2'] = yyyy0mmdd1; // search [ - yyyy0mmdd1] // jusqu'a l'infini
        $this->post('/materiels/find', $dataSearch);
        //$this->assertResponseContains("Résultats (2)", "Le nb de materiels pour la recherche par fin de periode d'acquisition est incorrect.");
        $this->assertResponseContains('Résultats ('.nb_matos_in_fixture.')', "Le nb de materiels pour la recherche par fin de periode d'acquisition est incorrect.");

        $dataSearch['s_periode_acquisition2'] = yyyy1mmdd1; // search [ - yyyy1mmdd1] // jqau plus récent
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains('Résultats ('.nb_matos_in_fixture.')', "Le nb de materiels pour la recherche par fin de periode d'acquisition est incorrect.");

        $dataSearch['s_periode_acquisition2'] = yyyy1mmdd2; // search [ - yyyy1mmdd2]
        $this->post('/materiels/find', $dataSearch);
        $nb = nb_matos_in_fixture - 1;
        $this->assertResponseContains('Résultats ('.$nb.')', "Le nb de materiels pour la recherche par fin de periode d'acquisition est incorrect.");

        $dataSearch['s_periode_acquisition2'] = yyyy2mmdd1; // search [ - yyyy2mmdd1]
        $this->post('/materiels/find', $dataSearch);
        $nb = 5;
        $this->assertResponseContains('Résultats ('.$nb.')', "Le nb de materiels pour la recherche par fin de periode d'acquisition est incorrect.");

        $dataSearch['s_periode_acquisition2'] = yyyy2mmdd2; // search [ - yyyy2mmdd2] // jqau plus ancien
        $this->post('/materiels/find', $dataSearch);
        $nb = 5 - 1;
        $this->assertResponseContains('Résultats ('.$nb.')', "Le nb de materiels pour la recherche par fin de periode d'acquisition est incorrect.");
        
        $dataSearch['s_periode_acquisition2'] = '';

        
        //
        // Test sur prix
        //
        
        // - Test champ prix_ht
        $dataSearch['s_prix_ht'] = '50';
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (1)", "Le nb de materiels pour la recherche par prix ht est incorrect (v1).");
        $dataSearch['s_prix_ht'] = '';
        // - Meme test mais avec autres champs
        $dataSearch['s_prix_ht_sup'] = '50'; // >= 50
        $dataSearch['s_prix_ht_inf'] = '50'; // <= 50
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (1)", "Le nb de materiels pour la recherche par prix ht est incorrect (v2).");
        $dataSearch['s_prix_ht_inf'] = '';
        $dataSearch['s_prix_ht_sup'] = '';
        $dataSearch['s_prix_ht'] = '75';
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (4)", "Le nb de materiels pour la recherche par prix ht est incorrect (v1).");
        $dataSearch['s_prix_ht'] = '';
        
        // - Test champ prix_ht_sup
        $dataSearch['s_prix_ht_sup'] = '30'; // >= 30
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (6)", "Le nb de materiels pour la recherche par prix ht superieur est incorrect.");
        $dataSearch['s_prix_ht_sup'] = '';
        // - Test champ prix_ht_inf
        $dataSearch['s_prix_ht_inf'] = '70'; // <=70
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (2)", "Le nb de materiels pour la recherche par prix ht inferieur est incorrect.");
        $dataSearch['s_prix_ht_inf'] = '';
        // - Test champ prix_ht_inf et sup
        $dataSearch['s_prix_ht_sup'] = '30'; // >= 30
        $dataSearch['s_prix_ht_inf'] = '70'; // <=70
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (1)", "Le nb de materiels pour la recherche par prix ht inf et sup est incorrect.");
        $dataSearch['s_prix_ht_sup'] = '25'; // >= 30
        $dataSearch['s_prix_ht_inf'] = '75'; // <=75
        $this->post('/materiels/find', $dataSearch);
        $this->assertResponseContains("Résultats (6)", "Le nb de materiels pour la recherche par prix ht inf et sup est incorrect.");
        $dataSearch['s_prix_ht_inf'] = '';
        $dataSearch['s_prix_ht_sup'] = '';
        
        // 4.2 Test champs multiples (plusieurs champs à la fois)
        //$dataSearch = $this->get_specific_fields();
        
    }

    /**
     * Test addReadSuivisMateriel
     *
     * @return void
     */
    private function _testAddReadEntitiesMateriel($entity_name, $nb_entities_in_fixture, $data) {
        $entities_name = $entity_name.'s';
        $nb = $nb_entities_in_fixture;
        
        $this->authSuperAdmin();
        
        //$this->get('/materiels/view/1');
        $this->get('/materiels/view/3');
        //$this->assertResponseContains("Suivi(s) du matériel (1)", "Le nb de suivis renvoyé pour ce matériel est incorrect.");
        $this->assertResponseContains(ucfirst($entity_name)."(s) du matériel ($nb)", "Le nb de $entities_name renvoyé pour ce matériel est incorrect (1).");
        
        //$this->post('/suivis/add/1', $dataSuivi1);
        //$this->post('/suivis/add/1', $dataSuivi2);
        $this->post("/$entities_name/add/3", $data); $nb++;
        $this->post("/$entities_name/add/3", $data); $nb++;
        
        //$this->get('/materiels/view/1');
        $this->get('/materiels/view/3');
        $this->assertResponseContains(ucfirst($entity_name)."(s) du matériel ($nb)", "Le nb de $entities_name renvoyé pour ce matériel est incorrect (2).");
    }
    
    /**
     * Test addReadSuivisMateriel
     *
     * @return void
     */
    public function STRICTER_testAddReadSuivisMateriel() {
        $dataSuivi1 = [
            //'materiel_id' => 1, // created
            'materiel_id' => 3, // validated
            'date_controle' => '2016-04-19',
            'date_prochain_controle' => '2016-04-19',
            'type_suivi_id' => 1,
            'groupes_metier_id' => 1,
            'groupes_thematique_id' => 1,
            'organisme' => 'Lorem ipsum dolor sit amet',
            'frequence' => 1,
            'type_frequence' => '/ Jours',
            'commentaire' => 'Lorem ipsum dolor sit amet',
            'nom_createur' => 'Lorem ipsum dolor sit amet',
            'nom_modificateur' => 'Lorem ipsum dolor sit amet',
            'created' => '2016-04-19 09:09:28',
            'modified' => '2016-04-19 09:09:28'
        ];
        $this->_testAddReadEntitiesMateriel('suivi', 1, $dataSuivi1);

        /*
        $dataSuivi2 = [
            'materiel_id' => 3,
            'date_controle' => '2016-04-19',
            'date_prochain_controle' => '2016-04-19',
            'type_suivi_id' => 1,
            'groupes_metier_id' => 1,
            'groupes_thematique_id' => 1,
            'organisme' => 'Lorem ipsum dolor sit amet',
            'frequence' => 1,
            'type_frequence' => '/ Jours',
            'commentaire' => 'Lorem ipsum dolor sit amet',
            'nom_createur' => 'Lorem ipsum dolor sit amet',
            'nom_modificateur' => 'Lorem ipsum dolor sit amet',
            'created' => '2016-04-19 09:09:28',
            'modified' => '2016-04-19 09:09:28'
        ];
        
        $this->authSuperAdmin();
        
        //$this->get('/materiels/view/1');
        $this->get('/materiels/view/3');
        $this->assertResponseContains("Suivi(s) du matériel (1)", "Le nb de suivis renvoyé pour ce matériel est incorrect.");
        
        //$this->post('/suivis/add/1', $dataSuivi1);
        //$this->post('/suivis/add/1', $dataSuivi2);
        $this->post('/suivis/add/3', $dataSuivi1);
        $this->post('/suivis/add/3', $dataSuivi1);
        
        //$this->get('/materiels/view/1');
        $this->get('/materiels/view/3');
        //$this->assertResponseContains("Suivi(s) du matériel (3)", "Le nb de suivis renvoyé pour ce matériel est incorrect.");
        */
    }

    /**
     * Test addReadEmpruntsMateriel
     *
     * @return void
     */
    public function STRICTER_testAddReadEmpruntsMateriel() {

        $dataEmprunt1 = [
            //'materiel_id' => 1, // created
            'materiel_id' => 3, // validated
            'date_emprunt' => '2016-04-19',
            'date_retour_emprunt' => '2016-04-19',
            'emprunt_interne' => 1,
            'laboratoire' => 'Lorem ipsum dolor sit amet',
            'site_id' => 1, // Roche
            'e_lieu_detail' => 'Lorem ipsum dolor sit amet',
            'nom_emprunteur' => 'Lorem ipsum dolor sit amet',
            'email_emprunteur' => 'Lorem ipsum dolor sit amet',
            'tel' => 'Lorem ipsum dolor ',
            'commentaire' => 'Lorem ipsum dolor sit amet',
            'nom_createur' => 'Lorem ipsum dolor sit amet',
            'nom_modificateur' => 'Lorem ipsum dolor sit amet',
            'created' => '2016-04-19 09:09:26',
            'modified' => '2016-04-19 09:09:26'
        ];
        $this->_testAddReadEntitiesMateriel('emprunt', 1, $dataEmprunt1);

        /*
        $dataEmprunt2 = [
            'materiel_id' => 3,
            'date_emprunt' => '2016-04-19',
            'date_retour_emprunt' => '2016-04-19',
            'emprunt_interne' => 0,
            'laboratoire' => 'Lorem ipsum dolor sit amet',
            'site_id' => 1, // Roche
            'e_lieu_detail' => 'Lorem ipsum dolor sit amet',
            'nom_emprunteur' => 'Lorem ipsum dolor sit amet',
            'email_emprunteur' => 'Lorem ipsum dolor sit amet',
            'tel' => 'Lorem ipsum dolor ',
            'commentaire' => 'Lorem ipsum dolor sit amet',
            'nom_createur' => 'Lorem ipsum dolor sit amet',
            'nom_modificateur' => 'Lorem ipsum dolor sit amet',
            'created' => '2016-04-19 09:09:26',
            'modified' => '2016-04-19 09:09:26'
        ];

        $this->authSuperAdmin();

        $this->post('/emprunts/add/3', $dataEmprunt1);
        $this->post('/emprunts/add/3', $dataEmprunt2);

        $this->get('/materiels/view/3');
        $this->assertResponseContains("Emprunt(s) du matériel (3)", "Le nb d'emprunt renvoyé pour ce matériel est incorrect.");
        */
    }

    /**
     * NE FONCTIONNE PAS
     * Test addCopieMateriel
     *
     * @return void public function testAddCopieMateriel() {
     *         $this->authUser();
     *         $data = [
     *         'designation' => 'Test 14',
     *         'sur_categorie_id' => 1,
     *         'categorie_id' => 1,
     *         'materiel_administratif' => 0,
     *         'materiel_technique' => 1,
     *         'status' => 'CREATED',
     *         'date_acquisition' => '2016-04-16'];
     *         $this->post('/materiels/add/13', $data);
     *         $this->get('/materiels/view/14');
     *         $this->assertResponseContains("Jesus", "La copie du materiel ne se fait pas correctement.");
     *         $this->assertResponseContains("TEST COPIE MATERIEL", "La copie du materiel ne se fait pas correctement.");
     *         }
     */

    /**
     * Test updateStatutCreated
     *
     * @return void
     */
    public function testUpdateStatutCreated() {
        $this->authSuperAdmin();

        $this->post('/materiels/status-validated/11');
        $this->get('/materiels/view/11');

        $this->assertResponseContains('VALIDATED', "La validation du materiel ne se fait pas correctement.");
    }

    /**
     * Test updateStatutValidated
     *
     * @return void
     */
    public function testUpdateStatutValidated() {
        $this->authSuperAdmin();

        //$this->post('/materiels/status-to-be-archived/12');
        $this->post('/materiels/status-tobearchived/12');
        $this->get('/materiels/view/12');

        $this->assertResponseContains('TOBEARCHIVED', "La demande d'archivage du materiel ne se fait pas correctement.");
    }

    /**
     * Test updateStatutToBeArchived
     *
     * @return void
     */
    public function testUpdateStatutToBeArchived() {
        $this->authAdmin();

        $this->post('/materiels/status-archived/13');
        $this->get('/materiels/view/13');

        $this->assertResponseNotContains('TOBEARCHIVED', "L'archivage du materiel ne se fait pas correctement.");
    }

    /**
     * Test UpdatePlaceEtiquetteMateriel
     *
     * @return void
     */
    public function testUpdatePlaceEtiquetteMateriel() {
        $this->authSuperAdmin();
        // on prend un materiel VALIDATED
        //$id=11;
        $id=3;
        $this->post("/materiels/set-label-is-placed/$id/view"); // ou setLabelIsPlaced (marche pareil)
        $this->get("/materiels/view/$id");
        $this->assertResponseContains(
            '<TR> <TD><strong>Etiquette placée</strong></TD> <TD style="color: green">Oui</TD> </TR>', 
            "Le placement de l'étiquette sur le materiel ne se fait pas correctement."
        );
        //$this->assertResponseContains('Etiquette collée</strong></TD> <TD>Oui', "Le placement de l'étiquette sur le materiel ne se fait pas correctement.");
    }

    /**
     * Test UpdateNotPlaceEtiquetteMateriel
     *
     * @return void
     */
    public function testUpdateNotPlaceEtiquetteMateriel() {
        $this->authSuperAdmin();
        $this->post('/materiels/set-label-is-not-placed/12/view');
        $this->get('/materiels/view/12');
        $this->assertResponseContains(
            //'<TR> <TD><strong>Etiquette collée</strong></TD> <TD style="color: #FF0000">Non</TD> </TR>',
            '<TR> <TD><strong>Etiquette placée</strong></TD> <TD style="color: red">Non</TD> </TR>', 
            "La déclaration d'une étiquette non collée sur le materiel ne se fait pas correctement.");
        //$this->assertResponseContains('Etiquette collée</strong></TD> <TD>Non', "L'enlevement de l'étiquette sur le materiel ne se fait pas correctement.");
    }

    /**
     * Test UpdateStatusSelectedMateriel
     *
     * @return void
     */
    public function testUpdateStatusSelectedMateriels() {
        $this->authSuperAdmin();
        //$this->authAdmin();
        $this->post('/materiels/execActions', ['updateSelectedStatus' => 'true', 'what' => 'CREATED', 11 => '1', 12 => '1', 13 => '1']);
        
        $this->get('/materiels/view/11');
        $this->assertResponseContains('VALIDATED', "(11) La mise à jour de plusieurs statuts sur le materiel ne se fait pas correctement.");
        $this->assertResponseNotContains('CREATED', "(11) La mise à jour de plusieurs statuts sur le materiel ne se fait pas correctement.");
        $this->assertResponseNotContains('TOBEARCHIVED', "(11) La mise à jour de plusieurs statuts sur le materiel ne se fait pas correctement.");
        $this->assertResponseNotContains('ARCHIVED', "(11) La mise à jour de plusieurs statuts sur le materiel ne se fait pas correctement.");
        
        $this->get('/materiels/view/12');
        $this->assertResponseContains('VALIDATED', "(12) La mise à jour de plusieurs statuts sur le materiel ne se fait pas correctement.");
        $this->assertResponseNotContains('CREATED', "(12) La mise à jour de plusieurs statuts sur le materiel ne se fait pas correctement.");
        $this->assertResponseNotContains('TOBEARCHIVED', "La mise à jour de plusieurs statuts sur le materiel ne se fait pas correctement.");
        $this->assertResponseNotContains('ARCHIVED', "La mise à jour de plusieurs statuts sur le materiel ne se fait pas correctement.");
        
        $this->get('/materiels/view/13');
        $this->assertResponseContains('VALIDATED', "(13) La mise à jour de plusieurs statuts sur le materiel ne se fait pas correctement.");
        $this->assertResponseNotContains('CREATED', "(13) La mise à jour de plusieurs statuts sur le materiel ne se fait pas correctement.");
        $this->assertResponseNotContains('TOBEARCHIVED', "La mise à jour de plusieurs statuts sur le materiel ne se fait pas correctement.");
        $this->assertResponseNotContains('ARCHIVED', "La mise à jour de plusieurs statuts sur le materiel ne se fait pas correctement.");
    }


    /**
     * Test ACLEditUtilisateur
     *
     * @return void
     */
    public function testACLEditUtilisateur() {
        // $this->authAdmin();
        $this->authUtilisateur();

        // $this->get('/materiels/edit/12');
        // $this->assertResponseNotContains('Test 12', 'Le profil utilisateur a accès au formulaire edit, alors que le matériel ne lui appartient pas.');
        // $this->assertResponseContains('Test 12', 'Le profil utilisateur a accès au formulaire edit, alors que le matériel ne lui appartient pas.');
        $this->get('/materiels/view/11');
        $this->assertResponseContains('Informations', 'La page view n\'existe pas');

        $this->get('/materiels/edit/11');
        //$this->assertResponseContains('Editer', 'La page edit n\'existe pas');
        $this->assertResponseContains('Éditer', 'La page edit n\'existe pas');
        $this->assertResponseContains('Test 11', 'Le profil utilisateur n\'a pas accès au formulaire edit, alors que le matériel lui appartient.');
        // (EP 17/7/19 changed)
        //$this->assertResponseNotContains('EOTP', 'Le profil utilisateur a accès à la partie administrative sur le formulaire edit.');
        $this->assertResponseContains('EOTP', 'Le profil utilisateur doit avoir accès à la partie administrative sur le formulaire edit (mais en read only).');
    }


    /**
     * Test ACLChangeStatutUtilisateur
     *
     * @return void
     */
    public function testACLChangeStatutUtilisateur() {
        $this->authUtilisateur();

        $this->post('/materiels/status-validated/11');
        $this->get('/materiels/view/11');
        $this->assertResponseContains('CREATED', "La validation du materiel se fait avec un profil utilisateur.");

        $this->post('/materiels/status-tobearchived/12');
        $this->get('/materiels/view/12');
        $this->assertResponseContains('VALIDATED', "La demande d'archivage du materiel se fait avec un profil utilisateur.");

        $this->post('/materiels/status-archived/13');
        $this->get('/materiels/view/13');
        $this->assertResponseContains('TOBEARCHIVED', "L'archivage du materiel se fait avec un profil utilisateur.");
    }

    /**
     * Test ACLChangeStatutAdmin
     *
     * @return void
     */
    public function testACLChangeStatutAdmin() {
        $this->authAdmin();

        $this->post('/materiels/status-validated/11');
        $this->get('/materiels/view/11');
        $this->assertResponseContains('VALIDATED', "La validation du materiel ne se fait pas correctement avec un profil admin+.");

        $this->post('/materiels/status-tobearchived/12');
        $this->get('/materiels/view/12');
        $this->assertResponseContains('TOBEARCHIVED', "La demande d'archivage du materiel ne se fait pas correctement avec un profil admin+.");

        $this->post('/materiels/status-archived/13');
        $this->get('/materiels/view/13');
        $this->assertResponseContains('ARCHIVED', "L'archivage du materiel ne se fait pas correctement avec un profil admin+.");
    }

    /**
     * Test ACLIndexResponsable
     *
     * @return void
     */
    public function testACLIndexResponsable() {
        $this->authResponsable();

        $this->get('/materiels/index?GM=1');
        $this->assertResponseContains('Liste des matériels (5)', "La liste des materiels selon le groupe métier ne s'affiche pas correctement.");

        $this->get('/materiels/index?GMV=1');
        $this->assertResponseContains('Liste des matériels (3)', "La liste des materiels selon le groupe métier et CREATED ne s'affiche pas correctement.");
    }

    /**
     * Test MaterielPanne
     *
     * @return void
     */
    public function testMaterielPanne() {
        $this->authSuperAdmin();

        $this->get('/materiels/view/2');
        $this->assertResponseNotContains("(HORS SERVICE)", "Le matériel est hors-service par défaut.");

        $data = [
            'designation' => 'Test 6',
            'sur_categorie_id' => 1,
            'categorie_id' => 1,
            'materiel_administratif' => 0,
            'materiel_technique' => 1,
            'status' => 'CREATED',
            //'date_acquisition' => '19-04-2016',
            //'date_acquisition' => '19/04/2016',
            'date_acquisition' => '19/04/'.yyyy0,
            'date_reception' => '', // sinon FAUT qu'elle soit >= date_acquisition            
            'nom_createur' => 'Pallier Etienne',
            'nom_modificateur' => 'Jean Administration',
            'nom_responsable' => 'Jacques Utilisateur',
            'email_responsable' => 'Jacques.Utilisateur@irap.omp.eu',
            'hors_service' => 1
        ];

        $this->post('/materiels/edit/2', $data);
        $this->get('/materiels/view/2');
        $this->assertResponseContains("(HORS SERVICE)", "Le matériel n'est pas hors-service comme demandé.");
    }
    
    
/**
 * TEST IMPOSSIBLE CAR FONCTION DU CONTROLLER FINI PAR EXIT()
 * Test exportFind
 *
 * @return void public function testExportFind() {
 *         $this->authUser();
 *         $csv = 'id;Designation;Sur-categorie;Categorie;Sous-categorie;"Numero interne";Description;Organisme;"Mat. administratif";"Mat. technique";Statut;"Date d\'acquisition";"Date de reception";Fournisseur;"Prix HT";EOTP;"Numero de commande";"Code comptable";"Numero de serie";"Grp. thematique";"Grp. metier";"Numero inventaire organisme";"Ancien Numero inventaire";"Site stockage";"Nom responsable";"Email responsable"
 *         12;"Test 12";"Lorem ipsum dolor sit amet";"Lorem ipsum dolor sit amet";"Lorem ipsum dolor sit amet";TEST-2016-0012;"Lorem ipsum dolor sit amet, aliquet feugiat. Convallis morbi fringilla gravida, phasellus feugiat dapibus velit nunc, pulvinar eget sollicitudin venenatis cum nullam, vivamus ut a sed, mollitia lectus. Nulla vestibulum massa neque ut et, id hendrerit sit, feugiat in taciti enim proin nibh, tempor dignissim, rhoncus duis vestibulum nunc mattis convallis.";"Lorem ipsum dolor sit amet";1;1;VALIDATED;11/05/2016;19/04/2016;"Lorem ipsum dolor sit amet";75;"Lorem ipsum dolor sit amet";"Lorem ipsum dolor sit amet";"Lorem ipsum dolor sit amet";"Lorem ipsum dolor sit amet";"Lorem ipsum dolor sit amet";"Lorem ipsum dolor sit amet";"Lorem ipsum dolor sit amet";"Lorem ipsum dolor sit amet";"Lorem ipsum dolor sit amet-Lorem ipsum dolor sit amet";"Lorem ipsum dolor sit amet";"Lorem ipsum dolor sit amet"';
 *         $materiel = $this->Materiels->get('12');
 *         $data = [ 'result' => [$materiel]];
 *         $this->session($data);
 *         $this->put('/materiels/export/search');
 *         //$this->assertTextContains(, $csv);
 *         $this->assertResponseContains($csv, 'L\'export CSV de la recherche ne fonctionne pas correctement');
 *         }
 *         /** TEST IMPOSSIBLE CAR FONCTION DU CONTROLLER FINI PAR EXIT()
 *         Test exportAll
 * @return void public function testExportAll() {
 *         $this->authUser();
 *         $this->>post('materiels/export', ['exportAll' => 'test']);
 *         $this->assertResponseContains("fdsf");
 *         }
 *         /** TEST IMPOSSIBLE CAR FONCTION DU CONTROLLER FINI PAR EXIT()
 *         Test generateRubanMateriel
 * @return void public function testGenerateRubanMateriel() {
 *         $this->authUser();
 *         }
 */
    
    
/*
 * *********************************************
 * *********************************************
 * *********************************************
 * *********************************************
 * 
 * *** TEST GENERIQUE DES ACTIONS ET DES VUES (surtout view et index) ***
 * 
 * *********************************************
 * *********************************************
 * *********************************************
 * *********************************************
 * 
 */    
    
    /**
     * (EP 20200625)
     * 
     * Test des vues view.ctp et index.ctp avec tous les profils (roles U,R,A,S)
     * ET tous les materiels de la BD de test (fixture) 
     * 
     * Méthode 2 :
     * Test (générique) des vues index et view de Materiels (/materiels/index et /view) 
     * qui teste le CONTENU des vues pour TOUS les materiels de la BD de test (fixture), 
     * aussi bien dans la vue index globale 
     * que dans CHAQUE vue détaillée de chaque matériel 
     * (en vérifiant aussi la liste des suivis et emprunts associés à ce matériel)
     *
     * Dans le détail :
     * On teste que tous les matériels de la BD sont dans la page index
     * Pour chaque materiel :
     * 1) on teste sa présence dans la page index
     * 2) On teste sa vue détaillée (view) et on regarde si la liste des suivis et emprunts est correcte
     * 
     * @dataProvider dataProviderRoles4
     */
    public function testMaterielPagesIndexAndView2($role) {
        //if ($role != 'RESP') return;
        
        $this->authAs($role);
        
        $this->d("*******************");
        $this->d("    ROLE $role :");
        $this->d("*******************");
        
        // INDISPENSABLE, NE PAS SUPPRIMER !!!
        //debug($_SESSION); // NULL why ?
        // On doit faire ceci (qui appelle l'action index) pour que la variable $_SESSION existe !!!
        // et donc aussi le USER authentifié ci-dessus avec authAs()
        $nbentities = $this->getNbEntitiesExpectedInIndexView();
        $this->_checkNbEntitiesInIndexViewIsAsExpected('Materiels', $nbentities);
        //debug($_SESSION);return;
        // pas NULL why ?
        // On sauvegarde le user courant
        /*
         $configuration = TableRegistry::getTableLocator()->get('Configurations')->find()->first();
         $ldapAuthType = $configuration->ldap_authenticationType;
         $user = $_SESSION['Auth']['User'][$ldapAuthType];
         */
        $user = $_SESSION['Auth']['User'];
        
        // On récup une instance de MaterielsController
        $cm = $this->_getController();
        // On recup TOUS les materiels de la BD (fixture)
        $materiels = $this->Materiels->find('all', [
            'contain' => [
                'Documents',
                'Emprunts',
                'Suivis'
            ]
        ]);
        foreach ($materiels as $m) {
            
            // 1) teste la présence du materiel dans index
            if ($cm->isAuthorizedActionForCurrentUser('index')) {
                $this->get("/materiels/index");
                $this->assertResponseOk();
                // Seul Admin+ a accès aux matériels archivés
                // Pour les autres profils, ce matos ne sera pas dans la page index => on zappe ce cas
                //if ( ! ($m->status=='ARCHIVED' && !$this->USER_IS_ADMIN_AT_LEAST()) )
                if ( $m->status!='ARCHIVED' || $this->USER_IS_ADMIN_AT_LEAST() )
                    $this->_checkIndexPageContainsALineForThisMateriel($m,$cm);
            }
            
            // 2) teste sa vue détaillée (et la liste de ses suivis et emprunts)
            $id = $m->id;
            if ($cm->isAuthorizedActionForCurrentUser('view',$id)) {
                $this->get("/materiels/view/$id");
                $this->assertResponseOk();
                // a) tester que la vue contient bien les boutons attendus
                $this->_checkViewPageContainsAllAuthorizedActionButtonsForMaterielId($id, $user, $cm);
                //TODO:
                // b) tester la liste des suivis, emprunts, et docs
                $this->_checkViewPageContainsAllRelatedEntitiesForMateriel($m, $user, $cm);
            }
        
        }
    }
        
        
    /**
     * (EP 20200625)
     *     
     * Test des vues view.ctp et index.ctp avec tous les profils (roles U,R,A,S) 
     * ET avec tous les statuts de matériel (C,V,T,A)
     * (avec un seul matériel de test qui est modifié à volonté)
     * 
     * Méthode 1 :
     * Test (générique) des vues index et view de Materiels (/materiels/index et /view) 
     * qui teste le CONTENU des vues à partir d'UN UNIQUE matériel de test 
     * qui est modifié à souhait pour essayer de représenter tous les grands cas possibles.
     * 
     * Dans le détail :
     * On teste toujours avec le MEME materiel, mais en MODIFIANT ses attributs 
     * liés au statut du matériel et à l'appartenance du matériel (belonging et samegroup).
     * Pour chaque materiel (modifié) :
     * on teste la présence ou non des boutons d'action (edit, validate, delete, ...)
     *
     * @return void
     *
     * @dataProvider dataProviderRoles4AndStatuses4
     */
    public function testMaterielPagesIndexAndView1($role, $status) {
        $this->d("*******************");
        $this->d("    ROLE $role, STATUT $status :");
        $this->d("*******************");
        
        // On prend un id de materiel ok pour le test
        // On va modifier à souhait ce materiel en BD (fixture)
        $id = $this->_getEntityIdOkForTesting();
        
        // On ajoute les actions qui dépendent de l'état du matériel
        $m = $this->Materiels->get($id); // ou Cake\Datasource\Exception\RecordNotFoundException
        /* Pour changer d'action :
        $m->etiquette = false;
        $m->etiquette = true;
        $this->Materiels->save($m);
        */
        if ($m->etiquette) 
            $action_buttons['setLabelIsNotPlaced'] = 'Etiquette NON collée';
        else
            $action_buttons['setLabelIsPlaced'] = 'Etiquette collée';
        
        // Attention, le role n'est pas encore écrit dans la session !!!
        // La variable $_SESSION n'existe même pas encore
        $this->authAs($role);
        //debug($_SESSION); // null why ???
        
        // INDISPENSABLE, NE PAS SUPPRIMER !!!
        // On doit donc faire ceci (qui appelle l'action index) pour que la variable $_SESSION existe !!! 
        // et donc aussi le USER authentifié ci-dessus avec authAs()
        $nbentities = $this->getNbEntitiesExpectedInIndexView();
        //debug($_SESSION); // NULL why ?
        $this->_checkNbEntitiesInIndexViewIsAsExpected('Materiels', $nbentities);
        //debug($_SESSION);return;
        // pas NULL why ?
        // On sauvegarde le user courant
        /*
        $configuration = TableRegistry::getTableLocator()->get('Configurations')->find()->first();
        $ldapAuthType = $configuration->ldap_authenticationType;
        $user = $_SESSION['Auth']['User'][$ldapAuthType];
        */
        $user = $_SESSION['Auth']['User'];
        //debug("(0) user is"); debug($user);
        
        
        // Force le rechargement des materiels car ils vont être modifiés par les tests
        AppController::forceReload();
        
        // On récup une instance de MaterielsController
        $cm = $this->_getController();
        
        // Condition d'appartenance, couple (belong,samegroup)
        // Toutes les combinaisons de (bool,bool) : TT, TF, FT, FF
        foreach ([false,true] as $belong) {
            foreach ([false,true] as $samegroup) {
                $this->_updateMatosStatusAndBelongingWith($id, $status, $belong, $samegroup);
                // Si les actions 'view' ou/et 'index' sont autorisées, on les exécute, puis on teste le contenue de leur vue
                
                // 1) Check /materiels/index page
                if ($cm->isAuthorizedActionForCurrentUser('index')) {
                    $this->get("/materiels/index");
                    $this->assertResponseOk();
                    $m = $this->Materiels->get($id);
                    // Seul Admin+ a accès aux matériels archivés
                    // Pour les autres profils, ce matos ne sera pas dans la page index => on zappe ce cas
                    //if ( ! ($m->status=='ARCHIVED' && !$this->USER_IS_ADMIN_AT_LEAST()) )
                    if ( $m->status!='ARCHIVED' || $this->USER_IS_ADMIN_AT_LEAST() )
                        $this->_checkIndexPageContainsALineForThisMateriel($m,$cm);
                        //$this->_checkIndexPageContainsThisLineForThisMaterielId($id,$role,$cm);
                }
                
                // 2) Check /materiels/view page
                if ($cm->isAuthorizedActionForCurrentUser('view', $id)) {
                    $this->get("/materiels/view/$id");
                    $this->assertResponseOk();
                    $this->_checkViewPageContainsAllAuthorizedActionButtonsForMaterielId($id, $user, $cm);
                    /*
                    foreach ($action_buttons as $action_name=>$action_label)
                        $this->_checkViewPageContainsThisActionButton($action_name, $action_label, $id, $user, $cm);
                    */
                        /*
                        //debug("action:");debug("$action_name => $action_label");
                        // Par défaut, Materiels
                        $controller_name = 'Materiels';
                        $controller = $cm;
                        $args = explode('/', $action_name);
                        if (count($args)==2) {
                            $controller_name = $args[0];
                            $action_name = $args[1];
                            $controller = $this->_getControllerInstanceFromName($controller_name);
                        }
                        // Controleur materiel
                        //debug($controller->name);
                        //if ($controller_name == 'Materiels')
                        if ($controller==$cm)
                            $action_button_should_be_present = $controller->isAuthorizedActionForCurrentUser($action_name, $id);
                            //if ($action_name=='setLabelIsPlaced') 
                            //debug("action_button_should_be_present is"); debug($action_button_should_be_present);
                        // Autre controleur
                        else 
                            $action_button_should_be_present = $controller->isAuthorizedActionForCurrentUser($action_name, null, $id, $user);
                        //$this->_checkViewPageContainsThisActionButton($action_name, $action_label, $id, $action_button_should_be_present);
                        */
                }
            } // each samegroup
        } // each belong
        
    } // testMaterielViewPage()

    /*
    private function _getControllerFromName($controller_name) {
        if ($controller_name=='Materiels')
            return $this->_getController();
            // Autre controleur
        else
            return $this->_getControllerInstanceFromName($controller_name);
    }
    */
    /*
    private function _getControllerForAction($action_name) {
        $args = explode('/', $action_name);
        // Controleur materiel
        if (count($args)==1) 
            return $this->_getController();
        // Autre controleur
        else 
            return $this->_getControllerInstanceFromName($args[0]);
    }*/
    
    
    // Check View Page Contains All Suivis And Prets And Documents For Materiel $m
    private function _checkViewPageContainsAllRelatedEntitiesForMateriel($m, $user, $cm) {
        $related_entities_names = ['suivis', 'emprunts', 'documents'];
        foreach ($related_entities_names as $entities_name) {
            $this->d("- ******* Checking presence (in view) of related entity $entities_name *******");
            
            // 1) check titre du style "Suivi(s) du matériel (0)"
            $entities = $m->$entities_name;
            $nbentities = count($entities);
            //$this->assertResponseContains("Suivi(s) du matériel (0)");
            $entity_name = substr(ucfirst($entities_name), 0, -1);
            $entity_title = "$entity_name(s) du";
            if ($entities_name == 'documents') $entity_title = "Fichier(s) lié(s) au";
            $this->assertResponseContains("$entity_title matériel (");
            $this->assertResponseContains("$entity_title matériel ($nbentities)");
            //$related_entities = $m->suivis;
            //debug("for matos $m->id, $entities_name entities are"); 
            //debug($suivis);
            
            // 2) check présence de chaque entité avec ses boutons d'action (edit, delete) et ses attributs (nom, autres...)
            foreach ($entities as $e) {
                //debug("check entity id $e->id name $e->nom");
                
                /* a) Boutons action (edit,delete)
                 * La présence (ou non) des boutons dépend uniquement du matériel affiché.
                 * Donc, TOUSES les entités (tous les suivis par exemple) auront (ou pas) les MEMES boutons.
                 * Il suffirait donc de tester seulement la première entité de la liste mais bon... (optimisation possible si besoin)
                 */
                // edit
                $action = "$entities_name/edit"; // suivis/edit
                $this->_checkActionButtonIsPresentInPage($action, $e->id, $user);
                // delete
                $action = "$entities_name/delete"; // suivis/edit
                $this->_checkActionButtonIsPresentInPage($action, $e->id, $user);
                /*
                // (docs) mailDevis
                if ($entities_name == 'documents') {
                    $action = "$entities_name/mailDevis"; // suivis/edit
                    $this->_checkActionButtonIsPresentInPage($action, $e->id, $user);
                }
                */
                
                // b) Attributs (nom...)
                //$this->assertResponseContains($e->id);
                //if ($e->nom) $this->assertResponseContains($e->nom);
                $intitule = $e->nom;
                if (in_array($entities_name,['suivis','emprunts'])) $intitule .= ' ('.strtolower($entity_name)." $e->id)";
                $this->assertResponseContains($intitule, "Le $entity_name $e->id ('$e->nom') n'a pas été trouvé dans la page index");
            }
        }
        return true;
    }

    
    //private function _checkViewPageContainsThisActionButton($action_name, $action_label, $id, $action_button_should_be_present=true) {
    //private function _checkViewPageContainsThisActionButton($action_name, $action_label, $id, $user, $cm) {
    private function _checkViewPageContainsAllAuthorizedActionButtonsForMaterielId($id, $user, $cm) {
        // Tous les boutons d'action accessibles (selon le role et le matériel) depuis la vue détaillée d'un matériel (materiels/view)
        $action_buttons = [

            // - Entité matériel
            'actionInconnue' => 'Action inconnue',
            'edit' => 'Editer', // 'Editer ce matériel'
            'delete' => 'Supprimer',
            'add_by_copy' => 'Copier',
            'statusCreated' => 'Dévalider',
            'statusValidated' => 'Valider',
            'statusTobearchived' => "Demander sortie",
            'statusArchived' => 'Sortie inventaire',
            
            // - Entités associées
            'suivis/add' => 'Nouv. Suivi',
            'emprunts/add' => 'Nouv. Prêt',
            'documents/add' => 'Lier un Doc.',
            'documents/ficheMateriel' => 'Fiche PDF du matériel',
            'documents/admission' => 'Doc. admission',
            'documents/sortie' => 'Doc. sortie',
            'printLabelRuban' => 'étiquette',
            
        ];
        foreach ($action_buttons as $action_name=>$action_label) {
            //debug("action:");debug("$action_name => $action_label");
            // Par défaut, Materiels
            $controller_name = 'Materiels';
            $controller = $cm;
            $args = explode('/', $action_name);
            if (count($args)==2) {
                $controller_name = $args[0];
                $action_name = $args[1];
                $controller = $this->_getControllerInstanceFromName($controller_name);
            }
            // Controleur materiel
            //debug($controller->name);
            //if ($controller_name == 'Materiels')
            if ($controller==$cm)
                $action_button_should_be_present = $controller->isAuthorizedActionForCurrentUser($action_name, $id);
                //if ($action_name=='setLabelIsPlaced')
                //debug("action_button_should_be_present is"); debug($action_button_should_be_present);
            // Autre controleur
            else
                $action_button_should_be_present = $controller->isAuthorizedActionForCurrentUser($action_name, null, $id, $user);
                //$this->_checkViewPageContainsThisActionButton($action_name, $action_label, $id, $action_button_should_be_present);
            /*
            if ($action_name=='sortie') {
                debug($action_button_should_be_present);
                exit;
            }
            */
            if ($action_button_should_be_present)
                $this->assertResponseContains($action_label, "La vue détaillée du matériel (/materiels/view/$id) ne contient pas de bouton '$action_label' comme attendu !");
            else
                $this->assertResponseNotContains($action_label, "La vue du matériel (/materiels/view/$id) contient le bouton '$action_label', alors qu'elle ne devrait PAS !");
        }
    }
                
    
    // Check du contenu de la vue index.ctp (surtout la présence ou non des boutons d'actions)
    //private function OFF_checkIndexPageContentForRoleAndMatos($role, $matos_status, $i, $matos_id) {
    private function _checkIndexPageContainsALineForThisMateriel($m,$cm) {
        
        //$m = $this->Materiels->get($id);
        //$content = $this->_getBodyAsString();
        //debug("content len 0 is ".strlen($content));
        
        // Par défaut, les boutons sont absents
        //$bEdit = $bDelete = $bUpgrade = '';

        //$frompos = 0;
        
        // 0) Nom du matos présent ? 
        //debug("role is $role, status is $m->status");
        //if ( in_array($role,['USER','RESP']) && $m->status=='ARCHIVED' ) return;
        //if (!$this->USER_IS_ADMIN_AT_LEAST() && $m->status=='ARCHIVED') return;
        //debug("ici");
        $matos_name = $m->designation;
        $this->assertResponseContains($matos_name, "La ligne du matériel d'id $m->id dans la vue 'index' des matériels (/materiels/index) NE contient PAS le nom du materiel '$matos_name' pourtant attendu !");

        // 1) bouton Edit présent ?
        $action = 'edit';
        //$bEdit = '<i class="icon-pencil"></i>';
        $this->_checkActionButtonIsPresentInIndexPage($action, $m->id, $cm);
        
        // 2) bouton Upgrade status présent ?
        //$action = 'upgrade';
        //$status_actions = ['status-validated', 'status-tobearchived', 'status-archived'];
        $status_actions = ['statusValidated', 'statusTobearchived', 'statusArchived'];
        foreach ($status_actions as $action) $this->_checkActionButtonIsPresentInIndexPage($action, $m->id, $cm);
            
        // 3) bouton Delete présent ?
        $action = 'delete';
        //$bDelete = '<i class="icon-trash"></i>';
        $this->_checkActionButtonIsPresentInIndexPage($action, $m->id, $cm);
        
        //$this->assertResponseOk();
        //$matos_line = $bEdit.'***'.$bUpgrade.'***'.$bDelete.'***'.$matos_name;
        //$this->assertResponseContains($matos_line, "La ligne du matériel d'id $m->id dans la vue 'index' des matériels (/materiels/index) ne contient pas les boutons attendus !");
        //$this->assertResponseRegExp($pattern, "pas bon regex !");        
            
    } // _checkIndexPageContentForRoleAndMatos()
    
    
    //TODO:
    private function _checkActionButtonIsPresentInPage($action_name, $id, $user) {
        //return true;
        
        $controller_name = null;
        $controller = null;
        $args = explode('/', $action_name); // 'suivis/edit'
        //if (count($args)==2) {
            $controller_name = $args[0];
            $action_name = $args[1];
            $controller = $this->_getControllerInstanceFromName($controller_name);
        //}
        //debug($action_name);
        $button_should_be_present = $controller->isAuthorizedActionForCurrentUser($action_name, $id, null, $user);
        //debug("button_should_be_present is"); debug($button_should_be_present);
        $action_link = Inflector::dasherize($action_name); // statusTobearchived => status-tobearchived
        //$elem = '<a href="/'.$controller_name.'/'.$action_link.'/'.$id.'"'; // <a href="/materiels/status-tobearchived/12015"
        $elem = '/'.$controller_name.'/'.$action_link.'/'.$id; // <a href="/materiels/status-tobearchived/12015"
        //debug($elem);
        if ($button_should_be_present)
            $this->assertResponseContains($elem, "La ligne du $controller_name d'id $id dans la vue 'view' des matériels (/materiels/view) NE contient PAS le bouton '$action_name' ($action_link) pourtant attendu !");
        else
            $this->assertResponseNotContains($elem, "La ligne du $controller_name d'id $id dans la vue 'view' des matériels (/materiels/view) contient le bouton '$action_name' ($action_link) pourtant inattendu !");
    }
    
    private function _checkActionButtonIsPresentInIndexPage($action, $id, $cm) {
        $button_should_be_present = $cm->isAuthorizedActionForCurrentUser($action, $id);
        $action_link = Inflector::dasherize($action); // statusTobearchived => status-tobearchived
        $elem = '<a href="/materiels/'.$action_link.'/'.$id.'"'; // <a href="/materiels/status-tobearchived/12015"
        if ($button_should_be_present)
            $this->assertResponseContains($elem, "La ligne du matériel d'id $id dans la vue 'index' des matériels (/materiels/index) NE contient PAS le bouton '$action' ($action_link) pourtant attendu !");
        else
            $this->assertResponseNotContains($elem, "La ligne du matériel d'id $id dans la vue 'index' des matériels (/materiels/index) contient le bouton '$action' ($action_link) pourtant inattendu !");
        /*
        if ($cm->isAuthorizedActionForCurrentUser($action, $id)) {
            $elem = '<a href="/materiels/'.$action.'/'.$m->id.'"'; // <a href="/materiels/status-tobearchived/12015"
            $curpos = strpos($content, $elem);
            debug($curpos);
            $this->assertTrue($curpos!==false);
            $content = substr($content, $curpos);
            debug("content len 2 is ".strlen($content));
            return [];
        }
        */
    }   
    
    /**
     * Test (automatique) de (presque) TOUTES les actions de CE controleur
     *
     * @return void
     *
     * @dataProvider dataProviderActionsAndRoles4
     */
    public function testAuthorizationsForAllActionsOnMateriels($action, $role_short, $role_long) {
        //$nb = $this->getNbEntitiesInFixture();
        //debug("nb is $nb"); exit;
        // call parent
        //$this->_testAuthorizationsForAllActionsOfController('Materiels', $action, $role_short, $role_long);
        $this->_testAuthorizationsForAllControllerActions($action, $role_short, $role_long);
    }
        

    // (EP 20200629)
    private function _assertFlashMessageIsAsExpectedForAction($action, $SUCCESS=true) {
        // Par défaut, pas de message flash
        $expected_flash_message = [];
        if (in_array($action, ['add', 'edit', 'delete', 'statusCreated', 'statusValidated', 'statusTobearchived', 'statusArchived']))
            $expected_flash_message = 'Le matériel a bien été ';
        switch($action) {
            case 'add':
                $expected_flash_message .= 'ajouté';
                break;
            case 'edit':
                $expected_flash_message .= 'modifié';
                break;
            case 'delete':
                $expected_flash_message .= 'supprimé';
                break;
            case 'statusCreated': 
                $expected_flash_message .= 'rétrogradé au statut CREATED'; 
                break;
            case 'statusValidated': 
                $expected_flash_message .= 'validé'; 
                if (!$SUCCESS) $expected_flash_message = "Pour valider un matériel, les champs suivants ne doivent pas être vides :";
                /*
					Date de reception,
					Nom utilisateur,
					Fournisseur,
					Organisme,
					Prix,
					et Numéro de commande";
                */
                break;
            case 'statusTobearchived': $expected_flash_message = "La sortie d'inventaire a bien été demandée"; break;
            case 'statusArchived': $expected_flash_message .= "archivé (sorti de l'inventaire)"; break;
        }
        //$flash_message = isset($_SESSION['Flash']) ? $_SESSION['Flash']['flash'][0]['message']:[];
        //debug($_SESSION['Flash']);
        $flash_message = isset($_SESSION['Flash']['flash']) ? $_SESSION['Flash']['flash'][0]['message'] : [];
        //debug($flash_message);
        if ($SUCCESS && $expected_flash_message) $this->assertTrue($flash_message != [], "Pas de message flash alors qu'il devrait y en avoir un !");
        if ($flash_message) {
            // Assert a flash message in the 'flash' key.
            // Test message partiel
            $msg_error = "Le message flash est incorrect : ($flash_message) au lieu de ($expected_flash_message)";
            if ($action == 'statusValidated') $this->assertTrue(strpos($flash_message, $expected_flash_message)===0, $msg_error);
            else {
                if ($SUCCESS) {
                    $this->assertTrue(strpos($flash_message, $expected_flash_message)===0, $msg_error);
                    // Test message complet
                    $this->assertFlashMessage($expected_flash_message, 'flash');
                    //$this->assertEquals($expected_flash_message, $flash_message);
                }
                else {
                    $this->assertFalse(strpos($flash_message, $expected_flash_message)===0, $msg_error);
                    $this->assertTrue(strpos($flash_message, "Désolé, vous n'êtes pas autorisé à accéder à cette zone.")===0, $msg_error);
                }
            }
        }
    }
    
    // (EP 20200629)
    private function _doActionAndCheckResult($action, $id=null, $SUCCESS=true, $data=[], $controller=null) {
        $action_link = Inflector::dasherize($action); // statusValidated => status-validated
        //$this->post("/materiels/$action_link/$id");
        //$this->post("/materiels/$action", $data);
        if (!$controller) $controller = 'materiels'; 
        //$full_action = "/materiels/$action_link";
        $full_action = "/$controller/$action_link";
        if ($id) $full_action .= "/$id";
        //debug($full_action);
        //debug($data);
        $this->post($full_action, $data);
        //if ($action =='statusValidated') return;
        $this->assertResponseSuccess();
        $this->_assertFlashMessageIsAsExpectedForAction($action, $SUCCESS);
    }
    
    // (EP 20200629)
    private function _checkMaterielStatusChangedTo($id,$new_status) {
        $m = $this->Materiels->get($id);
        $this->assertSame($m->status, $new_status);
    }
    
    // (EP 20200629) 
    private function _testMaterielCannotBeModifiedAnymoreExceptIfDevalidated($id) {
    
        // On sauve le statut courant
        $m = $this->Materiels->get($id);
        $current_status = $m->status;
        
        // 1) On vérifie qu'on ne peut plus modifier le matériel (car VALIDATED+)
        $action = 'edit';
        $new_data = [
            'designation' => 'Nouveau nom modifié',
        ];
        $this->_doActionAndCheckResult($action, $id, $SUCCESS=false, $new_data);

        // 2) On vérifie qu'on peut le modifier si on le dévalide :
        $action = 'statusCreated';
        $this->_doActionAndCheckResult($action, $id, $SUCCESS=true);
        $this->_checkMaterielStatusChangedTo($id,'CREATED');
        $action = 'edit';
        $this->_doActionAndCheckResult($action, $id, $SUCCESS=true, $new_data);
        $m = $this->Materiels->get($id);
        $this->assertSame($m->designation, 'Nouveau nom modifié');
        
        // 3) On valide à nouveau pour passer à VALIDATED
        $new_status = 'VALIDATED';
        $action = 'statusValidated';
        $this->_doActionAndCheckResult($action, $id, $SUCCESS=true);
        $this->_checkMaterielStatusChangedTo($id,$new_status);
        
        $statuses = [
            'TOBEARCHIVED' => 'statusTobearchived', 
            'ARCHIVED' => 'statusArchived'
        ];
        // 4) On repasse au statut courant (du début) si on n'y est pas encore
        foreach ($statuses as $new_status=>$new_status_action) {
            $m = $this->Materiels->get($id);
            if ($m->status == $current_status) break;
            $this->_doActionAndCheckResult($new_status_action, $id, $SUCCESS=true);
            $this->_checkMaterielStatusChangedTo($id,$new_status);
        }
        
    }
    
    
    /**
     * (EP 20200720)
     *
     * Test des controles sur les dates
     *
     */
    //const MAX_DIFF_YEARS = 10; // maxi 10 ans entre 2 dates
    public function testMaterielDatesValidation() {
        
        // On teste avec le profil SUPERADMIN car il a (presque) tous les droits
        $this->authAs('SUPER');
        
        // On récupère un matériel qcq qu'on va modifier à souhait pour faire les tests
        $id = $this->_getEntityIdOkForTesting();
        $m = $this->Materiels->get($id);
        $format = 'd/m/Y';

        
        // 1) Test edit date acquisition correct format => OK
        $f = 'date_acquisition';
        
        $new_data = [
            $f => '19/04/'.yyyy0,
            'date_reception' => '',
        ];
        $action = 'edit';
        //$this->_doActionAndCheckResult($action, $id, $SUCCESS=true, $new_data);
        $this->_doActionAndCheckResult($action, $id, TRUE, $new_data);
        
        
        // 2) Test edit date acquisition wrong format => KO
        
        // - date avec tirets => KO
        $new_data = [
            $f => '19-04-'.yyyy0,
            //'date_reception' => '',
        ];
        $this->_doActionAndCheckResult($action, $id, FALSE, $new_data);
        // - année sur 2 chiffres => KO
        $new_data = [ $f => '19/04/'.(yyyy0-2000) ];
        $this->_doActionAndCheckResult($action, $id, FALSE, $new_data);
        // - date format US AA/MM/DD => KO
        $new_data = [ $f => yyyy0.'/04/19' ];
        $this->_doActionAndCheckResult($action, $id, FALSE, $new_data);
        // - date (achat) incorrecte => KO
        $new_data = [ $f => '31/04/'.yyyy0 ];
        $this->_doActionAndCheckResult($action, $id, FALSE, $new_data);
        
        
        // 3) Test edit date acquisition non autorisée => KO

        // - date (achat) today => OK...
        $tz = new \DateTimeZone('Europe/Paris');
        $date = $today = new \DateTime('now',$tz);
        //debug($date);
        $new_data = [ $f => $date->format($format) ];
        $this->_doActionAndCheckResult($action, $id, TRUE, $new_data);
        // - ... mais date future (demain) => KO
        $date = $tomorrow = new \DateTime('+1 days',$tz);
        //$date = $tomorrow->add(new \DateInterval('P1D'));
        //debug($date);
        $new_data = [ $f => $date->format($format) ];
        $this->_doActionAndCheckResult($action, $id, FALSE, $new_data);
        // - date (achat) loin dans le passé (-40 ans) => OK...
        $date = $old = new \DateTime('-40 years',$tz);
        //$old = new \DateTime('now',$tz);
        //$date = $old->sub(new \DateInterval('P40Y'));
        $new_data = [ $f => $date->format($format) ];
        $this->_doActionAndCheckResult($action, $id, TRUE, $new_data);
        // - mais pas trop loin dans le passé (-50 ans) => KO
        $date = $old->sub(new \DateInterval('P10Y'));
        //debug($date);
        $new_data = [ $f => $date->format($format) ];
        $this->_doActionAndCheckResult($action, $id, FALSE, $new_data);
        
        
        // 4) Test écart entre 2 dates :
        // - a) Date reception >= date acq, mais pas trop loin
        // - b) Date fin garantie >= date reception, mais pas trop loin
        $dates = [
            'rec-acq' => [
                'date_acquisition',
                'date_reception'
            ],  
            'gar-rec' => [
                'date_reception',
                'date_fin_garantie'
            ]
        ];
        foreach ($dates as $d) {
            //$d1 = 'date_acquisition';
            //$d2 = 'date_reception';
            $d1 = $d[0];
            $d2 = $d[1];
            // - date (reception) < date acq => KO
            $date = $yesterday = new \DateTime('-1 days',$tz);
            /*
            $yesterday = new \DateTime('now',$tz);
            $date = $yesterday->sub(new \DateInterval('P1D'));
            */
            $new_data = [
                $d1 => $today->format($format),
                $d2 => $date->format($format)
            ];
            $this->_doActionAndCheckResult($action, $id, FALSE, $new_data);
            // - date (reception) = date acq => OK
            $date = $today;
            $new_data = [
                $d1 => $today->format($format),
                $d2 => $date->format($format)
            ];
            $this->_doActionAndCheckResult($action, $id, TRUE, $new_data);
            // - date (reception) > date_acq (jqa MAX_DIFF - 1 jour) => OK...
            /*
            $far = new \DateTime('now',$tz);
            $far->add(new \DateInterval('P'.MAX_DIFF_YEARS.'Y'));
            */
            $far = new \DateTime('+'.MAX_DIFF_YEARS.' years',$tz);
            $date = $far->sub(new \DateInterval('P1D'));
            //debug($date);
            $new_data = [
                $d1 => $today->format($format),
                $d2 => $date->format($format)
            ];
            $this->_doActionAndCheckResult($action, $id, TRUE, $new_data);
            // - ...mais pas trop loin dans le futur (MAX_DIFF) => KO
            $date = $far->add(new \DateInterval('P1D'));
            //debug($date);
            $new_data = [ 
                $d1 => $today->format($format),
                $d2 => $date->format($format)
            ];
            $this->_doActionAndCheckResult($action, $id, FALSE, $new_data);
        } // foreach $dates

        // 5) Test Date fin garantie >= date reception, mais pas trop loin
        // C'est la meme chose que le point precedent (3), on suppose donc que c'est ok...
    }
    
    
    /**
     * (EP 20200629) 
     * 
     * Test du cycle de vie complet d'un matériel
     * 
     * On teste les états-transitions d'un matériel, le passage progressif d'un état à un autre :
     *      CREATED => VALIDATED => TBA => ARCHIVED
     * (on teste aussi toutes les actions qui sont possibles ou pas à chaque état)
     * 
     * Ce test vérifie le diagramme UML etats-transitions webroot/doc/diagrams/materiel_state_diagram.txt
     *  
     */
    public function testMaterielLifeCycle() {

        // On teste avec le profil SUPERADMIN car il a (presque) tous les droits
        $this->authAs('SUPER');
        // Nb materiels au départ dans la BD
        $nbentities = $this->getNbEntitiesExpectedInIndexView();
        $this->_checkNbEntitiesInIndexViewIsAsExpected('Materiels', $nbentities);
        // Données minimum à "poster" pour créer un nouveau matériel
        $data = $this->getNewEntityWithAllMandatoryFields();
        
        /*
         * 1) NAISSANCE, création => CREATED
         */
        $new_status = 'CREATED';
        $action = 'add';
        $this->_doActionAndCheckResult($action, null, $SUCCESS=true, $data);
        $nbentities++;
        $this->_checkNbEntitiesInIndexViewIsAsExpected('Materiels', $nbentities);
        // On récupère ce dernier matériel créé from BD
        $m = $this->Materiels->find()->last();
        //debug($m); 
        // id = 15
        $id = $m->id;
        // On vérifie que le statut du matos a bien changé
        $this->_checkMaterielStatusChangedTo($id,$new_status);
        //$this->assertSame($m->status, $new_status);
        // On vérifie qu'on NE peut PAS sortir le doc d'admission (DocumentsController)
        /*
        //$this->_doActionAndCheckResult('admission', $id, $SUCCESS=false, [], 'documents');
        //$this->post("documents/admission_pdf/$id.pdf");
        $this->post("documents/admission/$id");
        $this->assertFileResponse('admission.pdf');
        */
        
        
        /*
         * 2) Validation => VALIDATED
         */
        $new_status = 'VALIDATED';
        //$action_link = 'status-validated';

        // a) FAIL car manque des données pour valider
        $action = 'statusValidated';
        $this->_doActionAndCheckResult($action, $id, $SUCCESS=false);
        
        // b) On ajoute les données manquantes
        // CHAMPS NECESSAIRES POUR MATERIEL VALIDATED :
        $new_data = [
         //'date_reception' => '2016-04-19',
         //'date_reception' => '19/04/2016', // FAIL car doit etre >= date achat !!
         'date_reception' => '19/04/'.yyyy0,
         'nom_responsable' => 'LoremEE ipsum dolor sit amet',
         'fournisseur_id' => 1,
         'organisme_id' => 1,
         'prix_ht' => 75,
         'numero_commande' => 'Lorem ipsum dolor sit amet',
        ];
        $action = 'edit'; 
        //$this->_doActionAndCheckResult($action, $id, $SUCCESS=true, $new_data);
        $this->_doActionAndCheckResult($action, $id, true, $new_data);
        //$m = $this->Materiels->find()->last();
        //$m = $this->Materiels->get($id);
        //debug($m);
        
        // c) SUCCESS car on a toutes les données nécessaires
        $action = 'statusValidated';
        //$this->_doActionAndCheckResult($action, $id, $SUCCESS=true);
        $this->_doActionAndCheckResult($action, $id, true);
        // On vérifie que le statut du matos a bien changé
        $this->_checkMaterielStatusChangedTo($id,$new_status);
        
        // d) On vérifie qu'on peut dévalider ce materiel pour le repasser à l'état CREATED
        $this->_testMaterielCannotBeModifiedAnymoreExceptIfDevalidated($id);
        //$this->_checkMaterielStatusChangedTo($id,$new_status);
        
        //TODO:
        // e) On vérifie qu'on peut sortir le doc d'admission (DocumentsController)
        ////$this->_doActionAndCheckResult('admission', $id, $SUCCESS=true, [], 'documents');
        
        /* 
         * 3) Demande archivage => TBA
         */
        $new_status = 'TOBEARCHIVED';
        $action = 'statusTobearchived';
        $this->_doActionAndCheckResult($action, $id, $SUCCESS=true);
        $this->_checkMaterielStatusChangedTo($id,$new_status);
        $this->_testMaterielCannotBeModifiedAnymoreExceptIfDevalidated($id);
        //$this->_checkMaterielStatusChangedTo($id,$new_status);
        
        /* 
         * 4) Sortie d'inventaire (archivage) => ARCHIVED
         */
        $new_status = 'ARCHIVED';
        $action = 'statusArchived';
        $this->_doActionAndCheckResult($action, $id, $SUCCESS=true);
        $this->_checkMaterielStatusChangedTo($id,$new_status);
        $this->_testMaterielCannotBeModifiedAnymoreExceptIfDevalidated($id);
        //$this->_checkMaterielStatusChangedTo($id,$new_status);
        //$this->_checkMaterielStatusChangedTo($id,'ARCHIVED');
        //TODO:
        // On vérifie qu'on peut afficher le doc de sortie (DocumentsController)
        /*
        //$this->_doActionAndCheckResult('sortie', $id, $SUCCESS=true, [], 'documents');
        //$this->post("documents/sortiePdf/$id.pdf");
        $this->post("documents/sortie/$id");
        $this->assertFileResponse('doc-sortie.pdf');
        */
        
        /* 
         * 5) MORT, suppression définitive de la BD => n'existe plus
         */
        //$this->Materiels->delete($m);
        $action = 'delete';
        // Check qu'on ne peut pas supprimer le materiel à moins de le devalider d'abord
        $this->_doActionAndCheckResult($action, $id, $SUCCESS=false);
        // Pour le supprimer, je dois d'abord le dévalider puis faire en sorte qu'il m'appartienne
        $this->_doActionAndCheckResult('statusCreated', $id, $SUCCESS=true);
        $this->_doActionAndCheckResult('edit', $id, $SUCCESS=true, [ 'nom_responsable' => 'user1 SUPER' ]);
        $this->_doActionAndCheckResult($action, $id, $SUCCESS=true);
        $nbentities--;
        $this->_checkNbEntitiesInIndexViewIsAsExpected('Materiels', $nbentities);
        
    }
    
    
    /**
     * @dataProvider dataProviderRoles4
     */
    public function OFF_testActionDeleteMateriel($role) {
        $this->_testActionDeleteEntity($role);
    }
    
    
} // class MaterielsControllerTest