Java tutorial
/** * The contents of this file are subject to the license and copyright * detailed in the LICENSE file at the root of the source * tree and available online at * * https://github.com/keeps/roda */ package org.roda.core.storage; import static org.hamcrest.MatcherAssert.assertThat; import static org.testng.AssertJUnit.assertEquals; import static org.testng.AssertJUnit.assertFalse; import static org.testng.AssertJUnit.assertNotNull; import static org.testng.AssertJUnit.assertTrue; import java.io.IOException; import java.io.InputStream; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.StandardCopyOption; import java.util.ArrayList; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Map.Entry; import org.apache.commons.io.IOUtils; import org.hamcrest.Matchers; import org.roda.core.common.iterables.CloseableIterable; import org.roda.core.data.common.RodaConstants; import org.roda.core.data.exceptions.AlreadyExistsException; import org.roda.core.data.exceptions.GenericException; import org.roda.core.data.exceptions.NotFoundException; import org.roda.core.data.exceptions.RODAException; import org.roda.core.data.exceptions.RequestNotValidException; import org.roda.core.data.v2.ip.StoragePath; import org.roda.core.storage.fedora.FedoraStorageService; import org.roda.core.storage.fs.FSUtils; import org.testng.Assert; import org.testng.annotations.AfterMethod; import org.testng.annotations.Test; import jersey.repackaged.com.google.common.collect.Iterables; /** * * @author Luis Faria <lfaria@keep.pt> * @author Helder Silva <hsilva@keep.pt> * @author Sebastien Leroux <sleroux@keep.pt> * * @param <T> * the storage service implementation * */ @Test(groups = { RodaConstants.TEST_GROUP_ALL, RodaConstants.TEST_GROUP_TRAVIS }) public abstract class AbstractStorageServiceTest<T extends StorageService> { /** * Get current instance of storage. * * @return */ protected abstract T getStorage(); /** * Clean up storage, making it empty. */ @AfterMethod public abstract void cleanUp(); public abstract void testClassInstantiation() throws RODAException; public void testListContainer() throws RODAException { // 1) list of containers CloseableIterable<Container> iterable = getStorage().listContainers(); assertThat(iterable, Matchers.iterableWithSize(0)); // 2) container list with one element (which implies creating one // container) final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); Iterator<Container> iterator = getStorage().listContainers().iterator(); assertTrue(iterator.hasNext()); Container next = iterator.next(); assertNotNull(next); assertEquals(containerStoragePath, next.getStoragePath()); assertFalse(iterator.hasNext()); // 3) list after cleanup getStorage().deleteContainer(containerStoragePath); iterator = getStorage().listContainers().iterator(); assertFalse(iterator.hasNext()); } public void testCreateGetDeleteContainer() throws RODAException { // 1) create container final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // 2) get created container Container container = getStorage().getContainer(containerStoragePath); assertNotNull(container); assertEquals(containerStoragePath, container.getStoragePath()); // 3) create container that already exists try { getStorage().createContainer(containerStoragePath); Assert.fail( "An exception should have been thrown while creating a container that already exists but it didn't happen!"); } catch (AlreadyExistsException e) { // do nothing } // 4) delete container getStorage().deleteContainer(containerStoragePath); // 5) test delete container try { getStorage().getContainer(containerStoragePath); Assert.fail( "An exception should have been thrown while getting a container that was deleted but it didn't happened!"); } catch (NotFoundException e) { // do nothing } } public void testGetContainerThatDoesntExist() throws RODAException { // 1) get container that doesn't exist final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); try { getStorage().getContainer(containerStoragePath); Assert.fail( "An exception should have been thrown while getting a container that doesn't exist but it didn't happened!"); } catch (NotFoundException e) { // do nothing } } public void testGetContainerThatIsActuallyADirectory() throws RODAException { // set up final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); final StoragePath directoryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().createDirectory(directoryStoragePath); // get directory as it was a binary try { getStorage().getContainer(directoryStoragePath); Assert.fail( "An exception should have been thrown while getting a container which actually isn't a container but instead a directory but it didn't happened!"); } catch (RequestNotValidException e) { // do nothing } // cleanup getStorage().deleteContainer(containerStoragePath); } public void testGetContainerThatIsActuallyABinary() throws RODAException { // set up final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); final StoragePath binaryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); final ContentPayload payload = new RandomMockContentPayload(); getStorage().createBinary(binaryStoragePath, payload, false); // get binary as it was a directory try { getStorage().getContainer(binaryStoragePath); Assert.fail( "An exception should have been thrown while getting a container which actually isn't a container but instead a binary but it didn't happened!"); } catch (RequestNotValidException e) { // do nothing } // cleanup getStorage().deleteContainer(containerStoragePath); } public void testDeleteContainerThatDoesntExist() throws RODAException { // create container final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // 1) delete container that exists getStorage().deleteContainer(containerStoragePath); // 2) delete container that no longer exists try { getStorage().deleteContainer(containerStoragePath); Assert.fail( "An exception should have been thrown while deleting a container that no longer exists but it didn't happened!"); } catch (NotFoundException e) { // do nothing } } public void testDeleteNonEmptyContainer() throws RODAException { // Set up final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); StoragePath directoryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().createDirectory(directoryStoragePath); // 1) delete container recursively getStorage().deleteContainer(containerStoragePath); // 2) test delete container try { getStorage().getContainer(containerStoragePath); Assert.fail( "An exception should have been thrown while getting a container that doesn't exist but it didn't happened!"); } catch (NotFoundException e) { // do nothing } try { getStorage().getDirectory(directoryStoragePath); Assert.fail( "An exception should have been thrown while getting a container that doesn't exist but it didn't happened!"); } catch (NotFoundException e) { // do nothing } } public void testListResourcesUnderContainer() throws RODAException { // create container final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // 1) list empty container Iterable<Resource> resources = getStorage().listResourcesUnderContainer(containerStoragePath, false); assertNotNull(resources); assertNotNull(resources.iterator()); assertFalse(resources.iterator().hasNext()); // 2) list container with 2 resources beneath (directories) StoragePath directoryStoragePath1 = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().createDirectory(directoryStoragePath1); StoragePath directoryStoragePath2 = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().createDirectory(directoryStoragePath2); resources = getStorage().listResourcesUnderContainer(containerStoragePath, false); assertNotNull(resources); assertThat(resources, Matchers.<Resource>iterableWithSize(2)); // TODO test recursive listing // cleanup getStorage().deleteResource(containerStoragePath); } public void testCreateGetDeleteDirectory() throws RODAException { // create container final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // 1) create directory StoragePath directoryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().createDirectory(directoryStoragePath); // 2) get created directory Directory directory = getStorage().getDirectory(directoryStoragePath); assertNotNull(directory); assertEquals(directoryStoragePath, directory.getStoragePath()); assertTrue(directory.isDirectory()); // 3) create directory that already exists try { getStorage().createDirectory(directoryStoragePath); Assert.fail( "An exception should have been thrown while creating a directory that already exists but it didn't happened!"); } catch (AlreadyExistsException e) { // do nothing } // 4) delete directory getStorage().deleteResource(directoryStoragePath); // 5) test deleted directory try { getStorage().getDirectory(directoryStoragePath); Assert.fail( "An exception should have been thrown while getting a directory that was deleted but it didn't happened!"); } catch (NotFoundException e) { // do nothing } // cleanup getStorage().deleteContainer(containerStoragePath); } public void testGetDirectoryThatDoesntExist() throws RODAException { // set up final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); StoragePath directoryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); // get directory that doesn't exist try { getStorage().getDirectory(directoryStoragePath); Assert.fail( "An exception should have been thrown while getting a directory that doesn't exist but it didn't happened!"); } catch (NotFoundException e) { // do nothing } // cleanup getStorage().deleteContainer(containerStoragePath); } public void testGetDirectoryThatIsActuallyABinary() throws RODAException { // set up final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); final StoragePath binaryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); final ContentPayload payload = new RandomMockContentPayload(); getStorage().createBinary(binaryStoragePath, payload, false); // get binary as it was a directory try { getStorage().getDirectory(binaryStoragePath); Assert.fail( "An exception should have been thrown while getting a directory which actually isn't a directory but instead a binary but it didn't happened!"); } catch (RequestNotValidException e) { // do nothing } // cleanup getStorage().deleteContainer(containerStoragePath); } public void testGetDirectoryThatIsActuallyAContainer() throws RODAException { // set up final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // get container as it was a directory try { getStorage().getDirectory(containerStoragePath); Assert.fail( "An exception should have been thrown while getting a directory which actually isn't a directory but instead a container but it didn't happened!"); } catch (RequestNotValidException e) { // do nothing } // cleanup getStorage().deleteContainer(containerStoragePath); } public void testListResourcesUnderDirectory() throws RODAException, IOException { // create container final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // create directory StoragePath directoryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().createDirectory(directoryStoragePath); // 1) list empty directory Iterable<Resource> resources = getStorage().listResourcesUnderDirectory(directoryStoragePath, false); assertNotNull(resources); assertFalse(resources.iterator().hasNext()); // 2) list directory with 2 resources beneath (directories) final StoragePath subDirectoryStoragePath1 = StorageTestUtils .generateRandomResourceStoragePathUnder(directoryStoragePath); getStorage().createDirectory(subDirectoryStoragePath1); final StoragePath subDirectoryStoragePath2 = StorageTestUtils .generateRandomResourceStoragePathUnder(directoryStoragePath); getStorage().createDirectory(subDirectoryStoragePath2); // add grand-child to ensure it is not listed final StoragePath subSubDirectoryStoragePath1 = StorageTestUtils .generateRandomResourceStoragePathUnder(subDirectoryStoragePath1); getStorage().createDirectory(subSubDirectoryStoragePath1); resources = getStorage().listResourcesUnderDirectory(directoryStoragePath, false); assertNotNull(resources); assertThat(resources, Matchers.<Resource>iterableWithSize(2)); // TODO test recursive listing // cleanup getStorage().deleteContainer(containerStoragePath); } @Test(enabled = false) protected void testBinaryContent(Binary binary, ContentPayload providedPayload) throws IOException, GenericException { // check if content is the same assertTrue(IOUtils.contentEquals(providedPayload.createInputStream(), binary.getContent().createInputStream())); Path tempFile = Files.createTempFile("test", ".tmp"); Files.copy(binary.getContent().createInputStream(), tempFile, StandardCopyOption.REPLACE_EXISTING); // check size in bytes assertEquals(Long.valueOf(Files.size(tempFile)), binary.getSizeInBytes()); if (binary.getContentDigest() != null) { for (Entry<String, String> entry : binary.getContentDigest().entrySet()) { String digest = FSUtils.computeContentDigest(tempFile, entry.getKey()); assertEquals(digest, entry.getValue()); } } // delete temp file Files.delete(tempFile); } public void testCreateGetDeleteBinary() throws RODAException, IOException { // create container final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // 1) create binary final StoragePath binaryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); final ContentPayload payload = new RandomMockContentPayload(); getStorage().createBinary(binaryStoragePath, payload, false); // 2) get binary Binary binary = getStorage().getBinary(binaryStoragePath); assertNotNull(binary); assertEquals(binaryStoragePath, binary.getStoragePath()); assertFalse(binary.isDirectory()); assertFalse(binary.isReference()); testBinaryContent(binary, payload); // 3) create binary that already exists try { getStorage().createBinary(binaryStoragePath, payload, false); Assert.fail( "An exception should have been thrown while creating a binary that already exists but it didn't happened!"); } catch (AlreadyExistsException e) { // do nothing } // 4) delete binary getStorage().deleteResource(binaryStoragePath); // 5) test deleted binary try { getStorage().getBinary(binaryStoragePath); Assert.fail( "An exception should have been thrown while getting a binary that was deleted but it didn't happened!"); } catch (NotFoundException e) { // do nothing } // cleanup getStorage().deleteContainer(containerStoragePath); } public void testCreateGetDeleteBinaryAsReference() throws RODAException, IOException { // create container final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // 1) create binary final StoragePath binaryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); final ContentPayload payload = new RandomMockContentPayload(); try { getStorage().createBinary(binaryStoragePath, payload, true); // 2) get binary Binary binary = getStorage().getBinary(binaryStoragePath); assertNotNull(binary); assertEquals(binaryStoragePath, binary.getStoragePath()); assertFalse(binary.isDirectory()); assertTrue(binary.isReference()); testBinaryContent(binary, payload); // 3) create binary that already exists try { getStorage().createBinary(binaryStoragePath, payload, false); Assert.fail( "An exception should have been thrown while creating a binary that already exists but it didn't happened!"); } catch (AlreadyExistsException e) { // do nothing } // 4) delete binary getStorage().deleteResource(binaryStoragePath); // 5) test deleted binary try { getStorage().getBinary(binaryStoragePath); Assert.fail( "An exception should have been thrown while getting a binary that was deleted but it didn't happened!"); } catch (NotFoundException e) { // do nothing } } catch (GenericException e) { // catching not implemented // do nothing } // cleanup getStorage().deleteContainer(containerStoragePath); } public void testUpdateBinaryContent() throws RODAException, IOException { // create container final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // create binary final StoragePath binaryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); final ContentPayload payload = new RandomMockContentPayload(); getStorage().createBinary(binaryStoragePath, payload, false); // get created binary and save content to file final Binary binaryCreated = getStorage().getBinary(binaryStoragePath); assertNotNull(binaryCreated); final Path original = Files.createTempFile(binaryCreated.getStoragePath().getName(), ".tmp"); binaryCreated.getContent().writeToPath(original); // 1) update binary content final ContentPayload newPayload = new RandomMockContentPayload(); final Binary binaryUpdated = getStorage().updateBinaryContent(binaryStoragePath, newPayload, false, false); assertNotNull(binaryUpdated); try (InputStream stream = Files.newInputStream(original)) { assertFalse(IOUtils.contentEquals(stream, binaryUpdated.getContent().createInputStream())); } testBinaryContent(binaryUpdated, newPayload); // cleanup getStorage().deleteContainer(containerStoragePath); } public void testUpdateBinaryThatDoesntExist() throws RODAException, IOException { // create container final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // update binary content from binary that doesn't exist final StoragePath binaryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); final ContentPayload payload = new RandomMockContentPayload(); final boolean asReference = false; try { getStorage().updateBinaryContent(binaryStoragePath, payload, asReference, false); Assert.fail( "An exception should have been thrown while updating a binary that doesn't exist but it didn't happened!"); } catch (NotFoundException e) { // do nothing } // update binary content now with createIfNotExists=true Binary updatedBinaryContent = getStorage().updateBinaryContent(binaryStoragePath, payload, asReference, true); testBinaryContent(updatedBinaryContent, payload); // cleanup getStorage().deleteContainer(containerStoragePath); } // TODO test update binary from reference to reference // TODO test update binary from non-reference to reference // TODO test update binary from reference to non-reference public void testGetBinaryThatDoesntExist() throws RODAException { // set up final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); StoragePath binaryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); // get binary that doesn't exist try { getStorage().getBinary(binaryStoragePath); Assert.fail( "An exception should have been thrown while getting a binary that doesn't exist but it didn't happened!"); } catch (NotFoundException e) { // do nothing } // cleanup getStorage().deleteContainer(containerStoragePath); } public void testGetBinaryThatIsActuallyADirectory() throws RODAException { // set up final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); final StoragePath directoryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().createDirectory(directoryStoragePath); // get directory as it was a binary try { getStorage().getBinary(directoryStoragePath); Assert.fail( "An exception should have been thrown while getting a binary which actually isn't a binary but instead a directory but it didn't happened!"); } catch (RequestNotValidException e) { // do nothing } // cleanup getStorage().deleteContainer(containerStoragePath); } public void testGetBinaryThatIsActuallyAContainer() throws RODAException { // set up final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // get container as it was a binary try { getStorage().getBinary(containerStoragePath); Assert.fail( "An exception should have been thrown while getting a binary which actually isn't a binary but instead a container but it didn't happened!"); } catch (RequestNotValidException e) { // do nothing } // cleanup getStorage().deleteContainer(containerStoragePath); } public void testDeleteNonEmptyDirectory() throws RODAException { // Set up final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); StoragePath directoryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().createDirectory(directoryStoragePath); StoragePath binaryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(directoryStoragePath); final ContentPayload binaryPayload = new RandomMockContentPayload(); getStorage().createBinary(binaryStoragePath, binaryPayload, false); // test recursively delete directory getStorage().deleteResource(directoryStoragePath); // test get sub-resource try { getStorage().getBinary(binaryStoragePath); Assert.fail( "An exception should have been thrown while getting a binary that doesn't exist but it didn't happened!"); } catch (NotFoundException e) { // do nothing } // test specific cleanup getStorage().deleteContainer(containerStoragePath); } public void testCopyContainerToSameStorage() throws RODAException, IOException { // create and populate source container final StoragePath sourceContainerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(sourceContainerStoragePath); StorageTestUtils.populate(getStorage(), sourceContainerStoragePath); final StoragePath targetContainerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().copy(getStorage(), sourceContainerStoragePath, targetContainerStoragePath); StorageTestUtils.testEntityEqualRecursively(getStorage(), sourceContainerStoragePath, getStorage(), targetContainerStoragePath); // cleanup getStorage().deleteContainer(sourceContainerStoragePath); getStorage().deleteContainer(targetContainerStoragePath); } public void testCopyDirectoryToSameStorage() throws RODAException, IOException { // create container final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // create and populate source directory final StoragePath sourceDirectoryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().createDirectory(sourceDirectoryStoragePath); StorageTestUtils.populate(getStorage(), sourceDirectoryStoragePath); final StoragePath targetDirectoryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().copy(getStorage(), sourceDirectoryStoragePath, targetDirectoryStoragePath); StorageTestUtils.testEntityEqualRecursively(getStorage(), sourceDirectoryStoragePath, getStorage(), targetDirectoryStoragePath); // cleanup getStorage().deleteContainer(containerStoragePath); } public void testCopyBinaryToSameStorage() throws RODAException, IOException { // create container final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // create binary final StoragePath sourceBinaryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); final ContentPayload sourcePayload = new RandomMockContentPayload(); getStorage().createBinary(sourceBinaryStoragePath, sourcePayload, false); final StoragePath targetBinaryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().copy(getStorage(), sourceBinaryStoragePath, targetBinaryStoragePath); final Binary sourceBinary = getStorage().getBinary(sourceBinaryStoragePath); final Binary targetBinary = getStorage().getBinary(targetBinaryStoragePath); assertEquals(sourceBinary.isDirectory(), targetBinary.isDirectory()); assertEquals(sourceBinary.getContentDigest(), targetBinary.getContentDigest()); assertEquals(sourceBinary.getSizeInBytes(), targetBinary.getSizeInBytes()); assertEquals(sourceBinary.isReference(), targetBinary.isReference()); assertTrue(IOUtils.contentEquals(sourceBinary.getContent().createInputStream(), targetBinary.getContent().createInputStream())); // cleanup getStorage().deleteContainer(containerStoragePath); } // TODO test copy from different storage public void testMoveContainerToSameStorage() throws RODAException, IOException { // create and populate source container final StoragePath sourceContainerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(sourceContainerStoragePath); StorageTestUtils.populate(getStorage(), sourceContainerStoragePath); // copy for comparison test final StoragePath copyContainerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().copy(getStorage(), sourceContainerStoragePath, copyContainerStoragePath); // move final StoragePath targetContainerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().move(getStorage(), sourceContainerStoragePath, targetContainerStoragePath); // check with copy StorageTestUtils.testEntityEqualRecursively(getStorage(), copyContainerStoragePath, getStorage(), targetContainerStoragePath); // test source does not exist try { getStorage().getContainer(sourceContainerStoragePath); Assert.fail( "An exception should have been thrown while getting a container that was moved but it didn't happened!"); } catch (NotFoundException e) { // do nothing } // cleanup getStorage().deleteContainer(copyContainerStoragePath); getStorage().deleteContainer(targetContainerStoragePath); } public void testMoveDirectoryToSameStorage() throws RODAException, IOException { // create container final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // create and populate source directory final StoragePath sourceDirectoryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().createDirectory(sourceDirectoryStoragePath); StorageTestUtils.populate(getStorage(), sourceDirectoryStoragePath); // copy for comparison test final StoragePath copyDirectoryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().copy(getStorage(), sourceDirectoryStoragePath, copyDirectoryStoragePath); // move final StoragePath targetDirectoryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().move(getStorage(), sourceDirectoryStoragePath, targetDirectoryStoragePath); // check with copy StorageTestUtils.testEntityEqualRecursively(getStorage(), copyDirectoryStoragePath, getStorage(), targetDirectoryStoragePath); // test source does not exist try { getStorage().getDirectory(sourceDirectoryStoragePath); Assert.fail( "An exception should have been thrown while getting a directory that was moved but it didn't happened!"); } catch (NotFoundException e) { // do nothing } // cleanup getStorage().deleteContainer(containerStoragePath); } public void testMoveBinaryToSameStorage() throws RODAException, IOException { // create container final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // create binary final StoragePath sourceBinaryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); final ContentPayload sourcePayload = new RandomMockContentPayload(); getStorage().createBinary(sourceBinaryStoragePath, sourcePayload, false); // copy for comparison test final StoragePath copyBinaryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().copy(getStorage(), sourceBinaryStoragePath, copyBinaryStoragePath); // move final StoragePath targetBinaryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); getStorage().move(getStorage(), sourceBinaryStoragePath, targetBinaryStoragePath); // check with copy final Binary copyBinary = getStorage().getBinary(copyBinaryStoragePath); final Binary targetBinary = getStorage().getBinary(targetBinaryStoragePath); assertEquals(copyBinary.isDirectory(), targetBinary.isDirectory()); assertEquals(copyBinary.getContentDigest(), targetBinary.getContentDigest()); assertEquals(copyBinary.getSizeInBytes(), targetBinary.getSizeInBytes()); assertEquals(copyBinary.isReference(), targetBinary.isReference()); assertTrue(IOUtils.contentEquals(copyBinary.getContent().createInputStream(), targetBinary.getContent().createInputStream())); // test source does not exist try { getStorage().getBinary(sourceBinaryStoragePath); Assert.fail( "An exception should have been thrown while getting a binary that was moved but it didn't happened!"); } catch (NotFoundException e) { // do nothing } // cleanup getStorage().deleteContainer(containerStoragePath); } // TODO test move from different storage public void testBinaryVersions() throws RODAException, IOException { Map<String, String> properties = new HashMap<>(); properties.put(RodaConstants.VERSION_ACTION, RodaConstants.VersionAction.UPDATED.toString()); // create container final StoragePath containerStoragePath = StorageTestUtils.generateRandomContainerStoragePath(); getStorage().createContainer(containerStoragePath); // 1) create binary final StoragePath binaryStoragePath = StorageTestUtils .generateRandomResourceStoragePathUnder(containerStoragePath); final ContentPayload payload1 = new RandomMockContentPayload(); getStorage().createBinary(binaryStoragePath, payload1, false); // 2) create binary version String message1 = "v1"; properties.put(RodaConstants.VERSION_MESSAGE, message1); BinaryVersion v1 = getStorage().createBinaryVersion(binaryStoragePath, properties); // 3) update binary final ContentPayload payload2 = new RandomMockContentPayload(); getStorage().updateBinaryContent(binaryStoragePath, payload2, false, false); // 4) create binary version 2 String message2 = "v2"; properties.put(RodaConstants.VERSION_MESSAGE, message2); getStorage().createBinaryVersion(binaryStoragePath, properties); // 5) create a version with a message that already exists getStorage().createBinaryVersion(binaryStoragePath, properties); // 6) list binary versions CloseableIterable<BinaryVersion> binaryVersions = getStorage().listBinaryVersions(binaryStoragePath); List<BinaryVersion> reusableBinaryVersions = new ArrayList<>(); Iterables.addAll(reusableBinaryVersions, binaryVersions); assertEquals(3, reusableBinaryVersions.size()); // 7) get binary version BinaryVersion binaryVersion1 = getStorage().getBinaryVersion(binaryStoragePath, v1.getId()); // TODO compare properties assertEquals(message1, binaryVersion1.getProperties().get(RodaConstants.VERSION_MESSAGE)); if (!(getStorage() instanceof FedoraStorageService)) { assertNotNull(binaryVersion1.getCreatedDate()); } assertTrue(IOUtils.contentEquals(payload1.createInputStream(), binaryVersion1.getBinary().getContent().createInputStream())); // 8) revert to previous version getStorage().revertBinaryVersion(binaryStoragePath, v1.getId()); Binary binary = getStorage().getBinary(binaryStoragePath); testBinaryContent(binary, payload1); // 9) delete binary version getStorage().deleteBinaryVersion(binaryStoragePath, v1.getId()); try { getStorage().getBinaryVersion(binaryStoragePath, v1.getId()); Assert.fail("Should have thrown NotFoundException"); } catch (NotFoundException e) { // do nothing } // 10) delete binary and all its history getStorage().deleteResource(binaryStoragePath); try { getStorage().getBinaryVersion(binaryStoragePath, v1.getId()); Assert.fail("Should have thrown NotFoundException"); } catch (NotFoundException e) { // do nothing } // cleanup getStorage().deleteContainer(containerStoragePath); } }