@Before public void setUp() {
mockEmployeeDAO = createMock(EmployeeDAO.class);
employeeBO = new EmployeeBO(mockEmployeeDAO);
employee = new Employee("Alex", "CA", "US");
}
@Test public void shouldAddNewEmployee() {
mockEmployeeDAO.insert(employee);
replay(mockEmployeeDAO);
employeeBO.addNewEmployee(employee);
verify(mockEmployeeDAO);
}
@Test public void shouldUpdateEmployee() {
mockEmployeeDAO.update(employee);
replay(mockEmployeeDAO);
employeeBO.updateEmployee(employee);
verify(mockEmployeeDAO);
}

/**
* Understands a template for usage of EasyMock mocks.
* @author Alex Ruiz
*/
public abstract class EasyMockTemplate {
/** Mock objects managed by this template */
private final List<Object> mocks = new ArrayList<Object>();

/**
* Constructor.
* @param mocks the mock objects this template will manage.
* @throws IllegalArgumentException if the list of mock objects is null or empty.
* @throws IllegalArgumentException if the list of mock objects contains a null value.
*/
public EasyMockTemplate(Object... mocks) {
if (mocks == null) throw new IllegalArgumentException("The list of mock objects should not be null");
if (mocks.length == 0) throw new IllegalArgumentException("The list of mock objects should not be empty");
for (Object mock : mocks) {
if (mock == null) throw new IllegalArgumentException("The list of mocks should not include null values");
this.mocks.add(mock);
}
}

/**
* Encapsulates the common pattern followed when using EasyMock.
* <ol>
* <li>Set up expectations on the mock objects</li>
* <li>Set the state of the mock controls to "replay"</li>
* <li>Execute the code to test</li>
* <li>Verify that the expectations were met</li>
* </ol>
* Steps 2 and 4 are considered invariant behavior while steps 1 and 3 should be implemented by subclasses of this template.
*/
public final void run() {
setUp();
expectations();
for (Object mock : mocks) replay(mock);
codeToTest();
for (Object mock : mocks) verify(mock);
}

/** Sets the expectations on the mock objects. */
protected abstract void expectations();

/** Executes the code that is under test. */
protected abstract void codeToTest();

/** Sets up the test fixture if necessary. */
protected void setUp() {}
}

@Test public void shouldAddNewEmployee() {
EasyMockTemplate t = new EasyMockTemplate(mockEmployeeDao) {
@Override protected void expectations() {
mockEmployeeDAO.insert(employee);
}

@Override protected void codeToTest() {
employeeBO.addNewEmployee(employee);
}
};
t.run();
}

@Test public void shouldUpdateEmployee() {
EasyMockTemplate t = new EasyMockTemplate(mockEmployeeDao) {
@Override protected void expectations() {
mockEmployeeDAO.update(employee);
}

@Override protected void codeToTest() {
employeeBO.updateEmployee(employee);
}
};
t.run();
}

public final class IgnoreExceptionsCacheManagerDecorator implements CacheManager {

private static final Object NULL = new Object();

private static Logger logger = Logger.getAnonymousLogger();

private final CacheManager decorated;

public IgnoreExceptionsCacheManagerDecorator(CacheManager decorated) {
this.decorated = decorated;
}
public Object getFromCache(String key) {
try {
return decorated.getFromCache(key);
} catch (Exception e) {
logger.log(SEVERE, "Unable to retrieve an object using key \"" + key + "\"", e);
}
return NULL;
}

public void putInCache(String key, Object o) {
try {
decorated.putInCache(key, o);
} catch (Exception e) {
logger.log(SEVERE, "Unable to store the object " + o + " using key \"" + key + "\"", e);
}
}
}

public class IgnoreExceptionsCacheManagerDecoratorTest {

private IgnoreExceptionsCacheManagerDecorator decorator;
private CacheManager decoratedMock;

@Before public void setUp() {
decoratedMock = createMock(CacheManager.class);
decorator = new IgnoreExceptionsCacheManagerDecorator(decoratedMock);
}

@Test public void shouldNotPropagateExceptionFromCache() {
final String key = "name";
final RuntimeException exception = new RuntimeException();
EasyMockTemplate t = new EasyMockTemplate(decoratedMock) {

@Override protected void expectations() {
expect(decoratedMock.getFromCache(key)).andThrow(exception);
}

@Override protected void codeToTest() {
try {
decorator.getFromCache(key);
} catch (Exception e) {
if (e == exception) fail("Should not propagate exception thrown by the cache");
}
assertExceptionWasLogged(exception);
}
};
t.run();
}
}