@Before
public void setUp() {
when(entityFactory.createMachine(machineDescriptor1)).thenReturn(machine1);
when(entityFactory.createMachine(machineDescriptor2)).thenReturn(machine2);
when(entityFactory.createMachineNode(
isNull(MachineTreeNode.class),
anyString(),
Matchers.<List<MachineTreeNode>>anyObject()))
.thenReturn(rootNode);
//noinspection unchecked
when(entityFactory.createMachineNode(eq(rootNode), eq(machineState2), isNull(List.class)))
.thenReturn(machineNode2);
//noinspection unchecked
when(entityFactory.createMachineNode(eq(rootNode), eq(machineState1), isNull(List.class)))
.thenReturn(machineNode1);
presenter =
new MachinePanelPresenter(
view, service, entityFactory, locale, appliance, eventBus, resources, appContext);
when(service.getMachinesStates(anyString())).thenReturn(machineStatePromise);
when(machineStatePromise.then(Matchers.<Operation<List<MachineStateDto>>>anyObject()))
.thenReturn(machineStatePromise);
when(service.getMachine(anyString())).thenReturn(machinePromise);
when(machinePromise.then(Matchers.<Operation<MachineDto>>anyObject()))
.thenReturn(machinePromise);
when(appContext.getWorkspace()).thenReturn(usersWorkspaceDto);
when(usersWorkspaceDto.getId()).thenReturn(TEXT);
}
@Before
public void setUp() {
when(appContext.getWorkspaceId()).thenReturn(WORKSPACE_ID);
when(machineService.getMachines(anyString())).thenReturn(machinesPromise);
when(machineService.getMachine(anyString())).thenReturn(machinePromise);
when(machinePromise.then(Matchers.<Operation<MachineDto>>anyObject()))
.thenReturn(machinePromise);
when(machineService.getProcesses(anyString())).thenReturn(processesPromise);
when(processesPromise.then(Matchers.<Operation<List<MachineProcessDto>>>anyObject()))
.thenReturn(processesPromise);
presenter =
new ConsolesPanelPresenter(
view,
eventBus,
dtoFactory,
dialogFactory,
entityFactory,
terminalFactory,
commandConsoleFactory,
commandTypeRegistry,
workspaceAgent,
notificationManager,
localizationConstant,
machineService,
resources,
appContext);
}
@Test
public void testPutAll_with_cache_writer() throws Exception {
CacheConfigurationBuilder cacheConfigurationBuilder =
CacheConfigurationBuilder.newCacheConfigurationBuilder(
String.class, String.class, heap(100));
CacheConfiguration<String, String> cacheConfiguration = cacheConfigurationBuilder.build();
CacheLoaderWriterProvider cacheLoaderWriterProvider = mock(CacheLoaderWriterProvider.class);
CacheLoaderWriter cacheLoaderWriter = mock(CacheLoaderWriter.class);
doThrow(new RuntimeException("We should not have called .write() but .writeAll()"))
.when(cacheLoaderWriter)
.write(Matchers.anyObject(), Matchers.anyObject());
when(cacheLoaderWriterProvider.createCacheLoaderWriter(
anyString(), Matchers.any(CacheConfiguration.class)))
.thenReturn(cacheLoaderWriter);
CacheManagerBuilder<CacheManager> managerBuilder =
CacheManagerBuilder.newCacheManagerBuilder().using(cacheLoaderWriterProvider);
CacheManager cacheManager = managerBuilder.withCache("myCache", cacheConfiguration).build(true);
Cache<String, String> myCache = cacheManager.getCache("myCache", String.class, String.class);
HashMap<String, String> stringStringHashMap = new HashMap<String, String>();
for (int i = 0; i < 3; i++) {
stringStringHashMap.put("key" + i, "value" + i);
}
// the call to putAll
myCache.putAll(stringStringHashMap);
verify(cacheLoaderWriter, times(3)).writeAll(Matchers.any(Iterable.class));
Set set =
new HashSet() {
{
add(entry("key0", "value0"));
}
};
verify(cacheLoaderWriter).writeAll(set);
set =
new HashSet() {
{
add(entry("key1", "value1"));
}
};
verify(cacheLoaderWriter).writeAll(set);
set =
new HashSet() {
{
add(entry("key2", "value2"));
}
};
verify(cacheLoaderWriter).writeAll(set);
for (int i = 0; i < 3; i++) {
assertThat(myCache.get("key" + i), is("value" + i));
}
}
@Test
public void testRemoveAll_with_store_that_throws() throws Exception {
CacheConfigurationBuilder cacheConfigurationBuilder =
CacheConfigurationBuilder.newCacheConfigurationBuilder(
String.class, String.class, heap(100));
CacheConfiguration<String, String> cacheConfiguration = cacheConfigurationBuilder.build();
CacheLoaderWriterProvider cacheLoaderWriterProvider = mock(CacheLoaderWriterProvider.class);
CacheLoaderWriter cacheLoaderWriter = mock(CacheLoaderWriter.class);
when(cacheLoaderWriterProvider.createCacheLoaderWriter(
anyString(), Matchers.any(CacheConfiguration.class)))
.thenReturn(cacheLoaderWriter);
CacheManagerBuilder<CacheManager> managerBuilder =
CacheManagerBuilder.newCacheManagerBuilder()
.using(cacheLoaderWriterProvider)
.using(new CustomStoreProvider());
CacheManager cacheManager = managerBuilder.withCache("myCache", cacheConfiguration).build(true);
Cache<String, String> myCache = cacheManager.getCache("myCache", String.class, String.class);
for (int i = 0; i < 3; i++) {
myCache.put("key" + i, "value" + i);
}
doThrow(new RuntimeException("We should not have called .write() but .writeAll()"))
.when(cacheLoaderWriter)
.write(Matchers.anyObject(), Matchers.anyObject());
Set<String> fewKeysSet =
new HashSet<String>() {
{
add("key0");
add("key2");
}
};
// the call to removeAll
myCache.removeAll(fewKeysSet);
for (int i = 0; i < 3; i++) {
if (i == 0 || i == 2) {
assertThat(myCache.get("key" + i), is(nullValue()));
} else {
assertThat(myCache.get("key" + i), is("value" + i));
}
}
Set set =
new HashSet() {
{
add("key0");
add("key2");
}
};
verify(cacheLoaderWriter).deleteAll(set);
}
@Test
public void testPutAll_store_throws_cache_exception() throws Exception {
CacheConfigurationBuilder cacheConfigurationBuilder =
CacheConfigurationBuilder.newCacheConfigurationBuilder(
String.class, String.class, heap(100));
CacheConfiguration<String, String> cacheConfiguration = cacheConfigurationBuilder.build();
CacheLoaderWriterProvider cacheLoaderWriterProvider = mock(CacheLoaderWriterProvider.class);
CacheLoaderWriter cacheLoaderWriter = mock(CacheLoaderWriter.class);
doThrow(new RuntimeException("We should not have called .write() but .writeAll()"))
.when(cacheLoaderWriter)
.write(Matchers.anyObject(), Matchers.anyObject());
when(cacheLoaderWriterProvider.createCacheLoaderWriter(
anyString(), Matchers.any(CacheConfiguration.class)))
.thenReturn(cacheLoaderWriter);
CacheManagerBuilder<CacheManager> managerBuilder =
CacheManagerBuilder.newCacheManagerBuilder()
.using(cacheLoaderWriterProvider)
.using(new CustomStoreProvider());
CacheManager cacheManager = managerBuilder.withCache("myCache", cacheConfiguration).build(true);
Cache<String, String> myCache = cacheManager.getCache("myCache", String.class, String.class);
Map<String, String> stringStringHashMap = new HashMap<String, String>();
for (int i = 0; i < 3; i++) {
stringStringHashMap.put("key" + i, "value" + i);
}
// the call to putAll
myCache.putAll(stringStringHashMap);
for (int i = 0; i < 3; i++) {
// the store threw an exception when we call bulkCompute
assertThat(myCache.get("key" + i), is(nullValue()));
// but still, the cache writer could writeAll the values !
// assertThat(cacheWriterToHashMapMap.get("key" + i), is("value" + i));
}
// but still, the cache writer could writeAll the values at once !
verify(cacheLoaderWriter, times(1)).writeAll(Matchers.any(Iterable.class));
Set set =
new HashSet() {
{
add(entry("key0", "value0"));
add(entry("key1", "value1"));
add(entry("key2", "value2"));
}
};
verify(cacheLoaderWriter).writeAll(set);
}
void mockQuery(final String name, final List<Registration> results) {
final Query mockedQuery = mock(Query.class);
when(mockedQuery.getResultList()).thenReturn(results);
when(mockedQuery.setParameter(Matchers.anyString(), Matchers.anyObject()))
.thenReturn(mockedQuery);
when(this.cut.em.createNamedQuery(name)).thenReturn(mockedQuery);
}
@Test
public void emptyClusterListTest()
throws InsufficientServerCapacityException, AffinityConflictException {
ServiceOfferingVO svcOffering =
new ServiceOfferingVO(
"testOffering",
1,
512,
500,
1,
1,
false,
false,
false,
"test dpm",
ProvisioningType.THIN,
false,
false,
null,
false,
VirtualMachine.Type.User,
domainId,
null,
"FirstFitPlanner");
Mockito.when(vmProfile.getServiceOffering()).thenReturn(svcOffering);
DataCenterDeployment plan = new DataCenterDeployment(dataCenterId);
Mockito.when(avoids.shouldAvoid((DataCenterVO) Matchers.anyObject())).thenReturn(false);
Mockito.when(_planner.canHandle(vmProfile, plan, avoids)).thenReturn(true);
Mockito.when(((DeploymentClusterPlanner) _planner).orderClusters(vmProfile, plan, avoids))
.thenReturn(null);
DeployDestination dest = _dpm.planDeployment(vmProfile, plan, avoids, null);
assertNull("Planner cannot handle, destination should be null! ", dest);
}
@Test
public void show_How_Stubbing_Works() {
/**
* Set up phase.
*
* <p>1. Create Mocks, 2. Stub only required methods 3. Inject the mock objects.
*/
// Stubbing
when(mockedBookDao.getTop5BooksOnSale()).thenReturn(top5BooksOnSaleList);
when(mockedBookDao.getSpecialPromotionsBasedOnUser(Matchers.<User>anyObject()))
.thenReturn(booksOnSpecialPromotionList);
// Injecting mocked DAO
promotionsService.setBookDao(mockedBookDao);
// Calling business method
final List<Book> promotionList = promotionsService.getSimplePromotions(user);
// Verification of behavior
verify(mockedBookDao).getSpecialPromotionsBasedOnUser(user);
verify(mockedBookDao, never()).getTop5BooksOnSale();
assertNotNull(promotionList);
assertTrue(
promotionList.size()
== 3); // Stubbed method being called because the size is 3. The real method returns 1
// element list.
}
@Test
public void services_Are_Being_Mocked_Here() {
// Mock
CustomerSpecialsService customerSpecialsService = mock(CustomerSpecialsService.class);
WeeklySpecialsService weeklySpecialsService = mock(WeeklySpecialsService.class);
// Stubbing
when(mockedBookDao.getTop5BooksOnSale()).thenReturn(top5BooksOnSaleList);
when(mockedBookDao.getSpecialPromotionsBasedOnUser(null))
.thenReturn(booksOnSpecialPromotionList);
when(customerSpecialsService.getSpecials()).thenReturn(booksOnSpecialPromotionList);
final PromotionsService promotionsService = new PromotionsService();
promotionsService.setBookDao(mockedBookDao); // Inject mocked DAO
promotionsService.setCustomerSpecialsService(customerSpecialsService); // This is mocked too!
promotionsService.setWeeklySpecialsService(
weeklySpecialsService); // And this one too is mocked!
// Passing in null user
final List<Book> promotionList = promotionsService.getPromotions(null);
verify(mockedBookDao).getTop5BooksOnSale();
verify(mockedBookDao, never()).getSpecialPromotionsBasedOnUser(null);
verify(customerSpecialsService, never()).applySpecials(anyList(), Matchers.<User>anyObject());
verify(customerSpecialsService).getSpecials();
assertNotNull(promotionList);
assertTrue(promotionList.size() == 3);
}
@Test(enabled = true)
public void shouldValidateRequestWhenAuthenticationFailed()
throws ResourceException, AuthException {
// Given
MessageInfoContext messageInfo = mock(MessageInfoContext.class);
AuthenticatorResult authResult = mock(AuthenticatorResult.class);
Subject clientSubject = new Subject();
Subject serviceSubject = new Subject();
Map<String, Object> messageInfoMap = new HashMap<String, Object>();
Map<String, Object> auditInfoMap = new HashMap<String, Object>();
Request request = new Request();
given(messageInfo.getRequest()).willReturn(request);
request.getHeaders().put("X-OpenIDM-Username", "USERNAME");
request.getHeaders().put("X-OpenIDM-Password", "PASSWORD");
given(messageInfo.getRequestContextMap()).willReturn(messageInfoMap);
messageInfoMap.put(AuditTrail.AUDIT_INFO_KEY, auditInfoMap);
given(authResult.isAuthenticated()).willReturn(false);
given(authenticator.authenticate(eq("USERNAME"), eq("PASSWORD"), Matchers.<Context>anyObject()))
.willReturn(authResult);
// When
AuthStatus authStatus =
module
.validateRequest(messageInfo, clientSubject, serviceSubject)
.getOrThrowUninterruptibly();
// Then
assertTrue(clientSubject.getPrincipals().isEmpty());
assertEquals(authStatus, AuthStatus.SEND_FAILURE);
}
@Test
public void shouldReadResourceSet() throws Exception {
// Given
ServerContext context = mock(ServerContext.class);
ReadRequest request = mock(ReadRequest.class);
given(request.getFields()).willReturn(Arrays.asList(new JsonPointer("/fred")));
ResultHandler<Resource> handler = mock(ResultHandler.class);
ResourceSetDescription resourceSet = new ResourceSetDescription();
resourceSet.setDescription(json(object()));
Promise<ResourceSetDescription, ResourceException> resourceSetPromise =
Promises.newSuccessfulPromise(resourceSet);
given(contextHelper.getRealm(context)).willReturn("REALM");
given(contextHelper.getUserId(context)).willReturn("RESOURCE_OWNER_ID");
given(
resourceSetService.getResourceSet(
context, "REALM", "RESOURCE_SET_ID", "RESOURCE_OWNER_ID", false))
.willReturn(resourceSetPromise);
// When
resource.readInstance(context, "RESOURCE_SET_ID", request, handler);
// Then
verify(handler).handleResult(Matchers.<Resource>anyObject());
}
@Test
public void shouldQueryResourceSetToken() throws Exception {
// Given
Map<String, Object> queryParameters = new HashMap<String, Object>();
queryParameters.put(ResourceSetTokenField.CLIENT_ID, "CLIENT_ID");
ResourceSetDescription resourceSet1 =
new ResourceSetDescription(
"123", "CLIENT_ID", "RESOURCE_OWNER_ID", Collections.<String, Object>emptyMap());
ResourceSetDescription resourceSet2 =
new ResourceSetDescription(
"456", "CLIENT_ID", "RESOURCE_OWNER_ID", Collections.<String, Object>emptyMap());
given(dataStore.query(Matchers.<QueryFilter<String>>anyObject()))
.willReturn(asSet(resourceSet1, resourceSet2));
resourceSet1.setRealm("REALM");
resourceSet2.setRealm("REALM");
// When
QueryFilter<String> query = QueryFilter.alwaysTrue();
Set<ResourceSetDescription> resourceSetDescriptions = store.query(query);
// Then
assertThat(resourceSetDescriptions).contains(resourceSet1, resourceSet2);
ArgumentCaptor<QueryFilter> tokenFilterCaptor = ArgumentCaptor.forClass(QueryFilter.class);
verify(dataStore).query(tokenFilterCaptor.capture());
assertThat(tokenFilterCaptor.getValue())
.isEqualTo(
QueryFilter.and(query, QueryFilter.equalTo(ResourceSetTokenField.REALM, "REALM")));
}
@Test(enabled = false, expectedExceptions = BadRequestException.class)
public void shouldNotCreateDuplicateResourceSetWithSameId() throws Exception {
// Given
OAuth2Request request = mock(OAuth2Request.class);
ResourceSetDescription resourceSetDescription =
new ResourceSetDescription(
"RESOURCE_SET_ID",
"CLIENT_ID",
"RESOURCE_OWNER_ID",
Collections.<String, Object>singletonMap("name", "RESOURCE_SET_NAME"));
resourceSetDescription.setRealm("REALM");
given(dataStore.query(Matchers.<QueryFilter<String>>anyObject()))
.willReturn(Collections.singleton(resourceSetDescription));
// When
try {
store.create(request, resourceSetDescription);
} catch (BadRequestException e) {
// Then
assertThat(resourceSetDescription.getPolicyUri()).isNull();
verify(dataStore, never()).create(any(ResourceSetDescription.class));
throw e;
}
}
@Test
public void testRemoveAll_cache_writer_throws_exception() throws Exception {
CacheConfigurationBuilder cacheConfigurationBuilder =
CacheConfigurationBuilder.newCacheConfigurationBuilder(
String.class, String.class, heap(100));
CacheConfiguration<String, String> cacheConfiguration = cacheConfigurationBuilder.build();
CacheLoaderWriterProvider cacheLoaderWriterProvider = mock(CacheLoaderWriterProvider.class);
CacheLoaderWriter cacheLoaderWriterThatThrows = mock(CacheLoaderWriter.class);
doThrow(new Exception("Simulating an exception from the cache writer"))
.when(cacheLoaderWriterThatThrows)
.deleteAll(Matchers.any(Iterable.class));
when(cacheLoaderWriterProvider.createCacheLoaderWriter(
anyString(), Matchers.any(CacheConfiguration.class)))
.thenReturn(cacheLoaderWriterThatThrows);
CacheManagerBuilder<CacheManager> managerBuilder =
CacheManagerBuilder.newCacheManagerBuilder().using(cacheLoaderWriterProvider);
CacheManager cacheManager = managerBuilder.withCache("myCache", cacheConfiguration).build(true);
Cache<String, String> myCache = cacheManager.getCache("myCache", String.class, String.class);
for (int i = 0; i < 3; i++) {
myCache.put("key" + i, "value" + i);
}
doThrow(new RuntimeException("We should not have called .write() but .writeAll()"))
.when(cacheLoaderWriterThatThrows)
.write(Matchers.anyObject(), Matchers.anyObject());
Set<String> fewKeysSet =
new HashSet<String>() {
{
add("key0");
add("key2");
}
};
// the call to removeAll
try {
myCache.removeAll(fewKeysSet);
fail();
} catch (BulkCacheWritingException bcwe) {
assertThat(bcwe.getFailures().size(), is(2));
assertThat(bcwe.getSuccesses().size(), is(0));
}
}
@Test
public void actionCollectionShouldHandleUnsupportedAction() {
// Given
ServerContext context = mock(ServerContext.class);
ActionRequest request = mock(ActionRequest.class);
ResultHandler<JsonValue> handler = mock(ResultHandler.class);
given(request.getAction()).willReturn("UNSUPPORTED_ACTION");
// When
resource.actionCollection(context, request, handler);
// Then
verify(handler).handleError(Matchers.<NotSupportedException>anyObject());
verify(handler, never()).handleResult(Matchers.<JsonValue>anyObject());
}
@Test
public void shouldNotSetExceptionResponse() {
// Given
Request request = mock(Request.class);
Response response = mock(Response.class);
Status status = new Status(111);
given(response.getStatus()).willReturn(status);
// When
exceptionFilter.afterHandle(request, response);
// Then
verify(response, never()).setEntity(Matchers.<Representation>anyObject());
verify(response, never()).setStatus(Matchers.<Status>anyObject());
}
@Test
public void treeShouldBeDisplayedWithMachines() throws Exception {
presenter.showMachines();
verify(service).getMachinesStates(anyString());
verify(machineStatePromise).then(operationMachineStateCaptor.capture());
operationMachineStateCaptor.getValue().apply(Collections.singletonList(machineState1));
verify(entityFactory)
.createMachineNode(
isNull(MachineTreeNode.class), eq("root"), Matchers.<List<MachineTreeNode>>anyObject());
verify(entityFactory).createMachineNode(eq(rootNode), eq(machineState1), eq(null));
verify(view).setData(Matchers.<MachineTreeNode>anyObject());
verify(view).selectNode(machineNode1);
}
@Test(dataProvider = "dataWithoutVersionHeader")
@SuppressWarnings("unchecked")
public void shouldRouteActionRequestsUsingDefaultVersionBehaviour(
String resource,
DefaultVersionBehaviour versionBehaviour,
boolean expectException,
RequestHandler provider) {
// Given
AcceptAPIVersionContext apiVersionContext =
new AcceptAPIVersionContext(
new RootContext(),
"PROTOCOL_NAME",
AcceptAPIVersion.newBuilder().withDefaultProtocolVersion("1.0").build());
ServerContext context = new ServerContext(apiVersionContext);
ActionRequest request =
Requests.newActionRequest(resource, "ACTION_ID").setContent(json(object()));
ResultHandler<JsonValue> handler = mock(ResultHandler.class);
setDefaultVersionBehaviour(router, versionBehaviour);
// When
router.handleAction(context, request, handler);
// Then
if (expectException) {
ArgumentCaptor<ResourceException> exceptionCaptor =
ArgumentCaptor.forClass(ResourceException.class);
verify(handler).handleError(exceptionCaptor.capture());
assertThat(exceptionCaptor.getValue()).isInstanceOf(BadRequestException.class);
verifyZeroInteractions(
usersHandlerOne,
usersHandlerTwo,
usersHandlerThree,
groupsHandlerOne,
groupsHandlerTwo,
groupsHandlerThree);
} else {
verify(provider)
.handleAction(
Matchers.<ServerContext>anyObject(),
Matchers.<ActionRequest>anyObject(),
eq(handler));
}
}
@Test
public void testBroadcast() throws Exception {
TestObjects.initBukkitOnlinePlayers();
int sendPacketCalls = 0;
int playerCount = Bukkit.getOnlinePlayers().size();
ActionBarSender.broadcast(new Message(""));
sendPacketCalls += playerCount;
verifyStatic(times(sendPacketCalls));
Utils.sendPacket(any(Player.class), Matchers.anyObject());
ActionBarSender actionBarSender = new ActionBarSender();
actionBarSender.doBroadcast("");
sendPacketCalls += playerCount;
verifyStatic(times(sendPacketCalls));
Utils.sendPacket(any(Player.class), Matchers.anyObject());
actionBarSender.doBroadcast("", 34);
sendPacketCalls += playerCount;
verifyStatic(times(sendPacketCalls));
Utils.sendPacket(any(Player.class), Matchers.anyObject());
}
@Test
public void constructorShouldBeVerified() {
verify(entityFactory)
.createMachineNode(eq(null), eq("root"), Matchers.<List<MachineTreeNode>>anyObject());
verify(eventBus).addHandler(MachineStateEvent.TYPE, presenter);
verify(eventBus).addHandler(WorkspaceStartedEvent.TYPE, presenter);
verify(eventBus).addHandler(StopWorkspaceEvent.TYPE, presenter);
verify(eventBus).addHandler(MachineStartingEvent.TYPE, presenter);
}
@Test(dataProvider = "dataWithVersionHeader")
@SuppressWarnings("unchecked")
public void shouldRouteDeleteVersionRequests(
String resource, String requestedVersion, boolean expectException, RequestHandler provider) {
// Given
AcceptAPIVersionContext apiVersionContext =
new AcceptAPIVersionContext(
new RootContext(),
"PROTOCOL_NAME",
AcceptAPIVersion.newBuilder()
.withDefaultProtocolVersion("1.0")
.withDefaultResourceVersion(requestedVersion)
.build());
ServerContext context = new ServerContext(apiVersionContext);
DeleteRequest request = Requests.newDeleteRequest(resource);
ResultHandler<Resource> handler = mock(ResultHandler.class);
// When
router.handleDelete(context, request, handler);
// Then
if (expectException) {
ArgumentCaptor<ResourceException> exceptionCaptor =
ArgumentCaptor.forClass(ResourceException.class);
verify(handler).handleError(exceptionCaptor.capture());
assertThat(exceptionCaptor.getValue()).isInstanceOf(NotFoundException.class);
verifyZeroInteractions(
usersHandlerOne,
usersHandlerTwo,
usersHandlerThree,
groupsHandlerOne,
groupsHandlerTwo,
groupsHandlerThree);
} else {
verify(provider)
.handleDelete(
Matchers.<ServerContext>anyObject(),
Matchers.<DeleteRequest>anyObject(),
eq(handler));
}
}
@Test
public void shouldNotSaveDataWhenNoMeasures() {
NewCoverageAggregator aggregator = new NewCoverageAggregator();
DecoratorContext context = mock(DecoratorContext.class);
when(context.getChildrenMeasures(CoreMetrics.NEW_LINES_TO_COVER))
.thenReturn(Collections.<Measure>emptyList());
aggregator.aggregate(context, CoreMetrics.NEW_LINES_TO_COVER, 3);
verify(context, never()).saveMeasure(Matchers.<Measure>anyObject());
}
@Test
public void isCalibrating() {
sessionManager = spy(sessionManager);
doReturn(new Session())
.when(sessionManager.sessionRepository)
.loadFully(anyLong(), Matchers.<ProgressListener>anyObject());
sessionManager.loadSession(0, progressListener);
verify(sessionManager, atLeastOnce()).setSession(any(Session.class));
}
@Test
public void revokeAllUserPoliciesActionShouldHandleResourceException() {
// Given
ServerContext context = mock(ServerContext.class);
ActionRequest request = mock(ActionRequest.class);
ResultHandler<JsonValue> handler = mock(ResultHandler.class);
given(contextHelper.getRealm(context)).willReturn("REALM");
given(contextHelper.getUserId(context)).willReturn("RESOURCE_OWNER_ID");
given(request.getAction()).willReturn("revokeAll");
given(resourceSetService.revokeAllPolicies(context, "REALM", "RESOURCE_OWNER_ID"))
.willReturn(Promises.<Void, ResourceException>newFailedPromise(new NotFoundException()));
// When
resource.actionCollection(context, request, handler);
// Then
verify(handler).handleError(Matchers.<ResourceException>anyObject());
verify(handler, never()).handleResult(Matchers.<JsonValue>anyObject());
}
@Test
public void testSend() throws InvocationTargetException, IllegalAccessException {
int sendPacketCalls = 0;
//noinspection SpellCheckingInspection
TestBukkitPlayer player = new TestBukkitPlayer();
List<Player> players = new ArrayList<>();
players.add(player);
players.add(player);
int playerCount = players.size();
ActionBarSender.send(player, new Message(""));
verifyStatic(times(++sendPacketCalls));
Utils.sendPacket(any(Player.class), Matchers.anyObject());
ActionBarSender.send(players, new Message(""));
sendPacketCalls += playerCount;
verifyStatic(times(sendPacketCalls));
Utils.sendPacket(any(Player.class), Matchers.anyObject());
ActionBarSender actionBarSender = new ActionBarSender();
actionBarSender.doSend(player, "");
verifyStatic(times(++sendPacketCalls));
Utils.sendPacket(any(Player.class), Matchers.anyObject());
actionBarSender.doSend(player, "", false);
verifyStatic(times(++sendPacketCalls));
Utils.sendPacket(any(Player.class), Matchers.anyObject());
actionBarSender.doSend(players, "");
sendPacketCalls += playerCount;
verifyStatic(times(sendPacketCalls));
Utils.sendPacket(any(Player.class), Matchers.anyObject());
actionBarSender.doSend(players, "", true);
sendPacketCalls += playerCount;
verifyStatic(times(sendPacketCalls));
Utils.sendPacket(any(Player.class), Matchers.anyObject());
}
@Test
public void addMember() {
Member member = new Member();
member.setEmail("*****@*****.**");
member.setPassword("pass");
memberService.add(member);
verify(mockPasswordEncoder).encodePassword("pass", null);
verify(mockMemberRepository).add(member);
verify(mockSendMailService).sendMessage(Matchers.<SpringSproutMessage>anyObject());
assertThat(member.getAvatar(), is(CoreMatchers.<Object>notNullValue()));
}
@Test
public void testDeleteWhenDeleteIsFailed() throws Exception {
doAnswer(
new Answer() {
@Override
public Object answer(InvocationOnMock invocation) throws Throwable {
Object[] arguments = invocation.getArguments();
AsyncRequestCallback<Void> callback = (AsyncRequestCallback<Void>) arguments[1];
GwtReflectionUtils.callOnFailure(callback, mock(Throwable.class));
return callback;
}
})
.when(projectServiceClient)
.delete(anyString(), (AsyncRequestCallback<Void>) anyObject());
DeleteCallback callback = mock(DeleteCallback.class);
projectNode.delete(callback);
verify(projectServiceClient)
.delete(eq(ITEM_PATH), Matchers.<AsyncRequestCallback<Void>>anyObject());
verify(callback).onFailure(Matchers.<Throwable>anyObject());
}
@Test
public void shouldShowMachinesWhenMachinesPartIsActive() throws Exception {
ActivePartChangedEvent event = mock(ActivePartChangedEvent.class);
when(event.getActivePart()).thenReturn(presenter);
presenter.onActivePartChanged(event);
verify(event).getActivePart();
verify(appContext).getWorkspace();
verify(service).getMachinesStates(anyString());
verify(machineStatePromise).then(operationMachineStateCaptor.capture());
operationMachineStateCaptor.getValue().apply(Collections.singletonList(machineState1));
verify(entityFactory)
.createMachineNode(
isNull(MachineTreeNode.class), eq("root"), Matchers.<List<MachineTreeNode>>anyObject());
verify(entityFactory).createMachineNode(eq(rootNode), eq(machineState1), eq(null));
verify(view).setData(Matchers.<MachineTreeNode>anyObject());
verify(view).selectNode(machineNode1);
}
@Test
public void createShouldNotBeSupported() {
// Given
ServerContext context = mock(ServerContext.class);
CreateRequest request = mock(CreateRequest.class);
ResultHandler<Resource> handler = mock(ResultHandler.class);
// When
resource.createInstance(context, request, handler);
// Then
verify(handler).handleError(Matchers.<NotSupportedException>anyObject());
}
@Test
public void testGetChildrenWhenRequestFailure() throws Exception {
String path = "path";
AsyncCallback asyncCallback = mock(AsyncCallback.class);
projectNode.getChildren(path, asyncCallback);
verify(projectServiceClient).getChildren(eq(path), asyncRequestCallbackCaptor.capture());
AsyncRequestCallback<Array<ItemReference>> requestCallback =
asyncRequestCallbackCaptor.getValue();
GwtReflectionUtils.callOnFailure(requestCallback, mock(Throwable.class));
verify(asyncCallback).onFailure(Matchers.<Throwable>anyObject());
}