/** * Calls {@link #getMockedConnection(Configuration)} and then mocks a few more of the popular * {@link ClusterConnection} methods so they do 'normal' operation (see return doc below for * list). Be sure to shutdown the connection when done by calling {@link Connection#close()} else * it will stick around; this is probably not what you want. * * @param conf Configuration to use * @param admin An AdminProtocol; can be null but is usually itself a mock. * @param client A ClientProtocol; can be null but is usually itself a mock. * @param sn ServerName to include in the region location returned by this <code>connection</code> * @param hri HRegionInfo to include in the location returned when getRegionLocator is called on * the mocked connection * @return Mock up a connection that returns a {@link Configuration} when {@link * ClusterConnection#getConfiguration()} is called, a 'location' when {@link * ClusterConnection#getRegionLocation(org.apache.hadoop.hbase.TableName, byte[], boolean)} is * called, and that returns the passed {@link AdminProtos.AdminService.BlockingInterface} * instance when {@link ClusterConnection#getAdmin(ServerName)} is called, returns the passed * {@link ClientProtos.ClientService.BlockingInterface} instance when {@link * ClusterConnection#getClient(ServerName)} is called (Be sure to call {@link * Connection#close()} when done with this mocked Connection. * @throws IOException */ public static ClusterConnection getMockedConnectionAndDecorate( final Configuration conf, final AdminProtos.AdminService.BlockingInterface admin, final ClientProtos.ClientService.BlockingInterface client, final ServerName sn, final HRegionInfo hri) throws IOException { ConnectionImplementation c = Mockito.mock(ConnectionImplementation.class); Mockito.when(c.getConfiguration()).thenReturn(conf); Mockito.doNothing().when(c).close(); // Make it so we return a particular location when asked. final HRegionLocation loc = new HRegionLocation(hri, sn); Mockito.when( c.getRegionLocation( (TableName) Mockito.any(), (byte[]) Mockito.any(), Mockito.anyBoolean())) .thenReturn(loc); Mockito.when(c.locateRegion((TableName) Mockito.any(), (byte[]) Mockito.any())).thenReturn(loc); Mockito.when( c.locateRegion( (TableName) Mockito.any(), (byte[]) Mockito.any(), Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.anyInt())) .thenReturn(new RegionLocations(loc)); if (admin != null) { // If a call to getAdmin, return this implementation. Mockito.when(c.getAdmin(Mockito.any(ServerName.class))).thenReturn(admin); } if (client != null) { // If a call to getClient, return this client. Mockito.when(c.getClient(Mockito.any(ServerName.class))).thenReturn(client); } NonceGenerator ng = Mockito.mock(NonceGenerator.class); Mockito.when(c.getNonceGenerator()).thenReturn(ng); Mockito.when(c.getAsyncProcess()) .thenReturn( new AsyncProcess( c, conf, null, RpcRetryingCallerFactory.instantiate(conf), false, RpcControllerFactory.instantiate(conf), conf.getInt(HConstants.HBASE_RPC_TIMEOUT_KEY, HConstants.DEFAULT_HBASE_RPC_TIMEOUT), conf.getInt( HConstants.HBASE_CLIENT_OPERATION_TIMEOUT, HConstants.DEFAULT_HBASE_CLIENT_OPERATION_TIMEOUT))); Mockito.when(c.getNewRpcRetryingCallerFactory(conf)) .thenReturn( RpcRetryingCallerFactory.instantiate( conf, RetryingCallerInterceptorFactory.NO_OP_INTERCEPTOR, null)); Mockito.when(c.getRpcControllerFactory()).thenReturn(Mockito.mock(RpcControllerFactory.class)); Table t = Mockito.mock(Table.class); Mockito.when(c.getTable((TableName) Mockito.any())).thenReturn(t); ResultScanner rs = Mockito.mock(ResultScanner.class); Mockito.when(t.getScanner((Scan) Mockito.any())).thenReturn(rs); return c; }
@Test public void testReplyToOneDeepCustomCorrelationKey() throws Exception { ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class); Connection mockConnection = mock(Connection.class); Channel mockChannel = mock(Channel.class); when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection); when(mockConnection.isOpen()).thenReturn(true); when(mockConnection.createChannel()).thenReturn(mockChannel); final RabbitTemplate template = new RabbitTemplate(new SingleConnectionFactory(mockConnectionFactory)); template.setCorrelationKey(CORRELATION_HEADER); Queue replyQueue = new Queue("new.replyTo"); template.setReplyQueue(replyQueue); MessageProperties messageProperties = new MessageProperties(); messageProperties.setReplyTo("replyTo1"); messageProperties.setCorrelationId("saveThis".getBytes()); Message message = new Message("Hello, world!".getBytes(), messageProperties); final AtomicReference<String> replyTo = new AtomicReference<String>(); final AtomicReference<String> correlationId = new AtomicReference<String>(); doAnswer( new Answer<Object>() { public Object answer(InvocationOnMock invocation) throws Throwable { BasicProperties basicProps = (BasicProperties) invocation.getArguments()[4]; replyTo.set(basicProps.getReplyTo()); correlationId.set((String) basicProps.getHeaders().get(CORRELATION_HEADER)); MessageProperties springProps = new DefaultMessagePropertiesConverter() .toMessageProperties(basicProps, null, "UTF-8"); Message replyMessage = new Message("!dlrow olleH".getBytes(), springProps); template.onMessage(replyMessage); return null; } }) .when(mockChannel) .basicPublish( Mockito.any(String.class), Mockito.any(String.class), Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.any(BasicProperties.class), Mockito.any(byte[].class)); Message reply = template.sendAndReceive(message); assertNotNull(reply); assertNotNull(replyTo.get()); assertEquals("new.replyTo", replyTo.get()); assertNotNull(correlationId.get()); assertEquals("replyTo1", reply.getMessageProperties().getReplyTo()); assertTrue(!"saveThis".equals(correlationId.get())); assertEquals("replyTo1", reply.getMessageProperties().getReplyTo()); }
@SuppressWarnings("unchecked") @Test @Ignore public void testCanControlGatheredEntriesUsingRsm() throws Exception { NodeItem item1 = new NodeItemImpl(TEST_NODE_1, "node1:1", new Date(0), "<entry>item1</entry>"); NodeItem item2 = new NodeItemImpl(TEST_NODE_2, "node2:1", new Date(10), "<entry>item2</entry>"); NodeItem item3 = new NodeItemImpl(TEST_NODE_1, "node1:2", new Date(20), "<entry>item3</entry>"); NodeItem item4 = new NodeItemImpl(TEST_NODE_1, "node1:3", new Date(30), "<entry>item4</entry>"); ArrayList<NodeItem> results = new ArrayList<NodeItem>(); results.add(item1); results.add(item2); results.add(item3); results.add(item4); Mockito.when( channelManager.getUserFeedItems( Mockito.any(JID.class), Mockito.any(Date.class), Mockito.anyInt(), Mockito.any(GlobalItemID.class), Mockito.anyBoolean())) .thenReturn(new ClosableIteratorImpl<NodeItem>(results.iterator())); Mockito.when( channelManager.getCountUserFeedItems( Mockito.any(JID.class), Mockito.any(Date.class), Mockito.anyBoolean())) .thenReturn(results.size()); Element rsm = request.getElement().addElement("rsm"); rsm.addNamespace("", PubSubElementProcessorAbstract.NS_RSM); rsm.addElement("max").addText("2"); rsm.addElement("after").addText("node1:1"); userItemsGet.process(element, jid, request, null); IQ response = (IQ) queue.poll(); Assert.assertEquals(IQ.Type.result, response.getType()); Element pubsub = response.getChildElement(); Assert.assertEquals("pubsub", pubsub.getName()); Assert.assertEquals(JabberPubsub.NAMESPACE_URI, pubsub.getNamespaceURI()); List<Element> items = pubsub.elements("items"); Assert.assertEquals(2, items.size()); Assert.assertEquals(TEST_NODE_2, items.get(0).attributeValue("node")); Assert.assertEquals(TEST_NODE_1, items.get(1).attributeValue("node")); Assert.assertEquals(1, items.get(0).elements("item").size()); Assert.assertEquals(1, items.get(1).elements("item").size()); Element rsmResult = pubsub.element("set"); Assert.assertEquals("2", rsmResult.element("count").getText()); Assert.assertEquals("node2:1", rsmResult.element("first").getText()); Assert.assertEquals("node1:2", rsmResult.element("last").getText()); }
@Test public void testInactiveControlRetriedOnceAndSucceeds() throws InterruptedException { final WebTarget QUALIFY_TARGET = Mockito.mock(WebTarget.class); final WebTarget FOLLOW_TARGET = Mockito.mock(WebTarget.class); final Invocation.Builder QUALIFY_BUILDER = Mockito.mock(Invocation.Builder.class); final AsyncInvoker QUALIFY_ASYNC = Mockito.mock(AsyncInvoker.class); final Invocation.Builder FOLLOW_BUILDER = Mockito.mock(Invocation.Builder.class); final AsyncInvoker FOLLOW_ASYNC = Mockito.mock(AsyncInvoker.class); Mockito.when(QUALIFY_TARGET.request()).thenReturn(QUALIFY_BUILDER); Mockito.when(QUALIFY_BUILDER.async()).thenReturn(QUALIFY_ASYNC); Mockito.when(FOLLOW_TARGET.request()).thenReturn(FOLLOW_BUILDER); Mockito.when(FOLLOW_BUILDER.async()).thenReturn(FOLLOW_ASYNC); final ChannelMonitor MONITOR = new RetryingControlChannelMonitor(config(), QUALIFY_TARGET, FOLLOW_TARGET); final Future CAPTURE_FUTURE = Mockito.mock(Future.class); final DataUnitCounter COUNTER = Mockito.mock(DataUnitCounter.class); Mockito.when(COUNTER.getDataUnitCount()).thenReturn(0); final ControlChannelId id = new ControlChannelId(10, 20, 30, 40); final Identifiable capture = new FollowRequest(10d, 20d, 0, 1337d, id); assert MONITOR.monitor(capture, CAPTURE_FUTURE, COUNTER); assert MONITOR.contains(id); Mockito.verify(CAPTURE_FUTURE, Mockito.never()).cancel(Mockito.anyBoolean()); Thread.sleep(1100); Mockito.verify(CAPTURE_FUTURE, Mockito.times(1)).cancel(Mockito.anyBoolean()); assert MONITOR.contains(id); ArgumentCaptor<InvocationCallback> QUALIFY_CALLBACK = ArgumentCaptor.forClass(InvocationCallback.class); Mockito.verify(QUALIFY_ASYNC).post(Mockito.any(Entity.class), QUALIFY_CALLBACK.capture()); ControlChannelQualities QUALITIES = Mockito.mock(ControlChannelQualities.class); Mockito.when(QUALITIES.getWacn()).thenReturn(id.getWacn()); Mockito.when(QUALITIES.getSystemId()).thenReturn(id.getSystemId()); Mockito.when(QUALITIES.getRfSubsystemId()).thenReturn(id.getRfSubsystemId()); Mockito.when(QUALITIES.getSiteId()).thenReturn(id.getSiteId()); QUALIFY_CALLBACK.getValue().completed(QUALITIES); assert !MONITOR.contains(id); Mockito.verify(FOLLOW_ASYNC, Mockito.times(1)) .post(Mockito.any(Entity.class), Mockito.any(InvocationCallback.class)); }
@Test(expected = IOException.class) public void testPrepareConfigFilesThrowsExceptionWhenUnzipFailed() throws IOException { doThrow(IOException.class) .when(archiverService) .unzip(Mockito.<InputStream>any(), Mockito.anyBoolean()); yarnConfigFilesProvider.prepareConfigFiles(); }
@Before public void before() throws KettleException { MockitoAnnotations.initMocks(this); Mockito.when(parentJob.getLogLevel()).thenReturn(LogLevel.BASIC); entry.setParentJob(parentJob); entry.setSaveMessage(true); Mockito.when(message.getMessageNumber()).thenReturn(1); Mockito.when(mailConn.getMessage()).thenReturn(message); Mockito.doNothing().when(mailConn).openFolder(Mockito.anyBoolean()); Mockito.doNothing().when(mailConn).openFolder(Mockito.anyString(), Mockito.anyBoolean()); Mockito.when(mailConn.getMessagesCount()).thenReturn(1); }
@Test public void testCancel() { final WebTarget QUALIFY = Mockito.mock(WebTarget.class); final WebTarget FOLLOW = Mockito.mock(WebTarget.class); final ChannelMonitor MONITOR = new RetryingControlChannelMonitor(config(), QUALIFY, FOLLOW); final Future FUTURE = Mockito.mock(Future.class); final DataUnitCounter COUNTER = Mockito.mock(DataUnitCounter.class); Mockito.when(COUNTER.getDataUnitCount()).thenReturn(1337); final GroupChannelId id = new GroupChannelId(10, 20, 30, 40, 50, 60d); final Identifiable capture = new GroupCaptureRequest(10d, 20d, 0, 1337d, id); assert MONITOR.monitor(capture, FUTURE, COUNTER); assert MONITOR.contains(id); Mockito.verify(FUTURE, Mockito.never()).cancel(Mockito.anyBoolean()); MONITOR.cancel(id); Mockito.verify(FUTURE, Mockito.times(1)).cancel(Mockito.anyBoolean()); assert !MONITOR.contains(id); }
@Test public void whenRequestingParentOnlyCorrectFlagIsSetOnDatabaseRequest() throws Exception { Element rsm = new BaseElement(new QName("set", new Namespace("", "http://jabber.org/protocol/rsm"))); element.addAttribute("node", "/user/[email protected]/posts"); IQ request = this.request.createCopy(); request.getChildElement().element("user-items").addAttribute("parent-only", "true"); Mockito.when(channelManager.nodeExists(anyString())).thenReturn(true); Mockito.when(channelManager.getNodeMembership(node, jid)) .thenReturn( new NodeMembershipImpl(node, jid, Subscriptions.subscribed, Affiliations.member, null)); Mockito.when( channelManager.getUserFeedItems( Mockito.any(JID.class), Mockito.any(Date.class), Mockito.anyInt(), Mockito.any(GlobalItemID.class), Mockito.anyBoolean())) .thenReturn(new ClosableIteratorImpl<NodeItem>(new ArrayList<NodeItem>().iterator())); Mockito.when( channelManager.getCountUserFeedItems( Mockito.any(JID.class), Mockito.any(Date.class), Mockito.anyBoolean())) .thenReturn(0); userItemsGet.process(element, jid, request, rsm); Mockito.verify(channelManager, Mockito.times(1)) .getUserFeedItems( Mockito.any(JID.class), Mockito.any(Date.class), Mockito.anyInt(), Mockito.any(GlobalItemID.class), Mockito.eq(true)); }
@Before public void setUp() { MockApplication application = new MyMockApplicationEx(parent); ActionManagerEx manager = Mockito.mock(ActionManagerEx.class); ActionToolbar actionToolbar = Mockito.mock(ActionToolbar.class); Mockito.when(actionToolbar.getComponent()).thenReturn(new JComponent() {}); Mockito.when( manager.createActionToolbar( Mockito.anyString(), Mockito.any(ActionGroup.class), Mockito.anyBoolean())) .thenReturn(actionToolbar); Mockito.when( manager.createActionToolbar( Mockito.anyString(), Mockito.any(ActionGroup.class), Mockito.anyBoolean(), Mockito.anyBoolean())) .thenReturn(actionToolbar); application.addComponent(ActionManager.class, manager); ApplicationManager.setApplication(application, parent); XDebugSession session = Mockito.mock(XDebugSession.class); Mockito.when(handler.getProcess()).thenReturn(mockProcess); Mockito.when(mockProcess.getXDebugSession()).thenReturn(session); }
/** * Test get of root region fails properly if nothing to connect to. * * @throws IOException * @throws InterruptedException * @throws KeeperException */ @Test public void testVerifyRootRegionLocationFails() throws IOException, InterruptedException, KeeperException { HConnection connection = Mockito.mock(HConnection.class); ConnectException connectException = new ConnectException("Connection refused"); final HRegionInterface implementation = Mockito.mock(HRegionInterface.class); Mockito.when(implementation.getRegionInfo((byte[]) Mockito.any())).thenThrow(connectException); Mockito.when( connection.getHRegionConnection( Mockito.anyString(), Mockito.anyInt(), Mockito.anyBoolean())) .thenReturn(implementation); final CatalogTracker ct = constructAndStartCatalogTracker(connection); RootLocationEditor.setRootLocation( this.watcher, new ServerName("example.com", 1234, System.currentTimeMillis())); Assert.assertFalse(ct.verifyRootRegionLocation(100)); }
@Test public void testDatasourceProvider() throws Exception { mondrianCatalogHelper = mock(MondrianCatalogHelper.class); // steelwheels mondrian catalog MondrianSchema steelWheelsSchema = new MondrianSchema(STEEL_WHEELS, Arrays.asList(new MondrianCube[] {mockCube})); MondrianCatalog steelWheelsCatalog = new MondrianCatalog( STEEL_WHEELS, MONDRIAN_DS_PROVIDER, STEEL_WHEELS + ".mondrian.xml", steelWheelsSchema); // sampledata mondrian catalog MondrianSchema sampleDataSchema = new MondrianSchema(SAMPLE_DATA, Arrays.asList(new MondrianCube[] {mockCube})); MondrianCatalog sampleDataCatalog = new MondrianCatalog( SAMPLE_DATA, MONDRIAN_DS_PROVIDER, SAMPLE_DATA + ".mondrian.xml", sampleDataSchema); // add catalogs to mondrianCatalogHelper mondrianCatalogHelper.addCatalog(steelWheelsCatalog, false, standaloneSession); mondrianCatalogHelper.addCatalog(sampleDataCatalog, false, standaloneSession); List<MondrianCatalog> returnList = new ArrayList<MondrianCatalog>(); returnList.add(sampleDataCatalog); returnList.add(steelWheelsCatalog); // mock mondrianCatalogHelper.listCatalogs return doReturn(returnList) .when(mondrianCatalogHelper) .listCatalogs(Mockito.any(IPentahoSession.class), Mockito.anyBoolean()); // create AnalysisDatasourceProvider IDatasourceProvider analysisDatasourceProvider = new AnalysisDatasourceProvider(mondrianCatalogHelper); List<IDatasource> datasources = analysisDatasourceProvider.getDatasources(); assertEquals(2, datasources.size()); assertEquals(SAMPLE_DATA, datasources.get(0).getName()); assertEquals(ANALYSIS_TYPE, datasources.get(0).getType().getId()); assertEquals(STEEL_WHEELS, datasources.get(1).getName()); assertEquals(ANALYSIS_TYPE, datasources.get(1).getType().getId()); }
@SuppressWarnings("unchecked") @Test public void testTransactionStatementsAsynch() throws Exception { ConnectionImpl conn = Mockito.mock(ConnectionImpl.class); Mockito.stub(conn.submitSetAutoCommitTrue(Mockito.anyBoolean())) .toReturn((ResultsFuture) ResultsFuture.NULL_FUTURE); Properties p = new Properties(); Mockito.stub(conn.getExecutionProperties()).toReturn(p); StatementImpl statement = new StatementImpl(conn, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY); statement.submitExecute("start transaction", null); // $NON-NLS-1$ Mockito.verify(conn).setAutoCommit(false); statement.submitExecute("commit", null); // $NON-NLS-1$ Mockito.verify(conn).submitSetAutoCommitTrue(true); statement.submitExecute("start transaction", null); // $NON-NLS-1$ statement.submitExecute("rollback", null); // $NON-NLS-1$ Mockito.verify(conn).submitSetAutoCommitTrue(false); }
/** * @param implementation An {@link HRegionInterface} instance; you'll likely want to pass a mocked * HRS; can be null. * @return Mock up a connection that returns a {@link org.apache.hadoop.conf.Configuration} when * {@link HConnection#getConfiguration()} is called, a 'location' when {@link * HConnection#getRegionLocation(byte[], byte[], boolean)} is called, and that returns the * passed {@link HRegionInterface} instance when {@link * HConnection#getHRegionConnection(String, int)} is called (Be sure call {@link * HConnectionManager#deleteConnection(org.apache.hadoop.conf.Configuration)} when done with * this mocked Connection. * @throws IOException */ private HConnection mockConnection(final HRegionInterface implementation) throws IOException { HConnection connection = HConnectionTestingUtility.getMockedConnection(UTIL.getConfiguration()); Mockito.doNothing().when(connection).close(); // Make it so we return any old location when asked. final HRegionLocation anyLocation = new HRegionLocation(HRegionInfo.FIRST_META_REGIONINFO, SN.getHostname(), SN.getPort()); Mockito.when( connection.getRegionLocation( (byte[]) Mockito.any(), (byte[]) Mockito.any(), Mockito.anyBoolean())) .thenReturn(anyLocation); Mockito.when(connection.locateRegion((byte[]) Mockito.any(), (byte[]) Mockito.any())) .thenReturn(anyLocation); if (implementation != null) { // If a call to getHRegionConnection, return this implementation. Mockito.when(connection.getHRegionConnection(Mockito.anyString(), Mockito.anyInt())) .thenReturn(implementation); } return connection; }
@SuppressWarnings("unchecked") @Test public void testOutgoingStanzaFormattedAsExpected() throws Exception { NodeItem item1 = new NodeItemImpl(TEST_NODE_1, "1", new Date(), "<entry>item1</entry>"); NodeItem item2 = new NodeItemImpl(TEST_NODE_2, "1", new Date(), "<entry>item2</entry>"); NodeItem item3 = new NodeItemImpl(TEST_NODE_1, "2", new Date(), "<entry>item3</entry>"); NodeItem item4 = new NodeItemImpl(TEST_NODE_1, "3", new Date(), "<entry>item4</entry>"); ArrayList<NodeItem> results = new ArrayList<NodeItem>(); results.add(item1); results.add(item2); results.add(item3); results.add(item4); Mockito.when( channelManager.getUserFeedItems( Mockito.any(JID.class), Mockito.any(Date.class), Mockito.anyInt(), Mockito.any(GlobalItemID.class), Mockito.anyBoolean())) .thenReturn(new ClosableIteratorImpl<NodeItem>(results.iterator())); userItemsGet.process(element, jid, request, null); IQ response = (IQ) queue.poll(); Assert.assertEquals(IQ.Type.result, response.getType()); Element pubsub = response.getChildElement(); Assert.assertEquals("pubsub", pubsub.getName()); Assert.assertEquals(JabberPubsub.NAMESPACE_URI, pubsub.getNamespaceURI()); List<Element> items = pubsub.elements("items"); Assert.assertEquals(3, items.size()); Assert.assertEquals(TEST_NODE_1, items.get(0).attributeValue("node")); Assert.assertEquals(TEST_NODE_2, items.get(1).attributeValue("node")); Assert.assertEquals(TEST_NODE_1, items.get(2).attributeValue("node")); Assert.assertEquals(1, items.get(0).elements("item").size()); Assert.assertEquals(2, items.get(2).elements("item").size()); }
@Test public void testNodeStoreExceptionGeneratesAnErrorStanza() throws Exception { Mockito.when( channelManager.getUserFeedItems( Mockito.any(JID.class), Mockito.any(Date.class), Mockito.anyInt(), Mockito.any(GlobalItemID.class), Mockito.anyBoolean())) .thenThrow(new NodeStoreException()); userItemsGet.process(element, jid, request, null); Packet response = queue.poll(); PacketError error = response.getError(); Assert.assertNotNull(error); Assert.assertEquals(PacketError.Type.wait, error.getType()); Assert.assertEquals(PacketError.Condition.internal_server_error, error.getCondition()); }
@Test public void testNoUserItemsReturnsEmptyStanza() throws Exception { Mockito.when( channelManager.getUserFeedItems( Mockito.any(JID.class), Mockito.any(Date.class), Mockito.anyInt(), Mockito.any(GlobalItemID.class), Mockito.anyBoolean())) .thenReturn(new ClosableIteratorImpl<NodeItem>(new ArrayList<NodeItem>().iterator())); userItemsGet.process(element, jid, request, null); IQ response = (IQ) queue.poll(); Assert.assertEquals(IQ.Type.result, response.getType()); Element pubsub = response.getChildElement(); Assert.assertEquals("pubsub", pubsub.getName()); Assert.assertEquals(JabberPubsub.NAMESPACE_URI, pubsub.getNamespaceURI()); }
/** * Calls {@link #getMockedConnection(Configuration)} and then mocks a few more of the popular * {@link HConnection} methods so they do 'normal' operation (see return doc below for list). Be * sure to shutdown the connection when done by calling {@link * HConnectionManager#deleteConnection(Configuration, boolean)} else it will stick around; this is * probably not what you want. * * @param implementation An {@link HRegionInterface} instance; you'll likely want to pass a mocked * HRS; can be null. * @param conf Configuration to use * @param implementation An HRegionInterface; can be null but is usually itself a mock. * @param sn ServerName to include in the region location returned by this <code>implementation * </code> * @param hri HRegionInfo to include in the location returned when getRegionLocation is called on * the mocked connection * @return Mock up a connection that returns a {@link Configuration} when {@link * HConnection#getConfiguration()} is called, a 'location' when {@link * HConnection#getRegionLocation(byte[], byte[], boolean)} is called, and that returns the * passed {@link HRegionInterface} instance when {@link * HConnection#getHRegionConnection(String, int)} is called (Be sure call {@link * HConnectionManager#deleteConnection(org.apache.hadoop.conf.Configuration, boolean)} when * done with this mocked Connection. * @throws IOException */ public static HConnection getMockedConnectionAndDecorate( final Configuration conf, final HRegionInterface implementation, final ServerName sn, final HRegionInfo hri) throws IOException { HConnection c = HConnectionTestingUtility.getMockedConnection(conf); Mockito.doNothing().when(c).close(); // Make it so we return a particular location when asked. final HRegionLocation loc = new HRegionLocation(hri, sn.getHostname(), sn.getPort()); Mockito.when( c.getRegionLocation( (byte[]) Mockito.any(), (byte[]) Mockito.any(), Mockito.anyBoolean())) .thenReturn(loc); Mockito.when(c.locateRegion((byte[]) Mockito.any(), (byte[]) Mockito.any())).thenReturn(loc); if (implementation != null) { // If a call to getHRegionConnection, return this implementation. Mockito.when(c.getHRegionConnection(Mockito.anyString(), Mockito.anyInt())) .thenReturn(implementation); } return c; }
@Test public void testUnparsableItemEntriesAreSimplyIgnored() throws Exception { NodeItem item1 = new NodeItemImpl(TEST_NODE_1, "1", new Date(), "<entry>item1</entry>"); NodeItem item2 = new NodeItemImpl(TEST_NODE_1, "2", new Date(), "<entry>item2"); ArrayList<NodeItem> results = new ArrayList<NodeItem>(); results.add(item1); results.add(item2); Mockito.when( channelManager.getUserFeedItems( Mockito.any(JID.class), Mockito.any(Date.class), Mockito.anyInt(), Mockito.any(GlobalItemID.class), Mockito.anyBoolean())) .thenReturn(new ClosableIteratorImpl<NodeItem>(results.iterator())); userItemsGet.process(element, jid, request, null); IQ response = (IQ) queue.poll(); Assert.assertEquals(1, response.getChildElement().element("items").elements("item").size()); }
@Test public void deliveryAssignmentEmailNotificationTest_Original_Basic() throws MitchellException { try { APDDeliveryContextDocument aPDDeliveryContextDocument = APDDeliveryContextDocument.Factory.parse( new File("src/test/resources/APDDeliveryContextDocument.xml")); Mockito.doNothing() .when(assignmentEmailDeliveryHandler) .deliverIAEmail( (APDDeliveryContextDocument) Mockito.anyObject(), Mockito.anyBoolean(), Mockito.anyString()); asgEmailDelService.deliveryAssignmentEmailNotification( aPDDeliveryContextDocument, new ArrayList<String>(), "IA_BASIC_EMAIL_TYPE"); Mockito.when(cultureDAO.getCultureByCompany(Mockito.anyString())).thenReturn(null); Mockito.verify(assignmentEmailDeliveryHandler) .deliverIAEmail(aPDDeliveryContextDocument, true, "en-US"); } catch (XmlException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } }
/** * Test that MetaReader will ride over server throwing "Server not running" IOEs. * * @see https://issues.apache.org/jira/browse/HBASE-3446 * @throws IOException * @throws InterruptedException */ @Test public void testRideOverServerNotRunning() throws IOException, InterruptedException { // Need a zk watcher. ZooKeeperWatcher zkw = new ZooKeeperWatcher( UTIL.getConfiguration(), this.getClass().getSimpleName(), ABORTABLE, true); // This is a servername we use in a few places below. ServerName sn = new ServerName("example.com", 1234, System.currentTimeMillis()); HConnection connection = null; CatalogTracker ct = null; try { // Mock an HRegionInterface. Our mock implementation will fail a few // times when we go to open a scanner. final HRegionInterface implementation = Mockito.mock(HRegionInterface.class); // When openScanner called throw IOE 'Server not running' a few times // before we return a scanner id. Whats WEIRD is that these // exceptions do not show in the log because they are caught and only // printed if we FAIL. We eventually succeed after retry so these don't // show. We will know if they happened or not because we will ask // mockito at the end of this test to verify that openscanner was indeed // called the wanted number of times. final long scannerid = 123L; Mockito.when(implementation.openScanner((byte[]) Mockito.any(), (Scan) Mockito.any())) .thenThrow(new IOException("Server not running (1 of 3)")) .thenThrow(new IOException("Server not running (2 of 3)")) .thenThrow(new IOException("Server not running (3 of 3)")) .thenReturn(scannerid); // Make it so a verifiable answer comes back when next is called. Return // the verifiable answer and then a null so we stop scanning. Our // verifiable answer is something that looks like a row in META with // a server and startcode that is that of the above defined servername. List<KeyValue> kvs = new ArrayList<KeyValue>(); final byte[] rowToVerify = Bytes.toBytes("rowToVerify"); kvs.add( new KeyValue( rowToVerify, HConstants.CATALOG_FAMILY, HConstants.REGIONINFO_QUALIFIER, Writables.getBytes(HRegionInfo.FIRST_META_REGIONINFO))); kvs.add( new KeyValue( rowToVerify, HConstants.CATALOG_FAMILY, HConstants.SERVER_QUALIFIER, Bytes.toBytes(sn.getHostAndPort()))); kvs.add( new KeyValue( rowToVerify, HConstants.CATALOG_FAMILY, HConstants.STARTCODE_QUALIFIER, Bytes.toBytes(sn.getStartcode()))); final Result[] result = new Result[] {new Result(kvs)}; Mockito.when(implementation.next(Mockito.anyLong(), Mockito.anyInt())) .thenReturn(result) .thenReturn(null); // Associate a spied-upon HConnection with UTIL.getConfiguration. Need // to shove this in here first so it gets picked up all over; e.g. by // HTable. connection = HConnectionTestingUtility.getSpiedConnection(UTIL.getConfiguration()); // Fix the location lookup so it 'works' though no network. First // make an 'any location' object. final HRegionLocation anyLocation = new HRegionLocation(HRegionInfo.FIRST_META_REGIONINFO, sn.getHostname(), sn.getPort()); // Return the any location object when locateRegion is called in HTable // constructor and when its called by ServerCallable (it uses getRegionLocation). // The ugly format below comes of 'Important gotcha on spying real objects!' from // http://mockito.googlecode.com/svn/branches/1.6/javadoc/org/mockito/Mockito.html Mockito.doReturn(anyLocation) .when(connection) .locateRegion((byte[]) Mockito.any(), (byte[]) Mockito.any()); Mockito.doReturn(anyLocation) .when(connection) .getRegionLocation((byte[]) Mockito.any(), (byte[]) Mockito.any(), Mockito.anyBoolean()); // Now shove our HRI implementation into the spied-upon connection. Mockito.doReturn(implementation) .when(connection) .getHRegionConnection(Mockito.anyString(), Mockito.anyInt()); // Now start up the catalogtracker with our doctored Connection. ct = new CatalogTracker(zkw, null, connection, ABORTABLE, 0); ct.start(); // Scan meta for user tables and verify we got back expected answer. NavigableMap<HRegionInfo, Result> hris = MetaReader.getServerUserRegions(ct, sn); assertTrue(hris.size() == 1); assertTrue(hris.firstEntry().getKey().equals(HRegionInfo.FIRST_META_REGIONINFO)); assertTrue(Bytes.equals(rowToVerify, hris.firstEntry().getValue().getRow())); // Finally verify that openscanner was called four times -- three times // with exception and then on 4th attempt we succeed. Mockito.verify(implementation, Mockito.times(4)) .openScanner((byte[]) Mockito.any(), (Scan) Mockito.any()); } finally { if (ct != null) ct.stop(); HConnectionManager.deleteConnection(UTIL.getConfiguration(), true); zkw.close(); } }
/** Verifies that an up-stack RabbitTemplate uses the listener's channel (MessageListener). */ @SuppressWarnings("unchecked") @Test public void testMessageListener() throws Exception { ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class); Connection mockConnection = mock(Connection.class); final Channel onlyChannel = mock(Channel.class); when(onlyChannel.isOpen()).thenReturn(true); final CachingConnectionFactory cachingConnectionFactory = new CachingConnectionFactory(mockConnectionFactory); when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection); when(mockConnection.isOpen()).thenReturn(true); final AtomicReference<Exception> tooManyChannels = new AtomicReference<Exception>(); doAnswer( new Answer<Channel>() { boolean done; @Override public Channel answer(InvocationOnMock invocation) throws Throwable { if (!done) { done = true; return onlyChannel; } tooManyChannels.set(new Exception("More than one channel requested")); Channel channel = mock(Channel.class); when(channel.isOpen()).thenReturn(true); return channel; } }) .when(mockConnection) .createChannel(); final AtomicReference<Consumer> consumer = new AtomicReference<Consumer>(); doAnswer( new Answer<String>() { @Override public String answer(InvocationOnMock invocation) throws Throwable { consumer.set((Consumer) invocation.getArguments()[6]); return null; } }) .when(onlyChannel) .basicConsume( anyString(), anyBoolean(), anyString(), anyBoolean(), anyBoolean(), anyMap(), any(Consumer.class)); final CountDownLatch commitLatch = new CountDownLatch(1); doAnswer( new Answer<String>() { @Override public String answer(InvocationOnMock invocation) throws Throwable { commitLatch.countDown(); return null; } }) .when(onlyChannel) .txCommit(); final CountDownLatch latch = new CountDownLatch(1); SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(cachingConnectionFactory); container.setMessageListener( new MessageListener() { @Override public void onMessage(Message message) { RabbitTemplate rabbitTemplate = new RabbitTemplate(cachingConnectionFactory); rabbitTemplate.setChannelTransacted(true); // should use same channel as container rabbitTemplate.convertAndSend("foo", "bar", "baz"); latch.countDown(); } }); container.setQueueNames("queue"); container.setChannelTransacted(true); container.setShutdownTimeout(100); container.afterPropertiesSet(); container.start(); consumer .get() .handleDelivery( "qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(), new byte[] {0}); assertTrue(latch.await(10, TimeUnit.SECONDS)); Exception e = tooManyChannels.get(); if (e != null) { throw e; } verify(mockConnection, Mockito.times(1)).createChannel(); assertTrue(commitLatch.await(10, TimeUnit.SECONDS)); verify(onlyChannel).txCommit(); verify(onlyChannel) .basicPublish( Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(), Mockito.any(BasicProperties.class), Mockito.any(byte[].class)); // verify close() was never called on the channel DirectFieldAccessor dfa = new DirectFieldAccessor(cachingConnectionFactory); List<?> channels = (List<?>) dfa.getPropertyValue("cachedChannelsTransactional"); assertEquals(0, channels.size()); container.stop(); }
/** * Verifies that the listener channel is not exposed when so configured and up-stack * RabbitTemplate uses the additional channel. created when exposeListenerChannel is false * (ChannelAwareMessageListener). */ @SuppressWarnings("unchecked") @Test public void testChannelAwareMessageListenerDontExpose() throws Exception { ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class); Connection mockConnection = mock(Connection.class); final Channel firstChannel = mock(Channel.class); when(firstChannel.isOpen()).thenReturn(true); final Channel secondChannel = mock(Channel.class); when(secondChannel.isOpen()).thenReturn(true); final SingleConnectionFactory singleConnectionFactory = new SingleConnectionFactory(mockConnectionFactory); when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection); when(mockConnection.isOpen()).thenReturn(true); final AtomicReference<Exception> tooManyChannels = new AtomicReference<Exception>(); doAnswer( new Answer<Channel>() { boolean done; @Override public Channel answer(InvocationOnMock invocation) throws Throwable { if (!done) { done = true; return firstChannel; } return secondChannel; } }) .when(mockConnection) .createChannel(); final AtomicReference<Consumer> consumer = new AtomicReference<Consumer>(); doAnswer( new Answer<String>() { @Override public String answer(InvocationOnMock invocation) throws Throwable { consumer.set((Consumer) invocation.getArguments()[6]); return null; } }) .when(firstChannel) .basicConsume( anyString(), anyBoolean(), anyString(), anyBoolean(), anyBoolean(), anyMap(), any(Consumer.class)); final CountDownLatch commitLatch = new CountDownLatch(1); doAnswer( new Answer<String>() { @Override public String answer(InvocationOnMock invocation) throws Throwable { commitLatch.countDown(); return null; } }) .when(firstChannel) .txCommit(); final CountDownLatch latch = new CountDownLatch(1); final AtomicReference<Channel> exposed = new AtomicReference<Channel>(); SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(singleConnectionFactory); container.setMessageListener( new ChannelAwareMessageListener() { @Override public void onMessage(Message message, Channel channel) { exposed.set(channel); RabbitTemplate rabbitTemplate = new RabbitTemplate(singleConnectionFactory); rabbitTemplate.setChannelTransacted(true); // should use same channel as container rabbitTemplate.convertAndSend("foo", "bar", "baz"); latch.countDown(); } }); container.setQueueNames("queue"); container.setChannelTransacted(true); container.setExposeListenerChannel(false); container.setShutdownTimeout(100); container.afterPropertiesSet(); container.start(); consumer .get() .handleDelivery( "qux", new Envelope(1, false, "foo", "bar"), new BasicProperties(), new byte[] {0}); assertTrue(latch.await(10, TimeUnit.SECONDS)); Exception e = tooManyChannels.get(); if (e != null) { throw e; } // once for listener, once for exposed + 0 for template (used bound) verify(mockConnection, Mockito.times(2)).createChannel(); assertTrue(commitLatch.await(10, TimeUnit.SECONDS)); verify(firstChannel).txCommit(); verify(secondChannel).txCommit(); verify(secondChannel) .basicPublish( Mockito.anyString(), Mockito.anyString(), Mockito.anyBoolean(), Mockito.any(BasicProperties.class), Mockito.any(byte[].class)); assertSame(secondChannel, exposed.get()); verify(firstChannel, Mockito.never()).close(); verify(secondChannel, Mockito.times(1)).close(); container.stop(); }
@Test public void testReplyToThreeDeepCustomCorrelationKey() throws Exception { ConnectionFactory mockConnectionFactory = mock(ConnectionFactory.class); Connection mockConnection = mock(Connection.class); Channel mockChannel = mock(Channel.class); when(mockConnectionFactory.newConnection((ExecutorService) null)).thenReturn(mockConnection); when(mockConnection.isOpen()).thenReturn(true); when(mockConnection.createChannel()).thenReturn(mockChannel); final RabbitTemplate template = new RabbitTemplate(new SingleConnectionFactory(mockConnectionFactory)); template.setCorrelationKey(CORRELATION_HEADER); Queue replyQueue = new Queue("replyTo2"); template.setReplyQueue(replyQueue); MessageProperties messageProperties = new MessageProperties(); messageProperties.setReplyTo("replyTo1"); messageProperties.setCorrelationId("a".getBytes()); Message message = new Message("Hello, world!".getBytes(), messageProperties); final AtomicInteger count = new AtomicInteger(); final List<String> nestedReplyTo = new ArrayList<String>(); final List<String> nestedCorrelation = new ArrayList<String>(); doAnswer( new Answer<Object>() { public Object answer(InvocationOnMock invocation) throws Throwable { BasicProperties basicProps = (BasicProperties) invocation.getArguments()[4]; nestedReplyTo.add(basicProps.getReplyTo()); nestedCorrelation.add(basicProps.getCorrelationId()); MessageProperties springProps = new DefaultMessagePropertiesConverter() .toMessageProperties(basicProps, null, "UTF-8"); Message replyMessage = new Message("!dlrow olleH".getBytes(), springProps); if (count.incrementAndGet() < 2) { Message anotherMessage = new Message("Second".getBytes(), springProps); template.setReplyQueue(new Queue("replyTo3")); replyMessage = template.sendAndReceive(anotherMessage); nestedReplyTo.add(replyMessage.getMessageProperties().getReplyTo()); nestedCorrelation.add( (String) replyMessage.getMessageProperties().getHeaders().get(CORRELATION_HEADER)); } template.onMessage(replyMessage); return null; } }) .when(mockChannel) .basicPublish( Mockito.any(String.class), Mockito.any(String.class), Mockito.anyBoolean(), Mockito.anyBoolean(), Mockito.any(BasicProperties.class), Mockito.any(byte[].class)); Message reply = template.sendAndReceive(message); assertNotNull(reply); assertEquals(3, nestedReplyTo.size()); assertEquals("replyTo2", nestedReplyTo.get(0)); assertEquals("replyTo3", nestedReplyTo.get(1)); assertEquals("replyTo2", nestedReplyTo.get(2)); // intermediate reply assertEquals("replyTo1", reply.getMessageProperties().getReplyTo()); assertEquals("a", new String(reply.getMessageProperties().getCorrelationId(), "UTF-8")); }
@SuppressWarnings("serial") @Test public void testPagingAfterItem() throws Exception { Element rsm = new BaseElement(new QName("set", new Namespace("", "http://jabber.org/protocol/rsm"))); GlobalItemID itemID = new GlobalItemIDImpl(new JID("capulet.lit"), "/user/[email protected]/posts", "item1"); rsm.addElement("after").setText(itemID.toString()); rsm.addElement("max").setText("5"); element.addAttribute("node", node); Mockito.when(channelManager.nodeExists(anyString())).thenReturn(true); Mockito.when(channelManager.getNodeMembership(node, jid)) .thenReturn( new NodeMembershipImpl(node, jid, Subscriptions.subscribed, Affiliations.member, null)); ArrayList<NodeItem> results = new ArrayList<NodeItem>() { { add( new NodeItemImpl( TEST_NODE_1, "entry1", new Date(System.currentTimeMillis()), "<entry><id>entry1</id></entry>")); add( new NodeItemImpl( TEST_NODE_2, "entry2", new Date(System.currentTimeMillis() - 100), "<entry><id>entry2</id></entry>")); } }; Mockito.when( channelManager.getUserFeedItems( Mockito.any(JID.class), Mockito.any(Date.class), Mockito.anyInt(), Mockito.any(GlobalItemID.class), Mockito.anyBoolean())) .thenReturn(new ClosableIteratorImpl<NodeItem>(results.iterator())); Mockito.when( channelManager.getCountUserFeedItems( Mockito.any(JID.class), Mockito.any(Date.class), Mockito.anyBoolean())) .thenReturn(100); userItemsGet.process(element, jid, request, rsm); verify(channelManager) .getUserFeedItems(eq(jid), any(Date.class), eq(5), eq(itemID), Mockito.anyBoolean()); Packet p = queue.poll(100, TimeUnit.MILLISECONDS); // Check the response has a valid rsm element Element rsmOut = p.getElement().element("pubsub").element("set"); assertEquals("Unexpected count returned", "100", rsmOut.element("count").getText()); assertEquals( "Unexpected first returned", TEST_NODE_1 + ",entry1", rsmOut.element("first").getText()); assertEquals( "Unexpected last returned", TEST_NODE_2 + ",entry2", rsmOut.element("last").getText()); }