/* The contents of this file are subject to the license and copyright terms
* detailed in the license directory at the root of the source tree (also
* available online at http://fedora-commons.org/license/).
*/
package org.fcrepo.server.storage.lowlevel.akubra;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import java.io.BufferedReader;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.akubraproject.mem.MemBlobStore;
import org.apache.commons.io.IOUtils;
import org.fcrepo.common.FaultException;
import org.fcrepo.server.errors.LowlevelStorageException;
import org.fcrepo.server.errors.ObjectAlreadyInLowlevelStorageException;
import org.fcrepo.server.errors.ObjectNotInLowlevelStorageException;
import org.fcrepo.server.storage.FedoraStorageHintProvider;
import org.fcrepo.server.storage.MockFedoraHintsProvider;
import org.junit.Before;
import org.junit.Test;
/**
* Unit tests for {@link AkubraLowlevelStorage}
*
* @author Chris Wilper
*/
public class AkubraLowlevelStorageTest {
private static final String OBJ_KEY = "test:obj";
private static final String OBJ_CONTENT = "obj-content";
private static final String OBJ_CONTENT2 = "obj-content2";
private static final String DS_KEY = OBJ_KEY + "+DS+DS.0";
private static final String DS_CONTENT = "ds-content";
private static final String DS_CONTENT2 = "ds-content2";
private AkubraLowlevelStorage instance;
private AkubraLowlevelStorage safeInstance;
@Before
public void setUp() {
this.instance = getInstance(false, false);
this.safeInstance = getInstance(true, true);
}
/** Adding an existing datastream should fail. */
@Test (expected=ObjectAlreadyInLowlevelStorageException.class)
public void testAddExistingDatastream() throws LowlevelStorageException {
instance.addDatastream(DS_KEY, toStream(DS_CONTENT));
instance.addDatastream(DS_KEY, toStream(DS_CONTENT));
}
/** Adding an existing object should fail. */
@Test (expected=ObjectAlreadyInLowlevelStorageException.class)
public void testAddExistingObject() throws LowlevelStorageException {
instance.addObject(OBJ_KEY, toStream(OBJ_CONTENT));
assertTrue(instance.objectExists(OBJ_KEY));
instance.addObject(OBJ_KEY, toStream(OBJ_CONTENT));
}
/** Adding a new datastream should succeed. */
@Test
public void testAddNonExistingDatastream() throws Exception {
instance.addDatastream(DS_KEY, toStream(DS_CONTENT));
}
/** Adding a new object should succeed. */
@Test
public void testAddNonExistingObject() throws Exception {
instance.addObject(OBJ_KEY, toStream(OBJ_CONTENT));
}
/** Datastream audit should not throw an exception. */
@Test
public void testAuditDatastream() throws Exception {
instance.auditDatastream();
}
/** Object audit should not throw an exception. */
@Test
public void testAuditObject() throws Exception {
instance.auditObject();
}
/** Datastream rebuild should not throw an exception. */
@Test
public void testRebuildDatastream() throws Exception {
instance.rebuildDatastream();
}
/** Object rebuild should not throw an exception. */
@Test
public void testRebuildObject() throws Exception {
instance.rebuildObject();
}
/** Removing an existing datastream should succeed. */
@Test
public void testRemoveExistingDatastream() throws Exception {
instance.addDatastream(DS_KEY, toStream(DS_CONTENT));
instance.removeDatastream(DS_KEY);
}
/** Removing an existing object should succeed. */
@Test
public void testRemoveExistingObject() throws Exception {
instance.addObject(OBJ_KEY, toStream(OBJ_CONTENT));
instance.removeObject(OBJ_KEY);
}
/** Removing a non-existing datastream should fail. */
@Test (expected=ObjectNotInLowlevelStorageException.class)
public void testRemoveNonExistingDatastream() throws Exception {
instance.removeDatastream(DS_KEY);
}
/** Removing a non-existing object should fail. */
@Test (expected=ObjectNotInLowlevelStorageException.class)
public void testRemoveNonExistingObject() throws Exception {
instance.removeObject(OBJ_KEY);
}
/** Replacing an existing datastream should succeed. */
@Test
public void testReplaceExistingDatastream() throws Exception {
instance.addDatastream(DS_KEY, toStream(DS_CONTENT));
instance.replaceDatastream(DS_KEY, toStream(DS_CONTENT2));
List<String> list = toList(instance.listDatastreams());
assertEquals(1, list.size());
assertEquals(DS_CONTENT2,
toString(instance.retrieveDatastream(DS_KEY)));
}
/** Replacing an existing datastream "safely" should succeed. */
@Test
public void testReplaceExistingDatastreamSafely() throws Exception {
safeInstance.addDatastream(DS_KEY, toStream(DS_CONTENT));
safeInstance.replaceDatastream(DS_KEY, toStream(DS_CONTENT2));
List<String> list = toList(safeInstance.listDatastreams());
assertEquals(1, list.size());
assertEquals(DS_CONTENT2,
toString(safeInstance.retrieveDatastream(DS_KEY)));
}
/** Replacing an existing object should succeed. */
@Test
public void testReplaceExistingObject() throws Exception {
instance.addObject(OBJ_KEY, toStream(OBJ_CONTENT));
instance.replaceObject(OBJ_KEY, toStream(OBJ_CONTENT2));
List<String> list = toList(instance.listObjects());
assertEquals(1, list.size());
assertEquals(OBJ_CONTENT2,
toString(instance.retrieveObject(OBJ_KEY)));
}
/** Replacing an existing object "safely" should succeed. */
@Test
public void testReplaceExistingObjectSafely() throws Exception {
safeInstance.addObject(OBJ_KEY, toStream(OBJ_CONTENT));
safeInstance.replaceObject(OBJ_KEY, toStream(OBJ_CONTENT2));
List<String> list = toList(safeInstance.listObjects());
assertEquals(1, list.size());
assertEquals(OBJ_CONTENT2,
toString(safeInstance.retrieveObject(OBJ_KEY)));
}
/** Replacing a non-existing datastream should fail. */
@Test (expected=ObjectNotInLowlevelStorageException.class)
public void testReplaceNonExistingDatastream() throws Exception {
instance.replaceDatastream(DS_KEY, toStream(DS_CONTENT));
}
/** Replacing a non-existing datastream "safely" should fail. */
@Test (expected=ObjectNotInLowlevelStorageException.class)
public void testReplaceNonExistingDatastreamSafely() throws Exception {
safeInstance.replaceDatastream(DS_KEY, toStream(DS_CONTENT));
}
/** Replacing a non-existing object should fail. */
@Test (expected=ObjectNotInLowlevelStorageException.class)
public void testReplaceNonExistingObject() throws Exception {
instance.replaceObject(OBJ_KEY, toStream(OBJ_CONTENT));
}
/** Replacing a non-existing object "safely" should fail. */
@Test (expected=ObjectNotInLowlevelStorageException.class)
public void testReplaceNonExistingObjectSafely() throws Exception {
safeInstance.replaceObject(OBJ_KEY, toStream(OBJ_CONTENT));
}
/** Retrieving an existing datastream should succeed. */
@Test
public void testRetrieveExistingDatastream() throws Exception {
instance.addDatastream(DS_KEY, toStream(DS_CONTENT));
assertEquals(DS_CONTENT,
toString(instance.retrieveDatastream(DS_KEY)));
}
/** Retrieving an existing object should succeed. */
@Test
public void testRetrieveExistingObject() throws Exception {
instance.addObject(OBJ_KEY, toStream(OBJ_CONTENT));
assertEquals(OBJ_CONTENT,
toString(instance.retrieveObject(OBJ_KEY)));
}
/** Retrieving a non-existing datastream should fail. */
@Test (expected=ObjectNotInLowlevelStorageException.class)
public void testRetrieveNonExistingDatastream() throws Exception {
instance.retrieveDatastream(DS_KEY);
}
/** Retrieving a non-existing object should fail. */
@Test (expected=ObjectNotInLowlevelStorageException.class)
public void testRetrieveNonExistingObject() throws Exception {
instance.retrieveDatastream(OBJ_KEY);
}
/**
* List of datastreams should start at 0, and change to reflect
* reflect what's added and removed.
*/
@Test
public void testListDatastreams() throws Exception {
List<String> list;
list = toList(instance.listDatastreams());
assertEquals(0, list.size());
instance.addDatastream(DS_KEY, toStream(DS_CONTENT));
list = toList(instance.listDatastreams());
assertEquals(1, list.size());
assertEquals(DS_KEY, list.get(0));
instance.removeDatastream(DS_KEY);
list = toList(instance.listDatastreams());
assertEquals(0, list.size());
}
/**
* List of objects should start at 0, and change to reflect
* reflect what's added and removed.
*/
@Test
public void testListObjects() throws Exception {
List<String> list;
list = toList(instance.listObjects());
assertEquals(0, list.size());
instance.addObject(OBJ_KEY, toStream(OBJ_CONTENT));
list = toList(instance.listObjects());
assertEquals(1, list.size());
assertEquals(OBJ_KEY, list.get(0));
instance.removeObject(OBJ_KEY);
list = toList(instance.listObjects());
assertEquals(0, list.size());
}
/**
* getDatastreamSize should retrieve size of added datastream
*/
@Test
public void testGetDatastreamSize() throws Exception {
instance.addDatastream(DS_KEY, toStream(DS_CONTENT));
assertEquals(DS_CONTENT.getBytes("UTF-8").length,
instance.getDatastreamSize(DS_KEY));
}
@Test
public void testAddDatastreamWithHints() throws Exception {
FedoraStorageHintProvider provider = new MockFedoraHintsProvider();
Map<String, String> hints = provider.getHintsForAboutToBeStoredDatastream(null, null);
instance.addDatastream(DS_KEY, toStream(DS_CONTENT), hints);
}
@Test
public void testReplaceDatastreamWithHints() throws Exception {
FedoraStorageHintProvider provider = new MockFedoraHintsProvider();
Map<String, String> hints = provider.getHintsForAboutToBeStoredDatastream(null, null);
instance.addDatastream(DS_KEY, toStream(DS_CONTENT), hints);
instance.replaceDatastream(DS_KEY, toStream(DS_CONTENT), hints);
}
@Test
public void testAddObjectWithHints() throws Exception {
FedoraStorageHintProvider provider = new MockFedoraHintsProvider();
Map<String, String> hints = provider.getHintsForAboutToBeStoredObject(null);
instance.addObject(OBJ_KEY, toStream(OBJ_CONTENT), hints);
}
@Test
public void testReplaceObjectWithHints() throws Exception {
FedoraStorageHintProvider provider = new MockFedoraHintsProvider();
Map<String, String> hints = provider.getHintsForAboutToBeStoredObject(null);
instance.addObject(OBJ_KEY, toStream(OBJ_CONTENT), hints);
instance.replaceObject(OBJ_KEY, toStream(OBJ_CONTENT), hints);
}
private static AkubraLowlevelStorage getInstance(
boolean forceSafeObjectOverwrites,
boolean forceSafeDatastreamOverwrites) {
return new AkubraLowlevelStorage(new MemBlobStore(),
new MemBlobStore(),
forceSafeObjectOverwrites,
forceSafeDatastreamOverwrites);
}
private static List<String> toList(Iterator<String> iter) {
List<String> list = new ArrayList<String>();
while (iter.hasNext()) {
list.add(iter.next());
}
return list;
}
private static InputStream toStream(String string) {
try {
return new ByteArrayInputStream(string.getBytes("UTF-8"));
} catch (IOException wontHappen) {
throw new FaultException(wontHappen);
}
}
private static String toString(InputStream stream) {
try {
return new BufferedReader(new InputStreamReader(stream)).readLine();
} catch (IOException wontHappen) {
throw new FaultException(wontHappen);
} finally {
IOUtils.closeQuietly(stream);
}
}
// Supports legacy test runners
public static junit.framework.Test suite() {
return new junit.framework.JUnit4TestAdapter(AkubraLowlevelStorageTest.class);
}
}