MediaWiki  1.28.0
FileBackendTest.php
Go to the documentation of this file.
1 <?php
2 
8 class FileBackendTest extends MediaWikiTestCase {
9 
11  private $backend;
13  private $multiBackend;
15  public $singleBackend;
16  private static $backendToUse;
17 
18  protected function setUp() {
19  global $wgFileBackends;
20  parent::setUp();
21  $tmpDir = $this->getNewTempDirectory();
22  if ( $this->getCliArg( 'use-filebackend' ) ) {
23  if ( self::$backendToUse ) {
24  $this->singleBackend = self::$backendToUse;
25  } else {
26  $name = $this->getCliArg( 'use-filebackend' );
27  $useConfig = [];
28  foreach ( $wgFileBackends as $conf ) {
29  if ( $conf['name'] == $name ) {
30  $useConfig = $conf;
31  break;
32  }
33  }
34  $useConfig['name'] = 'localtesting'; // swap name
35  $useConfig['shardViaHashLevels'] = [ // test sharding
36  'unittest-cont1' => [ 'levels' => 1, 'base' => 16, 'repeat' => 1 ]
37  ];
38  if ( isset( $useConfig['fileJournal'] ) ) {
39  $useConfig['fileJournal'] = FileJournal::factory( $useConfig['fileJournal'], $name );
40  }
41  $useConfig['lockManager'] = LockManagerGroup::singleton()->get( $useConfig['lockManager'] );
42  $class = $useConfig['class'];
43  self::$backendToUse = new $class( $useConfig );
44  $this->singleBackend = self::$backendToUse;
45  }
46  } else {
47  $this->singleBackend = new FSFileBackend( [
48  'name' => 'localtesting',
49  'lockManager' => LockManagerGroup::singleton()->get( 'fsLockManager' ),
50  'wikiId' => wfWikiID(),
51  'containerPaths' => [
52  'unittest-cont1' => "{$tmpDir}/localtesting-cont1",
53  'unittest-cont2' => "{$tmpDir}/localtesting-cont2" ]
54  ] );
55  }
56  $this->multiBackend = new FileBackendMultiWrite( [
57  'name' => 'localtesting',
58  'lockManager' => LockManagerGroup::singleton()->get( 'fsLockManager' ),
59  'parallelize' => 'implicit',
60  'wikiId' => wfWikiID() . wfRandomString(),
61  'backends' => [
62  [
63  'name' => 'localmultitesting1',
64  'class' => 'FSFileBackend',
65  'containerPaths' => [
66  'unittest-cont1' => "{$tmpDir}/localtestingmulti1-cont1",
67  'unittest-cont2' => "{$tmpDir}/localtestingmulti1-cont2" ],
68  'isMultiMaster' => false
69  ],
70  [
71  'name' => 'localmultitesting2',
72  'class' => 'FSFileBackend',
73  'containerPaths' => [
74  'unittest-cont1' => "{$tmpDir}/localtestingmulti2-cont1",
75  'unittest-cont2' => "{$tmpDir}/localtestingmulti2-cont2" ],
76  'isMultiMaster' => true
77  ]
78  ]
79  ] );
80  }
81 
82  private static function baseStorePath() {
83  return 'mwstore://localtesting';
84  }
85 
86  private function backendClass() {
87  return get_class( $this->backend );
88  }
89 
94  public function testIsStoragePath( $path, $isStorePath ) {
95  $this->assertEquals( $isStorePath, FileBackend::isStoragePath( $path ),
96  "FileBackend::isStoragePath on path '$path'" );
97  }
98 
99  public static function provider_testIsStoragePath() {
100  return [
101  [ 'mwstore://', true ],
102  [ 'mwstore://backend', true ],
103  [ 'mwstore://backend/container', true ],
104  [ 'mwstore://backend/container/', true ],
105  [ 'mwstore://backend/container/path', true ],
106  [ 'mwstore://backend//container/', true ],
107  [ 'mwstore://backend//container//', true ],
108  [ 'mwstore://backend//container//path', true ],
109  [ 'mwstore:///', true ],
110  [ 'mwstore:/', false ],
111  [ 'mwstore:', false ],
112  ];
113  }
114 
119  public function testSplitStoragePath( $path, $res ) {
120  $this->assertEquals( $res, FileBackend::splitStoragePath( $path ),
121  "FileBackend::splitStoragePath on path '$path'" );
122  }
123 
124  public static function provider_testSplitStoragePath() {
125  return [
126  [ 'mwstore://backend/container', [ 'backend', 'container', '' ] ],
127  [ 'mwstore://backend/container/', [ 'backend', 'container', '' ] ],
128  [ 'mwstore://backend/container/path', [ 'backend', 'container', 'path' ] ],
129  [ 'mwstore://backend/container//path', [ 'backend', 'container', '/path' ] ],
130  [ 'mwstore://backend//container/path', [ null, null, null ] ],
131  [ 'mwstore://backend//container//path', [ null, null, null ] ],
132  [ 'mwstore://', [ null, null, null ] ],
133  [ 'mwstore://backend', [ null, null, null ] ],
134  [ 'mwstore:///', [ null, null, null ] ],
135  [ 'mwstore:/', [ null, null, null ] ],
136  [ 'mwstore:', [ null, null, null ] ]
137  ];
138  }
139 
144  public function testNormalizeStoragePath( $path, $res ) {
145  $this->assertEquals( $res, FileBackend::normalizeStoragePath( $path ),
146  "FileBackend::normalizeStoragePath on path '$path'" );
147  }
148 
149  public static function provider_normalizeStoragePath() {
150  return [
151  [ 'mwstore://backend/container', 'mwstore://backend/container' ],
152  [ 'mwstore://backend/container/', 'mwstore://backend/container' ],
153  [ 'mwstore://backend/container/path', 'mwstore://backend/container/path' ],
154  [ 'mwstore://backend/container//path', 'mwstore://backend/container/path' ],
155  [ 'mwstore://backend/container///path', 'mwstore://backend/container/path' ],
156  [
157  'mwstore://backend/container///path//to///obj',
158  'mwstore://backend/container/path/to/obj'
159  ],
160  [ 'mwstore://', null ],
161  [ 'mwstore://backend', null ],
162  [ 'mwstore://backend//container/path', null ],
163  [ 'mwstore://backend//container//path', null ],
164  [ 'mwstore:///', null ],
165  [ 'mwstore:/', null ],
166  [ 'mwstore:', null ],
167  ];
168  }
169 
174  public function testParentStoragePath( $path, $res ) {
175  $this->assertEquals( $res, FileBackend::parentStoragePath( $path ),
176  "FileBackend::parentStoragePath on path '$path'" );
177  }
178 
179  public static function provider_testParentStoragePath() {
180  return [
181  [ 'mwstore://backend/container/path/to/obj', 'mwstore://backend/container/path/to' ],
182  [ 'mwstore://backend/container/path/to', 'mwstore://backend/container/path' ],
183  [ 'mwstore://backend/container/path', 'mwstore://backend/container' ],
184  [ 'mwstore://backend/container', null ],
185  [ 'mwstore://backend/container/path/to/obj/', 'mwstore://backend/container/path/to' ],
186  [ 'mwstore://backend/container/path/to/', 'mwstore://backend/container/path' ],
187  [ 'mwstore://backend/container/path/', 'mwstore://backend/container' ],
188  [ 'mwstore://backend/container/', null ],
189  ];
190  }
191 
196  public function testExtensionFromPath( $path, $res ) {
197  $this->assertEquals( $res, FileBackend::extensionFromPath( $path ),
198  "FileBackend::extensionFromPath on path '$path'" );
199  }
200 
201  public static function provider_testExtensionFromPath() {
202  return [
203  [ 'mwstore://backend/container/path.txt', 'txt' ],
204  [ 'mwstore://backend/container/path.svg.png', 'png' ],
205  [ 'mwstore://backend/container/path', '' ],
206  [ 'mwstore://backend/container/path.', '' ],
207  ];
208  }
209 
213  public function testStore( $op ) {
214  $this->addTmpFiles( $op['src'] );
215 
216  $this->backend = $this->singleBackend;
217  $this->tearDownFiles();
218  $this->doTestStore( $op );
219  $this->tearDownFiles();
220 
221  $this->backend = $this->multiBackend;
222  $this->tearDownFiles();
223  $this->doTestStore( $op );
224  $this->tearDownFiles();
225  }
226 
230  private function doTestStore( $op ) {
231  $backendName = $this->backendClass();
232 
233  $source = $op['src'];
234  $dest = $op['dst'];
235  $this->prepare( [ 'dir' => dirname( $dest ) ] );
236 
237  file_put_contents( $source, "Unit test file" );
238 
239  if ( isset( $op['overwrite'] ) || isset( $op['overwriteSame'] ) ) {
240  $this->backend->store( $op );
241  }
242 
243  $status = $this->backend->doOperation( $op );
244 
245  $this->assertGoodStatus( $status,
246  "Store from $source to $dest succeeded without warnings ($backendName)." );
247  $this->assertEquals( true, $status->isOK(),
248  "Store from $source to $dest succeeded ($backendName)." );
249  $this->assertEquals( [ 0 => true ], $status->success,
250  "Store from $source to $dest has proper 'success' field in Status ($backendName)." );
251  $this->assertEquals( true, file_exists( $source ),
252  "Source file $source still exists ($backendName)." );
253  $this->assertEquals( true, $this->backend->fileExists( [ 'src' => $dest ] ),
254  "Destination file $dest exists ($backendName)." );
255 
256  $this->assertEquals( filesize( $source ),
257  $this->backend->getFileSize( [ 'src' => $dest ] ),
258  "Destination file $dest has correct size ($backendName)." );
259 
260  $props1 = FSFile::getPropsFromPath( $source );
261  $props2 = $this->backend->getFileProps( [ 'src' => $dest ] );
262  $this->assertEquals( $props1, $props2,
263  "Source and destination have the same props ($backendName)." );
264 
265  $this->assertBackendPathsConsistent( [ $dest ] );
266  }
267 
268  public static function provider_testStore() {
269  $cases = [];
270 
271  $tmpName = TempFSFile::factory( "unittests_", 'txt', wfTempDir() )->getPath();
272  $toPath = self::baseStorePath() . '/unittest-cont1/e/fun/obj1.txt';
273  $op = [ 'op' => 'store', 'src' => $tmpName, 'dst' => $toPath ];
274  $cases[] = [ $op ];
275 
276  $op2 = $op;
277  $op2['overwrite'] = true;
278  $cases[] = [ $op2 ];
279 
280  $op3 = $op;
281  $op3['overwriteSame'] = true;
282  $cases[] = [ $op3 ];
283 
284  return $cases;
285  }
286 
291  public function testCopy( $op ) {
292  $this->backend = $this->singleBackend;
293  $this->tearDownFiles();
294  $this->doTestCopy( $op );
295  $this->tearDownFiles();
296 
297  $this->backend = $this->multiBackend;
298  $this->tearDownFiles();
299  $this->doTestCopy( $op );
300  $this->tearDownFiles();
301  }
302 
303  private function doTestCopy( $op ) {
304  $backendName = $this->backendClass();
305 
306  $source = $op['src'];
307  $dest = $op['dst'];
308  $this->prepare( [ 'dir' => dirname( $source ) ] );
309  $this->prepare( [ 'dir' => dirname( $dest ) ] );
310 
311  if ( isset( $op['ignoreMissingSource'] ) ) {
312  $status = $this->backend->doOperation( $op );
313  $this->assertGoodStatus( $status,
314  "Move from $source to $dest succeeded without warnings ($backendName)." );
315  $this->assertEquals( [ 0 => true ], $status->success,
316  "Move from $source to $dest has proper 'success' field in Status ($backendName)." );
317  $this->assertEquals( false, $this->backend->fileExists( [ 'src' => $source ] ),
318  "Source file $source does not exist ($backendName)." );
319  $this->assertEquals( false, $this->backend->fileExists( [ 'src' => $dest ] ),
320  "Destination file $dest does not exist ($backendName)." );
321 
322  return; // done
323  }
324 
325  $status = $this->backend->doOperation(
326  [ 'op' => 'create', 'content' => 'blahblah', 'dst' => $source ] );
327  $this->assertGoodStatus( $status,
328  "Creation of file at $source succeeded ($backendName)." );
329 
330  if ( isset( $op['overwrite'] ) || isset( $op['overwriteSame'] ) ) {
331  $this->backend->copy( $op );
332  }
333 
334  $status = $this->backend->doOperation( $op );
335 
336  $this->assertGoodStatus( $status,
337  "Copy from $source to $dest succeeded without warnings ($backendName)." );
338  $this->assertEquals( true, $status->isOK(),
339  "Copy from $source to $dest succeeded ($backendName)." );
340  $this->assertEquals( [ 0 => true ], $status->success,
341  "Copy from $source to $dest has proper 'success' field in Status ($backendName)." );
342  $this->assertEquals( true, $this->backend->fileExists( [ 'src' => $source ] ),
343  "Source file $source still exists ($backendName)." );
344  $this->assertEquals( true, $this->backend->fileExists( [ 'src' => $dest ] ),
345  "Destination file $dest exists after copy ($backendName)." );
346 
347  $this->assertEquals(
348  $this->backend->getFileSize( [ 'src' => $source ] ),
349  $this->backend->getFileSize( [ 'src' => $dest ] ),
350  "Destination file $dest has correct size ($backendName)." );
351 
352  $props1 = $this->backend->getFileProps( [ 'src' => $source ] );
353  $props2 = $this->backend->getFileProps( [ 'src' => $dest ] );
354  $this->assertEquals( $props1, $props2,
355  "Source and destination have the same props ($backendName)." );
356 
357  $this->assertBackendPathsConsistent( [ $source, $dest ] );
358  }
359 
360  public static function provider_testCopy() {
361  $cases = [];
362 
363  $source = self::baseStorePath() . '/unittest-cont1/e/file.txt';
364  $dest = self::baseStorePath() . '/unittest-cont2/a/fileMoved.txt';
365 
366  $op = [ 'op' => 'copy', 'src' => $source, 'dst' => $dest ];
367  $cases[] = [
368  $op, // operation
369  $source, // source
370  $dest, // dest
371  ];
372 
373  $op2 = $op;
374  $op2['overwrite'] = true;
375  $cases[] = [
376  $op2, // operation
377  $source, // source
378  $dest, // dest
379  ];
380 
381  $op2 = $op;
382  $op2['overwriteSame'] = true;
383  $cases[] = [
384  $op2, // operation
385  $source, // source
386  $dest, // dest
387  ];
388 
389  $op2 = $op;
390  $op2['ignoreMissingSource'] = true;
391  $cases[] = [
392  $op2, // operation
393  $source, // source
394  $dest, // dest
395  ];
396 
397  $op2 = $op;
398  $op2['ignoreMissingSource'] = true;
399  $cases[] = [
400  $op2, // operation
401  self::baseStorePath() . '/unittest-cont-bad/e/file.txt', // source
402  $dest, // dest
403  ];
404 
405  return $cases;
406  }
407 
412  public function testMove( $op ) {
413  $this->backend = $this->singleBackend;
414  $this->tearDownFiles();
415  $this->doTestMove( $op );
416  $this->tearDownFiles();
417 
418  $this->backend = $this->multiBackend;
419  $this->tearDownFiles();
420  $this->doTestMove( $op );
421  $this->tearDownFiles();
422  }
423 
424  private function doTestMove( $op ) {
425  $backendName = $this->backendClass();
426 
427  $source = $op['src'];
428  $dest = $op['dst'];
429  $this->prepare( [ 'dir' => dirname( $source ) ] );
430  $this->prepare( [ 'dir' => dirname( $dest ) ] );
431 
432  if ( isset( $op['ignoreMissingSource'] ) ) {
433  $status = $this->backend->doOperation( $op );
434  $this->assertGoodStatus( $status,
435  "Move from $source to $dest succeeded without warnings ($backendName)." );
436  $this->assertEquals( [ 0 => true ], $status->success,
437  "Move from $source to $dest has proper 'success' field in Status ($backendName)." );
438  $this->assertEquals( false, $this->backend->fileExists( [ 'src' => $source ] ),
439  "Source file $source does not exist ($backendName)." );
440  $this->assertEquals( false, $this->backend->fileExists( [ 'src' => $dest ] ),
441  "Destination file $dest does not exist ($backendName)." );
442 
443  return; // done
444  }
445 
446  $status = $this->backend->doOperation(
447  [ 'op' => 'create', 'content' => 'blahblah', 'dst' => $source ] );
448  $this->assertGoodStatus( $status,
449  "Creation of file at $source succeeded ($backendName)." );
450 
451  if ( isset( $op['overwrite'] ) || isset( $op['overwriteSame'] ) ) {
452  $this->backend->copy( $op );
453  }
454 
455  $status = $this->backend->doOperation( $op );
456  $this->assertGoodStatus( $status,
457  "Move from $source to $dest succeeded without warnings ($backendName)." );
458  $this->assertEquals( true, $status->isOK(),
459  "Move from $source to $dest succeeded ($backendName)." );
460  $this->assertEquals( [ 0 => true ], $status->success,
461  "Move from $source to $dest has proper 'success' field in Status ($backendName)." );
462  $this->assertEquals( false, $this->backend->fileExists( [ 'src' => $source ] ),
463  "Source file $source does not still exists ($backendName)." );
464  $this->assertEquals( true, $this->backend->fileExists( [ 'src' => $dest ] ),
465  "Destination file $dest exists after move ($backendName)." );
466 
467  $this->assertNotEquals(
468  $this->backend->getFileSize( [ 'src' => $source ] ),
469  $this->backend->getFileSize( [ 'src' => $dest ] ),
470  "Destination file $dest has correct size ($backendName)." );
471 
472  $props1 = $this->backend->getFileProps( [ 'src' => $source ] );
473  $props2 = $this->backend->getFileProps( [ 'src' => $dest ] );
474  $this->assertEquals( false, $props1['fileExists'],
475  "Source file does not exist accourding to props ($backendName)." );
476  $this->assertEquals( true, $props2['fileExists'],
477  "Destination file exists accourding to props ($backendName)." );
478 
479  $this->assertBackendPathsConsistent( [ $source, $dest ] );
480  }
481 
482  public static function provider_testMove() {
483  $cases = [];
484 
485  $source = self::baseStorePath() . '/unittest-cont1/e/file.txt';
486  $dest = self::baseStorePath() . '/unittest-cont2/a/fileMoved.txt';
487 
488  $op = [ 'op' => 'move', 'src' => $source, 'dst' => $dest ];
489  $cases[] = [
490  $op, // operation
491  $source, // source
492  $dest, // dest
493  ];
494 
495  $op2 = $op;
496  $op2['overwrite'] = true;
497  $cases[] = [
498  $op2, // operation
499  $source, // source
500  $dest, // dest
501  ];
502 
503  $op2 = $op;
504  $op2['overwriteSame'] = true;
505  $cases[] = [
506  $op2, // operation
507  $source, // source
508  $dest, // dest
509  ];
510 
511  $op2 = $op;
512  $op2['ignoreMissingSource'] = true;
513  $cases[] = [
514  $op2, // operation
515  $source, // source
516  $dest, // dest
517  ];
518 
519  $op2 = $op;
520  $op2['ignoreMissingSource'] = true;
521  $cases[] = [
522  $op2, // operation
523  self::baseStorePath() . '/unittest-cont-bad/e/file.txt', // source
524  $dest, // dest
525  ];
526 
527  return $cases;
528  }
529 
534  public function testDelete( $op, $withSource, $okStatus ) {
535  $this->backend = $this->singleBackend;
536  $this->tearDownFiles();
537  $this->doTestDelete( $op, $withSource, $okStatus );
538  $this->tearDownFiles();
539 
540  $this->backend = $this->multiBackend;
541  $this->tearDownFiles();
542  $this->doTestDelete( $op, $withSource, $okStatus );
543  $this->tearDownFiles();
544  }
545 
546  private function doTestDelete( $op, $withSource, $okStatus ) {
547  $backendName = $this->backendClass();
548 
549  $source = $op['src'];
550  $this->prepare( [ 'dir' => dirname( $source ) ] );
551 
552  if ( $withSource ) {
553  $status = $this->backend->doOperation(
554  [ 'op' => 'create', 'content' => 'blahblah', 'dst' => $source ] );
555  $this->assertGoodStatus( $status,
556  "Creation of file at $source succeeded ($backendName)." );
557  }
558 
559  $status = $this->backend->doOperation( $op );
560  if ( $okStatus ) {
561  $this->assertGoodStatus( $status,
562  "Deletion of file at $source succeeded without warnings ($backendName)." );
563  $this->assertEquals( true, $status->isOK(),
564  "Deletion of file at $source succeeded ($backendName)." );
565  $this->assertEquals( [ 0 => true ], $status->success,
566  "Deletion of file at $source has proper 'success' field in Status ($backendName)." );
567  } else {
568  $this->assertEquals( false, $status->isOK(),
569  "Deletion of file at $source failed ($backendName)." );
570  }
571 
572  $this->assertEquals( false, $this->backend->fileExists( [ 'src' => $source ] ),
573  "Source file $source does not exist after move ($backendName)." );
574 
575  $this->assertFalse(
576  $this->backend->getFileSize( [ 'src' => $source ] ),
577  "Source file $source has correct size (false) ($backendName)." );
578 
579  $props1 = $this->backend->getFileProps( [ 'src' => $source ] );
580  $this->assertFalse( $props1['fileExists'],
581  "Source file $source does not exist according to props ($backendName)." );
582 
583  $this->assertBackendPathsConsistent( [ $source ] );
584  }
585 
586  public static function provider_testDelete() {
587  $cases = [];
588 
589  $source = self::baseStorePath() . '/unittest-cont1/e/myfacefile.txt';
590 
591  $op = [ 'op' => 'delete', 'src' => $source ];
592  $cases[] = [
593  $op, // operation
594  true, // with source
595  true // succeeds
596  ];
597 
598  $cases[] = [
599  $op, // operation
600  false, // without source
601  false // fails
602  ];
603 
604  $op['ignoreMissingSource'] = true;
605  $cases[] = [
606  $op, // operation
607  false, // without source
608  true // succeeds
609  ];
610 
611  $op['ignoreMissingSource'] = true;
612  $op['src'] = self::baseStorePath() . '/unittest-cont-bad/e/file.txt';
613  $cases[] = [
614  $op, // operation
615  false, // without source
616  true // succeeds
617  ];
618 
619  return $cases;
620  }
621 
626  public function testDescribe( $op, $withSource, $okStatus ) {
627  $this->backend = $this->singleBackend;
628  $this->tearDownFiles();
629  $this->doTestDescribe( $op, $withSource, $okStatus );
630  $this->tearDownFiles();
631 
632  $this->backend = $this->multiBackend;
633  $this->tearDownFiles();
634  $this->doTestDescribe( $op, $withSource, $okStatus );
635  $this->tearDownFiles();
636  }
637 
638  private function doTestDescribe( $op, $withSource, $okStatus ) {
639  $backendName = $this->backendClass();
640 
641  $source = $op['src'];
642  $this->prepare( [ 'dir' => dirname( $source ) ] );
643 
644  if ( $withSource ) {
645  $status = $this->backend->doOperation(
646  [ 'op' => 'create', 'content' => 'blahblah', 'dst' => $source,
647  'headers' => [ 'Content-Disposition' => 'xxx' ] ] );
648  $this->assertGoodStatus( $status,
649  "Creation of file at $source succeeded ($backendName)." );
650  if ( $this->backend->hasFeatures( FileBackend::ATTR_HEADERS ) ) {
651  $attr = $this->backend->getFileXAttributes( [ 'src' => $source ] );
652  $this->assertHasHeaders( [ 'Content-Disposition' => 'xxx' ], $attr );
653  }
654 
655  $status = $this->backend->describe( [ 'src' => $source,
656  'headers' => [ 'Content-Disposition' => '' ] ] ); // remove
657  $this->assertGoodStatus( $status,
658  "Removal of header for $source succeeded ($backendName)." );
659 
660  if ( $this->backend->hasFeatures( FileBackend::ATTR_HEADERS ) ) {
661  $attr = $this->backend->getFileXAttributes( [ 'src' => $source ] );
662  $this->assertFalse( isset( $attr['headers']['content-disposition'] ),
663  "File 'Content-Disposition' header removed." );
664  }
665  }
666 
667  $status = $this->backend->doOperation( $op );
668  if ( $okStatus ) {
669  $this->assertGoodStatus( $status,
670  "Describe of file at $source succeeded without warnings ($backendName)." );
671  $this->assertEquals( true, $status->isOK(),
672  "Describe of file at $source succeeded ($backendName)." );
673  $this->assertEquals( [ 0 => true ], $status->success,
674  "Describe of file at $source has proper 'success' field in Status ($backendName)." );
675  if ( $this->backend->hasFeatures( FileBackend::ATTR_HEADERS ) ) {
676  $attr = $this->backend->getFileXAttributes( [ 'src' => $source ] );
677  $this->assertHasHeaders( $op['headers'], $attr );
678  }
679  } else {
680  $this->assertEquals( false, $status->isOK(),
681  "Describe of file at $source failed ($backendName)." );
682  }
683 
684  $this->assertBackendPathsConsistent( [ $source ] );
685  }
686 
687  private function assertHasHeaders( array $headers, array $attr ) {
688  foreach ( $headers as $n => $v ) {
689  if ( $n !== '' ) {
690  $this->assertTrue( isset( $attr['headers'][strtolower( $n )] ),
691  "File has '$n' header." );
692  $this->assertEquals( $v, $attr['headers'][strtolower( $n )],
693  "File has '$n' header value." );
694  } else {
695  $this->assertFalse( isset( $attr['headers'][strtolower( $n )] ),
696  "File does not have '$n' header." );
697  }
698  }
699  }
700 
701  public static function provider_testDescribe() {
702  $cases = [];
703 
704  $source = self::baseStorePath() . '/unittest-cont1/e/myfacefile.txt';
705 
706  $op = [ 'op' => 'describe', 'src' => $source,
707  'headers' => [ 'Content-Disposition' => 'inline' ], ];
708  $cases[] = [
709  $op, // operation
710  true, // with source
711  true // succeeds
712  ];
713 
714  $cases[] = [
715  $op, // operation
716  false, // without source
717  false // fails
718  ];
719 
720  return $cases;
721  }
722 
727  public function testCreate( $op, $alreadyExists, $okStatus, $newSize ) {
728  $this->backend = $this->singleBackend;
729  $this->tearDownFiles();
730  $this->doTestCreate( $op, $alreadyExists, $okStatus, $newSize );
731  $this->tearDownFiles();
732 
733  $this->backend = $this->multiBackend;
734  $this->tearDownFiles();
735  $this->doTestCreate( $op, $alreadyExists, $okStatus, $newSize );
736  $this->tearDownFiles();
737  }
738 
739  private function doTestCreate( $op, $alreadyExists, $okStatus, $newSize ) {
740  $backendName = $this->backendClass();
741 
742  $dest = $op['dst'];
743  $this->prepare( [ 'dir' => dirname( $dest ) ] );
744 
745  $oldText = 'blah...blah...waahwaah';
746  if ( $alreadyExists ) {
747  $status = $this->backend->doOperation(
748  [ 'op' => 'create', 'content' => $oldText, 'dst' => $dest ] );
749  $this->assertGoodStatus( $status,
750  "Creation of file at $dest succeeded ($backendName)." );
751  }
752 
753  $status = $this->backend->doOperation( $op );
754  if ( $okStatus ) {
755  $this->assertGoodStatus( $status,
756  "Creation of file at $dest succeeded without warnings ($backendName)." );
757  $this->assertEquals( true, $status->isOK(),
758  "Creation of file at $dest succeeded ($backendName)." );
759  $this->assertEquals( [ 0 => true ], $status->success,
760  "Creation of file at $dest has proper 'success' field in Status ($backendName)." );
761  } else {
762  $this->assertEquals( false, $status->isOK(),
763  "Creation of file at $dest failed ($backendName)." );
764  }
765 
766  $this->assertEquals( true, $this->backend->fileExists( [ 'src' => $dest ] ),
767  "Destination file $dest exists after creation ($backendName)." );
768 
769  $props1 = $this->backend->getFileProps( [ 'src' => $dest ] );
770  $this->assertEquals( true, $props1['fileExists'],
771  "Destination file $dest exists according to props ($backendName)." );
772  if ( $okStatus ) { // file content is what we saved
773  $this->assertEquals( $newSize, $props1['size'],
774  "Destination file $dest has expected size according to props ($backendName)." );
775  $this->assertEquals( $newSize,
776  $this->backend->getFileSize( [ 'src' => $dest ] ),
777  "Destination file $dest has correct size ($backendName)." );
778  } else { // file content is some other previous text
779  $this->assertEquals( strlen( $oldText ), $props1['size'],
780  "Destination file $dest has original size according to props ($backendName)." );
781  $this->assertEquals( strlen( $oldText ),
782  $this->backend->getFileSize( [ 'src' => $dest ] ),
783  "Destination file $dest has original size according to props ($backendName)." );
784  }
785 
786  $this->assertBackendPathsConsistent( [ $dest ] );
787  }
788 
792  public static function provider_testCreate() {
793  $cases = [];
794 
795  $dest = self::baseStorePath() . '/unittest-cont2/a/myspacefile.txt';
796 
797  $op = [ 'op' => 'create', 'content' => 'test test testing', 'dst' => $dest ];
798  $cases[] = [
799  $op, // operation
800  false, // no dest already exists
801  true, // succeeds
802  strlen( $op['content'] )
803  ];
804 
805  $op2 = $op;
806  $op2['content'] = "\n";
807  $cases[] = [
808  $op2, // operation
809  false, // no dest already exists
810  true, // succeeds
811  strlen( $op2['content'] )
812  ];
813 
814  $op2 = $op;
815  $op2['content'] = "fsf\n waf 3kt";
816  $cases[] = [
817  $op2, // operation
818  true, // dest already exists
819  false, // fails
820  strlen( $op2['content'] )
821  ];
822 
823  $op2 = $op;
824  $op2['content'] = "egm'g gkpe gpqg eqwgwqg";
825  $op2['overwrite'] = true;
826  $cases[] = [
827  $op2, // operation
828  true, // dest already exists
829  true, // succeeds
830  strlen( $op2['content'] )
831  ];
832 
833  $op2 = $op;
834  $op2['content'] = "39qjmg3-qg";
835  $op2['overwriteSame'] = true;
836  $cases[] = [
837  $op2, // operation
838  true, // dest already exists
839  false, // succeeds
840  strlen( $op2['content'] )
841  ];
842 
843  return $cases;
844  }
845 
849  public function testDoQuickOperations() {
850  $this->backend = $this->singleBackend;
851  $this->doTestDoQuickOperations();
852  $this->tearDownFiles();
853 
854  $this->backend = $this->multiBackend;
855  $this->doTestDoQuickOperations();
856  $this->tearDownFiles();
857  }
858 
859  private function doTestDoQuickOperations() {
860  $backendName = $this->backendClass();
861 
862  $base = self::baseStorePath();
863  $files = [
864  "$base/unittest-cont1/e/fileA.a",
865  "$base/unittest-cont1/e/fileB.a",
866  "$base/unittest-cont1/e/fileC.a"
867  ];
868  $createOps = [];
869  $purgeOps = [];
870  foreach ( $files as $path ) {
871  $status = $this->prepare( [ 'dir' => dirname( $path ) ] );
872  $this->assertGoodStatus( $status,
873  "Preparing $path succeeded without warnings ($backendName)." );
874  $createOps[] = [ 'op' => 'create', 'dst' => $path, 'content' => mt_rand( 0, 50000 ) ];
875  $copyOps[] = [ 'op' => 'copy', 'src' => $path, 'dst' => "$path-2" ];
876  $moveOps[] = [ 'op' => 'move', 'src' => "$path-2", 'dst' => "$path-3" ];
877  $purgeOps[] = [ 'op' => 'delete', 'src' => $path ];
878  $purgeOps[] = [ 'op' => 'delete', 'src' => "$path-3" ];
879  }
880  $purgeOps[] = [ 'op' => 'null' ];
881 
882  $this->assertGoodStatus(
883  $this->backend->doQuickOperations( $createOps ),
884  "Creation of source files succeeded ($backendName)." );
885  foreach ( $files as $file ) {
886  $this->assertTrue( $this->backend->fileExists( [ 'src' => $file ] ),
887  "File $file exists." );
888  }
889 
890  $this->assertGoodStatus(
891  $this->backend->doQuickOperations( $copyOps ),
892  "Quick copy of source files succeeded ($backendName)." );
893  foreach ( $files as $file ) {
894  $this->assertTrue( $this->backend->fileExists( [ 'src' => "$file-2" ] ),
895  "File $file-2 exists." );
896  }
897 
898  $this->assertGoodStatus(
899  $this->backend->doQuickOperations( $moveOps ),
900  "Quick move of source files succeeded ($backendName)." );
901  foreach ( $files as $file ) {
902  $this->assertTrue( $this->backend->fileExists( [ 'src' => "$file-3" ] ),
903  "File $file-3 move in." );
904  $this->assertFalse( $this->backend->fileExists( [ 'src' => "$file-2" ] ),
905  "File $file-2 moved away." );
906  }
907 
908  $this->assertGoodStatus(
909  $this->backend->quickCopy( [ 'src' => $files[0], 'dst' => $files[0] ] ),
910  "Copy of file {$files[0]} over itself succeeded ($backendName)." );
911  $this->assertTrue( $this->backend->fileExists( [ 'src' => $files[0] ] ),
912  "File {$files[0]} still exists." );
913 
914  $this->assertGoodStatus(
915  $this->backend->quickMove( [ 'src' => $files[0], 'dst' => $files[0] ] ),
916  "Move of file {$files[0]} over itself succeeded ($backendName)." );
917  $this->assertTrue( $this->backend->fileExists( [ 'src' => $files[0] ] ),
918  "File {$files[0]} still exists." );
919 
920  $this->assertGoodStatus(
921  $this->backend->doQuickOperations( $purgeOps ),
922  "Quick deletion of source files succeeded ($backendName)." );
923  foreach ( $files as $file ) {
924  $this->assertFalse( $this->backend->fileExists( [ 'src' => $file ] ),
925  "File $file purged." );
926  $this->assertFalse( $this->backend->fileExists( [ 'src' => "$file-3" ] ),
927  "File $file-3 purged." );
928  }
929  }
930 
934  public function testConcatenate( $op, $srcs, $srcsContent, $alreadyExists, $okStatus ) {
935  $this->backend = $this->singleBackend;
936  $this->tearDownFiles();
937  $this->doTestConcatenate( $op, $srcs, $srcsContent, $alreadyExists, $okStatus );
938  $this->tearDownFiles();
939 
940  $this->backend = $this->multiBackend;
941  $this->tearDownFiles();
942  $this->doTestConcatenate( $op, $srcs, $srcsContent, $alreadyExists, $okStatus );
943  $this->tearDownFiles();
944  }
945 
946  private function doTestConcatenate( $params, $srcs, $srcsContent, $alreadyExists, $okStatus ) {
947  $backendName = $this->backendClass();
948 
949  $expContent = '';
950  // Create sources
951  $ops = [];
952  foreach ( $srcs as $i => $source ) {
953  $this->prepare( [ 'dir' => dirname( $source ) ] );
954  $ops[] = [
955  'op' => 'create', // operation
956  'dst' => $source, // source
957  'content' => $srcsContent[$i]
958  ];
959  $expContent .= $srcsContent[$i];
960  }
961  $status = $this->backend->doOperations( $ops );
962 
963  $this->assertGoodStatus( $status,
964  "Creation of source files succeeded ($backendName)." );
965 
966  $dest = $params['dst'] = $this->getNewTempFile();
967  if ( $alreadyExists ) {
968  $ok = file_put_contents( $dest, 'blah...blah...waahwaah' ) !== false;
969  $this->assertEquals( true, $ok,
970  "Creation of file at $dest succeeded ($backendName)." );
971  } else {
972  $ok = file_put_contents( $dest, '' ) !== false;
973  $this->assertEquals( true, $ok,
974  "Creation of 0-byte file at $dest succeeded ($backendName)." );
975  }
976 
977  // Combine the files into one
978  $status = $this->backend->concatenate( $params );
979  if ( $okStatus ) {
980  $this->assertGoodStatus( $status,
981  "Creation of concat file at $dest succeeded without warnings ($backendName)." );
982  $this->assertEquals( true, $status->isOK(),
983  "Creation of concat file at $dest succeeded ($backendName)." );
984  } else {
985  $this->assertEquals( false, $status->isOK(),
986  "Creation of concat file at $dest failed ($backendName)." );
987  }
988 
989  if ( $okStatus ) {
990  $this->assertEquals( true, is_file( $dest ),
991  "Dest concat file $dest exists after creation ($backendName)." );
992  } else {
993  $this->assertEquals( true, is_file( $dest ),
994  "Dest concat file $dest exists after failed creation ($backendName)." );
995  }
996 
997  $contents = file_get_contents( $dest );
998  $this->assertNotEquals( false, $contents, "File at $dest exists ($backendName)." );
999 
1000  if ( $okStatus ) {
1001  $this->assertEquals( $expContent, $contents,
1002  "Concat file at $dest has correct contents ($backendName)." );
1003  } else {
1004  $this->assertNotEquals( $expContent, $contents,
1005  "Concat file at $dest has correct contents ($backendName)." );
1006  }
1007  }
1008 
1009  public static function provider_testConcatenate() {
1010  $cases = [];
1011 
1012  $srcs = [
1013  self::baseStorePath() . '/unittest-cont1/e/file1.txt',
1014  self::baseStorePath() . '/unittest-cont1/e/file2.txt',
1015  self::baseStorePath() . '/unittest-cont1/e/file3.txt',
1016  self::baseStorePath() . '/unittest-cont1/e/file4.txt',
1017  self::baseStorePath() . '/unittest-cont1/e/file5.txt',
1018  self::baseStorePath() . '/unittest-cont1/e/file6.txt',
1019  self::baseStorePath() . '/unittest-cont1/e/file7.txt',
1020  self::baseStorePath() . '/unittest-cont1/e/file8.txt',
1021  self::baseStorePath() . '/unittest-cont1/e/file9.txt',
1022  self::baseStorePath() . '/unittest-cont1/e/file10.txt'
1023  ];
1024  $content = [
1025  'egfage',
1026  'ageageag',
1027  'rhokohlr',
1028  'shgmslkg',
1029  'kenga',
1030  'owagmal',
1031  'kgmae',
1032  'g eak;g',
1033  'lkaem;a',
1034  'legma'
1035  ];
1036  $params = [ 'srcs' => $srcs ];
1037 
1038  $cases[] = [
1039  $params, // operation
1040  $srcs, // sources
1041  $content, // content for each source
1042  false, // no dest already exists
1043  true, // succeeds
1044  ];
1045 
1046  $cases[] = [
1047  $params, // operation
1048  $srcs, // sources
1049  $content, // content for each source
1050  true, // dest already exists
1051  false, // succeeds
1052  ];
1053 
1054  return $cases;
1055  }
1056 
1061  public function testGetFileStat( $path, $content, $alreadyExists ) {
1062  $this->backend = $this->singleBackend;
1063  $this->tearDownFiles();
1064  $this->doTestGetFileStat( $path, $content, $alreadyExists );
1065  $this->tearDownFiles();
1066 
1067  $this->backend = $this->multiBackend;
1068  $this->tearDownFiles();
1069  $this->doTestGetFileStat( $path, $content, $alreadyExists );
1070  $this->tearDownFiles();
1071  }
1072 
1073  private function doTestGetFileStat( $path, $content, $alreadyExists ) {
1074  $backendName = $this->backendClass();
1075 
1076  if ( $alreadyExists ) {
1077  $this->prepare( [ 'dir' => dirname( $path ) ] );
1078  $status = $this->create( [ 'dst' => $path, 'content' => $content ] );
1079  $this->assertGoodStatus( $status,
1080  "Creation of file at $path succeeded ($backendName)." );
1081 
1082  $size = $this->backend->getFileSize( [ 'src' => $path ] );
1083  $time = $this->backend->getFileTimestamp( [ 'src' => $path ] );
1084  $stat = $this->backend->getFileStat( [ 'src' => $path ] );
1085 
1086  $this->assertEquals( strlen( $content ), $size,
1087  "Correct file size of '$path'" );
1088  $this->assertTrue( abs( time() - wfTimestamp( TS_UNIX, $time ) ) < 10,
1089  "Correct file timestamp of '$path'" );
1090 
1091  $size = $stat['size'];
1092  $time = $stat['mtime'];
1093  $this->assertEquals( strlen( $content ), $size,
1094  "Correct file size of '$path'" );
1095  $this->assertTrue( abs( time() - wfTimestamp( TS_UNIX, $time ) ) < 10,
1096  "Correct file timestamp of '$path'" );
1097 
1098  $this->backend->clearCache( [ $path ] );
1099 
1100  $size = $this->backend->getFileSize( [ 'src' => $path ] );
1101 
1102  $this->assertEquals( strlen( $content ), $size,
1103  "Correct file size of '$path'" );
1104 
1105  $this->backend->preloadCache( [ $path ] );
1106 
1107  $size = $this->backend->getFileSize( [ 'src' => $path ] );
1108 
1109  $this->assertEquals( strlen( $content ), $size,
1110  "Correct file size of '$path'" );
1111  } else {
1112  $size = $this->backend->getFileSize( [ 'src' => $path ] );
1113  $time = $this->backend->getFileTimestamp( [ 'src' => $path ] );
1114  $stat = $this->backend->getFileStat( [ 'src' => $path ] );
1115 
1116  $this->assertFalse( $size, "Correct file size of '$path'" );
1117  $this->assertFalse( $time, "Correct file timestamp of '$path'" );
1118  $this->assertFalse( $stat, "Correct file stat of '$path'" );
1119  }
1120  }
1121 
1122  public static function provider_testGetFileStat() {
1123  $cases = [];
1124 
1125  $base = self::baseStorePath();
1126  $cases[] = [ "$base/unittest-cont1/e/b/z/some_file.txt", "some file contents", true ];
1127  $cases[] = [ "$base/unittest-cont1/e/b/some-other_file.txt", "", true ];
1128  $cases[] = [ "$base/unittest-cont1/e/b/some-diff_file.txt", null, false ];
1129 
1130  return $cases;
1131  }
1132 
1137  public function testStreamFile( $path, $content, $alreadyExists ) {
1138  $this->backend = $this->singleBackend;
1139  $this->tearDownFiles();
1140  $this->doTestStreamFile( $path, $content, $alreadyExists );
1141  $this->tearDownFiles();
1142 
1143  $this->backend = $this->multiBackend;
1144  $this->tearDownFiles();
1145  $this->doTestStreamFile( $path, $content, $alreadyExists );
1146  $this->tearDownFiles();
1147  }
1148 
1149  private function doTestStreamFile( $path, $content ) {
1150  $backendName = $this->backendClass();
1151 
1152  if ( $content !== null ) {
1153  $this->prepare( [ 'dir' => dirname( $path ) ] );
1154  $status = $this->create( [ 'dst' => $path, 'content' => $content ] );
1155  $this->assertGoodStatus( $status,
1156  "Creation of file at $path succeeded ($backendName)." );
1157 
1158  ob_start();
1159  $this->backend->streamFile( [ 'src' => $path, 'headless' => 1, 'allowOB' => 1 ] );
1160  $data = ob_get_contents();
1161  ob_end_clean();
1162 
1163  $this->assertEquals( $content, $data, "Correct content streamed from '$path'" );
1164  } else { // 404 case
1165  ob_start();
1166  $this->backend->streamFile( [ 'src' => $path, 'headless' => 1, 'allowOB' => 1 ] );
1167  $data = ob_get_contents();
1168  ob_end_clean();
1169 
1170  $this->assertRegExp( '#<h1>File not found</h1>#', $data,
1171  "Correct content streamed from '$path' ($backendName)" );
1172  }
1173  }
1174 
1175  public static function provider_testStreamFile() {
1176  $cases = [];
1177 
1178  $base = self::baseStorePath();
1179  $cases[] = [ "$base/unittest-cont1/e/b/z/some_file.txt", "some file contents" ];
1180  $cases[] = [ "$base/unittest-cont1/e/b/some-other_file.txt", null ];
1181 
1182  return $cases;
1183  }
1184 
1185  public function testStreamFileRange() {
1186  $this->backend = $this->singleBackend;
1187  $this->tearDownFiles();
1188  $this->doTestStreamFileRange();
1189  $this->tearDownFiles();
1190 
1191  $this->backend = $this->multiBackend;
1192  $this->tearDownFiles();
1193  $this->doTestStreamFileRange();
1194  $this->tearDownFiles();
1195  }
1196 
1197  private function doTestStreamFileRange() {
1198  $backendName = $this->backendClass();
1199 
1200  $base = self::baseStorePath();
1201  $path = "$base/unittest-cont1/e/b/z/range_file.txt";
1202  $content = "0123456789ABCDEF";
1203 
1204  $this->prepare( [ 'dir' => dirname( $path ) ] );
1205  $status = $this->create( [ 'dst' => $path, 'content' => $content ] );
1206  $this->assertGoodStatus( $status,
1207  "Creation of file at $path succeeded ($backendName)." );
1208 
1209  static $ranges = [
1210  'bytes=0-0' => '0',
1211  'bytes=0-3' => '0123',
1212  'bytes=4-8' => '45678',
1213  'bytes=15-15' => 'F',
1214  'bytes=14-15' => 'EF',
1215  'bytes=-5' => 'BCDEF',
1216  'bytes=-1' => 'F',
1217  'bytes=10-16' => 'ABCDEF',
1218  'bytes=10-99' => 'ABCDEF',
1219  ];
1220 
1221  foreach ( $ranges as $range => $chunk ) {
1222  ob_start();
1223  $this->backend->streamFile( [ 'src' => $path, 'headless' => 1, 'allowOB' => 1,
1224  'options' => [ 'range' => $range ] ] );
1225  $data = ob_get_contents();
1226  ob_end_clean();
1227 
1228  $this->assertEquals( $chunk, $data, "Correct chunk streamed from '$path' for '$range'" );
1229  }
1230  }
1231 
1237  public function testGetFileContents( $source, $content ) {
1238  $this->backend = $this->singleBackend;
1239  $this->tearDownFiles();
1240  $this->doTestGetFileContents( $source, $content );
1241  $this->tearDownFiles();
1242 
1243  $this->backend = $this->multiBackend;
1244  $this->tearDownFiles();
1245  $this->doTestGetFileContents( $source, $content );
1246  $this->tearDownFiles();
1247  }
1248 
1249  private function doTestGetFileContents( $source, $content ) {
1250  $backendName = $this->backendClass();
1251 
1252  $srcs = (array)$source;
1253  $content = (array)$content;
1254  foreach ( $srcs as $i => $src ) {
1255  $this->prepare( [ 'dir' => dirname( $src ) ] );
1256  $status = $this->backend->doOperation(
1257  [ 'op' => 'create', 'content' => $content[$i], 'dst' => $src ] );
1258  $this->assertGoodStatus( $status,
1259  "Creation of file at $src succeeded ($backendName)." );
1260  }
1261 
1262  if ( is_array( $source ) ) {
1263  $contents = $this->backend->getFileContentsMulti( [ 'srcs' => $source ] );
1264  foreach ( $contents as $path => $data ) {
1265  $this->assertNotEquals( false, $data, "Contents of $path exists ($backendName)." );
1266  $this->assertEquals(
1267  current( $content ),
1268  $data,
1269  "Contents of $path is correct ($backendName)."
1270  );
1271  next( $content );
1272  }
1273  $this->assertEquals(
1274  $source,
1275  array_keys( $contents ),
1276  "Contents in right order ($backendName)."
1277  );
1278  $this->assertEquals(
1279  count( $source ),
1280  count( $contents ),
1281  "Contents array size correct ($backendName)."
1282  );
1283  } else {
1284  $data = $this->backend->getFileContents( [ 'src' => $source ] );
1285  $this->assertNotEquals( false, $data, "Contents of $source exists ($backendName)." );
1286  $this->assertEquals( $content[0], $data, "Contents of $source is correct ($backendName)." );
1287  }
1288  }
1289 
1290  public static function provider_testGetFileContents() {
1291  $cases = [];
1292 
1293  $base = self::baseStorePath();
1294  $cases[] = [ "$base/unittest-cont1/e/b/z/some_file.txt", "some file contents" ];
1295  $cases[] = [ "$base/unittest-cont1/e/b/some-other_file.txt", "more file contents" ];
1296  $cases[] = [
1297  [ "$base/unittest-cont1/e/a/x.txt", "$base/unittest-cont1/e/a/y.txt",
1298  "$base/unittest-cont1/e/a/z.txt" ],
1299  [ "contents xx", "contents xy", "contents xz" ]
1300  ];
1301 
1302  return $cases;
1303  }
1304 
1309  public function testGetLocalCopy( $source, $content ) {
1310  $this->backend = $this->singleBackend;
1311  $this->tearDownFiles();
1312  $this->doTestGetLocalCopy( $source, $content );
1313  $this->tearDownFiles();
1314 
1315  $this->backend = $this->multiBackend;
1316  $this->tearDownFiles();
1317  $this->doTestGetLocalCopy( $source, $content );
1318  $this->tearDownFiles();
1319  }
1320 
1321  private function doTestGetLocalCopy( $source, $content ) {
1322  $backendName = $this->backendClass();
1323 
1324  $srcs = (array)$source;
1325  $content = (array)$content;
1326  foreach ( $srcs as $i => $src ) {
1327  $this->prepare( [ 'dir' => dirname( $src ) ] );
1328  $status = $this->backend->doOperation(
1329  [ 'op' => 'create', 'content' => $content[$i], 'dst' => $src ] );
1330  $this->assertGoodStatus( $status,
1331  "Creation of file at $src succeeded ($backendName)." );
1332  }
1333 
1334  if ( is_array( $source ) ) {
1335  $tmpFiles = $this->backend->getLocalCopyMulti( [ 'srcs' => $source ] );
1336  foreach ( $tmpFiles as $path => $tmpFile ) {
1337  $this->assertNotNull( $tmpFile,
1338  "Creation of local copy of $path succeeded ($backendName)." );
1339  $contents = file_get_contents( $tmpFile->getPath() );
1340  $this->assertNotEquals( false, $contents, "Local copy of $path exists ($backendName)." );
1341  $this->assertEquals(
1342  current( $content ),
1343  $contents,
1344  "Local copy of $path is correct ($backendName)."
1345  );
1346  next( $content );
1347  }
1348  $this->assertEquals(
1349  $source,
1350  array_keys( $tmpFiles ),
1351  "Local copies in right order ($backendName)."
1352  );
1353  $this->assertEquals(
1354  count( $source ),
1355  count( $tmpFiles ),
1356  "Local copies array size correct ($backendName)."
1357  );
1358  } else {
1359  $tmpFile = $this->backend->getLocalCopy( [ 'src' => $source ] );
1360  $this->assertNotNull( $tmpFile,
1361  "Creation of local copy of $source succeeded ($backendName)." );
1362  $contents = file_get_contents( $tmpFile->getPath() );
1363  $this->assertNotEquals( false, $contents, "Local copy of $source exists ($backendName)." );
1364  $this->assertEquals(
1365  $content[0],
1366  $contents,
1367  "Local copy of $source is correct ($backendName)."
1368  );
1369  }
1370 
1371  $obj = new stdClass();
1372  $tmpFile->bind( $obj );
1373  }
1374 
1375  public static function provider_testGetLocalCopy() {
1376  $cases = [];
1377 
1378  $base = self::baseStorePath();
1379  $cases[] = [ "$base/unittest-cont1/e/a/z/some_file.txt", "some file contents" ];
1380  $cases[] = [ "$base/unittest-cont1/e/a/some-other_file.txt", "more file contents" ];
1381  $cases[] = [ "$base/unittest-cont1/e/a/\$odd&.txt", "test file contents" ];
1382  $cases[] = [
1383  [ "$base/unittest-cont1/e/a/x.txt", "$base/unittest-cont1/e/a/y.txt",
1384  "$base/unittest-cont1/e/a/z.txt" ],
1385  [ "contents xx $", "contents xy 111", "contents xz" ]
1386  ];
1387 
1388  return $cases;
1389  }
1390 
1395  public function testGetLocalReference( $source, $content ) {
1396  $this->backend = $this->singleBackend;
1397  $this->tearDownFiles();
1398  $this->doTestGetLocalReference( $source, $content );
1399  $this->tearDownFiles();
1400 
1401  $this->backend = $this->multiBackend;
1402  $this->tearDownFiles();
1403  $this->doTestGetLocalReference( $source, $content );
1404  $this->tearDownFiles();
1405  }
1406 
1407  private function doTestGetLocalReference( $source, $content ) {
1408  $backendName = $this->backendClass();
1409 
1410  $srcs = (array)$source;
1411  $content = (array)$content;
1412  foreach ( $srcs as $i => $src ) {
1413  $this->prepare( [ 'dir' => dirname( $src ) ] );
1414  $status = $this->backend->doOperation(
1415  [ 'op' => 'create', 'content' => $content[$i], 'dst' => $src ] );
1416  $this->assertGoodStatus( $status,
1417  "Creation of file at $src succeeded ($backendName)." );
1418  }
1419 
1420  if ( is_array( $source ) ) {
1421  $tmpFiles = $this->backend->getLocalReferenceMulti( [ 'srcs' => $source ] );
1422  foreach ( $tmpFiles as $path => $tmpFile ) {
1423  $this->assertNotNull( $tmpFile,
1424  "Creation of local copy of $path succeeded ($backendName)." );
1425  $contents = file_get_contents( $tmpFile->getPath() );
1426  $this->assertNotEquals( false, $contents, "Local ref of $path exists ($backendName)." );
1427  $this->assertEquals(
1428  current( $content ),
1429  $contents,
1430  "Local ref of $path is correct ($backendName)."
1431  );
1432  next( $content );
1433  }
1434  $this->assertEquals(
1435  $source,
1436  array_keys( $tmpFiles ),
1437  "Local refs in right order ($backendName)."
1438  );
1439  $this->assertEquals(
1440  count( $source ),
1441  count( $tmpFiles ),
1442  "Local refs array size correct ($backendName)."
1443  );
1444  } else {
1445  $tmpFile = $this->backend->getLocalReference( [ 'src' => $source ] );
1446  $this->assertNotNull( $tmpFile,
1447  "Creation of local copy of $source succeeded ($backendName)." );
1448  $contents = file_get_contents( $tmpFile->getPath() );
1449  $this->assertNotEquals( false, $contents, "Local ref of $source exists ($backendName)." );
1450  $this->assertEquals( $content[0], $contents, "Local ref of $source is correct ($backendName)." );
1451  }
1452  }
1453 
1454  public static function provider_testGetLocalReference() {
1455  $cases = [];
1456 
1457  $base = self::baseStorePath();
1458  $cases[] = [ "$base/unittest-cont1/e/a/z/some_file.txt", "some file contents" ];
1459  $cases[] = [ "$base/unittest-cont1/e/a/some-other_file.txt", "more file contents" ];
1460  $cases[] = [ "$base/unittest-cont1/e/a/\$odd&.txt", "test file contents" ];
1461  $cases[] = [
1462  [ "$base/unittest-cont1/e/a/x.txt", "$base/unittest-cont1/e/a/y.txt",
1463  "$base/unittest-cont1/e/a/z.txt" ],
1464  [ "contents xx 1111", "contents xy %", "contents xz $" ]
1465  ];
1466 
1467  return $cases;
1468  }
1469 
1474  public function testGetLocalCopyAndReference404() {
1475  $this->backend = $this->singleBackend;
1476  $this->tearDownFiles();
1477  $this->doTestGetLocalCopyAndReference404();
1478  $this->tearDownFiles();
1479 
1480  $this->backend = $this->multiBackend;
1481  $this->tearDownFiles();
1482  $this->doTestGetLocalCopyAndReference404();
1483  $this->tearDownFiles();
1484  }
1485 
1486  public function doTestGetLocalCopyAndReference404() {
1487  $backendName = $this->backendClass();
1488 
1489  $base = self::baseStorePath();
1490 
1491  $tmpFile = $this->backend->getLocalCopy( [
1492  'src' => "$base/unittest-cont1/not-there" ] );
1493  $this->assertEquals( null, $tmpFile, "Local copy of not existing file is null ($backendName)." );
1494 
1495  $tmpFile = $this->backend->getLocalReference( [
1496  'src' => "$base/unittest-cont1/not-there" ] );
1497  $this->assertEquals( null, $tmpFile, "Local ref of not existing file is null ($backendName)." );
1498  }
1499 
1504  public function testGetFileHttpUrl( $source, $content ) {
1505  $this->backend = $this->singleBackend;
1506  $this->tearDownFiles();
1507  $this->doTestGetFileHttpUrl( $source, $content );
1508  $this->tearDownFiles();
1509 
1510  $this->backend = $this->multiBackend;
1511  $this->tearDownFiles();
1512  $this->doTestGetFileHttpUrl( $source, $content );
1513  $this->tearDownFiles();
1514  }
1515 
1516  private function doTestGetFileHttpUrl( $source, $content ) {
1517  $backendName = $this->backendClass();
1518 
1519  $this->prepare( [ 'dir' => dirname( $source ) ] );
1520  $status = $this->backend->doOperation(
1521  [ 'op' => 'create', 'content' => $content, 'dst' => $source ] );
1522  $this->assertGoodStatus( $status,
1523  "Creation of file at $source succeeded ($backendName)." );
1524 
1525  $url = $this->backend->getFileHttpUrl( [ 'src' => $source ] );
1526 
1527  if ( $url !== null ) { // supported
1528  $data = Http::request( "GET", $url, [], __METHOD__ );
1529  $this->assertEquals( $content, $data,
1530  "HTTP GET of URL has right contents ($backendName)." );
1531  }
1532  }
1533 
1534  public static function provider_testGetFileHttpUrl() {
1535  $cases = [];
1536 
1537  $base = self::baseStorePath();
1538  $cases[] = [ "$base/unittest-cont1/e/a/z/some_file.txt", "some file contents" ];
1539  $cases[] = [ "$base/unittest-cont1/e/a/some-other_file.txt", "more file contents" ];
1540  $cases[] = [ "$base/unittest-cont1/e/a/\$odd&.txt", "test file contents" ];
1541 
1542  return $cases;
1543  }
1544 
1550  public function testPrepareAndClean( $path, $isOK ) {
1551  $this->backend = $this->singleBackend;
1552  $this->doTestPrepareAndClean( $path, $isOK );
1553  $this->tearDownFiles();
1554 
1555  $this->backend = $this->multiBackend;
1556  $this->doTestPrepareAndClean( $path, $isOK );
1557  $this->tearDownFiles();
1558  }
1559 
1560  public static function provider_testPrepareAndClean() {
1561  $base = self::baseStorePath();
1562 
1563  return [
1564  [ "$base/unittest-cont1/e/a/z/some_file1.txt", true ],
1565  [ "$base/unittest-cont2/a/z/some_file2.txt", true ],
1566  # Specific to FS backend with no basePath field set
1567  # [ "$base/unittest-cont3/a/z/some_file3.txt", false ],
1568  ];
1569  }
1570 
1571  private function doTestPrepareAndClean( $path, $isOK ) {
1572  $backendName = $this->backendClass();
1573 
1574  $status = $this->prepare( [ 'dir' => dirname( $path ) ] );
1575  if ( $isOK ) {
1576  $this->assertGoodStatus( $status,
1577  "Preparing dir $path succeeded without warnings ($backendName)." );
1578  $this->assertEquals( true, $status->isOK(),
1579  "Preparing dir $path succeeded ($backendName)." );
1580  } else {
1581  $this->assertEquals( false, $status->isOK(),
1582  "Preparing dir $path failed ($backendName)." );
1583  }
1584 
1585  $status = $this->backend->secure( [ 'dir' => dirname( $path ) ] );
1586  if ( $isOK ) {
1587  $this->assertGoodStatus( $status,
1588  "Securing dir $path succeeded without warnings ($backendName)." );
1589  $this->assertEquals( true, $status->isOK(),
1590  "Securing dir $path succeeded ($backendName)." );
1591  } else {
1592  $this->assertEquals( false, $status->isOK(),
1593  "Securing dir $path failed ($backendName)." );
1594  }
1595 
1596  $status = $this->backend->publish( [ 'dir' => dirname( $path ) ] );
1597  if ( $isOK ) {
1598  $this->assertGoodStatus( $status,
1599  "Publishing dir $path succeeded without warnings ($backendName)." );
1600  $this->assertEquals( true, $status->isOK(),
1601  "Publishing dir $path succeeded ($backendName)." );
1602  } else {
1603  $this->assertEquals( false, $status->isOK(),
1604  "Publishing dir $path failed ($backendName)." );
1605  }
1606 
1607  $status = $this->backend->clean( [ 'dir' => dirname( $path ) ] );
1608  if ( $isOK ) {
1609  $this->assertGoodStatus( $status,
1610  "Cleaning dir $path succeeded without warnings ($backendName)." );
1611  $this->assertEquals( true, $status->isOK(),
1612  "Cleaning dir $path succeeded ($backendName)." );
1613  } else {
1614  $this->assertEquals( false, $status->isOK(),
1615  "Cleaning dir $path failed ($backendName)." );
1616  }
1617  }
1618 
1619  public function testRecursiveClean() {
1620  $this->backend = $this->singleBackend;
1621  $this->doTestRecursiveClean();
1622  $this->tearDownFiles();
1623 
1624  $this->backend = $this->multiBackend;
1625  $this->doTestRecursiveClean();
1626  $this->tearDownFiles();
1627  }
1628 
1632  private function doTestRecursiveClean() {
1633  $backendName = $this->backendClass();
1634 
1635  $base = self::baseStorePath();
1636  $dirs = [
1637  "$base/unittest-cont1",
1638  "$base/unittest-cont1/e",
1639  "$base/unittest-cont1/e/a",
1640  "$base/unittest-cont1/e/a/b",
1641  "$base/unittest-cont1/e/a/b/c",
1642  "$base/unittest-cont1/e/a/b/c/d0",
1643  "$base/unittest-cont1/e/a/b/c/d1",
1644  "$base/unittest-cont1/e/a/b/c/d2",
1645  "$base/unittest-cont1/e/a/b/c/d0/1",
1646  "$base/unittest-cont1/e/a/b/c/d0/2",
1647  "$base/unittest-cont1/e/a/b/c/d1/3",
1648  "$base/unittest-cont1/e/a/b/c/d1/4",
1649  "$base/unittest-cont1/e/a/b/c/d2/5",
1650  "$base/unittest-cont1/e/a/b/c/d2/6"
1651  ];
1652  foreach ( $dirs as $dir ) {
1653  $status = $this->prepare( [ 'dir' => $dir ] );
1654  $this->assertGoodStatus( $status,
1655  "Preparing dir $dir succeeded without warnings ($backendName)." );
1656  }
1657 
1658  if ( $this->backend instanceof FSFileBackend ) {
1659  foreach ( $dirs as $dir ) {
1660  $this->assertEquals( true, $this->backend->directoryExists( [ 'dir' => $dir ] ),
1661  "Dir $dir exists ($backendName)." );
1662  }
1663  }
1664 
1665  $status = $this->backend->clean(
1666  [ 'dir' => "$base/unittest-cont1", 'recursive' => 1 ] );
1667  $this->assertGoodStatus( $status,
1668  "Recursive cleaning of dir $dir succeeded without warnings ($backendName)." );
1669 
1670  foreach ( $dirs as $dir ) {
1671  $this->assertEquals( false, $this->backend->directoryExists( [ 'dir' => $dir ] ),
1672  "Dir $dir no longer exists ($backendName)." );
1673  }
1674  }
1675 
1679  public function testDoOperations() {
1680  $this->backend = $this->singleBackend;
1681  $this->tearDownFiles();
1682  $this->doTestDoOperations();
1683  $this->tearDownFiles();
1684 
1685  $this->backend = $this->multiBackend;
1686  $this->tearDownFiles();
1687  $this->doTestDoOperations();
1688  $this->tearDownFiles();
1689  }
1690 
1691  private function doTestDoOperations() {
1692  $base = self::baseStorePath();
1693 
1694  $fileA = "$base/unittest-cont1/e/a/b/fileA.txt";
1695  $fileAContents = '3tqtmoeatmn4wg4qe-mg3qt3 tq';
1696  $fileB = "$base/unittest-cont1/e/a/b/fileB.txt";
1697  $fileBContents = 'g-jmq3gpqgt3qtg q3GT ';
1698  $fileC = "$base/unittest-cont1/e/a/b/fileC.txt";
1699  $fileCContents = 'eigna[ogmewt 3qt g3qg flew[ag';
1700  $fileD = "$base/unittest-cont1/e/a/b/fileD.txt";
1701 
1702  $this->prepare( [ 'dir' => dirname( $fileA ) ] );
1703  $this->create( [ 'dst' => $fileA, 'content' => $fileAContents ] );
1704  $this->prepare( [ 'dir' => dirname( $fileB ) ] );
1705  $this->create( [ 'dst' => $fileB, 'content' => $fileBContents ] );
1706  $this->prepare( [ 'dir' => dirname( $fileC ) ] );
1707  $this->create( [ 'dst' => $fileC, 'content' => $fileCContents ] );
1708  $this->prepare( [ 'dir' => dirname( $fileD ) ] );
1709 
1710  $status = $this->backend->doOperations( [
1711  [ 'op' => 'describe', 'src' => $fileA,
1712  'headers' => [ 'X-Content-Length' => '91.3' ], 'disposition' => 'inline' ],
1713  [ 'op' => 'copy', 'src' => $fileA, 'dst' => $fileC, 'overwrite' => 1 ],
1714  // Now: A:<A>, B:<B>, C:<A>, D:<empty> (file:<orginal contents>)
1715  [ 'op' => 'copy', 'src' => $fileC, 'dst' => $fileA, 'overwriteSame' => 1 ],
1716  // Now: A:<A>, B:<B>, C:<A>, D:<empty>
1717  [ 'op' => 'move', 'src' => $fileC, 'dst' => $fileD, 'overwrite' => 1 ],
1718  // Now: A:<A>, B:<B>, C:<empty>, D:<A>
1719  [ 'op' => 'move', 'src' => $fileB, 'dst' => $fileC ],
1720  // Now: A:<A>, B:<empty>, C:<B>, D:<A>
1721  [ 'op' => 'move', 'src' => $fileD, 'dst' => $fileA, 'overwriteSame' => 1 ],
1722  // Now: A:<A>, B:<empty>, C:<B>, D:<empty>
1723  [ 'op' => 'move', 'src' => $fileC, 'dst' => $fileA, 'overwrite' => 1 ],
1724  // Now: A:<B>, B:<empty>, C:<empty>, D:<empty>
1725  [ 'op' => 'copy', 'src' => $fileA, 'dst' => $fileC ],
1726  // Now: A:<B>, B:<empty>, C:<B>, D:<empty>
1727  [ 'op' => 'move', 'src' => $fileA, 'dst' => $fileC, 'overwriteSame' => 1 ],
1728  // Now: A:<empty>, B:<empty>, C:<B>, D:<empty>
1729  [ 'op' => 'copy', 'src' => $fileC, 'dst' => $fileC, 'overwrite' => 1 ],
1730  // Does nothing
1731  [ 'op' => 'copy', 'src' => $fileC, 'dst' => $fileC, 'overwriteSame' => 1 ],
1732  // Does nothing
1733  [ 'op' => 'move', 'src' => $fileC, 'dst' => $fileC, 'overwrite' => 1 ],
1734  // Does nothing
1735  [ 'op' => 'move', 'src' => $fileC, 'dst' => $fileC, 'overwriteSame' => 1 ],
1736  // Does nothing
1737  [ 'op' => 'null' ],
1738  // Does nothing
1739  ] );
1740 
1741  $this->assertGoodStatus( $status, "Operation batch succeeded" );
1742  $this->assertEquals( true, $status->isOK(), "Operation batch succeeded" );
1743  $this->assertEquals( 14, count( $status->success ),
1744  "Operation batch has correct success array" );
1745 
1746  $this->assertEquals( false, $this->backend->fileExists( [ 'src' => $fileA ] ),
1747  "File does not exist at $fileA" );
1748  $this->assertEquals( false, $this->backend->fileExists( [ 'src' => $fileB ] ),
1749  "File does not exist at $fileB" );
1750  $this->assertEquals( false, $this->backend->fileExists( [ 'src' => $fileD ] ),
1751  "File does not exist at $fileD" );
1752 
1753  $this->assertEquals( true, $this->backend->fileExists( [ 'src' => $fileC ] ),
1754  "File exists at $fileC" );
1755  $this->assertEquals( $fileBContents,
1756  $this->backend->getFileContents( [ 'src' => $fileC ] ),
1757  "Correct file contents of $fileC" );
1758  $this->assertEquals( strlen( $fileBContents ),
1759  $this->backend->getFileSize( [ 'src' => $fileC ] ),
1760  "Correct file size of $fileC" );
1761  $this->assertEquals( Wikimedia\base_convert( sha1( $fileBContents ), 16, 36, 31 ),
1762  $this->backend->getFileSha1Base36( [ 'src' => $fileC ] ),
1763  "Correct file SHA-1 of $fileC" );
1764  }
1765 
1769  public function testDoOperationsPipeline() {
1770  $this->backend = $this->singleBackend;
1771  $this->tearDownFiles();
1772  $this->doTestDoOperationsPipeline();
1773  $this->tearDownFiles();
1774 
1775  $this->backend = $this->multiBackend;
1776  $this->tearDownFiles();
1777  $this->doTestDoOperationsPipeline();
1778  $this->tearDownFiles();
1779  }
1780 
1781  // concurrency orientated
1782  private function doTestDoOperationsPipeline() {
1783  $base = self::baseStorePath();
1784 
1785  $fileAContents = '3tqtmoeatmn4wg4qe-mg3qt3 tq';
1786  $fileBContents = 'g-jmq3gpqgt3qtg q3GT ';
1787  $fileCContents = 'eigna[ogmewt 3qt g3qg flew[ag';
1788 
1789  $tmpNameA = TempFSFile::factory( "unittests_", 'txt', wfTempDir() )->getPath();
1790  $tmpNameB = TempFSFile::factory( "unittests_", 'txt', wfTempDir() )->getPath();
1791  $tmpNameC = TempFSFile::factory( "unittests_", 'txt', wfTempDir() )->getPath();
1792  $this->addTmpFiles( [ $tmpNameA, $tmpNameB, $tmpNameC ] );
1793  file_put_contents( $tmpNameA, $fileAContents );
1794  file_put_contents( $tmpNameB, $fileBContents );
1795  file_put_contents( $tmpNameC, $fileCContents );
1796 
1797  $fileA = "$base/unittest-cont1/e/a/b/fileA.txt";
1798  $fileB = "$base/unittest-cont1/e/a/b/fileB.txt";
1799  $fileC = "$base/unittest-cont1/e/a/b/fileC.txt";
1800  $fileD = "$base/unittest-cont1/e/a/b/fileD.txt";
1801 
1802  $this->prepare( [ 'dir' => dirname( $fileA ) ] );
1803  $this->create( [ 'dst' => $fileA, 'content' => $fileAContents ] );
1804  $this->prepare( [ 'dir' => dirname( $fileB ) ] );
1805  $this->prepare( [ 'dir' => dirname( $fileC ) ] );
1806  $this->prepare( [ 'dir' => dirname( $fileD ) ] );
1807 
1808  $status = $this->backend->doOperations( [
1809  [ 'op' => 'store', 'src' => $tmpNameA, 'dst' => $fileA, 'overwriteSame' => 1 ],
1810  [ 'op' => 'store', 'src' => $tmpNameB, 'dst' => $fileB, 'overwrite' => 1 ],
1811  [ 'op' => 'store', 'src' => $tmpNameC, 'dst' => $fileC, 'overwrite' => 1 ],
1812  [ 'op' => 'copy', 'src' => $fileA, 'dst' => $fileC, 'overwrite' => 1 ],
1813  // Now: A:<A>, B:<B>, C:<A>, D:<empty> (file:<orginal contents>)
1814  [ 'op' => 'copy', 'src' => $fileC, 'dst' => $fileA, 'overwriteSame' => 1 ],
1815  // Now: A:<A>, B:<B>, C:<A>, D:<empty>
1816  [ 'op' => 'move', 'src' => $fileC, 'dst' => $fileD, 'overwrite' => 1 ],
1817  // Now: A:<A>, B:<B>, C:<empty>, D:<A>
1818  [ 'op' => 'move', 'src' => $fileB, 'dst' => $fileC ],
1819  // Now: A:<A>, B:<empty>, C:<B>, D:<A>
1820  [ 'op' => 'move', 'src' => $fileD, 'dst' => $fileA, 'overwriteSame' => 1 ],
1821  // Now: A:<A>, B:<empty>, C:<B>, D:<empty>
1822  [ 'op' => 'move', 'src' => $fileC, 'dst' => $fileA, 'overwrite' => 1 ],
1823  // Now: A:<B>, B:<empty>, C:<empty>, D:<empty>
1824  [ 'op' => 'copy', 'src' => $fileA, 'dst' => $fileC ],
1825  // Now: A:<B>, B:<empty>, C:<B>, D:<empty>
1826  [ 'op' => 'move', 'src' => $fileA, 'dst' => $fileC, 'overwriteSame' => 1 ],
1827  // Now: A:<empty>, B:<empty>, C:<B>, D:<empty>
1828  [ 'op' => 'copy', 'src' => $fileC, 'dst' => $fileC, 'overwrite' => 1 ],
1829  // Does nothing
1830  [ 'op' => 'copy', 'src' => $fileC, 'dst' => $fileC, 'overwriteSame' => 1 ],
1831  // Does nothing
1832  [ 'op' => 'move', 'src' => $fileC, 'dst' => $fileC, 'overwrite' => 1 ],
1833  // Does nothing
1834  [ 'op' => 'move', 'src' => $fileC, 'dst' => $fileC, 'overwriteSame' => 1 ],
1835  // Does nothing
1836  [ 'op' => 'null' ],
1837  // Does nothing
1838  ] );
1839 
1840  $this->assertGoodStatus( $status, "Operation batch succeeded" );
1841  $this->assertEquals( true, $status->isOK(), "Operation batch succeeded" );
1842  $this->assertEquals( 16, count( $status->success ),
1843  "Operation batch has correct success array" );
1844 
1845  $this->assertEquals( false, $this->backend->fileExists( [ 'src' => $fileA ] ),
1846  "File does not exist at $fileA" );
1847  $this->assertEquals( false, $this->backend->fileExists( [ 'src' => $fileB ] ),
1848  "File does not exist at $fileB" );
1849  $this->assertEquals( false, $this->backend->fileExists( [ 'src' => $fileD ] ),
1850  "File does not exist at $fileD" );
1851 
1852  $this->assertEquals( true, $this->backend->fileExists( [ 'src' => $fileC ] ),
1853  "File exists at $fileC" );
1854  $this->assertEquals( $fileBContents,
1855  $this->backend->getFileContents( [ 'src' => $fileC ] ),
1856  "Correct file contents of $fileC" );
1857  $this->assertEquals( strlen( $fileBContents ),
1858  $this->backend->getFileSize( [ 'src' => $fileC ] ),
1859  "Correct file size of $fileC" );
1860  $this->assertEquals( Wikimedia\base_convert( sha1( $fileBContents ), 16, 36, 31 ),
1861  $this->backend->getFileSha1Base36( [ 'src' => $fileC ] ),
1862  "Correct file SHA-1 of $fileC" );
1863  }
1864 
1868  public function testDoOperationsFailing() {
1869  $this->backend = $this->singleBackend;
1870  $this->tearDownFiles();
1871  $this->doTestDoOperationsFailing();
1872  $this->tearDownFiles();
1873 
1874  $this->backend = $this->multiBackend;
1875  $this->tearDownFiles();
1876  $this->doTestDoOperationsFailing();
1877  $this->tearDownFiles();
1878  }
1879 
1880  private function doTestDoOperationsFailing() {
1881  $base = self::baseStorePath();
1882 
1883  $fileA = "$base/unittest-cont2/a/b/fileA.txt";
1884  $fileAContents = '3tqtmoeatmn4wg4qe-mg3qt3 tq';
1885  $fileB = "$base/unittest-cont2/a/b/fileB.txt";
1886  $fileBContents = 'g-jmq3gpqgt3qtg q3GT ';
1887  $fileC = "$base/unittest-cont2/a/b/fileC.txt";
1888  $fileCContents = 'eigna[ogmewt 3qt g3qg flew[ag';
1889  $fileD = "$base/unittest-cont2/a/b/fileD.txt";
1890 
1891  $this->prepare( [ 'dir' => dirname( $fileA ) ] );
1892  $this->create( [ 'dst' => $fileA, 'content' => $fileAContents ] );
1893  $this->prepare( [ 'dir' => dirname( $fileB ) ] );
1894  $this->create( [ 'dst' => $fileB, 'content' => $fileBContents ] );
1895  $this->prepare( [ 'dir' => dirname( $fileC ) ] );
1896  $this->create( [ 'dst' => $fileC, 'content' => $fileCContents ] );
1897 
1898  $status = $this->backend->doOperations( [
1899  [ 'op' => 'copy', 'src' => $fileA, 'dst' => $fileC, 'overwrite' => 1 ],
1900  // Now: A:<A>, B:<B>, C:<A>, D:<empty> (file:<orginal contents>)
1901  [ 'op' => 'copy', 'src' => $fileC, 'dst' => $fileA, 'overwriteSame' => 1 ],
1902  // Now: A:<A>, B:<B>, C:<A>, D:<empty>
1903  [ 'op' => 'copy', 'src' => $fileB, 'dst' => $fileD, 'overwrite' => 1 ],
1904  // Now: A:<A>, B:<B>, C:<A>, D:<B>
1905  [ 'op' => 'move', 'src' => $fileC, 'dst' => $fileD ],
1906  // Now: A:<A>, B:<B>, C:<A>, D:<empty> (failed)
1907  [ 'op' => 'move', 'src' => $fileB, 'dst' => $fileC, 'overwriteSame' => 1 ],
1908  // Now: A:<A>, B:<B>, C:<A>, D:<empty> (failed)
1909  [ 'op' => 'move', 'src' => $fileB, 'dst' => $fileA, 'overwrite' => 1 ],
1910  // Now: A:<B>, B:<empty>, C:<A>, D:<empty>
1911  [ 'op' => 'delete', 'src' => $fileD ],
1912  // Now: A:<B>, B:<empty>, C:<A>, D:<empty>
1913  [ 'op' => 'null' ],
1914  // Does nothing
1915  ], [ 'force' => 1 ] );
1916 
1917  $this->assertNotEquals( [], $status->getErrors(), "Operation had warnings" );
1918  $this->assertEquals( true, $status->isOK(), "Operation batch succeeded" );
1919  $this->assertEquals( 8, count( $status->success ),
1920  "Operation batch has correct success array" );
1921 
1922  $this->assertEquals( false, $this->backend->fileExists( [ 'src' => $fileB ] ),
1923  "File does not exist at $fileB" );
1924  $this->assertEquals( false, $this->backend->fileExists( [ 'src' => $fileD ] ),
1925  "File does not exist at $fileD" );
1926 
1927  $this->assertEquals( true, $this->backend->fileExists( [ 'src' => $fileA ] ),
1928  "File does not exist at $fileA" );
1929  $this->assertEquals( true, $this->backend->fileExists( [ 'src' => $fileC ] ),
1930  "File exists at $fileC" );
1931  $this->assertEquals( $fileBContents,
1932  $this->backend->getFileContents( [ 'src' => $fileA ] ),
1933  "Correct file contents of $fileA" );
1934  $this->assertEquals( strlen( $fileBContents ),
1935  $this->backend->getFileSize( [ 'src' => $fileA ] ),
1936  "Correct file size of $fileA" );
1937  $this->assertEquals( Wikimedia\base_convert( sha1( $fileBContents ), 16, 36, 31 ),
1938  $this->backend->getFileSha1Base36( [ 'src' => $fileA ] ),
1939  "Correct file SHA-1 of $fileA" );
1940  }
1941 
1945  public function testGetFileList() {
1946  $this->backend = $this->singleBackend;
1947  $this->tearDownFiles();
1948  $this->doTestGetFileList();
1949  $this->tearDownFiles();
1950 
1951  $this->backend = $this->multiBackend;
1952  $this->tearDownFiles();
1953  $this->doTestGetFileList();
1954  $this->tearDownFiles();
1955  }
1956 
1957  private function doTestGetFileList() {
1958  $backendName = $this->backendClass();
1959  $base = self::baseStorePath();
1960 
1961  // Should have no errors
1962  $iter = $this->backend->getFileList( [ 'dir' => "$base/unittest-cont-notexists" ] );
1963 
1964  $files = [
1965  "$base/unittest-cont1/e/test1.txt",
1966  "$base/unittest-cont1/e/test2.txt",
1967  "$base/unittest-cont1/e/test3.txt",
1968  "$base/unittest-cont1/e/subdir1/test1.txt",
1969  "$base/unittest-cont1/e/subdir1/test2.txt",
1970  "$base/unittest-cont1/e/subdir2/test3.txt",
1971  "$base/unittest-cont1/e/subdir2/test4.txt",
1972  "$base/unittest-cont1/e/subdir2/subdir/test1.txt",
1973  "$base/unittest-cont1/e/subdir2/subdir/test2.txt",
1974  "$base/unittest-cont1/e/subdir2/subdir/test3.txt",
1975  "$base/unittest-cont1/e/subdir2/subdir/test4.txt",
1976  "$base/unittest-cont1/e/subdir2/subdir/test5.txt",
1977  "$base/unittest-cont1/e/subdir2/subdir/sub/test0.txt",
1978  "$base/unittest-cont1/e/subdir2/subdir/sub/120-px-file.txt",
1979  ];
1980 
1981  // Add the files
1982  $ops = [];
1983  foreach ( $files as $file ) {
1984  $this->prepare( [ 'dir' => dirname( $file ) ] );
1985  $ops[] = [ 'op' => 'create', 'content' => 'xxy', 'dst' => $file ];
1986  }
1987  $status = $this->backend->doQuickOperations( $ops );
1988  $this->assertGoodStatus( $status,
1989  "Creation of files succeeded ($backendName)." );
1990  $this->assertEquals( true, $status->isOK(),
1991  "Creation of files succeeded with OK status ($backendName)." );
1992 
1993  // Expected listing at root
1994  $expected = [
1995  "e/test1.txt",
1996  "e/test2.txt",
1997  "e/test3.txt",
1998  "e/subdir1/test1.txt",
1999  "e/subdir1/test2.txt",
2000  "e/subdir2/test3.txt",
2001  "e/subdir2/test4.txt",
2002  "e/subdir2/subdir/test1.txt",
2003  "e/subdir2/subdir/test2.txt",
2004  "e/subdir2/subdir/test3.txt",
2005  "e/subdir2/subdir/test4.txt",
2006  "e/subdir2/subdir/test5.txt",
2007  "e/subdir2/subdir/sub/test0.txt",
2008  "e/subdir2/subdir/sub/120-px-file.txt",
2009  ];
2010  sort( $expected );
2011 
2012  // Actual listing (no trailing slash) at root
2013  $iter = $this->backend->getFileList( [ 'dir' => "$base/unittest-cont1" ] );
2014  $list = $this->listToArray( $iter );
2015  sort( $list );
2016  $this->assertEquals( $expected, $list, "Correct file listing ($backendName)." );
2017 
2018  // Actual listing (no trailing slash) at root with advise
2019  $iter = $this->backend->getFileList( [
2020  'dir' => "$base/unittest-cont1",
2021  'adviseStat' => 1
2022  ] );
2023  $list = $this->listToArray( $iter );
2024  sort( $list );
2025  $this->assertEquals( $expected, $list, "Correct file listing ($backendName)." );
2026 
2027  // Actual listing (with trailing slash) at root
2028  $list = [];
2029  $iter = $this->backend->getFileList( [ 'dir' => "$base/unittest-cont1/" ] );
2030  foreach ( $iter as $file ) {
2031  $list[] = $file;
2032  }
2033  sort( $list );
2034  $this->assertEquals( $expected, $list, "Correct file listing ($backendName)." );
2035 
2036  // Expected listing at subdir
2037  $expected = [
2038  "test1.txt",
2039  "test2.txt",
2040  "test3.txt",
2041  "test4.txt",
2042  "test5.txt",
2043  "sub/test0.txt",
2044  "sub/120-px-file.txt",
2045  ];
2046  sort( $expected );
2047 
2048  // Actual listing (no trailing slash) at subdir
2049  $iter = $this->backend->getFileList( [ 'dir' => "$base/unittest-cont1/e/subdir2/subdir" ] );
2050  $list = $this->listToArray( $iter );
2051  sort( $list );
2052  $this->assertEquals( $expected, $list, "Correct file listing ($backendName)." );
2053 
2054  // Actual listing (no trailing slash) at subdir with advise
2055  $iter = $this->backend->getFileList( [
2056  'dir' => "$base/unittest-cont1/e/subdir2/subdir",
2057  'adviseStat' => 1
2058  ] );
2059  $list = $this->listToArray( $iter );
2060  sort( $list );
2061  $this->assertEquals( $expected, $list, "Correct file listing ($backendName)." );
2062 
2063  // Actual listing (with trailing slash) at subdir
2064  $list = [];
2065  $iter = $this->backend->getFileList( [ 'dir' => "$base/unittest-cont1/e/subdir2/subdir/" ] );
2066  foreach ( $iter as $file ) {
2067  $list[] = $file;
2068  }
2069  sort( $list );
2070  $this->assertEquals( $expected, $list, "Correct file listing ($backendName)." );
2071 
2072  // Actual listing (using iterator second time)
2073  $list = $this->listToArray( $iter );
2074  sort( $list );
2075  $this->assertEquals( $expected, $list, "Correct file listing ($backendName), second iteration." );
2076 
2077  // Actual listing (top files only) at root
2078  $iter = $this->backend->getTopFileList( [ 'dir' => "$base/unittest-cont1" ] );
2079  $list = $this->listToArray( $iter );
2080  sort( $list );
2081  $this->assertEquals( [], $list, "Correct top file listing ($backendName)." );
2082 
2083  // Expected listing (top files only) at subdir
2084  $expected = [
2085  "test1.txt",
2086  "test2.txt",
2087  "test3.txt",
2088  "test4.txt",
2089  "test5.txt"
2090  ];
2091  sort( $expected );
2092 
2093  // Actual listing (top files only) at subdir
2094  $iter = $this->backend->getTopFileList(
2095  [ 'dir' => "$base/unittest-cont1/e/subdir2/subdir" ]
2096  );
2097  $list = $this->listToArray( $iter );
2098  sort( $list );
2099  $this->assertEquals( $expected, $list, "Correct top file listing ($backendName)." );
2100 
2101  // Actual listing (top files only) at subdir with advise
2102  $iter = $this->backend->getTopFileList( [
2103  'dir' => "$base/unittest-cont1/e/subdir2/subdir",
2104  'adviseStat' => 1
2105  ] );
2106  $list = $this->listToArray( $iter );
2107  sort( $list );
2108  $this->assertEquals( $expected, $list, "Correct top file listing ($backendName)." );
2109 
2110  foreach ( $files as $file ) { // clean up
2111  $this->backend->doOperation( [ 'op' => 'delete', 'src' => $file ] );
2112  }
2113 
2114  $iter = $this->backend->getFileList( [ 'dir' => "$base/unittest-cont1/not/exists" ] );
2115  foreach ( $iter as $iter ) {
2116  // no errors
2117  }
2118  }
2119 
2124  public function testGetDirectoryList() {
2125  $this->backend = $this->singleBackend;
2126  $this->tearDownFiles();
2127  $this->doTestGetDirectoryList();
2128  $this->tearDownFiles();
2129 
2130  $this->backend = $this->multiBackend;
2131  $this->tearDownFiles();
2132  $this->doTestGetDirectoryList();
2133  $this->tearDownFiles();
2134  }
2135 
2136  private function doTestGetDirectoryList() {
2137  $backendName = $this->backendClass();
2138 
2139  $base = self::baseStorePath();
2140  $files = [
2141  "$base/unittest-cont1/e/test1.txt",
2142  "$base/unittest-cont1/e/test2.txt",
2143  "$base/unittest-cont1/e/test3.txt",
2144  "$base/unittest-cont1/e/subdir1/test1.txt",
2145  "$base/unittest-cont1/e/subdir1/test2.txt",
2146  "$base/unittest-cont1/e/subdir2/test3.txt",
2147  "$base/unittest-cont1/e/subdir2/test4.txt",
2148  "$base/unittest-cont1/e/subdir2/subdir/test1.txt",
2149  "$base/unittest-cont1/e/subdir3/subdir/test2.txt",
2150  "$base/unittest-cont1/e/subdir4/subdir/test3.txt",
2151  "$base/unittest-cont1/e/subdir4/subdir/test4.txt",
2152  "$base/unittest-cont1/e/subdir4/subdir/test5.txt",
2153  "$base/unittest-cont1/e/subdir4/subdir/sub/test0.txt",
2154  "$base/unittest-cont1/e/subdir4/subdir/sub/120-px-file.txt",
2155  ];
2156 
2157  // Add the files
2158  $ops = [];
2159  foreach ( $files as $file ) {
2160  $this->prepare( [ 'dir' => dirname( $file ) ] );
2161  $ops[] = [ 'op' => 'create', 'content' => 'xxy', 'dst' => $file ];
2162  }
2163  $status = $this->backend->doQuickOperations( $ops );
2164  $this->assertGoodStatus( $status,
2165  "Creation of files succeeded ($backendName)." );
2166  $this->assertEquals( true, $status->isOK(),
2167  "Creation of files succeeded with OK status ($backendName)." );
2168 
2169  $this->assertEquals( true,
2170  $this->backend->directoryExists( [ 'dir' => "$base/unittest-cont1/e/subdir1" ] ),
2171  "Directory exists in ($backendName)." );
2172  $this->assertEquals( true,
2173  $this->backend->directoryExists( [ 'dir' => "$base/unittest-cont1/e/subdir2/subdir" ] ),
2174  "Directory exists in ($backendName)." );
2175  $this->assertEquals( false,
2176  $this->backend->directoryExists( [ 'dir' => "$base/unittest-cont1/e/subdir2/test1.txt" ] ),
2177  "Directory does not exists in ($backendName)." );
2178 
2179  // Expected listing
2180  $expected = [
2181  "e",
2182  ];
2183  sort( $expected );
2184 
2185  // Actual listing (no trailing slash)
2186  $list = [];
2187  $iter = $this->backend->getTopDirectoryList( [ 'dir' => "$base/unittest-cont1" ] );
2188  foreach ( $iter as $file ) {
2189  $list[] = $file;
2190  }
2191  sort( $list );
2192 
2193  $this->assertEquals( $expected, $list, "Correct top dir listing ($backendName)." );
2194 
2195  // Expected listing
2196  $expected = [
2197  "subdir1",
2198  "subdir2",
2199  "subdir3",
2200  "subdir4",
2201  ];
2202  sort( $expected );
2203 
2204  // Actual listing (no trailing slash)
2205  $list = [];
2206  $iter = $this->backend->getTopDirectoryList( [ 'dir' => "$base/unittest-cont1/e" ] );
2207  foreach ( $iter as $file ) {
2208  $list[] = $file;
2209  }
2210  sort( $list );
2211 
2212  $this->assertEquals( $expected, $list, "Correct top dir listing ($backendName)." );
2213 
2214  // Actual listing (with trailing slash)
2215  $list = [];
2216  $iter = $this->backend->getTopDirectoryList( [ 'dir' => "$base/unittest-cont1/e/" ] );
2217  foreach ( $iter as $file ) {
2218  $list[] = $file;
2219  }
2220  sort( $list );
2221 
2222  $this->assertEquals( $expected, $list, "Correct top dir listing ($backendName)." );
2223 
2224  // Expected listing
2225  $expected = [
2226  "subdir",
2227  ];
2228  sort( $expected );
2229 
2230  // Actual listing (no trailing slash)
2231  $list = [];
2232  $iter = $this->backend->getTopDirectoryList( [ 'dir' => "$base/unittest-cont1/e/subdir2" ] );
2233  foreach ( $iter as $file ) {
2234  $list[] = $file;
2235  }
2236  sort( $list );
2237 
2238  $this->assertEquals( $expected, $list, "Correct top dir listing ($backendName)." );
2239 
2240  // Actual listing (with trailing slash)
2241  $list = [];
2242  $iter = $this->backend->getTopDirectoryList(
2243  [ 'dir' => "$base/unittest-cont1/e/subdir2/" ]
2244  );
2245 
2246  foreach ( $iter as $file ) {
2247  $list[] = $file;
2248  }
2249  sort( $list );
2250 
2251  $this->assertEquals( $expected, $list, "Correct top dir listing ($backendName)." );
2252 
2253  // Actual listing (using iterator second time)
2254  $list = [];
2255  foreach ( $iter as $file ) {
2256  $list[] = $file;
2257  }
2258  sort( $list );
2259 
2260  $this->assertEquals(
2261  $expected,
2262  $list,
2263  "Correct top dir listing ($backendName), second iteration."
2264  );
2265 
2266  // Expected listing (recursive)
2267  $expected = [
2268  "e",
2269  "e/subdir1",
2270  "e/subdir2",
2271  "e/subdir3",
2272  "e/subdir4",
2273  "e/subdir2/subdir",
2274  "e/subdir3/subdir",
2275  "e/subdir4/subdir",
2276  "e/subdir4/subdir/sub",
2277  ];
2278  sort( $expected );
2279 
2280  // Actual listing (recursive)
2281  $list = [];
2282  $iter = $this->backend->getDirectoryList( [ 'dir' => "$base/unittest-cont1/" ] );
2283  foreach ( $iter as $file ) {
2284  $list[] = $file;
2285  }
2286  sort( $list );
2287 
2288  $this->assertEquals( $expected, $list, "Correct dir listing ($backendName)." );
2289 
2290  // Expected listing (recursive)
2291  $expected = [
2292  "subdir",
2293  "subdir/sub",
2294  ];
2295  sort( $expected );
2296 
2297  // Actual listing (recursive)
2298  $list = [];
2299  $iter = $this->backend->getDirectoryList( [ 'dir' => "$base/unittest-cont1/e/subdir4" ] );
2300  foreach ( $iter as $file ) {
2301  $list[] = $file;
2302  }
2303  sort( $list );
2304 
2305  $this->assertEquals( $expected, $list, "Correct dir listing ($backendName)." );
2306 
2307  // Actual listing (recursive, second time)
2308  $list = [];
2309  foreach ( $iter as $file ) {
2310  $list[] = $file;
2311  }
2312  sort( $list );
2313 
2314  $this->assertEquals( $expected, $list, "Correct dir listing ($backendName)." );
2315 
2316  $iter = $this->backend->getDirectoryList( [ 'dir' => "$base/unittest-cont1/e/subdir1" ] );
2317  $items = $this->listToArray( $iter );
2318  $this->assertEquals( [], $items, "Directory listing is empty." );
2319 
2320  foreach ( $files as $file ) { // clean up
2321  $this->backend->doOperation( [ 'op' => 'delete', 'src' => $file ] );
2322  }
2323 
2324  $iter = $this->backend->getDirectoryList( [ 'dir' => "$base/unittest-cont1/not/exists" ] );
2325  foreach ( $iter as $file ) {
2326  // no errors
2327  }
2328 
2329  $items = $this->listToArray( $iter );
2330  $this->assertEquals( [], $items, "Directory listing is empty." );
2331 
2332  $iter = $this->backend->getDirectoryList( [ 'dir' => "$base/unittest-cont1/e/not/exists" ] );
2333  $items = $this->listToArray( $iter );
2334  $this->assertEquals( [], $items, "Directory listing is empty." );
2335  }
2336 
2341  public function testLockCalls() {
2342  $this->backend = $this->singleBackend;
2343  $this->doTestLockCalls();
2344  }
2345 
2346  private function doTestLockCalls() {
2347  $backendName = $this->backendClass();
2348 
2349  $paths = [
2350  "test1.txt",
2351  "test2.txt",
2352  "test3.txt",
2353  "subdir1",
2354  "subdir1", // duplicate
2355  "subdir1/test1.txt",
2356  "subdir1/test2.txt",
2357  "subdir2",
2358  "subdir2", // duplicate
2359  "subdir2/test3.txt",
2360  "subdir2/test4.txt",
2361  "subdir2/subdir",
2362  "subdir2/subdir/test1.txt",
2363  "subdir2/subdir/test2.txt",
2364  "subdir2/subdir/test3.txt",
2365  "subdir2/subdir/test4.txt",
2366  "subdir2/subdir/test5.txt",
2367  "subdir2/subdir/sub",
2368  "subdir2/subdir/sub/test0.txt",
2369  "subdir2/subdir/sub/120-px-file.txt",
2370  ];
2371 
2372  for ( $i = 0; $i < 25; $i++ ) {
2373  $status = $this->backend->lockFiles( $paths, LockManager::LOCK_EX );
2374  $this->assertEquals( print_r( [], true ), print_r( $status->getErrors(), true ),
2375  "Locking of files succeeded ($backendName) ($i)." );
2376  $this->assertEquals( true, $status->isOK(),
2377  "Locking of files succeeded with OK status ($backendName) ($i)." );
2378 
2379  $status = $this->backend->lockFiles( $paths, LockManager::LOCK_SH );
2380  $this->assertEquals( print_r( [], true ), print_r( $status->getErrors(), true ),
2381  "Locking of files succeeded ($backendName) ($i)." );
2382  $this->assertEquals( true, $status->isOK(),
2383  "Locking of files succeeded with OK status ($backendName) ($i)." );
2384 
2385  $status = $this->backend->unlockFiles( $paths, LockManager::LOCK_SH );
2386  $this->assertEquals( print_r( [], true ), print_r( $status->getErrors(), true ),
2387  "Locking of files succeeded ($backendName) ($i)." );
2388  $this->assertEquals( true, $status->isOK(),
2389  "Locking of files succeeded with OK status ($backendName) ($i)." );
2390 
2391  $status = $this->backend->unlockFiles( $paths, LockManager::LOCK_EX );
2392  $this->assertEquals( print_r( [], true ), print_r( $status->getErrors(), true ),
2393  "Locking of files succeeded ($backendName). ($i)" );
2394  $this->assertEquals( true, $status->isOK(),
2395  "Locking of files succeeded with OK status ($backendName) ($i)." );
2396 
2397  # # Flip the acquire/release ordering around ##
2398 
2399  $status = $this->backend->lockFiles( $paths, LockManager::LOCK_SH );
2400  $this->assertEquals( print_r( [], true ), print_r( $status->getErrors(), true ),
2401  "Locking of files succeeded ($backendName) ($i)." );
2402  $this->assertEquals( true, $status->isOK(),
2403  "Locking of files succeeded with OK status ($backendName) ($i)." );
2404 
2405  $status = $this->backend->lockFiles( $paths, LockManager::LOCK_EX );
2406  $this->assertEquals( print_r( [], true ), print_r( $status->getErrors(), true ),
2407  "Locking of files succeeded ($backendName) ($i)." );
2408  $this->assertEquals( true, $status->isOK(),
2409  "Locking of files succeeded with OK status ($backendName) ($i)." );
2410 
2411  $status = $this->backend->unlockFiles( $paths, LockManager::LOCK_EX );
2412  $this->assertEquals( print_r( [], true ), print_r( $status->getErrors(), true ),
2413  "Locking of files succeeded ($backendName). ($i)" );
2414  $this->assertEquals( true, $status->isOK(),
2415  "Locking of files succeeded with OK status ($backendName) ($i)." );
2416 
2417  $status = $this->backend->unlockFiles( $paths, LockManager::LOCK_SH );
2418  $this->assertEquals( print_r( [], true ), print_r( $status->getErrors(), true ),
2419  "Locking of files succeeded ($backendName) ($i)." );
2420  $this->assertEquals( true, $status->isOK(),
2421  "Locking of files succeeded with OK status ($backendName) ($i)." );
2422  }
2423 
2424  $status = Status::newGood();
2425  $sl = $this->backend->getScopedFileLocks( $paths, LockManager::LOCK_EX, $status );
2426  $this->assertInstanceOf( 'ScopedLock', $sl,
2427  "Scoped locking of files succeeded ($backendName)." );
2428  $this->assertEquals( [], $status->getErrors(),
2429  "Scoped locking of files succeeded ($backendName)." );
2430  $this->assertEquals( true, $status->isOK(),
2431  "Scoped locking of files succeeded with OK status ($backendName)." );
2432 
2433  ScopedLock::release( $sl );
2434  $this->assertEquals( null, $sl,
2435  "Scoped unlocking of files succeeded ($backendName)." );
2436  $this->assertEquals( [], $status->getErrors(),
2437  "Scoped unlocking of files succeeded ($backendName)." );
2438  $this->assertEquals( true, $status->isOK(),
2439  "Scoped unlocking of files succeeded with OK status ($backendName)." );
2440  }
2441 
2445  public function testGetContentType( $mimeCallback, $mimeFromString ) {
2446  global $IP;
2447 
2448  $be = TestingAccessWrapper::newFromObject( new MemoryFileBackend(
2449  [
2450  'name' => 'testing',
2451  'class' => 'MemoryFileBackend',
2452  'wikiId' => 'meow',
2453  'mimeCallback' => $mimeCallback
2454  ]
2455  ) );
2456 
2457  $dst = 'mwstore://testing/container/path/to/file_no_ext';
2458  $src = "$IP/tests/phpunit/data/media/srgb.jpg";
2459  $this->assertEquals( 'image/jpeg', $be->getContentType( $dst, null, $src ) );
2460  $this->assertEquals(
2461  $mimeFromString ? 'image/jpeg' : 'unknown/unknown',
2462  $be->getContentType( $dst, file_get_contents( $src ), null ) );
2463 
2464  $src = "$IP/tests/phpunit/data/media/Png-native-test.png";
2465  $this->assertEquals( 'image/png', $be->getContentType( $dst, null, $src ) );
2466  $this->assertEquals(
2467  $mimeFromString ? 'image/png' : 'unknown/unknown',
2468  $be->getContentType( $dst, file_get_contents( $src ), null ) );
2469  }
2470 
2471  public static function provider_testGetContentType() {
2472  return [
2473  [ null, false ],
2474  [ [ FileBackendGroup::singleton(), 'guessMimeInternal' ], true ]
2475  ];
2476  }
2477 
2478  public function testReadAffinity() {
2479  $be = TestingAccessWrapper::newFromObject(
2480  new FileBackendMultiWrite( [
2481  'name' => 'localtesting',
2482  'wikiId' => wfWikiID() . mt_rand(),
2483  'backends' => [
2484  [ // backend 0
2485  'name' => 'multitesting0',
2486  'class' => 'MemoryFileBackend',
2487  'isMultiMaster' => false,
2488  'readAffinity' => true
2489  ],
2490  [ // backend 1
2491  'name' => 'multitesting1',
2492  'class' => 'MemoryFileBackend',
2493  'isMultiMaster' => true
2494  ]
2495  ]
2496  ] )
2497  );
2498 
2499  $this->assertEquals(
2500  1,
2501  $be->getReadIndexFromParams( [ 'latest' => 1 ] ),
2502  'Reads with "latest" flag use backend 1'
2503  );
2504  $this->assertEquals(
2505  0,
2506  $be->getReadIndexFromParams( [ 'latest' => 0 ] ),
2507  'Reads without "latest" flag use backend 0'
2508  );
2509 
2510  $p = 'container/test-cont/file.txt';
2511  $be->backends[0]->quickCreate( [
2512  'dst' => "mwstore://multitesting0/$p", 'content' => 'cattitude' ] );
2513  $be->backends[1]->quickCreate( [
2514  'dst' => "mwstore://multitesting1/$p", 'content' => 'princess of power' ] );
2515 
2516  $this->assertEquals(
2517  'cattitude',
2518  $be->getFileContents( [ 'src' => "mwstore://localtesting/$p" ] ),
2519  "Non-latest read came from backend 0"
2520  );
2521  $this->assertEquals(
2522  'princess of power',
2523  $be->getFileContents( [ 'src' => "mwstore://localtesting/$p", 'latest' => 1 ] ),
2524  "Latest read came from backend1"
2525  );
2526  }
2527 
2528  public function testAsyncWrites() {
2529  $be = TestingAccessWrapper::newFromObject(
2530  new FileBackendMultiWrite( [
2531  'name' => 'localtesting',
2532  'wikiId' => wfWikiID() . mt_rand(),
2533  'backends' => [
2534  [ // backend 0
2535  'name' => 'multitesting0',
2536  'class' => 'MemoryFileBackend',
2537  'isMultiMaster' => false
2538  ],
2539  [ // backend 1
2540  'name' => 'multitesting1',
2541  'class' => 'MemoryFileBackend',
2542  'isMultiMaster' => true
2543  ]
2544  ],
2545  'replication' => 'async'
2546  ] )
2547  );
2548 
2549  $this->setMwGlobals( 'wgCommandLineMode', false );
2550 
2551  $p = 'container/test-cont/file.txt';
2552  $be->quickCreate( [
2553  'dst' => "mwstore://localtesting/$p", 'content' => 'cattitude' ] );
2554 
2555  $this->assertEquals(
2556  false,
2557  $be->backends[0]->getFileContents( [ 'src' => "mwstore://multitesting0/$p" ] ),
2558  "File not yet written to backend 0"
2559  );
2560  $this->assertEquals(
2561  'cattitude',
2562  $be->backends[1]->getFileContents( [ 'src' => "mwstore://multitesting1/$p" ] ),
2563  "File already written to backend 1"
2564  );
2565 
2566  DeferredUpdates::doUpdates();
2567 
2568  $this->assertEquals(
2569  'cattitude',
2570  $be->backends[0]->getFileContents( [ 'src' => "mwstore://multitesting0/$p" ] ),
2571  "File now written to backend 0"
2572  );
2573  }
2574 
2575  public function testSanitizeOpHeaders() {
2576  $be = TestingAccessWrapper::newFromObject( new MemoryFileBackend( [
2577  'name' => 'localtesting',
2578  'wikiId' => wfWikiID()
2579  ] ) );
2580 
2581  $name = wfRandomString( 300 );
2582 
2583  $input = [
2584  'headers' => [
2585  'content-Disposition' => FileBackend::makeContentDisposition( 'inline', $name ),
2586  'Content-dUration' => 25.6,
2587  'X-LONG-VALUE' => str_pad( '0', 300 ),
2588  'CONTENT-LENGTH' => 855055,
2589  ]
2590  ];
2591  $expected = [
2592  'headers' => [
2593  'content-disposition' => FileBackend::makeContentDisposition( 'inline', $name ),
2594  'content-duration' => 25.6,
2595  'content-length' => 855055
2596  ]
2597  ];
2598 
2599  MediaWiki\suppressWarnings();
2600  $actual = $be->sanitizeOpHeaders( $input );
2601  MediaWiki\restoreWarnings();
2602 
2603  $this->assertEquals( $expected, $actual, "Header sanitized properly" );
2604  }
2605 
2606  // helper function
2607  private function listToArray( $iter ) {
2608  return is_array( $iter ) ? $iter : iterator_to_array( $iter );
2609  }
2610 
2611  // test helper wrapper for backend prepare() function
2612  private function prepare( array $params ) {
2613  return $this->backend->prepare( $params );
2614  }
2615 
2616  // test helper wrapper for backend prepare() function
2617  private function create( array $params ) {
2618  $params['op'] = 'create';
2619 
2620  return $this->backend->doQuickOperations( [ $params ] );
2621  }
2622 
2623  function tearDownFiles() {
2624  $containers = [ 'unittest-cont1', 'unittest-cont2', 'unittest-cont-bad' ];
2625  foreach ( $containers as $container ) {
2626  $this->deleteFiles( $container );
2627  }
2628  }
2629 
2630  private function deleteFiles( $container ) {
2631  $base = self::baseStorePath();
2632  $iter = $this->backend->getFileList( [ 'dir' => "$base/$container" ] );
2633  if ( $iter ) {
2634  foreach ( $iter as $file ) {
2635  $this->backend->quickDelete( [ 'src' => "$base/$container/$file" ] );
2636  }
2637  // free the directory, to avoid Permission denied under windows on rmdir
2638  unset( $iter );
2639  }
2640  $this->backend->clean( [ 'dir' => "$base/$container", 'recursive' => 1 ] );
2641  }
2642 
2643  function assertBackendPathsConsistent( array $paths ) {
2644  if ( $this->backend instanceof FileBackendMultiWrite ) {
2645  $status = $this->backend->consistencyCheck( $paths );
2646  $this->assertGoodStatus( $status, "Files synced: " . implode( ',', $paths ) );
2647  }
2648  }
2649 
2650  function assertGoodStatus( StatusValue $status, $msg ) {
2651  $this->assertEquals( print_r( [], 1 ), print_r( $status->getErrors(), 1 ), $msg );
2652  }
2653 }
FileBackendTest\baseStorePath
static baseStorePath()
Definition: FileBackendTest.php:82
FileBackendTest\testGetContentType
testGetContentType($mimeCallback, $mimeFromString)
provider_testGetContentType
Definition: FileBackendTest.php:2445
array
the array() calling protocol came about after MediaWiki 1.4rc1.
FileBackendTest\testGetFileHttpUrl
testGetFileHttpUrl($source, $content)
provider_testGetFileHttpUrl FileBackend::getFileHttpUrl
Definition: FileBackendTest.php:1504
FileBackendTest\provider_testParentStoragePath
static provider_testParentStoragePath()
Definition: FileBackendTest.php:179
FileBackendTest\$singleBackend
FSFileBackend $singleBackend
Definition: FileBackendTest.php:15
$dir
if(count($args)==0) $dir
Definition: importImages.php:56
FileBackendTest\testDescribe
testDescribe($op, $withSource, $okStatus)
provider_testDescribe FileBackend::doOperation
Definition: FileBackendTest.php:626
LockManagerGroup\singleton
static singleton($domain=false)
Definition: LockManagerGroup.php:53
false
processing should stop and the error should be shown to the user * false
Definition: hooks.txt:189
FileBackendTest\testExtensionFromPath
testExtensionFromPath($path, $res)
provider_testExtensionFromPath FileBackend::extensionFromPath
Definition: FileBackendTest.php:196
$IP
$IP
Definition: WebStart.php:58
FileBackendTest\testSplitStoragePath
testSplitStoragePath($path, $res)
provider_testSplitStoragePath FileBackend::splitStoragePath
Definition: FileBackendTest.php:119
FileBackendTest\provider_testGetLocalReference
static provider_testGetLocalReference()
Definition: FileBackendTest.php:1454
FileBackendTest\provider_testGetFileContents
static provider_testGetFileContents()
Definition: FileBackendTest.php:1290
FileBackendTest\testDoOperations
testDoOperations()
FileBackend::doOperations.
Definition: FileBackendTest.php:1679
FileBackendTest\assertHasHeaders
assertHasHeaders(array $headers, array $attr)
Definition: FileBackendTest.php:687
DeferredUpdates\doUpdates
static doUpdates($mode= 'run', $stage=self::ALL)
Do any deferred updates and clear the list.
Definition: DeferredUpdates.php:125
$wgFileBackends
$wgFileBackends
File backend structure configuration.
Definition: DefaultSettings.php:641
FileBackend\ATTR_HEADERS
const ATTR_HEADERS
Bitfield flags for supported features.
Definition: FileBackend.php:129
FileBackendTest\provider_testExtensionFromPath
static provider_testExtensionFromPath()
Definition: FileBackendTest.php:201
FileBackendTest\assertBackendPathsConsistent
assertBackendPathsConsistent(array $paths)
Definition: FileBackendTest.php:2643
FileBackendTest\doTestCreate
doTestCreate($op, $alreadyExists, $okStatus, $newSize)
Definition: FileBackendTest.php:739
$source
$source
Definition: mwdoc-filter.php:45
FileBackendTest\testIsStoragePath
testIsStoragePath($path, $isStorePath)
provider_testIsStoragePath FileBackend::isStoragePath
Definition: FileBackendTest.php:94
FileBackendTest\testLockCalls
testLockCalls()
FileBackend::lockFiles FileBackend::unlockFiles.
Definition: FileBackendTest.php:2341
FileBackendTest\doTestPrepareAndClean
doTestPrepareAndClean($path, $isOK)
Definition: FileBackendTest.php:1571
$files
$files
Definition: importImages.php:74
FileBackendTest\doTestGetLocalCopy
doTestGetLocalCopy($source, $content)
Definition: FileBackendTest.php:1321
FileBackendTest\provider_testCopy
static provider_testCopy()
Definition: FileBackendTest.php:360
FileBackendTest\testGetFileList
testGetFileList()
FileBackend::getFileList.
Definition: FileBackendTest.php:1945
FileBackendTest\doTestGetFileHttpUrl
doTestGetFileHttpUrl($source, $content)
Definition: FileBackendTest.php:1516
FileBackendTest\doTestDelete
doTestDelete($op, $withSource, $okStatus)
Definition: FileBackendTest.php:546
FileBackendTest\testStore
testStore($op)
provider_testStore
Definition: FileBackendTest.php:213
global
when a variable name is used in a it is silently declared as a new local masking the global
Definition: design.txt:93
MediaWikiTestCase\getNewTempFile
getNewTempFile()
Obtains a new temporary file name.
Definition: MediaWikiTestCase.php:433
FileBackend\extensionFromPath
static extensionFromPath($path, $case= 'lowercase')
Get the final extension from a storage or FS path.
Definition: FileBackend.php:1507
FileBackendTest\$backend
FileBackend $backend
Definition: FileBackendTest.php:11
FileBackendTest\provider_testConcatenate
static provider_testConcatenate()
Definition: FileBackendTest.php:1009
wfRandomString
wfRandomString($length=32)
Get a random string containing a number of pseudo-random hex characters.
Definition: GlobalFunctions.php:334
Http\request
static request($method, $url, $options=[], $caller=__METHOD__)
Perform an HTTP request.
Definition: Http.php:57
TempFSFile\factory
static factory($prefix, $extension= '', $tmpDirectory=null)
Make a new temporary file on the file system.
Definition: TempFSFile.php:55
FileBackendTest\provider_normalizeStoragePath
static provider_normalizeStoragePath()
Definition: FileBackendTest.php:149
TS_UNIX
const TS_UNIX
Unix time - the number of seconds since 1970-01-01 00:00:00 UTC.
Definition: defines.php:6
wfTimestamp
wfTimestamp($outputtype=TS_UNIX, $ts=0)
Get a timestamp string in one of various formats.
Definition: GlobalFunctions.php:2007
true
null means default in associative array with keys and values unescaped Should be merged with default with a value of false meaning to suppress the attribute in associative array with keys and values unescaped noclasses just before the function returns a value If you return true
Definition: hooks.txt:1936
FileBackendTest\provider_testCreate
static provider_testCreate()
provider_testCreate
Definition: FileBackendTest.php:792
wfTempDir
wfTempDir()
Tries to get the system directory for temporary files.
Definition: GlobalFunctions.php:2074
FileBackendTest\provider_testGetLocalCopy
static provider_testGetLocalCopy()
Definition: FileBackendTest.php:1375
FileBackendTest\testCopy
testCopy($op)
provider_testCopy FileBackend::doOperation
Definition: FileBackendTest.php:291
LockManager\LOCK_EX
const LOCK_EX
Definition: LockManager.php:70
$res
$res
Definition: database.txt:21
FileBackend\isStoragePath
static isStoragePath($path)
Check if a given path is a "mwstore://" path.
Definition: FileBackend.php:1436
FileBackendTest\provider_testIsStoragePath
static provider_testIsStoragePath()
Definition: FileBackendTest.php:99
FileBackendTest\provider_testMove
static provider_testMove()
Definition: FileBackendTest.php:482
FileBackendTest\provider_testGetFileStat
static provider_testGetFileStat()
Definition: FileBackendTest.php:1122
FileBackendTest\create
create(array $params)
Definition: FileBackendTest.php:2617
FileBackendTest\testGetLocalReference
testGetLocalReference($source, $content)
provider_testGetLocalReference FileBackend::getLocalReference
Definition: FileBackendTest.php:1395
FileBackendTest\doTestGetFileContents
doTestGetFileContents($source, $content)
Definition: FileBackendTest.php:1249
FileBackendTest\provider_testDelete
static provider_testDelete()
Definition: FileBackendTest.php:586
FileBackendTest
FileRepo FileBackend medium.
Definition: FileBackendTest.php:8
$params
$params
Definition: styleTest.css.php:40
FileBackendTest\testNormalizeStoragePath
testNormalizeStoragePath($path, $res)
provider_normalizeStoragePath FileBackend::normalizeStoragePath
Definition: FileBackendTest.php:144
FileBackendTest\provider_testPrepareAndClean
static provider_testPrepareAndClean()
Definition: FileBackendTest.php:1560
FileBackendTest\doTestGetLocalReference
doTestGetLocalReference($source, $content)
Definition: FileBackendTest.php:1407
FileBackendTest\deleteFiles
deleteFiles($container)
Definition: FileBackendTest.php:2630
LockManager\LOCK_SH
const LOCK_SH
Lock types; stronger locks have higher values.
Definition: LockManager.php:68
StatusValue\newGood
static newGood($value=null)
Factory function for good results.
Definition: StatusValue.php:76
FileBackendTest\doTestConcatenate
doTestConcatenate($params, $srcs, $srcsContent, $alreadyExists, $okStatus)
Definition: FileBackendTest.php:946
FileBackendTest\prepare
prepare(array $params)
Definition: FileBackendTest.php:2612
FileBackendTest\provider_testDescribe
static provider_testDescribe()
Definition: FileBackendTest.php:701
wfWikiID
wfWikiID()
Get an ASCII string identifying this wiki This is used as a prefix in memcached keys.
Definition: GlobalFunctions.php:3024
FileBackendTest\assertGoodStatus
assertGoodStatus(StatusValue $status, $msg)
Definition: FileBackendTest.php:2650
FileBackendTest\testGetFileStat
testGetFileStat($path, $content, $alreadyExists)
provider_testGetFileStat FileBackend::getFileStat
Definition: FileBackendTest.php:1061
FileBackendTest\testGetDirectoryList
testGetDirectoryList()
FileBackend::getTopDirectoryList FileBackend::getDirectoryList.
Definition: FileBackendTest.php:2124
as
This document is intended to provide useful advice for parties seeking to redistribute MediaWiki to end users It s targeted particularly at maintainers for Linux since it s been observed that distribution packages of MediaWiki often break We ve consistently had to recommend that users seeking support use official tarballs instead of their distribution s and this often solves whatever problem the user is having It would be nice if this could such as
Definition: distributors.txt:9
FileBackendTest\provider_testSplitStoragePath
static provider_testSplitStoragePath()
Definition: FileBackendTest.php:124
FileBackendTest\provider_testStore
static provider_testStore()
Definition: FileBackendTest.php:268
FileBackendTest\testDoQuickOperations
testDoQuickOperations()
FileBackend::doQuickOperations.
Definition: FileBackendTest.php:849
FileBackend\normalizeStoragePath
static normalizeStoragePath($storagePath)
Normalize a storage path by cleaning up directory separators.
Definition: FileBackend.php:1471
FileBackendTest\provider_testStreamFile
static provider_testStreamFile()
Definition: FileBackendTest.php:1175
FileBackendTest\doTestGetFileStat
doTestGetFileStat($path, $content, $alreadyExists)
Definition: FileBackendTest.php:1073
php
injection txt This is an overview of how MediaWiki makes use of dependency injection The design described here grew from the discussion of RFC T384 The term dependency this means that anything an object needs to operate should be injected from the the object itself should only know narrow no concrete implementation of the logic it relies on The requirement to inject everything typically results in an architecture that based on two main types of and essentially stateless service objects that use other service objects to operate on the value objects As of the beginning MediaWiki is only starting to use the DI approach Much of the code still relies on global state or direct resulting in a highly cyclical dependency which acts as the top level factory for services in MediaWiki which can be used to gain access to default instances of various services MediaWikiServices however also allows new services to be defined and default services to be redefined Services are defined or redefined by providing a callback the instantiator that will return a new instance of the service When it will create an instance of MediaWikiServices and populate it with the services defined in the files listed by thereby bootstrapping the DI framework Per $wgServiceWiringFiles lists includes ServiceWiring php
Definition: injection.txt:35
FileBackendTest\doTestStore
doTestStore($op)
FileBackend::doOperation.
Definition: FileBackendTest.php:230
FileBackendTest\testGetLocalCopy
testGetLocalCopy($source, $content)
provider_testGetLocalCopy FileBackend::getLocalCopy
Definition: FileBackendTest.php:1309
FileBackendTest\testGetLocalCopyAndReference404
testGetLocalCopyAndReference404()
FileBackend::getLocalCopy FileBackend::getLocalReference.
Definition: FileBackendTest.php:1474
FileBackendTest\doTestDescribe
doTestDescribe($op, $withSource, $okStatus)
Definition: FileBackendTest.php:638
FileBackendTest\testDoOperationsPipeline
testDoOperationsPipeline()
FileBackend::doOperations.
Definition: FileBackendTest.php:1769
$content
this hook is for auditing only RecentChangesLinked and Watchlist RecentChangesLinked and Watchlist e g Watchlist removed from all revisions and log entries to which it was applied This gives extensions a chance to take it off their books as the deletion has already been partly carried out by this point or something similar the user will be unable to create the tag set and then return false from the hook function Ensure you consume the ChangeTagAfterDelete hook to carry out custom deletion actions as context called by AbstractContent::getParserOutput May be used to override the normal model specific rendering of page content $content
Definition: hooks.txt:1046
FileBackendTest\testCreate
testCreate($op, $alreadyExists, $okStatus, $newSize)
provider_testCreate FileBackend::doOperation
Definition: FileBackendTest.php:727
MemoryFileBackend
Simulation of a backend storage in memory.
Definition: MemoryFileBackend.php:34
FileBackendTest\testStreamFile
testStreamFile($path, $content, $alreadyExists)
provider_testGetFileStat FileBackend::streamFile
Definition: FileBackendTest.php:1137
FileBackendMultiWrite
Proxy backend that mirrors writes to several internal backends.
Definition: FileBackendMultiWrite.php:44
StatusValue\getErrors
getErrors()
Get the list of errors.
Definition: StatusValue.php:143
FileBackendTest\provider_testGetContentType
static provider_testGetContentType()
Definition: FileBackendTest.php:2471
FileBackendTest\testConcatenate
testConcatenate($op, $srcs, $srcsContent, $alreadyExists, $okStatus)
provider_testConcatenate
Definition: FileBackendTest.php:934
FileBackend\makeContentDisposition
static makeContentDisposition($type, $filename= '')
Build a Content-Disposition header value per RFC 6266.
Definition: FileBackend.php:1540
$status
this hook is for auditing only RecentChangesLinked and Watchlist RecentChangesLinked and Watchlist e g Watchlist removed from all revisions and log entries to which it was applied This gives extensions a chance to take it off their books as the deletion has already been partly carried out by this point or something similar the user will be unable to create the tag set $status
Definition: hooks.txt:1046
MediaWikiTestCase\getNewTempDirectory
getNewTempDirectory()
obtains a new temporary directory
Definition: MediaWikiTestCase.php:450
FileBackendTest\$multiBackend
FileBackendMultiWrite $multiBackend
Definition: FileBackendTest.php:13
FileBackendTest\testPrepareAndClean
testPrepareAndClean($path, $isOK)
provider_testPrepareAndClean FileBackend::prepare FileBackend::clean
Definition: FileBackendTest.php:1550
MediaWikiTestCase\$tmpFiles
array $tmpFiles
Holds the paths of temporary files/directories created through getNewTempFile, and getNewTempDirector...
Definition: MediaWikiTestCase.php:74
FileBackendTest\testDelete
testDelete($op, $withSource, $okStatus)
provider_testDelete FileBackend::doOperation
Definition: FileBackendTest.php:534
FileBackend\splitStoragePath
static splitStoragePath($storagePath)
Split a storage path into a backend name, a container name, and a relative file path.
Definition: FileBackend.php:1448
TestingAccessWrapper\newFromObject
static newFromObject($object)
Return the same object, without access restrictions.
Definition: TestingAccessWrapper.php:24
FileBackendTest\doTestRecursiveClean
doTestRecursiveClean()
FileBackend::clean.
Definition: FileBackendTest.php:1632
FSFileBackend
Class for a file system (FS) based file backend.
Definition: FSFileBackend.php:41
MediaWikiTestCase\setMwGlobals
setMwGlobals($pairs, $value=null)
Definition: MediaWikiTestCase.php:640
FileBackendTest\testGetFileContents
testGetFileContents($source, $content)
provider_testGetFileContents FileBackend::getFileContents FileBackend::getFileContentsMulti ...
Definition: FileBackendTest.php:1237
ScopedLock\release
static release(ScopedLock &$lock=null)
Release a scoped lock and set any errors in the attatched StatusValue object.
Definition: ScopedLock.php:92
FSFile\getPropsFromPath
static getPropsFromPath($path, $ext=true)
Get an associative array containing information about a file in the local filesystem.
Definition: FSFile.php:202
$time
see documentation in includes Linker php for Linker::makeImageLink & $time
Definition: hooks.txt:1749
FileJournal\factory
static factory(array $config, $backend)
Create an appropriate FileJournal object from config.
Definition: FileJournal.php:63
FileBackendTest\testMove
testMove($op)
provider_testMove FileBackend::doOperation
Definition: FileBackendTest.php:412
FileBackendTest\doTestStreamFile
doTestStreamFile($path, $content)
Definition: FileBackendTest.php:1149
FileBackendTest\testDoOperationsFailing
testDoOperationsFailing()
FileBackend::doOperations.
Definition: FileBackendTest.php:1868
FileBackendTest\testParentStoragePath
testParentStoragePath($path, $res)
provider_testParentStoragePath FileBackend::parentStoragePath
Definition: FileBackendTest.php:174
FileBackendTest\provider_testGetFileHttpUrl
static provider_testGetFileHttpUrl()
Definition: FileBackendTest.php:1534
FileBackend\parentStoragePath
static parentStoragePath($storagePath)
Get the parent storage directory of a storage path.
Definition: FileBackend.php:1493
$name
Allows to change the fields on the form that will be generated $name
Definition: hooks.txt:300