Open Monograph Press: tests/classes/monograph/SubmissionFileDAOTest.inc.php Source File

00001 <?php
00002 
00016 import('lib.pkp.tests.DatabaseTestCase');
00017 import('classes.monograph.SubmissionFileDAO');
00018 import('classes.monograph.ArtworkFileDAODelegate');
00019 import('classes.monograph.MonographFile');
00020 import('classes.monograph.ArtworkFile');
00021 import('classes.monograph.MonographDAO');
00022 import('classes.monograph.Genre');
00023 import('classes.monograph.reviewRound.ReviewRound');
00024 import('lib.pkp.classes.db.DBResultRange');
00025 
00026 // Define test ids.
00027 define('SUBMISSION_FILE_DAO_TEST_PRESS_ID', 999);
00028 define('SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID', 9999);
00029 define('SUBMISSION_FILE_DAO_TEST_DOC_GENRE_ID', 1);
00030 define('SUBMISSION_FILE_DAO_TEST_ART_GENRE_ID', 2);
00031 
00032 
00033 // Define a temp file location for testing.
00034 define('TMP_FILES', '/tmp');
00035 
00036 class SubmissionFileDAOTest extends DatabaseTestCase {
00037    private $testFile;
00038 
00039    protected function setUp() {
00040       // Create a test file on the file system.
00041       $this->testFile = tempnam(TMP_FILES, 'SubmissionFile');
00042 
00043       // Register a mock monograph DAO.
00044       $monographDao =& $this->getMock('MonographDAO', array('getMonograph'));
00045       $monograph = new Monograph();
00046       $monograph->setId(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID);
00047       $monograph->setPressId(SUBMISSION_FILE_DAO_TEST_PRESS_ID);
00048       $monographDao->expects($this->any())
00049                    ->method('getMonograph')
00050                    ->will($this->returnValue($monograph));
00051       DAORegistry::registerDAO('MonographDAO', $monographDao);
00052 
00053       // Register a mock genre DAO.
00054       $genreDao =& $this->getMock('GenreDAO', array('getById'));
00055       DAORegistry::registerDAO('GenreDAO', $genreDao);
00056       $genreDao->expects($this->any())
00057                ->method('getById')
00058                ->will($this->returnCallback(array($this, 'getTestGenre')));
00059 
00060       $this->_cleanFiles();
00061    }
00062 
00063    protected function tearDown() {
00064       if (file_exists($this->testFile)) unlink($this->testFile);
00065       $this->_cleanFiles();
00066    }
00067 
00075    public function testSubmissionFileCrud() {
00076       //
00077       // Create test data.
00078       //
00079       // Create two test files, one monograph file one artwork file.
00080       $file1Rev1 = new ArtworkFile();
00081       $file1Rev1->setName('test-artwork', 'en_US');
00082       $file1Rev1->setCaption('test-caption');
00083       $file1Rev1->setFileStage(MONOGRAPH_FILE_PROOF);
00084       $file1Rev1->setSubmissionId(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID);
00085       $file1Rev1->setFileType('image/jpeg');
00086       $file1Rev1->setFileSize(512);
00087       $file1Rev1->setDateUploaded('2011-12-04 00:00:00');
00088       $file1Rev1->setDateModified('2011-12-04 00:00:00');
00089       $file1Rev1->setAssocType(ASSOC_TYPE_REVIEW_ASSIGNMENT);
00090       $file1Rev1->setAssocId(5);
00091 
00092       $file2Rev1 = new MonographFile();
00093       $file2Rev1->setName('test-document', 'en_US');
00094       $file2Rev1->setFileStage(MONOGRAPH_FILE_PROOF);
00095       $file2Rev1->setSubmissionId(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID);
00096       $file2Rev1->setFileType('application/pdf');
00097       $file2Rev1->setFileSize(256);
00098       $file2Rev1->setDateUploaded('2011-12-05 00:00:00');
00099       $file2Rev1->setDateModified('2011-12-05 00:00:00');
00100 
00101 
00102       //
00103       // isInlineable()
00104       //
00105       // Test the isInlineable method.
00106       $submissionFileDao = DAORegistry::getDAO('SubmissionFileDAO'); /* @var $submissionFileDao SubmissionFileDAO */
00107       self::assertFalse($submissionFileDao->isInlineable($file2Rev1));
00108       self::assertTrue($submissionFileDao->isInlineable($file1Rev1));
00109 
00110 
00111       //
00112       // insertObject()
00113       //
00114       // Persist the two test files.
00115       $this->_insertFile($file1Rev1, 'test artwork', SUBMISSION_FILE_DAO_TEST_ART_GENRE_ID);
00116       self::assertType('ArtworkFile', $file1Rev1);
00117       $this->_insertFile($file2Rev1, 'test monograph', SUBMISSION_FILE_DAO_TEST_DOC_GENRE_ID);
00118       self::assertType('MonographFile', $file2Rev1);
00119 
00120       // Persist a second revision of the artwork file but this time with a
00121       // document genre so that it needs to be downcast for insert.
00122       $downcastFile = clone($file1Rev1); /* @var $downcastFile ArtworkFile */
00123       $downcastFile->setRevision(2);
00124       $downcastFile->setDateUploaded('2011-12-05 00:00:00');
00125       $downcastFile->setDateModified('2011-12-05 00:00:00');
00126       $file1Rev2 =& $this->_insertFile($downcastFile, 'test downcast', SUBMISSION_FILE_DAO_TEST_DOC_GENRE_ID);
00127 
00128       // Test whether the target type is correct.
00129       self::assertType('MonographFile', $file1Rev2);
00130       // Test that no data on the target interface has been lost.
00131       $this->_compareFiles($downcastFile, $file1Rev2);
00132 
00133       // Persist a second revision of the monograph file but this time with an
00134       // artwork genre so that it needs to be upcast for insert.
00135       $upcastFile = clone($file2Rev1); /* @var $upcastFile MonographFile */
00136       $upcastFile->setRevision(2);
00137       $file2Rev2 =& $this->_insertFile($upcastFile, 'test upcast', SUBMISSION_FILE_DAO_TEST_ART_GENRE_ID);
00138 
00139       // Test whether the target type is correct.
00140       self::assertType('ArtworkFile', $file2Rev2);
00141       // Test that no data on the target interface has been lost.
00142       $this->_compareFiles($upcastFile, $file2Rev2);
00143       // Make sure that other fields contain default values as
00144       // they are empty on upcast.
00145       self::assertNull($file2Rev2->getCaption());
00146 
00147 
00148       //
00149       // getRevision()
00150       //
00151       // Retrieve the first revision of the artwork file.
00152       self::assertNull($submissionFileDao->getRevision(null, $file1Rev1->getRevision()));
00153       self::assertNull($submissionFileDao->getRevision($file1Rev1->getFileId(), null));
00154       self::assertEquals($file1Rev1, $submissionFileDao->getRevision($file1Rev1->getFileId(), $file1Rev1->getRevision()));
00155       self::assertEquals($file1Rev1, $submissionFileDao->getRevision($file1Rev1->getFileId(), $file1Rev1->getRevision(), $file1Rev1->getFileStage()));
00156       self::assertEquals($file1Rev1, $submissionFileDao->getRevision($file1Rev1->getFileId(), $file1Rev1->getRevision(), $file1Rev1->getFileStage(), SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID));
00157       self::assertNull($submissionFileDao->getRevision($file1Rev1->getFileId(), $file1Rev1->getRevision(), MONOGRAPH_FILE_PROOF+1));
00158       self::assertNull($submissionFileDao->getRevision($file1Rev1->getFileId(), $file1Rev1->getRevision(), null, SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID+1));
00159 
00160 
00161       //
00162       // updateObject()
00163       //
00164       // Update the artwork file.
00165       $file1Rev1->setOriginalFileName('updated-file-name');
00166       $file1Rev1->setCaption('test-caption');
00167       $updatedFile =& $submissionFileDao->updateObject($file1Rev1);
00168 
00169       // Now change the genre so that the canonical file name
00170       // and the file implementation will have to change.
00171       $previousFilePath = $file1Rev1->getFilePath();
00172       $file1Rev1->setGenreId(SUBMISSION_FILE_DAO_TEST_DOC_GENRE_ID);
00173       $updatedFile =& $submissionFileDao->updateObject($file1Rev1);
00174 
00175       // Test whether the target type is correct.
00176       self::assertType('MonographFile', $updatedFile);
00177       // Test that no data on the target interface has been lost.
00178       $this->_compareFiles($file1Rev1, $updatedFile);
00179 
00180       // Test the new file path and files.
00181       $newFilePath = $updatedFile->getFilePath();
00182       self::assertNotEquals($previousFilePath, $newFilePath);
00183       self::assertFileNotExists($previousFilePath);
00184       self::assertFileExists($newFilePath);
00185 
00186       // Now change the genre back so that we can test casting
00187       // in the other direction.
00188       $updatedFile->setGenreId(SUBMISSION_FILE_DAO_TEST_ART_GENRE_ID);
00189       $updatedFile =& $submissionFileDao->updateObject($updatedFile);
00190 
00191       // Test whether the target type is correct.
00192       self::assertType('ArtworkFile', $updatedFile);
00193       // Test that no data on the target interface has been lost.
00194       $this->_compareFiles($file1Rev1, $updatedFile);
00195       // Make sure that other fields contain default values as
00196       // they are lost on double recast.
00197       self::assertNull($updatedFile->getCaption());
00198       $file1Rev1 = $updatedFile;
00199 
00200 
00201       //
00202       // getLatestRevision()
00203       //
00204       // Retrieve the latest revision of file 1.
00205       self::assertNull($submissionFileDao->getLatestRevision(null));
00206       self::assertEquals($file1Rev2, $submissionFileDao->getLatestRevision($file1Rev1->getFileId()));
00207       self::assertEquals($file1Rev2, $submissionFileDao->getLatestRevision($file1Rev1->getFileId(), $file1Rev1->getFileStage()));
00208       self::assertEquals($file1Rev2, $submissionFileDao->getLatestRevision($file1Rev1->getFileId(), $file1Rev1->getFileStage(), SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID));
00209       self::assertNull($submissionFileDao->getLatestRevision($file1Rev1->getFileId(), MONOGRAPH_FILE_PROOF+1));
00210       self::assertNull($submissionFileDao->getLatestRevision($file1Rev1->getFileId(), null, SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID+1));
00211 
00212 
00213       //
00214       // getLatestRevisions()
00215       //
00216       // Calculate the unique ids of the test files.
00217       $uniqueId1_1 = $file1Rev1->getFileIdAndRevision();
00218       $uniqueId1_2 = $file1Rev2->getFileIdAndRevision();
00219       $uniqueId2_1 = $file2Rev1->getFileIdAndRevision();
00220       $uniqueId2_2 = $file2Rev2->getFileIdAndRevision();
00221 
00222       // Retrieve the latest revisions of both files.
00223       self::assertNull($submissionFileDao->getLatestRevisions(null));
00224       self::assertEquals(array($uniqueId1_2 => $file1Rev2, $uniqueId2_2 => $file2Rev2),
00225             $submissionFileDao->getLatestRevisions(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID));
00226       self::assertEquals(array($uniqueId1_2 => $file1Rev2, $uniqueId2_2 => $file2Rev2),
00227             $submissionFileDao->getLatestRevisions(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID, MONOGRAPH_FILE_PROOF));
00228       self::assertEquals(array(),
00229             $submissionFileDao->getLatestRevisions(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID+1));
00230       self::assertEquals(array(),
00231             $submissionFileDao->getLatestRevisions(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID, MONOGRAPH_FILE_PROOF+1));
00232 
00233       // Test paging.
00234       $rangeInfo = new DBResultRange(2, 1);
00235       self::assertEquals(array($uniqueId1_2 => $file1Rev2, $uniqueId2_2 => $file2Rev2),
00236             $submissionFileDao->getLatestRevisions(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID, null, $rangeInfo));
00237       $rangeInfo = new DBResultRange(1, 1);
00238       self::assertEquals(array($uniqueId1_2 => $file1Rev2),
00239             $submissionFileDao->getLatestRevisions(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID, null, $rangeInfo));
00240       $rangeInfo = new DBResultRange(1, 2);
00241       self::assertEquals(array($uniqueId2_2 => $file2Rev2),
00242             $submissionFileDao->getLatestRevisions(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID, null, $rangeInfo));
00243 
00244 
00245       //
00246       // getAllRevisions()
00247       //
00248       // Retrieve all revisions of file 1.
00249       self::assertNull($submissionFileDao->getAllRevisions(null));
00250       self::assertEquals(array($uniqueId1_2 => $file1Rev2, $uniqueId1_1 => $file1Rev1),
00251             $submissionFileDao->getAllRevisions($file1Rev1->getFileId(), MONOGRAPH_FILE_PROOF));
00252       self::assertEquals(array($uniqueId1_2 => $file1Rev2, $uniqueId1_1 => $file1Rev1),
00253             $submissionFileDao->getAllRevisions($file1Rev1->getFileId(), MONOGRAPH_FILE_PROOF, SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID));
00254       self::assertEquals(array(),
00255             $submissionFileDao->getAllRevisions($file1Rev1->getFileId(), null, SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID+1));
00256       self::assertEquals(array(),
00257             $submissionFileDao->getAllRevisions($file1Rev1->getFileId(), MONOGRAPH_FILE_PROOF+1, null));
00258 
00259 
00260       //
00261       // getLatestRevisionsByAssocId()
00262       //
00263       // Retrieve the latest revisions by association.
00264       self::assertNull($submissionFileDao->getLatestRevisionsByAssocId(ASSOC_TYPE_REVIEW_ASSIGNMENT, null));
00265       self::assertNull($submissionFileDao->getLatestRevisionsByAssocId(null, 5));
00266       self::assertEquals(array($uniqueId1_2 => $file1Rev2),
00267             $submissionFileDao->getLatestRevisionsByAssocId(ASSOC_TYPE_REVIEW_ASSIGNMENT, 5));
00268       self::assertEquals(array($uniqueId1_2 => $file1Rev2),
00269             $submissionFileDao->getLatestRevisionsByAssocId(ASSOC_TYPE_REVIEW_ASSIGNMENT, 5, MONOGRAPH_FILE_PROOF));
00270       self::assertEquals(array(),
00271             $submissionFileDao->getLatestRevisionsByAssocId(ASSOC_TYPE_REVIEW_ASSIGNMENT, 5, MONOGRAPH_FILE_PROOF+1));
00272 
00273       // Retrieve all revisions by association.
00274       self::assertNull($submissionFileDao->getAllRevisionsByAssocId(ASSOC_TYPE_REVIEW_ASSIGNMENT, null));
00275       self::assertNull($submissionFileDao->getAllRevisionsByAssocId(null, 5));
00276       self::assertEquals(array($uniqueId1_2 => $file1Rev2, $uniqueId1_1 => $file1Rev1),
00277             $submissionFileDao->getAllRevisionsByAssocId(ASSOC_TYPE_REVIEW_ASSIGNMENT, 5));
00278       self::assertEquals(array($uniqueId1_2 => $file1Rev2, $uniqueId1_1 => $file1Rev1),
00279             $submissionFileDao->getAllRevisionsByAssocId(ASSOC_TYPE_REVIEW_ASSIGNMENT, 5, MONOGRAPH_FILE_PROOF));
00280       self::assertEquals(array(), $submissionFileDao->getAllRevisionsByAssocId(ASSOC_TYPE_REVIEW_ASSIGNMENT, 5, MONOGRAPH_FILE_PROOF+1));
00281 
00282 
00283       //
00284       // assignRevisionToReviewRound()
00285       //
00286       // Insert one more revision to test review round file assignments.
00287       $file1Rev3 = clone($file1Rev2);
00288       $file1Rev3->setRevision(3);
00289       self::assertEquals($file1Rev3, $submissionFileDao->insertObject($file1Rev3, $this->testFile));
00290       $uniqueId1_3 = $file1Rev3->getFileIdAndRevision();
00291 
00292       // Insert review round file assignments.
00293       $submissionFileDao->assignRevisionToReviewRound($file1Rev1->getFileId(), $file1Rev1->getRevision(),
00294             WORKFLOW_STAGE_ID_INTERNAL_REVIEW, 1, SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID);
00295       $submissionFileDao->assignRevisionToReviewRound($file2Rev2->getFileId(), $file2Rev2->getRevision(),
00296             WORKFLOW_STAGE_ID_INTERNAL_REVIEW, 1, SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID);
00297 
00298 
00299       //
00300       // getRevisionsByReviewRound()
00301       //
00302       // Retrieve assigned review round files by review stage id and round.
00303       self::assertEquals(array($uniqueId1_1 => $file1Rev1, $uniqueId2_2 => $file2Rev2),
00304             $submissionFileDao->getRevisionsByReviewRound(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID, WORKFLOW_STAGE_ID_INTERNAL_REVIEW, 1));
00305       self::assertNull($submissionFileDao->getRevisionsByReviewRound(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID, null, null));
00306 
00307 
00308       //
00309       // getLatestNewRevisionsByReviewRound()
00310       //
00311       // Retrieve revisions of review round files that are newer than the review round files themselves.
00312       self::assertEquals(array($uniqueId1_3 => $file1Rev3),
00313             $submissionFileDao->getLatestNewRevisionsByReviewRound(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID, WORKFLOW_STAGE_ID_INTERNAL_REVIEW, 1));
00314       self::assertNull($submissionFileDao->getLatestNewRevisionsByReviewRound(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID, null, null));
00315 
00316 
00317       //
00318       // deleteAllRevisionsByReviewRound()
00319       //
00320       $submissionFileDao->deleteAllRevisionsByReviewRound(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID, WORKFLOW_STAGE_ID_INTERNAL_REVIEW, 1);
00321       self::assertEquals(array(),
00322             $submissionFileDao->getRevisionsByReviewRound(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID, WORKFLOW_STAGE_ID_INTERNAL_REVIEW, 1));
00323 
00324 
00325       //
00326       // deleteRevision() and deleteRevisionById()
00327       //
00328       // Delete the first revision of file1.
00329       // NB: This implicitly tests deletion by ID.
00330       self::assertEquals(1, $submissionFileDao->deleteRevision($file1Rev1));
00331       self::assertNull($submissionFileDao->getRevision($file1Rev1->getFileId(), $file1Rev1->getRevision()));
00332       // Re-insert the file for the next test.
00333       self::assertEquals($file1Rev1, $submissionFileDao->insertObject($file1Rev1, $this->testFile));
00334 
00335 
00336       //
00337       // deleteLatestRevisionById()
00338       //
00339       // Delete the latest revision of file1.
00340       self::assertEquals(1, $submissionFileDao->deleteLatestRevisionById($file1Rev1->getFileId()));
00341       self::assertType('ArtworkFile', $submissionFileDao->getRevision($file1Rev1->getFileId(), $file1Rev1->getRevision()));
00342       self::assertNull($submissionFileDao->getRevision($file1Rev3->getFileId(), $file1Rev3->getRevision()));
00343 
00344 
00345       //
00346       // deleteAllRevisionsById()
00347       //
00348       // Delete all revisions of file1.
00349       self::assertEquals(2, $submissionFileDao->deleteAllRevisionsById($file1Rev1->getFileId()));
00350       self::assertType('MonographFile', $submissionFileDao->getRevision($file2Rev1->getFileId(), $file2Rev1->getRevision()));
00351       self::assertNull($submissionFileDao->getRevision($file1Rev1->getFileId(), $file1Rev1->getRevision()));
00352       self::assertNull($submissionFileDao->getRevision($file1Rev2->getFileId(), $file1Rev2->getRevision()));
00353       // Re-insert the files for the next test.
00354       self::assertEquals($file1Rev1, $submissionFileDao->insertObject($file1Rev1, $this->testFile));
00355       self::assertEquals($file1Rev2, $submissionFileDao->insertObject($file1Rev2, $this->testFile));
00356 
00357 
00358       //
00359       // deleteAllRevisionsByAssocId()
00360       //
00361       // Delete all revisions by assoc id.
00362       self::assertEquals(2, $submissionFileDao->deleteAllRevisionsByAssocId(ASSOC_TYPE_REVIEW_ASSIGNMENT, 5));
00363       self::assertType('MonographFile', $submissionFileDao->getRevision($file2Rev1->getFileId(), $file2Rev1->getRevision()));
00364       self::assertNull($submissionFileDao->getRevision($file1Rev1->getFileId(), $file1Rev1->getRevision()));
00365       self::assertNull($submissionFileDao->getRevision($file1Rev2->getFileId(), $file1Rev2->getRevision()));
00366       // Re-insert the files for the next test.
00367       self::assertEquals($file1Rev1, $submissionFileDao->insertObject($file1Rev1, $this->testFile));
00368       self::assertEquals($file1Rev2, $submissionFileDao->insertObject($file1Rev2, $this->testFile));
00369 
00370 
00371       //
00372       // deleteAllRevisionsBySubmissionId()
00373       //
00374       // Delete all revisions by submission id.
00375       self::assertEquals(4, $submissionFileDao->deleteAllRevisionsBySubmissionId(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID));
00376       self::assertNull($submissionFileDao->getRevision($file2Rev1->getFileId(), $file2Rev1->getRevision()));
00377       self::assertNull($submissionFileDao->getRevision($file1Rev1->getFileId(), $file1Rev1->getRevision()));
00378       self::assertNull($submissionFileDao->getRevision($file1Rev2->getFileId(), $file1Rev2->getRevision()));
00379 
00380 
00381       //
00382       // insertObject() for new revisions
00383       //
00384       // Test insertion of new revisions.
00385       // Create two files with different file ids.
00386       $file1Rev1->setFileId(null);
00387       $file1Rev1->setRevision(null);
00388       $file1Rev1 =& $submissionFileDao->insertObject($file1Rev1, $this->testFile);
00389       $file1Rev2->setFileId(null);
00390       $file1Rev2->setRevision(null);
00391       $file1Rev2->setGenreId(SUBMISSION_FILE_DAO_TEST_DOC_GENRE_ID);
00392       $file1Rev2 =& $submissionFileDao->insertObject($file1Rev2, $this->testFile);
00393 
00394       // Test the file ids, revisions and identifying fields.
00395       self::assertNotEquals($file1Rev1->getFileId(), $file1Rev2->getFileId());
00396       self::assertNotEquals($file1Rev1->getGenreId(), $file1Rev2->getGenreId());
00397       self::assertEquals(1, $submissionFileDao->getLatestRevisionNumber($file1Rev1->getFileId()));
00398       self::assertEquals(1, $submissionFileDao->getLatestRevisionNumber($file1Rev2->getFileId()));
00399 
00400 
00401       //
00402       // setAsLatestRevision()
00403       //
00404       // Now make the second file a revision of the first.
00405       $file1Rev2 =& $submissionFileDao->setAsLatestRevision($file1Rev1->getFileId(), $file1Rev2->getFileId(),
00406             $file1Rev1->getSubmissionId(), $file1Rev1->getFileStage());
00407 
00408       // And test the file ids, revisions, identifying fields and types again.
00409       self::assertEquals($file1Rev1->getFileId(), $file1Rev2->getFileId());
00410       self::assertEquals($file1Rev1->getGenreId(), $file1Rev2->getGenreId());
00411       self::assertEquals(1, $file1Rev1->getRevision());
00412       self::assertEquals(2, $submissionFileDao->getLatestRevisionNumber($file1Rev1->getFileId()));
00413       $submissionFiles =& $submissionFileDao->getAllRevisions($file1Rev1->getFileId());
00414       self::assertEquals(2, count($submissionFiles));
00415       foreach($submissionFiles as $submissionFile) { /* @var $submissionFile SubmissionFile */
00416          self::assertType('ArtworkFile', $submissionFile);
00417       }
00418    }
00419 
00420    function testNewDataObjectByGenreId() {
00421       // Instantiate the SUT.
00422       $submissionFileDao = DAORegistry::getDAO('SubmissionFileDAO'); /* @var $submissionFileDao SubmissionFileDAO */
00423 
00424       // Test whether the newDataObjectByGenreId method will return a monograph file.
00425       $fileObject =& $submissionFileDao->newDataObjectByGenreId(SUBMISSION_FILE_DAO_TEST_DOC_GENRE_ID);
00426       self::assertType('MonographFile', $fileObject);
00427 
00428       // Now set an artwork genre and try again.
00429       $fileObject =& $submissionFileDao->newDataObjectByGenreId(SUBMISSION_FILE_DAO_TEST_ART_GENRE_ID);
00430       self::assertType('ArtworkFile', $fileObject);
00431    }
00432 
00433 
00434    //
00435    // Public helper methods
00436    //
00442    public function getTestGenre($genreId) {
00443       // Create a test genre.
00444       switch($genreId) {
00445          case SUBMISSION_FILE_DAO_TEST_DOC_GENRE_ID:
00446             $category = GENRE_CATEGORY_DOCUMENT;
00447             $name = 'Document Genre';
00448             $designation = 'D';
00449             break;
00450 
00451          case SUBMISSION_FILE_DAO_TEST_ART_GENRE_ID:
00452             $category = GENRE_CATEGORY_ARTWORK;
00453             $name = 'Artwork Genre';
00454             $designation = 'A';
00455             break;
00456 
00457          default:
00458             self::fail();
00459       }
00460       $genre = new Genre();
00461       $press =& Request::getPress();
00462       $genre->setPressId($press->getId());
00463       $genre->setId($genreId);
00464       $genre->setName($name, 'en_US');
00465       $genre->setDesignation($designation, 'en_US');
00466       $genre->setCategory($category);
00467       return $genre;
00468    }
00469 
00470 
00471    //
00472    // Private helper methods
00473    //
00481    function _compareFiles($sourceFile, $targetFile) {
00482       self::assertEquals($sourceFile->getName('en_US'), $targetFile->getName('en_US'));
00483       self::assertEquals($sourceFile->getFileStage(), $targetFile->getFileStage());
00484       self::assertEquals($sourceFile->getSubmissionId(), $targetFile->getSubmissionId());
00485       self::assertEquals($sourceFile->getFileType(), $targetFile->getFileType());
00486       self::assertEquals($sourceFile->getFileSize(), $targetFile->getFileSize());
00487       self::assertEquals($sourceFile->getDateUploaded(), $targetFile->getDateUploaded());
00488       self::assertEquals($sourceFile->getDateModified(), $targetFile->getDateModified());
00489       self::assertEquals($sourceFile->getAssocType(), $targetFile->getAssocType());
00490       self::assertEquals($sourceFile->getAssocId(), $targetFile->getAssocId());
00491    }
00492 
00500    private function _insertFile($file, $testContent, $genreId) {
00501       // Prepare the test.
00502       file_put_contents($this->testFile, $testContent);
00503       $file->setGenreId($genreId);
00504 
00505       // Insert the file.
00506       $submissionFileDao = DAORegistry::getDAO('SubmissionFileDAO'); /* @var $submissionFileDao SubmissionFileDAO */
00507       $file =& $submissionFileDao->insertObject($file, $this->testFile);
00508 
00509       // Test the outcome.
00510       self::assertFileExists($file->getFilePath());
00511       self::assertEquals($testContent, file_get_contents($file->getFilePath()));
00512 
00513       return $file;
00514    }
00515 
00519    private function _cleanFiles() {
00520       // Delete the test submission's files.
00521       $submissionFileDao = DAORegistry::getDAO('SubmissionFileDAO'); /* @var $submissionFileDao SubmissionFileDAO */
00522       $submissionFileDao->deleteAllRevisionsBySubmissionId(SUBMISSION_FILE_DAO_TEST_SUBMISSION_ID);
00523    }
00524 }
00525 ?>