@Test
public void testValidSubscription() {
// add configuration
// Mock the task scheduler and capture the runnable
ArgumentCaptor<Runnable> runnableArg = ArgumentCaptor.forClass(Runnable.class);
when(taskScheduler.scheduleWithFixedDelay(runnableArg.capture(), anyLong()))
.thenReturn(Mockito.mock(ScheduledFuture.class));
// Mock the response to the subsribeContext
ArgumentCaptor<SuccessCallback> successArg = ArgumentCaptor.forClass(SuccessCallback.class);
ListenableFuture<SubscribeContextResponse> responseFuture =
Mockito.mock(ListenableFuture.class);
doNothing().when(responseFuture).addCallback(successArg.capture(), any());
Configuration configuration = getBasicConf();
subscriptionManager.setConfiguration(configuration);
// Capture the arg of subscription and return the mocked future
ArgumentCaptor<String> urlProviderArg = ArgumentCaptor.forClass(String.class);
ArgumentCaptor<SubscribeContext> subscribeContextArg =
ArgumentCaptor.forClass(SubscribeContext.class);
when(ngsiClient.subscribeContext(
urlProviderArg.capture(), eq(null), subscribeContextArg.capture()))
.thenReturn(responseFuture);
// Execute scheduled runnable
runnableArg.getValue().run();
// Return the SubscribeContextResponse
callSuccessCallback(successArg);
// check ngsiClient.unsubscribe() is never called
verify(ngsiClient, never()).unsubscribeContext(any(), any(), any());
subscriptionManager.validateSubscriptionId("12345678", "http://iotAgent");
}
@Test
public void testGetUsersWithAuthority() throws SQLException {
String expectedQuery =
"select \"public\".\"users\".\"username\", \"public\".\"users\".\"locked\", \"public\".\"authorities\".\"authority\", count(\"public\".\"users\".\"username\") over () as \"count\" from \"public\".\"users\" join \"public\".\"authorities\" on \"public\".\"users\".\"username\" = \"public\".\"authorities\".\"username\" where \"public\".\"authorities\".\"authority\" = 'ROLE_ADMIN' order by \"public\".\"users\".\"username\" asc limit 5 offset 0";
Pageable pageable = Mockito.mock(Pageable.class);
ResultSet resultSet = Mockito.mock(ResultSet.class);
Mockito.when(pageable.getPageNumber()).thenReturn(0);
Mockito.when(pageable.getPageSize()).thenReturn(5);
Mockito.when(resultSet.getInt(PagingConstants.COUNT)).thenReturn(1);
Mockito.when(resultSet.getString("username")).thenReturn("admin");
RESTPage<UserDTO> page = userDao.getUsersWithAuthority("ROLE_ADMIN", pageable);
ArgumentCaptor<PagingRowCallbackHandler> pagingRowCallbackHandlerCaptor =
ArgumentCaptor.forClass(PagingRowCallbackHandler.class);
Mockito.verify(jdbcTemplate)
.query(Matchers.eq(expectedQuery), pagingRowCallbackHandlerCaptor.capture());
PagingRowCallbackHandler pagingRowCallbackHandler = pagingRowCallbackHandlerCaptor.getValue();
pagingRowCallbackHandler.processRow(resultSet);
Mockito.verify(resultSet).getInt(PagingConstants.COUNT);
Mockito.verify(resultSet).getString("username");
Assert.assertEquals(1, page.getContentSize());
Assert.assertEquals("admin", page.getContent().get(0).getUsername());
}
@Test
public void setConfigurationOK() throws Exception {
// Mock the task scheduler and capture the runnable
ArgumentCaptor<Runnable> runnableArg = ArgumentCaptor.forClass(Runnable.class);
when(taskScheduler.scheduleWithFixedDelay(runnableArg.capture(), anyLong()))
.thenReturn(Mockito.mock(ScheduledFuture.class));
// Mock the response to the subsribeContext
ArgumentCaptor<SuccessCallback> successArg = ArgumentCaptor.forClass(SuccessCallback.class);
ListenableFuture<SubscribeContextResponse> responseFuture =
Mockito.mock(ListenableFuture.class);
doNothing().when(responseFuture).addCallback(successArg.capture(), any());
Configuration configuration = getBasicConf();
subscriptionManager.setConfiguration(configuration);
// Capture the arg of subscription and return the mocked future
ArgumentCaptor<String> urlProviderArg = ArgumentCaptor.forClass(String.class);
ArgumentCaptor<SubscribeContext> subscribeContextArg =
ArgumentCaptor.forClass(SubscribeContext.class);
when(ngsiClient.subscribeContext(
urlProviderArg.capture(), eq(null), subscribeContextArg.capture()))
.thenReturn(responseFuture);
// Execute scheduled runnable
runnableArg.getValue().run();
// Return the SubscribeContextResponse
callSuccessCallback(successArg);
SubscribeContext subscribeContext = subscribeContextArg.getValue();
assertEquals("S.*", subscribeContext.getEntityIdList().get(0).getId());
assertEquals("TempSensor", subscribeContext.getEntityIdList().get(0).getType());
assertEquals(true, subscribeContext.getEntityIdList().get(0).getIsPattern());
assertEquals("temp", subscribeContext.getAttributeList().get(0));
assertEquals("PT1H", subscribeContext.getDuration());
assertEquals("http://iotAgent", urlProviderArg.getValue());
Set<Provider> providers = configuration.getEventTypeIns().get(0).getProviders();
for (Provider provider : providers) {
assertEquals("12345678", provider.getSubscriptionId());
assertNotNull(provider.getSubscriptionDate());
}
}
@SuppressWarnings("unchecked")
@Test
public void canPushAllOnMultipleAdd() {
diff(listWith(), listWith("1", "2"));
ArgumentCaptor<List> captor = ArgumentCaptor.forClass(List.class);
verify(dbObjectDiff).addPushAll(captor.capture());
List<Object> value = captor.getValue();
assertThat(value).hasSize(2).contains("1", "2");
}
@Test
public void testUnsubscribeOnProviderRemoval() {
// Mock the task scheduler and capture the runnable
ArgumentCaptor<Runnable> runnableArg = ArgumentCaptor.forClass(Runnable.class);
when(taskScheduler.scheduleWithFixedDelay(runnableArg.capture(), anyLong()))
.thenReturn(Mockito.mock(ScheduledFuture.class));
// Mock the response to the subsribeContext
ArgumentCaptor<SuccessCallback> successArg = ArgumentCaptor.forClass(SuccessCallback.class);
ListenableFuture<SubscribeContextResponse> responseFuture =
Mockito.mock(ListenableFuture.class);
doNothing().when(responseFuture).addCallback(successArg.capture(), any());
// Return the mocked future on subscription
when(ngsiClient.subscribeContext(any(), any(), any())).thenReturn(responseFuture);
Configuration configuration = getBasicConf();
subscriptionManager.setConfiguration(configuration);
// Execute scheduled runnable
runnableArg.getValue().run();
// Return the SubscribeContextResponse
callSuccessCallback(successArg);
// Mock future for unsubscribeContext
ListenableFuture<UnsubscribeContextResponse> responseFuture2 =
Mockito.mock(ListenableFuture.class);
doNothing().when(responseFuture2).addCallback(successArg.capture(), any());
when(ngsiClient.unsubscribeContext(eq("http://iotAgent"), eq(null), eq("12345678")))
.thenReturn(responseFuture2);
// Reset conf should trigger unsubsribeContext
Configuration emptyConfiguration = getBasicConf();
emptyConfiguration.getEventTypeIns().get(0).setProviders(Collections.emptySet());
subscriptionManager.setConfiguration(emptyConfiguration);
// Check that unsubsribe is called
Assert.notNull(successArg.getValue());
}
@Test
public void testEncodedMemoryCacheGetSuccessful() {
setupEncodedMemoryCacheGetSuccess();
when(mProducerContext.getLowestPermittedRequestLevel())
.thenReturn(ImageRequest.RequestLevel.ENCODED_MEMORY_CACHE);
mEncodedMemoryCacheProducer.produceResults(mConsumer, mProducerContext);
ArgumentCaptor<EncodedImage> argumentCaptor = ArgumentCaptor.forClass(EncodedImage.class);
verify(mConsumer).onNewResult(argumentCaptor.capture(), eq(true));
EncodedImage encodedImage = argumentCaptor.getValue();
Assert.assertSame(
mFinalEncodedImage.getUnderlyingReferenceTestOnly(),
encodedImage.getUnderlyingReferenceTestOnly());
verify(mProducerListener).onProducerStart(mRequestId, PRODUCER_NAME);
Map<String, String> extraMap = ImmutableMap.of(EncodedMemoryCacheProducer.VALUE_FOUND, "true");
verify(mProducerListener).onProducerFinishWithSuccess(mRequestId, PRODUCER_NAME, extraMap);
Assert.assertFalse(mFinalImageReference.isValid());
}
@Test
public void testEncodedMemoryCacheGetNotFoundNextProducerSuccess() {
setupEncodedMemoryCacheGetNotFound();
setupNextProducerStreamingSuccess();
mEncodedMemoryCacheProducer.produceResults(mConsumer, mProducerContext);
verify(mMemoryCache, never()).cache(mCacheKey, mIntermediateImageReference);
ArgumentCaptor<CloseableReference> argumentCaptor =
ArgumentCaptor.forClass(CloseableReference.class);
verify(mMemoryCache).cache(eq(mCacheKey), argumentCaptor.capture());
CloseableReference<PooledByteBuffer> capturedRef =
(CloseableReference<PooledByteBuffer>) argumentCaptor.getValue();
Assert.assertSame(
mFinalImageReference.getUnderlyingReferenceTestOnly(),
capturedRef.getUnderlyingReferenceTestOnly());
verify(mConsumer).onNewResult(mIntermediateEncodedImage, false);
verify(mConsumer).onNewResult(mFinalEncodedImage, true);
Assert.assertTrue(EncodedImage.isValid(mFinalEncodedImageClone));
verify(mProducerListener).onProducerStart(mRequestId, PRODUCER_NAME);
Map<String, String> extraMap = ImmutableMap.of(EncodedMemoryCacheProducer.VALUE_FOUND, "false");
verify(mProducerListener).onProducerFinishWithSuccess(mRequestId, PRODUCER_NAME, extraMap);
}
/**
* Check creating new article with get user auth context
*
* @throws Exception
*/
@Test
@PrepareForTest({SecurityContextHolder.class})
public void testCreateArticle() throws Exception {
Article article = new Article();
PowerMockito.mockStatic(SecurityContextHolder.class);
PowerMockito.when(SecurityContextHolder.getContext()).thenReturn(securityContext);
Mockito.when(securityContext.getAuthentication()).thenReturn(authentication);
Mockito.when(authentication.getPrincipal()).thenReturn(userDetail);
Mockito.when(userDetail.getUsername()).thenReturn("userName");
Mockito.when(userService.getAuthorizedUser()).thenReturn(user);
articleService.createArticle(article);
ArgumentCaptor<Article> argument = ArgumentCaptor.forClass(Article.class);
Mockito.verify(articleDao, Mockito.times(1)).createArticle(argument.capture());
Assert.assertEquals(argument.getValue().getUserOwner(), user);
}