@Test
public void testLoadAndSaveAggregate() {
UUID identifier = UUID.randomUUID();
DomainEventMessage event1 =
new GenericDomainEventMessage<String>(
identifier, (long) 1, "Mock contents", MetaData.emptyInstance());
DomainEventMessage event2 =
new GenericDomainEventMessage<String>(
identifier, (long) 2, "Mock contents", MetaData.emptyInstance());
when(mockEventStore.readEvents("test", identifier))
.thenReturn(new SimpleDomainEventStream(event1, event2));
TestAggregate aggregate = testSubject.load(identifier, null);
assertEquals(0, aggregate.getUncommittedEventCount());
assertEquals(2, aggregate.getHandledEvents().size());
assertSame(event1, aggregate.getHandledEvents().get(0));
assertSame(event2, aggregate.getHandledEvents().get(1));
// now the aggregate is loaded (and hopefully correctly locked)
StubDomainEvent event3 = new StubDomainEvent();
aggregate.apply(event3);
CurrentUnitOfWork.commit();
verify(mockEventBus).publish(isA(DomainEventMessage.class));
verify(mockEventBus, never()).publish(event1);
verify(mockEventBus, never()).publish(event2);
verify(mockEventStore, times(1)).appendEvents(eq("test"), isA(DomainEventStream.class));
assertEquals(0, aggregate.getUncommittedEventCount());
}
/**
* Verifies that we find the correct results for the following constellation.
*
* <ol>
* <li>Build with result, build result = SUCCESS
* <li>Build with no result
* <li>Build with result, build result = FAILURE
* <li>Build with no result
* <li>Baseline
* </ol>
*
* @throws Exception the exception
*/
@SuppressWarnings("rawtypes")
@Test
public void testHasReferenceResult() throws Exception {
AbstractBuild withSuccessResult = mock(AbstractBuild.class);
AbstractBuild noResult2 = mock(AbstractBuild.class);
AbstractBuild withFailureResult = mock(AbstractBuild.class);
AbstractBuild noResult1 = mock(AbstractBuild.class);
AbstractBuild baseline = mock(AbstractBuild.class);
when(baseline.getPreviousBuild()).thenReturn(noResult1);
when(noResult1.getPreviousBuild()).thenReturn(withFailureResult);
when(withFailureResult.getPreviousBuild()).thenReturn(noResult2);
when(noResult2.getPreviousBuild()).thenReturn(withSuccessResult);
TestResultAction failureAction = mock(TestResultAction.class);
when(withFailureResult.getAction(TestResultAction.class)).thenReturn(failureAction);
when(failureAction.isSuccessful()).thenReturn(false);
BuildResult failureResult = mock(BuildResult.class);
when(failureAction.getResult()).thenReturn(failureResult);
TestResultAction successAction = mock(TestResultAction.class);
when(withSuccessResult.getAction(TestResultAction.class)).thenReturn(successAction);
when(successAction.isSuccessful()).thenReturn(true);
BuildResult successResult = mock(BuildResult.class);
AnnotationContainer container = mock(AnnotationContainer.class);
when(successResult.getContainer()).thenReturn(container);
when(successAction.getResult()).thenReturn(successResult);
BuildHistory history = createHistory(baseline);
assertTrue("Build has no previous result", history.hasPreviousResult());
assertSame("Build has wrong previous result", failureResult, history.getPreviousResult());
assertSame("Build has wrong reference result", container, history.getReferenceAnnotations());
}
@Test
public void testFormAdd() throws Exception {
Form form = new Form(request);
assertEquals(0, form.size());
Button button = Button.button("OK");
form.add(button);
assertEquals(1, form.size());
TextField field = new TextField("name");
form.add(field, "Name");
form.add(null); // ignored
form.add(null, "Name"); // ignored
assertEquals(2, form.size());
assertSame(field, form.get(1));
assertSame(field, form.get("name"));
assertNull(form.get("x"));
assertNull(form.get(null));
try {
// cannot add twice
form.add(field);
fail();
} catch (IllegalStateException e) {
}
form.setRequired(true);
assertTrue(field.isRequired());
form.setReadOnly(true);
assertTrue(field.isReadOnly());
assertTrue(form.validate(true));
form.remove(field);
assertEquals(1, form.size());
}
@Test
public void testButton() {
Form form = new Form(request);
Button button;
button = Button.button("OK");
assertOut(button, "<button>OK</button>");
assertEquals(null, button.getName());
form.add(button);
assertEquals(form.getName() + "_button", button.getName());
button = Button.reset("Reset");
button.setDisabled();
assertOut(button, "<button type='reset' disabled>Reset</button>");
button = Button.submit("Submit");
button.setName("submit");
assertOut(button, "<button type='submit' name='submit' value='Submit'>Submit</button>");
form.add(button);
assertEquals("submit", button.getName());
Button defaultButton = button;
assertSame(form.getDefaultButton(), button);
button = Button.inputButton("OK");
assertOut(button, "<input type='button' value='OK'>");
button = Button.inputReset("Reset");
assertOut(button, "<input type='reset' value='Reset'>");
button = Button.inputSubmit("Submit");
button.setOnClick("alert()");
assertOut(button, "<input type='submit' value='Submit' onclick='alert()'>");
button.end(out);
out.assertOut("");
form.add(button);
assertSame(defaultButton, form.getDefaultButton());
// misc
assertTrue(button.read(null));
assertEquals(Control.Category.BUTTON, button.getCategory());
assertFalse(defaultButton.isClicked());
setParam(form.getName(), "");
assertTrue(defaultButton.isClicked());
assertFalse(button.isClicked());
setParam(form.getName(), "reload");
assertFalse(defaultButton.isClicked());
setParam(defaultButton.getName(), "x");
assertFalse(defaultButton.isClicked());
setParam(defaultButton.getName(), defaultButton.getValue());
assertTrue(defaultButton.isClicked());
setParam(defaultButton.getName(), null);
assertFalse(defaultButton.isDirectlyClicked());
setParam(defaultButton.getName(), "x");
assertFalse(defaultButton.isDirectlyClicked());
setParam(defaultButton.getName(), defaultButton.getValue());
assertTrue(defaultButton.isDirectlyClicked());
}
@Test
public void testTextField() {
TextField field = new TextField("email");
assertEquals("email", field.getName());
assertEquals("text", field.getInputType());
field.setInputType(TextField.INPUT_TYPE_EMAIL);
assertEquals("email", field.getInputType());
assertSame(field, field.toFocusControl());
assertSame(field, field.toInputField());
assertEquals(0, field.getMaxLength());
assertEquals(0, field.getSize());
field.setMaxLength(100);
assertEquals(50, field.getSize());
assertEquals(100, field.getMaxLength());
field.setSize(25);
assertEquals(25, field.getSize());
assertEquals(100, field.getMaxLength());
assertNull(field.getPattern());
field.setPattern("*@*");
assertEquals("*@*", field.getPattern());
assertNull(field.getPlaceholder());
field.setPlaceholder("enter email");
assertEquals("enter email", field.getPlaceholder());
assertNull(field.getId());
field.setId("xyz");
assertEquals("xyz", field.getId());
assertEquals("", field.getLabel());
assertFalse(field.hasLabel());
field.setLabel("label");
assertEquals("label", field.getLabel());
field.setLabel(null);
assertEquals("", field.getLabel());
assertNull(field.getData());
field.setData(this);
assertSame(this, field.getData());
assertEquals(1, field.getRows());
assertEquals(Control.Category.INPUT, field.getCategory());
assertEquals("", field.format());
assertEquals("TextField[email=null]", field.toString());
assertOut(
field,
"<input type='email' name='email' value='' size='25' maxlength='100' id='xyz' placeholder='enter email' pattern='*@*'>");
}
@Test
public void testGetBlueprint() throws Exception {
assertNotNull(crs.getBlueprint());
assertNotNull(irs.getBlueprint());
assertNotNull(drs.getBlueprint());
assertSame(crs.getModel(), irs.getModel());
assertSame(drs.getModel(), irs.getModel());
}
@Test
public void nextZeroWeight() {
Balancer<Void, MockDatabase> balancer =
this.factory.createBalancer(Collections.singleton(this.databases[0]));
assertSame(this.databases[0], balancer.next());
}
@Test
@SuppressWarnings("unchecked")
public void testDoWithRetry_ReadTimeOut() throws Exception {
AmazonElasticMapReduceCustomClient client =
new AmazonElasticMapReduceCustomClient("dummy", "dummy");
client.setRequestInterval(100);
Callable callable = mock(Callable.class);
AmazonClientException exception =
new AmazonClientException("Unable to execute HTTP request: Read timed out");
when(callable.call()).thenThrow(exception, exception, exception).thenReturn(new Object());
long startTime = System.currentTimeMillis();
Object result = client.doThrottleSafe(callable);
assertNotNull(result);
assertThat(
(System.currentTimeMillis() - startTime),
greaterThanOrEqualTo(3 * client.getRequestInterval()));
// now exceed retries
client.setMaxRetriesOnConnectionErrors(2);
when(callable.call()).thenThrow(exception, exception, exception).thenReturn(new Object());
try {
client.doThrottleSafe(callable);
fail("should throw exception");
} catch (Exception e) {
assertSame(exception, e);
}
}
@Test
public void getService_MUST_return_the_same_instance_WHEN_in_dev_mode() throws Exception {
doReturn(Mode.DEV).when(configurationSource()).runMode();
try (TemporaryPlayApplication ignored = new TemporaryPlayApplication()) {
assertSame(serviceLoader.getService(), serviceLoader.getService());
}
}
@Test
public void whenPostCommitTaskFails_exceptionThrown() {
Transaction tx = new AbstractTransactionImpl();
tx.start();
RuntimeException exception = new RuntimeException();
TransactionLifecycleListener listener = mock(TransactionLifecycleListener.class);
doThrow(exception).when(listener).notify(tx, TransactionLifecycleEvent.PostCommit);
tx.registerLifecycleListener(listener);
try {
tx.commit();
fail();
} catch (RuntimeException found) {
assertSame(exception, found);
}
assertIsCommitted(tx);
verify(listener, times(1)).notify(tx, TransactionLifecycleEvent.PreCommit);
verify(listener, times(1)).notify(tx, TransactionLifecycleEvent.PostCommit);
verify(listener, times(0)).notify(tx, TransactionLifecycleEvent.PreAbort);
verify(listener, times(0)).notify(tx, TransactionLifecycleEvent.PostAbort);
}
@Test
public void enhanceShouldNotEnhanceTwice() {
ResultSet mockResultSet = mock(ResultSet.class);
EnhancedResultSet enhanced1 = ResultSets.enhance(mockResultSet);
EnhancedResultSet enhanced2 = ResultSets.enhance(enhanced1);
assertSame(enhanced1, enhanced2);
}
@Test
public void whenFromClassThenTheSourceIsSetToTheSameTypeAndName() {
context.from(Date.class);
CallSource source = context.getConfiguredCallSource();
assertSame(Date.class, source.getType());
assertEquals(Date.class.getName(), source.getName());
}
/** Test method for {@link CriterionParser#parse()}. */
@Test
public void testParse() {
setField(testParser, METRIC_DAO_FIELD, mockMetricDao);
when(mockMetricDao.findMetricByName(METRIC_NAME)).thenReturn(METRIC_1);
assertSame(METRIC_1, testParser.parse().getMetric());
assertEquals(AMOUNT, testParser.parse().getAmount(), 0);
assertEquals(DAYS * 7, testParser.parse().getDays());
}
/**
* expect an XmppException with the desired XmppError would be thrown while the State parameter
* handles the xml string
*
* @param state
* @param xml
* @param error
*/
protected void expectXmppException(State state, String xml, XmppError error) {
try {
state.step(context, xml);
fail("Should throw an XmppException");
} catch (XmppException e) {
assertSame(error, e.getXmppError());
}
}
@Test
public void testStartupSuccess() throws Exception {
VistaAuthenticationProvider provider = new VistaAuthenticationProvider();
provider.setUserDetailsService(mockUserDetailService);
provider.setUserCache(new MockUserCache());
assertSame(mockUserDetailService, provider.getUserDetailsService());
provider.afterPropertiesSet();
}
@Test
public void spr14853AdaptsToOptionalWithSync() {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(Spr14853Config.class);
Spr14853Service bean = context.getBean(Spr14853Service.class);
Cache cache = context.getBean(CacheManager.class).getCache("itemCache");
TestBean tb = new TestBean("tb1");
bean.insertItem(tb);
assertSame(tb, bean.findById("tb1").get());
assertSame(tb, cache.get("tb1").get());
cache.clear();
TestBean tb2 = bean.findById("tb1").get();
assertNotSame(tb, tb2);
assertSame(tb2, cache.get("tb1").get());
}
@Test
public void spr11249() throws Exception {
AnnotationConfigApplicationContext context =
new AnnotationConfigApplicationContext(Spr11249Config.class);
Spr11249Service bean = context.getBean(Spr11249Service.class);
Object result = bean.doSomething("op", 2, 3);
assertSame(result, bean.doSomething("op", 2, 3));
context.close();
}
@Test
public void testClosed() throws Exception {
IoUtil.close(null);
IOException e = new IOException();
Closeable c = mock(Closeable.class);
doThrow(e).when(c).close();
assertSame(e, IoUtil.close(c));
}
@Test
public void setAndGetCacheable() {
MessageSourceMacroDescriptor desc = descriptor.cacheable(true);
assertSame(descriptor, desc);
assertTrue(descriptor.isCacheable());
descriptor.cacheable(false);
assertFalse(descriptor.isCacheable());
}
public void test_getInstance() {
DaoInvokerFactory factory = DaoInvokerFactory.getInstance();
assertNotNull(factory);
DaoInvokerFactory factory2 = DaoInvokerFactory.getInstance();
assertSame(factory, factory2);
}
@Test
public void nextSingleWeight() {
Balancer<Void, MockDatabase> balancer =
this.factory.createBalancer(
new HashSet<MockDatabase>(Arrays.asList(this.databases[0], this.databases[1])));
assertSame(this.databases[1], balancer.next());
int count = 10;
CountDownLatch latch = new CountDownLatch(count);
WaitingInvoker invoker = new WaitingInvoker(latch);
ExecutorService executor = Executors.newFixedThreadPool(count);
List<Future<Void>> futures = new ArrayList<Future<Void>>(count);
for (int i = 0; i < count; ++i) {
futures.add(executor.submit(new InvocationTask(balancer, invoker, this.databases[1])));
}
try {
// Ensure all invokers are started
latch.await();
// Should still use the same database, even under load
assertSame(this.databases[1], balancer.next());
// Allow invokers to continue
synchronized (invoker) {
invoker.notifyAll();
}
this.complete(futures);
// Should still use the same database, after load
assertSame(this.databases[1], balancer.next());
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
} finally {
executor.shutdownNow();
}
}
@Test
public void getItemShouldIgnoreMeAfterSort() {
final User penny = new User("Penny", 1);
final User amy = new User("Amy", 2);
final User que = new User("Que", 3);
final User fido = new User("Fido", 4);
adapter.add(me);
adapter.add(penny);
adapter.add(amy);
adapter.add(que);
adapter.add(fido);
assertEquals(4, adapter.getCount());
assertSame(amy, adapter.getItem(0));
assertSame(fido, adapter.getItem(1));
assertSame(penny, adapter.getItem(2));
assertSame(que, adapter.getItem(3));
}
@Test
public void getItemShouldIgnoreMe() {
final User test1 = new User("Test1", 1);
final User test2 = new User("Test2", 2);
final User test3 = new User("Test3", 3);
final User test4 = new User("Test4", 4);
adapter.add(test1);
adapter.add(test2);
adapter.add(me);
adapter.add(test3);
adapter.add(test4);
assertEquals(4, adapter.getCount());
assertSame(test1, adapter.getItem(0));
assertSame(test2, adapter.getItem(1));
assertSame(test3, adapter.getItem(2));
assertSame(test4, adapter.getItem(3));
}
@Test
public void testLoad_FirstEventIsSnapshot() {
UUID identifier = UUID.randomUUID();
TestAggregate aggregate = new TestAggregate(identifier);
when(mockEventStore.readEvents("test", identifier))
.thenReturn(
new SimpleDomainEventStream(
new GenericDomainEventMessage<AggregateSnapshot<TestAggregate>>(
identifier, 10, new AggregateSnapshot<TestAggregate>(aggregate))));
assertSame(aggregate, testSubject.load(identifier));
}
@Test
public void resolveExceptionShouldSetCountries() {
long maxUploadSize = 1000;
setUpPlayerProfile();
final ModelAndView modelAndViewUnderTest =
underTest.resolveException(
request, response, null, new MaxUploadSizeExceededException(maxUploadSize));
assertSame(
countryRepository.getCountries(), modelAndViewUnderTest.getModelMap().get("countries"));
}
/**
* Verifies that we find the correct results for the following constellation.
*
* <ol>
* <li>Build with result
* <li>Build with no result
* <li>Baseline
* </ol>
*
* @throws Exception the exception
*/
@Test
@SuppressWarnings("rawtypes")
public void testHasPreviousResult() throws Exception {
AbstractBuild withResult = mock(AbstractBuild.class);
AbstractBuild noResult = mock(AbstractBuild.class);
AbstractBuild baseline = mock(AbstractBuild.class);
when(baseline.getPreviousBuild()).thenReturn(noResult);
when(noResult.getPreviousBuild()).thenReturn(withResult);
TestResultAction action = mock(TestResultAction.class);
when(withResult.getAction(TestResultAction.class)).thenReturn(action);
BuildResult result = mock(BuildResult.class);
when(action.getResult()).thenReturn(result);
AnnotationContainer container = mock(AnnotationContainer.class);
when(result.getContainer()).thenReturn(container);
BuildHistory history = createHistory(baseline);
assertTrue("Build has no previous result", history.hasPreviousResult());
assertSame("Build has wrong previous result", result, history.getPreviousResult());
assertSame("Build has wrong reference result", container, history.getReferenceAnnotations());
}
@Test
public void testConstructor() {
SerializedEventMessage<Object> message1 =
new SerializedEventMessage<Object>(
eventId, timestamp, serializedPayload, serializedMetaData, serializer);
assertSame(MetaData.emptyInstance(), message1.getMetaData());
assertEquals(Object.class, message1.getPayloadType());
assertFalse(message1.isPayloadDeserialized());
assertEquals(Object.class, message1.getPayload().getClass());
assertTrue(message1.isPayloadDeserialized());
}
@Test
public void backups() {
Balancer<Void, MockDatabase> balancer =
this.factory.createBalancer(Collections.<MockDatabase>emptySet());
Iterable<MockDatabase> result = balancer.backups();
assertNotNull(result);
Iterator<MockDatabase> backups = result.iterator();
assertFalse(backups.hasNext());
balancer = this.factory.createBalancer(Collections.singleton(this.databases[0]));
result = balancer.backups();
assertNotNull(result);
backups = result.iterator();
assertFalse(backups.hasNext());
balancer =
this.factory.createBalancer(
new HashSet<MockDatabase>(Arrays.asList(this.databases[0], this.databases[1])));
result = balancer.backups();
assertNotNull(result);
backups = result.iterator();
assertTrue(backups.hasNext());
assertSame(this.databases[1], backups.next());
assertFalse(backups.hasNext());
balancer =
this.factory.createBalancer(new HashSet<MockDatabase>(Arrays.asList(this.databases)));
result = balancer.backups();
assertNotNull(result);
backups = result.iterator();
assertTrue(backups.hasNext());
assertSame(this.databases[1], backups.next());
assertTrue(backups.hasNext());
assertSame(this.databases[2], backups.next());
assertFalse(backups.hasNext());
}
@Test
public void testSelect() {
Select<String> select = new Select<>("name", KEYS);
assertSame(KEYS, select.getKeyList());
assertEquals(0, select.getRows());
select.setRows(1);
assertEquals(1, select.getRows());
assertSame(select, select.toFocusControl());
assertFalse(select.useOptionGroups());
select.setUseOptionGroups(true);
assertTrue(select.useOptionGroups());
select.setUseOptionGroups(false);
assertFalse(select.useOptionGroups());
assertEquals(-1, select.getSelectedIndex());
assertEquals(null, select.getSelectedText());
when(request.getParameter(select.getName())).thenReturn(null);
assertTrue(select.read(request));
select.setRequired(true);
assertFalse(select.read(request));
when(request.getParameter(select.getName())).thenReturn("a");
assertTrue(select.read(request));
assertEquals("a", select.getValue());
when(request.getParameter(select.getName())).thenReturn("x");
assertFalse(select.read(request));
assertNull(select.getValue());
assertEquals("x", select.getErrorValue());
Select<String> select2 = new Select<>("name2", KeyLists.<String>empty());
assertOut(select2, "<select name='name2'>\n\t<option value=''></option>\n</select>");
select2.removeDefaultOption();
select2.setDisabled();
select2.setRows(2);
assertOut(select2, "<select name='name2' size='2' disabled>\n</select>");
}
/**
* Test method for {@link
* net.sf.hajdbc.balancer.load.LoadBalancer#invoke(net.sf.hajdbc.invocation.Invoker,
* net.sf.hajdbc.Database, java.lang.Object)}.
*/
@Test
public void invoke() throws Exception {
TestInvoker invoker = mock(TestInvoker.class);
Object object = new Object();
Object expected = new Object();
Exception expectedException = new Exception();
Balancer<Void, MockDatabase> balancer =
this.factory.createBalancer(new HashSet<MockDatabase>(Arrays.asList(this.databases)));
when(invoker.invoke(this.databases[0], object)).thenReturn(expected);
Object result = null;
Exception exception = null;
try {
result = balancer.invoke(invoker, this.databases[0], object);
} catch (Exception e) {
exception = e;
}
assertSame(expected, result);
assertNull(exception);
reset(invoker);
when(invoker.invoke(this.databases[0], object)).thenThrow(expectedException);
result = null;
exception = null;
try {
result = balancer.invoke(invoker, this.databases[0], object);
} catch (Exception e) {
exception = e;
}
assertNull(result);
assertSame(expectedException, exception);
}
