@Test public void findAllNotSecure() { final Map<String, UserOrg> users = new HashMap<>(); final UserOrg user1 = newUser(); users.put("wuser", user1); final UserOrg user2 = new UserOrg(); user2.setCompany("ing"); user2.setGroups(Collections.singletonList("any")); users.put("user2", user2); final GroupOrg groupOrg1 = new GroupOrg("cn=DIG,ou=fonction,ou=groups,dc=sample,dc=com", "DIG", Collections.singleton("wuser")); final Map<String, GroupOrg> groupsMap = new HashMap<>(); groupsMap.put("dig", groupOrg1); resource.groupResource = Mockito.mock(GroupResource.class); final CompanyOrg company = new CompanyOrg("ou=ing,ou=france,ou=people,dc=sample,dc=com", "ing"); Mockito.when(companyRepository.findByIdExpected(DEFAULT_USER, "ing")).thenReturn(company); groupFindById(DEFAULT_USER, "dig", groupOrg1); Mockito.when(userRepository.findAll(ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.any())) .thenReturn(new PageImpl<>(new ArrayList<>(users.values()))); Mockito.when(resource.groupResource.getContainers()).thenReturn(new HashSet<>(groupsMap.values())); Mockito.when(resource.groupResource.getContainersForWrite()).thenReturn(new HashSet<>(groupsMap.values())); final List<UserOrg> data = resource.findAllNotSecure(null, null); // Check the users checkUser(data.get(0)); }
/** * Mock a managed LDAP desynchronization */ @Test public void removeUserSync() { final GroupLdapRepository groupRepository = new GroupLdapRepository() { @Override public GroupOrg findById(final String name) { // The group has only the user user we want to remove return new GroupOrg("dc=" + name, name, Collections.singleton("flast1")); } }; groupRepository.setLdapCacheRepository(Mockito.mock(LdapCacheRepository.class)); final LdapTemplate ldapTemplate = Mockito.mock(LdapTemplate.class); groupRepository.setTemplate(ldapTemplate); Mockito.doThrow(new org.springframework.ldap.AttributeInUseException(new AttributeInUseException("any"))).when(ldapTemplate) .modifyAttributes(ArgumentMatchers.any(LdapName.class), ArgumentMatchers.any()); removeUser(groupRepository); }
@Before public void before() throws Exception { Answer<Cancelable> runAndReturn = new Answer<Cancelable>() { @Override public Cancelable answer(InvocationOnMock invocation) throws Exception { try { Function0<Unit> block = invocation.getArgument(0); block.invoke(); } catch (Exception e) { e.printStackTrace(); Assert.fail(e.getMessage()); } return canceler; } }; doAnswer(runAndReturn).when(mockRunner).runWithCancel(ArgumentMatchers.<Function0<Unit>>any()); doAnswer(runAndReturn).when(mockRunner).run(ArgumentMatchers.<Function0<Unit>>any()); }
/** * retrieve keys from AWS * * @throws Exception * exception */ @Test public void getEC2Keys() throws Exception { final ProvAwsPluginResource resource = Mockito.spy(this.resource); final CurlRequest mockRequest = new CurlRequest("GET", MOCK_URL, null); mockRequest.setSaveResponse(true); Mockito.doReturn(mockRequest).when(resource).newRequest(ArgumentMatchers.any(AWS4SignatureQueryBuilder.class), ArgumentMatchers.eq(subscription)); httpServer.stubFor( get(urlEqualTo("/mock")).willReturn(aResponse().withStatus(HttpStatus.SC_OK).withBody("<keyName>my-key</keyName>"))); httpServer.start(); final List<NamedBean<String>> keys = resource.getEC2Keys(subscription); Assert.assertFalse(keys.isEmpty()); Assert.assertEquals(1, keys.size()); Assert.assertEquals("my-key", keys.get(0).getId()); }
@Test public void findAllNotSecureByManagedGroup() { final Map<String, UserOrg> users = new HashMap<>(); final UserOrg user1 = newUser(); users.put("wuser", user1); final UserOrg user2 = new UserOrg(); user2.setCompany("ing"); user2.setGroups(Collections.singletonList("any")); users.put("user2", user2); final GroupOrg groupOrg1 = new GroupOrg("cn=DIG,ou=fonction,ou=groups,dc=sample,dc=com", "DIG", Collections.singleton("wuser")); final Map<String, GroupOrg> groupsMap = new HashMap<>(); groupsMap.put("dig", groupOrg1); resource.groupResource = Mockito.mock(GroupResource.class); final CompanyOrg company = new CompanyOrg("ou=ing,ou=france,ou=people,dc=sample,dc=com", "ing"); Mockito.when(companyRepository.findByIdExpected(DEFAULT_USER, "ing")).thenReturn(company); groupFindById(DEFAULT_USER, "dig", groupOrg1); Mockito.when(userRepository.findAll(ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.any())) .thenReturn(new PageImpl<>(new ArrayList<>(users.values()))); Mockito.when(resource.groupResource.getContainers()).thenReturn(new HashSet<>(groupsMap.values())); Mockito.when(resource.groupResource.getContainersForWrite()).thenReturn(new HashSet<>(groupsMap.values())); final List<UserOrg> data = resource.findAllNotSecure(null, "dig"); // Check the users checkUser(data.get(0)); }
@Test public void handleOutboundMessageTerminatesClientIfErrorOccursDuringSend() { // given ClientConnectedState target = new ClientConnectedState(client); doThrow(IOException.class).when(mockSession).write(ArgumentMatchers.any(byte[].class)); // when target.handleOutboundMessage(new SerializableMessage()); // then assertThat(messageQueue.size(), is(1)); assertThat(messageQueue.get(0), is(instanceOf(ClientDisconnected.class))); assertThat(client.getCurrentState(), is(instanceOf(ClientDisconnectedState.class))); verify(mockSession, times(1)).write(ArgumentMatchers.any(byte[].class)); verify(mockSession, times(1)).terminate(); verifyNoMoreInteractions(mockSession); }
@Test public void testSynchronizeJira() throws Exception { final ImportContext context = new ImportContext(); final ImportStatus result = new ImportStatus(); result.setCanSynchronizeJira(true); final JiraImportPluginResource resource = Mockito.mock(JiraImportPluginResource.class); Mockito.doCallRealMethod().when(resource).synchronizeJira(ArgumentMatchers.same(context), ArgumentMatchers.same(result)); Mockito.when(resource.authenticateAdmin(ArgumentMatchers.same(context), ArgumentMatchers.any(CurlProcessor.class))) .thenReturn(true); Mockito.when(resource.clearJiraCache(ArgumentMatchers.same(context), ArgumentMatchers.same(result), ArgumentMatchers.any(CurlProcessor.class))).thenReturn(true); Mockito.when(resource.reIndexProject(ArgumentMatchers.same(context), ArgumentMatchers.same(result), ArgumentMatchers.any(CurlProcessor.class))).thenReturn(true); resource.synchronizeJira(context, result); Assert.assertTrue(result.getSynchronizedJira()); }
@Test public void whenSendingHandshakeMessageFailsClientIsTerminated() { // given doThrow(IOException.class).when(mockSession).write(ArgumentMatchers.any(byte[].class)); ClientHandshakeState target = new ClientHandshakeState(client); // when client.setState(target); // then assertThat(client.getCurrentState(), is(instanceOf(ClientDisconnectedState.class))); assertThat(messageQueue.size(), is(2)); assertThat(messageQueue.get(0), is(instanceOf(ClientConnectionRefused.class))); assertThat(((ClientConnectionRefused)messageQueue.get(0)).getReason(), Matchers.startsWith("Failed to send handshake: ")); verify(mockSession, times(1)).write(ArgumentMatchers.any(byte[].class)); verify(mockSession, times(1)).terminate(); verifyNoMoreInteractions(mockSession); }
@Test public void handleSessionClosedMakesStateTransition() { // given doThrow(IOException.class).when(mockSession).write(ArgumentMatchers.any(byte[].class)); ClientHandshakeState target = new ClientHandshakeState(client); // when target.handleSessionClosed(mockSession); // then assertThat(client.getCurrentState(), is(instanceOf(ClientDisconnectedState.class))); assertThat(messageQueue.size(), is(2)); assertThat(messageQueue.get(0), is(instanceOf(ClientConnectionRefused.class))); assertThat(((ClientConnectionRefused)messageQueue.get(0)).getReason(), is("connection closed by server")); verifyZeroInteractions(mockSession); }
@Test public void processDataReceivedTerminatesSendingMessageToClientFails() throws IOException, ProtocolException { // given doThrow(IOException.class).when(sessionMock).write(ArgumentMatchers.any(byte[].class)); Handshake handshake = new Handshake(HandshakeConstants.HANDSHAKE_MAGIC, HandshakeConstants.HANDSHAKE_PROTOCOL_VERSION); byte[] handshakeData = new MessageSerializer(handshake).serialize(); client.processDataReceived(handshakeData); ClientConnectedState target = new ClientConnectedState(client); // when target.processDataReceived(); // then assertThat(client.getCurrentState(), is(instanceOf(ClientClosedState.class))); verify(sessionMock, times(1)).terminate(); verify(sessionMock, times(1)).write(ArgumentMatchers.any(byte[].class)); verifyNoMoreInteractions(sessionMock); verifyNoMoreInteractions(messageBusMock); }
@Test public void connectWhenRegisteringClientSocketThrowsException() throws IOException { // given when(socketFactoryMock.openSocketSelector()).thenReturn(selectorMock); when(socketFactoryMock.openClientSocket(anyString(), anyInt())).thenReturn(socketMock); doThrow(IOException.class).when(selectorMock).register(ArgumentMatchers.any(TCPClientSocket.class), anyBoolean()); // when boolean obtained = client.connect(HOST, PORT); // then assertThat(obtained, is(false)); assertThat(client.isRunning(), is(false)); // verify method calls verify(socketFactoryMock, times(1)).openSocketSelector(); verify(socketFactoryMock, times(1)).openClientSocket(anyString(), anyInt()); verify(selectorMock, times(1)).register(any(TCPClientSocket.class), anyBoolean()); verify(selectorMock, times(1)).close(); verify(socketMock, times(1)).close(); }
@Test public void closingSocketAndSelectorWhenExceptionIsThrownInClose() throws IOException { // given when(socketFactoryMock.openSocketSelector()).thenReturn(selectorMock); when(socketFactoryMock.openClientSocket(anyString(), anyInt())).thenReturn(socketMock); doThrow(IOException.class).when(selectorMock).register(ArgumentMatchers.any(TCPClientSocket.class), anyBoolean()); doThrow(IOException.class).when(selectorMock).close(); doThrow(IOException.class).when(socketMock).close(); // when boolean obtained = client.connect(HOST, PORT); // then assertThat(obtained, is(false)); assertThat(client.isRunning(), is(false)); // verify method calls verify(socketFactoryMock, times(1)).openSocketSelector(); verify(socketFactoryMock, times(1)).openClientSocket(anyString(), anyInt()); verify(selectorMock, times(1)).register(any(TCPClientSocket.class), anyBoolean()); verify(selectorMock, times(1)).close(); verify(socketMock, times(1)).close(); }
@SuppressWarnings("unchecked") @Before public void mockApplicationContext() { final ApplicationContext applicationContext = Mockito.mock(ApplicationContext.class); SpringUtils.setSharedApplicationContext(applicationContext); mockLdapResource = Mockito.mock(UserOrgResource.class); final UserFullLdapTask mockTask = new UserFullLdapTask(); mockTask.resource = mockLdapResource; mockTask.securityHelper = securityHelper; final UserAtomicLdapTask mockTaskUpdate = new UserAtomicLdapTask(); mockTaskUpdate.resource = mockLdapResource; mockTaskUpdate.securityHelper = securityHelper; Mockito.when(applicationContext.getBean(SessionSettings.class)).thenReturn(new SessionSettings()); Mockito.when(applicationContext.getBean((Class<?>) ArgumentMatchers.any(Class.class))).thenAnswer((Answer<Object>) invocation -> { final Class<?> requiredType = (Class<Object>) invocation.getArguments()[0]; if (requiredType == UserFullLdapTask.class) { return mockTask; } if (requiredType == UserAtomicLdapTask.class) { return mockTaskUpdate; } return UserBatchLdapResourceTest.super.applicationContext.getBean(requiredType); }); mockTaskUpdate.jaxrsFactory = ServerProviderFactory.createInstance(null); }
@Test public void aClosedSessionDoesNotStoreReadDataFromSocket() throws IOException { // given final String message = "Hello World!"; when(socketMock.read(ArgumentMatchers.any(ByteBuffer.class))).then(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) throws Throwable { ByteBuffer data = invocation.getArgument(0); data.put(message.getBytes()); return message.getBytes().length; } }); SessionImpl target = new SessionImpl(selectorMock); target.close(); // when int obtained = target.doReadFromSocket(socketMock); // then assertThat(obtained, is(0)); assertThat(target.read(), is(nullValue())); }
@SuppressWarnings("unchecked") @Override protected void prepareDriver() throws Exception { System.clearProperty("test.selenium.remote"); localDriverClass = WebDriverMock.class.getName(); remoteDriverClass = WebDriverMock.class.getName(); scenario = "sc"; super.prepareDriver(); mockDriver = Mockito.mock(WebDriverMock.class); Mockito.when(mockDriver.getScreenshotAs(ArgumentMatchers.any(OutputType.class))).thenReturn( new File(Thread.currentThread().getContextClassLoader().getResource("log4j2.json").toURI())); final Options options = Mockito.mock(Options.class); Mockito.when(options.window()).thenReturn(Mockito.mock(Window.class)); Mockito.when(mockDriver.manage()).thenReturn(options); final WebElement webElement = Mockito.mock(WebElement.class); Mockito.when(mockDriver.findElement(ArgumentMatchers.any(By.class))).thenReturn(webElement); Mockito.when(webElement.isDisplayed()).thenReturn(true); this.driver = mockDriver; }
@Test(expected = IllegalStateException.class) public void testDownloadDataBlobError() throws Exception { final URL jarLocation = getBlobFile(); InputStream openStream = null; try { // Get the JAR input openStream = jarLocation.openStream(); // Proceed to the test resource.prepareData(openStream, 1); final StreamingOutput downloadLobFile = resource.downloadLobFile(); final OutputStream output = Mockito.mock(OutputStream.class); Mockito.doThrow(new IOException()).when(output).write(ArgumentMatchers.any(byte[].class)); downloadLobFile.write(output); } finally { IOUtils.closeQuietly(openStream); } }
@Before public void setUp() { endPointService = new EndPointServiceImpl(endPointDao, endPointCheckSchedulerService, lockService); Mockito.doAnswer(invocation -> { ((Runnable) invocation.getArguments()[1]).run(); return null; }).when(lockService).doInLock(ArgumentMatchers.any(), ArgumentMatchers.any()); Mockito.when(endPointDao.find(EXISTING_ID)).thenReturn(Optional.of(existingEndPoint)); Mockito.when(endPointDao.findByName(EXISTING_NAME)).thenReturn(Optional.of(existingEndPoint)); endPoints = Arrays.asList(existingEndPoint, otherExistingEndPoint); Mockito.when(endPointDao.findAll()).thenReturn(endPoints); }
@Before public void setUp() throws ParseException { existingEndPoint = new EndPoint(); endPointCheckService = new EndPointCheckServiceImpl(endPointCheckDao, endPointCheckerFactory, endPointService); Mockito.when(endPointService.findEndPoint(EXISTING_END_POINT_ID)).thenReturn(existingEndPoint); Mockito.when(endPointCheckerFactory.createEndPointChecker(ArgumentMatchers.any())) .thenReturn(endPointChecker); startDate = new SimpleDateFormat(EndPointCheckResourceImpl.DATE_FORMAT).parse("2017-01-01"); endDate = new SimpleDateFormat(EndPointCheckResourceImpl.DATE_FORMAT).parse("2017-01-02"); Mockito.when(endPointCheckDao .findByDateRange(ArgumentMatchers.eq(existingEndPoint), ArgumentMatchers.eq(Utils.toStartOfDay(startDate)), ArgumentMatchers.eq(Utils.toEndOfDay(endDate)))) .thenReturn(endPointChecks); }
@Test public void testSynchronizeJiraNoScriptRunner() throws Exception { final ImportContext context = new ImportContext(); final ImportStatus result = new ImportStatus(); result.setCanSynchronizeJira(true); final JiraImportPluginResource resource = Mockito.mock(JiraImportPluginResource.class); Mockito.doCallRealMethod().when(resource).synchronizeJira(ArgumentMatchers.same(context), ArgumentMatchers.same(result)); Mockito.when(resource.authenticateAdmin(ArgumentMatchers.same(context), ArgumentMatchers.any(CurlProcessor.class))) .thenReturn(true); resource.synchronizeJira(context, result); Mockito.verify(resource, Mockito.times(1)).authenticateAdmin(ArgumentMatchers.same(context), ArgumentMatchers.any(CurlProcessor.class)); Mockito.verify(resource, Mockito.times(1)).clearJiraCache(ArgumentMatchers.same(context), ArgumentMatchers.same(result), ArgumentMatchers.any(CurlProcessor.class)); Mockito.verify(resource, Mockito.never()).reIndexProject(ArgumentMatchers.same(context), ArgumentMatchers.same(result), ArgumentMatchers.any(CurlProcessor.class)); Assert.assertFalse(result.getSynchronizedJira()); }
@SuppressWarnings("unchecked") @Before public void mockApplicationContext() { final ApplicationContext applicationContext = Mockito.mock(ApplicationContext.class); SpringUtils.setSharedApplicationContext(applicationContext); mockLdapResource = Mockito.mock(GroupResource.class); final GroupFullLdapTask mockTask = new GroupFullLdapTask(); mockTask.resource = mockLdapResource; mockTask.securityHelper = securityHelper; mockTask.containerScopeResource = Mockito.mock(ContainerScopeResource.class); Mockito.when(applicationContext.getBean(SessionSettings.class)).thenReturn(new SessionSettings()); Mockito.when(applicationContext.getBean((Class<?>) ArgumentMatchers.any(Class.class))).thenAnswer((Answer<Object>) invocation -> { final Class<?> requiredType = (Class<Object>) invocation.getArguments()[0]; if (requiredType == GroupFullLdapTask.class) { return mockTask; } return GroupBatchLdapResourceTest.super.applicationContext.getBean(requiredType); }); final ContainerScope container = new ContainerScope(); container.setId(1); container.setName("Fonction"); container.setType(ContainerType.GROUP); Mockito.when(mockTask.containerScopeResource.findByName("Fonction")).thenReturn(container); }
@Test public void findAllNotSecureByManagedCompany() { final Map<String, UserOrg> users = new HashMap<>(); final UserOrg user1 = newUser(); users.put("wuser", user1); final UserOrg user2 = new UserOrg(); user2.setCompany("ing"); user2.setGroups(Collections.singletonList("any")); users.put("user2", user2); final GroupOrg groupOrg1 = new GroupOrg("cn=DIG,ou=fonction,ou=groups,dc=sample,dc=com", "DIG", Collections.singleton("wuser")); final Map<String, GroupOrg> groupsMap = new HashMap<>(); groupsMap.put("dig", groupOrg1); resource.companyResource = Mockito.mock(CompanyResource.class); final CompanyOrg company = new CompanyOrg("ou=ing,ou=france,ou=people,dc=sample,dc=com", "ing"); Mockito.when(companyRepository.findByIdExpected(DEFAULT_USER, "ing")).thenReturn(company); groupFindById(DEFAULT_USER, "dig", groupOrg1); Mockito.when(userRepository.findAll(ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.any())) .thenReturn(new PageImpl<>(new ArrayList<>(users.values()))); Mockito.when(resource.companyResource.getContainers()).thenReturn(Collections.singleton(company)); Mockito.when(resource.companyResource.getContainersForWrite()).thenReturn(Collections.singleton(company)); final List<UserOrg> data = resource.findAllNotSecure("ing", null); // Check the users checkUser(data.get(0)); }
@Test public void step_2_two_block() throws Exception { Block lastBlock = ctx1.context.getInstance().getBlockchainService().getLastBlock(); Mockito.when(mockTimeProvider.get()).thenReturn(lastBlock.getTimestamp() + 180 * 2 + 1); ctx1.generateBlockForNow(); ctx2.fullBlockSync(); Mockito.verify(ctx1.syncBlockPeerService, Mockito.times(1)).getLastBlock(); Mockito.verify(ctx1.syncBlockPeerService, Mockito.times(1)).getBlockHistory(ArgumentMatchers.any()); Assert.assertEquals("Blockchain synchronized", ctx1.context.getInstance().getBlockchainService().getLastBlock().getID(), ctx2.context.getInstance().getBlockchainService().getLastBlock().getID()); }
@Test public void step_5_too_many_blocks() throws Exception { Block lastBlock = ctx1.context.getInstance().getBlockchainService().getLastBlock(); int time = lastBlock.getTimestamp() + Constant.BLOCK_PERIOD * Constant.BLOCK_IN_DAY * 2 + 1; Mockito.when(mockTimeProvider.get()).thenReturn(time); ctx1.generateBlockForNow(); ctx2.syncBlockListTask.run(); Mockito.verify(ctx1.syncBlockPeerService, Mockito.times(1)).getLastBlock(); Mockito.verify(ctx1.syncBlockPeerService, Mockito.atLeast(2)).getBlockHistory(ArgumentMatchers.any()); Mockito.verify(ctx1.syncBlockPeerService, Mockito.atLeast(2)).getDifficulty(); Assert.assertEquals("Blockchain synchronized", ctx1.context.getInstance().getBlockchainService().getLastBlock().getID(), ctx2.context.getInstance().getBlockchainService().getLastBlock().getID()); }
@Test public void testUserSubscriptions() throws MalformedURLException { ArticleDao articleDao = Mockito.mock(ArticleDao.class); Mockito.when(articleDao.hasSubscriptions(ArgumentMatchers.anyLong())).thenReturn(true); Mockito.when(articleDao.getSources(ArgumentMatchers.anyLong())).thenReturn(Collections.singletonList(new Source(new URL(NYTIMES)))); FeedProcessor processor = FeedProcessorImpl.newInstance(articleDao); List<Article> articles = processor.buildArticleCollection(Mockito.mock(User.class)); assertTrue(!articles.isEmpty()); assertThat( "Every articles has a description", articles, everyItem( hasProperty("description", not(blankOrNullString())) ) ); }
@SuppressWarnings("unchecked") @Override protected void prepareDriver() throws Exception { testName = Mockito.mock(TestName.class); Mockito.when(testName.getMethodName()).thenReturn("mockTest"); System.clearProperty("test.selenium.remote"); localDriverClass = WebDriverMock.class.getName(); remoteDriverClass = WebDriverMock.class.getName(); scenario = "sc"; super.prepareDriver(); mockDriver = Mockito.mock(WebDriverMock.class); Mockito.when(((WebDriverMock) mockDriver).getScreenshotAs(ArgumentMatchers.any(OutputType.class))).thenReturn( new File(Thread.currentThread().getContextClassLoader().getResource("log4j2.json").toURI())); final Options options = Mockito.mock(Options.class); Mockito.when(options.window()).thenReturn(Mockito.mock(Window.class)); Mockito.when(mockDriver.manage()).thenReturn(options); final WebElement webElement = Mockito.mock(WebElement.class); Mockito.when(mockDriver.findElement(ArgumentMatchers.any(By.class))).thenReturn(webElement); Mockito.when(webElement.isDisplayed()).thenReturn(true); this.driver = mockDriver; }
@Test public void findAllNotSecureByGroup() { final Map<String, UserOrg> users = new HashMap<>(); final UserOrg user1 = newUser(); users.put("wuser", user1); final UserOrg user2 = new UserOrg(); user2.setCompany("ing"); user2.setGroups(Collections.singletonList("any")); users.put("user2", user2); final GroupOrg groupOrg1 = new GroupOrg("cn=DIG,ou=fonction,ou=groups,dc=sample,dc=com", "DIG", Collections.singleton("wuser")); final Map<String, GroupOrg> groupsMap = new HashMap<>(); groupsMap.put("dig", groupOrg1); resource.groupResource = Mockito.mock(GroupResource.class); final CompanyOrg company = new CompanyOrg("ou=ing,ou=france,ou=people,dc=sample,dc=com", "ing"); Mockito.when(companyRepository.findByIdExpected(DEFAULT_USER, "ing")).thenReturn(company); groupFindById(DEFAULT_USER, "dig", groupOrg1); Mockito.when(userRepository.findAll(ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.any())) .thenReturn(new PageImpl<>(new ArrayList<>(users.values()))); Mockito.when(resource.groupResource.getContainers()).thenReturn(new HashSet<>(groupsMap.values())); Mockito.when(resource.groupResource.getContainersForWrite()).thenReturn(new HashSet<>(groupsMap.values())); final List<UserOrg> data = resource.findAllNotSecure(null, "dig"); // Check the users checkUser(data.get(0)); }
@Test public void testSynchronizeJiraReindexFailed() throws Exception { final ImportContext context = new ImportContext(); final ImportStatus result = new ImportStatus(); result.setCanSynchronizeJira(true); final JiraImportPluginResource resource = Mockito.mock(JiraImportPluginResource.class); Mockito.doCallRealMethod().when(resource).synchronizeJira(ArgumentMatchers.same(context), ArgumentMatchers.same(result)); Mockito.when(resource.authenticateAdmin(ArgumentMatchers.same(context), ArgumentMatchers.any(CurlProcessor.class))) .thenReturn(true); Mockito.when(resource.clearJiraCache(ArgumentMatchers.same(context), ArgumentMatchers.same(result), ArgumentMatchers.any(CurlProcessor.class))).thenReturn(true); resource.synchronizeJira(context, result); Mockito.verify(resource, Mockito.times(1)).authenticateAdmin(ArgumentMatchers.same(context), ArgumentMatchers.any(CurlProcessor.class)); Mockito.verify(resource, Mockito.times(1)).clearJiraCache(ArgumentMatchers.same(context), ArgumentMatchers.same(result), ArgumentMatchers.any(CurlProcessor.class)); Mockito.verify(resource, Mockito.times(1)).reIndexProject(ArgumentMatchers.same(context), ArgumentMatchers.same(result), ArgumentMatchers.any(CurlProcessor.class)); Assert.assertFalse(result.getSynchronizedJira()); }
@Test public void testSynchronizeJiraCantSynchronize() throws Exception { final ImportContext context = new ImportContext(); final ImportStatus result = new ImportStatus(); result.setCanSynchronizeJira(false); final JiraImportPluginResource resource = Mockito.mock(JiraImportPluginResource.class); Mockito.doCallRealMethod().when(resource).synchronizeJira(ArgumentMatchers.same(context), ArgumentMatchers.same(result)); resource.synchronizeJira(context, result); Mockito.verify(resource, Mockito.never()).authenticateAdmin(ArgumentMatchers.same(context), ArgumentMatchers.any(CurlProcessor.class)); Assert.assertNull(result.getSynchronizedJira()); }
/** * Mock a not managed LDAP desynchronization */ @Test(expected = org.springframework.ldap.AttributeInUseException.class) public void addUserSyncError() { final GroupLdapRepository groupRepository = newGroupLdapRepository(); final LdapTemplate ldapTemplate = Mockito.mock(LdapTemplate.class); groupRepository.setTemplate(ldapTemplate); Mockito.doThrow(new org.springframework.ldap.AttributeInUseException(new AttributeInUseException("any"))).when(ldapTemplate) .modifyAttributes(ArgumentMatchers.any(LdapName.class), ArgumentMatchers.any()); addUser(groupRepository); }
/** * Mock a managed LDAP desynchronization */ @Test public void addUserSync1() { final GroupLdapRepository groupRepository = newGroupLdapRepository(); final LdapTemplate ldapTemplate = Mockito.mock(LdapTemplate.class); groupRepository.setTemplate(ldapTemplate); Mockito.doThrow(new org.springframework.ldap.AttributeInUseException(new AttributeInUseException("value #0 already exists"))) .when(ldapTemplate).modifyAttributes(ArgumentMatchers.any(LdapName.class), ArgumentMatchers.any()); addUser(groupRepository); }
/** * Mock a managed LDAP desynchronization */ @Test public void addUserSync2() { final GroupLdapRepository groupRepository = newGroupLdapRepository(); final LdapTemplate ldapTemplate = Mockito.mock(LdapTemplate.class); groupRepository.setTemplate(ldapTemplate); Mockito.doThrow(new org.springframework.ldap.AttributeInUseException(new AttributeInUseException("ATTRIBUTE_OR_VALUE_EXISTS"))) .when(ldapTemplate).modifyAttributes(ArgumentMatchers.any(LdapName.class), ArgumentMatchers.any()); addUser(groupRepository); }
/** * Mock a managed LDAP schema violation */ @Test public void removeUserNotMember() { final GroupLdapRepository groupRepository = newGroupLdapRepository(); final LdapTemplate ldapTemplate = Mockito.mock(LdapTemplate.class); groupRepository.setTemplate(ldapTemplate); Mockito.doThrow(new org.springframework.ldap.SchemaViolationException(new SchemaViolationException("any"))).when(ldapTemplate) .modifyAttributes(ArgumentMatchers.any(LdapName.class), ArgumentMatchers.any()); removeUser(groupRepository); }
@Test public void checkSubscriptionStatusDown() throws Exception { final ProvAwsPluginResource resource = Mockito.spy(ProvAwsPluginResource.class); Mockito.doReturn(false).when(resource).validateAccess(ArgumentMatchers.anyInt()); final SubscriptionStatusWithData status = resource.checkSubscriptionStatus(subscription, null, new HashMap<String, String>()); Assert.assertFalse(status.getStatus().isUp()); }
@SuppressWarnings("unchecked") @Test public void getTokenNotExists() { final LdapTemplate mock = Mockito.mock(LdapTemplate.class); Mockito.when(mock.search((String) ArgumentMatchers.any(), ArgumentMatchers.any(), ArgumentMatchers.any(ContextMapper.class))) .thenReturn(Collections.emptyList()); repository.setTemplate(mock); Assert.assertNull(repository.getToken("any")); }
@Test @PrepareForTest({Files.class, ConversionFileWriterWrapper.class}) public void testFailureToWriteQpp() throws IOException { PowerMockito.mockStatic(Files.class); PowerMockito.when(Files.newBufferedWriter(ArgumentMatchers.any(Path.class))).thenThrow(new IOException()); Path path = Paths.get("../qrda-files/valid-QRDA-III-latest.xml"); ConversionFileWriterWrapper converterWrapper = new ConversionFileWriterWrapper(path); converterWrapper.transform(); assertFileDoesNotExists("valid-QRDA-III-latest.qpp.json"); }
@Test @PrepareForTest({Files.class, ConversionFileWriterWrapper.class}) public void testFailureToWriteErrors() throws IOException { PowerMockito.mockStatic(Files.class); PowerMockito.when(Files.newBufferedWriter(ArgumentMatchers.any(Path.class))).thenThrow(new IOException()); Path path = Paths.get("src/test/resources/not-a-QRDA-III-file.xml"); ConversionFileWriterWrapper converterWrapper = new ConversionFileWriterWrapper(path); converterWrapper.transform(); assertFileDoesNotExists("not-a-QRDA-III-file.err.json"); }
/** * Test method for * {@link org.ligoj.app.plugin.prov.aws.auth.AWS4SignerBase#getCanonicalizedQueryString(java.util.Map)}. */ @Test(expected = TechnicalException.class) public void testGetCanonicalizedQueryStringException() throws Exception { final AWS4SignerBase signer = new AWS4SignerForAuthorizationHeader(); final URLCodec urlCodec = Mockito.mock(URLCodec.class); ReflectionTestUtils.setField(signer, "urlCodec", urlCodec); Mockito.when(urlCodec.encode(ArgumentMatchers.anyString())).thenThrow(new EncoderException()); signer.getCanonicalizedQueryString(ImmutableMap.of("q2", "v2", "q1", "v1")); }