/**
* 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;
import org.apache.log4j.Logger;
import org.dspace.authorize.AuthorizeException;
import org.dspace.authorize.factory.AuthorizeServiceFactory;
import org.dspace.authorize.service.AuthorizeService;
import org.dspace.core.Context;
import org.dspace.core.I18nUtil;
import org.dspace.discovery.MockIndexEventConsumer;
import org.dspace.eperson.EPerson;
import org.dspace.eperson.factory.EPersonServiceFactory;
import org.dspace.eperson.service.EPersonService;
import org.dspace.storage.rdbms.DatabaseUtils;
import org.junit.After;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import java.sql.SQLException;
import static org.junit.Assert.fail;
/**
* This is the base class for most Unit Tests. It contains some generic mocks and
* utilities that are needed by most of the unit tests developed for DSpace.
* <P>
* NOTE: This base class also performs in-memory (H2) database initialization.
* If your tests don't need that, you may wish to just use AbstractDSpaceTest.
*
* @see AbstractDSpaceTest
* @author pvillega
*/
@Ignore
public class AbstractUnitTest extends AbstractDSpaceTest
{
/** log4j category */
private static final Logger log = Logger.getLogger(AbstractUnitTest.class);
/**
* Context mock object to use in the tests.
*/
protected Context context;
/**
* EPerson mock object to use in the tests.
*/
protected EPerson eperson;
/**
* This service is used by the majority of DSO-based Unit tests, which
* is why it is initialized here.
*/
protected AuthorizeService authorizeService = AuthorizeServiceFactory.getInstance().getAuthorizeService();
/**
* This method will be run before the first test as per @BeforeClass. It will
* initialize shared resources required for all tests of this class.
* <p>
* NOTE: Per JUnit, "The @BeforeClass methods of superclasses will be run before those the current class."
* http://junit.org/apidocs/org/junit/BeforeClass.html
* <p>
* This method builds on the initialization in AbstractDSpaceTest, and
* initializes the in-memory database for tests that need it.
*/
@BeforeClass
public static void initDatabase()
{
// Clear our old flyway object. Because this DB is in-memory, its
// data is lost when the last connection is closed. So, we need
// to (re)start Flyway from scratch for each Unit Test class.
DatabaseUtils.clearFlywayDBCache();
try
{
// Update/Initialize the database to latest version (via Flyway)
DatabaseUtils.updateDatabase();
}
catch(SQLException se)
{
log.error("Error initializing database", se);
fail("Error initializing database: " + se.getMessage()
+ (se.getCause() == null ? "" : ": " + se.getCause().getMessage()));
}
// Initialize mock indexer (which does nothing, since Solr isn't running)
new MockIndexEventConsumer();
}
/**
* This method will be run before every test as per @Before. It will
* initialize resources required for each individual unit test.
*
* Other methods can be annotated with @Before here or in subclasses
* but no execution order is guaranteed
*/
@Before
public void init() {
try
{
//Start a new context
context = new Context();
context.turnOffAuthorisationSystem();
//Find our global test EPerson account. If it doesn't exist, create it.
EPersonService ePersonService = EPersonServiceFactory.getInstance().getEPersonService();
eperson = ePersonService.findByEmail(context, "test@email.com");
if(eperson == null)
{
// This EPerson creation should only happen once (i.e. for first test run)
log.info("Creating initial EPerson (email=test@email.com) for Unit Tests");
eperson = ePersonService.create(context);
eperson.setFirstName(context, "first");
eperson.setLastName(context, "last");
eperson.setEmail("test@email.com");
eperson.setCanLogIn(true);
eperson.setLanguage(context, I18nUtil.getDefaultLocale().getLanguage());
// actually save the eperson to unit testing DB
ePersonService.update(context, eperson);
}
// Set our global test EPerson as the current user in DSpace
context.setCurrentUser(eperson);
// If our Anonymous/Administrator groups aren't initialized, initialize them as well
EPersonServiceFactory.getInstance().getGroupService().initDefaultGroupNames(context);
context.restoreAuthSystemState();
}
catch (AuthorizeException ex)
{
log.error("Error creating initial eperson or default groups", ex);
fail("Error creating initial eperson or default groups in AbstractUnitTest init()");
}
catch (SQLException ex)
{
log.error(ex.getMessage(),ex);
fail("SQL Error on AbstractUnitTest init()");
}
}
/**
* 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
public void destroy()
{
// Cleanup our global context object
try {
cleanupContext(context);
} catch (SQLException e) {
throw new RuntimeException(e);
}
}
/**
* Utility method to cleanup a created Context object (to save memory).
* This can also be used by individual tests to cleanup context objects they create.
*/
protected void cleanupContext(Context c) throws SQLException {
// If context still valid, abort it
if(c!=null && c.isValid())
c.complete();
// Cleanup Context object by setting it to null
if(c!=null)
c = null;
}
}