/**
* 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.core;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.Locale;
import mockit.NonStrictExpectations;
import org.dspace.AbstractUnitTest;
import org.dspace.authorize.AuthorizeException;
import org.dspace.authorize.AuthorizeManager;
import org.dspace.eperson.EPerson;
import org.dspace.eperson.Group;
import org.junit.*;
import static org.junit.Assert.* ;
import static org.hamcrest.CoreMatchers.*;
/**
* Perform some basic unit tests for Context Class
* @author tdonohue
*/
public class ContextTest extends AbstractUnitTest
{
/**
* Test of getDBConnection method, of class Context.
*/
@Test
public void testGetDBConnection() throws SQLException
{
Connection connection = context.getDBConnection();
assertThat("testGetDBConnection 0", connection, notNullValue());
assertThat("testGetDBConnection 1", connection.isClosed(), equalTo(false));
}
/**
* Test of setCurrentUser method, of class Context.
*/
@Test
public void testSetCurrentUser() throws SQLException, AuthorizeException
{
new NonStrictExpectations(AuthorizeManager.class)
{{
// Allow Admin permissions - needed to create a new EPerson
AuthorizeManager.isAdmin((Context) any); result = true;
}};
EPerson oldUser = context.getCurrentUser();
// Create a dummy EPerson to set as current user
EPerson newUser = EPerson.create(context);
newUser.setFirstName("Jane");
newUser.setLastName("Doe");
newUser.setEmail("jane@email.com");
newUser.setCanLogIn(true);
newUser.setLanguage(I18nUtil.getDefaultLocale().getLanguage());
context.setCurrentUser(newUser);
assertThat("testSetCurrentUser 0", context.getCurrentUser(), notNullValue());
assertThat("testSetCurrentUser 1", context.getCurrentUser(), equalTo(newUser));
// Restore the previous current user
context.setCurrentUser(oldUser);
}
/**
* Test of getCurrentUser method, of class Context.
*/
@Test
public void testGetCurrentUser()
{
//NOTE: 'eperson' is initialized by AbstractUnitTest & set as the "currentUser" there
assertThat("testGetCurrentUser 0", context.getCurrentUser(), notNullValue());
assertThat("testGetCurrentUser 1", context.getCurrentUser(), equalTo(eperson));
}
/**
* Test of getCurrentLocale method, of class Context.
*/
@Test
public void testGetCurrentLocale()
{
//NOTE: CurrentLocale is not initialized in AbstractUnitTest. So it should be DEFAULTLOCALE
assertThat("testGetCurrentLocale 0", context.getCurrentLocale(), notNullValue());
assertThat("testGetCurrentLocale 1", context.getCurrentLocale(), equalTo(I18nUtil.DEFAULTLOCALE));
}
/**
* Test of setCurrentLocale method, of class Context.
*/
@Test
public void testSetCurrentLocale() {
//Get previous value
Locale oldLocale = context.getCurrentLocale();
//Set a new, non-English value
Locale newLocale = Locale.FRENCH;
context.setCurrentLocale(newLocale);
assertThat("testSetCurrentLocale 0", context.getCurrentLocale(), notNullValue());
assertThat("testSetCurrentLocale 1", context.getCurrentLocale(), equalTo(newLocale));
// Restore previous value
context.setCurrentLocale(oldLocale);
}
/**
* Test of ignoreAuthorization method, of class Context.
*/
@Test
public void testIgnoreAuthorization()
{
// Turn off authorization
context.turnOffAuthorisationSystem();
assertThat("testIgnoreAuthorization 0", context.ignoreAuthorization(), equalTo(true));
// Turn it back on
context.restoreAuthSystemState();
assertThat("testIgnoreAuthorization 1", context.ignoreAuthorization(), equalTo(false));
}
/**
* Test of turnOffAuthorisationSystem method, of class Context.
*/
/*@Test
public void testTurnOffAuthorisationSystem() {
// Already tested in testIgnoreAuthorization()
}*/
/**
* Test of restoreAuthSystemState method, of class Context.
*/
/*@Test
public void testRestoreAuthSystemState() {
// Already tested in testIgnoreAuthorization()
}*/
/**
* Test of setIgnoreAuthorization method, of class Context.
*/
/*@Test
public void testSetIgnoreAuthorization() {
// Deprecated method
}*/
/**
* Test of setExtraLogInfo method, of class Context.
*/
@Test
public void testSetExtraLogInfo()
{
// Get the previous value
String oldValue = context.getExtraLogInfo();
// Set a new value
String newValue = "This is some extra log info";
context.setExtraLogInfo(newValue);
assertThat("testSetExtraLogInfo 0", context.getExtraLogInfo(), notNullValue());
assertThat("testSetExtraLogInfo 1", context.getExtraLogInfo(), equalTo(newValue));
}
/**
* Test of getExtraLogInfo method, of class Context.
*/
@Test
public void testGetExtraLogInfo()
{
// Extra log info has a default value of "", and AbstractUnitTest doesn't change it
String defaultValue = "";
assertThat("testGetExtraLogInfo 0", context.getExtraLogInfo(), notNullValue());
assertThat("testGetExtraLogInfo 1", context.getExtraLogInfo(), equalTo(defaultValue));
}
/**
* Test of complete method, of class Context.
*/
@Test
public void testComplete() throws SQLException
{
// To test complete() we need a new Context object
Context instance = new Context();
// By default, we should have a new DB connection, so let's make sure it is there
assertThat("testComplete 0", instance.getDBConnection(), notNullValue());
assertThat("testComplete 1", instance.getDBConnection().isClosed(), equalTo(false));
assertThat("testComplete 2", instance.isValid(), equalTo(true));
// Now, call complete(). This should set DB connection to null & invalidate context
instance.complete();
assertThat("testComplete 3", instance.getDBConnection(), nullValue());
assertThat("testComplete 4", instance.isValid(), equalTo(false));
// Cleanup our new context
cleanupContext(instance);
// TODO: May also want to test that complete() is calling commit()?
}
/**
* Test of complete method, of class Context.
*/
@Test
public void testComplete2() throws SQLException
{
// To test complete() we need a new Context object
Context instance = new Context();
// Call complete twice. The second call should NOT throw an error
// and effectively does nothing
instance.complete();
instance.complete();
// Cleanup our new context
cleanupContext(instance);
}
/**
* Test of commit method, of class Context.
*/
@Test
public void testCommit() throws Exception
{
new NonStrictExpectations(AuthorizeManager.class)
{{
// Allow Admin permissions - needed to create a new EPerson
AuthorizeManager.isAdmin((Context) any); result = true;
}};
// Create a new EPerson & commit it
String createdEmail = "jimmy@email.com";
EPerson newUser = EPerson.create(context);
newUser.setFirstName("Jimmy");
newUser.setLastName("Doe");
newUser.setEmail(createdEmail);
newUser.setCanLogIn(true);
newUser.setLanguage(I18nUtil.getDefaultLocale().getLanguage());
// Ensure EPerson is committed
newUser.update();
context.commit();
//Now, open a new context, and see if this eperson can be found!
Context newInstance = new Context();
EPerson found = EPerson.findByEmail(newInstance, createdEmail);
assertThat("testCommit 0", found, notNullValue());
// Cleanup our new context
cleanupContext(newInstance);
}
/**
* Test of commit method, of class Context.
*/
@Test(expected=IllegalStateException.class)
public void testCommitReadOnlyContext() throws Exception
{
// Create a read-only Context
Context instance = new Context(Context.READ_ONLY);
try
{
// Attempt to commit to it - should throw an exception
instance.commit();
}
finally
{
// Cleanup our context
cleanupContext(instance);
}
}
/**
* Test of commit method, of class Context.
*/
@Test(expected=IllegalStateException.class)
public void testCommitInvalidContext() throws Exception
{
// Create a new Context
Context instance = new Context();
// Close context (invalidating it)
instance.abort();
try
{
// Attempt to commit to it - should throw an exception
instance.commit();
}
finally
{
// Cleanup our context
cleanupContext(instance);
}
}
/**
* Test of abort method, of class Context.
*/
@Test
public void testAbort() throws SQLException, AuthorizeException
{
new NonStrictExpectations(AuthorizeManager.class)
{{
// Allow Admin permissions - needed to create a new EPerson
AuthorizeManager.isAdmin((Context) any); result = true;
}};
// To test abort() we need a new Context object
Context instance = new Context();
// Create a new EPerson (DO NOT COMMIT IT)
String createdEmail = "susie@email.com";
EPerson newUser = EPerson.create(instance);
newUser.setFirstName("Susan");
newUser.setLastName("Doe");
newUser.setEmail(createdEmail);
newUser.setCanLogIn(true);
newUser.setLanguage(I18nUtil.getDefaultLocale().getLanguage());
// Abort our context
instance.abort();
// Ensure the context is no longer valid
assertThat("testAbort 0", instance.isValid(), equalTo(false));
// Open a new context, let's make sure that EPerson isn't there
Context newInstance = new Context();
EPerson found = EPerson.findByEmail(newInstance, createdEmail);
assertThat("testAbort 1", found, nullValue());
// Cleanup our contexts
cleanupContext(instance);
cleanupContext(newInstance);
}
/**
* Test of abort method, of class Context.
*/
@Test
public void testAbort2() throws SQLException
{
// To test abort() we need a new Context object
Context instance = new Context();
// Call abort twice. The second call should NOT throw an error
// and effectively does nothing
instance.abort();
instance.abort();
// Cleanup our context
cleanupContext(instance);
}
/**
* Test of isValid method, of class Context.
*/
/*@Test
public void testIsValid() {
// This is already tested by testComplete() and testAbort()
}*/
/**
* Test of isReadOnly method, of class Context.
*/
@Test
public void testIsReadOnly() throws SQLException
{
// Our default context should NOT be read only
assertThat("testIsReadOnly 0", context.isReadOnly(), equalTo(false));
// Create a new read-only context
Context instance = new Context(Context.READ_ONLY);
assertThat("testIsReadOnly 1", instance.isReadOnly(), equalTo(true));
// Cleanup our context
cleanupContext(instance);
}
/**
* Test of fromCache method, of class Context.
*/
@Test
public void testFromCache() throws SQLException, AuthorizeException
{
new NonStrictExpectations(AuthorizeManager.class)
{{
// Allow Admin permissions - needed to create a new EPerson
AuthorizeManager.isAdmin((Context) any); result = true;
}};
// To test caching we need a new Context object
Context instance = new Context();
// Create a new Eperson object
EPerson newEperson = EPerson.create(instance);
newEperson.setFirstName("Sam");
newEperson.setLastName("Smith");
newEperson.setEmail("sammy@smith.com");
newEperson.setCanLogIn(true);
newEperson.setLanguage(I18nUtil.getDefaultLocale().getLanguage());
// Cache the object
instance.cache(newEperson, newEperson.getID());
// Now, pull the object out of the cache
EPerson fromCache = (EPerson) instance.fromCache(EPerson.class, newEperson.getID());
assertThat("testFromCache 0", fromCache, notNullValue());
assertThat("testFromCache 1", fromCache, equalTo(newEperson));
// Cleanup our context
cleanupContext(instance);
}
/**
* Test of cache method, of class Context.
*/
@Test
public void testCache() throws SQLException
{
// To test caching we need a new Context object
Context instance = new Context();
// Create a simple object to cache
String cacheMe = "Look for me in your local cache!";
int cacheMeID = 9999999;
// Cache the object
instance.cache(cacheMe, cacheMeID);
// Now, can we get it back?
String fromCache = (String) instance.fromCache(String.class, cacheMeID);
assertThat("testCache 0", fromCache, notNullValue());
assertThat("testCache 1", fromCache, equalTo(cacheMe));
// Cleanup our context
cleanupContext(instance);
}
/**
* Test of removeCached method, of class Context.
*/
@Test
public void testRemoveCached() throws SQLException
{
// To test caching we need a new Context object
Context instance = new Context();
// Create a simple object to cache
String cacheMe = "Look for me in your local cache!";
int cacheMeID = 9999999;
// Cache the object
instance.cache(cacheMe, cacheMeID);
// Can we get it back?
String fromCache = (String) instance.fromCache(String.class, cacheMeID);
assertThat("testRemoveCache 0", fromCache, notNullValue());
assertThat("testRemoveCache 1", fromCache, equalTo(cacheMe));
// Now, can we remove it?
instance.removeCached(cacheMe, cacheMeID);
assertThat("testRemoveCache 3", instance.fromCache(String.class, cacheMeID), nullValue());
// Cleanup our context
cleanupContext(instance);
}
/**
* Test of clearCache method, of class Context.
*/
@Test
public void testClearCache() throws SQLException
{
// To test caching we need a new Context object
Context instance = new Context();
// Create a simple object to cache
String cacheMe = "Look for me in your local cache!";
int cacheMeID = 9999999;
// Cache the object
instance.cache(cacheMe, cacheMeID);
// Ensure cache is non-empty
assertThat("testClearCache 0", instance.getCacheSize(), equalTo(1));
// Clear our cache
instance.clearCache();
// Ensure cache is empty
assertThat("testClearCache 1", instance.getCacheSize(), equalTo(0));
// Cleanup our context
cleanupContext(instance);
}
/**
* Test of getCacheSize method, of class Context.
*/
/*@Test
public void testGetCacheSize() {
// Tested in testClearCache()
}*/
/**
* Test of setSpecialGroup method, of class Context.
*/
@Test
public void testSetSpecialGroup() throws SQLException
{
// To test special groups we need a new Context object
Context instance = new Context();
// Pass in random integers (need not be valid group IDs)
instance.setSpecialGroup(10000);
instance.setSpecialGroup(10001);
assertThat("testSetSpecialGroup 0", instance.inSpecialGroup(10000), equalTo(true));
assertThat("testSetSpecialGroup 1", instance.inSpecialGroup(10001), equalTo(true));
assertThat("testSetSpecialGroup 2", instance.inSpecialGroup(20000), equalTo(false));
// Cleanup our context
cleanupContext(instance);
}
/**
* Test of inSpecialGroup method, of class Context.
*/
/*@Test
public void testInSpecialGroup() {
// tested in testSetSpecialGroup
}*/
/**
* Test of getSpecialGroups method, of class Context.
*/
@Test
public void testGetSpecialGroups() throws SQLException, AuthorizeException
{
new NonStrictExpectations(AuthorizeManager.class)
{{
// Allow Admin permissions - needed to create a new Group
AuthorizeManager.isAdmin((Context) any); result = true;
}};
// To test special groups we need a new Context object
Context instance = new Context();
// Create a new group & add it as a special group
Group group = Group.create(instance);
int groupID = group.getID();
instance.setSpecialGroup(groupID);
// Also add Administrator group as a special group
Group adminGroup = Group.find(instance, Group.ADMIN_ID);
int adminGroupID = adminGroup.getID();
instance.setSpecialGroup(adminGroupID);
// Now get our special groups
Group[] specialGroups = instance.getSpecialGroups();
assertThat("testGetSpecialGroup 0", specialGroups.length, equalTo(2));
assertThat("testGetSpecialGroup 1", specialGroups[0], equalTo(group));
assertThat("testGetSpecialGroup 1", specialGroups[1], equalTo(adminGroup));
// Cleanup our context
cleanupContext(instance);
}
/**
* Test of finalize method, of class Context.
*/
@Test
public void testFinalize() throws Throwable {
// We need a new Context object
Context instance = new Context();
instance.finalize();
// Finalize is like abort()...should invalidate our context
assertThat("testSetSpecialGroup 0", instance.isValid(), equalTo(false));
// Cleanup our context
cleanupContext(instance);
}
}