trunk/tests/testDigitalizedDocument.php

<?php
/**
 * Ce fichier regroupe les tests unitaire sur la classe DigitalizedDocument
 *
 * @package openads
 * @version SVN : $Id$
 */

require_once('../obj/digitalizedDocument.class.php');

/**
 * Cette classe permet de faire des tests unitaires sur la classe DigitalizedDocument
 * 
 * La constante DEBUG doit être définis sur DEGUG_MODE ou PRODUCTION_MODE
 * 
 * Lors de l'envoi de la commande ajouter --stderr
 *
 * Jeu de données utilisé :
 * Le dossier d'instruction PC0130551200001P0 présent dans la bdd,
 * les dossiers et document présent dans binaire/test_digitalizedDocument
 */
class DigitalizedDocumentTest extends PHPUnit_Framework_TestCase {

    protected static $digitalizedDocument = NULL;

    /**
     * Fonction lancée en debut de classe
     */
    public static function setUpBeforeClass() {
        parent::setUpBeforeClass();
        //On instancie la classe DigitalizedDocument
        self::$digitalizedDocument = new DigitalizedDocument();
        $_SERVER['REQUEST_URI'] = "";
    }

    /**
     * Fonction lancée en fin de classe
     */
    public static function tearDownAfterClass() {
        parent::tearDownAfterClass();
        //On détruit l'instance de la classe DigitalizedDocument
        self::$digitalizedDocument->__destruct();
    }

    /**
     * Fonction permettant de verifier l'ajout dans la base de données
     */
    private function checkLinkFile($uid) {

        //Requête qui vérifie dans la bdd si le lien existe
        $sql = "SELECT document_numerise 
                FROM ".DB_PREFIXE."document_numerise 
                WHERE uid = '".$uid."'";
        $document_numerise = self::$digitalizedDocument->f->db->getOne($sql);
        self::$digitalizedDocument->f->addToLog("tests/testDigitalizedDocument.php : db->getOne(".$sql.")", VERBOSE_MODE);
        self::$digitalizedDocument->f->isDatabaseError($document_numerise);

        //Si le lien a été trouvé on retourne vrai
        if ($document_numerise) {

            return true;

        }

        //sinon on retourne false
        return false;
    }

    /*
     * Test la fonction analyseFolder
     */
    public function testAnalyseFolder() {
        
        //Nom possible d'un répertoire
        $foldername = "PC0130551200001.P0";
        //Retour de la fonction analyseFolder
        $analyseFolder = self::$digitalizedDocument->analyseFolder($foldername);
        //On vérifie les données retournée dans l'objet
        $this->assertEquals($analyseFolder->dossier, 'PC0130551200001P0');

        //Nom erroné d'un repertoire
        $foldername = "AAA014121A.AZ7";
        //Retour de la fonction analyseFolder
        $analyseFolder = self::$digitalizedDocument->analyseFolder($foldername);
        //On vérifie que le retour est un objet vide
        $this->assertEquals($analyseFolder, null);
    }

    /**
     * Test la fonction listFiles
     */
    public function testListFiles() {

        //Nom possible de dossier
        $path = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
        //Retour de la fonction listFiles
        $listFiles = self::$digitalizedDocument->listFiles($path);
        //On vérifie les documents retourné
        $this->assertEquals($listFiles[0], "20091106AUTPCP.pdf");

        //Nom de dossier vide
        $path = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200002.P0";
        //Retour de la fontion listFiles
        $listFiles = self::$digitalizedDocument->listFiles($path);
        //On vérifie que le tableau retourné est vide
        $this->assertEquals($listFiles, null);
    }

    /*
     * Test la fonction extractMetadataFromFilename
     */
    public function testExtractMetadataFromFilename() {

        //Nom possible de document
        $filename = "20091106AUTPCP.pdf";
        //Retour de la fonction extractMetadataFromFilename
        $extractMetadataFromFilename = self::$digitalizedDocument->extractMetadataFromFilename($filename);
        //On vérifie les données retournées
        $this->assertEquals($extractMetadataFromFilename["type_doc"], "AUTPCP");
        $this->assertEquals($extractMetadataFromFilename["date_evenement"], "06/11/2009");

        //Nom possible de document avec version
        $filename = "20130420ART-1.pdf";
        //Retour de la fonction extractMetadataFromFilename
        $extractMetadataFromFilename = self::$digitalizedDocument->extractMetadataFromFilename($filename);
        //On vérifie les données retournées
        $this->assertEquals($extractMetadataFromFilename["type_doc"], "ART");
        $this->assertEquals($extractMetadataFromFilename["date_evenement"], "20/04/2013");

        //Nom erroné de document
        $filename = "20591212.pdf";
        //Retour de la fonction extractMetadataFromFilename
        $extractMetadataFromFilename = self::$digitalizedDocument->extractMetadataFromFilename($filename);
        //On vérifie que le tableau retourné est vide
        $this->assertEquals($extractMetadataFromFilename, null);

    }

    /**
     * Test la fonction extractMetadataFromApp
     */
    public function testExtractMetadataFromApp() {

        //Code possible de type de document
        $code = 'AUTPCP';
        //Retour de la fonction extractMetadataFromApp
        $extractMetadataFromApp = self::$digitalizedDocument->extractMetadataFromApp($code);
        //On vérifie les données retournée dans l'objet
        $this->assertEquals($extractMetadataFromApp, 'autres pièces composant le dossier (A3/A4)');

        //Code erroné de type de document
        $code = 'ZZPOP';
        //Retour de la fonction extractMetadataFromApp
        $extractMetadataFromApp = self::$digitalizedDocument->extractMetadataFromApp($code);
        //On vérifie que le retour est null
        $this->assertEquals($extractMetadataFromApp, null);
        
    }

    /**
     * Test la fonction extractMetadataToFilestorage
     */
    public function testExtractMetadataToFilestorage() {

        //Nom possible de dossier
        $path = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
        //Nom possible de document
        $filename = "20091106AUTPCP.pdf";
        //Retour de la fonction extractMetadataToFilestorage
        $extractMetadataToFilestorage = self::$digitalizedDocument->extractMetadataToFilestorage($path, $filename);
        //On vérifie les données retournées
        $this->assertEquals($extractMetadataToFilestorage['filename'], '20091106AUTPCP.pdf');
        $this->assertEquals($extractMetadataToFilestorage['size'], '17435');
        $this->assertEquals($extractMetadataToFilestorage['mimetype'], 'application/pdf');

        //Chemin document erroné
        $path = "";
        //Nom possible de document
        $filename = "20091106AUTPCP.pdf";
        //Retour de la fonction extractMetadataToFilestorage
        $extractMetadataToFilestorage = self::$digitalizedDocument->extractMetadataToFilestorage($path, $filename);
        //On vérifie que le retour est null
        $this->assertEquals($extractMetadataToFilestorage, null);

    }

    /**
     * Test de la fonction setMetadata
     */
    public function testSetMetadata() {

        //Nom possible d'un répertoire
        $foldername = "PC0130551200001.P0";
        //Nom possible de dossier
        $path = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
        //Nom possible de document avec version
        $filename = "20091106AUTPCP.pdf";
        //Retour de la fonction analyseFolder
        $dossier_instruction = self::$digitalizedDocument->analyseFolder($foldername);
        //Retour de la fonction setMetadata
        $setMetadata = self::$digitalizedDocument->setMetadata($dossier_instruction, $path, $filename);
        //On vérifie les données retournées
        $this->assertEquals($setMetadata["dossier"], "PC0130551200001P0");
        $this->assertEquals($setMetadata["dossier_autorisation"], "PC0130551200001");
        $this->assertEquals($setMetadata["date_demande_initiale"], "2012/12");
        $this->assertEquals($setMetadata["dossier_instruction_type"], "P");
        $this->assertEquals($setMetadata["statut"], "En cours");
        $this->assertEquals($setMetadata["dossier_autorisation_type"], "PC");
        $this->assertEquals($setMetadata["groupe"], "ADS");
        $this->assertEquals($setMetadata["code_produit"], "OpenADS");
        $this->assertEquals($setMetadata["type_doc"], "autres pièces composant le dossier (A3/A4)");
        $this->assertEquals($setMetadata["date_evenement"], "06/11/2009");
        $this->assertEquals($setMetadata["filename"], "20091106AUTPCP.pdf");
        $this->assertEquals($setMetadata["size"], "17435");
        $this->assertEquals($setMetadata["mimetype"], "application/pdf");

        //Nom possible d'un répertoire
        $foldername = "PC0130551200001.P0";
        //Nom possible de dossier
        $path = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
        //Nom possible de document
        $filename = "20091106AUTPCP.pdf";
        //dossier_instruction erroné
        $dossier_instruction = "";
        //Retour de la fonction setMetadata
        $setMetadata = self::$digitalizedDocument->setMetadata($dossier_instruction, $path, $filename);
        //On vérifie que le résultat retourné est null
        $this->assertEquals($setMetadata, null);

    }

    /**
     * Test la fonction createFile
     */
    public function testCreateFile() {

        //Nom possible d'un répertoire
        $foldername = "PC0130551200001.P0";
        //Nom possible de dossier
        $path = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
        //Nom possible de document
        $filename = "20091106AUTPCP.pdf";
        //Retour de la fonction analyseFolder
        $dossier_instruction = self::$digitalizedDocument->analyseFolder($foldername);
        //Contenu du fichier
        $file_content = file_get_contents($path.'/'.$filename);
        //Metadonnées du document
        $metadata = self::$digitalizedDocument->setMetadata($dossier_instruction, $path, $filename);

        //Retour de la fonction createFile
        $createFile = self::$digitalizedDocument->createFile($file_content, $metadata);
        //On vérifie que l'action s'est bien déroulée
        $file_exists_filestorage = self::$digitalizedDocument->filestorage->get($uid);
        $this->assertTrue($file_exists_filestorage != null);

    }

    /*
     * Test la fonction deleteFile
     */
    public function testDeleteFile() {

        //Création d'un fichier dans le filestorage
        //Nom possible d'un répertoire
        $foldername = "PC0130551200001.P0";
        //Nom possible de dossier
        $path = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
        //Nom possible de document avec version
        $filename = "20091106AUTPCP.pdf";
        //Retour de la fonction analyseFolder
        $dossier_instruction = self::$digitalizedDocument->analyseFolder($foldername);
        //Contenu du fichier
        $file_content = file_get_contents($path.'/'.$filename);
        //Metadonnées du document
        $metadata = self::$digitalizedDocument->setMetadata($dossier_instruction, $path, $filename);
        //Retour de la fonction createFile
        $uid = self::$digitalizedDocument->createFile($file_content, $metadata);

        //Retour de la fonction deleteFile
        $deleteFile = self::$digitalizedDocument->deleteFile($uid);
        //On vérifie que l'action s'est bien déroulée
        $file_exists_filestorage = self::$digitalizedDocument->filestorage->get($uid);
        $this->assertEquals($file_exists_filestorage, null);

    }

    /**
     * Test la fonction linkFile
     */
    public function testLinkFile() {

        //Uid d'un fichier
        $uid = uniqid();
        //Clé primaire du dossier d'instruction
        $id_instruction = "PC0130551200001P0";
        //Retour de la fonction linkFile
        self::$digitalizedDocument->linkFile($uid, $id_instruction, self::$digitalizedDocument->f->db, NULL);
        //On vérifie que l'action s'est bien déroulée
        $this->assertEquals($this->checkLinkFile($uid), true);

        //Uid pas présent dans la bdd
        $uid = uniqid();
        //On vérifie que false est bien retourné
        $this->assertEquals($this->checkLinkFile($uid), false);

    }

    /**
     * Test la fonction moveFile
     */
    public function testMoveFile() {

        //Dossier source
        $pathSrc = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
        //Dossier de destination
        $pathDes = "binaire/test_digitalizedDocument/Transfert GED/Done/PC0130551200001.P0";
        //Nom du fichier
        $filename = "20091106AUTPCP.pdf";
        //Retour de la fonction moveFile
        $moveFile = self::$digitalizedDocument->moveFile($pathSrc, $pathDes, $filename);
        //On vérifie que l'action s'est bien déroulée
        //Le document doit être présent dans la destination
        $file_exists_destination = file_exists($pathDes.'/'.$filename);
        $this->assertEquals($file_exists_destination, true);
        //Le document ne doit plus être présent dans la source
        $file_exists_source = file_exists($pathSrc.'/'.$filename);
        $this->assertEquals($file_exists_source, false);
        
        //Remet le fichier dans todo pour les autres tests
        rename($pathDes.'/'.$filename, $pathSrc.'/'.$filename);

    }

    /**
     * Test la fonction purgeFiles
     */
    public function testPurgeFiles() {

        //Dossier source
        $pathSrc = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
        //Dossier de destination
        $pathDes = "binaire/test_digitalizedDocument/Transfert GED/Done/PC0130551200001.P0";
        //Création dossier
        if (!file_exists($pathDes)) {
            mkdir("binaire/test_digitalizedDocument/Transfert GED/Done/PC0130551200001.P0");
        }
        //Nom du fichier
        $filename = "20091106AUTPCP.pdf";
        //Met le fichier dans Done
        copy($pathSrc.'/'.$filename, $pathDes.'/'.$filename);

        //fichier
        $file = $pathDes.'/'.$filename;
        //Date de l'import du document
        $dateImport = "2012-01-01";
        //Nombre jour
        $nbDay = 60;
        //Retour de la fonction purge
        $purgeFiles = self::$digitalizedDocument->purgeFiles($file, $dateImport, $nbDay);
        //On vérifie que l'action s'est bien déroulée
        $this->assertEquals($purgeFiles, true);

        //Création du fichier
        $newfile = "20091106RIPC05.pdf";
        copy($pathSrc.'/'.$filename, $pathDes.'/'.$newfile);
        //fichier
        $file = $pathDes.'/'.$newfile;
        //Retour de la fonction purge sans les paramètres de date
        $purgeFiles = self::$digitalizedDocument->purgeFiles($file);
        //On vérifie que l'action s'est bien déroulée
        $this->assertEquals($purgeFiles, true);

        //Création du fichier
        $newfile = "20091106DGPC03.pdf";
        copy($pathSrc.'/'.$filename, $pathDes.'/'.$newfile);
        //fichier
        $file = $pathDes.'/'.$newfile;
        //Date de l'import du document
        $dateImport = date('d-m-Y');
        //Nombre jour
        $nbDay = 60;
        //Retour de la fonction purge 
        $purgeFiles = self::$digitalizedDocument->purgeFiles($file, $dateImport, $nbDay);
        //On vérifie que l'action s'est bien déroulée
        $this->assertEquals($purgeFiles, false);

        //Supprime le fichier laissé dans le dossier Done
        unlink($pathDes.'/'.$newfile);

    }

    /**
     * Test la fonction run_import
     */
    public function test_run_import() {

        //Nom de dossier
        $pathSrc = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
        //Nom dossier destination
        $pathDes = "binaire/test_digitalizedDocument/Transfert GED/Done/PC0130551200001.P0";
        //Déclarations paramètre
        $db = self::$digitalizedDocument->f->db;
        $DEBUG = NULL;
        //Retour de la fonction run_import
        $run_import = self::$digitalizedDocument->run_import($pathSrc, $pathDes, $db, $DEBUG);
        //On vérifie que l'action s'est bien déroulée
        $this->assertEquals($run_import, true);

        //Replace le fichier dans le fichier source
        rename($pathDes.'/'."20091106AUTPCP.pdf", $pathSrc.'/'."20091106AUTPCP.pdf");

        
    }

    /**
     * Test la fonction run_purge
     */
    public function test_run_purge() {

        //Dossier source
        $pathSrc = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
        //Dossier de destination
        $pathDes = "binaire/test_digitalizedDocument/Transfert GED/Done/PC0130551200001.P0";
        //Création dossier
        if (!file_exists($pathDes)) {
            mkdir("binaire/test_digitalizedDocument/Transfert GED/Done/PC0130551200001.P0");
        }
        //Nom du fichier
        $filename = "20091106AUTPCP.pdf";
        //Met le fichier 20091106AUTPCP dans Done
        copy($pathSrc.'/'.$filename, $pathDes.'/'.$filename);
        //Création du fichier 20091106RIPC05
        $newfile = "20091106RIPC05.pdf";
        copy($pathSrc.'/'.$filename, $pathDes.'/'.$newfile);
        //Création du fichier 20091106DGPC03
        $newfile = "20091106DGPC03.pdf";
        copy($pathSrc.'/'.$filename, $pathDes.'/'.$newfile);

        //Nombre jour
        $nbDay = 60;
        //Retour de la fonction run_purge
        $run_purge = self::$digitalizedDocument->run_purge($pathDes, $nbDay);
        //On vérifie que l'action s'est bien déroulée
        $this->assertEquals($run_purge, true);
        
    }

}

?>
1	softime	1830	<?php
2			/**
3			* Ce fichier regroupe les tests unitaire sur la classe DigitalizedDocument
4			*
5			* @package openads
6			* @version SVN : $Id$
7			*/
8
9	softime	1835	require_once('../obj/digitalizedDocument.class.php');
10	softime	1830
11			/**
12			* Cette classe permet de faire des tests unitaires sur la classe DigitalizedDocument
13			*
14			* La constante DEBUG doit être définis sur DEGUG_MODE ou PRODUCTION_MODE
15			*
16			* Lors de l'envoi de la commande ajouter --stderr
17	softime	1851	*
18			* Jeu de données utilisé :
19			* Le dossier d'instruction PC0130551200001P0 présent dans la bdd,
20			* les dossiers et document présent dans binaire/test_digitalizedDocument
21	softime	1830	*/
22			class DigitalizedDocumentTest extends PHPUnit_Framework_TestCase {
23
24			protected static $digitalizedDocument = NULL;
25
26			/**
27			* Fonction lancée en debut de classe
28			*/
29			public static function setUpBeforeClass() {
30	softime	1835	parent::setUpBeforeClass();
31	softime	1830	//On instancie la classe DigitalizedDocument
32			self::$digitalizedDocument = new DigitalizedDocument();
33			$_SERVER['REQUEST_URI'] = "";
34			}
35
36			/**
37			* Fonction lancée en fin de classe
38			*/
39			public static function tearDownAfterClass() {
40	softime	1835	parent::tearDownAfterClass();
41	softime	1830	//On détruit l'instance de la classe DigitalizedDocument
42			self::$digitalizedDocument->__destruct();
43			}
44
45	softime	1851	/**
46			* Fonction permettant de verifier l'ajout dans la base de données
47			*/
48			private function checkLinkFile($uid) {
49
50			//Requête qui vérifie dans la bdd si le lien existe
51			$sql = "SELECT document_numerise
52			FROM ".DB_PREFIXE."document_numerise
53			WHERE uid = '".$uid."'";
54			$document_numerise = self::$digitalizedDocument->f->db->getOne($sql);
55			self::$digitalizedDocument->f->addToLog("tests/testDigitalizedDocument.php : db->getOne(".$sql.")", VERBOSE_MODE);
56			self::$digitalizedDocument->f->isDatabaseError($document_numerise);
57
58			//Si le lien a été trouvé on retourne vrai
59			if ($document_numerise) {
60
61			return true;
62
63			}
64
65			//sinon on retourne false
66			return false;
67			}
68
69	softime	1830	/*
70			* Test la fonction analyseFolder
71			*/
72			public function testAnalyseFolder() {
73
74			//Nom possible d'un répertoire
75			$foldername = "PC0130551200001.P0";
76			//Retour de la fonction analyseFolder
77			$analyseFolder = self::$digitalizedDocument->analyseFolder($foldername);
78			//On vérifie les données retournée dans l'objet
79			$this->assertEquals($analyseFolder->dossier, 'PC0130551200001P0');
80
81			//Nom erroné d'un repertoire
82			$foldername = "AAA014121A.AZ7";
83			//Retour de la fonction analyseFolder
84			$analyseFolder = self::$digitalizedDocument->analyseFolder($foldername);
85			//On vérifie que le retour est un objet vide
86			$this->assertEquals($analyseFolder, null);
87			}
88
89			/**
90			* Test la fonction listFiles
91			*/
92			public function testListFiles() {
93
94			//Nom possible de dossier
95	softime	1851	$path = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
96	softime	1830	//Retour de la fonction listFiles
97			$listFiles = self::$digitalizedDocument->listFiles($path);
98			//On vérifie les documents retourné
99			$this->assertEquals($listFiles[0], "20091106AUTPCP.pdf");
100
101			//Nom de dossier vide
102	softime	1851	$path = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200002.P0";
103	softime	1830	//Retour de la fontion listFiles
104			$listFiles = self::$digitalizedDocument->listFiles($path);
105			//On vérifie que le tableau retourné est vide
106			$this->assertEquals($listFiles, null);
107			}
108
109			/*
110			* Test la fonction extractMetadataFromFilename
111			*/
112			public function testExtractMetadataFromFilename() {
113
114			//Nom possible de document
115			$filename = "20091106AUTPCP.pdf";
116			//Retour de la fonction extractMetadataFromFilename
117			$extractMetadataFromFilename = self::$digitalizedDocument->extractMetadataFromFilename($filename);
118			//On vérifie les données retournées
119	softime	1835	$this->assertEquals($extractMetadataFromFilename["type_doc"], "AUTPCP");
120			$this->assertEquals($extractMetadataFromFilename["date_evenement"], "06/11/2009");
121	softime	1830
122			//Nom possible de document avec version
123			$filename = "20130420ART-1.pdf";
124			//Retour de la fonction extractMetadataFromFilename
125			$extractMetadataFromFilename = self::$digitalizedDocument->extractMetadataFromFilename($filename);
126			//On vérifie les données retournées
127	softime	1835	$this->assertEquals($extractMetadataFromFilename["type_doc"], "ART");
128			$this->assertEquals($extractMetadataFromFilename["date_evenement"], "20/04/2013");
129	softime	1830
130			//Nom erroné de document
131			$filename = "20591212.pdf";
132			//Retour de la fonction extractMetadataFromFilename
133			$extractMetadataFromFilename = self::$digitalizedDocument->extractMetadataFromFilename($filename);
134			//On vérifie que le tableau retourné est vide
135			$this->assertEquals($extractMetadataFromFilename, null);
136
137			}
138
139			/**
140			* Test la fonction extractMetadataFromApp
141			*/
142			public function testExtractMetadataFromApp() {
143
144			//Code possible de type de document
145			$code = 'AUTPCP';
146			//Retour de la fonction extractMetadataFromApp
147			$extractMetadataFromApp = self::$digitalizedDocument->extractMetadataFromApp($code);
148			//On vérifie les données retournée dans l'objet
149			$this->assertEquals($extractMetadataFromApp, 'autres pièces composant le dossier (A3/A4)');
150
151			//Code erroné de type de document
152			$code = 'ZZPOP';
153			//Retour de la fonction extractMetadataFromApp
154			$extractMetadataFromApp = self::$digitalizedDocument->extractMetadataFromApp($code);
155			//On vérifie que le retour est null
156			$this->assertEquals($extractMetadataFromApp, null);
157
158			}
159
160			/**
161			* Test la fonction extractMetadataToFilestorage
162			*/
163			public function testExtractMetadataToFilestorage() {
164
165			//Nom possible de dossier
166	softime	1851	$path = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
167	softime	1830	//Nom possible de document
168			$filename = "20091106AUTPCP.pdf";
169			//Retour de la fonction extractMetadataToFilestorage
170			$extractMetadataToFilestorage = self::$digitalizedDocument->extractMetadataToFilestorage($path, $filename);
171			//On vérifie les données retournées
172			$this->assertEquals($extractMetadataToFilestorage['filename'], '20091106AUTPCP.pdf');
173	softime	1835	$this->assertEquals($extractMetadataToFilestorage['size'], '17435');
174			$this->assertEquals($extractMetadataToFilestorage['mimetype'], 'application/pdf');
175	softime	1830
176			//Chemin document erroné
177			$path = "";
178			//Nom possible de document
179			$filename = "20091106AUTPCP.pdf";
180			//Retour de la fonction extractMetadataToFilestorage
181			$extractMetadataToFilestorage = self::$digitalizedDocument->extractMetadataToFilestorage($path, $filename);
182	softime	1835	//On vérifie que le retour est null
183	softime	1830	$this->assertEquals($extractMetadataToFilestorage, null);
184
185			}
186
187			/**
188			* Test de la fonction setMetadata
189			*/
190			public function testSetMetadata() {
191
192			//Nom possible d'un répertoire
193			$foldername = "PC0130551200001.P0";
194			//Nom possible de dossier
195	softime	1851	$path = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
196	softime	1830	//Nom possible de document avec version
197			$filename = "20091106AUTPCP.pdf";
198			//Retour de la fonction analyseFolder
199			$dossier_instruction = self::$digitalizedDocument->analyseFolder($foldername);
200			//Retour de la fonction setMetadata
201			$setMetadata = self::$digitalizedDocument->setMetadata($dossier_instruction, $path, $filename);
202			//On vérifie les données retournées
203	softime	1835	$this->assertEquals($setMetadata["dossier"], "PC0130551200001P0");
204			$this->assertEquals($setMetadata["dossier_autorisation"], "PC0130551200001");
205			$this->assertEquals($setMetadata["date_demande_initiale"], "2012/12");
206			$this->assertEquals($setMetadata["dossier_instruction_type"], "P");
207			$this->assertEquals($setMetadata["statut"], "En cours");
208			$this->assertEquals($setMetadata["dossier_autorisation_type"], "PC");
209			$this->assertEquals($setMetadata["groupe"], "ADS");
210			$this->assertEquals($setMetadata["code_produit"], "OpenADS");
211	softime	1830	$this->assertEquals($setMetadata["type_doc"], "autres pièces composant le dossier (A3/A4)");
212	softime	1835	$this->assertEquals($setMetadata["date_evenement"], "06/11/2009");
213			$this->assertEquals($setMetadata["filename"], "20091106AUTPCP.pdf");
214			$this->assertEquals($setMetadata["size"], "17435");
215			$this->assertEquals($setMetadata["mimetype"], "application/pdf");
216	softime	1830
217			//Nom possible d'un répertoire
218			$foldername = "PC0130551200001.P0";
219			//Nom possible de dossier
220	softime	1851	$path = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
221	softime	1835	//Nom possible de document
222	softime	1830	$filename = "20091106AUTPCP.pdf";
223			//dossier_instruction erroné
224			$dossier_instruction = "";
225			//Retour de la fonction setMetadata
226			$setMetadata = self::$digitalizedDocument->setMetadata($dossier_instruction, $path, $filename);
227	softime	1835	//On vérifie que le résultat retourné est null
228	softime	1830	$this->assertEquals($setMetadata, null);
229
230			}
231
232			/**
233			* Test la fonction createFile
234			*/
235			public function testCreateFile() {
236
237			//Nom possible d'un répertoire
238			$foldername = "PC0130551200001.P0";
239			//Nom possible de dossier
240	softime	1851	$path = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
241	softime	1835	//Nom possible de document
242	softime	1830	$filename = "20091106AUTPCP.pdf";
243			//Retour de la fonction analyseFolder
244			$dossier_instruction = self::$digitalizedDocument->analyseFolder($foldername);
245			//Contenu du fichier
246			$file_content = file_get_contents($path.'/'.$filename);
247			//Metadonnées du document
248			$metadata = self::$digitalizedDocument->setMetadata($dossier_instruction, $path, $filename);
249
250			//Retour de la fonction createFile
251			$createFile = self::$digitalizedDocument->createFile($file_content, $metadata);
252			//On vérifie que l'action s'est bien déroulée
253	softime	1851	$file_exists_filestorage = self::$digitalizedDocument->filestorage->get($uid);
254			$this->assertTrue($file_exists_filestorage != null);
255	softime	1830
256			}
257
258			/*
259			* Test la fonction deleteFile
260			*/
261			public function testDeleteFile() {
262
263			//Création d'un fichier dans le filestorage
264			//Nom possible d'un répertoire
265			$foldername = "PC0130551200001.P0";
266			//Nom possible de dossier
267	softime	1851	$path = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
268	softime	1830	//Nom possible de document avec version
269			$filename = "20091106AUTPCP.pdf";
270			//Retour de la fonction analyseFolder
271			$dossier_instruction = self::$digitalizedDocument->analyseFolder($foldername);
272			//Contenu du fichier
273			$file_content = file_get_contents($path.'/'.$filename);
274			//Metadonnées du document
275			$metadata = self::$digitalizedDocument->setMetadata($dossier_instruction, $path, $filename);
276			//Retour de la fonction createFile
277			$uid = self::$digitalizedDocument->createFile($file_content, $metadata);
278
279			//Retour de la fonction deleteFile
280			$deleteFile = self::$digitalizedDocument->deleteFile($uid);
281			//On vérifie que l'action s'est bien déroulée
282	softime	1851	$file_exists_filestorage = self::$digitalizedDocument->filestorage->get($uid);
283			$this->assertEquals($file_exists_filestorage, null);
284	softime	1830
285			}
286
287			/**
288			* Test la fonction linkFile
289			*/
290			public function testLinkFile() {
291
292			//Uid d'un fichier
293			$uid = uniqid();
294			//Clé primaire du dossier d'instruction
295			$id_instruction = "PC0130551200001P0";
296			//Retour de la fonction linkFile
297			self::$digitalizedDocument->linkFile($uid, $id_instruction, self::$digitalizedDocument->f->db, NULL);
298			//On vérifie que l'action s'est bien déroulée
299	softime	1851	$this->assertEquals($this->checkLinkFile($uid), true);
300	softime	1830
301			//Uid pas présent dans la bdd
302			$uid = uniqid();
303	softime	1835	//On vérifie que false est bien retourné
304	softime	1851	$this->assertEquals($this->checkLinkFile($uid), false);
305	softime	1830
306			}
307
308			/**
309			* Test la fonction moveFile
310			*/
311			public function testMoveFile() {
312
313			//Dossier source
314	softime	1851	$pathSrc = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
315	softime	1830	//Dossier de destination
316	softime	1851	$pathDes = "binaire/test_digitalizedDocument/Transfert GED/Done/PC0130551200001.P0";
317	softime	1830	//Nom du fichier
318			$filename = "20091106AUTPCP.pdf";
319	softime	1851	//Retour de la fonction moveFile
320	softime	1830	$moveFile = self::$digitalizedDocument->moveFile($pathSrc, $pathDes, $filename);
321			//On vérifie que l'action s'est bien déroulée
322	softime	1851	//Le document doit être présent dans la destination
323			$file_exists_destination = file_exists($pathDes.'/'.$filename);
324			$this->assertEquals($file_exists_destination, true);
325			//Le document ne doit plus être présent dans la source
326			$file_exists_source = file_exists($pathSrc.'/'.$filename);
327			$this->assertEquals($file_exists_source, false);
328	softime	1830
329			//Remet le fichier dans todo pour les autres tests
330	softime	1835	rename($pathDes.'/'.$filename, $pathSrc.'/'.$filename);
331	softime	1830
332			}
333
334			/**
335			* Test la fonction purgeFiles
336			*/
337			public function testPurgeFiles() {
338
339			//Dossier source
340	softime	1851	$pathSrc = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
341	softime	1830	//Dossier de destination
342	softime	1851	$pathDes = "binaire/test_digitalizedDocument/Transfert GED/Done/PC0130551200001.P0";
343	softime	1830	//Création dossier
344			if (!file_exists($pathDes)) {
345	softime	1851	mkdir("binaire/test_digitalizedDocument/Transfert GED/Done/PC0130551200001.P0");
346	softime	1830	}
347			//Nom du fichier
348			$filename = "20091106AUTPCP.pdf";
349			//Met le fichier dans Done
350	softime	1835	copy($pathSrc.'/'.$filename, $pathDes.'/'.$filename);
351	softime	1830
352			//fichier
353			$file = $pathDes.'/'.$filename;
354			//Date de l'import du document
355			$dateImport = "2012-01-01";
356			//Nombre jour
357			$nbDay = 60;
358			//Retour de la fonction purge
359			$purgeFiles = self::$digitalizedDocument->purgeFiles($file, $dateImport, $nbDay);
360			//On vérifie que l'action s'est bien déroulée
361			$this->assertEquals($purgeFiles, true);
362
363			//Création du fichier
364			$newfile = "20091106RIPC05.pdf";
365	softime	1835	copy($pathSrc.'/'.$filename, $pathDes.'/'.$newfile);
366	softime	1830	//fichier
367			$file = $pathDes.'/'.$newfile;
368			//Retour de la fonction purge sans les paramètres de date
369			$purgeFiles = self::$digitalizedDocument->purgeFiles($file);
370			//On vérifie que l'action s'est bien déroulée
371			$this->assertEquals($purgeFiles, true);
372
373			//Création du fichier
374			$newfile = "20091106DGPC03.pdf";
375	softime	1835	copy($pathSrc.'/'.$filename, $pathDes.'/'.$newfile);
376	softime	1830	//fichier
377			$file = $pathDes.'/'.$newfile;
378			//Date de l'import du document
379			$dateImport = date('d-m-Y');
380			//Nombre jour
381			$nbDay = 60;
382			//Retour de la fonction purge
383			$purgeFiles = self::$digitalizedDocument->purgeFiles($file, $dateImport, $nbDay);
384			//On vérifie que l'action s'est bien déroulée
385			$this->assertEquals($purgeFiles, false);
386
387			//Supprime le fichier laissé dans le dossier Done
388	softime	1835	unlink($pathDes.'/'.$newfile);
389	softime	1830
390			}
391
392			/**
393			* Test la fonction run_import
394			*/
395			public function test_run_import() {
396
397			//Nom de dossier
398	softime	1851	$pathSrc = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
399	softime	1830	//Nom dossier destination
400	softime	1851	$pathDes = "binaire/test_digitalizedDocument/Transfert GED/Done/PC0130551200001.P0";
401	softime	1830	//Déclarations paramètre
402			$db = self::$digitalizedDocument->f->db;
403			$DEBUG = NULL;
404			//Retour de la fonction run_import
405			$run_import = self::$digitalizedDocument->run_import($pathSrc, $pathDes, $db, $DEBUG);
406			//On vérifie que l'action s'est bien déroulée
407			$this->assertEquals($run_import, true);
408
409			//Replace le fichier dans le fichier source
410	softime	1835	rename($pathDes.'/'."20091106AUTPCP.pdf", $pathSrc.'/'."20091106AUTPCP.pdf");
411
412	softime	1830
413			}
414
415			/**
416			* Test la fonction run_purge
417			*/
418			public function test_run_purge() {
419
420			//Dossier source
421	softime	1851	$pathSrc = "binaire/test_digitalizedDocument/Transfert GED/Todo/PC0130551200001.P0";
422	softime	1830	//Dossier de destination
423	softime	1851	$pathDes = "binaire/test_digitalizedDocument/Transfert GED/Done/PC0130551200001.P0";
424	softime	1830	//Création dossier
425			if (!file_exists($pathDes)) {
426	softime	1851	mkdir("binaire/test_digitalizedDocument/Transfert GED/Done/PC0130551200001.P0");
427	softime	1830	}
428			//Nom du fichier
429			$filename = "20091106AUTPCP.pdf";
430			//Met le fichier 20091106AUTPCP dans Done
431	softime	1835	copy($pathSrc.'/'.$filename, $pathDes.'/'.$filename);
432	softime	1830	//Création du fichier 20091106RIPC05
433			$newfile = "20091106RIPC05.pdf";
434	softime	1835	copy($pathSrc.'/'.$filename, $pathDes.'/'.$newfile);
435	softime	1830	//Création du fichier 20091106DGPC03
436			$newfile = "20091106DGPC03.pdf";
437	softime	1835	copy($pathSrc.'/'.$filename, $pathDes.'/'.$newfile);
438	softime	1830
439			//Nombre jour
440			$nbDay = 60;
441			//Retour de la fonction run_purge
442			$run_purge = self::$digitalizedDocument->run_purge($pathDes, $nbDay);
443			//On vérifie que l'action s'est bien déroulée
444			$this->assertEquals($run_purge, true);
445
446			}
447
448			}
449
450			?>