<groupId>com.carrotsearch.randomizedtesting</groupId>
<artifactId>randomizedtesting-runner</artifactId>
</exclusion>
+ <exclusion>
+ <groupId>org.elasticsearch</groupId>
+ <artifactId>securemock</artifactId>
+ </exclusion>
</exclusions>
</dependency>
<dependency>
import java.net.InetAddress;
import java.util.Map;
import java.util.Properties;
-import org.apache.catalina.connector.Connector;
import org.apache.catalina.startup.Tomcat;
import org.junit.Test;
-import org.mockito.ArgumentMatcher;
import org.mockito.Mockito;
import org.sonar.process.Props;
TomcatConnectors.configure(tomcat, new Props(p));
- verify(tomcat.getService()).addConnector(argThat(new ArgumentMatcher<Connector>() {
- @Override
- public boolean matches(Object o) {
- Connector c = (Connector) o;
- return c.getScheme().equals("http") && c.getPort() == 9000 && ((InetAddress) c.getProperty("address")).getHostAddress().equals("0.0.0.0");
- }
- }));
+ verify(tomcat.getService()).addConnector(argThat(c -> c.getScheme().equals("http") && c.getPort() == 9000 && ((InetAddress) c.getProperty("address")).getHostAddress().equals("0.0.0.0")));
}
@Test
TomcatConnectors.configure(tomcat, new Props(p));
- verify(tomcat.getService()).addConnector(argThat(new ArgumentMatcher<Connector>() {
- @Override
- public boolean matches(Object o) {
- Connector c = (Connector) o;
- return c.getScheme().equals("http") && c.getPort() == 9000 && ((InetAddress) c.getProperty("address")).getHostAddress().equals("1.2.3.4");
- }
- }));
+ verify(tomcat.getService())
+ .addConnector(argThat(c -> c.getScheme().equals("http") && c.getPort() == 9000 && ((InetAddress) c.getProperty("address")).getHostAddress().equals("1.2.3.4")));
}
@Test
Props props = new Props(properties);
TomcatConnectors.configure(tomcat, props);
- verify(tomcat.getService()).addConnector(argThat(new ArgumentMatcher<Connector>() {
- @Override
- public boolean matches(Object o) {
- Connector c = (Connector) o;
- return c.getMaxPostSize() == -1;
- }
- }));
+ verify(tomcat.getService()).addConnector(argThat(c -> c.getMaxPostSize() == -1));
}
- private void verifyHttpConnector(int expectedPort, Map<String,Object> expectedProps) {
- verify(tomcat.getService()).addConnector(argThat(new ArgumentMatcher<Connector>() {
- @Override
- public boolean matches(Object o) {
- Connector c = (Connector) o;
- if (!c.getScheme().equals("http")) {
- return false;
- }
- if (!c.getProtocol().equals(TomcatConnectors.HTTP_PROTOCOL)) {
- return false;
- }
- if (c.getPort() != expectedPort) {
+ private void verifyHttpConnector(int expectedPort, Map<String, Object> expectedProps) {
+ verify(tomcat.getService()).addConnector(argThat(c -> {
+ if (!c.getScheme().equals("http")) {
+ return false;
+ }
+ if (!c.getProtocol().equals(TomcatConnectors.HTTP_PROTOCOL)) {
+ return false;
+ }
+ if (c.getPort() != expectedPort) {
+ return false;
+ }
+ for (Map.Entry<String, Object> expectedProp : expectedProps.entrySet()) {
+ if (!expectedProp.getValue().equals(c.getProperty(expectedProp.getKey()))) {
return false;
}
- for (Map.Entry<String, Object> expectedProp : expectedProps.entrySet()) {
- if (!expectedProp.getValue().equals(c.getProperty(expectedProp.getKey()))) {
- return false;
- }
- }
- return true;
}
+ return true;
}));
}
}
import org.junit.Before;
import org.junit.Test;
import org.sonar.api.CoreProperties;
-import org.sonar.api.config.Configuration;
import org.sonar.api.config.PropertyDefinitions;
import org.sonar.api.config.internal.MapSettings;
-import org.sonar.api.utils.log.Logger;
import org.sonar.core.config.PurgeConstants;
import org.sonar.core.config.PurgeProperties;
import org.sonar.db.DbSession;
import org.sonar.db.purge.IdUuidPair;
-import org.sonar.db.purge.PurgeConfiguration;
import org.sonar.db.purge.PurgeDao;
import org.sonar.db.purge.PurgeListener;
import org.sonar.db.purge.PurgeProfiler;
import org.sonar.db.purge.period.DefaultPeriodCleaner;
import static java.util.Collections.emptyList;
+import static org.mockito.ArgumentMatchers.anyLong;
import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyLong;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.doThrow;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
underTest.purge(mock(DbSession.class), mock(IdUuidPair.class), settings.asConfig(), emptyList());
- verify(profiler, never()).dump(anyLong(), any(Logger.class));
+ verify(profiler, never()).dump(anyLong(), any());
}
@Test
underTest.purge(mock(DbSession.class), mock(IdUuidPair.class), settings.asConfig(), emptyList());
- verify(profiler).dump(anyLong(), any(Logger.class));
+ verify(profiler).dump(anyLong(), any());
}
@Test
underTest.purge(mock(DbSession.class), mock(IdUuidPair.class), settings.asConfig(), emptyList());
- verify(periodCleaner).clean(any(DbSession.class), anyString(), any(Configuration.class));
- verify(dao).purge(any(DbSession.class), any(PurgeConfiguration.class), any(PurgeListener.class), any(PurgeProfiler.class));
+ verify(periodCleaner).clean(any(), any(), any());
+ verify(dao).purge(any(), any(), any(), any());
}
}
import java.util.List;
import java.util.Map;
import org.apache.commons.io.IOUtils;
-import org.hamcrest.Description;
-import org.hamcrest.TypeSafeMatcher;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.tuple;
import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
import static org.mockito.Matchers.argThat;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
mockSuccessfulPrepareSubmitCall();
ComponentDto project = newPrivateProjectDto(db.getDefaultOrganization(), PROJECT_UUID).setDbKey(PROJECT_KEY);
- when(componentUpdater.create(any(DbSession.class), any(NewComponent.class), eq(null))).thenReturn(project);
- when(permissionTemplateService.wouldUserHaveScanPermissionWithDefaultTemplate(any(DbSession.class), eq(defaultOrganizationUuid), anyInt(), eq(PROJECT_KEY),
+ when(componentUpdater.create(any(), any(), any())).thenReturn(project);
+ when(permissionTemplateService.wouldUserHaveScanPermissionWithDefaultTemplate(any(), eq(defaultOrganizationUuid), any(), eq(PROJECT_KEY),
eq(Qualifiers.PROJECT)))
.thenReturn(true);
verifyReportIsPersisted(TASK_UUID);
verifyZeroInteractions(permissionTemplateService);
verifyZeroInteractions(favoriteUpdater);
- verify(queue).submit(argThat(new TypeSafeMatcher<CeTaskSubmit>() {
- @Override
- protected boolean matchesSafely(CeTaskSubmit submit) {
- return submit.getType().equals(CeTaskTypes.REPORT) && submit.getComponentUuid().equals(project.uuid()) &&
- submit.getUuid().equals(TASK_UUID);
- }
-
- @Override
- public void describeTo(Description description) {
-
- }
- }));
+ verify(queue).submit(argThat(submit ->
+ submit.getType().equals(CeTaskTypes.REPORT) && submit.getComponentUuid().equals(project.uuid()) && submit.getUuid().equals(TASK_UUID)));
}
@Test
mockSuccessfulPrepareSubmitCall();
ComponentDto createdProject = newPrivateProjectDto(organization, PROJECT_UUID).setDbKey(PROJECT_KEY);
- when(componentUpdater.create(any(DbSession.class), any(NewComponent.class), eq(null))).thenReturn(createdProject);
+ when(componentUpdater.create(any(), any(), isNull())).thenReturn(createdProject);
when(
- permissionTemplateService.wouldUserHaveScanPermissionWithDefaultTemplate(any(DbSession.class), eq(organization.getUuid()), anyInt(), eq(PROJECT_KEY), eq(Qualifiers.PROJECT)))
+ permissionTemplateService.wouldUserHaveScanPermissionWithDefaultTemplate(any(), eq(organization.getUuid()), any(), eq(PROJECT_KEY), eq(Qualifiers.PROJECT)))
.thenReturn(true);
- when(permissionTemplateService.hasDefaultTemplateWithPermissionOnProjectCreator(any(DbSession.class), eq(organization.getUuid()), any(ComponentDto.class))).thenReturn(true);
+ when(permissionTemplateService.hasDefaultTemplateWithPermissionOnProjectCreator(any(), eq(organization.getUuid()), any())).thenReturn(true);
underTest.submit(organization.getKey(), PROJECT_KEY, null, PROJECT_NAME, IOUtils.toInputStream("{binary}"));
verifyReportIsPersisted(TASK_UUID);
- verify(queue).submit(argThat(new TypeSafeMatcher<CeTaskSubmit>() {
- @Override
- protected boolean matchesSafely(CeTaskSubmit submit) {
- return submit.getType().equals(CeTaskTypes.REPORT) && submit.getComponentUuid().equals(PROJECT_UUID) &&
- submit.getUuid().equals(TASK_UUID);
- }
-
- @Override
- public void describeTo(Description description) {
-
- }
- }));
+ verify(queue).submit(argThat(submit ->
+ submit.getType().equals(CeTaskTypes.REPORT) && submit.getComponentUuid().equals(PROJECT_UUID) && submit.getUuid().equals(TASK_UUID)));
}
@Test
mockSuccessfulPrepareSubmitCall();
ComponentDto createdProject = newPrivateProjectDto(db.getDefaultOrganization(), PROJECT_UUID).setDbKey(PROJECT_KEY);
- when(componentUpdater.create(any(DbSession.class), any(NewComponent.class), eq(null))).thenReturn(createdProject);
- when(permissionTemplateService.wouldUserHaveScanPermissionWithDefaultTemplate(any(DbSession.class), eq(defaultOrganizationUuid), anyInt(),
+ when(componentUpdater.create(any(), any(), isNull())).thenReturn(createdProject);
+ when(permissionTemplateService.wouldUserHaveScanPermissionWithDefaultTemplate(any(), eq(defaultOrganizationUuid), any(),
eq(PROJECT_KEY), eq(Qualifiers.PROJECT)))
.thenReturn(true);
- when(permissionTemplateService.hasDefaultTemplateWithPermissionOnProjectCreator(any(DbSession.class), eq(defaultOrganizationUuid), any(ComponentDto.class))).thenReturn(false);
+ when(permissionTemplateService.hasDefaultTemplateWithPermissionOnProjectCreator(any(), eq(defaultOrganizationUuid), any())).thenReturn(false);
underTest.submit(defaultOrganizationKey, PROJECT_KEY, null, PROJECT_NAME, IOUtils.toInputStream("{binary}"));
mockSuccessfulPrepareSubmitCall();
ComponentDto project = newPrivateProjectDto(db.getDefaultOrganization(), PROJECT_UUID).setDbKey(PROJECT_KEY);
- when(componentUpdater.create(any(DbSession.class), any(NewComponent.class), eq(null))).thenReturn(project);
- when(permissionTemplateService.wouldUserHaveScanPermissionWithDefaultTemplate(any(DbSession.class), eq(defaultOrganizationUuid), anyInt(),
+ when(componentUpdater.create(any(), any(), any())).thenReturn(project);
+ when(permissionTemplateService.wouldUserHaveScanPermissionWithDefaultTemplate(any(), eq(defaultOrganizationUuid), any(),
eq(PROJECT_KEY), eq(Qualifiers.PROJECT)))
.thenReturn(true);
import org.junit.Test;
import org.sonar.api.measures.CoreMetrics;
import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
import org.sonar.db.qualitygate.QualityGateConditionDao;
import org.sonar.db.qualitygate.QualityGateConditionDto;
import org.sonar.db.qualitygate.QualityGateDao;
@Test
public void findById_returns_QualityGate_with_empty_set_of_conditions_when_there_is_none_in_DB() {
- when(qualityGateDao.selectById(any(DbSession.class), eq(SOME_ID))).thenReturn(QUALITY_GATE_DTO);
- when(qualityGateConditionDao.selectForQualityGate(any(DbSession.class), eq(SOME_ID))).thenReturn(Collections.emptyList());
+ when(qualityGateDao.selectById(any(), eq(SOME_ID))).thenReturn(QUALITY_GATE_DTO);
+ when(qualityGateConditionDao.selectForQualityGate(any(), eq(SOME_ID))).thenReturn(Collections.emptyList());
Optional<QualityGate> res = underTest.findById(SOME_ID);
@Test
public void findById_returns_conditions_when_there_is_some_in_DB() {
- when(qualityGateDao.selectById(any(DbSession.class), eq(SOME_ID))).thenReturn(QUALITY_GATE_DTO);
- when(qualityGateConditionDao.selectForQualityGate(any(DbSession.class), eq(SOME_ID))).thenReturn(ImmutableList.of(CONDITION_1, CONDITION_2));
+ when(qualityGateDao.selectById(any(), eq(SOME_ID))).thenReturn(QUALITY_GATE_DTO);
+ when(qualityGateConditionDao.selectForQualityGate(any(), eq(SOME_ID))).thenReturn(ImmutableList.of(CONDITION_1, CONDITION_2));
// metrics are always supposed to be there
when(metricRepository.getOptionalById(METRIC_ID_1)).thenReturn(Optional.of(METRIC_1));
when(metricRepository.getOptionalById(METRIC_ID_2)).thenReturn(Optional.of(METRIC_2));
@Test
public void findById_ignores_conditions_on_missing_metrics() {
- when(qualityGateDao.selectById(any(DbSession.class), eq(SOME_ID))).thenReturn(QUALITY_GATE_DTO);
- when(qualityGateConditionDao.selectForQualityGate(any(DbSession.class), eq(SOME_ID))).thenReturn(ImmutableList.of(CONDITION_1, CONDITION_2));
+ when(qualityGateDao.selectById(any(), eq(SOME_ID))).thenReturn(QUALITY_GATE_DTO);
+ when(qualityGateConditionDao.selectForQualityGate(any(), eq(SOME_ID))).thenReturn(ImmutableList.of(CONDITION_1, CONDITION_2));
// metrics are always supposed to be there
when(metricRepository.getOptionalById(METRIC_ID_1)).thenReturn(Optional.empty());
when(metricRepository.getOptionalById(METRIC_ID_2)).thenReturn(Optional.of(METRIC_2));
when(branch.getName()).thenReturn("origin/feature");
when(branch.isMain()).thenReturn(false);
when(branch.isLegacyFeature()).thenReturn(false);
- when(branch.generateKey(any(ScannerReport.Component.class), any(ScannerReport.Component.class))).thenReturn("generated");
+ when(branch.generateKey(any(), any())).thenReturn("generated");
analysisMetadataHolder.setRootComponentRef(ROOT_REF)
.setAnalysisDate(ANALYSIS_DATE)
.setProject(new Project("U1", REPORT_PROJECT_KEY, REPORT_PROJECT_KEY))
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;
-import org.sonar.api.config.Configuration;
import org.sonar.api.config.internal.MapSettings;
import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
import org.sonar.db.purge.IdUuidPair;
import org.sonar.server.computation.dbcleaner.ProjectCleaner;
import org.sonar.server.computation.task.projectanalysis.component.Component;
import static java.util.Arrays.asList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyList;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
underTest.execute();
ArgumentCaptor<IdUuidPair> argumentCaptor = ArgumentCaptor.forClass(IdUuidPair.class);
- verify(projectCleaner).purge(any(DbSession.class), argumentCaptor.capture(), any(Configuration.class), anyList());
+ verify(projectCleaner).purge(any(), argumentCaptor.capture(), any(), any());
assertThat(argumentCaptor.getValue().getId()).isEqualTo(PROJECT_ID);
assertThat(argumentCaptor.getValue().getUuid()).isEqualTo(PROJECT_UUID);
}
import org.sonar.server.util.cache.DiskCache;
import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
-import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.mockito.Matchers.anyString;
+import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.mock;
new DefaultIssue().setType(randomRuleType).setEffort(ISSUE_DURATION)
.setCreationDate(new Date(ANALYSE_DATE)))
.close();
- when(notificationService.hasProjectSubscribersForTypes(PROJECT.getUuid(), SendIssueNotificationsStep.NOTIF_TYPES)).thenReturn(true);
+ when(notificationService.hasProjectSubscribersForTypes(eq(PROJECT.getUuid()), any())).thenReturn(true);
underTest.execute();
verify(notificationService).deliver(newIssuesNotificationMock);
verify(newIssuesNotificationMock).setProject(PROJECT.getPublicKey(), PROJECT.getName(), null);
verify(newIssuesNotificationMock).setAnalysisDate(new Date(ANALYSE_DATE));
- verify(newIssuesNotificationMock).setStatistics(eq(PROJECT.getName()), any(NewIssuesStatistics.Stats.class));
+ verify(newIssuesNotificationMock).setStatistics(eq(PROJECT.getName()), any());
verify(newIssuesNotificationMock).setDebt(ISSUE_DURATION);
}
new DefaultIssue().setType(randomRuleType).setEffort(ISSUE_DURATION).setAssignee(ISSUE_ASSIGNEE)
.setCreationDate(new Date(ANALYSE_DATE)))
.close();
- when(notificationService.hasProjectSubscribersForTypes(PROJECT.getUuid(), SendIssueNotificationsStep.NOTIF_TYPES)).thenReturn(true);
+ when(notificationService.hasProjectSubscribersForTypes(eq(PROJECT.getUuid()), any())).thenReturn(true);
underTest.execute();
private NewIssuesNotification createNewIssuesNotificationMock() {
NewIssuesNotification notification = mock(NewIssuesNotification.class);
- when(notification.setProject(anyString(), anyString(), anyString())).thenReturn(notification);
- when(notification.setProjectVersion(anyString())).thenReturn(notification);
- when(notification.setAnalysisDate(any(Date.class))).thenReturn(notification);
- when(notification.setStatistics(anyString(), any(NewIssuesStatistics.Stats.class))).thenReturn(notification);
- when(notification.setDebt(any(Duration.class))).thenReturn(notification);
+ when(notification.setProject(any(), any(), any())).thenReturn(notification);
+ when(notification.setProjectVersion(any())).thenReturn(notification);
+ when(notification.setAnalysisDate(any())).thenReturn(notification);
+ when(notification.setStatistics(any(), any())).thenReturn(notification);
+ when(notification.setDebt(any())).thenReturn(notification);
return notification;
}
private MyNewIssuesNotification createMyNewIssuesNotificationMock() {
MyNewIssuesNotification notification = mock(MyNewIssuesNotification.class);
- when(notification.setAssignee(anyString())).thenReturn(notification);
- when(notification.setProject(anyString(), anyString(), anyString())).thenReturn(notification);
- when(notification.setProjectVersion(anyString())).thenReturn(notification);
- when(notification.setAnalysisDate(any(Date.class))).thenReturn(notification);
- when(notification.setStatistics(anyString(), any(NewIssuesStatistics.Stats.class))).thenReturn(notification);
- when(notification.setDebt(any(Duration.class))).thenReturn(notification);
+ when(notification.setAssignee(any())).thenReturn(notification);
+ when(notification.setProject(any(), any(), any())).thenReturn(notification);
+ when(notification.setProjectVersion(any())).thenReturn(notification);
+ when(notification.setAnalysisDate(any())).thenReturn(notification);
+ when(notification.setStatistics(any(), any())).thenReturn(notification);
+ when(notification.setDebt(any())).thenReturn(notification);
return notification;
}
import org.junit.Test;
import org.sonar.api.issue.Issue;
import org.sonar.core.issue.DefaultIssue;
-import org.sonar.core.issue.IssueChangeContext;
import org.sonar.server.tester.AnonymousMockUserSession;
import static com.google.common.collect.Maps.newHashMap;
when(context.issue()).thenReturn(issue);
action.execute(properties, context);
- verify(issueUpdater).addComment(eq(issue), eq(comment), any(IssueChangeContext.class));
+ verify(issueUpdater).addComment(eq(issue), eq(comment), any());
}
@Test
import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;
-import org.junit.Before;
import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.runners.MockitoJUnitRunner;
import org.sonar.api.notifications.Notification;
import org.sonar.api.notifications.NotificationChannel;
import org.sonar.api.web.UserRole;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyNoMoreInteractions;
import static org.mockito.Mockito.when;
-@RunWith(MockitoJUnitRunner.class)
public class ChangesOnMyIssueNotificationDispatcherTest {
- @Mock
- NotificationManager notifications;
+ private NotificationManager notifications = mock(NotificationManager.class);
+ private NotificationDispatcher.Context context = mock(NotificationDispatcher.Context.class);
+ private NotificationChannel emailChannel = mock(NotificationChannel.class);
+ private NotificationChannel twitterChannel = mock(NotificationChannel.class);
- @Mock
- NotificationDispatcher.Context context;
-
- @Mock
- NotificationChannel emailChannel;
-
- @Mock
- NotificationChannel twitterChannel;
-
- ChangesOnMyIssueNotificationDispatcher dispatcher;
-
- @Before
- public void setUp() {
- dispatcher = new ChangesOnMyIssueNotificationDispatcher(notifications);
- }
+ private ChangesOnMyIssueNotificationDispatcher underTest = new ChangesOnMyIssueNotificationDispatcher(notifications);
@Test
public void test_metadata() {
NotificationDispatcherMetadata metadata = ChangesOnMyIssueNotificationDispatcher.newMetadata();
- assertThat(metadata.getDispatcherKey()).isEqualTo(dispatcher.getKey());
+ assertThat(metadata.getDispatcherKey()).isEqualTo(underTest.getKey());
assertThat(metadata.getProperty(NotificationDispatcherMetadata.GLOBAL_NOTIFICATION)).isEqualTo("true");
assertThat(metadata.getProperty(NotificationDispatcherMetadata.PER_PROJECT_NOTIFICATION)).isEqualTo("true");
}
@Test
public void should_not_dispatch_if_other_notification_type() {
Notification notification = new Notification("other-notif");
- dispatcher.performDispatch(notification, context);
+ underTest.performDispatch(notification, context);
verify(context, never()).addUser(any(String.class), any(NotificationChannel.class));
}
recipients.put("simon", emailChannel);
recipients.put("freddy", twitterChannel);
recipients.put("godin", twitterChannel);
- when(notifications.findSubscribedRecipientsForDispatcher(dispatcher, "struts",
+ when(notifications.findSubscribedRecipientsForDispatcher(underTest, "struts",
new NotificationManager.SubscriberPermissionsOnProject(UserRole.USER))).thenReturn(recipients);
Notification notification = new IssueChangeNotification()
.setFieldValue("projectKey", "struts")
.setFieldValue("changeAuthor", "olivier")
.setFieldValue("assignee", "freddy");
- dispatcher.performDispatch(notification, context);
+ underTest.performDispatch(notification, context);
verify(context).addUser("freddy", twitterChannel);
verify(context, never()).addUser("godin", twitterChannel);
recipients.put("simon", emailChannel);
recipients.put("freddy", twitterChannel);
recipients.put("godin", twitterChannel);
- when(notifications.findSubscribedRecipientsForDispatcher(dispatcher, "uuid1", new NotificationManager.SubscriberPermissionsOnProject(UserRole.USER))).thenReturn(recipients);
+ when(notifications.findSubscribedRecipientsForDispatcher(underTest, "uuid1", new NotificationManager.SubscriberPermissionsOnProject(UserRole.USER))).thenReturn(recipients);
// change author is the assignee
- dispatcher.performDispatch(
+ underTest.performDispatch(
new IssueChangeNotification()
.setFieldValue("projectKey", "struts")
.setFieldValue("projectUuid", "uuid1")
context);
// no change author
- dispatcher.performDispatch(new IssueChangeNotification().setFieldValue("projectKey", "struts")
+ underTest.performDispatch(new IssueChangeNotification().setFieldValue("projectKey", "struts")
.setFieldValue("new.resolution", "FIXED"), context);
verifyNoMoreInteractions(context);
package org.sonar.server.platform;
import org.junit.Test;
-import org.mockito.ArgumentMatcher;
import org.sonar.api.config.GlobalPropertyChangeHandler;
import static org.assertj.core.api.Assertions.assertThat;
notifier.onGlobalPropertyChange("foo", "bar");
- verify(handler).onChange(argThat(new ArgumentMatcher<GlobalPropertyChangeHandler.PropertyChange>() {
- @Override
- public boolean matches(Object o) {
- GlobalPropertyChangeHandler.PropertyChange change = (GlobalPropertyChangeHandler.PropertyChange) o;
- return change.getKey().equals("foo") && change.getNewValue().equals("bar");
- }
- }));
+ verify(handler).onChange(argThat(change -> change.getKey().equals("foo") && change.getNewValue().equals("bar")));
}
@Test
@Rule
public ExpectedException expectedException = ExpectedException.none();
- private RootFilter filter;
- private FilterChain chain;
+ private FilterChain chain = mock(FilterChain.class);
+ private RootFilter underTest;
@Before
- public void initialize() throws Exception {
+ public void initialize() {
FilterConfig filterConfig = mock(FilterConfig.class);
ServletContext context = mock(ServletContext.class);
when(context.getContextPath()).thenReturn("/context");
when(filterConfig.getServletContext()).thenReturn(context);
- chain = mock(FilterChain.class);
-
- filter = new RootFilter();
- filter.init(filterConfig);
+ underTest = new RootFilter();
+ underTest.init(filterConfig);
}
@Test
- public void throwable_in_dofilter_is_caught_and_500_error_returned_if_response_is_not_committed() throws Exception {
+ public void throwable_in_doFilter_is_caught_and_500_error_returned_if_response_is_not_committed() throws Exception {
doThrow(new RuntimeException()).when(chain).doFilter(any(ServletRequest.class), any(ServletResponse.class));
HttpServletResponse response = mockHttpResponse(false);
- filter.doFilter(request("POST", "/context/service/call", "param=value"), response, chain);
+ underTest.doFilter(request("POST", "/context/service/call", "param=value"), response, chain);
verify(response).sendError(500);
}
@Test
- public void throwable_in_dofilter_is_caught_but_no_500_response_is_sent_if_response_already_committed() throws Exception {
+ public void throwable_in_doFilter_is_caught_but_no_500_response_is_sent_if_response_already_committed() throws Exception {
doThrow(new RuntimeException()).when(chain).doFilter(any(ServletRequest.class), any(ServletResponse.class));
HttpServletResponse response = mockHttpResponse(true);
- filter.doFilter(request("POST", "/context/service/call", "param=value"), response, chain);
+ underTest.doFilter(request("POST", "/context/service/call", "param=value"), response, chain);
verify(response, never()).sendError(500);
}
@Test
public void request_used_in_chain_do_filter_is_a_servlet_wrapper_when_static_resource() throws Exception {
- filter.doFilter(request("GET", "/context/static/image.png", null), null, chain);
+ underTest.doFilter(request("GET", "/context/static/image.png", null), mock(HttpServletResponse.class), chain);
ArgumentCaptor<ServletRequest> requestArgumentCaptor = ArgumentCaptor.forClass(ServletRequest.class);
- verify(chain).doFilter(requestArgumentCaptor.capture(), any(ServletResponse.class));
+ verify(chain).doFilter(requestArgumentCaptor.capture(), any(HttpServletResponse.class));
assertThat(requestArgumentCaptor.getValue()).isInstanceOf(RootFilter.ServletRequestWrapper.class);
}
@Test
public void request_used_in_chain_do_filter_is_a_servlet_wrapper_when_service_call() throws Exception {
- filter.doFilter(request("POST", "/context/service/call", "param=value"), null, chain);
+ underTest.doFilter(request("POST", "/context/service/call", "param=value"), mock(HttpServletResponse.class), chain);
ArgumentCaptor<ServletRequest> requestArgumentCaptor = ArgumentCaptor.forClass(ServletRequest.class);
- verify(chain).doFilter(requestArgumentCaptor.capture(), any(ServletResponse.class));
+ verify(chain).doFilter(requestArgumentCaptor.capture(), any(HttpServletResponse.class));
assertThat(requestArgumentCaptor.getValue()).isInstanceOf(RootFilter.ServletRequestWrapper.class);
}
@Test
public void fail_to_get_session_from_request() throws Exception {
- filter.doFilter(request("GET", "/context/static/image.png", null), null, chain);
+ underTest.doFilter(request("GET", "/context/static/image.png", null), mock(HttpServletResponse.class), chain);
ArgumentCaptor<ServletRequest> requestArgumentCaptor = ArgumentCaptor.forClass(ServletRequest.class);
verify(chain).doFilter(requestArgumentCaptor.capture(), any(ServletResponse.class));
@Test
public void fail_to_get_session_with_create_from_request() throws Exception {
- filter.doFilter(request("GET", "/context/static/image.png", null), null, chain);
+ underTest.doFilter(request("GET", "/context/static/image.png", null), mock(HttpServletResponse.class), chain);
ArgumentCaptor<ServletRequest> requestArgumentCaptor = ArgumentCaptor.forClass(ServletRequest.class);
verify(chain).doFilter(requestArgumentCaptor.capture(), any(ServletResponse.class));
return request;
}
- private HttpServletResponse mockHttpResponse(boolean commited) {
+ private static HttpServletResponse mockHttpResponse(boolean committed) {
HttpServletResponse response = mock(HttpServletResponse.class);
- when(response.isCommitted()).thenReturn(commited);
+ when(response.isCommitted()).thenReturn(committed);
return response;
}
}
public TemporaryFolder testFolder = new TemporaryFolder();
@Rule
public ExpectedException expectedException = ExpectedException.none();
- File downloadDir;
- UpdateCenterMatrixFactory updateCenterMatrixFactory;
- UpdateCenter updateCenter;
- HttpDownloader httpDownloader;
- PluginDownloader pluginDownloader;
+ private File downloadDir;
+ private UpdateCenterMatrixFactory updateCenterMatrixFactory;
+ private UpdateCenter updateCenter;
+ private HttpDownloader httpDownloader;
+ private PluginDownloader pluginDownloader;
@Before
public void before() throws Exception {
assertThat(new File(downloadDir, "testdep-1.0.jar")).exists();
}
- class HasFileName extends ArgumentMatcher<File> {
+ class HasFileName implements ArgumentMatcher<File> {
private final String name;
HasFileName(String name) {
this.name = name;
}
- public boolean matches(Object obj) {
- File file = (File) obj;
+ @Override
+ public boolean matches(File file) {
return file.getName().equals(name);
}
}
import org.junit.rules.ExpectedException;
import org.sonar.api.server.ws.WebService;
import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.qualityprofile.QProfileDto;
import org.sonar.server.exceptions.UnauthorizedException;
import org.sonar.server.organization.TestDefaultOrganizationProvider;
import org.sonar.server.qualityprofile.RuleActivator;
-import org.sonar.server.rule.index.RuleQuery;
import org.sonar.server.rule.ws.RuleQueryFactory;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.TestRequest;
import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.RETURNS_DEEP_STUBS;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
.setParam(PARAM_TARGET_KEY, qualityProfile.getKee())
.execute();
- verify(ruleActivator).bulkActivateAndCommit(any(DbSession.class), any(RuleQuery.class), any(QProfileDto.class), anyString());
+ verify(ruleActivator).bulkActivateAndCommit(any(), any(), any(), any());
}
@Test
.setParam(PARAM_TARGET_KEY, qualityProfile.getKee())
.execute();
- verify(ruleActivator).bulkActivateAndCommit(any(DbSession.class), any(RuleQuery.class), any(QProfileDto.class), anyString());
+ verify(ruleActivator).bulkActivateAndCommit(any(), any(), any(), any());
}
@Test
import org.junit.rules.ExpectedException;
import org.sonar.api.server.ws.WebService;
import org.sonar.db.DbClient;
-import org.sonar.db.DbSession;
import org.sonar.db.DbTester;
import org.sonar.db.organization.OrganizationDto;
import org.sonar.db.qualityprofile.QProfileDto;
import org.sonar.server.exceptions.UnauthorizedException;
import org.sonar.server.organization.TestDefaultOrganizationProvider;
import org.sonar.server.qualityprofile.RuleActivator;
-import org.sonar.server.rule.index.RuleQuery;
import org.sonar.server.rule.ws.RuleQueryFactory;
import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.TestRequest;
.setParam(PARAM_TARGET_KEY, qualityProfile.getKee())
.execute();
- verify(ruleActivator).bulkDeactivateAndCommit(any(DbSession.class), any(RuleQuery.class), any(QProfileDto.class));
+ verify(ruleActivator).bulkDeactivateAndCommit(any(), any(), any());
}
@Test
.setParam(PARAM_TARGET_KEY, qualityProfile.getKee())
.execute();
- verify(ruleActivator).bulkDeactivateAndCommit(any(DbSession.class), any(RuleQuery.class), any(QProfileDto.class));
+ verify(ruleActivator).bulkDeactivateAndCommit(any(), any(), any());
}
@Test
import static org.apache.commons.lang.RandomStringUtils.randomAlphanumeric;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.after;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.reset;
import static org.mockito.Mockito.spy;
internalProperties.write("telemetry.lastPing", String.valueOf(sixDaysAgo));
settings.setProperty("sonar.telemetry.frequencyInSeconds", "1");
underTest.start();
- verify(client, timeout(2_000).never()).upload(anyString());
+ verify(client, after(2_000).never()).upload(anyString());
internalProperties.write("telemetry.lastPing", String.valueOf(sevenDaysAgo));
verify(client, timeout(2_000).atLeastOnce()).upload(anyString());
internalProperties.write("telemetry.lastPing", String.valueOf(sixDaysAgo));
underTest.start();
- verify(client, timeout(2_000).never()).upload(anyString());
+ verify(client, after(2_000).never()).upload(anyString());
}
@Test
underTest.start();
underTest.start();
- verify(client, timeout(2_000).never()).upload(anyString());
+ verify(client, after(2_000).never()).upload(anyString());
verify(client, timeout(2_000).times(1)).optOut(anyString());
assertThat(logger.logs(LoggerLevel.INFO)).contains("Sharing of SonarQube statistics is disabled.");
}