546 lines
16 KiB
Java
Executable File
546 lines
16 KiB
Java
Executable File
/*
|
|
* Copyright (C) 2001, 2002 Red Hat Inc. All Rights Reserved.
|
|
*
|
|
* The contents of this file are subject to the CCM Public
|
|
* License (the "License"); you may not use this file except in
|
|
* compliance with the License. You may obtain a copy of
|
|
* the License at http://www.redhat.com/licenses/ccmpl.html
|
|
*
|
|
* Software distributed under the License is distributed on an "AS
|
|
* IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
|
|
* implied. See the License for the specific language governing
|
|
* rights and limitations under the License.
|
|
*
|
|
*/
|
|
|
|
package com.arsdigita.docmgr;
|
|
|
|
import com.arsdigita.domain.DataObjectNotFoundException;
|
|
import com.arsdigita.domain.DomainObjectFactory;
|
|
import com.arsdigita.mail.ByteArrayDataSource;
|
|
import com.arsdigita.persistence.OID;
|
|
import com.arsdigita.tools.junit.framework.BaseTestCase;
|
|
import com.arsdigita.versioning.TransactionCollection;
|
|
|
|
import javax.activation.DataHandler;
|
|
import java.math.BigDecimal;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.Map;
|
|
|
|
/**
|
|
* Test cases for files.
|
|
*
|
|
* @author ron@arsdigita.com
|
|
* @author stefan@arsdigita.com
|
|
* @version $Id: //apps/docmgr/dev/test/src/com/arsdigita/docmgr/FileTest.java#4 $
|
|
*/
|
|
|
|
public class FileTest extends BaseTestCase {
|
|
|
|
private Folder m_parent;
|
|
|
|
final static String TEST_IMAGE =
|
|
System.getProperty("test.base.dir") + "/com/arsdigita/docmgr/file.gif";
|
|
final static String TEST_FILE =
|
|
System.getProperty("test.base.dir") + "/com/arsdigita/docmgr/file.html";
|
|
final static String TEST_FILE_NOEXT =
|
|
System.getProperty("test.base.dir") + "/com/arsdigita/docmgr/file";
|
|
|
|
private static final org.apache.log4j.Logger s_log =
|
|
org.apache.log4j.Logger.getLogger(FileTest.class);
|
|
|
|
public FileTest(String name) {
|
|
super(name);
|
|
}
|
|
|
|
/**
|
|
* Create a parent folder to store files in.
|
|
*/
|
|
|
|
protected void setUp() throws Exception {
|
|
super.setUp();
|
|
String name = "file-test-folder";
|
|
String desc = null;
|
|
|
|
m_parent = new Folder(name,desc);
|
|
m_parent.save();
|
|
|
|
s_log.error("Starting test " + getName());
|
|
}
|
|
|
|
|
|
protected void tearDown() throws Exception {
|
|
s_log.error("Ending test " + getName());
|
|
super.tearDown();
|
|
}
|
|
|
|
/**
|
|
* Create a File.
|
|
*/
|
|
public void testFileCreate001() throws Exception {
|
|
String name = "f001";
|
|
String desc = "f001 description";
|
|
|
|
File f = new File(name,desc,m_parent);
|
|
f.save();
|
|
assertEquals(f.getName(), name);
|
|
assertEquals(f.getDescription(), desc);
|
|
}
|
|
|
|
/**
|
|
* Create a File and use it to store an HTML document. This is
|
|
* the common operation used when transferring an uploaded file
|
|
* into the document manager.
|
|
*/
|
|
|
|
public void testFileCreate002() throws Exception {
|
|
String name = "f002";
|
|
String desc = "f002 description";
|
|
|
|
java.io.File src = new java.io.File(TEST_FILE);
|
|
|
|
File f1 = null;
|
|
f1 = new File(m_parent);
|
|
f1.setContent(src,name,desc);
|
|
f1.save();
|
|
|
|
assertEquals(f1.getName(), name);
|
|
assertEquals(f1.getDescription(), desc);
|
|
assertEquals(f1.getContentType(), "text/html");
|
|
|
|
File f2 = null;
|
|
f2 = new File(f1.getID());
|
|
|
|
assertEquals(f1.getName(), f2.getName());
|
|
assertEquals(f1.getDescription(), f2.getDescription());
|
|
assertEquals(f1.getContentType(), f2.getContentType());
|
|
assertEquals(f1.getSize(), f2.getSize());
|
|
assertNotNull(f1.getRawContent());
|
|
assertNotNull(f2.getRawContent());
|
|
assertEquals(new String(f1.getRawContent()),
|
|
new String(f2.getRawContent()));
|
|
}
|
|
|
|
/**
|
|
* Create a File and use it to store an image.
|
|
*/
|
|
|
|
public void testFileCreate003() throws Exception {
|
|
String name = "f003";
|
|
String desc = "f003 description";
|
|
|
|
java.io.File src = new java.io.File(TEST_IMAGE);
|
|
|
|
File f1 = null;
|
|
f1 = new File(m_parent);
|
|
f1.setContent(src,name,desc);
|
|
f1.save();
|
|
|
|
assertEquals(f1.getName(), name);
|
|
assertEquals(f1.getDescription(), desc);
|
|
assertEquals(f1.getContentType(), "image/gif");
|
|
|
|
File f2 = null;
|
|
f2 = new File(f1.getID());
|
|
|
|
assertEquals(f1.getName(), f2.getName());
|
|
assertEquals(f1.getDescription(), f2.getDescription());
|
|
assertEquals(f1.getContentType(), f2.getContentType());
|
|
}
|
|
|
|
/**
|
|
* Create a File and use it to store data encapsulated by a
|
|
* DataHandler. This is the method typically used to transfer
|
|
* content from an email attachment into the document manager.
|
|
*/
|
|
|
|
public void testFileCreate004() throws Exception {
|
|
String name = "f004.txt";
|
|
String desc = "f004 description";
|
|
String type = "text/plain";
|
|
String text = "hello, world";
|
|
|
|
// Store a plain text "document" in the File
|
|
DataHandler dh = new DataHandler
|
|
(new ByteArrayDataSource(text, type, name));
|
|
|
|
File f1 = null;
|
|
f1 = new File(m_parent);
|
|
f1.setDataHandler(dh);
|
|
f1.setDescription(desc);
|
|
f1.save();
|
|
|
|
assertEquals(name, f1.getName());
|
|
assertEquals(desc, f1.getDescription());
|
|
assertEquals(type, f1.getContentType());
|
|
assertEquals(text, new String(f1.getRawContent()));
|
|
|
|
File f2 = null;
|
|
f2 = new File(f1.getID());
|
|
|
|
assertEquals(name, f2.getName());
|
|
assertEquals(desc, f2.getDescription());
|
|
assertEquals(type, f2.getContentType());
|
|
assertEquals(text, new String(f2.getRawContent()));
|
|
}
|
|
|
|
/**
|
|
* Verify that a file can be moved from one folder to another.
|
|
*/
|
|
|
|
public void testFileMove() throws Exception {
|
|
Folder root = FolderTest.buildFolderTree();
|
|
|
|
Folder f0 = null;
|
|
Folder f1 = null;
|
|
|
|
f0 = root.retrieveFolder("f0");
|
|
f1 = root.retrieveFolder("f1");
|
|
|
|
String name = "file";
|
|
String desc = "file description";
|
|
File file = null;
|
|
|
|
file = new File(name,desc,f0);
|
|
file.save();
|
|
|
|
assertEquals(file.getID(), f0.getResourceID(name));
|
|
|
|
// Move the file from f0 to f1
|
|
|
|
file.setParent(f1);
|
|
file.save();
|
|
|
|
// Verify the file no longer exists in old location
|
|
|
|
try {
|
|
f0.getResourceID(name);
|
|
fail("Retrieved file from old location");
|
|
} catch (DataObjectNotFoundException ex) {
|
|
// correct
|
|
}
|
|
|
|
// Retrieve the file from the new location
|
|
|
|
BigDecimal id = new BigDecimal(-1);
|
|
id = f1.getResourceID(name);
|
|
|
|
|
|
assertEquals(file.getID(), id);
|
|
assertEquals(file.getPath(), f1.getPath() + Resource.SEPARATOR + name);
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
* Verify that a file can be copied.
|
|
*/
|
|
|
|
public void testFileCopy() throws Exception {
|
|
String name = "file";
|
|
String desc = "file desc";
|
|
|
|
java.io.File src = new java.io.File(TEST_FILE);
|
|
|
|
File orig = new File(m_parent);
|
|
orig.setContent(src,name,desc);
|
|
orig.save();
|
|
|
|
File copy = null;
|
|
copy = (File) orig.copyTo(name + "-copy");
|
|
|
|
assertEquals(orig.getDescription(), copy.getDescription());
|
|
assertEquals(orig.getContentType(), copy.getContentType());
|
|
|
|
|
|
}
|
|
|
|
/**
|
|
* Test factory method for instantiating files.
|
|
*/
|
|
|
|
public void testFileFactory() throws Exception {
|
|
|
|
String name = "file";
|
|
String desc = "file desc";
|
|
|
|
java.io.File src = new java.io.File(TEST_FILE);
|
|
|
|
File f0 = new File(m_parent);
|
|
f0.setContent(src,name,desc);
|
|
f0.save();
|
|
|
|
OID oid = new OID(File.BASE_DATA_OBJECT_TYPE,
|
|
f0.getID());
|
|
File f1 = (File) DomainObjectFactory.newInstance(oid);
|
|
|
|
assertEquals(f0.getID(), f1.getID());
|
|
assertEquals(f0.getName(), f1.getName());
|
|
assertEquals(f0.getDescription(), f1.getDescription());
|
|
assertEquals(f0.getContentType(), f1.getContentType());
|
|
}
|
|
|
|
/**
|
|
* Test basic revision history.
|
|
*/
|
|
|
|
public void testFileRevisions() throws Exception {
|
|
|
|
String name = "file";
|
|
String desc = "file-description";
|
|
File file = new File(name,desc,m_parent);
|
|
|
|
// Save several revisions of this file
|
|
int numRevisions = 10;
|
|
|
|
// Store the content and symbolic revision tags in arrays so
|
|
// we can use them below.
|
|
|
|
String content[] = new String[numRevisions];
|
|
String tag[] = new String[numRevisions];
|
|
|
|
for (int i = 0; i < numRevisions; i++) {
|
|
content[i] = "file-content-" + i;
|
|
file.setText(content[i]);
|
|
file.save();
|
|
|
|
// Apply a tag to the last transaction
|
|
tag[i] = file.applyUniqueTag(String.valueOf(i) + "-");
|
|
}
|
|
|
|
// Revert each transaction back to the original and verify
|
|
// that the content is correctly recovered.
|
|
|
|
TransactionCollection tc = file.getTransactions();
|
|
assertEquals(numRevisions, tc.size());
|
|
|
|
for (int i = numRevisions-1; i >= 0; i--) {
|
|
assertTrue(tc.next());
|
|
file.rollBackTo(tc.getTransaction());
|
|
assertEquals(content[i], new String(file.getRawContent()));
|
|
file.save();
|
|
}
|
|
|
|
// Rollback to an intermediate revision
|
|
int targetRevision = 5;
|
|
file = new File(file.getID());
|
|
file.rollBackTo(tag[targetRevision]);
|
|
assertEquals(content[targetRevision],
|
|
new String(file.getRawContent()));
|
|
}
|
|
|
|
public void testFileDisplayName() throws Exception {
|
|
|
|
// Create a hash map with file name as a key mapping to
|
|
// expected value
|
|
|
|
HashMap fileNames = new HashMap();
|
|
fileNames.put("f001.txt", "f001");
|
|
fileNames.put("file.html", "file");
|
|
fileNames.put("file.htm", "file");
|
|
fileNames.put("file name", "file name");
|
|
fileNames.put(".file", ".file");
|
|
fileNames.put("file name.doc", "file name");
|
|
fileNames.put(".a.b.c", ".a.b.c");
|
|
fileNames.put("file a.b.c", "file a.b");
|
|
fileNames.put("a.b.c", "a.b");
|
|
|
|
File file = new File(m_parent);
|
|
|
|
Iterator iter = fileNames.entrySet().iterator();
|
|
while (iter.hasNext()) {
|
|
Map.Entry entry = (Map.Entry) iter.next();
|
|
String name = (String) entry.getKey();
|
|
String displayName = (String) entry.getValue();
|
|
|
|
file.setName(name);
|
|
assertEquals(displayName, file.getDisplayName());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that file MIME types cannot be changed once the file is
|
|
* persistent.
|
|
*/
|
|
|
|
public void testFileTypeChange() throws Exception {
|
|
|
|
String name = "file.html";
|
|
String desc = "file desc";
|
|
|
|
java.io.File src = new java.io.File(TEST_FILE);
|
|
|
|
File file = new File(m_parent);
|
|
file.setContent(src,name,desc);
|
|
file.save();
|
|
|
|
assertEquals("text/html", file.getContentType());
|
|
|
|
// Update properties of the file and verify that changes can
|
|
// be saved.
|
|
|
|
file.setName("a new name");
|
|
file.setDescription("a new description");
|
|
file.save();
|
|
|
|
// Try setting the content to a different MIME type and saving
|
|
// the file.
|
|
|
|
try {
|
|
src = new java.io.File(TEST_IMAGE);
|
|
name = "file.gif";
|
|
file.setContent(src,name,desc);
|
|
file.save();
|
|
fail("Changed MIME type of existing file");
|
|
} catch (TypeChangeException ex) {
|
|
// correct
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Create an HTML file for testing. The file is initialized but
|
|
* not saved.
|
|
*/
|
|
|
|
private File createTestFile() throws Exception {
|
|
|
|
String name = "file.html";
|
|
String desc = "file desc";
|
|
|
|
java.io.File src = new java.io.File(TEST_FILE);
|
|
|
|
File file = new File(m_parent);
|
|
file.setContent(src,name,desc);
|
|
file.initializeContentType(null);
|
|
return file;
|
|
}
|
|
|
|
/**
|
|
* Verify the behavior of rules governing file names and changes
|
|
* to file names.
|
|
*/
|
|
|
|
public void testFileNameRules() throws Exception {
|
|
|
|
File file = createTestFile();
|
|
file.save();
|
|
|
|
HashMap fileExtensions = new HashMap();
|
|
fileExtensions.put("file", "file.html");
|
|
fileExtensions.put("file.html", "file.html");
|
|
fileExtensions.put("file.txt", "file.txt");
|
|
|
|
// Test the appendExtension utility to verify that it
|
|
// correctly constructs file names with inherited extensions.
|
|
|
|
Iterator iter = fileExtensions.entrySet().iterator();
|
|
while (iter.hasNext()) {
|
|
Map.Entry entry = (Map.Entry) iter.next();
|
|
String name = (String) entry.getKey();
|
|
String expected = (String) entry.getValue();
|
|
|
|
assertEquals("Failed generating extension for " + name,
|
|
expected,
|
|
file.appendExtension(name));
|
|
}
|
|
|
|
// Verify the set of file names that are valid for renaming
|
|
// our test file.
|
|
|
|
HashMap fileNames = new HashMap();
|
|
fileNames.put("f001.txt", Boolean.FALSE);
|
|
fileNames.put("f001.htm", Boolean.TRUE);
|
|
fileNames.put("f001", Boolean.TRUE);
|
|
fileNames.put("f001 bar", Boolean.TRUE);
|
|
fileNames.put("foo bar .htm", Boolean.TRUE);
|
|
|
|
iter = fileNames.entrySet().iterator();
|
|
while (iter.hasNext()) {
|
|
Map.Entry entry = (Map.Entry) iter.next();
|
|
String name = (String) entry.getKey();
|
|
Boolean isValid = (Boolean) entry.getValue();
|
|
|
|
assertEquals("Failed testing the validity of " + name,
|
|
isValid.booleanValue(),
|
|
file.isValidNewName(name));
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Test the correct initialize of MIME type from an HTTP request
|
|
* with and without an explicit content type header.
|
|
*/
|
|
public void testFileUpload() throws Exception {
|
|
|
|
String name = "file";
|
|
String desc = "file desc";
|
|
|
|
TestServletRequest request = new TestServletRequest();
|
|
request.setContentType("text/html");
|
|
|
|
java.io.File src = new java.io.File(TEST_FILE);
|
|
|
|
File file = new File(m_parent);
|
|
file.setContent(src,name,desc);
|
|
|
|
file.initializeContentType(request);
|
|
|
|
file.save();
|
|
assertEquals("Failed to set the content type from the request",
|
|
"text/html",
|
|
file.getContentType());
|
|
|
|
// Verify that we can't reset the content type after the file
|
|
// has been saved
|
|
|
|
try {
|
|
file.initializeContentType(request);
|
|
fail("Re-initialized content type");
|
|
} catch (ContentTypeException ex) {
|
|
// correct
|
|
}
|
|
|
|
// Verify that the content type is initialized correctly from
|
|
// the file extension if no content type can be determined
|
|
// from the request. Two cases: no request, and no content
|
|
// type header
|
|
|
|
request.setContentType(null);
|
|
file = new File(m_parent);
|
|
file.setContent(src,name + ".html", desc);
|
|
|
|
file.initializeContentType(request);
|
|
assertEquals("text/html", file.getContentType());
|
|
file.delete();
|
|
|
|
file = new File(m_parent);
|
|
file.setContent(src,name + ".html", desc);
|
|
|
|
file.setContentType(null);
|
|
file.initializeContentType(null);
|
|
assertEquals("text/html", file.getContentType());
|
|
|
|
// Try a file with no extension, no content-type header, and
|
|
// verify that the default mime type is set
|
|
|
|
src = new java.io.File(TEST_FILE_NOEXT);
|
|
file = new File(m_parent);
|
|
file.setContent(src,name,desc);
|
|
file.initializeContentType(null);
|
|
assertEquals(File.DEFAULT_MIME_TYPE,
|
|
file.getContentType());
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
* Main method required to make this test runnable.
|
|
*/
|
|
|
|
public static void main(String args[]) {
|
|
junit.textui.TestRunner.run(FileTest.class);
|
|
}
|
|
}
|