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