@Nonnull @Override public First<M, F> init(M model) { logger.beforeInit(model); First<M, F> result = safeInvokeInit(model); logger.afterInit(model, result); return result; }
@Nonnull @Override public Next<M, F> update(M model, E event) { logger.beforeUpdate(model, event); Next<M, F> result = safeInvokeUpdate(model, event); logger.afterUpdate(model, event, result); return result; }
@Test public void delegatesAfterUpdateToAllLoggers() { AfterUpdate<String, Integer, String> testCase = AfterUpdate.create("Hello", 5, next("World", singleton("test"))); underTest.afterUpdate(testCase.model(), testCase.event(), testCase.next()); assertTestCaseLogged(testCase); }
private Next<M, F> safeInvokeUpdate(M model, E event) { try { return actualUpdate.update(model, event); } catch (Exception e) { logger.exceptionDuringUpdate(model, event, e); throw Throwables.propagate(e); } } }
private First<M, F> safeInvokeInit(M model) { try { return actualInit.init(model); } catch (Exception e) { logger.exceptionDuringInit(model, e); throw Throwables.propagate(e); } } }
@Override public void exceptionDuringInit(M model, Throwable exception) { for (Logger<M, E, F> logger : loggers) { logger.exceptionDuringInit(model, exception); } }
@Test public void delegatesExceptionDuringUpdateToAllLoggers() throws InstantiationException, IllegalAccessException { ExceptionDuringUpdate<String, Integer> testCase = ExceptionDuringUpdate.create("Something bad happened", 6, Exception.class); underTest.exceptionDuringUpdate(testCase.model(), testCase.event(), testCase.createException()); assertTestCaseLogged(testCase); }
@Test public void delegatesBeforeInitToAllLoggers() { BeforeInit<String> testCase = BeforeInit.create("Hello"); underTest.beforeInit(testCase.model()); assertTestCaseLogged(testCase); }
private First<M, F> safeInvokeInit(M model) { try { return actualInit.init(model); } catch (Exception e) { logger.exceptionDuringInit(model, e); throw Throwables.propagate(e); } } }
private Next<M, F> safeInvokeUpdate(M model, E event) { try { return actualUpdate.update(model, event); } catch (Exception e) { logger.exceptionDuringUpdate(model, event, e); throw Throwables.propagate(e); } } }
@Nonnull @Override public First<M, F> init(M model) { logger.beforeInit(model); First<M, F> result = safeInvokeInit(model); logger.afterInit(model, result); return result; }
@Override public void exceptionDuringUpdate(M model, E event, Throwable exception) { for (Logger<M, E, F> logger : loggers) { logger.exceptionDuringUpdate(model, event, exception); } } }
@Override public void afterUpdate(M model, E event, Next<M, F> result) { for (Logger<M, E, F> logger : loggers) { logger.afterUpdate(model, event, result); } }
@Override public void beforeUpdate(M model, E event) { for (Logger<M, E, F> logger : loggers) { logger.beforeUpdate(model, event); } }
@Test public void delegatesAfterInitToAllLoggers() { AfterInit<String, String> testCase = AfterInit.create("Hello", First.<String, String>first("World")); underTest.afterInit(testCase.model(), testCase.first()); assertTestCaseLogged(testCase); }
@Override public void beforeInit(M model) { for (Logger<M, E, F> logger : loggers) { logger.beforeInit(model); } }
@Override public void afterInit(M model, First<M, F> result) { for (Logger<M, E, F> logger : loggers) { logger.afterInit(model, result); } }
@Test public void delegatesBeforeUpdateToAllLoggers() { BeforeUpdate<String, Integer> testCase = BeforeUpdate.create("Hello", 5); underTest.beforeUpdate(testCase.model(), testCase.event()); assertTestCaseLogged(testCase); }
@Test public void delegatesExceptionDuringInitToAllLoggers() throws Exception { ExceptionDuringInit<String> testCase = ExceptionDuringInit.create("I'm broken", Exception.class); underTest.exceptionDuringInit(testCase.model(), testCase.createException()); assertTestCaseLogged(testCase); }
@Nonnull @Override public Next<M, F> update(M model, E event) { logger.beforeUpdate(model, event); Next<M, F> result = safeInvokeUpdate(model, event); logger.afterUpdate(model, event, result); return result; }