@Test
public void isSatisfiedShouldSucceedWithValidUrl() throws Exception {
String url = "http://www.citrusframework.org";
String timeout = "3000";
String httpResponseCode = "200";
reset(connection);
when(connection.getResponseCode()).thenReturn(200);
HttpCondition testling =
new HttpCondition() {
@Override
protected HttpURLConnection openConnection(URL url) {
Assert.assertEquals(url.toExternalForm(), "http://www.citrusframework.org");
return connection;
}
};
testling.setUrl(url);
testling.setTimeout(timeout);
testling.setHttpResponseCode(httpResponseCode);
reset(context);
when(context.resolveDynamicValue(url)).thenReturn(url);
when(context.resolveDynamicValue(httpResponseCode)).thenReturn(httpResponseCode);
when(context.resolveDynamicValue(timeout)).thenReturn(timeout);
Assert.assertTrue(testling.isSatisfied(context));
verify(connection).setConnectTimeout(3000);
verify(connection).setRequestMethod("HEAD");
verify(connection).disconnect();
}
@Test
public void testTagSnapshot() throws DataProviderException {
Snapshot snap =
dataProvider.tagSnapshot(branchSnapshot, Optional.of("name"), Optional.of("message"));
assertEquals(branchSnapshot, snap);
verify(notifier, times(1)).snapshotTagged(snap);
verify(notifier, only()).snapshotTagged(snap);
Mockito.reset(notifier);
snap = dataProvider.tagSnapshot(branchSnapshot, Optional.of("name2"), Optional.of("message"));
assertEquals(branchSnapshot, snap);
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
try {
dataProvider.tagSnapshot(branchSnapshot, Optional.of("name4"), Optional.of("message"));
fail("Exception should happen");
} catch (DataProviderException e) {
assertNotNull(e.getMessage());
}
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
Mockito.reset(notifier);
snap = dataProvider.tagSnapshot(branchSnapshot, Optional.of("name3"), Optional.of("message"));
assertNull(snap);
verify(notifier, never()).synchronised();
}
@Before
public void setup() {
Mockito.reset(userAccountRepositoryMock);
Mockito.reset(blogPostRepositoryMock);
Mockito.reset(commentPostRepositoryMock);
super.setup();
}
@Test
public void testDeleteSaveSet() throws DataProviderException {
boolean b = dataProvider.deleteSaveSet(branchSaveSet, "comment");
assertTrue(b);
verify(notifier, times(1)).saveSetDeleted(branchSaveSet);
verify(notifier, only()).saveSetDeleted(branchSaveSet);
Mockito.reset(notifier);
b = dataProvider.deleteSaveSet(branchSaveSet, "comment4");
assertFalse(b);
verify(notifier, never()).synchronised();
Mockito.reset(notifier);
b = dataProvider.deleteSaveSet(branchSaveSet, "comment2");
assertTrue(b);
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
try {
dataProvider.deleteSaveSet(branchSaveSet, "comment3");
fail("Exception should happen");
} catch (DataProviderException e) {
assertNotNull(e.getMessage());
}
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
}
@Test
public void testSaveSnapshot() throws DataProviderException {
VSnapshot snap = dataProvider.saveSnapshot(snapshot, "comment");
assertTrue(snap.equalsExceptSnapshot(snapshot));
verify(notifier, times(1)).snapshotSaved(snap);
verify(notifier, only()).snapshotSaved(snap);
Mockito.reset(notifier);
snap = dataProvider.saveSnapshot(snapshot, "comment2");
assertTrue(snap.equalsExceptSnapshot(snapshot));
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
try {
dataProvider.saveSnapshot(snapshot, "comment4");
fail("Exception should happen");
} catch (DataProviderException e) {
assertNotNull(e.getMessage());
}
verify(notifier, times(1)).synchronised();
verify(notifier, only()).synchronised();
Mockito.reset(notifier);
snap = dataProvider.saveSnapshot(snapshot, "comment3");
assertNull(snap);
verify(notifier, never()).synchronised();
}
@Test
public void testIfNodeIsAddedIfThereWasOnlyOneNodeBefore() throws Exception {
verify(routingTableService, never()).setNextHop(Matchers.<String>any(), Matchers.<String>any());
verify(namingServiceMock, never()).addEntry(Matchers.<NamingEntry>any());
setListenerState(ONE_NODE_ONE_NAME_NO_APPS);
ArgumentCaptor<NamingEntry> namingEntryArgumentCaptor =
ArgumentCaptor.forClass(NamingEntry.class);
verify(namingServiceMock).addEntry(namingEntryArgumentCaptor.capture());
assertEquals("urn:local:0xdcb0", namingEntryArgumentCaptor.getValue().getNodeName());
assertEquals("tcp", namingEntryArgumentCaptor.getValue().getIface().getType());
assertEquals("localhost:8888", namingEntryArgumentCaptor.getValue().getIface().getAddress());
reset(namingServiceMock);
reset(routingTableService);
setListenerState(TWO_NODES_ONE_NAME_NO_APPS);
verify(routingTableService, atLeastOnce()).setNextHop("urn:local:0xdcb2", "urn:local:0xdcb2");
ArgumentCaptor<NamingEntry> namingEntryArgumentCaptor2 =
ArgumentCaptor.forClass(NamingEntry.class);
verify(namingServiceMock).addEntry(namingEntryArgumentCaptor2.capture());
assertEquals("urn:local:0xdcb2", namingEntryArgumentCaptor2.getValue().getNodeName());
assertEquals("tcp", namingEntryArgumentCaptor2.getValue().getIface().getType());
assertEquals("localhost2:8888", namingEntryArgumentCaptor2.getValue().getIface().getAddress());
}
@Test
public void shouldValidateForGracePeriodWithDIPBInterestTypeAndVariableInstallments() {
ActionMessageMatcher actionMessageMatcher =
new ActionMessageMatcher(
ProductDefinitionConstants.INVALID_INTEREST_TYPE_FOR_GRACE_PERIODS);
loanPrdActionForm.setGracePeriodType(GraceType.PRINCIPALONLYGRACE.getValueAsString());
loanPrdActionForm.setCanConfigureVariableInstallments(true);
loanPrdActionForm.setInterestTypes(InterestType.FLAT.getValueAsString());
loanPrdActionForm.validateInterestTypeForGracePeriods(errors, Locale.getDefault());
Mockito.verify(errors).add(Mockito.anyString(), Mockito.argThat(actionMessageMatcher));
Mockito.reset(errors);
loanPrdActionForm.setGracePeriodType(GraceType.PRINCIPALONLYGRACE.getValueAsString());
loanPrdActionForm.setCanConfigureVariableInstallments(false);
loanPrdActionForm.setInterestTypes(InterestType.DECLINING_PB.getValueAsString());
loanPrdActionForm.validateInterestTypeForGracePeriods(errors, Locale.getDefault());
Mockito.verify(errors).add(Mockito.anyString(), Mockito.argThat(actionMessageMatcher));
Mockito.reset(errors);
loanPrdActionForm.setGracePeriodType(GraceType.GRACEONALLREPAYMENTS.getValueAsString());
loanPrdActionForm.setCanConfigureVariableInstallments(true);
loanPrdActionForm.setInterestTypes(InterestType.COMPOUND.getValueAsString());
loanPrdActionForm.validateInterestTypeForGracePeriods(errors, Locale.getDefault());
Mockito.verify(errors).add(Mockito.anyString(), Mockito.argThat(actionMessageMatcher));
Mockito.reset(errors);
loanPrdActionForm.setGracePeriodType(GraceType.NONE.getValueAsString());
loanPrdActionForm.setCanConfigureVariableInstallments(false);
loanPrdActionForm.setInterestTypes(InterestType.DECLINING_EPI.getValueAsString());
loanPrdActionForm.validateInterestTypeForGracePeriods(errors, Locale.getDefault());
Mockito.verifyZeroInteractions(errors);
Mockito.reset(errors);
}
@After
public void tearDown() {
// reset required because mockito gets puzzled with the parameterized JUnit rule
// TODO: better solution?
reset(contextBeforeSetup);
reset(contextAfterSetup);
}
@Test
public void shouldCantUnbombOnBoard() {
shouldBoardWith(new Sapper(1, 1));
assertBoard("☼☼☼☼☼\n" + "☼ ☼\n" + "☼ ☼\n" + "☼☺ ☼\n" + "☼☼☼☼☼\n");
unbombLeft();
verifyNoMoreInteractions(listener);
assertBoard("☼☼☼☼☼\n" + "☼ ☼\n" + "☼ ☼\n" + "☼☺ ☼\n" + "☼☼☼☼☼\n");
unbombDown();
verifyNoMoreInteractions(listener);
assertBoard("☼☼☼☼☼\n" + "☼ ☼\n" + "☼ ☼\n" + "☼☺ ☼\n" + "☼☼☼☼☼\n");
moveRight();
moveRight();
reset(listener);
unbombRight();
verifyNoMoreInteractions(listener);
assertBoard("☼☼☼☼☼\n" + "☼ ☼\n" + "☼ ☼\n" + "☼ ☺☼\n" + "☼☼☼☼☼\n");
moveUp();
moveUp();
reset(listener);
unbombUp();
verifyNoMoreInteractions(listener);
assertBoard("☼☼☼☼☼\n" + "☼ ☺☼\n" + "☼ ☼\n" + "☼ ☼\n" + "☼☼☼☼☼\n");
}
@Test
public void testItAbbreviatesDayNames() {
// simulate Feb month
when(calendar.get(Calendar.DAY_OF_WEEK)).thenReturn(1);
when(calendar.get(Calendar.MONTH)).thenReturn(1);
when(calendar.getActualMaximum(Calendar.DAY_OF_MONTH)).thenReturn(28);
underTest.setGrowProgress(
1000); // set grow progress so that it simulates the calendar being open
underTest.setLocale(Locale.FRANCE);
reset(canvas); // reset because invalidate is called
underTest.setUseWeekDayAbbreviation(true);
reset(canvas); // reset because invalidate is called
underTest.drawMonth(canvas, calendar, 0);
DateFormatSymbols dateFormatSymbols = new DateFormatSymbols(Locale.FRANCE);
String[] dayNames = dateFormatSymbols.getShortWeekdays();
InOrder inOrder = inOrder(canvas);
inOrder.verify(canvas).drawText(eq(dayNames[2]), anyInt(), anyInt(), eq(paint));
inOrder.verify(canvas).drawText(eq(dayNames[3]), anyInt(), anyInt(), eq(paint));
inOrder.verify(canvas).drawText(eq(dayNames[4]), anyInt(), anyInt(), eq(paint));
inOrder.verify(canvas).drawText(eq(dayNames[5]), anyInt(), anyInt(), eq(paint));
inOrder.verify(canvas).drawText(eq(dayNames[6]), anyInt(), anyInt(), eq(paint));
inOrder.verify(canvas).drawText(eq(dayNames[7]), anyInt(), anyInt(), eq(paint));
inOrder.verify(canvas).drawText(eq(dayNames[1]), anyInt(), anyInt(), eq(paint));
}
@Test
public void updateAuthenticatedContributorProfile() {
AuthenticationUtilService tested = getTested();
// case - nobody is authenticated
{
Mockito.when(tested.httpRequest.getUserPrincipal()).thenReturn(null);
Assert.assertFalse(tested.updateAuthenticatedContributorProfile());
Mockito.verifyZeroInteractions(tested.contributorProfileService);
}
Principal p = Mockito.mock(Principal.class);
// case - provider is authenticated
{
Mockito.reset(tested.contributorProfileService, tested.httpRequest);
Mockito.when(tested.httpRequest.getUserPrincipal()).thenReturn(p);
Mockito.when(tested.httpRequest.isUserInRole(Role.PROVIDER)).thenReturn(true);
Assert.assertFalse(tested.updateAuthenticatedContributorProfile());
Mockito.verifyZeroInteractions(tested.contributorProfileService);
}
// case - contributor is authenticated but username not in principal
{
Mockito.reset(tested.contributorProfileService, tested.httpRequest, p);
Mockito.when(tested.httpRequest.getUserPrincipal()).thenReturn(p);
Mockito.when(tested.httpRequest.isUserInRole(Role.CONTRIBUTOR)).thenReturn(true);
Assert.assertFalse(tested.updateAuthenticatedContributorProfile());
Mockito.verifyZeroInteractions(tested.contributorProfileService);
Mockito.verify(p).getName();
}
// case - contributor is authenticated, username is in principal
{
p = new ContributorPrincipal("uname");
Mockito.reset(tested.contributorProfileService, tested.httpRequest);
Mockito.when(tested.httpRequest.getUserPrincipal()).thenReturn(p);
Mockito.when(tested.httpRequest.isUserInRole(Role.CONTRIBUTOR)).thenReturn(true);
Assert.assertTrue(tested.updateAuthenticatedContributorProfile());
Mockito.verify(tested.contributorProfileService)
.createOrUpdateProfile(
ContributorProfileService.FIELD_TSC_JBOSSORG_USERNAME, "uname", false);
Mockito.verifyNoMoreInteractions(tested.contributorProfileService);
}
// case - contributor is authenticated, unsupported type of principal
{
p = Mockito.mock(Principal.class);
Mockito.reset(tested.contributorProfileService, tested.httpRequest);
Mockito.when(tested.httpRequest.getUserPrincipal()).thenReturn(p);
Mockito.when(tested.httpRequest.isUserInRole(Role.CONTRIBUTOR)).thenReturn(true);
Assert.assertFalse(tested.updateAuthenticatedContributorProfile());
Mockito.verifyNoMoreInteractions(tested.contributorProfileService);
}
}
@Test
public void testSetWiperLock() throws IOException {
try {
controller.setWiperLock(null, true);
fail("Got no RuntimeException on calling 'setWiperLock(null, ...)'!");
} catch (RuntimeException e) {
// expected
}
// channel.A -> lock
controller.setWiperLock(DeviceControllerChannel.A, true);
// test for proper write-argument -> see FIGURE 7-7 and TABLE 4-1
verify(i2cDevice).write(new byte[] {(byte) 0b0100100}, 0, 1);
// 'write' called on time
verify(i2cDevice).write(any(byte[].class), anyInt(), anyInt());
// channel.A -> unlock
reset(i2cDevice);
controller.setWiperLock(DeviceControllerChannel.A, false);
// test for proper write-argument -> see FIGURE 7-7 and TABLE 4-1
verify(i2cDevice).write(new byte[] {(byte) 0b0101000}, 0, 1);
// 'write' called on time
verify(i2cDevice).write(any(byte[].class), anyInt(), anyInt());
// channel.B -> lock
reset(i2cDevice);
controller.setWiperLock(DeviceControllerChannel.B, true);
// test for proper write-argument -> see FIGURE 7-7 and TABLE 4-1
verify(i2cDevice).write(new byte[] {(byte) 0b0110100}, 0, 1);
// 'write' called on time
verify(i2cDevice).write(any(byte[].class), anyInt(), anyInt());
// channel.B -> unlock
reset(i2cDevice);
controller.setWiperLock(DeviceControllerChannel.B, false);
// test for proper write-argument -> see FIGURE 7-7 and TABLE 4-1
verify(i2cDevice).write(new byte[] {(byte) 0b0111000}, 0, 1);
// 'write' called on time
verify(i2cDevice).write(any(byte[].class), anyInt(), anyInt());
}
@Test
public void testDecrease() throws IOException {
try {
controller.decrease(null, 1);
fail("Got no RuntimeException on calling 'decrease(null, ...)'!");
} catch (RuntimeException e) {
// expected
}
// zero-step decrease
controller.increase(DeviceControllerChannel.A, 0);
// 'write' called zero times
verify(i2cDevice, times(0)).write(any(byte[].class), anyInt(), anyInt());
// one-step decrease
reset(i2cDevice);
controller.decrease(DeviceControllerChannel.A, 1);
// test for proper write-argument -> see FIGURE 7-7 and TABLE 4-1
verify(i2cDevice).write(new byte[] {(byte) 0b0001000}, 0, 1);
// 'write' called on time
verify(i2cDevice).write(any(byte[].class), anyInt(), anyInt());
// three-step decrease
reset(i2cDevice);
controller.decrease(DeviceControllerChannel.B, 3);
// test for proper write-argument -> see FIGURE 7-7 and TABLE 4-1
verify(i2cDevice)
.write(new byte[] {(byte) 0b0011000, (byte) 0b0011000, (byte) 0b0011000}, 0, 3);
// 'write' called on time
verify(i2cDevice).write(any(byte[].class), anyInt(), anyInt());
// negative-steps decrease
reset(i2cDevice);
controller.decrease(DeviceControllerChannel.A, -1);
// test for proper write-argument -> see FIGURE 7-7 and TABLE 4-1
verify(i2cDevice).write(new byte[] {(byte) 0b0000100}, 0, 1);
// 'write' called on time
verify(i2cDevice).write(any(byte[].class), anyInt(), anyInt());
}
@Before
public void before() {
File dir = new File("target", UUID.randomUUID().toString());
Assert.assertTrue(dir.mkdirs());
System.setProperty(
RuntimeModule.SDC_PROPERTY_PREFIX + RuntimeInfo.DATA_DIR, dir.getAbsolutePath());
Mockito.reset(runtime);
Mockito.reset(logConfigurator);
Mockito.reset(buildInfo);
Mockito.reset(runtimeInfo);
Mockito.reset(task);
}
@Test
@Ignore("TODO: think about how to deal with this limitation")
public void canRemoveListWithSameValuesAndDifferentOne() {
diff(listWith("prems", "prems", "encore"), listWith("prems", "encore"));
final InOrder inOrder = inOrder(dbObjectDiff);
inOrder.verify(dbObjectDiff).pushKey("1");
inOrder.verify(dbObjectDiff).addSet("prems");
inOrder.verify(dbObjectDiff).popKey();
reset(dbObjectDiff);
diff(listWith("encore", "prems", "autre"), listWith("encore", "autre"));
verify(dbObjectDiff).pushKey("1");
reset(dbObjectDiff);
}
@Test
public void changePassword() {
ProviderRestService tested = getTested();
// case entity not found
{
Mockito.when(tested.entityService.get("ahoj")).thenReturn(null);
TestUtils.assertResponseStatus(tested.changePassword("ahoj", "pwd"), Status.NOT_FOUND);
}
// case - provider entity found and is same as caller, caller is not superprovider
{
Mockito.reset(tested.entityService, tested.providerService, tested.securityService);
Map<String, Object> m = new HashMap<String, Object>();
m.put(ProviderService.NAME, "aa");
Mockito.when(tested.entityService.get("aa")).thenReturn(m);
Mockito.when(tested.providerService.isSuperProvider("aa")).thenReturn(false);
Mockito.when(tested.securityService.createPwdHash("aa", "pwd")).thenReturn("pwdhash");
// we also check input password is trimmed!
TestUtils.assertResponseStatus(tested.changePassword("aa", "\n pwd \n"), Status.OK);
Mockito.verify(tested.entityService).update("aa", m);
Assert.assertEquals("pwdhash", m.get(ProviderService.PASSWORD_HASH));
}
// case - provider entity found but is different from caller, caller is not superprovider
{
Mockito.reset(tested.entityService, tested.providerService, tested.securityService);
Map<String, Object> m = new HashMap<String, Object>();
m.put(ProviderService.NAME, "ahoj");
Mockito.when(tested.entityService.get("ahoj")).thenReturn(m);
Mockito.when(tested.providerService.isSuperProvider("aa")).thenReturn(false);
TestUtils.assertResponseStatus(tested.changePassword("ahoj", "pwd"), Status.FORBIDDEN);
Mockito.verify(tested.entityService).get("ahoj");
Mockito.verifyNoMoreInteractions(tested.entityService);
}
// case - provider entity found but is different from caller, caller is superprovider
{
Mockito.reset(tested.entityService, tested.providerService, tested.securityService);
Map<String, Object> m = new HashMap<String, Object>();
m.put(ProviderService.NAME, "ahoj");
Mockito.when(tested.entityService.get("ahoj")).thenReturn(m);
Mockito.when(tested.providerService.isSuperProvider("aa")).thenReturn(true);
Mockito.when(tested.securityService.createPwdHash("ahoj", "pwd")).thenReturn("pwdhash");
TestUtils.assertResponseStatus(tested.changePassword("ahoj", "pwd"), Status.OK);
Mockito.verify(tested.entityService).update("ahoj", m);
Assert.assertEquals("pwdhash", m.get(ProviderService.PASSWORD_HASH));
}
}
@Test
public void testMetaScanner() throws Exception {
LOG.info("Starting testMetaScanner");
setUp();
final TableName TABLENAME = TableName.valueOf("testMetaScanner");
final byte[] FAMILY = Bytes.toBytes("family");
TEST_UTIL.createTable(TABLENAME, FAMILY);
Configuration conf = TEST_UTIL.getConfiguration();
HTable table = (HTable) connection.getTable(TABLENAME);
TEST_UTIL.createMultiRegions(
conf,
table,
FAMILY,
new byte[][] {
HConstants.EMPTY_START_ROW, Bytes.toBytes("region_a"), Bytes.toBytes("region_b")
});
// Make sure all the regions are deployed
TEST_UTIL.countRows(table);
MetaScanner.MetaScannerVisitor visitor = mock(MetaScanner.MetaScannerVisitor.class);
doReturn(true).when(visitor).processRow((Result) anyObject());
// Scanning the entire table should give us three rows
MetaScanner.metaScan(connection, visitor, TABLENAME);
verify(visitor, times(3)).processRow((Result) anyObject());
// Scanning the table with a specified empty start row should also
// give us three hbase:meta rows
reset(visitor);
doReturn(true).when(visitor).processRow((Result) anyObject());
MetaScanner.metaScan(connection, visitor, TABLENAME, HConstants.EMPTY_BYTE_ARRAY, 1000);
verify(visitor, times(3)).processRow((Result) anyObject());
// Scanning the table starting in the middle should give us two rows:
// region_a and region_b
reset(visitor);
doReturn(true).when(visitor).processRow((Result) anyObject());
MetaScanner.metaScan(connection, visitor, TABLENAME, Bytes.toBytes("region_ac"), 1000);
verify(visitor, times(2)).processRow((Result) anyObject());
// Scanning with a limit of 1 should only give us one row
reset(visitor);
doReturn(true).when(visitor).processRow((Result) anyObject());
MetaScanner.metaScan(connection, visitor, TABLENAME, Bytes.toBytes("region_ac"), 1);
verify(visitor, times(1)).processRow((Result) anyObject());
table.close();
}
@Test
public void onBannerCollapsed_shouldRestoreRefreshSettingAndCallAdClosed() throws Exception {
stub(moPubView.getAutorefreshEnabled()).toReturn(true);
subject.onBannerExpanded();
reset(moPubView);
subject.onBannerCollapsed();
verify(moPubView).setAutorefreshEnabled(eq(true));
verify(moPubView).adClosed();
stub(moPubView.getAutorefreshEnabled()).toReturn(false);
subject.onBannerExpanded();
reset(moPubView);
subject.onBannerCollapsed();
verify(moPubView).setAutorefreshEnabled(eq(false));
verify(moPubView).adClosed();
}
@Test
public void testGetPeerAddress() {
Map<String, String> peerMap = new HashMap<>();
peerMap.put("peer1", "peerAddress1");
peerMap.put("peer2", null);
DefaultConfigParamsImpl configParams = new DefaultConfigParamsImpl();
RaftActorContextImpl context =
new RaftActorContextImpl(
actor,
actor.underlyingActor().getContext(),
"test",
new ElectionTermImpl(new NonPersistentDataProvider(), "test", log),
-1,
-1,
peerMap,
configParams,
new NonPersistentDataProvider(),
log);
assertEquals("getPeerAddress", "peerAddress1", context.getPeerAddress("peer1"));
assertEquals("getPeerAddress", null, context.getPeerAddress("peer2"));
PeerAddressResolver mockResolver = mock(PeerAddressResolver.class);
doReturn("peerAddress2").when(mockResolver).resolve("peer2");
doReturn("peerAddress3").when(mockResolver).resolve("peer3");
configParams.setPeerAddressResolver(mockResolver);
assertEquals("getPeerAddress", "peerAddress2", context.getPeerAddress("peer2"));
assertEquals("getPeerAddress", "peerAddress3", context.getPeerAddress("peer3"));
reset(mockResolver);
assertEquals("getPeerAddress", "peerAddress1", context.getPeerAddress("peer1"));
assertEquals("getPeerAddress", "peerAddress2", context.getPeerAddress("peer2"));
verify(mockResolver, never()).resolve(anyString());
}
@Test
public void testTweetNotWorks() throws Exception {
reset(blockingIOProcessor);
clientPair.hardwareClient.send("tweet");
verify(clientPair.hardwareClient.responseMock, timeout(500))
.channelRead(any(), eq(new ResponseMessage(1, NOTIFICATION_INVALID_BODY_EXCEPTION)));
clientPair.hardwareClient.send("tweet ");
verify(clientPair.hardwareClient.responseMock, timeout(500))
.channelRead(any(), eq(new ResponseMessage(2, NOTIFICATION_INVALID_BODY_EXCEPTION)));
StringBuilder a = new StringBuilder();
for (int i = 0; i < 141; i++) {
a.append("a");
}
clientPair.hardwareClient.send("tweet " + a);
verify(clientPair.hardwareClient.responseMock, timeout(500))
.channelRead(any(), eq(new ResponseMessage(3, NOTIFICATION_INVALID_BODY_EXCEPTION)));
clientPair.appClient.send("deactivate 1");
verify(clientPair.appClient.responseMock, timeout(500))
.channelRead(any(), eq(new ResponseMessage(1, OK)));
clientPair.hardwareClient.send("tweet yo");
verify(clientPair.hardwareClient.responseMock, timeout(500))
.channelRead(any(), eq(new ResponseMessage(4, NOTIFICATION_NOT_AUTHORIZED_EXCEPTION)));
}
/**
* TODO: Make this work using a decent animation shadows / newer Robolectric
*
* @throws Exception
*/
@Ignore
@Test
public void onTouchUpAction_eventWhenLeftOverscrolling_smoothScrollBackToRightEnd()
throws Exception {
// Arrange
// Bring UUT to a left-overscroll state
MotionEvent moveEvent = createShortLeftMoveEvent();
when(mViewAdapter.isInAbsoluteStart()).thenReturn(false);
when(mViewAdapter.isInAbsoluteEnd()).thenReturn(true);
HorizontalOverScrollBounceEffectDecorator uut = getUUT();
uut.onTouch(mView, moveEvent);
reset(mView);
// Make the view as though it's been moved by the move event
float viewX = moveEvent.getX();
when(mView.getTranslationX()).thenReturn(viewX);
MotionEvent upEvent = createDefaultUpActionEvent();
// Act
boolean ret = uut.onTouch(mView, upEvent);
// Assert
assertTrue(ret);
verify(mView, atLeastOnce()).setTranslationX(anyFloat());
}
@Test
public void testSuccessfulAuthentication() throws Exception {
when(this.request.getServletPath()).thenReturn("/digestProtectedUri/");
final List<String> digest = new ArrayList<String>();
doAnswer(
new Answer() {
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
digest.add(invocation.getArguments()[1].toString());
return null;
}
})
.when(response)
.setHeader(anyString(), anyString());
when(this.request.getMethod()).thenReturn("GET");
this.securityFilter.doFilter(this.request, this.response, this.filterChain);
assertAuthenticationRequired(SC_UNAUTHORIZED);
prepareAuthenticationRequest("picketlink", "picketlink", digest.get(0));
reset(this.response);
this.securityFilter.doFilter(this.request, this.response, this.filterChain);
Mockito.verify(this.filterChain, times(1))
.doFilter(any(HttpServletRequest.class), any(HttpServletResponse.class));
}
@Test
public void testStatusUpdatingMessageHandler() {
TimelineOperations timelineOperations = Mockito.mock(TimelineOperations.class);
Mockito.when(this.twitter.timelineOperations()).thenReturn(timelineOperations);
ArgumentCaptor<TweetData> argument = ArgumentCaptor.forClass(TweetData.class);
this.in1.send(new GenericMessage<String>("foo"));
Mockito.verify(timelineOperations).updateStatus(argument.capture());
assertEquals("foo", argument.getValue().toRequestParameters().getFirst("status"));
Mockito.reset(timelineOperations);
ClassPathResource media = new ClassPathResource("log4j.properties");
this.in2.send(
MessageBuilder.withPayload(Collections.singletonMap("foo", "bar"))
.setHeader("media", media)
.build());
Mockito.verify(timelineOperations).updateStatus(argument.capture());
TweetData tweetData = argument.getValue();
MultiValueMap<String, Object> requestParameters = tweetData.toRequestParameters();
assertEquals("bar", requestParameters.getFirst("status"));
assertNull(requestParameters.getFirst("media"));
MultiValueMap<String, Object> uploadMediaParameters = tweetData.toUploadMediaParameters();
assertEquals(media, uploadMediaParameters.getFirst("media"));
}
@Test
public void testStateElement() {
ElementLocator locator = mock(ElementLocator.class);
when(locator.findElement()).thenReturn(element1);
WebElement webElement = LocatorProxies.createWebElement(locator);
assertThat(LocatorProxies.present(webElement)).isTrue();
webElement.isEnabled();
when(element1.isEnabled()).thenThrow(StaleElementReferenceException.class);
assertThat(LocatorProxies.present(webElement)).isFalse();
reset(element1);
when(element1.isEnabled()).thenThrow(StaleElementReferenceException.class);
assertThatThrownBy(
new ThrowableAssert.ThrowingCallable() {
@Override
public void call() throws Throwable {
webElement.isEnabled();
}
})
.isExactlyInstanceOf(StaleElementReferenceException.class);
verify(element1, times(6)).isEnabled();
}
@Test
public void otherClientError() throws Exception {
for (int i = 400; i <= 499; i++) {
if (i == 401 || i == 403) {
// covered above.
continue;
}
MockHttpStack mockHttpStack = new MockHttpStack();
BasicHttpResponse fakeResponse =
new BasicHttpResponse(new ProtocolVersion("HTTP", 1, 1), i, "");
mockHttpStack.setResponseToReturn(fakeResponse);
BasicNetwork httpNetwork = new BasicNetwork(mockHttpStack);
Request<String> request = buildRequest();
request.setRetryPolicy(mMockRetryPolicy);
doThrow(new VolleyError()).when(mMockRetryPolicy).retry(any(VolleyError.class));
try {
httpNetwork.performRequest(request);
} catch (VolleyError e) {
// expected
}
// should not retry other 400 errors.
verify(mMockRetryPolicy, never()).retry(any(VolleyError.class));
reset(mMockRetryPolicy);
}
}
@SuppressWarnings("rawtypes")
@Test
public void withHeaderMapper() throws Exception {
Object pollingConsumer = context.getBean("withHeaderMapper");
assertTrue(pollingConsumer instanceof PollingConsumer);
assertEquals(headerMapper, TestUtils.getPropertyValue(pollingConsumer, "handler.headerMapper"));
MessageChannel channel = context.getBean("outboundEventChannel", MessageChannel.class);
Message<?> message =
MessageBuilder.withPayload("hello")
.setHeader(XmppHeaders.TO, "oleg")
.setHeader("foobar", "foobar")
.build();
XMPPConnection connection = context.getBean("testConnection", XMPPConnection.class);
doAnswer(
invocation -> {
Object[] args = invocation.getArguments();
org.jivesoftware.smack.packet.Message xmppMessage =
(org.jivesoftware.smack.packet.Message) args[0];
assertEquals("oleg", xmppMessage.getTo());
assertEquals("foobar", JivePropertiesManager.getProperty(xmppMessage, "foobar"));
return null;
})
.when(connection)
.sendStanza(Mockito.any(org.jivesoftware.smack.packet.Message.class));
channel.send(message);
verify(connection, times(1))
.sendStanza(Mockito.any(org.jivesoftware.smack.packet.Message.class));
Mockito.reset(connection);
}
@Test
public void testSendBuilderWithDictionary() {
final DataDictionary dictionary = new NodeMappingDataDictionary();
reset(applicationContextMock);
when(applicationContextMock.getBean(TestActionListeners.class))
.thenReturn(new TestActionListeners());
when(applicationContextMock.getBeansOfType(SequenceBeforeTest.class))
.thenReturn(new HashMap<String, SequenceBeforeTest>());
when(applicationContextMock.getBeansOfType(SequenceAfterTest.class))
.thenReturn(new HashMap<String, SequenceAfterTest>());
MockTestDesigner builder =
new MockTestDesigner(applicationContext) {
@Override
public void configure() {
send(messageEndpoint)
.payload("{ \"TestRequest\": { \"Message\": \"?\" }}")
.dictionary(dictionary);
}
};
builder.configure();
TestCase test = builder.getTestCase();
Assert.assertEquals(test.getActionCount(), 1);
Assert.assertEquals(test.getActions().get(0).getClass(), SendMessageAction.class);
SendMessageAction action = ((SendMessageAction) test.getActions().get(0));
Assert.assertEquals(action.getName(), "send");
Assert.assertEquals(action.getEndpoint(), messageEndpoint);
Assert.assertEquals(action.getDataDictionary(), dictionary);
}
@Test
public void testSendBuilderWithEndpointName() {
reset(applicationContextMock);
when(applicationContextMock.getBean(TestActionListeners.class))
.thenReturn(new TestActionListeners());
when(applicationContextMock.getBeansOfType(SequenceBeforeTest.class))
.thenReturn(new HashMap<String, SequenceBeforeTest>());
when(applicationContextMock.getBeansOfType(SequenceAfterTest.class))
.thenReturn(new HashMap<String, SequenceAfterTest>());
MockTestDesigner builder =
new MockTestDesigner(applicationContextMock) {
@Override
public void configure() {
send("fooMessageEndpoint")
.payload("<TestRequest><Message>Hello World!</Message></TestRequest>");
}
};
builder.configure();
TestCase test = builder.getTestCase();
Assert.assertEquals(test.getActionCount(), 1);
Assert.assertEquals(test.getActions().get(0).getClass(), SendMessageAction.class);
SendMessageAction action = ((SendMessageAction) test.getActions().get(0));
Assert.assertEquals(action.getName(), "send");
Assert.assertEquals(action.getEndpointUri(), "fooMessageEndpoint");
}
@Test
public void testSendBuilderWithPayloadResource() throws IOException {
MockTestDesigner builder =
new MockTestDesigner(applicationContext) {
@Override
public void configure() {
send(messageEndpoint).payload(resource);
}
};
reset(resource);
when(resource.getInputStream())
.thenReturn(new ByteArrayInputStream("somePayloadData".getBytes()));
builder.configure();
TestCase test = builder.getTestCase();
Assert.assertEquals(test.getActionCount(), 1);
Assert.assertEquals(test.getActions().get(0).getClass(), SendMessageAction.class);
SendMessageAction action = ((SendMessageAction) test.getActions().get(0));
Assert.assertEquals(action.getName(), "send");
Assert.assertEquals(action.getEndpoint(), messageEndpoint);
Assert.assertEquals(action.getMessageBuilder().getClass(), PayloadTemplateMessageBuilder.class);
PayloadTemplateMessageBuilder messageBuilder =
(PayloadTemplateMessageBuilder) action.getMessageBuilder();
Assert.assertEquals(messageBuilder.getPayloadData(), "somePayloadData");
Assert.assertEquals(messageBuilder.getMessageHeaders().size(), 0L);
}
@Before
public void setup() throws Exception {
// TODO: figure out how initialization can be refactored with @InjectMocks
final StorageNode n = new StorageNode("node1", storage);
node = spy(n);
nodeContext = new StorageExecutionContext(communicationContext, node);
nodeContext = spy(nodeContext);
n.configure(nodeContext);
node.configure(nodeContext);
Mockito.reset(node);
verifyZeroInteractions(nodeContext);
verifyZeroInteractions(storage);
verifyZeroInteractions(node);
assertEquals("node1", node.getId());
assertEquals("NEW", node.getState());
// verify(node, atLeastOnce()).getId();
// verify(node).getState();
verifyZeroInteractions(nodeContext, storage, node);
doAnswer(
invocation -> {
final StorageOperation op = (StorageOperation) invocation.getArguments()[0];
doReturn(op).when(operationContext).operation();
return operationContext;
})
.when(nodeContext)
.contextFor(any(StorageOperation.class));
}
