method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
DestinationUpdateRequestAdapter implements UpdateRequestAdapter<DestinationUpdateRequest> { @Override public void adapt(DestinationUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withDestination(new Destination(updateRequest.getBroker(), Optional.ofNullable(updateRequest.getDestination()))); } @Override void adapt(DestinationUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }### Answer:
@Test public void verifyDestinationAdaptedCorrectly() { underTest.adapt(new DestinationUpdateRequest(BROKER_NAME, DESTINATION_NAME), failedMessageBuilder); verify(failedMessageBuilder).withDestination(new Destination(BROKER_NAME, Optional.of(DESTINATION_NAME))); } |
### Question:
PropertiesUpdateRequestAdapter implements UpdateRequestAdapter<PropertiesUpdateRequest> { @Override public void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { updateRequest.getDeletedProperties().forEach(failedMessageBuilder::removeProperty); updateRequest.getUpdatedProperties().forEach(failedMessageBuilder::withProperty); } @Override void adapt(PropertiesUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }### Answer:
@Test public void propertiesAreDeleted() { underTest.adapt(new PropertiesUpdateRequest(Collections.singleton(SOME_KEY), Collections.emptyMap()), failedMessageBuilder); verify(failedMessageBuilder).removeProperty(SOME_KEY); verifyNoMoreInteractions(failedMessageBuilder); }
@Test public void propertiesAreUpdated() { underTest.adapt(new PropertiesUpdateRequest(Collections.emptySet(), Collections.singletonMap(SOME_KEY, SOME_VALUE)), failedMessageBuilder); verify(failedMessageBuilder).withProperty(SOME_KEY, SOME_VALUE); verifyNoMoreInteractions(failedMessageBuilder); } |
### Question:
ContentUpdateRequestAdapter implements UpdateRequestAdapter<ContentUpdateRequest> { @Override public void adapt(ContentUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder) { failedMessageBuilder.withContent(updateRequest.getContent()); } @Override void adapt(ContentUpdateRequest updateRequest, FailedMessageBuilder failedMessageBuilder); }### Answer:
@Test public void verifyMessageContentAdaptedCorrectly() { underTest.adapt(new ContentUpdateRequest("some-content"), failedMessageBuilder); verify(failedMessageBuilder).withContent("some-content"); } |
### Question:
UpdateRequestAdapterRegistry { @SuppressWarnings("unchecked") public <T extends UpdateRequest> UpdateRequestAdapter<T> getAdapter(T updateRequest) { return updateRequestAdapters.getOrDefault(updateRequest.getClass(), defaultUpdateRequestAdapter); } UpdateRequestAdapterRegistry(UpdateRequestAdapter<UpdateRequest> defaultUpdateRequestAdapter); UpdateRequestAdapterRegistry addAdapter(Class<T> clazz, UpdateRequestAdapter<T> adapter); @SuppressWarnings("unchecked") UpdateRequestAdapter<T> getAdapter(T updateRequest); }### Answer:
@Test public void defaultAdapterIsReturnedWhenAdapterNotFoundForClass() { assertThat(underTest.getAdapter(updateRequest), is(defaultUpdateRequestAdapter)); } |
### Question:
FailedMessageSender implements MessageSender { public void send(FailedMessage failedMessage) { try { messageSender.send(failedMessage); failedMessageService.update(failedMessage.getFailedMessageId(), statusUpdateRequest(SENT)); } catch (Exception e) { LOGGER.error("Could not send FailedMessage: " + failedMessage.getFailedMessageId(), e); } } FailedMessageSender(MessageSender messageSender,
FailedMessageService failedMessageService); void send(FailedMessage failedMessage); }### Answer:
@Test public void successfullySendMessage() { when(failedMessage.getFailedMessageId()).thenReturn(FAILED_MESSAGE_ID); underTest.send(failedMessage); verify(messageSender).send(failedMessage); verify(failedMessageService).update(eq(FAILED_MESSAGE_ID), statusUpdateRequest.capture()); assertThat(statusUpdateRequest.getValue(), is(aStatusUpdateRequest(SENT))); } |
### Question:
MongoFailedMessageSearchService implements FailedMessageSearchService { @Override public Collection<FailedMessage> search(SearchFailedMessageRequest request) { final List<FailedMessage> failedMessages = getFailedMessages(mongoSearchRequestAdapter.toQuery(request)); LOGGER.debug("Found {} failedMessages", failedMessages.size()); return failedMessages; } MongoFailedMessageSearchService(MongoCollection<Document> dbCollection,
MongoSearchRequestAdapter mongoSearchRequestAdapter,
FailedMessageConverter failedMessageConverter,
MongoStatusHistoryQueryBuilder mongoStatusHistoryQueryBuilder,
FailedMessageDao failedMessageDao); @Override Collection<FailedMessage> search(SearchFailedMessageRequest request); @Override Collection<FailedMessage> findByStatus(StatusHistoryEvent.Status status); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); }### Answer:
@Test public void search() { failedMessageMongoDao.insert(failedMessageBuilder.build()); when(mongoSearchRequestAdapter.toQuery(request)).thenReturn(new Document()); assertThat(underTest.search(request), contains(aFailedMessage().withFailedMessageId(equalTo(failedMessageId)))); } |
### Question:
MongoFailedMessageSearchService implements FailedMessageSearchService { @Override public Collection<FailedMessage> findByStatus(StatusHistoryEvent.Status status) { final List<FailedMessage> failedMessages = getFailedMessages(mongoStatusHistoryQueryBuilder.currentStatusEqualTo(status)); LOGGER.debug("Found {} failedMessages with status {}", failedMessages.size(), status); return failedMessages; } MongoFailedMessageSearchService(MongoCollection<Document> dbCollection,
MongoSearchRequestAdapter mongoSearchRequestAdapter,
FailedMessageConverter failedMessageConverter,
MongoStatusHistoryQueryBuilder mongoStatusHistoryQueryBuilder,
FailedMessageDao failedMessageDao); @Override Collection<FailedMessage> search(SearchFailedMessageRequest request); @Override Collection<FailedMessage> findByStatus(StatusHistoryEvent.Status status); @Override Optional<FailedMessage> findById(FailedMessageId failedMessageId); }### Answer:
@Test public void findByStatus() { failedMessageMongoDao.insert(failedMessageBuilder.build()); when(mongoStatusHistoryQueryBuilder.currentStatusEqualTo(FAILED)).thenReturn(new Document()); assertThat(underTest.findByStatus(FAILED), contains(aFailedMessage().withFailedMessageId(equalTo(failedMessageId)))); } |
### Question:
MongoSearchResponseAdapter { public SearchFailedMessageResponse toResponse(Document document) { final Destination destination = failedMessageConverter.getDestination(document); final StatusHistoryEvent statusHistoryEvent = failedMessageConverter.getStatusHistoryEvent(document); return newSearchFailedMessageResponse() .withFailedMessageId(failedMessageConverter.getFailedMessageId(document)) .withBroker(destination.getBrokerName()) .withDestination(destination.getName().orElse(null)) .withContent(failedMessageConverter.getContent(document)) .withStatus(toFailedMessageStatus(statusHistoryEvent.getStatus())) .withStatusDateTime(statusHistoryEvent.getEffectiveDateTime()) .build(); } MongoSearchResponseAdapter(FailedMessageConverter failedMessageConverter); SearchFailedMessageResponse toResponse(Document document); }### Answer:
@Test public void convertBasicDBbjectToSearchResponse() { when(failedMessageConverter.getDestination(document)).thenReturn(new Destination("broker-name", Optional.of("queue-name"))); when(failedMessageConverter.getStatusHistoryEvent(document)).thenReturn(new StatusHistoryEvent(StatusHistoryEvent.Status.FAILED, NOW)); when(failedMessageConverter.getFailedMessageId(document)).thenReturn(FAILED_MESSAGE_ID); when(failedMessageConverter.getContent(document)).thenReturn("some-content"); SearchFailedMessageResponse response = underTest.toResponse(document); assertThat(response, new TypeSafeMatcher<SearchFailedMessageResponse>() { @Override public void describeTo(Description description) { } @Override protected boolean matchesSafely(SearchFailedMessageResponse response) { return FAILED_MESSAGE_ID.equals(response.getFailedMessageId()) && "some-content".equals(response.getContent()) && NOW.equals(response.getStatusDateTime()) && FailedMessageStatus.FAILED.equals(response.getStatus()) && "broker-name".equals(response.getBroker()) && Optional.of("queue-name").equals(response.getDestination()); } }); } |
### Question:
SearchFailedMessageResponseAdapter { public SearchFailedMessageResponse toResponse(FailedMessage failedMessage) { return newSearchFailedMessageResponse() .withBroker(failedMessage.getDestination().getBrokerName()) .withContent(failedMessage.getContent()) .withDestination(failedMessage.getDestination().getName().orElse(null)) .withStatus(FailedMessageStatusAdapter.toFailedMessageStatus(failedMessage.getStatusHistoryEvent().getStatus())) .withStatusDateTime(failedMessage.getStatusHistoryEvent().getEffectiveDateTime()) .withFailedMessageId(failedMessage.getFailedMessageId()) .withJmsMessageId(failedMessage.getJmsMessageId()) .withLabels(failedMessage.getLabels()) .build(); } SearchFailedMessageResponse toResponse(FailedMessage failedMessage); }### Answer:
@Test public void destinationNameIsEmpty() { assertThat(underTest.toResponse(failedMessageBuilder.withDestination(new Destination(BROKER_NAME, Optional.empty())).build()), is(aFailedMessage() .withBroker(equalTo(BROKER_NAME)) .withContent(equalTo(SOME_CONTENT)) .withDestination(equalTo(Optional.empty())) .withStatus(FailedMessageStatus.FAILED) .withStatusDateTime(NOW) .withFailedMessageId(equalTo(FAILED_MESSAGE_ID)) .withJmsMessageId(equalTo(JMS_MESSAGE_ID)) .withLabels(contains("foo")) )); }
@Test public void destinationNameIsPopulated() { assertThat(underTest.toResponse(failedMessageBuilder.withDestination(new Destination(BROKER_NAME, Optional.of(DESTINATION_NAME))).build()), is(aFailedMessage() .withBroker(equalTo(BROKER_NAME)) .withContent(equalTo(SOME_CONTENT)) .withDestination(equalTo(Optional.of(DESTINATION_NAME))) .withStatus(FailedMessageStatus.FAILED) .withStatusDateTime(NOW) .withFailedMessageId(equalTo(FAILED_MESSAGE_ID)) .withJmsMessageId(equalTo(JMS_MESSAGE_ID)) .withLabels(contains("foo")) )); } |
### Question:
ActiveMQDestinationExtractor implements DestinationExtractor<ActiveMQMessage> { @Override public Destination extractDestination(ActiveMQMessage message) { return new Destination( brokerName, ofNullable(message.getOriginalDestination()) .map(ActiveMQDestination::getPhysicalName) ); } ActiveMQDestinationExtractor(String brokerName); @Override Destination extractDestination(ActiveMQMessage message); }### Answer:
@Test public void createWhenOriginalDestinationPresent() { ActiveMQMessage message = mock(ActiveMQMessage.class); when(message.getOriginalDestination()).thenReturn(new ActiveMQQueue("queue.name")); Destination destination = underTest.extractDestination(message); assertThat(destination, equalTo(new Destination("internal", Optional.of("queue.name")))); }
@Test public void createWhenOriginalDestinationNotPresent() { ActiveMQMessage message = mock(ActiveMQMessage.class); when(message.getOriginalDestination()).thenReturn(null); Destination destination = underTest.extractDestination(message); assertThat(destination, is(aDestination().withBrokerName("internal").withNoName())); } |
### Question:
ResendScheduledExecutorsResource { @ApiOperation("Start the resend executor for the given broker") @POST @Path("/start") public void start( @ApiParam(value = "name of the broker as defined in application.yml", required = true) @PathParam("brokerName") String brokerName) { getExecutor(brokerName).start(); } ResendScheduledExecutorsResource(Map<String, ResendScheduledExecutorService> resendScheduledExecutors); @ApiOperation("Start the resend executor for the given broker") @POST @Path("/start") void start(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); @ApiOperation("Synchronously execute the resend job for the given broker") @POST @Path("/execute") void execute(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); @ApiOperation("Pause the resend executor for the given broker") @PUT @Path("/pause") void pause(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); }### Answer:
@Test(expected = BadRequestException.class) public void startThrowsABadRequestExceptionIfBrokerIsUnknown() { underTest.start("unknown-broker"); }
@Test public void startResendScheduledExecutorService() { underTest.start("internal-broker"); verify(resendScheduledExecutorService).start(); } |
### Question:
QueueBrowserService { public void browse() { jmsTemplate.browse(queueName, browserCallback); } QueueBrowserService(BrowserCallback<T> browserCallback,
JmsTemplate jmsTemplate,
String brokerName,
String queueName); void browse(); String getBrokerName(); }### Answer:
@Test public void browseDelegatesToJmsTemplate() { underTest.browse(); verify(jmsTemplate).browse("some-queue", browserCallback); } |
### Question:
QueueBrowserService { public String getBrokerName() { return brokerName; } QueueBrowserService(BrowserCallback<T> browserCallback,
JmsTemplate jmsTemplate,
String brokerName,
String queueName); void browse(); String getBrokerName(); }### Answer:
@Test public void brokerNameIsAvailable() { assertThat(underTest.getBrokerName(), is("some-broker")); } |
### Question:
QueueBrowserCallback implements BrowserCallback<Long> { @Override public Long doInJms(Session session, QueueBrowser browser) throws JMSException { long records = 0; LOGGER.debug("Browsing messages on {}", browser.getQueue()); final Enumeration enumeration = browser.getEnumeration(); while (enumeration.hasMoreElements()) { final Message message = (Message) enumeration.nextElement(); failedMessageListener.onMessage(message); records++; } LOGGER.debug("Processed {} messages on {}", records, browser.getQueue()); return records; } QueueBrowserCallback(FailedMessageListener failedMessageListener); @Override Long doInJms(Session session, QueueBrowser browser); }### Answer:
@Test public void noMessagesToBrowse() throws JMSException { when(queueBrowser.getEnumeration()).thenReturn(enumeration); when(enumeration.hasMoreElements()).thenReturn(false); assertThat(underTest.doInJms(session, queueBrowser), is(0L)); verifyZeroInteractions(failedMessageListener); }
@Test public void messagesToBrowse() throws JMSException { when(queueBrowser.getEnumeration()).thenReturn(enumeration); when(enumeration.hasMoreElements()).thenReturn(true).thenReturn(true).thenReturn(false); when(enumeration.nextElement()).thenReturn(textMessage1).thenReturn(textMessage2); assertThat(underTest.doInJms(session, queueBrowser), is(2L)); verify(failedMessageListener).onMessage(textMessage1); verify(failedMessageListener).onMessage(textMessage2); verifyZeroInteractions(failedMessageListener); } |
### Question:
QueueBrowserServiceBeanDefinitionFactory { public AbstractBeanDefinition create(String queueBrowserCallbackBeanName, String jmsTemplateBeanName, String brokerName, String queueName) { return genericBeanDefinition(QueueBrowserService.class) .addConstructorArgReference(queueBrowserCallbackBeanName) .addConstructorArgReference(jmsTemplateBeanName) .addConstructorArgValue(brokerName) .addConstructorArgValue(queueName) .getBeanDefinition(); } AbstractBeanDefinition create(String queueBrowserCallbackBeanName,
String jmsTemplateBeanName,
String brokerName,
String queueName); String createBeanName(String brokerName); }### Answer:
@Test public void createQueueBrowserServiceBeanDefinition() { AbstractBeanDefinition abstractBeanDefinition = underTest.create("queueBrowserCallback", "messageSender", BROKER_NAME, QUEUE_NAME); assertThat(abstractBeanDefinition.getBeanClass(), typeCompatibleWith(QueueBrowserService.class)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getIndexedArgumentValues().size(), is(4)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(0, BrowserCallback.class).getValue(), is(equalTo(new RuntimeBeanReference("queueBrowserCallback")))); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(1, JmsTemplate.class).getValue(), is(equalTo(new RuntimeBeanReference("messageSender")))); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(2, String.class).getValue(), is(BROKER_NAME)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(3, String.class).getValue(), is(QUEUE_NAME)); } |
### Question:
QueueBrowserServiceBeanDefinitionFactory { public String createBeanName(String brokerName) { return QUEUE_BROWSER_SERVICE_BEAN_NAME_PREFIX + brokerName; } AbstractBeanDefinition create(String queueBrowserCallbackBeanName,
String jmsTemplateBeanName,
String brokerName,
String queueName); String createBeanName(String brokerName); }### Answer:
@Test public void createBeanName() { assertThat(underTest.createBeanName(BROKER_NAME), is(equalTo(QUEUE_BROWSER_SERVICE_BEAN_NAME_PREFIX + BROKER_NAME))); } |
### Question:
ResendScheduledExecutorsResource { @ApiOperation("Synchronously execute the resend job for the given broker") @POST @Path("/execute") public void execute( @ApiParam(value = "name of the broker as defined in application.yml", required = true) @PathParam("brokerName") String brokerName) { getExecutor(brokerName).execute(); } ResendScheduledExecutorsResource(Map<String, ResendScheduledExecutorService> resendScheduledExecutors); @ApiOperation("Start the resend executor for the given broker") @POST @Path("/start") void start(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); @ApiOperation("Synchronously execute the resend job for the given broker") @POST @Path("/execute") void execute(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); @ApiOperation("Pause the resend executor for the given broker") @PUT @Path("/pause") void pause(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); }### Answer:
@Test(expected = BadRequestException.class) public void executeThrowsABadRequestExceptionIfBrokerIsUnknown() { underTest.execute("unknown-broker"); }
@Test public void executeResendScheduledExecutorService() { underTest.execute("internal-broker"); verify(resendScheduledExecutorService).execute(); } |
### Question:
QueueBrowserScheduledExecutorServiceBeanDefinitionFactory { public AbstractBeanDefinition create(ScheduledExecutorService executorService, String queueBrowserServiceBeanName, long initialDelay, long executionFrequency, TimeUnit timeUnit) { return genericBeanDefinition(QueueBrowserScheduledExecutorService.class) .addConstructorArgValue(executorService) .addConstructorArgReference(queueBrowserServiceBeanName) .addConstructorArgValue(initialDelay) .addConstructorArgValue(executionFrequency) .addConstructorArgValue(timeUnit) .setInitMethodName("start") .setDestroyMethodName("shutdown") .getBeanDefinition(); } AbstractBeanDefinition create(ScheduledExecutorService executorService,
String queueBrowserServiceBeanName,
long initialDelay,
long executionFrequency,
TimeUnit timeUnit); String createBeanName(String brokerName); static final String QUEUE_BROWSER_SCHEDULED_EXECUTOR_SERVICE_BEAN_NAME_PREFIX; }### Answer:
@Test public void createResendScheduledExecutorServiceBeanDefinition(){ AbstractBeanDefinition abstractBeanDefinition = underTest.create( executorService, "queueBrowserService", 0, 10, SECONDS); assertThat(abstractBeanDefinition.getBeanClass(), typeCompatibleWith(QueueBrowserScheduledExecutorService.class)); ConstructorArgumentValues constructorArgumentValues = abstractBeanDefinition.getConstructorArgumentValues(); assertThat(constructorArgumentValues.getIndexedArgumentValues().size(), is(5)); assertThat(constructorArgumentValues.getArgumentValue(0, ExecutorService.class).getValue(), is(executorService)); assertThat(constructorArgumentValues.getArgumentValue(1, QueueBrowserService.class).getValue(), is(equalTo(new RuntimeBeanReference("queueBrowserService")))); assertThat(constructorArgumentValues.getArgumentValue(2, Long.class).getValue(), is(0L)); assertThat(constructorArgumentValues.getArgumentValue(3, Long.class).getValue(), is(10L)); assertThat(constructorArgumentValues.getArgumentValue(4, TimeUnit.class).getValue(), is(SECONDS)); } |
### Question:
QueueBrowserScheduledExecutorServiceBeanDefinitionFactory { public String createBeanName(String brokerName) { return QUEUE_BROWSER_SCHEDULED_EXECUTOR_SERVICE_BEAN_NAME_PREFIX + brokerName; } AbstractBeanDefinition create(ScheduledExecutorService executorService,
String queueBrowserServiceBeanName,
long initialDelay,
long executionFrequency,
TimeUnit timeUnit); String createBeanName(String brokerName); static final String QUEUE_BROWSER_SCHEDULED_EXECUTOR_SERVICE_BEAN_NAME_PREFIX; }### Answer:
@Test public void createBeanName() throws Exception { assertThat(underTest.createBeanName(BROKER_NAME), is(equalTo(QUEUE_BROWSER_SCHEDULED_EXECUTOR_SERVICE_BEAN_NAME_PREFIX + BROKER_NAME))); } |
### Question:
ActiveMQConnectionFactoryFactoryBeanDefinitionFactory { public AbstractBeanDefinition create(String brokerName) { return genericBeanDefinition(ActiveMQConnectionFactoryFactory.class) .addConstructorArgValue(brokerName) .addConstructorArgReference("jmsListenerProperties") .getBeanDefinition(); } AbstractBeanDefinition create(String brokerName); String createBeanName(String brokerName); }### Answer:
@Test public void createABeanDefinitionForActiveMqConnectionFactory() throws Exception { AbstractBeanDefinition abstractBeanDefinition = underTest.create(BROKER_NAME); assertThat(abstractBeanDefinition.getBeanClass(), typeCompatibleWith(ActiveMQConnectionFactoryFactory.class)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(0, String.class).getValue(), is(BROKER_NAME)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(1, JmsListenerProperties.class, "jmsListenerProperties").getValue(), is(new RuntimeBeanReference("jmsListenerProperties"))); } |
### Question:
ResendScheduledExecutorsResource { @ApiOperation("Pause the resend executor for the given broker") @PUT @Path("/pause") public void pause( @ApiParam(value = "name of the broker as defined in application.yml", required = true) @PathParam("brokerName") String brokerName) { getExecutor(brokerName).pause(); } ResendScheduledExecutorsResource(Map<String, ResendScheduledExecutorService> resendScheduledExecutors); @ApiOperation("Start the resend executor for the given broker") @POST @Path("/start") void start(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); @ApiOperation("Synchronously execute the resend job for the given broker") @POST @Path("/execute") void execute(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); @ApiOperation("Pause the resend executor for the given broker") @PUT @Path("/pause") void pause(
@ApiParam(value = "name of the broker as defined in application.yml", required = true)
@PathParam("brokerName") String brokerName); }### Answer:
@Test(expected = BadRequestException.class) public void pauseThrowsABadRequestExceptionIfBrokerIsUnknown() { underTest.pause("unknown-broker"); }
@Test public void pauseResendScheduledExecutorService() { underTest.pause("internal-broker"); verify(resendScheduledExecutorService).pause(); } |
### Question:
ActiveMQConnectionFactoryFactoryBeanDefinitionFactory { public String createBeanName(String brokerName) { return FACTORY_BEAN_NAME_PREFIX + brokerName; } AbstractBeanDefinition create(String brokerName); String createBeanName(String brokerName); }### Answer:
@Test public void createBeanName() throws Exception { assertThat(underTest.createBeanName("foo"), is(equalTo(FACTORY_BEAN_NAME_PREFIX + "foo"))); } |
### Question:
FailedMessageListenerBeanDefinitionFactory { public AbstractBeanDefinition create(String brokerName) { return genericBeanDefinition(FailedMessageListener.class) .addConstructorArgValue(activeMQFailedMessageFactoryFactory.apply(brokerName)) .addConstructorArgReference("failedMessageProcessor") .getBeanDefinition(); } FailedMessageListenerBeanDefinitionFactory(Function<String, ActiveMQFailedMessageFactory> activeMQFailedMessageFactoryFactory); AbstractBeanDefinition create(String brokerName); String createBeanName(String brokerName); static final String FAILED_MESSAGE_LISTENER_BEAN_NAME_PREFIX; }### Answer:
@Test public void createFailedMessageListenerBeanDefinition() { AbstractBeanDefinition abstractBeanDefinition = underTest.create(BROKER_NAME); assertThat(abstractBeanDefinition.getBeanClass(), typeCompatibleWith(FailedMessageListener.class)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getIndexedArgumentValues().size(), is(2)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(0, ActiveMQFailedMessageFactory.class).getValue(), is(activeMQFailedMessageFactory)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(1, ActiveMQFailedMessageFactory.class).getValue(), is(equalTo(new RuntimeBeanReference("failedMessageProcessor")))); } |
### Question:
FailedMessageListenerBeanDefinitionFactory { public String createBeanName(String brokerName) { return FAILED_MESSAGE_LISTENER_BEAN_NAME_PREFIX + brokerName; } FailedMessageListenerBeanDefinitionFactory(Function<String, ActiveMQFailedMessageFactory> activeMQFailedMessageFactoryFactory); AbstractBeanDefinition create(String brokerName); String createBeanName(String brokerName); static final String FAILED_MESSAGE_LISTENER_BEAN_NAME_PREFIX; }### Answer:
@Test public void createBeanName() { assertThat(underTest.createBeanName(BROKER_NAME), is(equalTo(FAILED_MESSAGE_LISTENER_BEAN_NAME_PREFIX + BROKER_NAME))); } |
### Question:
NamedMessageListenerContainerBeanDefinitionFactory { public AbstractBeanDefinition create(String brokerName, String connectionFactoryBeanName, String queueName, String failedMessageListenerBeanName) { LOGGER.debug("Creating NamedMessageListenerContainer BeanDefinition for {}", brokerName); return genericBeanDefinition(NamedMessageListenerContainer.class) .addConstructorArgValue(brokerName) .addPropertyReference("connectionFactory", connectionFactoryBeanName) .addPropertyValue("destinationName", queueName) .addPropertyReference("messageListener", failedMessageListenerBeanName) .getBeanDefinition(); } AbstractBeanDefinition create(String brokerName,
String connectionFactoryBeanName,
String queueName,
String failedMessageListenerBeanName); String createBeanName(String brokerName); static final String NAMED_MESSAGE_LISTENER_CONTAINER_BEAN_NAME_PREFIX; }### Answer:
@Test public void createBeanDefinitionForDefaultMessageListenerContainer() { AbstractBeanDefinition abstractBeanDefinition = underTest.create( BROKER_NAME, CONNECTION_FACTORY_BEAN_NAME, QUEUE_NAME, FAILED_MESSAGE_LISTENER_BEAN_NAME ); assertThat(abstractBeanDefinition.getBeanClass(), typeCompatibleWith(NamedMessageListenerContainer.class)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getIndexedArgumentValues().size(), is(1)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(0, String.class).getValue(), is(BROKER_NAME)); MutablePropertyValues propertyValues = abstractBeanDefinition.getPropertyValues(); assertThat(propertyValues.size(), is(3)); assertThat(propertyValues.getPropertyValue("connectionFactory").getValue(), is(equalTo(new RuntimeBeanReference(CONNECTION_FACTORY_BEAN_NAME)))); assertThat(propertyValues.getPropertyValue("destinationName").getValue(), is(QUEUE_NAME)); assertThat(propertyValues.getPropertyValue("messageListener").getValue(), is(equalTo(new RuntimeBeanReference(FAILED_MESSAGE_LISTENER_BEAN_NAME)))); } |
### Question:
NamedMessageListenerContainerBeanDefinitionFactory { public String createBeanName(String brokerName) { return NAMED_MESSAGE_LISTENER_CONTAINER_BEAN_NAME_PREFIX + brokerName; } AbstractBeanDefinition create(String brokerName,
String connectionFactoryBeanName,
String queueName,
String failedMessageListenerBeanName); String createBeanName(String brokerName); static final String NAMED_MESSAGE_LISTENER_CONTAINER_BEAN_NAME_PREFIX; }### Answer:
@Test public void createBeanName() throws Exception { assertThat(underTest.createBeanName("foo"), is(equalTo(NAMED_MESSAGE_LISTENER_CONTAINER_BEAN_NAME_PREFIX + "foo"))); } |
### Question:
ActiveMQConnectionFactoryBeanDefinitionFactory { public AbstractBeanDefinition create(String nameOfFactoryBean) { return genericBeanDefinition(ActiveMQConnectionFactory.class) .setFactoryMethodOnBean("create", nameOfFactoryBean) .getBeanDefinition(); } AbstractBeanDefinition create(String nameOfFactoryBean); String createBeanName(String brokerName); static final String ACTIVE_MQ_CONNECTION_FACTORY_BEAN_NAME_PREFIX; }### Answer:
@Test public void createABeanDefinitionForActiveMqConnectionFactory() throws Exception { AbstractBeanDefinition abstractBeanDefinition = underTest.create(NAME_OF_FACTORY_BEAN); assertThat(abstractBeanDefinition.getBeanClass(), typeCompatibleWith(ActiveMQConnectionFactory.class)); assertThat(abstractBeanDefinition.getFactoryMethodName(), is("create")); assertThat(abstractBeanDefinition.getFactoryBeanName(), is(NAME_OF_FACTORY_BEAN)); } |
### Question:
ActiveMQConnectionFactoryBeanDefinitionFactory { public String createBeanName(String brokerName) { return ACTIVE_MQ_CONNECTION_FACTORY_BEAN_NAME_PREFIX + brokerName; } AbstractBeanDefinition create(String nameOfFactoryBean); String createBeanName(String brokerName); static final String ACTIVE_MQ_CONNECTION_FACTORY_BEAN_NAME_PREFIX; }### Answer:
@Test public void createBeanName() throws Exception { assertThat(underTest.createBeanName("foo"), is(equalTo(ACTIVE_MQ_CONNECTION_FACTORY_BEAN_NAME_PREFIX + "foo"))); } |
### Question:
MustachePageRenderer { public void render(Page page, OutputStream output) throws IOException { try { final Mustache template = mustacheFactory.compile(page.getTemplate()); try (OutputStreamWriter writer = new OutputStreamWriter(output, UTF_8)) { template.execute(writer, Arrays.asList( page )); } } catch (Throwable e) { throw new RuntimeException("Mustache template error: " + page.getTemplate(), e); } } MustachePageRenderer(MustacheFactory mustacheFactory); void render(Page page, OutputStream output); }### Answer:
@Test public void testRenderPage() throws Exception { try (ByteArrayOutputStream output = new ByteArrayOutputStream()) { underTest.render(new TestPage(), output); assertThat(output.toString(), containsString("<p>some content</p>")); } } |
### Question:
FailedMessageListPage extends Page { public boolean isPopupRendered() { return popupRendered; } FailedMessageListPage(boolean popupRendered); boolean isPopupRendered(); }### Answer:
@Test public void createFailedMessageListPage() { FailedMessageListPage underTest = new FailedMessageListPage(true); assertTrue(underTest.isPopupRendered()); assertEquals("list.mustache", underTest.getTemplate()); } |
### Question:
FailedMessageListController { @GET @Consumes(APPLICATION_JSON) @Produces(TEXT_HTML) public FailedMessageListPage getFailedMessages() { return new FailedMessageListPage(popupRendered); } FailedMessageListController(boolean popupRendered); @GET @Consumes(APPLICATION_JSON) @Produces(TEXT_HTML) FailedMessageListPage getFailedMessages(); }### Answer:
@Test public void getFailedMessageListPage() { final FailedMessageListPage failedMessages = underTest.getFailedMessages(); assertThat(failedMessages.getTemplate(), is(equalTo("list.mustache"))); assertThat(failedMessages.isPopupRendered(), is(true)); } |
### Question:
LabelExtractor { public Set<String> extractLabels(String labels) { return Stream.of(split(labels, ",")) .map(String::trim) .filter(label -> !label.isEmpty()) .collect(toSet()); } Set<String> extractLabels(String labels); }### Answer:
@Test public void emptyStingReturnsEmptySet() throws Exception { assertThat(underTest.extractLabels(""), is(emptyIterable())); }
@Test public void stringContainingWhitespaceReturnsEmptySet() throws Exception { assertThat(underTest.extractLabels(" \t"), is(emptyIterable())); }
@Test public void stringContainingOnlyCommasWhitespaceReturnsEmptySet() throws Exception { assertThat(underTest.extractLabels(" ,,\t,"), is(emptyIterable())); }
@Test public void leadingAndTrailingWhitespaceIsRemovedFromLabels() { assertThat(underTest.extractLabels(" foo , bar\t"), containsInAnyOrder("foo", "bar")); } |
### Question:
FailedMessageChangeResource { @POST @Path("/labels") public String updateLabelsOnFailedMessages(LabelRequest request) { LOGGER.info("Updating the labels on {} failedMessages", request.getChanges().size()); request.getChanges() .forEach(change -> { LOGGER.info("Setting labels on FailedMessage: {} to '{}'", change.getRecid(), change.getLabels()); labelFailedMessageClient.setLabels( fromString(change.getRecid()), labelExtractor.extractLabels(change.getLabels()) ); }); return "{ 'status': 'success' }"; } FailedMessageChangeResource(LabelFailedMessageClient labelFailedMessageClient,
LabelExtractor labelExtractor,
DeleteFailedMessageClient deleteFailedMessageClient); @POST @Path("/labels") String updateLabelsOnFailedMessages(LabelRequest request); @POST @Path("/delete") String deleteFailedMessages(DeleteRequest request); }### Answer:
@Test public void updateLabels() throws Exception { when(labelExtractor.extractLabels("foo, bar")).thenReturn(labels1); when(labelExtractor.extractLabels("black, white")).thenReturn(labels2); String result = underTest.updateLabelsOnFailedMessages( newLabelRequest() .withChange(newChange().withRecid(FAILED_MESSAGE_1_ID).withLabels("foo, bar")) .withChange(newChange().withRecid(FAILED_MESSAGE_2_ID).withLabels("black, white")) .build() ); assertThat(result, is(equalTo("{ 'status': 'success' }"))); verify(labelFailedMessageClient).setLabels(FAILED_MESSAGE_1_ID, labels1); verify(labelFailedMessageClient).setLabels(FAILED_MESSAGE_2_ID, labels2); } |
### Question:
FailedMessageChangeResource { @POST @Path("/delete") public String deleteFailedMessages(DeleteRequest request) { request.getSelected() .forEach(recid -> deleteFailedMessageClient.deleteFailedMessage(fromString(recid))); return "{ 'status': 'success' }"; } FailedMessageChangeResource(LabelFailedMessageClient labelFailedMessageClient,
LabelExtractor labelExtractor,
DeleteFailedMessageClient deleteFailedMessageClient); @POST @Path("/labels") String updateLabelsOnFailedMessages(LabelRequest request); @POST @Path("/delete") String deleteFailedMessages(DeleteRequest request); }### Answer:
@Test public void deleteFailedMessages() { String result = underTest.deleteFailedMessages( newDeleteRequest().withSelectedRecords(FAILED_MESSAGE_1_ID, FAILED_MESSAGE_2_ID).build() ); assertThat(result, is(equalTo("{ 'status': 'success' }"))); verify(deleteFailedMessageClient).deleteFailedMessage(FAILED_MESSAGE_1_ID); verify(deleteFailedMessageClient).deleteFailedMessage(FAILED_MESSAGE_2_ID); } |
### Question:
Constants { public static Optional<String> toIsoDateTimeWithMs(Instant instant) { return Optional.ofNullable(instant).map(ISO_DATE_TIME_WITH_MS::format); } private Constants(); static Optional<String> toIsoDateTimeWithMs(Instant instant); static Optional<Instant> toInstantFromIsoDateTime(String instantAsString); }### Answer:
@Test public void formatNullInstant() { assertEquals(Optional.empty(), Constants.toIsoDateTimeWithMs(null)); }
@Test public void formatGivenInstant() { assertEquals(Optional.of("1970-01-01T00:00:00.000Z"), Constants.toIsoDateTimeWithMs(Instant.ofEpochMilli(0))); } |
### Question:
LoginController { @GET public LoginPage getLoginPage(@Context HttpServletRequest request) { Optional<String> errorMessage = authenticationExceptionAdapter .toErrorMessage((AuthenticationException) request.getSession().getAttribute(AUTHENTICATION_EXCEPTION)); return new LoginPage(errorMessage); } LoginController(AuthenticationExceptionAdapter authenticationExceptionAdapter); @GET LoginPage getLoginPage(@Context HttpServletRequest request); }### Answer:
@Test public void loginPageIsCreatedSuccessfully() throws Exception { when(httpServletRequest.getSession()).thenReturn(httpSession); when(httpSession.getAttribute(AUTHENTICATION_EXCEPTION)).thenReturn(authenticationException); when(authenticationExceptionAdapter.toErrorMessage(authenticationException)).thenReturn(Optional.of("Error Message")); assertThat(underTest.getLoginPage(httpServletRequest), hasErrorMessage("Error Message")); } |
### Question:
AuthenticationExceptionAdapter { public Optional<String> toErrorMessage(AuthenticationException authenticationException) { return Optional.ofNullable(authenticationException) .map(exception -> { String message = exception.getMessage(); LOGGER.debug("Translating error message: {}", message); return "Incorrect username/password"; }); } Optional<String> toErrorMessage(AuthenticationException authenticationException); }### Answer:
@Test public void nullExceptionReturnsEmptyString() throws Exception { assertThat(underTest.toErrorMessage(null), is(Optional.empty())); }
@Test public void anyAuthenticationExceptionReturns() { assertThat(underTest.toErrorMessage(mock(AuthenticationException.class)), is(Optional.of("Incorrect username/password"))); } |
### Question:
SearchFailedMessageRequestAdapter { public SearchFailedMessageRequest adapt(SearchW2UIRequest request) { SearchFailedMessageRequestBuilder searchFailedMessageRequestBuilder = searchMatchingAnyCriteria(); for (Criteria criteria : request.getSearchCriteria()) { criteria.addToSearchRequest(searchFailedMessageRequestBuilder); } return searchFailedMessageRequestBuilder.build(); } SearchFailedMessageRequest adapt(SearchW2UIRequest request); }### Answer:
@Test public void searchWithMultipleCriteria() throws Exception { when(searchW2UIRequest.getSearchCriteria()).thenReturn(Arrays.asList( new Criteria(Criteria.Field.BROKER, Criteria.Operator.BEGINS, "Lorem"), new Criteria(Criteria.Field.CONTENT, Criteria.Operator.ENDS, "Ipsum"), new Criteria(Criteria.Field.DESTINATION, Criteria.Operator.CONTAINS, "Dolor") )); SearchFailedMessageRequest request = underTest.adapt(searchW2UIRequest); assertThat(request, aSearchRequestMatchingAnyCriteria() .withBroker("Lorem") .withContent("Ipsum") .withDestination("Dolor")); }
@Test public void searchWithNoCriteria() throws Exception { when(searchW2UIRequest.getSearchCriteria()).thenReturn(Collections.emptyList()); SearchFailedMessageRequest request = underTest.adapt(searchW2UIRequest); assertThat(request, aSearchRequestMatchingAnyCriteria() .withBroker(equalTo(Optional.empty())) .withContent(equalTo(Optional.empty())) .withDestination(equalTo(Optional.empty()))); } |
### Question:
HistoricStatusPredicate implements Predicate<FailedMessage> { @Override public boolean test(FailedMessage failedMessage) { return failedMessage.getStatusHistoryEvent().getEffectiveDateTime().isBefore(Instant.now()); } @Override boolean test(FailedMessage failedMessage); }### Answer:
@Test public void effectiveDateTimeInPastReturnsTrue() throws Exception { when(failedMessage.getStatusHistoryEvent()).thenReturn(statusHistoryEvent); when(statusHistoryEvent.getEffectiveDateTime()).thenReturn(Instant.now().minus(1, MILLIS)); assertThat(underTest.test(failedMessage), is(true)); }
@Test public void effectiveDateTimeInFutureReturnsFalse() throws Exception { when(failedMessage.getStatusHistoryEvent()).thenReturn(statusHistoryEvent); when(statusHistoryEvent.getEffectiveDateTime()).thenReturn(Instant.now().plus(1, SECONDS)); assertThat(underTest.test(failedMessage), is(false)); } |
### Question:
FailedMessageSenderBeanDefinitionFactory { public AbstractBeanDefinition create(String messageSenderDelegate) { return genericBeanDefinition(FailedMessageSender.class) .addConstructorArgReference(messageSenderDelegate) .addConstructorArgReference("failedMessageService") .addDependsOn("failedMessageDao") .getBeanDefinition(); } AbstractBeanDefinition create(String messageSenderDelegate); String createBeanName(String brokerName); }### Answer:
@Test public void createFailedMessageSenderBeanDefinition() throws Exception { AbstractBeanDefinition abstractBeanDefinition = underTest.create("messageSenderDelegate"); assertThat(abstractBeanDefinition.getBeanClass(), typeCompatibleWith(FailedMessageSender.class)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getIndexedArgumentValues().size(), is(2)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(0, MessageSender.class).getValue(), is(equalTo(new RuntimeBeanReference("messageSenderDelegate")))); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(1, FailedMessageService.class).getValue(), is(equalTo(new RuntimeBeanReference("failedMessageService")))); } |
### Question:
FailedMessageSenderBeanDefinitionFactory { public String createBeanName(String brokerName) { return FAILED_MESSAGE_SENDER_BEAN_NAME_PREFIX + brokerName; } AbstractBeanDefinition create(String messageSenderDelegate); String createBeanName(String brokerName); }### Answer:
@Test public void createBeanName() { assertThat(underTest.createBeanName(BROKER_NAME), is(equalTo(FAILED_MESSAGE_SENDER_BEAN_NAME_PREFIX + BROKER_NAME))); } |
### Question:
ResendScheduledExecutorServiceBeanDefinitionFactory { public AbstractBeanDefinition create(ScheduledExecutorService executorService, String resendFailedMessageServiceBeanName, long initialDelay, long executionFrequency, TimeUnit timeUnit) { return genericBeanDefinition(ResendScheduledExecutorService.class) .addConstructorArgValue(executorService) .addConstructorArgReference(resendFailedMessageServiceBeanName) .addConstructorArgValue(initialDelay) .addConstructorArgValue(executionFrequency) .addConstructorArgValue(timeUnit) .setInitMethodName("start") .setDestroyMethodName("shutdown") .getBeanDefinition(); } AbstractBeanDefinition create(ScheduledExecutorService executorService,
String resendFailedMessageServiceBeanName,
long initialDelay,
long executionFrequency,
TimeUnit timeUnit); String createBeanName(String brokerName); }### Answer:
@Test public void createResendScheduledExecutorServiceBeanDefinition() throws Exception { AbstractBeanDefinition abstractBeanDefinition = underTest.create( executorService, "resendFailedMessageService", 0, 10, SECONDS); assertThat(abstractBeanDefinition.getBeanClass(), typeCompatibleWith(ResendScheduledExecutorService.class)); ConstructorArgumentValues constructorArgumentValues = abstractBeanDefinition.getConstructorArgumentValues(); assertThat(constructorArgumentValues.getIndexedArgumentValues().size(), is(5)); assertThat(constructorArgumentValues.getArgumentValue(0, ExecutorService.class).getValue(), is(executorService)); assertThat(constructorArgumentValues.getArgumentValue(1, ResendFailedMessageService.class).getValue(), is(equalTo(new RuntimeBeanReference("resendFailedMessageService")))); assertThat(constructorArgumentValues.getArgumentValue(2, Long.class).getValue(), is(0L)); assertThat(constructorArgumentValues.getArgumentValue(3, Long.class).getValue(), is(10L)); assertThat(constructorArgumentValues.getArgumentValue(4, TimeUnit.class).getValue(), is(SECONDS)); } |
### Question:
ResendScheduledExecutorServiceBeanDefinitionFactory { public String createBeanName(String brokerName) { return RESEND_SCHEDULED_EXECUTOR_SERVICE_BEAN_NAME_PREFIX + brokerName; } AbstractBeanDefinition create(ScheduledExecutorService executorService,
String resendFailedMessageServiceBeanName,
long initialDelay,
long executionFrequency,
TimeUnit timeUnit); String createBeanName(String brokerName); }### Answer:
@Test public void createBeanName() throws Exception { assertThat(underTest.createBeanName(BROKER_NAME), is(equalTo(RESEND_SCHEDULED_EXECUTOR_SERVICE_BEAN_NAME_PREFIX + BROKER_NAME))); } |
### Question:
ResendFailedMessageServiceBeanDefinitionFactory { public AbstractBeanDefinition create(String brokerName, String messageSenderBeanName) { return genericBeanDefinition(ResendFailedMessageService.class) .addConstructorArgValue(brokerName) .addConstructorArgReference("failedMessageSearchService") .addConstructorArgReference(messageSenderBeanName) .addConstructorArgValue(historicStatusPredicate) .getBeanDefinition(); } ResendFailedMessageServiceBeanDefinitionFactory(HistoricStatusPredicate historicStatusPredicate); AbstractBeanDefinition create(String brokerName, String messageSenderBeanName); String createBeanName(String brokerName); }### Answer:
@Test public void createResendFailedMessageServiceBeanDefinition() throws Exception { AbstractBeanDefinition abstractBeanDefinition = underTest.create(BROKER_NAME, "messageSender"); assertThat(abstractBeanDefinition.getBeanClass(), typeCompatibleWith(ResendFailedMessageService.class)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getIndexedArgumentValues().size(), is(4)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(0, String.class).getValue(), is(BROKER_NAME)); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(1, FailedMessageSearchService.class).getValue(), is(equalTo(new RuntimeBeanReference("failedMessageSearchService")))); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(2, MessageSender.class).getValue(), is(equalTo(new RuntimeBeanReference("messageSender")))); assertThat(abstractBeanDefinition.getConstructorArgumentValues().getArgumentValue(3, HistoricStatusPredicate.class).getValue(), is(historicStatusPredicate)); } |
### Question:
ResendFailedMessageServiceBeanDefinitionFactory { public String createBeanName(String brokerName) { return RESEND_FAILED_MESSAGE_SERVICE_BEAN_NAME_PREFIX + brokerName; } ResendFailedMessageServiceBeanDefinitionFactory(HistoricStatusPredicate historicStatusPredicate); AbstractBeanDefinition create(String brokerName, String messageSenderBeanName); String createBeanName(String brokerName); }### Answer:
@Test public void createBeanName() throws Exception { assertThat(underTest.createBeanName(BROKER_NAME), is(equalTo(RESEND_FAILED_MESSAGE_SERVICE_BEAN_NAME_PREFIX + BROKER_NAME))); } |
### Question:
ResendFailedMessageService { public void resendMessages() { LOGGER.debug("Resending FailedMessages to: {}", brokerName); failedMessageSearchService .search(searchMatchingAllCriteria() .withBroker(brokerName) .withStatus(RESENDING) .build()) .stream() .filter(historicStatusPredicate::test) .forEach(messageSender::send); } ResendFailedMessageService(String brokerName,
FailedMessageSearchService failedMessageSearchService,
MessageSender messageSender,
HistoricStatusPredicate historicStatusPredicate); void resendMessages(); String getBrokerName(); }### Answer:
@Test public void successfullyResendFailedMessages() throws Exception { SearchFailedMessageRequest searchRequest = argThat(new HamcrestArgumentMatcher<>(aSearchRequestMatchingAllCriteria() .withBroker(equalTo(Optional.of(BROKER_NAME))) .withStatusMatcher(contains(RESENDING)))); when(failedMessageSearchService.search(searchRequest)).thenReturn(asList(failedMessage, anotherFailedMessage)); when(historicStatusPredicate.test(failedMessage)).thenReturn(true); when(historicStatusPredicate.test(anotherFailedMessage)).thenReturn(false); underTest.resendMessages(); verify(messageSender).send(failedMessage); verifyNoMoreInteractions(messageSender); } |
### Question:
VaultApiFactory { Vault createVaultAPI(VaultProperties vaultProperties) throws VaultException { return new Vault(buildConfiguration(vaultProperties)); } }### Answer:
@Test public void throwsExceptionWhenTokenFileNotFound() throws Exception { VaultProperties vaultProperties = createVaultPropertiesWithTokenFileAt(FILE_LOCATION_THAT_DOES_NOT_EXIST); expectedException.expect(VaultException.class); expectedException.expectCause(isA(NoSuchFileException.class)); expectedException.expectMessage(is("java.nio.file.NoSuchFileException: /tmp/file-does-not-exist")); underTest.createVaultAPI(vaultProperties); }
@Test public void readsTokenFileWhenItExists() throws Exception { String tokenFileLocation = ensureTokenFileExists(); VaultProperties vaultProperties = createVaultPropertiesWithTokenFileAt(tokenFileLocation); Vault vaultAPI = underTest.createVaultAPI(vaultProperties); assertThat(new File(tokenFileLocation).exists(), is(true)); assertThat(vaultAPI, is(notNullValue())); }
@Test public void readsTokenFileWhenItIsAFileUri() throws Exception { String tokenFileLocation = ensureTokenFileExists(); VaultProperties vaultProperties = createVaultPropertiesWithTokenFileAt("file:" + tokenFileLocation); Vault vaultAPI = underTest.createVaultAPI(vaultProperties); assertThat(vaultAPI, is(notNullValue())); }
@Test public void readsTokenFileWhenItIsAClasspathFile() throws Exception { VaultProperties vaultProperties = createVaultPropertiesWithTokenFileAt("classpath:test-token-value-file"); Vault vaultAPI = underTest.createVaultAPI(vaultProperties); assertThat(vaultAPI, is(notNullValue())); } |
### Question:
FailedMessageId implements Id { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; return id.equals(((FailedMessageId) o).id); } private FailedMessageId(UUID id); static FailedMessageId newFailedMessageId(); static FailedMessageId fromUUID(UUID uuid); @JsonCreator static FailedMessageId fromString(String uuid); @Override UUID getId(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); static final String FAILED_MESSAGE_ID; }### Answer:
@Test public void equalsTest() { assertFalse(FAILED_MESSAGE_ID.equals(null)); assertFalse(FailedMessageId.fromUUID(A_UUID).equals(A_UUID)); assertFalse(FailedMessageId.newFailedMessageId().equals(FAILED_MESSAGE_ID)); assertTrue(FAILED_MESSAGE_ID.equals(FAILED_MESSAGE_ID)); assertTrue(FailedMessageId.fromUUID(A_UUID).equals(FailedMessageId.fromUUID(A_UUID))); } |
### Question:
SingleValueVaultLookupStrategy implements SensitiveConfigValueLookupStrategy { @Override public boolean matches(String secret) { return isVaultEnabledAndPatternMatches(secret); } SingleValueVaultLookupStrategy(VaultProperties vaultProperties, VaultApiFactory vaultApiFactory); @Override boolean matches(String secret); @Override DecryptedValue retrieveSecret(String secretPath); }### Answer:
@Test public void matchesWhenConfiguredAndCorrectPath() throws Exception { assertThat(underTest.matches(MATCHING_PATH), is(true)); }
@Test public void secretPathDoesNotMatch() throws Exception { assertThat(underTest.matches(NON_MATCHING_PATH), is(false)); } |
### Question:
SensitiveConfigValueLookupRegistry { public DecryptedValue retrieveSecret(String secretPath) { return resolutionStrategies .stream() .filter(service -> service.matches(secretPath)) .findFirst() .map(service -> service.retrieveSecret(secretPath)) .orElseThrow(() -> new IllegalArgumentException("No relevant strategy could be found to resolve vault path for: " + secretPath)); } SensitiveConfigValueLookupRegistry(List<SensitiveConfigValueLookupStrategy> resolutionStrategies); DecryptedValue retrieveSecret(String secretPath); }### Answer:
@Test public void ensureThatIfNoResolutionStrategyForAVaultKeyCanBeFound_thenThrowAnIllegalArgumentException() throws Exception { SensitiveConfigValueLookupRegistry registry = new SensitiveConfigValueLookupRegistry(emptyList()); expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage(is("No relevant strategy could be found to resolve vault path for: bogus/path")); registry.retrieveSecret("bogus/path"); }
@Test public void ensureThatIfResolutionStrategyIsFoundButItReturnsNull_thenThrowAnIllegalArgumentException() throws Exception { List<SensitiveConfigValueLookupStrategy> listOfStrategies = new ArrayList<>(); listOfStrategies.add(new SensitiveConfigValueLookupStrategy() { @Override public DecryptedValue retrieveSecret(String secret) { return null; } @Override public boolean matches(String secret) { return true; } }); SensitiveConfigValueLookupRegistry registry = new SensitiveConfigValueLookupRegistry(listOfStrategies); expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage(is("No relevant strategy could be found to resolve vault path for: bogus/path")); registry.retrieveSecret("bogus/path"); } |
### Question:
VaultPropertySource extends MapPropertySource { @Override public char[] getProperty(String name) { if (containsProperty(name)) { LOGGER.trace("Attempting to lookup property key = {}", name); return sensitiveConfigValueLookupRegistry.retrieveSecret(super.getProperty(name).toString()).getClearText(); } return null; } VaultPropertySource(Map<String, Object> source, SensitiveConfigValueLookupRegistry registry); @Override char[] getProperty(String name); }### Answer:
@Test public void ensureThatPropertyKeyThatRequiresResolutionFromVault_isDelegatedToTheUnderlyingRegistry() throws Exception { Map<String, Object> mapOfKeys = new HashMap<>(); String expectedTestKey = "expected.test.key"; String vaultConfigValue = "VAULT(my/secret/path)"; char[] expectedResolvedValue = new char[]{'p', 'a', 's', 's'}; mapOfKeys.put(expectedTestKey, vaultConfigValue); when(registry.retrieveSecret(vaultConfigValue)).thenReturn(new DecryptedValue(expectedResolvedValue)); VaultPropertySource vaultPropertySource = new VaultPropertySource(mapOfKeys, registry); char[] actualResolverKey = vaultPropertySource.getProperty(expectedTestKey); assertTrue(Arrays.equals(actualResolverKey, expectedResolvedValue)); }
@Test public void ensureThatIfAttemptingToRetriveAKeyThatIsNotInTheListOfResovableKeys_thenReturnNull() throws Exception { VaultPropertySource vaultPropertySource = new VaultPropertySource(new HashMap<>(), registry); char[] property = vaultPropertySource.getProperty("non-existent-key"); assertNull(property); verifyZeroInteractions(registry); } |
### Question:
FailedMessageId implements Id { @Override public int hashCode() { return id.hashCode(); } private FailedMessageId(UUID id); static FailedMessageId newFailedMessageId(); static FailedMessageId fromUUID(UUID uuid); @JsonCreator static FailedMessageId fromString(String uuid); @Override UUID getId(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); static final String FAILED_MESSAGE_ID; }### Answer:
@Test public void hashCodeTest() { assertNotEquals(FAILED_MESSAGE_ID.hashCode(), FailedMessageId.newFailedMessageId().hashCode()); assertEquals(FAILED_MESSAGE_ID.getId().hashCode(), FAILED_MESSAGE_ID.hashCode()); } |
### Question:
FailedMessageBuilderFactory { public FailedMessageBuilder create(FailedMessageId failedMessageId) { return failedMessageDao.findById(failedMessageId) .filter(IS_DELETED.negate()) .map(createFailedMessageBuilder()) .orElseThrow(failedMessageNotFound(failedMessageId)) .withUpdateRequestAdapterRegistry(updateRequestAdapterRegistry); } FailedMessageBuilderFactory(UpdateRequestAdapterRegistry updateRequestAdapterRegistry,
FailedMessageDao failedMessageDao); FailedMessageBuilder create(FailedMessageId failedMessageId); }### Answer:
@Test public void failedMessageNotFoundExceptionThrownWhenFailedMessageEmpty() { expectedException.expect(FailedMessageNotFoundException.class); expectedException.expectMessage("Failed Message: " + FAILED_MESSAGE_ID + " not found"); when(failedMessageDao.findById(FAILED_MESSAGE_ID)).thenReturn(Optional.empty()); underTest.create(FAILED_MESSAGE_ID); verifyZeroInteractions(failedMessageBuilder); }
@Test public void failedMessageNotFoundExceptionThrownIfStatusIsDeleted() { expectedException.expect(FailedMessageNotFoundException.class); expectedException.expectMessage("Failed Message: " + FAILED_MESSAGE_ID + " not found"); when(failedMessageDao.findById(FAILED_MESSAGE_ID)).thenReturn(Optional.of(failedMessage)); when(failedMessage.getStatus()).thenReturn(DELETED); underTest.create(FAILED_MESSAGE_ID); verifyZeroInteractions(failedMessageBuilder); }
@Test public void successfullyCreateAFailedMessageBuilder() { when(failedMessageDao.findById(FAILED_MESSAGE_ID)).thenReturn(Optional.of(failedMessage)); when(failedMessage.getStatus()).thenReturn(FAILED); when(failedMessageBuilder.withUpdateRequestAdapterRegistry(updateRequestAdapterRegistry)).thenReturn(failedMessageBuilder); assertThat(underTest.create(FAILED_MESSAGE_ID), is(failedMessageBuilder)); verify(failedMessageBuilder).withUpdateRequestAdapterRegistry(updateRequestAdapterRegistry); } |
### Question:
FailedMessageLabelService { public void addLabel(FailedMessageId failedMessageId, String label) { LOGGER.debug("Adding label '{}' to FailedMessage: {}", label, failedMessageId); failedMessageDao.addLabel(failedMessageId, label); } FailedMessageLabelService(FailedMessageDao failedMessageDao); void addLabel(FailedMessageId failedMessageId, String label); void removeLabel(FailedMessageId failedMessageId, String label); void setLabels(FailedMessageId failedMessageId, Set<String> labels); }### Answer:
@Test public void addLabelDelegatesToDao() throws Exception { underTest.addLabel(FAILED_MESSAGE_ID, LABEL); verify(failedMessageDao).addLabel(FAILED_MESSAGE_ID, LABEL); } |
### Question:
FailedMessageLabelService { public void removeLabel(FailedMessageId failedMessageId, String label) { LOGGER.debug("Removing label '{}' from FailedMessage: {}", label, failedMessageId); failedMessageDao.removeLabel(failedMessageId, label); } FailedMessageLabelService(FailedMessageDao failedMessageDao); void addLabel(FailedMessageId failedMessageId, String label); void removeLabel(FailedMessageId failedMessageId, String label); void setLabels(FailedMessageId failedMessageId, Set<String> labels); }### Answer:
@Test public void removeLabelDelegatesToDao() throws Exception { underTest.removeLabel(FAILED_MESSAGE_ID, LABEL); verify(failedMessageDao).removeLabel(FAILED_MESSAGE_ID, LABEL); } |
### Question:
FailedMessageLabelService { public void setLabels(FailedMessageId failedMessageId, Set<String> labels) { LOGGER.debug("Replacing all labels on FailedMessage: {}", failedMessageId); failedMessageDao.setLabels(failedMessageId, labels); } FailedMessageLabelService(FailedMessageDao failedMessageDao); void addLabel(FailedMessageId failedMessageId, String label); void removeLabel(FailedMessageId failedMessageId, String label); void setLabels(FailedMessageId failedMessageId, Set<String> labels); }### Answer:
@Test public void setLabelsDelegatesToDao() { underTest.setLabels(FAILED_MESSAGE_ID, singleton(LABEL)); verify(failedMessageDao).setLabels(FAILED_MESSAGE_ID, singleton(LABEL)); } |
### Question:
FailedMessageService { public void create(FailedMessage failedMessage) { failedMessageDao.insert(failedMessage); } FailedMessageService(FailedMessageDao failedMessageDao,
FailedMessageBuilderFactory failedMessageBuilderFactory); void create(FailedMessage failedMessage); void delete(FailedMessageId failedMessageId); void update(FailedMessageId failedMessageId, T updateRequest); void update(FailedMessageId failedMessageId, List<? extends UpdateRequest> updateRequests); }### Answer:
@Test public void createFailedMessageDelegatesToDao() { underTest.create(failedMessage); Mockito.verify(failedMessageDao).insert(failedMessage); } |
### Question:
FailedMessageService { public <T extends UpdateRequest> void update(FailedMessageId failedMessageId, T updateRequest) { update(failedMessageId, Collections.singletonList(updateRequest)); } FailedMessageService(FailedMessageDao failedMessageDao,
FailedMessageBuilderFactory failedMessageBuilderFactory); void create(FailedMessage failedMessage); void delete(FailedMessageId failedMessageId); void update(FailedMessageId failedMessageId, T updateRequest); void update(FailedMessageId failedMessageId, List<? extends UpdateRequest> updateRequests); }### Answer:
@Test public void noUpdatesArePerformedIfTheUpdateRequestListIsEmpty() { underTest.update(FAILED_MESSAGE_ID, Collections.emptyList()); verifyZeroInteractions(failedMessageDao); verifyZeroInteractions(failedMessageBuilderFactory); } |
### Question:
PredicateOutcomeFailedMessageProcessor implements FailedMessageProcessor { @Override public void process(FailedMessage failedMessage) { if (predicate.test(failedMessage)) { positiveOutcomeFailedMessageProcessor.process(failedMessage); } else { negativeOutcomeFailedMessageProcessor.process(failedMessage); } } PredicateOutcomeFailedMessageProcessor(Predicate<FailedMessage> predicate,
FailedMessageProcessor positiveOutcomeFailedMessageProcessor,
FailedMessageProcessor negativeOutcomeFailedMessageProcessor); @Override void process(FailedMessage failedMessage); }### Answer:
@Test public void messageIsADuplicate() { duplicate = true; underTest.process(failedMessage); verify(duplicateFailedMessageProcessor).process(failedMessage); verifyZeroInteractions(newFailedMessageProcessor); }
@Test public void messageIsNotADuplicate() { duplicate = false; underTest.process(failedMessage); verify(newFailedMessageProcessor).process(failedMessage); verifyZeroInteractions(duplicateFailedMessageProcessor); } |
### Question:
FailedMessageId implements Id { @Override public String toString() { return id.toString(); } private FailedMessageId(UUID id); static FailedMessageId newFailedMessageId(); static FailedMessageId fromUUID(UUID uuid); @JsonCreator static FailedMessageId fromString(String uuid); @Override UUID getId(); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); static final String FAILED_MESSAGE_ID; }### Answer:
@Test public void toStringTest() { assertEquals(FAILED_MESSAGE_ID.getId().toString(), FAILED_MESSAGE_ID.toString()); } |
### Question:
NewFailedMessageProcessor implements FailedMessageProcessor { @Override public void process(FailedMessage failedMessage) { failedMessageService.create(failedMessage); } NewFailedMessageProcessor(FailedMessageService failedMessageService); @Override void process(FailedMessage failedMessage); }### Answer:
@Test public void delegatesToFailedMessageService() { underTest.process(failedMessage); } |
### Question:
UniqueFailedMessageIdPredicate implements Predicate<FailedMessage> { @Override public boolean test(FailedMessage failedMessage) { return !failedMessageDao.findById(failedMessage.getFailedMessageId()).isPresent(); } UniqueFailedMessageIdPredicate(FailedMessageDao failedMessageDao); @Override boolean test(FailedMessage failedMessage); }### Answer:
@Test public void predicateReturnsTrueWhenFailedMesageWithIdDoesNotExist() { when(failedMessage.getFailedMessageId()).thenReturn(FAILED_MESSAGE_ID); when(failedMessageDao.findById(FAILED_MESSAGE_ID)).thenReturn(Optional.empty()); assertThat(underTest.test(failedMessage), is(true)); }
@Test public void predicateReturnsFalseWhenFailedMessageWithIdExists() { when(failedMessage.getFailedMessageId()).thenReturn(FAILED_MESSAGE_ID); when(failedMessageDao.findById(FAILED_MESSAGE_ID)).thenReturn(Optional.of(failedMessage)); assertThat(underTest.test(failedMessage), is(false)); } |
### Question:
ExistingFailedMessageProcessor implements FailedMessageProcessor { @Override public void process(FailedMessage failedMessage) { failedMessageDao.update(failedMessage); } ExistingFailedMessageProcessor(FailedMessageDao failedMessageDao); @Override void process(FailedMessage failedMessage); }### Answer:
@Test public void successfullyProcessExistingFailedMessage() { underTest.process(failedMessage); verify(failedMessageDao).update(failedMessage); } |
### Question:
UniqueJmsMessageIdPredicate implements Predicate<FailedMessage> { @Override public boolean test(FailedMessage failedMessage) { return failedMessageSearchService.search(searchMatchingAllCriteria() .withBroker(failedMessage.getDestination().getBrokerName()) .withJmsMessageId(failedMessage.getJmsMessageId()) .build() ).isEmpty(); } UniqueJmsMessageIdPredicate(FailedMessageSearchService failedMessageSearchService); @Override boolean test(FailedMessage failedMessage); }### Answer:
@Test public void predicateReturnsTrueIfSearchFindsAResult() { when(destination.getBrokerName()).thenReturn(BROKER_NAME); when(failedMessage.getDestination()).thenReturn(destination); when(failedMessage.getJmsMessageId()).thenReturn(JMS_MESSAGE_ID); when(failedMessageSearchService.search(any(SearchFailedMessageRequest.class))).thenReturn(Collections.emptySet()); assertThat(underTest.test(failedMessage), is(true)); verify(failedMessageSearchService).search(argThat(aSearchRequestMatchingAllCriteria() .withBroker(BROKER_NAME) .withJmsMessageId(JMS_MESSAGE_ID))); }
@Test public void predicateReturnsFalseIfSearchFindsAResult() { when(destination.getBrokerName()).thenReturn(BROKER_NAME); when(failedMessage.getDestination()).thenReturn(destination); when(failedMessage.getJmsMessageId()).thenReturn(JMS_MESSAGE_ID); when(failedMessageSearchService.search(any(SearchFailedMessageRequest.class))).thenReturn(singleton(mock(FailedMessage.class))); assertThat(underTest.test(failedMessage), is(false)); verify(failedMessageSearchService).search(argThat(aSearchRequestMatchingAllCriteria() .withBroker(BROKER_NAME) .withJmsMessageId(JMS_MESSAGE_ID))); } |
### Question:
PropertiesConverter implements ObjectConverter<Map<String, Object>, String> { @Override public Map<String, Object> convertToObject(String value) { if (value == null) { return Collections.emptyMap(); } try { return objectMapper.readValue(value, new TypeReference<Map<String, Object>>() {}); } catch (IOException e) { LOGGER.error("Could read the following properties: " + value, e); } return Collections.emptyMap(); } PropertiesConverter(ObjectMapper objectMapper); @Override Map<String, Object> convertToObject(String value); @Override String convertFromObject(Map<String, Object> item); }### Answer:
@Test public void nullPropertiesReturnsANewHashMap() { assertThat(underTest.convertToObject(null), is(equalTo(new HashMap<>()))); }
@Test public void nullValueIsReturnedIfTheJsonCannotBeRead() throws IOException { when(objectMapper.readValue(any(String.class), any(TypeReference.class))).thenThrow(IOException.class); assertThat(new PropertiesConverter(objectMapper).convertToObject("foo"), is(Collections.emptyMap())); } |
### Question:
PropertiesConverter implements ObjectConverter<Map<String, Object>, String> { @Override public String convertFromObject(Map<String, Object> item) { if (item == null) { return null; } try { return objectMapper.writeValueAsString(item); } catch (JsonProcessingException e) { LOGGER.error("Could not convert the following Map: " + item, e); } return null; } PropertiesConverter(ObjectMapper objectMapper); @Override Map<String, Object> convertToObject(String value); @Override String convertFromObject(Map<String, Object> item); }### Answer:
@Test public void convertingNullMapToStringReturnsNull() { assertThat(underTest.convertFromObject(null), is(nullValue())); }
@Test public void nullValueIsReturnedIfTheMapCannotBeParsed() throws Exception { when(objectMapper.writeValueAsString(singletonMap("foo", "bar"))).thenThrow(JsonProcessingException.class); assertThat(new PropertiesConverter(objectMapper).convertFromObject(singletonMap("foo", "bar")), is(nullValue())); } |
### Question:
InstantAsDateTimeCodec implements Codec<Instant> { @Override public void encode(BsonWriter writer, Instant value, EncoderContext encoderContext) { writer.writeDateTime(value.toEpochMilli()); } @Override void encode(BsonWriter writer, Instant value, EncoderContext encoderContext); @Override Instant decode(BsonReader reader, DecoderContext decoderContext); @Override Class<Instant> getEncoderClass(); }### Answer:
@Test public void encode() { underTest.encode(bsonWriter, AN_INSTANT, encoderContext); verify(bsonWriter).writeDateTime(EPOCH_MILLI); } |
### Question:
StatusHistoryResponse { public StatusHistoryResponse(@JsonProperty("status") FailedMessageStatus status, @JsonProperty("effectiveDateTime") Instant effectiveDateTime) { this.status = status; this.effectiveDateTime = effectiveDateTime; } StatusHistoryResponse(@JsonProperty("status") FailedMessageStatus status,
@JsonProperty("effectiveDateTime") Instant effectiveDateTime); FailedMessageStatus getStatus(); Instant getEffectiveDateTime(); @Override String toString(); }### Answer:
@Test public void statusHistoryResponseTest() { assertThat(underTest, is(statusHistoryResponse().withStatus(FAILED).withEffectiveDateTime(NOW))); }
@Test public void serialiseAndDeserialiseObject() throws IOException { final String json = OBJECT_MAPPER.writeValueAsString(underTest); assertThat(OBJECT_MAPPER.readValue(json, StatusHistoryResponse.class), is(statusHistoryResponse().withStatus(FAILED).withEffectiveDateTime(NOW))); } |
### Question:
RemoveFailedMessageService { public void removeFailedMessages() { try { logger.info("Attempting to remove FailedMessages"); final long count = failedMessageDao.removeFailedMessages(); logger.info("Successfully removed {} messages", count); } catch (Exception e) { logger.error("Could not remove messages", e); } } RemoveFailedMessageService(FailedMessageDao failedMessageDao); RemoveFailedMessageService(FailedMessageDao failedMessageDao, Logger logger); void removeFailedMessages(); }### Answer:
@Test public void removeDelegatesToTheDao() { when(failedMessageDao.removeFailedMessages()).thenReturn(NUMBER_OF_MESSAGES_REMOVED); underTest.removeFailedMessages(); verify(failedMessageDao).removeFailedMessages(); }
@Test public void exceptionsAreSwallowedAndLogged() { when(failedMessageDao.removeFailedMessages()).thenThrow(exception); underTest.removeFailedMessages(); verify(logger).error("Could not remove messages", exception); } |
### Question:
InstantAsDateTimeCodec implements Codec<Instant> { @Override public Instant decode(BsonReader reader, DecoderContext decoderContext) { return Instant.ofEpochMilli(reader.readDateTime()); } @Override void encode(BsonWriter writer, Instant value, EncoderContext encoderContext); @Override Instant decode(BsonReader reader, DecoderContext decoderContext); @Override Class<Instant> getEncoderClass(); }### Answer:
@Test public void decode() { when(bsonReader.readDateTime()).thenReturn(EPOCH_MILLI); assertThat(underTest.decode(bsonReader, decoderContext), equalTo(AN_INSTANT)); } |
### Question:
ResendFailedMessageResource implements ResendFailedMessageClient { @Override public void resendFailedMessage(FailedMessageId failedMessageId) { failedMessageService.update(failedMessageId, statusUpdateRequest(RESEND)); } ResendFailedMessageResource(FailedMessageService failedMessageService,
Clock clock); @Override void resendFailedMessage(FailedMessageId failedMessageId); @Override void resendFailedMessageWithDelay(FailedMessageId failedMessageId, Duration duration); }### Answer:
@Test public void successfullyMarkAMessageForResending() { underTest.resendFailedMessage(FAILED_MESSAGE_ID); verify(failedMessageService).update(eq(FAILED_MESSAGE_ID), statusUpdateRequest.capture()); assertThat(statusUpdateRequest.getValue(), aStatusUpdateRequest(RESEND)); } |
### Question:
ResendFailedMessageResource implements ResendFailedMessageClient { @Override public void resendFailedMessageWithDelay(FailedMessageId failedMessageId, Duration duration) { failedMessageService.update(failedMessageId, new StatusUpdateRequest(RESEND, Instant.now(clock).plus(duration))); } ResendFailedMessageResource(FailedMessageService failedMessageService,
Clock clock); @Override void resendFailedMessage(FailedMessageId failedMessageId); @Override void resendFailedMessageWithDelay(FailedMessageId failedMessageId, Duration duration); }### Answer:
@Test public void successfullyMarkAMessageForResendingInTheFuture() { underTest.resendFailedMessageWithDelay(FAILED_MESSAGE_ID, Duration.ofSeconds(100)); verify(failedMessageService).update(eq(FAILED_MESSAGE_ID), statusUpdateRequest.capture()); assertThat(statusUpdateRequest.getValue(), aStatusUpdateRequest(RESEND) .withUpdatedDateTime(Matchers.equalTo(NOW.plus(100, SECONDS)))); } |
### Question:
CreateFailedMessageResource implements CreateFailedMessageClient { public void create(CreateFailedMessageRequest failedMessageRequest) { failedMessageDao.insert(failedMessageFactory.create(failedMessageRequest)); } CreateFailedMessageResource(FailedMessageFactory failedMessageFactory, FailedMessageDao failedMessageDao); void create(CreateFailedMessageRequest failedMessageRequest); }### Answer:
@Test public void createFailedMessage() throws Exception { when(failedMessageFactory.create(request)).thenReturn(failedMessage); underTest.create(request); verify(failedMessageDao).insert(failedMessage); } |
### Question:
FailedMessageFactory { public FailedMessage create(CreateFailedMessageRequest request) { return FailedMessageBuilder.newFailedMessage() .withFailedMessageId(request.getFailedMessageId()) .withContent(request.getContent()) .withDestination(new Destination(request.getBrokerName(), ofNullable(request.getDestinationName()))) .withFailedDateTime(request.getFailedAt()) .withProperties(request.getProperties()) .withSentDateTime(request.getSentAt()) .withLabels(request.getLabels()) .build(); } FailedMessage create(CreateFailedMessageRequest request); }### Answer:
@Test public void createFailedMessageFromRequest() throws Exception { FailedMessage failedMessage = underTest.create(newCreateFailedMessageRequest() .withContent("Hello World") .withBrokerName("broker") .withDestinationName("queue") .withFailedDateTime(NOW) .withFailedMessageId(FAILED_MESSAGE_ID) .withProperties(Collections.singletonMap("foo", "bar")) .withSentDateTime(NOW) .build()); assertThat(failedMessage, aFailedMessage() .withContent(equalTo("Hello World")) .withDestination(DestinationMatcher.aDestination().withBrokerName("broker").withName("queue")) .withFailedAt(equalTo(NOW)) .withFailedMessageId(equalTo(FAILED_MESSAGE_ID)) .withProperties(Matchers.hasEntry("foo", "bar")) .withSentAt(equalTo(NOW)) ); } |
### Question:
FailedMessageSearchResource implements SearchFailedMessageClient { @Override public FailedMessageResponse getFailedMessage(FailedMessageId failedMessageId) { return failedMessageDao.findById(failedMessageId) .filter(failedMessage -> !DELETED.equals(failedMessage.getStatus())) .map(failedMessageResponseFactory::create) .orElseThrow(() -> new NotFoundException(format("Failed Message: %s not found", failedMessageId))); } FailedMessageSearchResource(FailedMessageDao failedMessageDao,
FailedMessageResponseFactory failedMessageResponseFactory,
FailedMessageSearchService failedMessageSearchService,
SearchFailedMessageResponseAdapter searchFailedMessageResponseAdapter); @Override FailedMessageResponse getFailedMessage(FailedMessageId failedMessageId); @Override Collection<SearchFailedMessageResponse> search(SearchFailedMessageRequest request); }### Answer:
@Test public void findMessageById() { when(failedMessageDao.findById(FAILED_MESSAGE_ID)).thenReturn(Optional.of(failedMessage)); when(failedMessage.getStatus()).thenReturn(FAILED); when(failedMessageResponseFactory.create(failedMessage)).thenReturn(failedMessageResponse); assertThat(underTest.getFailedMessage(FAILED_MESSAGE_ID), is(failedMessageResponse)); }
@Test public void findMessageByIdThrowsNotFoundExceptionWhenMessageDoesNotExist() { expectedException.expect(NotFoundException.class); expectedException.expectMessage("Failed Message: " + FAILED_MESSAGE_ID + " not found"); when(failedMessageDao.findById(FAILED_MESSAGE_ID)).thenReturn(Optional.empty()); underTest.getFailedMessage(FAILED_MESSAGE_ID); verifyZeroInteractions(failedMessageResponseFactory); }
@Test public void findMessageByIdThrowsNotFoundExceptionWhenMessageIsDeleted() { expectedException.expect(NotFoundException.class); expectedException.expectMessage("Failed Message: " + FAILED_MESSAGE_ID + " not found"); when(failedMessageDao.findById(FAILED_MESSAGE_ID)).thenReturn(Optional.of(failedMessage)); when(failedMessage.getStatus()).thenReturn(DELETED); underTest.getFailedMessage(FAILED_MESSAGE_ID); verifyZeroInteractions(failedMessageResponseFactory); } |
### Question:
RemoveRecordsQueryFactory { public Document create() { return new Document() .append(STATUS_HISTORY + ".0." + STATUS, DELETED.name()) .append(STATUS_HISTORY + ".0." + EFFECTIVE_DATE_TIME, new Document(QueryOperators.LT, now().minus(7, DAYS))); } Document create(); }### Answer:
@Test public void removeRecordsQueryCreatedSuccessfully() { assertThat(underTest.create(), allOf( hasField(STATUS_HISTORY + ".0." + STATUS, equalTo(StatusHistoryEvent.Status.DELETED.name())), hasField(STATUS_HISTORY + ".0." + EFFECTIVE_DATE_TIME, hasField(QueryOperators.LT, notNullValue(Instant.class))) )); } |
### Question:
FailedMessageSearchResource implements SearchFailedMessageClient { @Override public Collection<SearchFailedMessageResponse> search(SearchFailedMessageRequest request) { return failedMessageSearchService.search(request) .stream() .map(searchFailedMessageResponseAdapter::toResponse) .collect(Collectors.toList()); } FailedMessageSearchResource(FailedMessageDao failedMessageDao,
FailedMessageResponseFactory failedMessageResponseFactory,
FailedMessageSearchService failedMessageSearchService,
SearchFailedMessageResponseAdapter searchFailedMessageResponseAdapter); @Override FailedMessageResponse getFailedMessage(FailedMessageId failedMessageId); @Override Collection<SearchFailedMessageResponse> search(SearchFailedMessageRequest request); }### Answer:
@Test public void validSearch() { FailedMessage failedMessage = mock(FailedMessage.class); SearchFailedMessageResponse searchFailedMessageResponse = mock(SearchFailedMessageResponse.class); SearchFailedMessageRequest searchFailedMessageRequest = mock(SearchFailedMessageRequest.class); when(searchFailedMessageRequest.getBroker()).thenReturn(Optional.of("broker")); when(failedMessageSearchService.search(searchFailedMessageRequest)).thenReturn(singletonList(failedMessage)); when(searchFailedMessageResponseAdapter.toResponse(failedMessage)).thenReturn(searchFailedMessageResponse); final Collection<SearchFailedMessageResponse> results = underTest.search(searchFailedMessageRequest); assertThat(results, contains(searchFailedMessageResponse)); verify(failedMessageSearchService).search(Mockito.refEq(searchFailedMessageRequest)); } |
### Question:
UpdateFailedMessageResource implements UpdateFailedMessageClient { @Override public void update(FailedMessageId failedMessageId, FailedMessageUpdateRequest failedMessageUpdateRequest) { failedMessageService.update(failedMessageId, failedMessageUpdateRequest.getUpdateRequests()); } UpdateFailedMessageResource(FailedMessageService failedMessageService); @Override void update(FailedMessageId failedMessageId, FailedMessageUpdateRequest failedMessageUpdateRequest); }### Answer:
@Test public void resourceDelegatesToTheFailedMessageService() { underTest.update(FAILED_MESSAGE_ID, FailedMessageUpdateRequest.aNewFailedMessageUpdateRequest().withUpdateRequest(updateRequest).build()); verify(failedMessageService).update(FAILED_MESSAGE_ID, Collections.singletonList(updateRequest)); } |
### Question:
MessageTextExtractor { public String extractText(Message message) { if (message instanceof TextMessage) { TextMessage textMessage = (TextMessage) message; try { return textMessage.getText(); } catch (JMSException e) { String errorMsg = String.format("Failed to extract the text from TextMessage: %s", textMessage.toString()); LOGGER.error(errorMsg, e); throw new RuntimeException(errorMsg, e); } } else { String errorMsg = String.format("Expected TextMessage received: %s", message.getClass().getName()); LOGGER.error(errorMsg); throw new RuntimeException(errorMsg); } } String extractText(Message message); }### Answer:
@Test public void extractTextFromMessage() throws Exception { TextMessage textMessage = mock(TextMessage.class); when(textMessage.getText()).thenReturn("Text"); assertThat(underTest.extractText(textMessage), is("Text")); }
@Test public void throwsExceptionIfNotTextMessage() throws Exception { expectedException.expect(RuntimeException.class); expectedException.expectMessage(allOf(startsWith("Expected TextMessage received:"), containsString("javax.jms.BytesMessage"))); underTest.extractText(mock(BytesMessage.class)); } |
### Question:
FailedMessageTransformer implements JmsMessageTransformer<TextMessage, FailedMessage> { @Override public void transform(TextMessage textMessage, FailedMessage data) throws JMSException { textMessage.setText(data.getContent()); Map<String, Object> properties = data.getProperties(); properties.keySet().forEach(key -> { try { textMessage.setObjectProperty(key, properties.get(key)); } catch (JMSException ignore) { LOGGER.warn("Could not add property: '{}' when sending FailedMessage: {}", key, data.getFailedMessageId()); } }); textMessage.setStringProperty(FailedMessageId.FAILED_MESSAGE_ID, data.getFailedMessageId().toString()); } @Override void transform(TextMessage textMessage, FailedMessage data); }### Answer:
@Test public void processingContinuesObjectPropertyCannotBeWritten() throws JMSException { when(failedMessage.getContent()).thenReturn("content"); when(failedMessage.getProperties()).thenReturn(ImmutableMap.of("foo", "bar", "ham", "eggs")); when(failedMessage.getFailedMessageId()).thenReturn(FAILED_MESSAGE_ID); doThrow(new JMSException("Arrrghhhhh")).when(textMessage).setObjectProperty("foo", "bar"); underTest.transform(textMessage, failedMessage); verify(textMessage).setText("content"); verify(textMessage).setObjectProperty("foo", "bar"); verify(textMessage).setObjectProperty("ham", "eggs"); verify(textMessage).setStringProperty(FailedMessageId.FAILED_MESSAGE_ID, FAILED_MESSAGE_ID.toString()); } |
### Question:
FailedMessageListener implements MessageListener { @Override public void onMessage(Message message) { try { LOGGER.debug("Received message: {} with CorrelationId: {}", message.getJMSMessageID(), message.getJMSCorrelationID()); failedMessageProcessor.process(failedMessageFactory.createFailedMessage(message)); } catch (JMSException e) { LOGGER.error("Could not read jmsMessageId or correlationId", e); } } FailedMessageListener(FailedMessageFactory failedMessageFactory,
FailedMessageProcessor failedMessageProcessor); @Override void onMessage(Message message); }### Answer:
@Test public void processMessageSuccessfully() throws Exception { when(failedMessageFactory.createFailedMessage(message)).thenReturn(failedMessage); underTest.onMessage(message); verify(failedMessageProcessor).process(failedMessage); }
@Test public void exceptionIsThrownRetrievingTheJMSMessageId() throws JMSException { when(message.getJMSMessageID()).thenThrow(JMSException.class); underTest.onMessage(message); verifyZeroInteractions(failedMessageProcessor); } |
### Question:
FailedMessageConverter implements DocumentWithIdConverter<FailedMessage, FailedMessageId> { @Override public Document createId(FailedMessageId failedMessageId) { return new Document("_id", failedMessageId.getId().toString()); } FailedMessageConverter(DocumentConverter<Destination> destinationDocumentConverter,
DocumentConverter<StatusHistoryEvent> statusHistoryEventDocumentConverter,
ObjectConverter<Map<String, Object>, String> propertiesMongoMapper); @Override FailedMessage convertToObject(Document document); StatusHistoryEvent getStatusHistoryEvent(Document document); FailedMessageId getFailedMessageId(Document document); Destination getDestination(Document document); String getContent(Document document); Instant getFailedDateTime(Document document); Instant getSentDateTime(Document document); @Override Document convertFromObject(FailedMessage item); Document convertForUpdate(FailedMessage item); @Override Document createId(FailedMessageId failedMessageId); static final String DESTINATION; static final String SENT_DATE_TIME; static final String FAILED_DATE_TIME; static final String CONTENT; static final String PROPERTIES; static final String STATUS_HISTORY; static final String LABELS; static final String JMS_MESSAGE_ID; }### Answer:
@Test public void createId() { assertThat(underTest.createId(FAILED_MESSAGE_ID), equalTo(new Document("_id", FAILED_MESSAGE_ID_AS_STRING))); } |
### Question:
CircularBuffer { public int size() { return currentSize; } CircularBuffer(int size); void enqueue(T item); int size(); @SuppressWarnings("unchecked") T getItem(int index); }### Answer:
@Test public void size() { CircularBuffer<Integer> queue = new CircularBuffer<>(2); assertEquals(0, queue.size()); queue.enqueue(0); queue.enqueue(1); assertEquals(2, queue.size()); queue.enqueue(3); assertEquals(2, queue.size()); } |
### Question:
CircularBuffer { @SuppressWarnings("unchecked") public T getItem(int index) { int target = head - index; if (target < 0) target = queue.length + target; return (T) queue[target]; } CircularBuffer(int size); void enqueue(T item); int size(); @SuppressWarnings("unchecked") T getItem(int index); }### Answer:
@Test public void getItem() { CircularBuffer<Integer> queue = new CircularBuffer<>(3); queue.enqueue(0); assertEquals((Integer) 0, queue.getItem(0)); queue.enqueue(1); assertEquals((Integer) 1, queue.getItem(0)); assertEquals((Integer) 0, queue.getItem(1)); queue.enqueue(2); assertEquals((Integer) 2, queue.getItem(0)); assertEquals((Integer) 1, queue.getItem(1)); assertEquals((Integer) 0, queue.getItem(2)); queue.enqueue(3); assertEquals((Integer) 3, queue.getItem(0)); assertEquals((Integer) 2, queue.getItem(1)); assertEquals((Integer) 1, queue.getItem(2)); } |
### Question:
KubeCloudClient implements CloudClientEx { @Override public boolean isInitialized() { return true; } KubeCloudClient(@NotNull KubeApiConnector apiConnector,
@Nullable String serverUuid,
@NotNull String cloudProfileId,
@NotNull List<KubeCloudImage> images,
@NotNull KubeCloudClientParametersImpl kubeClientParams,
@NotNull KubeBackgroundUpdater updater,
@NotNull BuildAgentPodTemplateProviders podTemplateProviders,
@Nullable ExecutorService executorService,
@NotNull KubePodNameGenerator nameGenerator); @Override boolean isInitialized(); @Override void dispose(); @NotNull @Override CloudInstance startNewInstance(@NotNull CloudImage cloudImage, @NotNull CloudInstanceUserData cloudInstanceUserData); @Override void restartInstance(@NotNull CloudInstance cloudInstance); @Override void terminateInstance(@NotNull CloudInstance cloudInstance); @Nullable @Override CloudImage findImageById(@NotNull String imageId); @Nullable @Override CloudInstance findInstanceByAgent(@NotNull AgentDescription agentDescription); @NotNull @Override Collection<? extends CloudImage> getImages(); @Nullable @Override CloudErrorInfo getErrorInfo(); @Override boolean canStartNewInstance(@NotNull CloudImage cloudImage); @Nullable @Override String generateAgentName(@NotNull AgentDescription agentDescription); String getProfileId(); }### Answer:
@Test public void testIsInitialized() throws Exception { assertTrue(createClient(Collections.emptyList()).isInitialized()); } |
### Question:
BoltOptions implements AutoCloseable { @Override public void close() { BoltNative.BoltDBOptions_Free(objectId); } BoltOptions(); BoltOptions(long timeout); BoltOptions(long timeout, boolean noGrowSync, boolean readOnly, int mmapFlags, int initialMmapSize); @Override void close(); }### Answer:
@Test public void create_and_free() { BoltOptions boltOptions = new BoltOptions(); boltOptions.close(); } |
### Question:
BoltBucket implements AutoCloseable { public void delete(byte[] key) { Error.ByValue error = BoltNative.BoltDBBucket_Delete(objectId, key, key.length); error.checkError(); } BoltBucket(long objectId); @Override void close(); byte[] get(byte[] key); void put(byte[] key, byte[] value); void delete(byte[] key); BoltBucket createBucket(byte[] name); BoltBucket createBucketIfNotExists(byte[] name); void deleteBucket(byte[] name); BoltBucket getBucket(byte[] name); BoltCursor createCursor(); long nextSequenceId(); BoltBucketStats getStats(); }### Answer:
@Test public void delete() throws IOException { try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> { try(BoltBucket bucket = boltTransaction.createBucket("test".getBytes())) { byte[] key = "foo".getBytes(); byte[] value = "bar".getBytes(); bucket.put(key, value); bucket.delete(key); byte[] getValue = bucket.get(key); Assert.assertNull(getValue); } }); } } |
### Question:
BoltBucket implements AutoCloseable { public BoltBucket createBucket(byte[] name) { Result.ByValue result = BoltNative.BoltDBBucket_CreateBucket(objectId, name, name.length); result.checkError(); return new BoltBucket(result.objectId); } BoltBucket(long objectId); @Override void close(); byte[] get(byte[] key); void put(byte[] key, byte[] value); void delete(byte[] key); BoltBucket createBucket(byte[] name); BoltBucket createBucketIfNotExists(byte[] name); void deleteBucket(byte[] name); BoltBucket getBucket(byte[] name); BoltCursor createCursor(); long nextSequenceId(); BoltBucketStats getStats(); }### Answer:
@Test @SuppressWarnings("EmptyTryBlock") public void create_bucket() throws IOException { try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> { try(BoltBucket parentBucket = boltTransaction.createBucket("parent".getBytes())) { try(BoltBucket ignored = parentBucket.createBucket("test".getBytes())) {} } }); } }
@Test(expected = BoltException.class) public void create_bucket_with_empty_name() throws IOException { try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> { try (BoltBucket parentBucket = boltTransaction.createBucket("parent".getBytes())) { parentBucket.createBucket("".getBytes()); } }); } }
@Test(expected = BoltException.class) @SuppressWarnings("EmptyTryBlock") public void create_bucket_twice() throws IOException { byte[] bucketName = "test".getBytes(); try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> { try (BoltBucket parentBucket = boltTransaction.createBucket("parent".getBytes())) { try (BoltBucket ignored = parentBucket.createBucket(bucketName)) {} parentBucket.createBucket(bucketName); } }); } } |
### Question:
BoltTransaction { public void commit() { Error.ByValue error = BoltNative.BoltDBTransaction_Commit(objectId); error.checkError(); } BoltTransaction(long objectId); void commit(); void rollback(); int getId(); long getDatabaseSize(); BoltBucket createBucket(byte[] name); BoltBucket createBucketIfNotExists(byte[] name); void deleteBucket(byte[] name); BoltBucket getBucket(byte[] name); BoltCursor createCursor(); BoltTransactionStats getStats(); }### Answer:
@Test public void commit_transaction() throws IOException { try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { BoltTransaction boltTransaction = bolt.begin(true); boltTransaction.commit(); } } |
### Question:
BoltTransaction { public void rollback() { Error.ByValue error = BoltNative.BoltDBTransaction_Rollback(objectId); error.checkError(); } BoltTransaction(long objectId); void commit(); void rollback(); int getId(); long getDatabaseSize(); BoltBucket createBucket(byte[] name); BoltBucket createBucketIfNotExists(byte[] name); void deleteBucket(byte[] name); BoltBucket getBucket(byte[] name); BoltCursor createCursor(); BoltTransactionStats getStats(); }### Answer:
@Test public void rollback_transaction() throws IOException { try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { BoltTransaction boltTransaction = bolt.begin(true); boltTransaction.rollback(); } } |
### Question:
BoltTransaction { public int getId() { return BoltNative.BoltDBTransaction_GetId(objectId); } BoltTransaction(long objectId); void commit(); void rollback(); int getId(); long getDatabaseSize(); BoltBucket createBucket(byte[] name); BoltBucket createBucketIfNotExists(byte[] name); void deleteBucket(byte[] name); BoltBucket getBucket(byte[] name); BoltCursor createCursor(); BoltTransactionStats getStats(); }### Answer:
@Test public void get_transaction_id() throws IOException { try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> Assert.assertTrue(boltTransaction.getId() > 0)); } } |
### Question:
BoltTransaction { public long getDatabaseSize() { return BoltNative.BoltDBTransaction_Size(objectId); } BoltTransaction(long objectId); void commit(); void rollback(); int getId(); long getDatabaseSize(); BoltBucket createBucket(byte[] name); BoltBucket createBucketIfNotExists(byte[] name); void deleteBucket(byte[] name); BoltBucket getBucket(byte[] name); BoltCursor createCursor(); BoltTransactionStats getStats(); }### Answer:
@Test public void get_database_size() throws IOException { try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> Assert.assertTrue(boltTransaction.getDatabaseSize() > 0)); } } |
### Question:
BoltTransaction { public BoltBucket createBucket(byte[] name) { Result.ByValue result = BoltNative.BoltDBTransaction_CreateBucket(objectId, name, name.length); result.checkError(); return new BoltBucket(result.objectId); } BoltTransaction(long objectId); void commit(); void rollback(); int getId(); long getDatabaseSize(); BoltBucket createBucket(byte[] name); BoltBucket createBucketIfNotExists(byte[] name); void deleteBucket(byte[] name); BoltBucket getBucket(byte[] name); BoltCursor createCursor(); BoltTransactionStats getStats(); }### Answer:
@Test @SuppressWarnings("EmptyTryBlock") public void create_bucket() throws IOException { try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> { try (BoltBucket ignored = boltTransaction.createBucket("test".getBytes())) {} }); } }
@Test(expected = BoltException.class) public void create_bucket_with_empty_name() throws IOException { try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> boltTransaction.createBucket("".getBytes())); } }
@Test(expected = BoltException.class) @SuppressWarnings("EmptyTryBlock") public void create_bucket_twice() throws IOException { byte[] bucketName = "test".getBytes(); try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> { try (BoltBucket ignored = boltTransaction.createBucket(bucketName)) {} boltTransaction.createBucket(bucketName); }); } } |
### Question:
BoltCursor implements AutoCloseable { public BoltKeyValue first() { try(KeyValue.ByValue keyValue = BoltNative.BoltDBCursor_First(objectId)) { return keyValue.hasKeyValue() ? new BoltKeyValue(keyValue.getKey(), keyValue.getValue()) : null; } } BoltCursor(long objectId); @Override void close(); BoltKeyValue first(); BoltKeyValue last(); BoltKeyValue next(); BoltKeyValue prev(); BoltKeyValue seek(byte[] seek); void delete(); }### Answer:
@Test public void move_first() throws IOException { byte[] bucketName = "test".getBytes(); try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> { try (BoltBucket ignored = boltTransaction.createBucket(bucketName)) { try (BoltCursor cursor = boltTransaction.createCursor()) { BoltKeyValue first = cursor.first(); Assert.assertNotNull(first); Assert.assertArrayEquals(bucketName, first.getKey()); Assert.assertNull(first.getValue()); } } }); } }
@Test public void move_first_when_not_exists() throws IOException { try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> { try (BoltCursor cursor = boltTransaction.createCursor()) { BoltKeyValue first = cursor.first(); Assert.assertNull(first); } }); } } |
### Question:
BoltTransaction { public BoltBucket createBucketIfNotExists(byte[] name) { Result.ByValue result = BoltNative.BoltDBTransaction_CreateBucketIfNotExists(objectId, name, name.length); result.checkError(); return new BoltBucket(result.objectId); } BoltTransaction(long objectId); void commit(); void rollback(); int getId(); long getDatabaseSize(); BoltBucket createBucket(byte[] name); BoltBucket createBucketIfNotExists(byte[] name); void deleteBucket(byte[] name); BoltBucket getBucket(byte[] name); BoltCursor createCursor(); BoltTransactionStats getStats(); }### Answer:
@Test @SuppressWarnings("EmptyTryBlock") public void create_bucket_if_not_exists() throws IOException { byte[] bucketName = "test".getBytes(); try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> { try (BoltBucket ignored = boltTransaction.createBucketIfNotExists(bucketName)) {} }); } }
@Test(expected = BoltException.class) public void create_bucket_if_not_exists_with_empty_name() throws IOException { try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> boltTransaction.createBucketIfNotExists("".getBytes())); } }
@Test @SuppressWarnings("EmptyTryBlock") public void create_bucket_if_not_exists_twice() throws IOException { byte[] bucketName = "test".getBytes(); try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> { try (BoltBucket ignored = boltTransaction.createBucketIfNotExists(bucketName)) {} try (BoltBucket ignored = boltTransaction.createBucketIfNotExists(bucketName)) {} }); } } |
### Question:
BoltTransaction { public void deleteBucket(byte[] name) { Error.ByValue error = BoltNative.BoltDBTransaction_DeleteBucket(objectId, name, name.length); error.checkError(); } BoltTransaction(long objectId); void commit(); void rollback(); int getId(); long getDatabaseSize(); BoltBucket createBucket(byte[] name); BoltBucket createBucketIfNotExists(byte[] name); void deleteBucket(byte[] name); BoltBucket getBucket(byte[] name); BoltCursor createCursor(); BoltTransactionStats getStats(); }### Answer:
@Test(expected = BoltException.class) public void delete_bucket_with_empty_name() throws IOException { try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> boltTransaction.deleteBucket("".getBytes())); } } |
### Question:
BoltTransaction { public BoltBucket getBucket(byte[] name) { Result.ByValue result = BoltNative.BoltDBTransaction_Bucket(objectId, name, name.length); result.checkError(); return new BoltBucket(result.objectId); } BoltTransaction(long objectId); void commit(); void rollback(); int getId(); long getDatabaseSize(); BoltBucket createBucket(byte[] name); BoltBucket createBucketIfNotExists(byte[] name); void deleteBucket(byte[] name); BoltBucket getBucket(byte[] name); BoltCursor createCursor(); BoltTransactionStats getStats(); }### Answer:
@Test(expected = BoltException.class) public void get_bucket_with_empty_name() throws IOException { try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> boltTransaction.getBucket("".getBytes())); } } |
### Question:
BoltTransaction { public BoltCursor createCursor() { long cursorObjectId = BoltNative.BoltDBTransaction_Cursor(objectId); return new BoltCursor(cursorObjectId); } BoltTransaction(long objectId); void commit(); void rollback(); int getId(); long getDatabaseSize(); BoltBucket createBucket(byte[] name); BoltBucket createBucketIfNotExists(byte[] name); void deleteBucket(byte[] name); BoltBucket getBucket(byte[] name); BoltCursor createCursor(); BoltTransactionStats getStats(); }### Answer:
@Test @SuppressWarnings("EmptyTryBlock") public void create_cursor() throws IOException { try(Bolt bolt = new Bolt(testFolder.newFile().getAbsolutePath())) { bolt.update(boltTransaction -> { try (BoltCursor ignored = boltTransaction.createCursor()) {} }); } } |
### Question:
Bolt implements AutoCloseable { public void update(Consumer<BoltTransaction> callback) { BoltTransaction transaction = begin(true); try { callback.accept(transaction); transaction.commit(); } catch (Throwable ex) { transaction.rollback(); throw ex; } } Bolt(String databaseFileName); Bolt(String databaseFileName, EnumSet<BoltFileMode> fileMode); Bolt(String databaseFileName, EnumSet<BoltFileMode> fileMode, BoltOptions options); void close(); BoltTransaction begin(boolean writeable); void update(Consumer<BoltTransaction> callback); void view(Consumer<BoltTransaction> callback); BoltStats getStats(); static void init(); }### Answer:
@Test public void open_update_transaction() throws IOException { String databaseFileName = testFolder.newFile().getAbsolutePath(); try(Bolt bolt = new Bolt(databaseFileName)) { final boolean[] wasInTransaction = {false}; bolt.update(boltTransaction -> { Assert.assertNotNull(boltTransaction); wasInTransaction[0] = true; }); Assert.assertTrue(wasInTransaction[0]); } } |
### Question:
Bolt implements AutoCloseable { public void view(Consumer<BoltTransaction> callback) { BoltTransaction transaction = begin(false); try { callback.accept(transaction); } finally { transaction.rollback(); } } Bolt(String databaseFileName); Bolt(String databaseFileName, EnumSet<BoltFileMode> fileMode); Bolt(String databaseFileName, EnumSet<BoltFileMode> fileMode, BoltOptions options); void close(); BoltTransaction begin(boolean writeable); void update(Consumer<BoltTransaction> callback); void view(Consumer<BoltTransaction> callback); BoltStats getStats(); static void init(); }### Answer:
@Test public void open_view_transaction() throws IOException { String databaseFileName = testFolder.newFile().getAbsolutePath(); try(Bolt bolt = new Bolt(databaseFileName)) { final boolean[] wasInTransaction = {false}; bolt.view(boltTransaction -> { Assert.assertNotNull(boltTransaction); wasInTransaction[0] = true; }); Assert.assertTrue(wasInTransaction[0]); } } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.