@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); }