@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()); }