Browse Source

Refactoring du test unitaire en un PHPUnit avec 5 tests internes en dependance les uns des autres pour execution dans le bon ordre

pull/4414/head
Cerdic 2 months ago
parent
commit
0b71bb8362
  1. 111
      tests/01_initialiser_archives.php
  2. 79
      tests/02_informer_archives.php
  3. 40
      tests/03_deballer_archives.php
  4. 54
      tests/04_emballer_archives.php
  5. 75
      tests/05_retirer_archives.php
  6. 246
      tests/ArchivisteTest.php
  7. 42
      tests/TestCase.inc

111
tests/01_initialiser_archives.php

@ -1,111 +0,0 @@
<?php
/**
* Tests unitaires de l'API d'Archives
* Initialisation
*/
use Spip\Archives\SpipArchives;
$test = 'initialiser archives';
$remonte = "";
while (!is_file($remonte."test.inc") and !is_dir($remonte.'ecrire/'))
$remonte = $remonte."../";
foreach ([$remonte."test.inc", $remonte."tests/test.inc", $remonte."tests/tests/legacy/test.inc"] as $f) {
if (is_file($f)){
require $f;
break;
}
}
if (!defined('_SPIP_TEST_INC')) {
die('Impossible de trouver test.inc depuis ' .getcwd());
}
$ok = true;
require __DIR__ . '/TestCase.inc';
archiviste_nettoyer_environnement_test();
include_spip('inc/archives');
$repertoire = archiviste_repertoire_de_test();
//extensions inconnues
foreach (array('sans_extension', 'extension_inconnue', 'faux_amis') as $cas) {
$archive = new SpipArchives(archiviste_fichier_de_test($cas));
if ($archive->erreur() !== 2) {
var_dump($archive->erreur(),$archive->message());
archiviste_finir_test("Echec creation d'une archive avec extensions incorrecte doit produire une erreur", $repertoire);
}
}
foreach (SpipArchives::compressionsConnues as $format) {
//presence fichier
$fichier = archiviste_fichier_de_test($format);
//fichier absent
$archive = new SpipArchives($fichier);
if ($archive->erreur() !== 3) {
var_dump($archive->erreur(),$archive->message());
archiviste_finir_test("[$format] Echec creation d'une nouvelle archive : doit produire une erreur fichier absent", $repertoire);
}
if ($archive->getLectureSeule()) {
var_dump($archive->erreur(),$archive->message());
archiviste_finir_test("[$format] Echec creation d'une nouvelle archive : ne doit pas etre en lecture seule", $repertoire);
}
if ($archive->deballer()) {
var_dump($archive->erreur(),$archive->message());
archiviste_finir_test("[$format] Echec creation d'une nouvelle archive : on ne peut deballer un fichier qui n'existe pas", $repertoire);
}
//fichier present
touch($fichier);
$archive = new SpipArchives($fichier);
if ($archive->erreur() !== false) {
var_dump($archive->erreur(),$archive->message());
archiviste_finir_test("[$format] Echec ouverture d'une archive existante : ne doit pas produire une erreur", $repertoire);
}
if ($archive->getLectureSeule()) {
var_dump($archive->erreur(),$archive->message());
archiviste_finir_test("[$format] Echec ouverture d'une archive existante : ne doit pas etre en lecture seule", $repertoire);
}
if ($archive->deballer($repertoire) or $archive->erreur() !== 5) {
var_dump($archive->erreur(),$archive->message());
archiviste_finir_test("[$format] Echec ouverture d'une archive existante : on ne peut pas deballer dans un repertoire qui n'existe pas", $repertoire);
}
// destination en lecture seule
mkdir($repertoire);
chmod($repertoire, 0500);
if ($archive->deballer($repertoire) or $archive->erreur() !== 5) {
var_dump($archive->erreur(),$archive->message());
archiviste_finir_test("[$format] Echec ouverture d'une archive existante : on ne peut pas deballer dans un repertoire en lecture seule", $repertoire);
}
chmod($repertoire, 0700);
//fichier en lecteure seule
chmod($fichier, 0400);
$archive = new SpipArchives($fichier);
if ($archive->erreur() !== false) {
var_dump($archive->erreur(),$archive->message());
archiviste_finir_test("[$format] Echec ouverture d'une archive existante en lecture seule : ne doit pas produire une erreur", $repertoire);
}
if (! $archive->getLectureSeule()){
var_dump($archive->erreur(), $archive->message());
archiviste_finir_test("[$format] Echec ouverture d'une archive existante en lecture seule : la lecture seule n'a pas ete detectee", $repertoire);
}
chmod($fichier, 0600);
//forcer le mode de compression
$fichier = archiviste_fichier_de_test('sans_extension');
touch($fichier);
$archive = new SpipArchives($fichier, $format);
if ($archive->erreur() !== false) {
var_dump($archive->erreur(),$archive->message());
archiviste_finir_test("[$format] Echec ouverture d'une archive existante dont on force le format : ne doit pas produire une erreur", $repertoire);
}
archiviste_nettoyer_contenu_de_test(archiviste_contenu_de_test(), $repertoire);
archiviste_nettoyer_environnement_test();
}
archiviste_finir_test(false, $repertoire);

79
tests/02_informer_archives.php

@ -1,79 +0,0 @@
<?php
/**
* Tests unitaires de l'API d'Archives
* Information sur les fichiers
*/
use Spip\Archives\SpipArchives;
$test = 'informer archives';
$remonte = "";
while (!is_file($remonte."test.inc") and !is_dir($remonte.'ecrire/'))
$remonte = $remonte."../";
foreach ([$remonte."test.inc", $remonte."tests/test.inc", $remonte."tests/tests/legacy/test.inc"] as $f) {
if (is_file($f)){
require $f;
break;
}
}
if (!defined('_SPIP_TEST_INC')) {
die('Impossible de trouver test.inc depuis ' .getcwd());
}
$ok = true;
require __DIR__ . '/TestCase.inc';
archiviste_nettoyer_environnement_test();
include_spip('inc/archives');
$destination = archiviste_repertoire_de_test();
foreach (SpipArchives::compressionsConnues as $format){
$fichier = archiviste_fichier_de_test($format);
archiviste_generer_archive_de_test($fichier, $format);
$archive = new SpipArchives($fichier);
$infos = $archive->informer();
if (!$infos){
var_dump($archive->erreur(), $archive->message());
archiviste_finir_test("[$format] Echec archive->informer()", $destination);
}
if (!isset($infos['fichiers'])){
var_dump($infos);
archiviste_finir_test("[$format] Entree fichiers manquante dans archive->informer()", $destination);
}
if (empty($infos['fichiers'])){
var_dump($infos);
archiviste_finir_test("[$format] Entree fichiers vide dans archive->informer()", $destination);
}
if (count($infos['fichiers'])!==2){
archiviste_finir_test("[$format] Echec archive->informer()", $destination);
}
if (!archiviste_trouver_fichier('test.txt', $infos['fichiers'])){
archiviste_finir_test("[$format] Fichier test.txt absent de archive->informer()", $destination);
}
if (!archiviste_trouver_fichier('sousrep/fichier', $infos['fichiers'])){
archiviste_finir_test("[$format] Fichier sousrep/fichier absent de archive->informer()", $destination);
}
if (empty($infos['proprietes'])){
var_dump($infos);
archiviste_finir_test("[$format] Entree proprietes manquante dans archive->informer()", $destination);
}
if ($infos['proprietes']['racine']!==''){
var_dump($infos);
archiviste_finir_test("[$format] Entree proprietes/racine incorrecte dans archive->informer()", $destination);
}
archiviste_nettoyer_contenu_de_test(archiviste_contenu_de_test(), $destination);
archiviste_nettoyer_environnement_test();
}
archiviste_finir_test(false, $destination);

40
tests/03_deballer_archives.php

@ -1,40 +0,0 @@
<?php
/**
* Tests unitaires de l'API d'Archives
* Extraction de fichiers
*/
use Spip\Archives\SpipArchives;
$test = 'deballer archives';
$remonte = "";
while (!is_file($remonte."test.inc") and !is_dir($remonte.'ecrire/'))
$remonte = $remonte."../";
foreach ([$remonte."test.inc", $remonte."tests/test.inc", $remonte."tests/tests/legacy/test.inc"] as $f) {
if (is_file($f)){
require $f;
break;
}
}
if (!defined('_SPIP_TEST_INC')) {
die('Impossible de trouver test.inc depuis ' .getcwd());
}
$ok = true;
require __DIR__ . '/TestCase.inc';
archiviste_nettoyer_environnement_test();
include_spip('inc/archives');
$destination = archiviste_repertoire_de_test();
foreach (SpipArchives::compressionsConnues as $format){
$fichier = archiviste_fichier_de_test($format);
archiviste_generer_archive_de_test($fichier, $format);
archiviste_teste_deballer($fichier, $format);
}
archiviste_finir_test(false, $destination);

54
tests/04_emballer_archives.php

@ -1,54 +0,0 @@
<?php
/**
* Tests unitaires de l'API d'Archives
* Production de fichiers
*/
use Spip\Archives\SpipArchives;
$test = 'emballer archives';
$remonte = "";
while (!is_file($remonte."test.inc") and !is_dir($remonte.'ecrire/'))
$remonte = $remonte."../";
foreach ([$remonte."test.inc", $remonte."tests/test.inc", $remonte."tests/tests/legacy/test.inc"] as $f) {
if (is_file($f)){
require $f;
break;
}
}
if (!defined('_SPIP_TEST_INC')) {
die('Impossible de trouver test.inc depuis ' .getcwd());
}
$ok = true;
require __DIR__ . '/TestCase.inc';
archiviste_nettoyer_environnement_test();
include_spip('inc/archives');
$destination = archiviste_repertoire_de_test() . '/';
foreach (SpipArchives::compressionsConnues as $format){
$fichier = archiviste_fichier_de_test($format);
$files_list = archiviste_generer_contenu_de_test(archiviste_contenu_de_test());
$archive = new SpipArchives($fichier);
if (!$archive->emballer($files_list)){
var_dump($archive->erreur(), $archive->message());
archiviste_finir_test("[$format] Echec emballer " . json_encode($files_list), $destination);
}
archiviste_nettoyer_contenu_de_test(archiviste_contenu_de_test(), $destination);
$infos = $archive->informer();
if (!$infos or count($infos['fichiers'])!==count($files_list)){
var_dump($infos);
archiviste_finir_test("[$format] Echec emballer : nombre de fichiers incorrects", $destination);
}
archiviste_teste_deballer($fichier, $format);
}
archiviste_finir_test(false, $destination);

75
tests/05_retirer_archives.php

@ -1,75 +0,0 @@
<?php
/**
* Tests unitaires de l'API d'Archives
* Production, mise à jour de fichiers
*/
use Spip\Archives\SpipArchives;
$test = 'retirer archives';
$remonte = "";
while (!is_file($remonte."test.inc") and !is_dir($remonte.'ecrire/'))
$remonte = $remonte."../";
foreach ([$remonte."test.inc", $remonte."tests/test.inc", $remonte."tests/tests/legacy/test.inc"] as $f) {
if (is_file($f)){
require $f;
break;
}
}
if (!defined('_SPIP_TEST_INC')) {
die('Impossible de trouver test.inc depuis ' .getcwd());
}
$ok = true;
require __DIR__ . '/TestCase.inc';
archiviste_nettoyer_environnement_test();
include_spip('inc/archives');
$destination = archiviste_repertoire_de_test();
foreach (SpipArchives::compressionsConnues as $format){
$fichier = archiviste_fichier_de_test($format);
archiviste_generer_archive_de_test($fichier, $format);
$archive = new SpipArchives($fichier);
$infos = $archive->informer();
$nb_files = count($infos['fichiers']);
if (!$archive->retirer(array('test.txt'))){
var_dump($archive->erreur(), $archive->message());
archiviste_finir_test("[$format] Echec retirer [test.txt]", $destination);
}
$infos = $archive->informer();
if (count($infos['fichiers'])!==$nb_files-1){
var_dump($infos);
archiviste_finir_test("[$format] retirer [test.txt] : nombre de fichiers innatendus apres", $destination);
}
@unlink($fichier);
archiviste_generer_archive_de_test($fichier, $format);
if (!$archive->retirer(array('sousrep/fichier'))){
var_dump($archive->erreur(), $archive->message());
archiviste_finir_test("[$format] Echec retirer [sousrep/fichier]", $destination);
}
$infos = $archive->informer();
if (count($infos['fichiers'])!==$nb_files-1){
var_dump($infos);
archiviste_finir_test("[$format] retirer [sousrep/fichier] : nombre de fichiers innatendus apres", $destination);
}
if (!$archive->retirer(array('dir/fichierinexistant'))
or $archive->erreur()){
var_dump($archive->erreur(), $archive->message());
archiviste_finir_test("[$format] Echec retirer [dir/fichierinexistant] n'aurait pas du produire une erreur", $destination);
}
}
archiviste_finir_test(false, $destination);

246
tests/ArchivisteTest.php

@ -0,0 +1,246 @@
<?php
/***************************************************************************\
* SPIP, Système de publication pour l'internet *
* *
* Copyright © avec tendresse depuis 2001 *
* Arnaud Martin, Antoine Pitrou, Philippe Rivière, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribué sous licence GNU/GPL. *
* Pour plus de détails voir le fichier COPYING.txt ou l'aide en ligne. *
* \***************************************************************************/
namespace Spip\Core\Tests;
use PHPUnit\Framework\TestCase;
use Spip\Archives\SpipArchives;
/**
* ArchivisteTest test
*
*/
class ArchivisteTest extends TestCase {
protected $repertoire;
protected function tearDown(): void{
if ($this->repertoire){
archiviste_nettoyer_contenu_de_test(archiviste_contenu_de_test(), $this->repertoire);
}
archiviste_nettoyer_environnement_test();
$this->repertoire = '';
}
protected function afficheArchiveErreur($archive, $message){
return ($message ? $message : "Echec erreur innatendue")
. "\nErreur : " . $archive->erreur()
. " | Message: " . $archive->message();
}
protected function assertArchiveErreur($expectedError, $archive, $message = ''){
$this->assertEquals($expectedError, $archive->erreur(), $this->afficheArchiveErreur($archive, $message));
}
protected function verifierDeballerArchive($fichier, $format): void{
$this->repertoire = archiviste_repertoire_de_test();
$archive = new SpipArchives($fichier);
$this->assertTrue($archive->deballer($this->repertoire, array('test.txt')), $this->afficheArchiveErreur($archive, "[$format] Echec deballer [test.txt]"));
$this->assertFileExists($f = $this->repertoire . '/test.txt', $this->afficheArchiveErreur($archive, "[$format] Fichier $f absent"));
$this->assertFileDoesNotExist($f = $this->repertoire . '/sousrep/fichier', $this->afficheArchiveErreur($archive, "[$format] Fichier $f present mais pas demande"));
archiviste_nettoyer_contenu_de_test(archiviste_contenu_de_test(), $this->repertoire);
$this->assertTrue($archive->deballer($this->repertoire), $this->afficheArchiveErreur($archive, "[$format] Echec deballer"));
$this->assertFileExists($f = $this->repertoire . '/test.txt', $this->afficheArchiveErreur($archive, "[$format] Fichier $f absent"));
$this->assertFileExists($f = $this->repertoire . '/sousrep/fichier', $this->afficheArchiveErreur($archive, "[$format] Fichier $f absent"));
archiviste_nettoyer_contenu_de_test(archiviste_contenu_de_test(), $this->repertoire);
}
public function testInitialiserArchives(): void{
require_once __DIR__ . '/TestCase.inc';
archiviste_nettoyer_environnement_test();
include_spip('inc/archives');
$this->repertoire = archiviste_repertoire_de_test();
//extensions inconnues
foreach (array('sans_extension', 'extension_inconnue', 'faux_amis') as $cas){
$archive = new SpipArchives(archiviste_fichier_de_test($cas));
$this->assertArchiveErreur(2, $archive, "Echec creation d'une archive avec extensions incorrecte doit produire une erreur");
}
foreach (SpipArchives::compressionsConnues as $format){
//presence fichier
$fichier = archiviste_fichier_de_test($format);
//fichier absent
$archive = new SpipArchives($fichier);
$this->assertArchiveErreur(3, $archive, "[$format] Echec creation d'une nouvelle archive : doit produire une erreur fichier absent");
$this->assertFalse($archive->getLectureSeule(), $this->afficheArchiveErreur($archive, "[$format] Echec creation d'une nouvelle archive : ne doit pas etre en lecture seule"));
$this->assertFalse($archive->deballer(), $this->afficheArchiveErreur($archive, "[$format] Echec creation d'une nouvelle archive : on ne peut deballer un fichier qui n'existe pas"));
//fichier present
touch($fichier);
$archive = new SpipArchives($fichier);
$this->assertFalse($archive->erreur(), $this->afficheArchiveErreur($archive, "[$format] Echec ouverture d'une archive existante : ne doit pas produire une erreur"));
$this->assertFalse($archive->getLectureSeule(), $this->afficheArchiveErreur($archive, "[$format] Echec ouverture d'une archive existante : ne doit pas etre en lecture seule"));
$this->assertFalse($archive->deballer($this->repertoire), $this->afficheArchiveErreur($archive, "[$format] Echec ouverture d'une archive existante : on ne peut pas deballer dans un repertoire qui n'existe pas"));
$this->assertArchiveErreur(5, $archive, "[$format] Echec ouverture d'une archive existante : on ne peut pas deballer dans un repertoire qui n'existe pas");
// destination en lecture seule
mkdir($this->repertoire);
chmod($this->repertoire, 0500);
$this->assertFalse($archive->deballer($this->repertoire), $this->afficheArchiveErreur($archive, "[$format] Echec ouverture d'une archive existante : on ne peut pas deballer dans un repertoire en lecture seule"));
$this->assertArchiveErreur(5, $archive, "[$format] Echec ouverture d'une archive existante : on ne peut pas deballer dans un repertoire en lecture seule");
chmod($this->repertoire, 0700);
//fichier en lecteure seule
chmod($fichier, 0400);
$archive = new SpipArchives($fichier);
$this->assertFalse($archive->erreur(), $this->afficheArchiveErreur($archive, "[$format] Echec ouverture d'une archive existante en lecture seule : ne doit pas produire une erreur"));
$this->assertTrue($archive->getLectureSeule(), $this->afficheArchiveErreur($archive, "[$format] Echec ouverture d'une archive existante en lecture seule : la lecture seule n'a pas ete detectee"));
chmod($fichier, 0600);
//forcer le mode de compression
$fichier = archiviste_fichier_de_test('sans_extension');
touch($fichier);
$archive = new SpipArchives($fichier, $format);
$this->assertFalse($archive->erreur(), $this->afficheArchiveErreur($archive, "[$format] Echec ouverture d'une archive existante dont on force le format : ne doit pas produire une erreur"));
archiviste_nettoyer_contenu_de_test(archiviste_contenu_de_test(), $this->repertoire);
archiviste_nettoyer_environnement_test();
}
}
/**
* @depends testInitialiserArchives
*/
public function testInformerArchives(): void{
require_once __DIR__ . '/TestCase.inc';
archiviste_nettoyer_environnement_test();
include_spip('inc/archives');
$this->repertoire = archiviste_repertoire_de_test();
foreach (SpipArchives::compressionsConnues as $format){
$fichier = archiviste_fichier_de_test($format);
archiviste_generer_archive_de_test($fichier, $format);
$archive = new SpipArchives($fichier);
$infos = $archive->informer();
$this->assertNotEmpty($infos, $this->afficheArchiveErreur($archive, "[$format] Echec archive->informer()"));
$this->assertArrayHasKey('fichiers', $infos, $this->afficheArchiveErreur($archive, "[$format] Entree fichiers manquante dans archive->informer()"));
$this->assertNotEmpty($infos['fichiers'], $this->afficheArchiveErreur($archive, "[$format] Entree fichiers vide dans archive->informer()"));
$this->assertCount(2, $infos['fichiers'], $this->afficheArchiveErreur($archive, "[$format] Echec archive->informer()"));
$this->assertNotEmpty(archiviste_trouver_fichier('test.txt', $infos['fichiers']), $this->afficheArchiveErreur($archive, "[$format] Fichier test.txt absent de archive->informer()"));
$this->assertNotEmpty(archiviste_trouver_fichier('sousrep/fichier', $infos['fichiers']), $this->afficheArchiveErreur($archive, "[$format] Fichier sousrep/fichier absent de archive->informer()"));
$this->assertNotEmpty($infos['proprietes'], $this->afficheArchiveErreur($archive, "[$format] Entree proprietes manquante dans archive->informer()"));
$this->assertEquals('', $infos['proprietes']['racine'], $this->afficheArchiveErreur($archive, "[$format] Entree proprietes/racine incorrecte dans archive->informer()"));
archiviste_nettoyer_contenu_de_test(archiviste_contenu_de_test(), $this->repertoire);
archiviste_nettoyer_environnement_test();
}
}
/**
* @depends testInformerArchives
*/
public function testDeballerArchives(): void{
require_once __DIR__ . '/TestCase.inc';
archiviste_nettoyer_environnement_test();
include_spip('inc/archives');
foreach (SpipArchives::compressionsConnues as $format){
$fichier = archiviste_fichier_de_test($format);
archiviste_generer_archive_de_test($fichier, $format);
$this->verifierDeballerArchive($fichier, $format);
}
}
/**
* @depends testDeballerArchives
*/
public function testEmballerArchives(): void{
require_once __DIR__ . '/TestCase.inc';
archiviste_nettoyer_environnement_test();
include_spip('inc/archives');
$this->repertoire = archiviste_repertoire_de_test();
foreach (SpipArchives::compressionsConnues as $format){
$fichier = archiviste_fichier_de_test($format);
$files_list = archiviste_generer_contenu_de_test(archiviste_contenu_de_test());
$archive = new SpipArchives($fichier);
$this->assertTrue($archive->emballer($files_list), $this->afficheArchiveErreur($archive, "[$format] Echec emballer " . json_encode($files_list)));
archiviste_nettoyer_contenu_de_test(archiviste_contenu_de_test(), $this->repertoire);
$infos = $archive->informer();
$this->assertNotEmpty($infos, $this->afficheArchiveErreur($archive, "[$format] Echec emballer : nombre de fichiers incorrects"));
$this->assertCount(count($files_list), $infos['fichiers'], $this->afficheArchiveErreur($archive, "[$format] Echec emballer : nombre de fichiers incorrects"));
$this->verifierDeballerArchive($fichier, $format);
}
}
/**
* @depends testEmballerArchives
*/
public function testRetirerArchives(): void{
require_once __DIR__ . '/TestCase.inc';
archiviste_nettoyer_environnement_test();
include_spip('inc/archives');
$this->repertoire = archiviste_repertoire_de_test();
foreach (SpipArchives::compressionsConnues as $format){
$fichier = archiviste_fichier_de_test($format);
archiviste_generer_archive_de_test($fichier, $format);
$archive = new SpipArchives($fichier);
$infos = $archive->informer();
$nb_files = count($infos['fichiers']);
$this->assertTrue($archive->retirer(array('test.txt')), $this->afficheArchiveErreur($archive, "[$format] Echec retirer [test.txt]"));
$infos = $archive->informer();
$this->assertCount($nb_files-1, $infos['fichiers'], "[$format] retirer [test.txt] : nombre de fichiers innatendus apres\n" . json_encode($infos));
@unlink($fichier);
archiviste_generer_archive_de_test($fichier, $format);
$this->assertTrue($archive->retirer(array('sousrep/fichier')), $this->afficheArchiveErreur($archive, "[$format] Echec retirer [sousrep/fichier]"));
$infos = $archive->informer();
$this->assertCount($nb_files-1, $infos['fichiers'], "[$format] retirer [sousrep/fichier] : nombre de fichiers innatendus apres\n" . json_encode($infos));
$this->assertTrue($archive->retirer(array('dir/fichierinexistant')), $this->afficheArchiveErreur($archive, "[$format] Echec retirer [dir/fichierinexistant] n'aurait pas du produire une erreur"));
$this->assertFalse($archive->erreur(), $this->afficheArchiveErreur($archive, "[$format] Echec retirer [dir/fichierinexistant] n'aurait pas du produire une erreur"));
}
}
}

42
tests/TestCase.inc

@ -128,48 +128,6 @@ function archiviste_nettoyer_contenu_de_test(array $fichiers = array(), $arbores
}
}
function archiviste_finir_test($erreur, $destination) {
archiviste_nettoyer_contenu_de_test(archiviste_contenu_de_test(), $destination);
archiviste_nettoyer_environnement_test();
if (!$erreur) {
echo 'OK';
}
else {
die($erreur);
}
}
function archiviste_teste_deballer($fichier, $format) {
$destination = archiviste_repertoire_de_test();
$archive = new Spip\Archives\SpipArchives($fichier);
if (!$archive->deballer($destination, array('test.txt'))) {
archiviste_finir_test("[$format] Echec deballer [test.txt]", $destination);
}
if (!file_exists($f = $destination . '/test.txt')) {
archiviste_finir_test("[$format] Fichier $f absent", $destination);
}
if (file_exists($f = $destination . '/sousrep/fichier')) {
archiviste_finir_test("[$format] Fichier $f present mais pas demande", $destination);
}
archiviste_nettoyer_contenu_de_test(archiviste_contenu_de_test(), $destination);
if (!$archive->deballer($destination)){
archiviste_finir_test("[$format] Echec deballer", $destination);
}
if (!file_exists($f = $destination . '/test.txt')) {
archiviste_finir_test("[$format] Fichier $f absent", $destination);
}
if (!file_exists($f = $destination . '/sousrep/fichier')) {
archiviste_finir_test("[$format] Fichier $f absent", $destination);
}
archiviste_nettoyer_contenu_de_test(archiviste_contenu_de_test(), $destination);
}
function archiviste_trouver_fichier($fileName, $files) {
foreach ($files as $file) {

Loading…
Cancel
Save