@Test public void lexicalHandler() throws Exception { Resource testLexicalHandlerXml = new ClassPathResource("testLexicalHandler.xml", getClass()); LexicalHandler expectedLexicalHandler = mockLexicalHandler(); standardReader.setContentHandler(null); standardReader.setProperty("http://xml.org/sax/properties/lexical-handler", expectedLexicalHandler); standardReader.parse(new InputSource(testLexicalHandlerXml.getInputStream())); inputFactory.setProperty("javax.xml.stream.isCoalescing", Boolean.FALSE); inputFactory.setProperty("http://java.sun.com/xml/stream/properties/report-cdata-event", Boolean.TRUE); inputFactory.setProperty("javax.xml.stream.isReplacingEntityReferences", Boolean.FALSE); inputFactory.setProperty("javax.xml.stream.isSupportingExternalEntities", Boolean.FALSE); LexicalHandler actualLexicalHandler = mockLexicalHandler(); willAnswer(invocation -> invocation.getArguments()[0] = "element"). given(actualLexicalHandler).startDTD(anyString(), anyString(), anyString()); AbstractStaxXMLReader staxXmlReader = createStaxXmlReader(testLexicalHandlerXml.getInputStream()); staxXmlReader.setProperty("http://xml.org/sax/properties/lexical-handler", actualLexicalHandler); staxXmlReader.parse(new InputSource()); // TODO: broken comparison since Mockito 2.2 upgrade // verifyIdenticalInvocations(expectedLexicalHandler, actualLexicalHandler); }
private void invokeMessageCreator() { willAnswer(invocation -> { MessageCreator messageCreator = (MessageCreator) invocation.getArguments()[1]; messageCreator.createMessage(null); return null; }).given(this.jmsTemplate).send(eq("myQueue"), any()); }
protected final ContentHandler mockContentHandler() throws Exception { ContentHandler contentHandler = mock(ContentHandler.class); willAnswer(new CopyCharsAnswer()).given(contentHandler).characters(any(char[].class), anyInt(), anyInt()); willAnswer(new CopyCharsAnswer()).given(contentHandler).ignorableWhitespace(any(char[].class), anyInt(), anyInt()); willAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) throws Throwable { invocation.getArguments()[3] = new AttributesImpl((Attributes) invocation.getArguments()[3]); return null; } }).given(contentHandler).startElement(anyString(), anyString(), anyString(), any(Attributes.class)); return contentHandler; }
private LexicalHandler mockLexicalHandler() throws Exception { LexicalHandler lexicalHandler = mock(LexicalHandler.class); willAnswer(new CopyCharsAnswer()).given(lexicalHandler).comment(any(char[].class), anyInt(), anyInt()); return lexicalHandler; }
@Before public void setup() throws JMSException { Mockito.reset(this.mockJmsTemplate); TextMessage message = mock(TextMessage.class); willReturn(new SimpleMessageConverter()) .given(this.mockJmsTemplate).getMessageConverter(); willReturn(message) .given(this.mockJmsTemplate).receiveSelected(isNull()); willAnswer((Answer<String>) invocation -> testMessageHolder.get()) .given(message).getText(); }
private void stubSetRunning(final CountDownLatch listenerConsumerAvailableLatch, final CountDownLatch listenerConsumerStartLatch, KafkaMessageListenerContainer<Integer, String> resettingContainer) { willAnswer(invocation -> { listenerConsumerAvailableLatch.countDown(); try { assertThat(listenerConsumerStartLatch.await(10, TimeUnit.SECONDS)).isTrue(); } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw new IllegalStateException(e); } return invocation.callRealMethod(); }).given(resettingContainer).setRunning(true); }
private KafkaMessageListenerContainer<Integer, String> spyOnContainer(KafkaMessageListenerContainer<Integer, String> container, final CountDownLatch stubbingComplete) { KafkaMessageListenerContainer<Integer, String> spy = spy(container); willAnswer(i -> { if (stubbingComplete.getCount() > 0 && Thread.currentThread().getName().endsWith("-C-1")) { try { stubbingComplete.await(10, TimeUnit.SECONDS); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } return i.callRealMethod(); }).given(spy).isRunning(); return spy; }
@SuppressWarnings("unchecked") @Test public void testBatchFilter() throws Exception { BatchAcknowledgingMessageListener<String, String> listener = mock(BatchAcknowledgingMessageListener.class); FilteringBatchMessageListenerAdapter<String, String> adapter = new FilteringBatchMessageListenerAdapter<String, String>(listener, r -> false); List<ConsumerRecord<String, String>> consumerRecords = new ArrayList<>(); final CountDownLatch latch = new CountDownLatch(1); willAnswer(i -> { latch.countDown(); return null; }).given(listener).onMessage(any(List.class), any(Acknowledgment.class)); Acknowledgment ack = mock(Acknowledgment.class); adapter.onMessage(consumerRecords, ack, null); assertThat(latch.await(10, TimeUnit.SECONDS)).isTrue(); verify(ack, never()).acknowledge(); }
@Test public void testBlockingReceiveWithTimeoutEmptyThenSend() throws Exception { Queue<Message<?>> queue = spy(new ArrayDeque<>()); CountDownLatch pollLatch = new CountDownLatch(1); AtomicBoolean first = new AtomicBoolean(true); willAnswer(i -> { pollLatch.countDown(); return first.getAndSet(false) ? null : i.callRealMethod(); }).given(queue).poll(); final QueueChannel channel = new QueueChannel(queue); final CountDownLatch latch = new CountDownLatch(1); ExecutorService exec = Executors.newSingleThreadExecutor(); exec.execute(() -> { Message<?> message = channel.receive(10000); if (message != null) { latch.countDown(); } }); assertTrue(pollLatch.await(10, TimeUnit.SECONDS)); channel.send(new GenericMessage<>("testing")); assertTrue(latch.await(10, TimeUnit.SECONDS)); exec.shutdownNow(); }
@Test public void testBlockingReceiveNoTimeoutEmptyThenSend() throws Exception { Queue<Message<?>> queue = spy(new ArrayDeque<>()); CountDownLatch pollLatch = new CountDownLatch(1); AtomicBoolean first = new AtomicBoolean(true); willAnswer(i -> { pollLatch.countDown(); return first.getAndSet(false) ? null : i.callRealMethod(); }).given(queue).poll(); final QueueChannel channel = new QueueChannel(queue); final CountDownLatch latch = new CountDownLatch(1); ExecutorService exec = Executors.newSingleThreadExecutor(); exec.execute(() -> { Message<?> message = channel.receive(); if (message != null) { latch.countDown(); } }); assertTrue(pollLatch.await(10, TimeUnit.SECONDS)); channel.send(new GenericMessage<>("testing")); assertTrue(latch.await(10, TimeUnit.SECONDS)); exec.shutdownNow(); }
@Test public void testAutoCreateChannel() { ConfigurableListableBeanFactory beanFactory = mock(ConfigurableListableBeanFactory.class, withSettings().extraInterfaces(BeanDefinitionRegistry.class)); given(beanFactory.getBean("channel", MessageChannel.class)).willThrow(NoSuchBeanDefinitionException.class); willAnswer(invocation -> invocation.getArgument(0)) .given(beanFactory).initializeBean(any(DirectChannel.class), eq("channel")); willAnswer(invocation -> invocation.getArgument(0)) .given(beanFactory).initializeBean(any(MessageHandler.class), eq("foo.foo.serviceActivator.handler")); MessagingAnnotationPostProcessor mapp = new MessagingAnnotationPostProcessor(); mapp.setBeanFactory(beanFactory); mapp.afterPropertiesSet(); mapp.postProcessAfterInitialization(new Foo(), "foo"); verify(beanFactory).registerSingleton(eq("channel"), any(DirectChannel.class)); }
@Test public void testAdvice() throws Exception { BoundRabbitChannelAdvice advice = this.config.advice(this.config.template()); Log logger = spy(TestUtils.getPropertyValue(advice, "logger", Log.class)); new DirectFieldAccessor(advice).setPropertyValue("logger", logger); willReturn(true).given(logger).isDebugEnabled(); final CountDownLatch latch = new CountDownLatch(1); willAnswer(i -> { latch.countDown(); return i.callRealMethod(); }).given(logger).debug(anyString()); this.gate.send("a,b,c"); assertTrue(this.config.latch.await(10, TimeUnit.SECONDS)); assertTrue(latch.await(10, TimeUnit.SECONDS)); assertThat(this.config.received).containsExactly("A", "B", "C"); }
@Bean public CachingConnectionFactory cf() throws Exception { ConnectionFactory cf = mock(ConnectionFactory.class); cf.setHost("localhost"); cf = spy(cf); willAnswer(i -> { this.connection = mock(Connection.class); willAnswer(ii -> { this.channel = mock(Channel.class); given(this.channel.isOpen()).willReturn(true); return this.channel; }).given(this.connection).createChannel(); return this.connection; }).given(cf).newConnection((ExecutorService) isNull(), anyString()); cf.setAutomaticRecoveryEnabled(false); CachingConnectionFactory ccf = new CachingConnectionFactory(cf); ccf.setSimplePublisherConfirms(true); return ccf; }
@Test public void receiveAndDontMarkAsRead() throws Exception { AbstractMailReceiver receiver = new ImapMailReceiver(); ((ImapMailReceiver) receiver).setShouldMarkMessagesAsRead(false); receiver = spy(receiver); receiver.setBeanFactory(mock(BeanFactory.class)); receiver.afterPropertiesSet(); Field folderField = AbstractMailReceiver.class.getDeclaredField("folder"); folderField.setAccessible(true); Folder folder = mock(Folder.class); given(folder.getPermanentFlags()).willReturn(new Flags(Flags.Flag.USER)); folderField.set(receiver, folder); Message msg1 = mock(MimeMessage.class); Message msg2 = mock(MimeMessage.class); final Message[] messages = new Message[] { msg1, msg2 }; willAnswer(invocation -> null).given(receiver).openFolder(); willAnswer(invocation -> messages).given(receiver).searchForNewMessages(); willAnswer(invocation -> null).given(receiver).fetchMessages(messages); receiver.afterPropertiesSet(); receiver.receive(); verify(msg1, times(0)).setFlag(Flag.SEEN, true); verify(msg2, times(0)).setFlag(Flag.SEEN, true); }
@Test public void to() throws InterruptedException { MessagingTemplate messagingTemplate = new MessagingTemplate(); CountDownLatch callLatch = new CountDownLatch(1); MessageHandler handler = mock(MessageHandler.class); willAnswer(invocation -> { Message<?> message = invocation.getArgument(0); String chatToUser = (String) message.getHeaders().get(XmppHeaders.TO); assertNotNull(chatToUser); assertEquals("test1@example.org", chatToUser); callLatch.countDown(); return null; }) .given(handler) .handleMessage(Mockito.any(Message.class)); this.output.subscribe(handler); messagingTemplate.send(this.input, MessageBuilder.withPayload("foo").build()); assertTrue(callLatch.await(10, TimeUnit.SECONDS)); verify(handler, times(1)).handleMessage(Mockito.any(Message.class)); }
private AbstractMailReceiver receiveAndMarkAsReadDontDeleteGuts(AbstractMailReceiver receiver, Message msg1, Message msg2) throws NoSuchFieldException, IllegalAccessException, MessagingException { ((ImapMailReceiver) receiver).setShouldMarkMessagesAsRead(true); receiver = spy(receiver); receiver.setBeanFactory(mock(BeanFactory.class)); receiver.afterPropertiesSet(); Field folderField = AbstractMailReceiver.class.getDeclaredField("folder"); folderField.setAccessible(true); Folder folder = mock(Folder.class); given(folder.getPermanentFlags()).willReturn(new Flags(Flags.Flag.USER)); folderField.set(receiver, folder); final Message[] messages = new Message[] { msg1, msg2 }; willAnswer(invocation -> { DirectFieldAccessor accessor = new DirectFieldAccessor(invocation.getMock()); int folderOpenMode = (int) accessor.getPropertyValue("folderOpenMode"); if (folderOpenMode != Folder.READ_WRITE) { throw new IllegalArgumentException("Folder had to be open in READ_WRITE mode"); } return null; }).given(receiver).openFolder(); willAnswer(invocation -> messages).given(receiver).searchForNewMessages(); willAnswer(invocation -> null).given(receiver).fetchMessages(messages); receiver.receive(); return receiver; }
@Test public void testExceptionFromLock() throws Exception { Lock mockLock = mock(Lock.class); AtomicBoolean exceptionThrown = new AtomicBoolean(); willAnswer(invocation -> { if (!exceptionThrown.getAndSet(true)) { throw new RuntimeException("lock is broken"); } else { return true; } }).given(mockLock).tryLock(anyLong(), any(TimeUnit.class)); LockRegistry registry = lockKey -> mockLock; CountDownLatch onGranted = new CountDownLatch(1); LockRegistryLeaderInitiator another = new LockRegistryLeaderInitiator(registry); another.setLeaderEventPublisher(new CountingPublisher(onGranted)); another.start(); assertTrue(onGranted.await(10, TimeUnit.SECONDS)); assertTrue(another.getContext().isLeader()); assertTrue(exceptionThrown.get()); another.stop(); }
@Test public void testDontCreateChannelWhenChannelHasBadDefinition() { ConfigurableListableBeanFactory beanFactory = mock(ConfigurableListableBeanFactory.class, withSettings().extraInterfaces(BeanDefinitionRegistry.class)); given(beanFactory.getBean("channel", MessageChannel.class)).willThrow(BeanCreationException.class); willAnswer(invocation -> invocation.getArgument(0)) .given(beanFactory).initializeBean(any(DirectChannel.class), eq("channel")); willAnswer(invocation -> invocation.getArgument(0)) .given(beanFactory).initializeBean(any(MessageHandler.class), eq("foo.foo.serviceActivator.handler")); MessagingAnnotationPostProcessor mapp = new MessagingAnnotationPostProcessor(); mapp.setBeanFactory(beanFactory); mapp.afterPropertiesSet(); try { mapp.postProcessAfterInitialization(new Foo(), "foo"); fail("Expected a DestinationResolutionException"); } catch (DestinationResolutionException e) { assertThat(e.getMessage(), containsString("A bean definition with name 'channel' exists, but failed to be created")); } }
@Test public void testAsyncDelayExpression() { ConnectionFactory connectionFactory = mock(ConnectionFactory.class); AsyncRabbitTemplate amqpTemplate = spy(new AsyncRabbitTemplate(new RabbitTemplate(connectionFactory), new SimpleMessageListenerContainer(connectionFactory), "replyTo")); amqpTemplate.setTaskScheduler(mock(TaskScheduler.class)); AsyncAmqpOutboundGateway gateway = new AsyncAmqpOutboundGateway(amqpTemplate); willAnswer( invocation -> amqpTemplate.new RabbitMessageFuture("foo", invocation.getArgument(2))) .given(amqpTemplate).sendAndReceive(anyString(), anyString(), any(Message.class)); gateway.setExchangeName("foo"); gateway.setRoutingKey("bar"); gateway.setDelayExpressionString("42"); gateway.setBeanFactory(mock(BeanFactory.class)); gateway.setOutputChannel(new NullChannel()); gateway.afterPropertiesSet(); gateway.start(); ArgumentCaptor<Message> captor = ArgumentCaptor.forClass(Message.class); gateway.handleMessage(new GenericMessage<>("foo")); verify(amqpTemplate).sendAndReceive(eq("foo"), eq("bar"), captor.capture()); assertThat(captor.getValue().getMessageProperties().getDelay(), equalTo(42)); }
@Test public void testHeaderMapperWinsAdapter() { ConnectionFactory connectionFactory = mock(ConnectionFactory.class); RabbitTemplate amqpTemplate = spy(new RabbitTemplate(connectionFactory)); AmqpOutboundEndpoint endpoint = new AmqpOutboundEndpoint(amqpTemplate); endpoint.setHeadersMappedLast(true); final AtomicReference<Message> amqpMessage = new AtomicReference<Message>(); willAnswer(invocation -> { amqpMessage.set(invocation.getArgument(2)); return null; }).given(amqpTemplate).send(isNull(), isNull(), any(Message.class), isNull()); org.springframework.messaging.Message<?> message = MessageBuilder.withPayload("foo") .setHeader(MessageHeaders.CONTENT_TYPE, "bar") .build(); endpoint.handleMessage(message); assertNotNull(amqpMessage.get()); assertEquals("bar", amqpMessage.get().getMessageProperties().getContentType()); }