mirror of
https://github.com/DSpace/DSpace.git
synced 2025-10-08 10:34:25 +00:00
596 lines
21 KiB
Java
596 lines
21 KiB
Java
/**
|
|
* The contents of this file are subject to the license and copyright
|
|
* detailed in the LICENSE and NOTICE files at the root of the source
|
|
* tree and available online at
|
|
*
|
|
* http://www.dspace.org/license/
|
|
*/
|
|
package org.dspace.content;
|
|
|
|
import static org.hamcrest.CoreMatchers.equalTo;
|
|
import static org.hamcrest.CoreMatchers.not;
|
|
import static org.hamcrest.CoreMatchers.notNullValue;
|
|
import static org.hamcrest.CoreMatchers.nullValue;
|
|
import static org.hamcrest.MatcherAssert.assertThat;
|
|
import static org.junit.Assert.assertEquals;
|
|
import static org.junit.Assert.assertFalse;
|
|
import static org.junit.Assert.assertTrue;
|
|
import static org.junit.Assert.fail;
|
|
import static org.mockito.ArgumentMatchers.any;
|
|
import static org.mockito.ArgumentMatchers.eq;
|
|
import static org.mockito.Mockito.doNothing;
|
|
import static org.mockito.Mockito.doThrow;
|
|
import static org.mockito.Mockito.spy;
|
|
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.IOException;
|
|
import java.sql.SQLException;
|
|
import java.util.ArrayList;
|
|
import java.util.Comparator;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.UUID;
|
|
|
|
import org.apache.logging.log4j.Logger;
|
|
import org.dspace.authorize.AuthorizeException;
|
|
import org.dspace.authorize.service.AuthorizeService;
|
|
import org.dspace.content.factory.ContentServiceFactory;
|
|
import org.dspace.content.service.BitstreamFormatService;
|
|
import org.dspace.core.Constants;
|
|
import org.dspace.core.Context;
|
|
import org.junit.After;
|
|
import org.junit.Before;
|
|
import org.junit.Test;
|
|
import org.springframework.test.util.ReflectionTestUtils;
|
|
|
|
/**
|
|
* Unit Tests for class Bitstream
|
|
*
|
|
* @author pvillega
|
|
*/
|
|
public class BitstreamTest extends AbstractDSpaceObjectTest {
|
|
/**
|
|
* log4j category
|
|
*/
|
|
private static final Logger log = org.apache.logging.log4j.LogManager.getLogger(BitstreamTest.class);
|
|
|
|
|
|
protected BitstreamFormatService bitstreamFormatService = ContentServiceFactory.getInstance()
|
|
.getBitstreamFormatService();
|
|
|
|
/**
|
|
* BitStream instance for the tests
|
|
*/
|
|
private Bitstream bs;
|
|
|
|
/**
|
|
* Spy of AuthorizeService to use for tests
|
|
* (initialized / setup in @Before method)
|
|
*/
|
|
private AuthorizeService authorizeServiceSpy;
|
|
|
|
/**
|
|
* This method will be run before every test as per @Before. It will
|
|
* initialize resources required for the tests.
|
|
*
|
|
* Other methods can be annotated with @Before here or in subclasses
|
|
* but no execution order is guaranteed
|
|
*/
|
|
@Before
|
|
@Override
|
|
public void init() {
|
|
super.init();
|
|
try {
|
|
//we have to create a new bitstream in the database
|
|
context.turnOffAuthorisationSystem();
|
|
File f = new File(testProps.get("test.bitstream").toString());
|
|
this.bs = bitstreamService.create(context, new FileInputStream(f));
|
|
this.dspaceObject = bs;
|
|
context.restoreAuthSystemState();
|
|
|
|
// Initialize our spy of the autowired (global) authorizeService bean.
|
|
// This allows us to customize the bean's method return values in tests below
|
|
authorizeServiceSpy = spy(authorizeService);
|
|
// "Wire" our spy to be used by the current loaded bitstreamService
|
|
// (To ensure it uses the spy instead of the real service)
|
|
ReflectionTestUtils.setField(bitstreamService, "authorizeService", authorizeServiceSpy);
|
|
} catch (IOException ex) {
|
|
log.error("IO Error in init", ex);
|
|
fail("SQL Error in init: " + ex.getMessage());
|
|
} catch (SQLException ex) {
|
|
log.error("SQL Error in init", ex);
|
|
fail("SQL Error in init: " + ex.getMessage());
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method will be run after every test as per @After. It will
|
|
* clean resources initialized by the @Before methods.
|
|
*
|
|
* Other methods can be annotated with @After here or in subclasses
|
|
* but no execution order is guaranteed
|
|
*/
|
|
@After
|
|
@Override
|
|
public void destroy() {
|
|
bs = null;
|
|
super.destroy();
|
|
}
|
|
|
|
/**
|
|
* Test of find method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testBSFind() throws SQLException {
|
|
UUID id = this.bs.getID();
|
|
Bitstream found = bitstreamService.find(context, id);
|
|
assertThat("testBSFind 0", found, notNullValue());
|
|
//the item created by default has no name nor type set
|
|
assertThat("testBSFind 1", found.getFormat(context).getMIMEType(), equalTo("application/octet-stream"));
|
|
assertThat("testBSFind 2", found.getName(), nullValue());
|
|
assertThat("testBSFind 3", found.getID(), equalTo(id));
|
|
}
|
|
|
|
/**
|
|
* Test of findAll method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testFindAll() throws SQLException {
|
|
List<Bitstream> found = bitstreamService.findAll(context);
|
|
assertThat("testFindAll 0", found, notNullValue());
|
|
//we have many bs, one created per test run, so at least we have 1 if
|
|
//this test is run first
|
|
assertTrue("testFindAll 1", found.size() >= 1);
|
|
|
|
boolean added = false;
|
|
for (Bitstream b : found) {
|
|
if (b.equals(bs)) {
|
|
added = true;
|
|
}
|
|
}
|
|
assertTrue("testFindAll 2", added);
|
|
}
|
|
|
|
@Test
|
|
public void testFindAllBatches() throws Exception {
|
|
//Adding some data for processing and cleaning this up at the end
|
|
context.turnOffAuthorisationSystem();
|
|
File f = new File(testProps.get("test.bitstream").toString());
|
|
List<Bitstream> inserted = new ArrayList<>();
|
|
for (int i = 0; i < 5; i++) {
|
|
Bitstream bs = bitstreamService.create(context, new FileInputStream(f));
|
|
inserted.add(bs);
|
|
}
|
|
context.restoreAuthSystemState();
|
|
|
|
// sorted list of all bitstreams
|
|
List<Bitstream> all = bitstreamService.findAll(context);
|
|
List<Bitstream> expected = new ArrayList<>(all);
|
|
expected.sort(Comparator.comparing(bs -> bs.getID().toString()));
|
|
|
|
int total = bitstreamService.countTotal(context);
|
|
int batchSize = 2;
|
|
int numberOfBatches = (int) Math.ceil((double) total / batchSize);
|
|
|
|
//collect in batches
|
|
List<Bitstream> collected = new ArrayList<>();
|
|
for (int i = 0; i < numberOfBatches; i++) {
|
|
Iterator<Bitstream> it = bitstreamService.findAll(context, batchSize, i * batchSize);
|
|
it.forEachRemaining(collected::add);
|
|
}
|
|
|
|
assertEquals("Batched results should match sorted findAll", expected, collected);
|
|
|
|
// Cleanup
|
|
context.turnOffAuthorisationSystem();
|
|
for (Bitstream b : inserted) {
|
|
bitstreamService.delete(context, b);
|
|
}
|
|
context.restoreAuthSystemState();
|
|
}
|
|
|
|
/**
|
|
* Test of create method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testCreate() throws IOException, SQLException {
|
|
File f = new File(testProps.get("test.bitstream").toString());
|
|
Bitstream created = bitstreamService.create(context, new FileInputStream(f));
|
|
|
|
//the item created by default has no name nor type set
|
|
assertThat("testCreate 0", created.getFormat(context).getMIMEType(), equalTo("application/octet-stream"));
|
|
assertThat("testCreate 1", created.getName(), nullValue());
|
|
}
|
|
|
|
/**
|
|
* Test of register method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testRegister() throws IOException, SQLException, AuthorizeException {
|
|
// Allow general Bitstream WRITE permissions
|
|
doNothing().when(authorizeServiceSpy).authorizeAction(any(Context.class), any(Bitstream.class),
|
|
eq(Constants.WRITE));
|
|
|
|
int assetstore = 0;
|
|
File f = new File(testProps.get("test.bitstream").toString());
|
|
Bitstream registered = bitstreamService.register(context, assetstore, f.getName());
|
|
//the item created by default has no name nor type set
|
|
assertThat("testRegister 0", registered.getFormat(context).getMIMEType(), equalTo("application/octet-stream"));
|
|
assertThat("testRegister 1", registered.getName(), nullValue());
|
|
}
|
|
|
|
/**
|
|
* Test of getID method, of class Bitstream.
|
|
*/
|
|
@Override
|
|
@Test
|
|
public void testGetID() {
|
|
assertTrue("testGetID 0", bs.getID() != null);
|
|
}
|
|
|
|
@Test
|
|
public void testLegacyID() {
|
|
assertTrue("testGetLegacyID 0", bs.getLegacyId() == null);
|
|
}
|
|
|
|
/**
|
|
* Test of getHandle method, of class Bitstream.
|
|
*/
|
|
@Override
|
|
@Test
|
|
public void testGetHandle() {
|
|
//no handle for bitstreams
|
|
assertThat("testGetHandle 0", bs.getHandle(), nullValue());
|
|
}
|
|
|
|
/**
|
|
* Test of getSequenceID method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testGetSequenceID() {
|
|
//sequence id is -1 when not set
|
|
assertThat("testGetSequenceID 0", bs.getSequenceID(), equalTo(-1));
|
|
}
|
|
|
|
/**
|
|
* Test of setSequenceID method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testSetSequenceID() {
|
|
int val = 2;
|
|
bs.setSequenceID(val);
|
|
assertThat("testSetSequenceID 0", bs.getSequenceID(), equalTo(val));
|
|
}
|
|
|
|
/**
|
|
* Test of getName method, of class Bitstream.
|
|
*/
|
|
@Override
|
|
@Test
|
|
public void testGetName() {
|
|
//name is null when not set
|
|
assertThat("testGetName 0", bs.getName(), nullValue());
|
|
}
|
|
|
|
/**
|
|
* Test of setName method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testSetName() throws SQLException {
|
|
String name = "new name";
|
|
bs.setName(context, name);
|
|
assertThat("testGetName 0", bs.getName(), notNullValue());
|
|
assertThat("testGetName 1", bs.getName(), not(equalTo("")));
|
|
assertThat("testGetName 2", bs.getName(), equalTo(name));
|
|
}
|
|
|
|
/**
|
|
* Test of getSource method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testGetSource() {
|
|
//source is null if not set
|
|
assertThat("testGetSource 0", bs.getSource(), nullValue());
|
|
}
|
|
|
|
/**
|
|
* Test of setSource method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testSetSource() throws SQLException {
|
|
String source = "new source";
|
|
bs.setSource(context, source);
|
|
assertThat("testSetSource 0", bs.getSource(), notNullValue());
|
|
assertThat("testSetSource 1", bs.getSource(), not(equalTo("")));
|
|
assertThat("testSetSource 2", bs.getSource(), equalTo(source));
|
|
}
|
|
|
|
/**
|
|
* Test of getDescription method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testGetDescription() {
|
|
//default description is null if not set
|
|
assertThat("testGetDescription 0", bs.getDescription(), nullValue());
|
|
}
|
|
|
|
/**
|
|
* Test of setDescription method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testSetDescription() throws SQLException {
|
|
String description = "new description";
|
|
bs.setDescription(context, description);
|
|
assertThat("testSetDescription 0", bs.getDescription(), notNullValue());
|
|
assertThat("testSetDescription 1", bs.getDescription(), not(equalTo("")));
|
|
assertThat("testSetDescription 2", bs.getDescription(), equalTo(description));
|
|
}
|
|
|
|
/**
|
|
* Test of getChecksum method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testGetChecksum() {
|
|
String checksum = "75a060bf6eb63fd0aad88b7d757728d3";
|
|
assertThat("testGetChecksum 0", bs.getChecksum(), notNullValue());
|
|
assertThat("testGetChecksum 1", bs.getChecksum(), not(equalTo("")));
|
|
assertThat("testGetChecksum 2", bs.getChecksum(), equalTo(checksum));
|
|
}
|
|
|
|
/**
|
|
* Test of getChecksumAlgorithm method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testGetChecksumAlgorithm() {
|
|
String alg = "MD5";
|
|
assertThat("testGetChecksumAlgorithm 0", bs.getChecksumAlgorithm(),
|
|
notNullValue());
|
|
assertThat("testGetChecksumAlgorithm 1", bs.getChecksumAlgorithm(),
|
|
not(equalTo("")));
|
|
assertThat("testGetChecksumAlgorithm 2", bs.getChecksumAlgorithm(),
|
|
equalTo(alg));
|
|
}
|
|
|
|
/**
|
|
* Test of getSizeBytes method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testGetSize() {
|
|
long size = 238413; // yuck, hardcoded!
|
|
assertThat("testGetSize 0", bs.getSizeBytes(), equalTo(size));
|
|
}
|
|
|
|
/**
|
|
* Test of setUserFormatDescription method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testSetUserFormatDescription() throws SQLException {
|
|
String userdescription = "user format description";
|
|
bs.setUserFormatDescription(context, userdescription);
|
|
assertThat("testSetUserFormatDescription 0", bs.getUserFormatDescription()
|
|
, notNullValue());
|
|
assertThat("testSetUserFormatDescription 1", bs.getUserFormatDescription()
|
|
, not(equalTo("")));
|
|
assertThat("testSetUserFormatDescription 2", bs.getUserFormatDescription()
|
|
, equalTo(userdescription));
|
|
}
|
|
|
|
/**
|
|
* Test of getUserFormatDescription method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testGetUserFormatDescription() {
|
|
//null by default if not set
|
|
assertThat("testGetUserFormatDescription 0", bs.getUserFormatDescription()
|
|
, nullValue());
|
|
}
|
|
|
|
/**
|
|
* Test of getFormatDescription method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testGetFormatDescription() throws SQLException {
|
|
//format is unknown by default
|
|
String format = "Unknown";
|
|
assertThat("testGetFormatDescription 0", bs.getFormatDescription(context),
|
|
notNullValue());
|
|
assertThat("testGetFormatDescription 1", bs.getFormatDescription(context),
|
|
not(equalTo("")));
|
|
assertThat("testGetFormatDescription 2", bs.getFormatDescription(context),
|
|
equalTo(format));
|
|
}
|
|
|
|
/**
|
|
* Test of getFormat method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testGetFormat() throws SQLException {
|
|
assertThat("testGetFormat 0", bs.getFormat(context), notNullValue());
|
|
assertThat("testGetFormat 1", bs.getFormat(context), equalTo(bitstreamFormatService.findUnknown(context)));
|
|
}
|
|
|
|
/**
|
|
* Test of setFormat method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testSetFormat() throws SQLException {
|
|
int id = 3;
|
|
BitstreamFormat format = bitstreamFormatService.find(context, id);
|
|
bs.setFormat(format);
|
|
assertThat("testSetFormat 0", bs.getFormat(context), notNullValue());
|
|
assertThat("testSetFormat 1", bs.getFormat(context), equalTo(bitstreamFormatService.find(context, id)));
|
|
}
|
|
|
|
/**
|
|
* Test of update method, of class Bitstream.
|
|
*/
|
|
@Test(expected = AuthorizeException.class)
|
|
public void testUpdateNotAdmin() throws SQLException, AuthorizeException {
|
|
// Disallow Bitstream WRITE permissions
|
|
doThrow(new AuthorizeException()).when(authorizeServiceSpy).authorizeAction(context, bs, Constants.WRITE);
|
|
|
|
//TODO: we need to verify the update, how?
|
|
bitstreamService.update(context, bs);
|
|
}
|
|
|
|
/**
|
|
* Test of update method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testUpdateAdmin() throws SQLException, AuthorizeException {
|
|
// Allow Bitstream WRITE permissions
|
|
doNothing().when(authorizeServiceSpy).authorizeAction(context, bs, Constants.WRITE);
|
|
|
|
//TODO: we need to verify the update, how?
|
|
bitstreamService.update(context, bs);
|
|
}
|
|
|
|
/**
|
|
* Test of delete method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testDeleteAndExpunge() throws IOException, SQLException, AuthorizeException {
|
|
// Create a new bitstream, which we can delete. As ordering of these
|
|
// tests is unpredictable we don't want to delete the global bitstream
|
|
context.ignoreAuthorization();
|
|
File f = new File(testProps.get("test.bitstream").toString());
|
|
Bitstream delBS = bitstreamService.create(context, new FileInputStream(f));
|
|
UUID bitstreamId = delBS.getID();
|
|
context.restoreAuthSystemState();
|
|
|
|
// Allow Bitstream WRITE permissions
|
|
doNothing().when(authorizeServiceSpy).authorizeAction(context, delBS, Constants.WRITE);
|
|
// Allow Bitstream DELETE permissions
|
|
doNothing().when(authorizeServiceSpy).authorizeAction(context, delBS, Constants.DELETE);
|
|
|
|
// Test that delete will flag the bitstream as deleted
|
|
assertFalse("testIsDeleted 0", delBS.isDeleted());
|
|
bitstreamService.delete(context, delBS);
|
|
assertTrue("testDelete 0", delBS.isDeleted());
|
|
|
|
// Now test expunge actually removes the bitstream
|
|
bitstreamService.expunge(context, delBS);
|
|
assertThat("testExpunge 0", bitstreamService.find(context, bitstreamId), nullValue());
|
|
}
|
|
|
|
/**
|
|
* Test of delete method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testDeleteBitstreamAndUnsetPrimaryBitstreamID()
|
|
throws IOException, SQLException, AuthorizeException {
|
|
|
|
context.turnOffAuthorisationSystem();
|
|
|
|
Community owningCommunity = communityService.create(null, context);
|
|
Collection collection = collectionService.create(context, owningCommunity);
|
|
WorkspaceItem workspaceItem = workspaceItemService.create(context, collection, false);
|
|
Item item = installItemService.installItem(context, workspaceItem);
|
|
Bundle b = bundleService.create(context, item, "TESTBUNDLE");
|
|
|
|
// Allow Bundle REMOVE permissions
|
|
doNothing().when(authorizeServiceSpy).authorizeAction(context, b, Constants.REMOVE);
|
|
// Allow Bitstream WRITE permissions
|
|
doNothing().when(authorizeServiceSpy)
|
|
.authorizeAction(any(Context.class), any(Bitstream.class), eq(Constants.WRITE));
|
|
// Allow Bitstream DELETE permissions
|
|
doNothing().when(authorizeServiceSpy)
|
|
.authorizeAction(any(Context.class), any(Bitstream.class), eq(Constants.DELETE));
|
|
|
|
//set a value different than default
|
|
File f = new File(testProps.get("test.bitstream").toString());
|
|
|
|
// Create a new bitstream, which we can delete.
|
|
Bitstream delBS = bitstreamService.create(context, new FileInputStream(f));
|
|
bundleService.addBitstream(context, b, delBS);
|
|
// set primary bitstream
|
|
b.setPrimaryBitstreamID(delBS);
|
|
context.restoreAuthSystemState();
|
|
|
|
// Test that delete will flag the bitstream as deleted
|
|
assertFalse("testDeleteBitstreamAndUnsetPrimaryBitstreamID 0", delBS.isDeleted());
|
|
assertThat("testDeleteBitstreamAndUnsetPrimaryBitstreamID 1", b.getPrimaryBitstream(), equalTo(delBS));
|
|
// Delete bitstream
|
|
bitstreamService.delete(context, delBS);
|
|
assertTrue("testDeleteBitstreamAndUnsetPrimaryBitstreamID 2", delBS.isDeleted());
|
|
|
|
// Now test if the primary bitstream was unset from bundle
|
|
assertThat("testDeleteBitstreamAndUnsetPrimaryBitstreamID 3", b.getPrimaryBitstream(), equalTo(null));
|
|
}
|
|
|
|
/**
|
|
* Test of retrieve method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testRetrieveCanRead() throws IOException, SQLException,
|
|
AuthorizeException {
|
|
// Allow Bitstream READ permissions
|
|
doNothing().when(authorizeServiceSpy).authorizeAction(context, bs, Constants.READ);
|
|
|
|
assertThat("testRetrieveCanRead 0", bitstreamService.retrieve(context, bs), notNullValue());
|
|
}
|
|
|
|
/**
|
|
* Test of retrieve method, of class Bitstream.
|
|
*/
|
|
@Test(expected = AuthorizeException.class)
|
|
public void testRetrieveNoRead() throws IOException, SQLException,
|
|
AuthorizeException {
|
|
// Disallow Bitstream READ permissions
|
|
doThrow(new AuthorizeException()).when(authorizeServiceSpy).authorizeAction(context, bs, Constants.READ);
|
|
|
|
assertThat("testRetrieveNoRead 0", bitstreamService.retrieve(context, bs), notNullValue());
|
|
}
|
|
|
|
/**
|
|
* Test of getBundles method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testGetBundles() throws SQLException {
|
|
assertThat("testGetBundles 0", bs.getBundles(), notNullValue());
|
|
//by default no bundles
|
|
assertTrue("testGetBundles 1", bs.getBundles().size() == 0);
|
|
}
|
|
|
|
/**
|
|
* Test of getType method, of class Bitstream.
|
|
*/
|
|
@Override
|
|
@Test
|
|
public void testGetType() {
|
|
assertThat("testGetType 0", bs.getType(), equalTo(Constants.BITSTREAM));
|
|
}
|
|
|
|
/**
|
|
* Test of isRegisteredBitstream method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testIsRegisteredBitstream() {
|
|
//false by default
|
|
assertThat("testIsRegisteredBitstream 0", bitstreamService.isRegisteredBitstream(bs),
|
|
equalTo(false));
|
|
}
|
|
|
|
/**
|
|
* Test of getStoreNumber method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
public void testGetStoreNumber() {
|
|
//stored in store 0 by default
|
|
assertTrue("testGetStoreNumber 0", bs.getStoreNumber() == 0);
|
|
}
|
|
|
|
/**
|
|
* Test of getParentObject method, of class Bitstream.
|
|
*/
|
|
@Test
|
|
@Override
|
|
public void testGetParentObject() throws SQLException {
|
|
//by default this bitstream is not linked to any object
|
|
assertThat("testGetParentObject 0", bitstreamService.getParentObject(context, bs),
|
|
nullValue());
|
|
}
|
|
|
|
}
|