import com.google.common.collect.Iterators;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Timer;
+import java.util.concurrent.atomic.AtomicLong;
import org.apache.commons.io.FileUtils;
import org.apache.commons.lang.math.RandomUtils;
+import org.junit.ClassRule;
import org.junit.Rule;
import org.junit.Test;
import org.slf4j.Logger;
import org.sonar.server.issue.index.IssueIndex;
import org.sonar.server.issue.index.IssueIndexer;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.Arrays;
-import java.util.Date;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Timer;
-import java.util.concurrent.atomic.AtomicLong;
+import org.sonar.server.tester.UserSessionRule;
public class IssueIndexBenchmarkTest {
final static int FILES_PER_PROJECT = 100;
final static int ISSUES_PER_FILE = 100;
+ @ClassRule
+ public static ServerTester tester = new ServerTester();
@Rule
- public ServerTester tester = new ServerTester();
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
@Rule
public Benchmark benchmark = new Benchmark();
}
private void benchmarkQueries() {
- MockUserSession.set().setUserGroups("sonar-users");
- benchmarkQuery("all issues", IssueQuery.builder().build());
- benchmarkQuery("project issues", IssueQuery.builder().projectUuids(Arrays.asList("PROJECT33")).build());
- benchmarkQuery("file issues", IssueQuery.builder().componentUuids(Arrays.asList("FILE333")).build());
- benchmarkQuery("various", IssueQuery.builder()
+ userSessionRule.setUserGroups("sonar-users");
+ benchmarkQuery("all issues", IssueQuery.builder(userSessionRule).build());
+ benchmarkQuery("project issues", IssueQuery.builder(userSessionRule).projectUuids(Arrays.asList("PROJECT33")).build());
+ benchmarkQuery("file issues", IssueQuery.builder(userSessionRule).componentUuids(Arrays.asList("FILE333")).build());
+ benchmarkQuery("various", IssueQuery.builder(userSessionRule)
.resolutions(Arrays.asList(Issue.RESOLUTION_FIXED))
.assigned(true)
.build());
private final DbClient dbClient;
private final ActivityIndexer indexer;
+ private final UserSession userSession;
- public ActivityService(DbClient dbClient, ActivityIndexer indexer) {
+ public ActivityService(DbClient dbClient, ActivityIndexer indexer, UserSession userSession) {
this.dbClient = dbClient;
this.indexer = indexer;
+ this.userSession = userSession;
}
public void save(Activity activity) {
ActivityDto dto = new ActivityDto()
.setKey(Uuids.create())
- .setAuthor(UserSession.get().login())
+ .setAuthor(userSession.login())
.setAction(activity.getAction())
.setMessage(activity.getMessage())
.setData(KeyValueFormat.format(activity.getData()))
import org.sonar.server.search.ws.BaseMapping;
import java.util.Map;
+import org.sonar.server.user.UserSession;
/**
* Conversion between {@link org.sonar.server.activity.index.ActivityDoc} and WS JSON response
*/
public class ActivityMapping extends BaseMapping<ActivityDoc, Object> {
- public ActivityMapping() {
+ public ActivityMapping(UserSession userSession) {
+ super(userSession);
map("type", ActivityIndexDefinition.FIELD_TYPE);
map("action", ActivityIndexDefinition.FIELD_ACTION);
mapDateTime("createdAt", ActivityIndexDefinition.FIELD_CREATED_AT);
import org.sonar.server.es.SearchOptions;
import org.sonar.server.es.SearchResult;
import org.sonar.server.search.QueryContext;
+import org.sonar.server.user.UserSession;
public class SearchAction implements RequestHandler {
private final ActivityIndex activityIndex;
private final ActivityMapping docToJsonMapping;
+ private final UserSession userSession;
- public SearchAction(ActivityIndex activityIndex, ActivityMapping docToJsonMapping) {
+ public SearchAction(ActivityIndex activityIndex, ActivityMapping docToJsonMapping, UserSession userSession) {
this.activityIndex = activityIndex;
this.docToJsonMapping = docToJsonMapping;
+ this.userSession = userSession;
}
void define(WebService.NewController controller) {
JsonWriter json = response.newJsonWriter().beginObject();
options.writeJson(json, results.getTotal());
- writeActivities(results, json, new QueryContext().setFieldsToReturn(request.paramAsStrings(WebService.Param.FIELDS)));
+ writeActivities(results, json, new QueryContext(userSession).setFieldsToReturn(request.paramAsStrings(WebService.Param.FIELDS)));
json.endObject().close();
}
private final DbClient dbClient;
private final PropertiesDao propertiesDao;
+ private final UserSession userSession;
- public GlobalRepositoryAction(DbClient dbClient, PropertiesDao propertiesDao) {
+ public GlobalRepositoryAction(DbClient dbClient, PropertiesDao propertiesDao, UserSession userSession) {
this.dbClient = dbClient;
this.propertiesDao = propertiesDao;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession userSession = UserSession.get();
boolean hasScanPerm = userSession.hasGlobalPermission(GlobalPermissions.SCAN_EXECUTION);
boolean hasPreviewPerm = userSession.hasGlobalPermission(GlobalPermissions.PREVIEW_EXECUTION);
if (!hasPreviewPerm && !hasScanPerm) {
package org.sonar.server.batch;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
import org.sonar.api.resources.Scopes;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.server.plugins.MimeTypes;
import org.sonar.server.user.UserSession;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-
import static com.google.common.collect.Maps.newHashMap;
public class IssuesAction implements BatchAction {
private static final String PARAM_KEY = "key";
private final DbClient dbClient;
-
private final IssueIndex issueIndex;
+ private final UserSession userSession;
- public IssuesAction(DbClient dbClient, IssueIndex issueIndex) {
+ public IssuesAction(DbClient dbClient, IssueIndex issueIndex, UserSession userSession) {
this.dbClient = dbClient;
this.issueIndex = issueIndex;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkGlobalPermission(GlobalPermissions.PREVIEW_EXECUTION);
+ userSession.checkGlobalPermission(GlobalPermissions.PREVIEW_EXECUTION);
final String moduleKey = request.mandatoryParam(PARAM_KEY);
response.stream().setMediaType(MimeTypes.PROTOBUF);
private final QProfileLoader qProfileLoader;
private final RuleService ruleService;
private final Languages languages;
+ private final UserSession userSession;
public ProjectRepositoryLoader(DbClient dbClient, QProfileFactory qProfileFactory, QProfileLoader qProfileLoader, RuleService ruleService,
- Languages languages) {
+ Languages languages, UserSession userSession) {
this.dbClient = dbClient;
this.qProfileFactory = qProfileFactory;
this.qProfileLoader = qProfileLoader;
this.ruleService = ruleService;
this.languages = languages;
+ this.userSession = userSession;
}
public ProjectRepositories load(ProjectRepositoryQuery query) {
- boolean hasScanPerm = UserSession.get().hasGlobalPermission(GlobalPermissions.SCAN_EXECUTION);
+ boolean hasScanPerm = userSession.hasGlobalPermission(GlobalPermissions.SCAN_EXECUTION);
checkPermission(query.isPreview());
DbSession session = dbClient.openSession(false);
// Current project/module can be null when analysing a new project
if (module != null) {
// Scan permission is enough to analyze all projects but preview permission is limited to projects user can access
- if (query.isPreview() && !UserSession.get().hasProjectPermissionByUuid(UserRole.USER, module.projectUuid())) {
+ if (query.isPreview() && !userSession.hasProjectPermissionByUuid(UserRole.USER, module.projectUuid())) {
throw new ForbiddenException("You're not authorized to access to project '" + module.name() + "', please contact your SonarQube administrator.");
}
for (org.sonar.batch.protocol.input.QProfile qProfile : ref.qProfiles()) {
// Load all rules of the profile language (only needed fields are loaded)
Map<RuleKey, Rule> languageRules = ruleByRuleKey(ruleService.search(new RuleQuery().setLanguages(newArrayList(qProfile.language())),
- new QueryContext().setLimit(100).setFieldsToReturn(newArrayList(
+ new QueryContext(userSession).setLimit(100).setFieldsToReturn(newArrayList(
RuleNormalizer.RuleField.KEY.field(), RuleNormalizer.RuleField.NAME.field(), RuleNormalizer.RuleField.INTERNAL_KEY.field(), RuleNormalizer.RuleField.TEMPLATE_KEY.field()
)).setScroll(true))
.scroll());
}
private void addManualRules(ProjectRepositories ref) {
- Result<Rule> ruleSearchResult = ruleService.search(new RuleQuery().setRepositories(newArrayList(RuleKey.MANUAL_REPOSITORY_KEY)), new QueryContext().setScroll(true)
+ Result<Rule> ruleSearchResult = ruleService.search(new RuleQuery().setRepositories(newArrayList(RuleKey.MANUAL_REPOSITORY_KEY)), new QueryContext(userSession).setScroll(true)
.setFieldsToReturn(newArrayList(RuleNormalizer.RuleField.KEY.field(), RuleNormalizer.RuleField.NAME.field())));
Iterator<Rule> rules = ruleSearchResult.scroll();
while (rules.hasNext()) {
}
private void checkPermission(boolean preview) {
- UserSession userSession = UserSession.get();
boolean hasScanPerm = userSession.hasGlobalPermission(GlobalPermissions.SCAN_EXECUTION);
boolean hasPreviewPerm = userSession.hasGlobalPermission(GlobalPermissions.PREVIEW_EXECUTION);
if (!hasPreviewPerm && !hasScanPerm) {
package org.sonar.server.batch;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.Iterator;
+import java.util.List;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.user.index.UserDoc;
import org.sonar.server.user.index.UserIndex;
-import java.io.IOException;
-import java.io.OutputStream;
-import java.util.Iterator;
-import java.util.List;
-
public class UsersAction implements BatchAction {
private static final String PARAM_LOGINS = "logins";
private final UserIndex userIndex;
+ private final UserSession userSession;
- public UsersAction(UserIndex userIndex) {
+ public UsersAction(UserIndex userIndex, UserSession userSession) {
this.userIndex = userIndex;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkGlobalPermission(GlobalPermissions.PREVIEW_EXECUTION);
+ userSession.checkGlobalPermission(GlobalPermissions.PREVIEW_EXECUTION);
List<String> logins = request.mandatoryParamAsStrings(PARAM_LOGINS);
response.stream().setMediaType(MimeTypes.PROTOBUF);
import com.google.common.base.Joiner;
import com.google.common.collect.Collections2;
import com.google.common.collect.Sets;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+import org.sonar.api.ServerComponent;
import org.sonar.api.ServerSide;
import org.sonar.api.i18n.I18n;
import org.sonar.api.resources.Scopes;
import org.sonar.server.permission.InternalPermissionService;
import org.sonar.server.user.UserSession;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
-import java.util.Collection;
-import java.util.Date;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Set;
-
import static com.google.common.collect.Lists.newArrayList;
@ServerSide
private final I18n i18n;
private final ResourceIndexerDao resourceIndexerDao;
private final InternalPermissionService permissionService;
+ private final UserSession userSession;
public ComponentService(DbClient dbClient, ResourceKeyUpdaterDao resourceKeyUpdaterDao, I18n i18n, ResourceIndexerDao resourceIndexerDao,
- InternalPermissionService permissionService) {
+ InternalPermissionService permissionService, UserSession userSession) {
this.dbClient = dbClient;
this.resourceKeyUpdaterDao = resourceKeyUpdaterDao;
this.i18n = i18n;
this.resourceIndexerDao = resourceIndexerDao;
this.permissionService = permissionService;
+ this.userSession = userSession;
}
public ComponentDto getByKey(String key) {
DbSession session = dbClient.openSession(false);
try {
ComponentDto projectOrModule = getByKey(session, projectOrModuleKey);
- UserSession.get().checkProjectUuidPermission(UserRole.ADMIN, projectOrModule.projectUuid());
+ userSession.checkProjectUuidPermission(UserRole.ADMIN, projectOrModule.projectUuid());
resourceKeyUpdaterDao.updateKey(projectOrModule.getId(), newKey);
session.commit();
DbSession session = dbClient.openSession(false);
try {
ComponentDto project = getByKey(projectKey);
- UserSession.get().checkProjectUuidPermission(UserRole.ADMIN, project.projectUuid());
+ userSession.checkProjectUuidPermission(UserRole.ADMIN, project.projectUuid());
return resourceKeyUpdaterDao.checkModuleKeysBeforeRenaming(project.getId(), stringToReplace, replacementString);
} finally {
session.close();
DbSession session = dbClient.openSession(true);
try {
ComponentDto project = getByKey(session, projectKey);
- UserSession.get().checkProjectUuidPermission(UserRole.ADMIN, project.projectUuid());
+ userSession.checkProjectUuidPermission(UserRole.ADMIN, project.projectUuid());
resourceKeyUpdaterDao.bulkUpdateKey(session, project.getId(), stringToReplace, replacementString);
session.commit();
} finally {
}
public String create(NewComponent newComponent) {
- UserSession.get().checkGlobalPermission(GlobalPermissions.PROVISIONING);
+ userSession.checkGlobalPermission(GlobalPermissions.PROVISIONING);
DbSession session = dbClient.openSession(false);
try {
package org.sonar.server.component.ws;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
import org.apache.commons.lang.BooleanUtils;
import org.sonar.api.i18n.I18n;
import org.sonar.api.measures.CoreMetrics;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.user.UserSession;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
-import java.util.List;
-import java.util.Map;
-
import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Maps.newHashMap;
private final Durations durations;
private final I18n i18n;
+ private final UserSession userSession;
- public ComponentAppAction(DbClient dbClient, Durations durations, I18n i18n) {
+ public ComponentAppAction(DbClient dbClient, Durations durations, I18n i18n, UserSession userSession) {
this.dbClient = dbClient;
this.durations = durations;
this.i18n = i18n;
+ this.userSession = userSession;
}
void define(WebService.NewController controller) {
@Override
public void handle(Request request, Response response) {
String componentUuid = request.mandatoryParam(PARAM_UUID);
- UserSession userSession = UserSession.get();
JsonWriter json = response.newJsonWriter();
json.beginObject();
value = metric.getBestValue();
}
if (metricType.equals(Metric.ValueType.FLOAT) && value != null) {
- return i18n.formatDouble(UserSession.get().locale(), value);
+ return i18n.formatDouble(userSession.locale(), value);
}
if (metricType.equals(Metric.ValueType.INT) && value != null) {
- return i18n.formatInteger(UserSession.get().locale(), value.intValue());
+ return i18n.formatInteger(userSession.locale(), value.intValue());
}
if (metricType.equals(Metric.ValueType.PERCENT) && value != null) {
- return i18n.formatDouble(UserSession.get().locale(), value) + "%";
+ return i18n.formatDouble(userSession.locale(), value) + "%";
}
if (metricType.equals(Metric.ValueType.WORK_DUR) && value != null) {
- return durations.format(UserSession.get().locale(), durations.create(value.longValue()), Durations.DurationFormat.SHORT);
+ return durations.format(userSession.locale(), durations.create(value.longValue()), Durations.DurationFormat.SHORT);
}
if ((metricType.equals(Metric.ValueType.STRING) || metricType.equals(Metric.ValueType.RATING)) && data != null) {
return data;
import java.util.List;
public class ProvisionedProjectsAction implements ProjectsAction {
- private final DbClient dbClient;
-
private static final List<String> POSSIBLE_FIELDS = Arrays.asList("uuid", "key", "name", "creationDate");
- public ProvisionedProjectsAction(DbClient dbClient) {
+ private final DbClient dbClient;
+ private final UserSession userSession;
+
+ public ProvisionedProjectsAction(DbClient dbClient, UserSession userSession) {
this.dbClient = dbClient;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkGlobalPermission(UserRole.ADMIN, "You need admin rights.");
+ userSession.checkGlobalPermission(UserRole.ADMIN, "You need admin rights.");
SearchOptions options = new SearchOptions().setPage(
request.mandatoryParamAsInt(Param.PAGE),
request.mandatoryParamAsInt(Param.PAGE_SIZE)
package org.sonar.server.component.ws;
import com.google.common.collect.Sets;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.RequestHandler;
import org.sonar.api.server.ws.Response;
import org.sonar.server.es.SearchOptions;
import org.sonar.server.user.UserSession;
-import java.util.Collection;
-import java.util.List;
-import java.util.Set;
-
import static com.google.common.collect.Sets.newLinkedHashSet;
import static org.sonar.api.server.ws.WebService.Param.PAGE;
import static org.sonar.api.server.ws.WebService.Param.PAGE_SIZE;
private static final String PARAM_COMPONENT_UUID = "componentUuid";
private final DbClient dbClient;
+ private final UserSession userSession;
- public SearchAction(DbClient dbClient) {
+ public SearchAction(DbClient dbClient, UserSession userSession) {
this.dbClient = dbClient;
+ this.userSession = userSession;
}
void define(WebService.NewController controller) {
DbSession session = dbClient.openSession(false);
try {
ComponentDto componentDto = dbClient.componentDao().getByUuid(session, viewOrSubUuid);
- UserSession.get().checkProjectUuidPermission(UserRole.USER, componentDto.projectUuid());
+ userSession.checkProjectUuidPermission(UserRole.USER, componentDto.projectUuid());
Set<Long> projectIds = newLinkedHashSet(dbClient.componentIndexDao().selectProjectIdsFromQueryAndViewOrSubViewUuid(session, query, componentDto.uuid()));
- Collection<Long> authorizedProjectIds = dbClient.authorizationDao().keepAuthorizedProjectIds(session, projectIds, UserSession.get().userId(), UserRole.USER);
+ Collection<Long> authorizedProjectIds = dbClient.authorizationDao().keepAuthorizedProjectIds(session, projectIds, userSession.userId(), UserRole.USER);
SearchOptions options = new SearchOptions();
options.setPage(request.mandatoryParamAsInt(PAGE), request.mandatoryParamAsInt(PAGE_SIZE));
package org.sonar.server.computation.ws;
+import java.util.Arrays;
+import java.util.Map;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.RequestHandler;
import org.sonar.api.server.ws.Response;
import org.sonar.server.issue.ws.IssuesWs;
import org.sonar.server.user.UserSession;
-import java.util.Arrays;
-import java.util.Map;
-
// FIXME replace by api/activities/search
public class HistoryWsAction implements ComputationWsAction, RequestHandler {
public static final String PARAM_TYPE = "type";
private final ActivityIndex activityIndex;
+ private final UserSession userSession;
- public HistoryWsAction(ActivityIndex activityIndex) {
+ public HistoryWsAction(ActivityIndex activityIndex, UserSession userSession) {
this.activityIndex = activityIndex;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) {
- UserSession.get().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
ActivityQuery query = new ActivityQuery();
query.setTypes(Arrays.asList(Activity.Type.ANALYSIS_REPORT.name()));
package org.sonar.server.computation.ws;
+import java.io.InputStream;
import org.apache.commons.io.IOUtils;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.RequestHandler;
import org.sonar.server.computation.ReportQueue;
import org.sonar.server.user.UserSession;
-import java.io.InputStream;
-
public class SubmitReportWsAction implements ComputationWsAction, RequestHandler {
public static final String ACTION = "submit_report";
private final ReportQueue queue;
private final ComputationThreadLauncher workerLauncher;
+ private final UserSession userSession;
- public SubmitReportWsAction(ReportQueue queue, ComputationThreadLauncher workerLauncher) {
+ public SubmitReportWsAction(ReportQueue queue, ComputationThreadLauncher workerLauncher, UserSession userSession) {
this.queue = queue;
this.workerLauncher = workerLauncher;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkGlobalPermission(GlobalPermissions.SCAN_EXECUTION);
+ userSession.checkGlobalPermission(GlobalPermissions.SCAN_EXECUTION);
String projectKey = request.mandatoryParam(PARAM_PROJECT_KEY);
InputStream reportData = request.paramAsInputStream(PARAM_REPORT_DATA);
try {
package org.sonar.server.dashboard.ws;
import com.google.common.collect.ListMultimap;
+import java.util.Collection;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.user.UserSession;
-import java.util.Collection;
-
public class DashboardsShowAction implements DashboardsAction {
private static final String PARAM_KEY = "key";
private final DbClient dbClient;
+ private final UserSession userSession;
- public DashboardsShowAction(DbClient dbClient) {
+ public DashboardsShowAction(DbClient dbClient, UserSession userSession) {
this.dbClient = dbClient;
+ this.userSession = userSession;
}
@Override
public void handle(Request request, Response response) throws Exception {
DbSession dbSession = dbClient.openSession(false);
try {
- Integer userId = UserSession.get().userId();
+ Integer userId = userSession.userId();
DashboardDto dashboard = dbClient.dashboardDao().getAllowedByKey(dbSession, request.mandatoryParamAsLong(PARAM_KEY),
userId != null ? userId.longValue() : null);
if (dashboard == null) {
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.rule.RuleDefinitionsLoader;
import org.sonar.server.rule.RuleOperations;
-import org.sonar.server.user.UserSession;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import java.io.Reader;
import java.util.Date;
import java.util.List;
+import org.sonar.server.user.UserSession;
import static com.google.common.collect.Lists.newArrayList;
private final DebtModelXMLExporter debtModelXMLExporter;
private final RuleDefinitionsLoader defLoader;
private final System2 system2;
+ private final UserSession userSession;
public DebtModelBackup(DbClient dbClient, DebtModelOperations debtModelOperations, RuleOperations ruleOperations,
DebtModelPluginRepository debtModelPluginRepository, DebtCharacteristicsXMLImporter characteristicsXMLImporter, DebtRulesXMLImporter rulesXMLImporter,
- DebtModelXMLExporter debtModelXMLExporter, RuleDefinitionsLoader defLoader) {
+ DebtModelXMLExporter debtModelXMLExporter, RuleDefinitionsLoader defLoader, UserSession userSession) {
this(dbClient, debtModelOperations, ruleOperations, debtModelPluginRepository, characteristicsXMLImporter, rulesXMLImporter, debtModelXMLExporter,
- defLoader, System2.INSTANCE);
+ defLoader, System2.INSTANCE, userSession);
}
@VisibleForTesting
DebtModelBackup(DbClient dbClient, DebtModelOperations debtModelOperations, RuleOperations ruleOperations,
DebtModelPluginRepository debtModelPluginRepository, DebtCharacteristicsXMLImporter characteristicsXMLImporter, DebtRulesXMLImporter rulesXMLImporter,
- DebtModelXMLExporter debtModelXMLExporter, RuleDefinitionsLoader defLoader, System2 system2) {
+ DebtModelXMLExporter debtModelXMLExporter, RuleDefinitionsLoader defLoader, System2 system2, UserSession userSession) {
this.dbClient = dbClient;
this.debtModelOperations = debtModelOperations;
this.ruleOperations = ruleOperations;
this.debtModelXMLExporter = debtModelXMLExporter;
this.defLoader = defLoader;
this.system2 = system2;
+ this.userSession = userSession;
}
public String backup() {
}
private void checkPermission() {
- UserSession.get().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
}
}
private final DbClient dbClient;
private final System2 system2;
+ private final UserSession userSession;
- public DebtModelOperations(DbClient dbClient) {
- this(dbClient, System2.INSTANCE);
+ public DebtModelOperations(DbClient dbClient, UserSession userSession) {
+ this(dbClient, System2.INSTANCE, userSession);
}
@VisibleForTesting
- DebtModelOperations(DbClient dbClient, System2 system2) {
+ DebtModelOperations(DbClient dbClient, System2 system2, UserSession userSession) {
this.dbClient = dbClient;
this.system2 = system2;
+ this.userSession = userSession;
}
public DebtCharacteristic create(String name, @Nullable Integer parentId) {
}
private void checkPermission() {
- UserSession.get().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
}
private static DebtCharacteristic toCharacteristic(CharacteristicDto dto) {
package org.sonar.server.design.ws;
import com.google.common.io.Resources;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.user.UserSession;
import org.sonar.server.user.ws.BaseUsersWsAction;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
public class ShowAction implements BaseUsersWsAction {
private static final String PARAM_FROM_PARENT_UUID = "fromParentUuid";
private static final String PARAM_TO_PARENT_UUID = "toParentUuid";
private final DbClient dbClient;
+ private final UserSession userSession;
- public ShowAction(DbClient dbClient) {
+ public ShowAction(DbClient dbClient, UserSession userSession) {
this.dbClient = dbClient;
+ this.userSession = userSession;
}
@Override
try {
ComponentDto fromParent = dbClient.componentDao().getByUuid(session, fromParentUuid);
ComponentDto project = dbClient.componentDao().getByUuid(session, fromParent.projectUuid());
- UserSession.get().checkProjectUuidPermission(UserRole.USER, project.uuid());
+ userSession.checkProjectUuidPermission(UserRole.USER, project.uuid());
List<FileDependencyDto> fileDependencies = dbClient.fileDependencyDao().selectFromParents(session, fromParentUuid, toParentUuid, project.getId());
writeResponse(response, fileDependencies, componentsByUuid(session, fileDependencies));
import com.google.common.base.Preconditions;
import com.google.common.io.Resources;
+import java.util.List;
+import javax.annotation.CheckForNull;
import org.sonar.api.measures.CoreMetrics;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.RequestHandler;
import org.sonar.server.measure.persistence.MeasureDao;
import org.sonar.server.user.UserSession;
-import javax.annotation.CheckForNull;
-import java.util.List;
-
public class ShowAction implements RequestHandler {
private final DbClient dbClient;
private final MeasureDao measureDao;
private final DuplicationsParser parser;
private final DuplicationsJsonWriter duplicationsJsonWriter;
+ private final UserSession userSession;
- public ShowAction(DbClient dbClient, ComponentDao componentDao, MeasureDao measureDao, DuplicationsParser parser, DuplicationsJsonWriter duplicationsJsonWriter) {
+ public ShowAction(DbClient dbClient, ComponentDao componentDao, MeasureDao measureDao, DuplicationsParser parser, DuplicationsJsonWriter duplicationsJsonWriter, UserSession userSession) {
this.dbClient = dbClient;
this.componentDao = componentDao;
this.measureDao = measureDao;
this.parser = parser;
this.duplicationsJsonWriter = duplicationsJsonWriter;
+ this.userSession = userSession;
}
void define(WebService.NewController controller) {
fileKey = componentDao.getByUuid(session, fileUuid).key();
}
- UserSession.get().checkComponentPermission(UserRole.CODEVIEWER, fileKey);
+ userSession.checkComponentPermission(UserRole.CODEVIEWER, fileKey);
try {
ComponentDto component = findComponent(fileKey, session);
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
import org.apache.commons.lang.StringUtils;
import org.sonar.api.ServerSide;
import org.sonar.api.issue.ActionPlan;
import org.sonar.server.util.RubyUtils;
import org.sonar.server.util.Validation;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
-import java.util.Collection;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-
import static com.google.common.collect.Lists.newArrayList;
/**
private final ActionService actionService;
private final IssueFilterService issueFilterService;
private final IssueBulkChangeService issueBulkChangeService;
+ private final UserSession userSession;
public InternalRubyIssueService(
IssueService issueService,
IssueCommentService commentService,
IssueChangelogService changelogService, ActionPlanService actionPlanService,
ResourceDao resourceDao, ActionService actionService,
- IssueFilterService issueFilterService, IssueBulkChangeService issueBulkChangeService) {
+ IssueFilterService issueFilterService, IssueBulkChangeService issueBulkChangeService,
+ UserSession userSession) {
this.issueService = issueService;
this.issueQueryService = issueQueryService;
this.commentService = commentService;
this.actionService = actionService;
this.issueFilterService = issueFilterService;
this.issueBulkChangeService = issueBulkChangeService;
+ this.userSession = userSession;
}
public Issue getIssueByKey(String issueKey) {
public Result<IssueComment> addComment(String issueKey, String text) {
Result<IssueComment> result = Result.of();
try {
- result.set(commentService.addComment(issueKey, text, UserSession.get()));
+ result.set(commentService.addComment(issueKey, text, userSession));
} catch (Exception e) {
result.addError(e.getMessage());
}
}
public IssueComment deleteComment(String commentKey) {
- return commentService.deleteComment(commentKey, UserSession.get());
+ return commentService.deleteComment(commentKey, userSession);
}
public Result<IssueComment> editComment(String commentKey, String newText) {
Result<IssueComment> result = Result.of();
try {
- result.set(commentService.editComment(commentKey, newText, UserSession.get()));
+ result.set(commentService.editComment(commentKey, newText, userSession));
} catch (Exception e) {
result.addError(e.getMessage());
}
}
public Collection<ActionPlan> findOpenActionPlans(String projectKey) {
- return actionPlanService.findOpenByProjectKey(projectKey, UserSession.get());
+ return actionPlanService.findOpenByProjectKey(projectKey, userSession);
}
public ActionPlan findActionPlan(String actionPlanKey) {
- return actionPlanService.findByKey(actionPlanKey, UserSession.get());
+ return actionPlanService.findByKey(actionPlanKey, userSession);
}
public List<ActionPlanStats> findActionPlanStats(String projectKey) {
- return actionPlanService.findActionPlanStats(projectKey, UserSession.get());
+ return actionPlanService.findActionPlanStats(projectKey, userSession);
}
public Result<ActionPlan> createActionPlan(Map<String, String> parameters) {
Result<ActionPlan> result = createActionPlanResult(parameters);
if (result.ok()) {
- result.set(actionPlanService.create(result.get(), UserSession.get()));
+ result.set(actionPlanService.create(result.get(), userSession));
}
return result;
}
public Result<ActionPlan> updateActionPlan(String key, Map<String, String> parameters) {
- DefaultActionPlan existingActionPlan = (DefaultActionPlan) actionPlanService.findByKey(key, UserSession.get());
+ DefaultActionPlan existingActionPlan = (DefaultActionPlan) actionPlanService.findByKey(key, userSession);
if (existingActionPlan == null) {
Result<ActionPlan> result = Result.of();
result.addError(Result.Message.ofL10n(ACTION_PLANS_ERRORS_ACTION_PLAN_DOES_NOT_EXIST_MESSAGE, key));
DefaultActionPlan actionPlan = (DefaultActionPlan) result.get();
actionPlan.setKey(existingActionPlan.key());
actionPlan.setUserLogin(existingActionPlan.userLogin());
- result.set(actionPlanService.update(actionPlan, UserSession.get()));
+ result.set(actionPlanService.update(actionPlan, userSession));
}
return result;
}
public Result<ActionPlan> closeActionPlan(String actionPlanKey) {
Result<ActionPlan> result = createResultForExistingActionPlan(actionPlanKey);
if (result.ok()) {
- result.set(actionPlanService.setStatus(actionPlanKey, ActionPlan.STATUS_CLOSED, UserSession.get()));
+ result.set(actionPlanService.setStatus(actionPlanKey, ActionPlan.STATUS_CLOSED, userSession));
}
return result;
}
public Result<ActionPlan> openActionPlan(String actionPlanKey) {
Result<ActionPlan> result = createResultForExistingActionPlan(actionPlanKey);
if (result.ok()) {
- result.set(actionPlanService.setStatus(actionPlanKey, ActionPlan.STATUS_OPEN, UserSession.get()));
+ result.set(actionPlanService.setStatus(actionPlanKey, ActionPlan.STATUS_OPEN, userSession));
}
return result;
}
public Result<ActionPlan> deleteActionPlan(String actionPlanKey) {
Result<ActionPlan> result = createResultForExistingActionPlan(actionPlanKey);
if (result.ok()) {
- actionPlanService.delete(actionPlanKey, UserSession.get());
+ actionPlanService.delete(actionPlanKey, userSession);
}
return result;
}
if (result.ok()) {
DefaultActionPlan actionPlan = DefaultActionPlan.create(name)
.setDescription(description)
- .setUserLogin(UserSession.get().login())
+ .setUserLogin(userSession.login())
.setDeadLine(deadLine);
// Can only set project on creation
public Result<Issue> executeAction(String issueKey, String actionKey) {
Result<Issue> result = Result.of();
try {
- result.set(actionService.execute(issueKey, actionKey, UserSession.get()));
+ result.set(actionService.execute(issueKey, actionKey, userSession));
} catch (Exception e) {
result.addError(e.getMessage());
}
* Never return null
*/
public IssueFilterDto findIssueFilter(Long id) {
- return issueFilterService.find(id, UserSession.get());
+ return issueFilterService.find(id, userSession);
}
public boolean isUserAuthorized(IssueFilterDto issueFilter) {
try {
- UserSession userSession = UserSession.get();
String user = issueFilterService.getLoggedLogin(userSession);
issueFilterService.verifyCurrentUserCanReadFilter(issueFilter, user);
return true;
}
public boolean canUserShareIssueFilter() {
- return issueFilterService.canShareFilter(UserSession.get());
+ return issueFilterService.canShareFilter(userSession);
}
public String serializeFilterQuery(Map<String, Object> filterQuery) {
* Execute issue filter from existing filter with optional overridable parameters
*/
public IssueFilterService.IssueFilterResult execute(Long issueFilterId, Map<String, Object> overrideProps) {
- IssueFilterDto issueFilter = issueFilterService.find(issueFilterId, UserSession.get());
+ IssueFilterDto issueFilter = issueFilterService.find(issueFilterId, userSession);
Map<String, Object> props = issueFilterService.deserializeIssueFilterQuery(issueFilter);
overrideProps(props, overrideProps);
return execute(props);
* List user issue filter
*/
public List<IssueFilterDto> findIssueFiltersForCurrentUser() {
- return issueFilterService.findByUser(UserSession.get());
+ return issueFilterService.findByUser(userSession);
}
/**
*/
public IssueFilterDto createIssueFilter(Map<String, String> parameters) {
IssueFilterDto result = createIssueFilterResultForNew(parameters);
- return issueFilterService.save(result, UserSession.get());
+ return issueFilterService.save(result, userSession);
}
/**
*/
public IssueFilterDto updateIssueFilter(Map<String, String> parameters) {
IssueFilterDto result = createIssueFilterResultForUpdate(parameters);
- return issueFilterService.update(result, UserSession.get());
+ return issueFilterService.update(result, userSession);
}
/**
* Update issue filter data
*/
public IssueFilterDto updateIssueFilterQuery(Long issueFilterId, Map<String, Object> data) {
- return issueFilterService.updateFilterQuery(issueFilterId, data, UserSession.get());
+ return issueFilterService.updateFilterQuery(issueFilterId, data, userSession);
}
/**
* Delete issue filter
*/
public void deleteIssueFilter(Long issueFilterId) {
- issueFilterService.delete(issueFilterId, UserSession.get());
+ issueFilterService.delete(issueFilterId, userSession);
}
/**
*/
public IssueFilterDto copyIssueFilter(Long issueFilterIdToCopy, Map<String, String> parameters) {
IssueFilterDto result = createIssueFilterResultForCopy(parameters);
- return issueFilterService.copy(issueFilterIdToCopy, result, UserSession.get());
+ return issueFilterService.copy(issueFilterIdToCopy, result, userSession);
}
@VisibleForTesting
}
public List<IssueFilterDto> findSharedFiltersForCurrentUser() {
- return issueFilterService.findSharedFiltersWithoutUserFilters(UserSession.get());
+ return issueFilterService.findSharedFiltersWithoutUserFilters(userSession);
}
public List<IssueFilterDto> findFavouriteIssueFiltersForCurrentUser() {
- return issueFilterService.findFavoriteFilters(UserSession.get());
+ return issueFilterService.findFavoriteFilters(userSession);
}
public boolean toggleFavouriteIssueFilter(Long issueFilterId) {
- return issueFilterService.toggleFavouriteIssueFilter(issueFilterId, UserSession.get());
+ return issueFilterService.toggleFavouriteIssueFilter(issueFilterId, userSession);
}
/**
*/
public IssueBulkChangeResult bulkChange(Map<String, Object> props, String comment, boolean sendNotifications) {
IssueBulkChangeQuery issueBulkChangeQuery = new IssueBulkChangeQuery(props, comment, sendNotifications);
- return issueBulkChangeService.execute(issueBulkChangeQuery, UserSession.get());
+ return issueBulkChangeService.execute(issueBulkChangeQuery, userSession);
}
private void checkMandatoryParameter(String value, String paramName, Result result) {
private final DefaultRuleFinder ruleFinder;
private final NotificationManager notificationService;
private final List<Action> actions;
+ private final UserSession userSession;
public IssueBulkChangeService(DbClient dbClient, IssueService issueService, IssueStorage issueStorage, DefaultRuleFinder ruleFinder,
- NotificationManager notificationService, List<Action> actions) {
+ NotificationManager notificationService, List<Action> actions, UserSession userSession) {
this.dbClient = dbClient;
this.issueService = issueService;
this.issueStorage = issueStorage;
this.ruleFinder = ruleFinder;
this.notificationService = notificationService;
this.actions = actions;
+ this.userSession = userSession;
}
public IssueBulkChangeResult execute(IssueBulkChangeQuery issueBulkChangeQuery, UserSession userSession) {
// Load from index to check permission
SearchOptions options = new SearchOptions().setLimit(SearchOptions.MAX_LIMIT);
// TODO restrict fields to issue key, in order to not load all other fields;
- List<IssueDoc> authorizedIssues = issueService.search(IssueQuery.builder().issueKeys(issueKeys).build(), options).getDocs();
+ List<IssueDoc> authorizedIssues = issueService.search(IssueQuery.builder(userSession).issueKeys(issueKeys).build(), options).getDocs();
Collection<String> authorizedKeys = Collections2.transform(authorizedIssues, new Function<IssueDoc, String>() {
@Override
public String apply(IssueDoc input) {
*/
package org.sonar.server.issue;
+import java.io.Serializable;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import org.sonar.api.ServerComponent;
import org.sonar.api.ServerSide;
import org.sonar.api.i18n.I18n;
import org.sonar.api.issue.internal.FieldDiffs;
import org.sonar.core.issue.IssueUpdater;
import org.sonar.server.user.UserSession;
-import java.io.Serializable;
-import java.util.List;
-import java.util.Locale;
-import java.util.Map;
-
import static com.google.common.collect.Lists.newArrayList;
@ServerSide
private final I18n i18n;
private final Durations durations;
+ private final UserSession userSession;
- public IssueChangelogFormatter(I18n i18n, Durations durations) {
+ public IssueChangelogFormatter(I18n i18n, Durations durations, UserSession userSession) {
this.i18n = i18n;
this.durations = durations;
+ this.userSession = userSession;
}
public List<String> format(Locale locale, FieldDiffs diffs) {
String oldValueString = oldValue != null && !"".equals(oldValue) ? oldValue.toString() : null;
if (IssueUpdater.TECHNICAL_DEBT.equals(key)) {
if (newValueString != null) {
- newValueString = durations.format(UserSession.get().locale(), Duration.create(Long.parseLong(newValueString)), Durations.DurationFormat.SHORT);
+ newValueString = durations.format(userSession.locale(), Duration.create(Long.parseLong(newValueString)), Durations.DurationFormat.SHORT);
}
if (oldValueString != null) {
- oldValueString = durations.format(UserSession.get().locale(), Duration.create(Long.parseLong(oldValueString)), Durations.DurationFormat.SHORT);
+ oldValueString = durations.format(userSession.locale(), Duration.create(Long.parseLong(oldValueString)), Durations.DurationFormat.SHORT);
}
}
return new IssueChangelogDiffFormat(oldValueString, newValueString);
*/
package org.sonar.server.issue;
+import java.util.Collection;
+import java.util.List;
+import org.sonar.api.ServerComponent;
import org.sonar.api.ServerSide;
import org.sonar.api.issue.Issue;
import org.sonar.api.issue.internal.FieldDiffs;
import org.sonar.core.issue.db.IssueChangeDao;
import org.sonar.server.user.UserSession;
-import java.util.Collection;
-import java.util.List;
-
import static com.google.common.collect.Lists.newArrayList;
/**
private final UserFinder userFinder;
private final IssueService issueService;
private final IssueChangelogFormatter formatter;
+ private final UserSession userSession;
- public IssueChangelogService(IssueChangeDao changeDao, UserFinder userFinder, IssueService issueService, IssueChangelogFormatter formatter) {
+ public IssueChangelogService(IssueChangeDao changeDao, UserFinder userFinder, IssueService issueService, IssueChangelogFormatter formatter, UserSession userSession) {
this.changeDao = changeDao;
this.userFinder = userFinder;
this.issueService = issueService;
this.formatter = formatter;
+ this.userSession = userSession;
}
public IssueChangelog changelog(String issueKey) {
}
public List<String> formatDiffs(FieldDiffs diffs) {
- return formatter.format(UserSession.get().locale(), diffs);
+ return formatter.format(userSession.locale(), diffs);
}
}
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableSet;
-import org.apache.commons.lang.builder.ReflectionToStringBuilder;
-import org.sonar.api.rule.RuleKey;
-import org.sonar.server.search.QueryContext;
-import org.sonar.server.user.UserSession;
-
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.Set;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+import org.apache.commons.lang.builder.ReflectionToStringBuilder;
+import org.sonar.api.rule.RuleKey;
+import org.sonar.server.search.QueryContext;
+import org.sonar.server.user.UserSession;
import static com.google.common.collect.Sets.newHashSet;
return ReflectionToStringBuilder.toString(this);
}
- public static Builder builder() {
- return new Builder();
+ public static Builder builder(UserSession userSession) {
+ return new Builder(userSession);
}
public static class Builder {
private String sort;
private Boolean asc = false;
private Boolean ignorePaging = false;
- private String userLogin = UserSession.get().login();
- private Set<String> userGroups = UserSession.get().userGroups();
+ private String userLogin;
+ private Set<String> userGroups;
private boolean checkAuthorization = true;
- private Builder() {
+ private Builder(UserSession userSession) {
+ this.userLogin = userSession.login();
+ this.userGroups = userSession.userGroups();
}
public Builder issueKeys(@Nullable Collection<String> l) {
private final DbClient dbClient;
private final ComponentService componentService;
private final System2 system;
+ private final UserSession userSession;
- public IssueQueryService(DbClient dbClient, ComponentService componentService, System2 system) {
+ public IssueQueryService(DbClient dbClient, ComponentService componentService, System2 system, UserSession userSession) {
this.dbClient = dbClient;
this.componentService = componentService;
this.system = system;
+ this.userSession = userSession;
}
public IssueQuery createFromMap(Map<String, Object> params) {
DbSession session = dbClient.openSession(false);
try {
- IssueQuery.Builder builder = IssueQuery.builder()
+ IssueQuery.Builder builder = IssueQuery.builder(userSession)
.issueKeys(RubyUtils.toStrings(params.get(IssueFilterParameters.ISSUES)))
.severities(RubyUtils.toStrings(params.get(IssueFilterParameters.SEVERITIES)))
.statuses(RubyUtils.toStrings(params.get(IssueFilterParameters.STATUSES)))
public IssueQuery createFromRequest(Request request) {
DbSession session = dbClient.openSession(false);
try {
- IssueQuery.Builder builder = IssueQuery.builder()
+ IssueQuery.Builder builder = IssueQuery.builder(userSession)
.issueKeys(request.paramAsStrings(IssueFilterParameters.ISSUES))
.severities(request.paramAsStrings(IssueFilterParameters.SEVERITIES))
.statuses(request.paramAsStrings(IssueFilterParameters.STATUSES))
assignees.addAll(assigneesFromParams);
}
if (assignees.contains(LOGIN_MYSELF)) {
- String login = UserSession.get().login();
+ String login = userSession.login();
if (login == null) {
assignees.add(UNKNOWN);
} else {
private void addViewsOrSubViews(IssueQuery.Builder builder, Collection<String> componentUuids, String uniqueQualifier) {
List<String> filteredViewUuids = newArrayList();
for (String viewUuid : componentUuids) {
- if ((Qualifiers.VIEW.equals(uniqueQualifier) && UserSession.get().hasProjectPermissionByUuid(UserRole.USER, viewUuid))
- || (Qualifiers.SUBVIEW.equals(uniqueQualifier) && UserSession.get().hasComponentUuidPermission(UserRole.USER, viewUuid))) {
+ if ((Qualifiers.VIEW.equals(uniqueQualifier) && userSession.hasProjectPermissionByUuid(UserRole.USER, viewUuid))
+ || (Qualifiers.SUBVIEW.equals(uniqueQualifier) && userSession.hasComponentUuidPermission(UserRole.USER, viewUuid))) {
filteredViewUuids.add(viewUuid);
}
}
*/
package org.sonar.server.issue;
-import com.google.common.base.Objects;
-import com.google.common.base.Strings;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+
import org.apache.commons.lang.StringUtils;
import org.sonar.api.ServerSide;
import org.sonar.api.issue.ActionPlan;
import org.sonar.server.user.index.UserDoc;
import org.sonar.server.user.index.UserIndex;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
+import com.google.common.base.Objects;
+import com.google.common.base.Strings;
@ServerSide
public class IssueService {
private final UserFinder userFinder;
private final UserIndex userIndex;
private final SourceLineIndex sourceLineIndex;
+ private final UserSession userSession;
public IssueService(DbClient dbClient, IssueIndex issueIndex,
IssueWorkflow workflow,
ActionPlanService actionPlanService,
RuleFinder ruleFinder,
UserFinder userFinder,
- UserIndex userIndex, SourceLineIndex sourceLineIndex) {
+ UserIndex userIndex, SourceLineIndex sourceLineIndex, UserSession userSession) {
this.dbClient = dbClient;
this.issueIndex = issueIndex;
this.workflow = workflow;
this.userFinder = userFinder;
this.userIndex = userIndex;
this.sourceLineIndex = sourceLineIndex;
+ this.userSession = userSession;
}
public List<String> listStatus() {
for (Transition transition : outTransitions) {
String projectUuid = issue.projectUuid();
if (StringUtils.isBlank(transition.requiredProjectPermission()) ||
- (projectUuid != null && UserSession.get().hasProjectPermissionByUuid(transition.requiredProjectPermission(), projectUuid))) {
+ (projectUuid != null && userSession.hasProjectPermissionByUuid(transition.requiredProjectPermission(), projectUuid))) {
allowedTransitions.add(transition);
}
}
DbSession session = dbClient.openSession(false);
try {
DefaultIssue defaultIssue = getByKeyForUpdate(session, issueKey).toDefaultIssue();
- IssueChangeContext context = IssueChangeContext.createUser(new Date(), UserSession.get().login());
- checkTransitionPermission(transitionKey, UserSession.get(), defaultIssue);
+ IssueChangeContext context = IssueChangeContext.createUser(new Date(), userSession.login());
+ checkTransitionPermission(transitionKey, userSession, defaultIssue);
if (workflow.doTransition(defaultIssue, transitionKey, context)) {
saveIssue(session, defaultIssue, context, null);
}
throw new NotFoundException("Unknown user: " + assignee);
}
}
- IssueChangeContext context = IssueChangeContext.createUser(new Date(), UserSession.get().login());
+ IssueChangeContext context = IssueChangeContext.createUser(new Date(), userSession.login());
if (issueUpdater.assign(issue, user, context)) {
saveIssue(session, issue, context, null);
}
try {
ActionPlan actionPlan = null;
if (!Strings.isNullOrEmpty(actionPlanKey)) {
- actionPlan = actionPlanService.findByKey(actionPlanKey, UserSession.get());
+ actionPlan = actionPlanService.findByKey(actionPlanKey, userSession);
if (actionPlan == null) {
throw new NotFoundException("Unknown action plan: " + actionPlanKey);
}
}
DefaultIssue issue = getByKeyForUpdate(session, issueKey).toDefaultIssue();
- IssueChangeContext context = IssueChangeContext.createUser(new Date(), UserSession.get().login());
+ IssueChangeContext context = IssueChangeContext.createUser(new Date(), userSession.login());
if (issueUpdater.plan(issue, actionPlan, context)) {
saveIssue(session, issue, context, null);
}
DbSession session = dbClient.openSession(false);
try {
DefaultIssue issue = getByKeyForUpdate(session, issueKey).toDefaultIssue();
- UserSession.get().checkProjectPermission(UserRole.ISSUE_ADMIN, issue.projectKey());
+ userSession.checkProjectPermission(UserRole.ISSUE_ADMIN, issue.projectKey());
- IssueChangeContext context = IssueChangeContext.createUser(new Date(), UserSession.get().login());
+ IssueChangeContext context = IssueChangeContext.createUser(new Date(), userSession.login());
if (issueUpdater.setManualSeverity(issue, severity, context)) {
saveIssue(session, issue, context, null);
}
ComponentDto component = dbClient.componentDao().getByKey(session, componentKey);
ComponentDto project = dbClient.componentDao().getByUuid(session, component.projectUuid());
- UserSession.get().checkProjectPermission(UserRole.USER, project.getKey());
+ userSession.checkProjectPermission(UserRole.USER, project.getKey());
if (!ruleKey.isManual()) {
throw new IllegalArgumentException("Issues can be created only on rules marked as 'manual': " + ruleKey);
}
.severity(Objects.firstNonNull(severity, Severity.MAJOR))
.effortToFix(effortToFix)
.ruleKey(ruleKey)
- .reporter(UserSession.get().login())
+ .reporter(userSession.login())
.assignee(findSourceLineUser(component.uuid(), line))
.build();
}
private void verifyLoggedIn() {
- UserSession.get().checkLoggedIn();
+ userSession.checkLoggedIn();
}
/**
* Search for all tags, whatever issue resolution or user access rights
*/
public List<String> listTags(@Nullable String textQuery, int pageSize) {
- IssueQuery query = IssueQuery.builder()
+ IssueQuery query = IssueQuery.builder(userSession)
.checkAuthorization(false)
.build();
return issueIndex.listTags(query, textQuery, pageSize);
}
public List<String> listAuthors(@Nullable String textQuery, int pageSize) {
- IssueQuery query = IssueQuery.builder()
+ IssueQuery query = IssueQuery.builder(userSession)
.checkAuthorization(false)
.build();
return issueIndex.listAuthors(query, textQuery, pageSize);
DbSession session = dbClient.openSession(false);
try {
DefaultIssue issue = getByKeyForUpdate(session, issueKey).toDefaultIssue();
- IssueChangeContext context = IssueChangeContext.createUser(new Date(), UserSession.get().login());
+ IssueChangeContext context = IssueChangeContext.createUser(new Date(), userSession.login());
if (issueUpdater.setTags(issue, tags, context)) {
saveIssue(session, issue, context, null);
}
package org.sonar.server.issue;
-import com.google.common.base.Strings;
+import java.util.Collection;
+import java.util.Map;
+
import org.sonar.api.ServerSide;
import org.sonar.api.issue.Issue;
import org.sonar.api.issue.condition.Condition;
import org.sonar.core.issue.IssueUpdater;
import org.sonar.server.user.UserSession;
-import java.util.Collection;
-import java.util.Map;
+import com.google.common.base.Strings;
@ServerSide
public class SetSeverityAction extends Action {
public static final String KEY = "set_severity";
private final IssueUpdater issueUpdater;
+ private final UserSession userSession;
- public SetSeverityAction(IssueUpdater issueUpdater) {
+ public SetSeverityAction(IssueUpdater issueUpdater, UserSession userSession) {
super(KEY);
this.issueUpdater = issueUpdater;
+ this.userSession = userSession;
super.setConditions(new IsUnResolved(), new Condition() {
@Override
public boolean matches(Issue issue) {
}
private boolean isCurrentUserIssueAdmin(String projectKey) {
- return UserSession.get().hasProjectPermission(UserRole.ISSUE_ADMIN, projectKey);
+ return userSession.hasProjectPermission(UserRole.ISSUE_ADMIN, projectKey);
}
@Override
package org.sonar.server.issue;
-import com.google.common.base.Predicate;
-import com.google.common.base.Strings;
-import com.google.common.collect.Iterables;
+import java.util.Collection;
+import java.util.Map;
+
import org.apache.commons.lang.StringUtils;
import org.sonar.api.ServerSide;
import org.sonar.api.issue.Issue;
import org.sonar.core.issue.workflow.Transition;
import org.sonar.server.user.UserSession;
-import java.util.Collection;
-import java.util.Map;
+import com.google.common.base.Predicate;
+import com.google.common.base.Strings;
+import com.google.common.collect.Iterables;
@ServerSide
public class TransitionAction extends Action {
public static final String KEY = "do_transition";
private final IssueWorkflow workflow;
+ private final UserSession userSession;
- public TransitionAction(IssueWorkflow workflow) {
+ public TransitionAction(IssueWorkflow workflow, UserSession userSession) {
super(KEY);
this.workflow = workflow;
+ this.userSession = userSession;
}
@Override
private boolean canExecuteTransition(Issue issue, final String transition) {
final DefaultIssue defaultIssue = (DefaultIssue) issue;
- final UserSession userSession = UserSession.get();
return Iterables.find(workflow.outTransitions(issue), new Predicate<Transition>() {
@Override
public boolean apply(Transition input) {
package org.sonar.server.issue.filter;
import com.google.common.io.Resources;
+import java.util.List;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.RequestHandler;
import org.sonar.api.server.ws.Response;
import org.sonar.core.issue.db.IssueFilterDto;
import org.sonar.server.user.UserSession;
-import java.util.List;
-
public class AppAction implements RequestHandler {
private final IssueFilterService service;
private final IssueFilterWriter issueFilterWriter;
+ private final UserSession userSession;
- public AppAction(IssueFilterService service, IssueFilterWriter issueFilterWriter) {
+ public AppAction(IssueFilterService service, IssueFilterWriter issueFilterWriter, UserSession userSession) {
this.service = service;
this.issueFilterWriter = issueFilterWriter;
+ this.userSession = userSession;
}
void define(WebService.NewController controller) {
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession session = UserSession.get();
-
JsonWriter json = response.newJsonWriter();
json.beginObject();
Integer filterId = request.paramAsInt("id");
IssueFilterDto filter = null;
if (filterId != null && filterId >= 0) {
- filter = service.find((long) filterId, session);
+ filter = service.find((long) filterId, userSession);
}
// Permissions
- json.prop("canManageFilters", session.isLoggedIn());
- json.prop("canBulkChange", session.isLoggedIn());
+ json.prop("canManageFilters", userSession.isLoggedIn());
+ json.prop("canBulkChange", userSession.isLoggedIn());
// Selected filter
if (filter != null) {
- issueFilterWriter.write(session, filter, json);
+ issueFilterWriter.write(userSession, filter, json);
}
// Favorite filters, if logged in
- if (session.isLoggedIn()) {
- List<IssueFilterDto> favorites = service.findFavoriteFilters(session);
+ if (userSession.isLoggedIn()) {
+ List<IssueFilterDto> favorites = service.findFavoriteFilters(userSession);
json.name("favorites").beginArray();
for (IssueFilterDto favorite : favorites) {
json
public class FavoritesAction implements RequestHandler {
private final IssueFilterService service;
+ private final UserSession userSession;
- public FavoritesAction(IssueFilterService service) {
+ public FavoritesAction(IssueFilterService service, UserSession userSession) {
this.service = service;
+ this.userSession = userSession;
}
void define(WebService.NewController controller) {
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession session = UserSession.get();
JsonWriter json = response.newJsonWriter();
json.beginObject().name("favoriteFilters").beginArray();
- if (session.isLoggedIn()) {
- for (IssueFilterDto favorite : service.findFavoriteFilters(session)) {
+ if (userSession.isLoggedIn()) {
+ for (IssueFilterDto favorite : service.findFavoriteFilters(userSession)) {
json.beginObject();
json.prop("id", favorite.getId());
json.prop("name", favorite.getName());
private final IssueFilterService service;
private final IssueFilterWriter issueFilterWriter;
+ private final UserSession userSession;
- public ShowAction(IssueFilterService service, IssueFilterWriter issueFilterWriter) {
+ public ShowAction(IssueFilterService service, IssueFilterWriter issueFilterWriter, UserSession userSession) {
this.service = service;
this.issueFilterWriter = issueFilterWriter;
+ this.userSession = userSession;
}
void define(WebService.NewController controller) {
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession session = UserSession.get();
- IssueFilterDto filter = service.find(request.mandatoryParamAsLong("id"), session);
+ IssueFilterDto filter = service.find(request.mandatoryParamAsLong("id"), userSession);
JsonWriter json = response.newJsonWriter();
json.beginObject();
- issueFilterWriter.write(session, filter, json);
+ issueFilterWriter.write(userSession, filter, json);
json.endObject();
json.close();
}
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.regex.Pattern;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
import org.apache.commons.lang.BooleanUtils;
import org.apache.commons.lang.StringUtils;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.sonar.server.user.UserSession;
import org.sonar.server.view.index.ViewIndexDefinition;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Date;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.SortedSet;
-import java.util.regex.Pattern;
-
import static com.google.common.collect.Lists.newArrayList;
/**
private final Sorting sorting;
private final System2 system;
+ private final UserSession userSession;
- public IssueIndex(EsClient client, System2 system) {
+ public IssueIndex(EsClient client, System2 system, UserSession userSession) {
super(client);
this.system = system;
+ this.userSession = userSession;
this.sorting = new Sorting();
this.sorting.add(IssueQuery.SORT_BY_ASSIGNEE, IssueIndexDefinition.FIELD_ISSUE_ASSIGNEE);
this.sorting.add(IssueQuery.SORT_BY_STATUS, IssueIndexDefinition.FIELD_ISSUE_STATUS);
*/
@CheckForNull
public IssueDoc getNullableByKey(String key) {
- SearchResult<IssueDoc> result = search(IssueQuery.builder().issueKeys(newArrayList(key)).build(), new SearchOptions());
+ SearchResult<IssueDoc> result = search(IssueQuery.builder(userSession).issueKeys(newArrayList(key)).build(), new SearchOptions());
if (result.getTotal() == 1) {
return result.getDocs().get(0);
}
}
private void addAssignedToMeFacetIfNeeded(SearchRequestBuilder builder, SearchOptions options, IssueQuery query, Map<String, FilterBuilder> filters, QueryBuilder queryBuilder) {
- String login = UserSession.get().login();
+ String login = userSession.login();
if (!options.getFacets().contains(IssueFilterParameters.FACET_ASSIGNED_TO_ME) || StringUtils.isEmpty(login)) {
return;
*/
public Iterator<IssueDoc> selectIssuesForBatch(ComponentDto component) {
BoolFilterBuilder filter = FilterBuilders.boolFilter()
- .must(createAuthorizationFilter(true, UserSession.get().login(), UserSession.get().userGroups()))
+ .must(createAuthorizationFilter(true, userSession.login(), userSession.userGroups()))
.mustNot(FilterBuilders.termsFilter(IssueIndexDefinition.FIELD_ISSUE_STATUS, Issue.STATUS_CLOSED));
switch (component.scope()) {
package org.sonar.server.issue.ws;
+import java.util.List;
import org.sonar.api.ServerSide;
import org.sonar.api.issue.Issue;
import org.sonar.api.issue.action.Action;
import org.sonar.server.issue.IssueService;
import org.sonar.server.user.UserSession;
-import java.util.List;
-
import static com.google.common.collect.Lists.newArrayList;
@ServerSide
private final IssueService issueService;
private final ActionService actionService;
+ private final UserSession userSession;
- public IssueActionsWriter(IssueService issueService, ActionService actionService) {
+ public IssueActionsWriter(IssueService issueService, ActionService actionService, UserSession userSession) {
this.issueService = issueService;
this.actionService = actionService;
+ this.userSession = userSession;
}
public void writeTransitions(Issue issue, JsonWriter json) {
json.name("transitions").beginArray();
- if (UserSession.get().isLoggedIn()) {
+ if (userSession.isLoggedIn()) {
for (Transition transition : issueService.listTransitions(issue)) {
json.value(transition.key());
}
private List<String> actions(Issue issue) {
List<String> actions = newArrayList();
- String login = UserSession.get().login();
+ String login = userSession.login();
if (login != null) {
actions.add("comment");
if (issue.resolution() == null) {
}
actions.add("plan");
String projectUuid = issue.projectUuid();
- if (projectUuid != null && UserSession.get().hasProjectPermissionByUuid(UserRole.ISSUE_ADMIN, projectUuid)) {
+ if (projectUuid != null && userSession.hasProjectPermissionByUuid(UserRole.ISSUE_ADMIN, projectUuid)) {
actions.add("set_severity");
}
for (Action action : actionService.listAvailableActions(issue)) {
package org.sonar.server.issue.ws;
import com.google.common.io.Resources;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
import org.sonar.api.i18n.I18n;
import org.sonar.api.issue.ActionPlan;
import org.sonar.api.issue.Issue;
import org.sonar.server.rule.RuleService;
import org.sonar.server.user.UserSession;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
-
import static com.google.common.collect.Maps.newHashMap;
public class IssueShowAction implements BaseIssuesWsAction {
private final RuleService ruleService;
private final I18n i18n;
private final Durations durations;
+ private final UserSession userSession;
public IssueShowAction(DbClient dbClient, IssueService issueService, IssueChangelogService issueChangelogService, IssueCommentService commentService,
- IssueActionsWriter actionsWriter, ActionPlanService actionPlanService, UserFinder userFinder, DebtModelService debtModel, RuleService ruleService,
- I18n i18n, Durations durations) {
+ IssueActionsWriter actionsWriter, ActionPlanService actionPlanService, UserFinder userFinder, DebtModelService debtModel, RuleService ruleService,
+ I18n i18n, Durations durations, UserSession userSession) {
this.dbClient = dbClient;
this.issueService = issueService;
this.issueChangelogService = issueChangelogService;
this.ruleService = ruleService;
this.i18n = i18n;
this.durations = durations;
+ this.userSession = userSession;
}
@Override
private void writeIssue(DbSession session, Issue issue, JsonWriter json) {
String actionPlanKey = issue.actionPlanKey();
- ActionPlan actionPlan = actionPlanKey != null ? actionPlanService.findByKey(actionPlanKey, UserSession.get()) : null;
+ ActionPlan actionPlan = actionPlanKey == null ? null : actionPlanService.findByKey(actionPlanKey, userSession);
Duration debt = issue.debt();
Rule rule = ruleService.getNonNullByKey(issue.ruleKey());
Date updateDate = issue.updateDate();
.prop("componentEnabled", component.isEnabled())
.prop("project", project.key())
.prop("projectName", projectName)
- //TODO replace subProject names by parentProject
+ // TODO replace subProject names by parentProject
.prop("subProject", parentProjectKey)
.prop("subProjectName", parentProjectName);
}
private void writeComments(Issue issue, JsonWriter json) {
json.name("comments").beginArray();
- String login = UserSession.get().login();
+ String login = userSession.login();
Map<String, User> usersByLogin = newHashMap();
List<DefaultIssueComment> comments = commentService.findComments(issue.key());
.prop("creationDate", DateUtils.formatDateTime(issue.creationDate()))
.prop("fCreationDate", formatDate(issue.creationDate()))
.name("diffs").beginArray()
- .value(i18n.message(UserSession.get().locale(), "created", null))
+ .value(i18n.message(userSession.locale(), "created", null))
.endArray()
.endObject();
@CheckForNull
private String formatDate(@Nullable Date date) {
if (date != null) {
- return i18n.formatDateTime(UserSession.get().locale(), date);
+ return i18n.formatDateTime(userSession.locale(), date);
}
return null;
}
@CheckForNull
private String formatAgeDate(@Nullable Date date) {
if (date != null) {
- return i18n.ageFromNow(UserSession.get().locale(), date);
+ return i18n.ageFromNow(userSession.locale(), date);
}
return null;
}
import com.google.common.collect.Multimap;
import com.google.common.collect.Sets;
import com.google.common.io.Resources;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Date;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
import org.apache.commons.lang.BooleanUtils;
import org.sonar.api.i18n.I18n;
import org.sonar.api.issue.ActionPlan;
import org.sonar.server.rule.RuleService;
import org.sonar.server.user.UserSession;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Date;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Maps.newHashMap;
import static com.google.common.collect.Sets.newHashSet;
private final I18n i18n;
private final Durations durations;
private final Languages languages;
+ private final UserSession userSession;
public SearchAction(DbClient dbClient, IssueService service, IssueActionsWriter actionsWriter, IssueQueryService issueQueryService,
- RuleService ruleService, ActionPlanService actionPlanService, UserFinder userFinder, I18n i18n, Durations durations, Languages languages) {
+ RuleService ruleService, ActionPlanService actionPlanService, UserFinder userFinder, I18n i18n, Durations durations, Languages languages,
+ UserSession userSession) {
this.dbClient = dbClient;
this.service = service;
this.actionsWriter = actionsWriter;
this.i18n = i18n;
this.durations = durations;
this.languages = languages;
+ this.userSession = userSession;
}
@Override
collectFacetsData(request, result, projectUuids, componentUuids, userLogins, actionPlanKeys);
- UserSession userSession = UserSession.get();
if (userSession.isLoggedIn()) {
userLogins.add(userSession.login());
}
assignees.remove(IssueQueryService.LOGIN_MYSELF);
}
addMandatoryFacetValues(results, IssueFilterParameters.ASSIGNEES, assignees);
- addMandatoryFacetValues(results, IssueFilterParameters.FACET_ASSIGNED_TO_ME, Arrays.asList(UserSession.get().login()));
+ addMandatoryFacetValues(results, IssueFilterParameters.FACET_ASSIGNED_TO_ME, Arrays.asList(userSession.login()));
addMandatoryFacetValues(results, IssueFilterParameters.REPORTERS, request.paramAsStrings(IssueFilterParameters.REPORTERS));
addMandatoryFacetValues(results, IssueFilterParameters.RULES, request.paramAsStrings(IssueFilterParameters.RULES));
addMandatoryFacetValues(results, IssueFilterParameters.LANGUAGES, request.paramAsStrings(IssueFilterParameters.LANGUAGES));
private void writeIssueComments(Collection<DefaultIssueComment> issueComments, Map<String, User> usersByLogin, JsonWriter json) {
if (!issueComments.isEmpty()) {
json.name("comments").beginArray();
- String login = UserSession.get().login();
+ String login = userSession.login();
for (IssueComment comment : issueComments) {
String userLogin = comment.userLogin();
User user = userLogin != null ? usersByLogin.get(userLogin) : null;
@CheckForNull
private String formatDate(@Nullable Date date) {
if (date != null) {
- return i18n.formatDateTime(UserSession.get().locale(), date);
+ return i18n.formatDateTime(userSession.locale(), date);
}
return null;
}
@CheckForNull
private String formatAgeDate(@Nullable Date date) {
if (date != null) {
- return i18n.ageFromNow(UserSession.get().locale(), date);
+ return i18n.ageFromNow(userSession.locale(), date);
}
return null;
}
package org.sonar.server.permission;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+
import org.sonar.api.ServerSide;
import org.sonar.api.security.DefaultGroups;
import org.sonar.api.web.UserRole;
import org.sonar.server.issue.index.IssueAuthorizationIndexer;
import org.sonar.server.user.UserSession;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
-import java.util.List;
-import java.util.Map;
-
/**
* Used by ruby code <pre>Internal.permissions</pre>
*/
private final PermissionFacade permissionFacade;
private final PermissionFinder finder;
private final IssueAuthorizationIndexer issueAuthorizationIndexer;
+ private final UserSession userSession;
public InternalPermissionService(DbClient dbClient, PermissionFacade permissionFacade, PermissionFinder finder,
- IssueAuthorizationIndexer issueAuthorizationIndexer) {
+ IssueAuthorizationIndexer issueAuthorizationIndexer, UserSession userSession) {
this.dbClient = dbClient;
this.permissionFacade = permissionFacade;
this.finder = finder;
this.issueAuthorizationIndexer = issueAuthorizationIndexer;
+ this.userSession = userSession;
}
public List<String> globalPermissions() {
}
public void applyDefaultPermissionTemplate(final String componentKey) {
- UserSession.get().checkLoggedIn();
+ userSession.checkLoggedIn();
DbSession session = dbClient.openSession(false);
try {
if (provisioned == null) {
checkProjectAdminPermission(componentKey);
} else {
- UserSession.get().checkGlobalPermission(GlobalPermissions.PROVISIONING);
+ userSession.checkGlobalPermission(GlobalPermissions.PROVISIONING);
}
permissionFacade.grantDefaultRoles(session, component.getId(), component.qualifier());
session.commit();
}
public void applyPermissionTemplate(Map<String, Object> params) {
- UserSession.get().checkLoggedIn();
+ userSession.checkLoggedIn();
ApplyPermissionTemplateQuery query = ApplyPermissionTemplateQuery.buildFromParams(params);
applyPermissionTemplate(query);
}
checkProjectAdminPermission(query.getSelectedComponents().get(0));
} else {
checkProjectAdminPermission(null);
- UserSession.get().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
}
for (String componentKey : query.getSelectedComponents()) {
}
private void applyChange(Operation operation, PermissionChange change, DbSession session) {
- UserSession.get().checkLoggedIn();
+ userSession.checkLoggedIn();
change.validate();
boolean changed;
if (change.user() != null) {
private void checkProjectAdminPermission(@Nullable String projectKey) {
if (projectKey == null) {
- UserSession.get().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
} else {
- if (!UserSession.get().hasGlobalPermission(GlobalPermissions.SYSTEM_ADMIN) && !UserSession.get().hasProjectPermission(UserRole.ADMIN, projectKey)) {
+ if (!userSession.hasGlobalPermission(GlobalPermissions.SYSTEM_ADMIN) && !userSession.hasProjectPermission(UserRole.ADMIN, projectKey)) {
throw new ForbiddenException("Insufficient privileges");
}
}
import org.sonar.core.user.UserDao;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.exceptions.NotFoundException;
-import org.sonar.server.user.UserSession;
import javax.annotation.CheckForNull;
import javax.annotation.Nullable;
import java.util.Map;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
+import org.sonar.server.user.UserSession;
/**
* Used by ruby code <pre>Internal.permission_templates</pre>
private final PermissionTemplateDao permissionTemplateDao;
private final UserDao userDao;
private final PermissionFinder finder;
+ private final UserSession userSession;
- public InternalPermissionTemplateService(MyBatis myBatis, PermissionTemplateDao permissionTemplateDao, UserDao userDao, PermissionFinder finder) {
+ public InternalPermissionTemplateService(MyBatis myBatis, PermissionTemplateDao permissionTemplateDao, UserDao userDao, PermissionFinder finder, UserSession userSession) {
this.myBatis = myBatis;
this.permissionTemplateDao = permissionTemplateDao;
this.userDao = userDao;
this.finder = finder;
+ this.userSession = userSession;
}
public UserWithPermissionQueryResult findUsersWithPermissionTemplate(Map<String, Object> params) {
@CheckForNull
public PermissionTemplate selectPermissionTemplate(String templateKey) {
- PermissionTemplateUpdater.checkSystemAdminUser();
+ PermissionTemplateUpdater.checkSystemAdminUser(userSession);
PermissionTemplateDto permissionTemplateDto = permissionTemplateDao.selectPermissionTemplate(templateKey);
return PermissionTemplate.create(permissionTemplateDto);
}
}
public List<PermissionTemplate> selectAllPermissionTemplates(@Nullable String componentKey) {
- PermissionTemplateUpdater.checkProjectAdminUser(componentKey);
+ PermissionTemplateUpdater.checkProjectAdminUser(componentKey, userSession);
List<PermissionTemplate> permissionTemplates = Lists.newArrayList();
List<PermissionTemplateDto> permissionTemplateDtos = permissionTemplateDao.selectAllPermissionTemplates();
if (permissionTemplateDtos != null) {
}
public PermissionTemplate createPermissionTemplate(String name, @Nullable String description, @Nullable String keyPattern) {
- PermissionTemplateUpdater.checkSystemAdminUser();
+ PermissionTemplateUpdater.checkSystemAdminUser(userSession);
validateTemplateName(null, name);
validateKeyPattern(keyPattern);
PermissionTemplateDto permissionTemplateDto = permissionTemplateDao.createPermissionTemplate(name, description, keyPattern);
}
public void updatePermissionTemplate(Long templateId, String newName, @Nullable String newDescription, @Nullable String newKeyPattern) {
- PermissionTemplateUpdater.checkSystemAdminUser();
+ PermissionTemplateUpdater.checkSystemAdminUser(userSession);
validateTemplateName(templateId, newName);
validateKeyPattern(newKeyPattern);
permissionTemplateDao.updatePermissionTemplate(templateId, newName, newDescription, newKeyPattern);
}
public void deletePermissionTemplate(Long templateId) {
- PermissionTemplateUpdater.checkSystemAdminUser();
+ PermissionTemplateUpdater.checkSystemAdminUser(userSession);
permissionTemplateDao.deletePermissionTemplate(templateId);
}
public void addUserPermission(String templateKey, String permission, String userLogin) {
- PermissionTemplateUpdater updater = new PermissionTemplateUpdater(templateKey, permission, userLogin, permissionTemplateDao, userDao) {
+ PermissionTemplateUpdater updater = new PermissionTemplateUpdater(templateKey, permission, userLogin, permissionTemplateDao, userDao, userSession) {
@Override
protected void doExecute(Long templateId, String permission) {
Long userId = getUserId();
}
public void removeUserPermission(String templateKey, String permission, String userLogin) {
- PermissionTemplateUpdater updater = new PermissionTemplateUpdater(templateKey, permission, userLogin, permissionTemplateDao, userDao) {
+ PermissionTemplateUpdater updater = new PermissionTemplateUpdater(templateKey, permission, userLogin, permissionTemplateDao, userDao, userSession) {
@Override
protected void doExecute(Long templateId, String permission) {
Long userId = getUserId();
}
public void addGroupPermission(String templateKey, String permission, String groupName) {
- PermissionTemplateUpdater updater = new PermissionTemplateUpdater(templateKey, permission, groupName, permissionTemplateDao, userDao) {
+ PermissionTemplateUpdater updater = new PermissionTemplateUpdater(templateKey, permission, groupName, permissionTemplateDao, userDao, userSession) {
@Override
protected void doExecute(Long templateId, String permission) {
Long groupId = getGroupId();
}
public void removeGroupPermission(String templateKey, String permission, String groupName) {
- PermissionTemplateUpdater updater = new PermissionTemplateUpdater(templateKey, permission, groupName, permissionTemplateDao, userDao) {
+ PermissionTemplateUpdater updater = new PermissionTemplateUpdater(templateKey, permission, groupName, permissionTemplateDao, userDao, userSession) {
@Override
protected void doExecute(Long templateId, String permission) {
Long groupId = getGroupId();
}
public void removeGroupFromTemplates(String groupName) {
- UserSession.get().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
DbSession session = myBatis.openSession(false);
try {
GroupDto group = userDao.selectGroupByName(groupName, session);
private final String updatedReference;
private final PermissionTemplateDao permissionTemplateDao;
private final UserDao userDao;
+ private final UserSession userSession;
- PermissionTemplateUpdater(String templateKey, String permission, String updatedReference, PermissionTemplateDao permissionTemplateDao, UserDao userDao) {
+ PermissionTemplateUpdater(String templateKey, String permission, String updatedReference, PermissionTemplateDao permissionTemplateDao, UserDao userDao, UserSession userSession) {
this.templateKey = templateKey;
this.permission = permission;
this.updatedReference = updatedReference;
this.permissionTemplateDao = permissionTemplateDao;
this.userDao = userDao;
+ this.userSession = userSession;
}
void executeUpdate() {
- checkSystemAdminUser();
+ checkSystemAdminUser(userSession);
Long templateId = getTemplateId(templateKey);
validatePermission(permission);
doExecute(templateId, permission);
return groupDto.getId();
}
- static void checkSystemAdminUser() {
- checkProjectAdminUser(null);
+ static void checkSystemAdminUser(UserSession userSession) {
+ checkProjectAdminUser(null, userSession);
}
- static void checkProjectAdminUser(@Nullable String componentKey) {
- UserSession currentSession = UserSession.get();
- currentSession.checkLoggedIn();
+ static void checkProjectAdminUser(@Nullable String componentKey, UserSession userSession) {
+ userSession.checkLoggedIn();
if (componentKey == null) {
- currentSession.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
- } else {
- if (!currentSession.hasGlobalPermission(GlobalPermissions.SYSTEM_ADMIN) && !currentSession.hasProjectPermission(UserRole.ADMIN, componentKey)) {
- throw new ForbiddenException("Insufficient privileges");
- }
+ userSession.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ } else if (!userSession.hasGlobalPermission(GlobalPermissions.SYSTEM_ADMIN) && !userSession.hasProjectPermission(UserRole.ADMIN, componentKey)) {
+ throw new ForbiddenException("Insufficient privileges");
}
}
*/
package org.sonar.server.platform;
-import com.google.common.collect.Lists;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+import java.util.Properties;
+
+import javax.annotation.Nullable;
+
import org.sonar.api.config.EmailSettings;
import org.sonar.api.issue.action.Actions;
import org.sonar.api.profiles.AnnotationProfileParser;
import org.sonar.server.user.GroupMembershipService;
import org.sonar.server.user.NewUserNotifier;
import org.sonar.server.user.SecurityRealmFactory;
+import org.sonar.server.user.ThreadLocalUserSession;
import org.sonar.server.user.UserUpdater;
import org.sonar.server.user.db.GroupDao;
import org.sonar.server.user.db.UserDao;
import org.sonar.server.ws.ListingWs;
import org.sonar.server.ws.WebServiceEngine;
-import javax.annotation.Nullable;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-import java.util.Properties;
+import com.google.common.collect.Lists;
class ServerComponents {
// rack bridges
PlatformRackBridge.class,
+ // user session
+ ThreadLocalUserSession.class,
+
// DB
DbClient.class,
startupContainer.addSingleton(RegisterIssueFilters.class);
startupContainer.addSingleton(RenameIssueWidgets.class);
- DoPrivileged.execute(new DoPrivileged.Task() {
+ DoPrivileged.execute(new DoPrivileged.Task(startupContainer.getComponentByType(ThreadLocalUserSession.class)) {
@Override
protected void doPrivileged() {
startupContainer.getComponentByType(IndexSynchronizer.class).executeDeprecated();
*/
package org.sonar.server.platform.ws;
+import java.io.IOException;
+import java.net.HttpURLConnection;
+import java.util.Date;
+import java.util.Locale;
import org.apache.commons.lang.LocaleUtils;
import org.sonar.api.platform.Server;
import org.sonar.api.server.ws.Request;
import org.sonar.core.i18n.DefaultI18n;
import org.sonar.server.user.UserSession;
-import java.io.IOException;
-import java.net.HttpURLConnection;
-import java.util.Date;
-import java.util.Locale;
-
public class L10nWs implements WebService {
private final DefaultI18n i18n;
private final Server server;
+ private final UserSession userSession;
- public L10nWs(DefaultI18n i18n, Server server) {
+ public L10nWs(DefaultI18n i18n, Server server, UserSession userSession) {
this.i18n = i18n;
this.server = server;
+ this.userSession = userSession;
}
@Override
response.stream().setStatus(HttpURLConnection.HTTP_NOT_MODIFIED).output().close();
} else {
- Locale locale = UserSession.get().locale();
+ Locale locale = userSession.locale();
String localeParam = request.param("locale");
if (localeParam != null) {
locale = LocaleUtils.toLocale(localeParam);
package org.sonar.server.platform.ws;
import java.util.Map;
-
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
public class SystemInfoWsAction implements SystemWsAction {
private final Monitor[] monitors;
+ private final UserSession userSession;
- public SystemInfoWsAction(Monitor... monitors) {
+ public SystemInfoWsAction(UserSession userSession, Monitor... monitors) {
+ this.userSession = userSession;
this.monitors = monitors;
}
@Override
public void handle(Request request, Response response) {
- UserSession.get().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
JsonWriter json = response.newJsonWriter();
writeJson(json);
json.close();
private final PluginDownloader pluginDownloader;
private final ServerPluginRepository pluginRepository;
+ private final UserSession userSession;
- public CancelAllPluginsWsAction(PluginDownloader pluginDownloader, ServerPluginRepository pluginRepository) {
+ public CancelAllPluginsWsAction(PluginDownloader pluginDownloader, ServerPluginRepository pluginRepository, UserSession userSession) {
this.pluginDownloader = pluginDownloader;
this.pluginRepository = pluginRepository;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
pluginDownloader.cancelDownloads();
pluginRepository.cancelUninstalls();
private final UpdateCenterMatrixFactory updateCenterFactory;
private final PluginDownloader pluginDownloader;
+ private final UserSession userSession;
public InstallPluginsWsAction(UpdateCenterMatrixFactory updateCenterFactory,
- PluginDownloader pluginDownloader) {
+ PluginDownloader pluginDownloader, UserSession userSession) {
this.updateCenterFactory = updateCenterFactory;
this.pluginDownloader = pluginDownloader;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
String key = request.mandatoryParam(PARAM_KEY);
PluginUpdate pluginUpdate = findAvailablePluginByKey(key);
pluginDownloader.download(key, pluginUpdate.getRelease().getVersion());
private static final String PARAM_KEY = "key";
private final ServerPluginRepository pluginRepository;
+ private final UserSession userSession;
- public UninstallPluginsWsAction(ServerPluginRepository pluginRepository) {
+ public UninstallPluginsWsAction(ServerPluginRepository pluginRepository, UserSession userSession) {
this.pluginRepository = pluginRepository;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
String key = request.mandatoryParam(PARAM_KEY);
ensurePluginIsInstalled(key);
pluginRepository.uninstall(key);
private final UpdateCenterMatrixFactory updateCenterFactory;
private final PluginDownloader pluginDownloader;
+ private final UserSession userSession;
- public UpdatePluginsWsAction(UpdateCenterMatrixFactory updateCenterFactory, PluginDownloader pluginDownloader) {
+ public UpdatePluginsWsAction(UpdateCenterMatrixFactory updateCenterFactory, PluginDownloader pluginDownloader, UserSession userSession) {
this.updateCenterFactory = updateCenterFactory;
this.pluginDownloader = pluginDownloader;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
String key = request.mandatoryParam(PARAM_KEY);
PluginUpdate pluginUpdate = findPluginUpdateByKey(key);
pluginDownloader.download(key, pluginUpdate.getRelease().getVersion());
*/
package org.sonar.server.qualitygate;
-import com.google.common.base.Predicate;
-import com.google.common.base.Strings;
-import com.google.common.collect.Collections2;
+import java.util.Collection;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+
import org.apache.commons.lang.BooleanUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.ibatis.session.SqlSession;
import org.sonar.core.qualitygate.db.QualityGateDao;
import org.sonar.core.qualitygate.db.QualityGateDto;
import org.sonar.server.component.db.ComponentDao;
-import org.sonar.server.exceptions.*;
+import org.sonar.server.exceptions.BadRequestException;
+import org.sonar.server.exceptions.Errors;
+import org.sonar.server.exceptions.ForbiddenException;
+import org.sonar.server.exceptions.Message;
+import org.sonar.server.exceptions.NotFoundException;
+import org.sonar.server.exceptions.ServerException;
import org.sonar.server.user.UserSession;
import org.sonar.server.util.Validation;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
-import java.util.Collection;
+import com.google.common.base.Predicate;
+import com.google.common.base.Strings;
+import com.google.common.collect.Collections2;
/**
* @since 4.3
public static final String SONAR_QUALITYGATE_PROPERTY = "sonar.qualitygate";
private final QualityGateDao dao;
-
private final QualityGateConditionDao conditionDao;
-
private final MetricFinder metricFinder;
-
private final PropertiesDao propertiesDao;
-
private final ComponentDao componentDao;
-
private final MyBatis myBatis;
+ private final UserSession userSession;
public QualityGates(QualityGateDao dao, QualityGateConditionDao conditionDao, MetricFinder metricFinder, PropertiesDao propertiesDao, ComponentDao componentDao,
- MyBatis myBatis) {
+ MyBatis myBatis, UserSession userSession) {
this.dao = dao;
this.conditionDao = conditionDao;
this.metricFinder = metricFinder;
this.propertiesDao = propertiesDao;
this.componentDao = componentDao;
this.myBatis = myBatis;
+ this.userSession = userSession;
}
public QualityGateDto create(String name) {
- checkPermission(UserSession.get());
+ checkPermission();
validateQualityGate(null, name);
QualityGateDto newQualityGate = new QualityGateDto().setName(name);
dao.insert(newQualityGate);
}
public QualityGateDto rename(long idToRename, String name) {
- checkPermission(UserSession.get());
+ checkPermission();
QualityGateDto toRename = getNonNullQgate(idToRename);
validateQualityGate(idToRename, name);
toRename.setName(name);
}
public QualityGateDto copy(long sourceId, String destinationName) {
- checkPermission(UserSession.get());
+ checkPermission();
getNonNullQgate(sourceId);
validateQualityGate(null, destinationName);
QualityGateDto destinationGate = new QualityGateDto().setName(destinationName);
}
public void delete(long idToDelete) {
- checkPermission(UserSession.get());
+ checkPermission();
QualityGateDto qGate = getNonNullQgate(idToDelete);
SqlSession session = myBatis.openSession(false);
try {
}
public void setDefault(@Nullable Long idToUseAsDefault) {
- checkPermission(UserSession.get());
+ checkPermission();
if (idToUseAsDefault == null) {
propertiesDao.deleteGlobalProperty(SONAR_QUALITYGATE_PROPERTY);
} else {
public QualityGateConditionDto createCondition(long qGateId, String metricKey, String operator,
@Nullable String warningThreshold, @Nullable String errorThreshold, @Nullable Integer period) {
- checkPermission(UserSession.get());
+ checkPermission();
getNonNullQgate(qGateId);
Metric metric = getNonNullMetric(metricKey);
validateCondition(metric, operator, warningThreshold, errorThreshold, period);
public QualityGateConditionDto updateCondition(long condId, String metricKey, String operator,
@Nullable String warningThreshold, @Nullable String errorThreshold, @Nullable Integer period) {
- checkPermission(UserSession.get());
+ checkPermission();
QualityGateConditionDto condition = getNonNullCondition(condId);
Metric metric = getNonNullMetric(metricKey);
validateCondition(metric, operator, warningThreshold, errorThreshold, period);
}
public void deleteCondition(Long condId) {
- checkPermission(UserSession.get());
+ checkPermission();
conditionDao.delete(getNonNullCondition(condId));
}
DbSession session = myBatis.openSession(false);
try {
getNonNullQgate(qGateId);
- checkPermission(UserSession.get(), projectId, session);
+ checkPermission(projectId, session);
propertiesDao.setProperty(new PropertyDto().setKey(SONAR_QUALITYGATE_PROPERTY).setResourceId(projectId).setValue(qGateId.toString()));
} finally {
MyBatis.closeQuietly(session);
DbSession session = myBatis.openSession(false);
try {
getNonNullQgate(qGateId);
- checkPermission(UserSession.get(), projectId, session);
+ checkPermission(projectId, session);
propertiesDao.deleteProjectProperty(SONAR_QUALITYGATE_PROPERTY, projectId);
} finally {
MyBatis.closeQuietly(session);
public boolean currentUserHasWritePermission() {
boolean hasWritePermission = false;
try {
- checkPermission(UserSession.get());
+ checkPermission();
hasWritePermission = true;
} catch (ServerException unallowed) {
// Ignored
}
- private void checkPermission(UserSession userSession) {
+ private void checkPermission() {
userSession.checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
}
- private void checkPermission(UserSession userSession, Long projectId, DbSession session) {
+ private void checkPermission(Long projectId, DbSession session) {
ComponentDto project = componentDao.getById(projectId, session);
if (!userSession.hasGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN) && !userSession.hasProjectPermission(UserRole.ADMIN, project.key())) {
throw new ForbiddenException("Insufficient privileges");
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import org.sonar.server.user.UserSession;
@ServerSide
public class QProfileLoader {
private final DbClient db;
private final IndexClient index;
+ private final UserSession userSession;
- public QProfileLoader(DbClient db, IndexClient index) {
+ public QProfileLoader(DbClient db, IndexClient index, UserSession userSession) {
this.db = db;
this.index = index;
+ this.userSession = userSession;
}
/**
.setQProfileKey(key)
.setActivation(true)
.setStatuses(Lists.newArrayList(RuleStatus.DEPRECATED)),
- new QueryContext().setLimit(0)).getTotal();
+ new QueryContext(userSession).setLimit(0)).getTotal();
}
}
package org.sonar.server.qualityprofile;
-import com.google.common.collect.Lists;
-import com.google.common.collect.Maps;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.CheckForNull;
+
import org.sonar.api.ServerSide;
import org.sonar.api.component.Component;
import org.sonar.api.web.UserRole;
import org.sonar.server.db.DbClient;
import org.sonar.server.user.UserSession;
-import javax.annotation.CheckForNull;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
@ServerSide
public class QProfileProjectLookup {
private final DbClient db;
+ private final UserSession userSession;
- public QProfileProjectLookup(DbClient db) {
+ public QProfileProjectLookup(DbClient db, UserSession userSession) {
this.db = db;
+ this.userSession = userSession;
}
public List<Component> projects(int profileId) {
componentsByKeys.put(component.key(), component);
}
- UserSession userSession = UserSession.get();
List<Component> result = Lists.newArrayList();
Collection<String> authorizedProjectKeys = db.authorizationDao().selectAuthorizedRootProjectsKeys(userSession.userId(), UserRole.USER);
for (Map.Entry<String, Component> entry : componentsByKeys.entrySet()) {
*/
package org.sonar.server.qualityprofile;
+import java.io.Reader;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.search.SearchHit;
import org.sonar.api.ServerSide;
import org.sonar.server.search.Result;
import org.sonar.server.user.UserSession;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
-import java.io.Reader;
-import java.io.StringReader;
-import java.io.StringWriter;
-import java.io.Writer;
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-
@ServerSide
public class QProfileService {
private final QProfileCopier copier;
private final QProfileReset reset;
private final QProfileExporters exporters;
+ private final UserSession userSession;
public QProfileService(DbClient db, ActivityIndex activityIndex, RuleActivator ruleActivator, QProfileFactory factory,
- QProfileBackuper backuper, QProfileCopier copier, QProfileReset reset, QProfileExporters exporters) {
+ QProfileBackuper backuper, QProfileCopier copier, QProfileReset reset, QProfileExporters exporters,
+ UserSession userSession) {
this.db = db;
this.activityIndex = activityIndex;
this.ruleActivator = ruleActivator;
this.copier = copier;
this.reset = reset;
this.exporters = exporters;
+ this.userSession = userSession;
}
public QProfileResult create(QProfileName name, @Nullable Map<String, String> xmlQProfilesByPlugin) {
}
private void verifyAdminPermission() {
- UserSession.get().checkLoggedIn();
- UserSession.get().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSession.checkLoggedIn();
+ userSession.checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
}
public Result<QProfileActivity> searchActivities(QProfileActivityQuery query, SearchOptions options) {
package org.sonar.server.qualityprofile;
-import com.google.common.base.Strings;
+import java.util.List;
+
+import javax.annotation.CheckForNull;
+
import org.sonar.api.ServerSide;
import org.sonar.api.component.Component;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.user.UserSession;
import org.sonar.server.util.Validation;
-import javax.annotation.CheckForNull;
-
-import java.util.List;
+import com.google.common.base.Strings;
/**
* Use {@link org.sonar.server.qualityprofile.QProfileService} instead
private final QProfileProjectOperations projectOperations;
private final QProfileProjectLookup projectLookup;
private final QProfileLookup profileLookup;
+ private final UserSession userSession;
public QProfiles(QProfileProjectOperations projectOperations, QProfileProjectLookup projectLookup,
- QProfileLookup profileLookup) {
+ QProfileLookup profileLookup, UserSession userSession) {
this.projectOperations = projectOperations;
this.projectLookup = projectLookup;
this.profileLookup = profileLookup;
+ this.userSession = userSession;
}
public List<QProfile> allProfiles() {
}
public void addProject(String profileKey, String projectUuid) {
- projectOperations.addProject(profileKey, projectUuid, UserSession.get());
+ projectOperations.addProject(profileKey, projectUuid, userSession);
}
public void removeProject(String profileKey, String projectUuid) {
- projectOperations.removeProject(profileKey, projectUuid, UserSession.get());
+ projectOperations.removeProject(profileKey, projectUuid, userSession);
}
public void removeProjectByLanguage(String language, long projectId) {
- projectOperations.removeProject(language, projectId, UserSession.get());
+ projectOperations.removeProject(language, projectId, userSession);
}
public void removeAllProjects(String profileKey) {
- projectOperations.removeAllProjects(profileKey, UserSession.get());
+ projectOperations.removeAllProjects(profileKey, userSession);
}
private void checkProfileNameParam(String name) {
import org.sonar.server.search.IndexClient;
import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
+import org.sonar.server.user.UserSession;
import org.sonar.server.util.TypeValidations;
import javax.annotation.CheckForNull;
private final RuleActivatorContextFactory contextFactory;
private final IndexClient index;
private final ActivityService activityService;
+ private final UserSession userSession;
public RuleActivator(DbClient db, IndexClient index,
RuleActivatorContextFactory contextFactory, TypeValidations typeValidations,
- ActivityService activityService) {
+ ActivityService activityService, UserSession userSession) {
this.db = db;
this.index = index;
this.contextFactory = contextFactory;
this.typeValidations = typeValidations;
this.activityService = activityService;
+ this.userSession = userSession;
}
public List<ActiveRuleChange> activate(DbSession dbSession, RuleActivation activation, String profileKey) {
RuleIndex ruleIndex = index.get(RuleIndex.class);
DbSession dbSession = db.openSession(false);
try {
- Result<Rule> ruleSearchResult = ruleIndex.search(ruleQuery, new QueryContext().setScroll(true)
+ Result<Rule> ruleSearchResult = ruleIndex.search(ruleQuery, new QueryContext(userSession).setScroll(true)
.setFieldsToReturn(Arrays.asList(RuleNormalizer.RuleField.KEY.field())));
Iterator<Rule> rules = ruleSearchResult.scroll();
while (rules.hasNext()) {
try {
RuleIndex ruleIndex = index.get(RuleIndex.class);
BulkChangeResult result = new BulkChangeResult();
- Result<Rule> ruleSearchResult = ruleIndex.search(ruleQuery, new QueryContext().setScroll(true)
+ Result<Rule> ruleSearchResult = ruleIndex.search(ruleQuery, new QueryContext(userSession).setScroll(true)
.setFieldsToReturn(Arrays.asList(RuleNormalizer.RuleField.KEY.field())));
Iterator<Rule> rules = ruleSearchResult.scroll();
while (rules.hasNext()) {
private final QProfileService profileService;
private final RuleService ruleService;
private final I18n i18n;
+ private final UserSession userSession;
- public BulkRuleActivationActions(QProfileService profileService, RuleService ruleService, I18n i18n) {
+ public BulkRuleActivationActions(QProfileService profileService, RuleService ruleService, I18n i18n, UserSession userSession) {
this.profileService = profileService;
this.ruleService = ruleService;
this.i18n = i18n;
+ this.userSession = userSession;
}
void define(WebService.NewController controller) {
JsonWriter json = response.newJsonWriter().beginObject();
json.prop("succeeded", result.countSucceeded());
json.prop("failed", result.countFailed());
- result.getErrors().writeJsonAsWarnings(json, i18n, UserSession.get().locale());
+ result.getErrors().writeJsonAsWarnings(json, i18n, userSession.locale());
json.endObject().close();
}
}
private final QProfileLookup profileLookup;
private final ComponentService componentService;
private final Languages languages;
+ private final UserSession userSession;
- public ProjectAssociationActions(QProfileProjectOperations profileProjectOperations, QProfileLookup profileLookup, ComponentService componentService, Languages languages) {
+ public ProjectAssociationActions(QProfileProjectOperations profileProjectOperations, QProfileLookup profileLookup, ComponentService componentService, Languages languages, UserSession userSession) {
this.profileProjectOperations = profileProjectOperations;
this.profileLookup = profileLookup;
this.componentService = componentService;
this.languages = languages;
+ this.userSession = userSession;
}
void define(WebService.NewController controller) {
NewAction addProject = controller.createAction("add_project")
.setSince("5.2")
.setDescription("Associate a project with a quality profile.")
- .setHandler(new AssociationHandler(profileLookup, componentService) {
+ .setHandler(new AssociationHandler(profileLookup, componentService, userSession) {
@Override
protected void changeAssociation(String profileKey, String projectUuid, UserSession userSession) {
profileProjectOperations.addProject(profileKey, projectUuid, userSession);
NewAction removeProject = controller.createAction("remove_project")
.setSince("5.2")
.setDescription("Remove a project's association with a quality profile.")
- .setHandler(new AssociationHandler(profileLookup, componentService) {
+ .setHandler(new AssociationHandler(profileLookup, componentService, userSession) {
@Override
protected void changeAssociation(String profileKey, String projectUuid, UserSession userSession) {
profileProjectOperations.removeProject(profileKey, projectUuid, userSession);
private final QProfileLookup profileLookup;
private final ComponentService componentService;
+ private final UserSession userSession;
- public AssociationHandler(QProfileLookup profileLookup, ComponentService componentService) {
+ public AssociationHandler(QProfileLookup profileLookup, ComponentService componentService, UserSession userSession) {
this.profileLookup = profileLookup;
this.componentService = componentService;
+ this.userSession = userSession;
}
protected abstract void changeAssociation(String profileKey, String projectUuid, UserSession userSession);
projectUuid = componentService.getByKey(projectKey).uuid();
}
- changeAssociation(profileKey, projectUuid, UserSession.get());
+ changeAssociation(profileKey, projectUuid, userSession);
response.noContent();
}
private final QProfileFactory profileFactory;
private final Languages languages;
+ private final UserSession userSession;
- public QProfileChangeParentAction(DbClient dbClient, RuleActivator ruleActivator, QProfileFactory profileFactory, Languages languages) {
+ public QProfileChangeParentAction(DbClient dbClient, RuleActivator ruleActivator, QProfileFactory profileFactory, Languages languages, UserSession userSession) {
this.dbClient = dbClient;
this.ruleActivator = ruleActivator;
this.profileFactory = profileFactory;
this.languages = languages;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkLoggedIn().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSession.checkLoggedIn().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
DbSession session = dbClient.openSession(false);
try {
private final QProfileCopier profileCopier;
private final Languages languages;
+ private final UserSession userSession;
- public QProfileCopyAction(QProfileCopier profileCopier, Languages languages) {
+ public QProfileCopyAction(QProfileCopier profileCopier, Languages languages, UserSession userSession) {
this.profileCopier = profileCopier;
this.languages = languages;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkLoggedIn().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSession.checkLoggedIn().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
String newName = request.mandatoryParam(PARAM_PROFILE_NAME);
String profileKey = request.mandatoryParam(PARAM_PROFILE_KEY);
import org.sonar.server.qualityprofile.QProfileFactory;
import org.sonar.server.qualityprofile.QProfileName;
import org.sonar.server.qualityprofile.QProfileResult;
-import org.sonar.server.user.UserSession;
import java.io.InputStream;
+import org.sonar.server.user.UserSession;
public class QProfileCreateAction implements BaseQProfileWsAction {
private final Languages languages;
private final ProfileImporter[] importers;
+ private final UserSession userSession;
- public QProfileCreateAction(DbClient dbClient, QProfileFactory profileFactory, QProfileExporters exporters, Languages languages, ProfileImporter[] importers) {
+ public QProfileCreateAction(DbClient dbClient, QProfileFactory profileFactory, QProfileExporters exporters, Languages languages, ProfileImporter[] importers, UserSession userSession) {
this.dbClient = dbClient;
this.profileFactory = profileFactory;
this.exporters = exporters;
this.languages = languages;
this.importers = importers;
+ this.userSession = userSession;
}
- public QProfileCreateAction(DbClient dbClient, QProfileFactory profileFactory, QProfileExporters exporters, Languages languages) {
- this(dbClient, profileFactory, exporters, languages, new ProfileImporter[0]);
+ public QProfileCreateAction(DbClient dbClient, QProfileFactory profileFactory, QProfileExporters exporters, Languages languages, UserSession userSession) {
+ this(dbClient, profileFactory, exporters, languages, new ProfileImporter[0], userSession);
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkLoggedIn().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSession.checkLoggedIn().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
String name = request.mandatoryParam(PARAM_PROFILE_NAME);
String language = request.mandatoryParam(PARAM_LANGUAGE);
private final Languages languages;
private final QProfileFactory profileFactory;
private final DbClient dbClient;
+ private final UserSession userSession;
- public QProfileDeleteAction(Languages languages, QProfileFactory profileFactory, DbClient dbClient) {
+ public QProfileDeleteAction(Languages languages, QProfileFactory profileFactory, DbClient dbClient, UserSession userSession) {
this.languages = languages;
this.profileFactory = profileFactory;
this.dbClient = dbClient;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkLoggedIn();
- UserSession.get().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSession.checkLoggedIn();
+ userSession.checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
DbSession session = dbClient.openSession(false);
import com.google.common.collect.Collections2;
import com.google.common.collect.Iterables;
import com.google.common.collect.Lists;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
import org.apache.commons.lang.builder.CompareToBuilder;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.user.UserSession;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-
public class QProfileProjectsAction implements BaseQProfileWsAction {
private static final String PARAM_KEY = "key";
private static final String SELECTION_DESELECTED = "deselected";
private final DbClient dbClient;
+ private final UserSession userSession;
- public QProfileProjectsAction(DbClient dbClient) {
+ public QProfileProjectsAction(DbClient dbClient, UserSession userSession) {
this.dbClient = dbClient;
+ this.userSession = userSession;
}
@Override
}
});
- final Collection<Long> authorizedProjectIds = dbClient.authorizationDao().keepAuthorizedProjectIds(session, projectIds, UserSession.get().userId(), UserRole.USER);
+ final Collection<Long> authorizedProjectIds = dbClient.authorizationDao().keepAuthorizedProjectIds(session, projectIds, userSession.userId(), UserRole.USER);
Iterable<ProjectQprofileAssociationDto> authorizedProjects = Iterables.filter(projects, new Predicate<ProjectQprofileAssociationDto>() {
@Override
public boolean apply(ProjectQprofileAssociationDto input) {
private static final String PARAM_PROFILE_KEY = "key";
private final QProfileFactory profileFactory;
+ private final UserSession userSession;
- public QProfileRenameAction(QProfileFactory profileFactory) {
+ public QProfileRenameAction(QProfileFactory profileFactory, UserSession userSession) {
this.profileFactory = profileFactory;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkLoggedIn().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSession.checkLoggedIn().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
String newName = request.mandatoryParam(PARAM_PROFILE_NAME);
String profileKey = request.mandatoryParam(PARAM_PROFILE_KEY);
import com.google.common.base.Charsets;
import com.google.common.base.Preconditions;
+import java.io.InputStream;
+import java.io.InputStreamReader;
import org.apache.commons.io.IOUtils;
import org.sonar.api.resources.Languages;
import org.sonar.api.server.ws.Request;
import org.sonar.server.qualityprofile.QProfileBackuper;
import org.sonar.server.user.UserSession;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-
public class QProfileRestoreAction implements BaseQProfileWsAction {
private static final String PARAM_BACKUP = "backup";
private final QProfileBackuper backuper;
private final Languages languages;
+ private final UserSession userSession;
- public QProfileRestoreAction(QProfileBackuper backuper, Languages languages) {
+ public QProfileRestoreAction(QProfileBackuper backuper, Languages languages, UserSession userSession) {
this.backuper = backuper;
this.languages = languages;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkLoggedIn().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSession.checkLoggedIn().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
InputStream backup = request.paramAsInputStream(PARAM_BACKUP);
InputStreamReader reader = null;
private final QProfileLookup profileLookup;
private final QProfileFactory profileFactory;
+ private final UserSession userSession;
- public QProfileSetDefaultAction(Languages languages, QProfileLookup profileLookup, QProfileFactory profileFactory) {
+ public QProfileSetDefaultAction(Languages languages, QProfileLookup profileLookup, QProfileFactory profileFactory, UserSession userSession) {
this.languages = languages;
this.profileLookup = profileLookup;
this.profileFactory = profileFactory;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkLoggedIn().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSession.checkLoggedIn().checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
String language = request.param(PARAM_LANGUAGE);
String profileName = request.param(PARAM_PROFILE_NAME);
import java.util.Collection;
import java.util.List;
+import org.sonar.server.user.UserSession;
import static com.google.common.collect.Lists.newArrayList;
public class DefaultRuleFinder implements RuleFinder {
private final RuleIndex index;
+ private final UserSession userSession;
- public DefaultRuleFinder(IndexClient indexes) {
+ public DefaultRuleFinder(IndexClient indexes, UserSession userSession) {
+ this.userSession = userSession;
this.index = indexes.get(RuleIndex.class);
}
@Override
public final org.sonar.api.rules.Rule find(org.sonar.api.rules.RuleQuery query) {
- Result<Rule> result = index.search(toQuery(query), new QueryContext());
+ Result<Rule> result = index.search(toQuery(query), new QueryContext(userSession));
if (!result.getHits().isEmpty()) {
return toRule(result.getHits().get(0));
} else {
@Override
public final Collection<org.sonar.api.rules.Rule> findAll(org.sonar.api.rules.RuleQuery query) {
List<org.sonar.api.rules.Rule> rules = newArrayList();
- for (Rule rule : index.search(toQuery(query), new QueryContext()).getHits()) {
+ for (Rule rule : index.search(toQuery(query), new QueryContext(userSession)).getHits()) {
rules.add(toRule(rule));
}
return rules;
package org.sonar.server.rule;
import com.google.common.base.Strings;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.CheckForNull;
import org.picocontainer.Startable;
import org.sonar.api.ServerSide;
import org.sonar.api.rule.RuleKey;
import org.sonar.server.user.UserSession;
import org.sonar.server.util.RubyUtils;
-import javax.annotation.CheckForNull;
-
-import java.util.List;
-import java.util.Map;
-
import static com.google.common.collect.Lists.newArrayList;
/**
private final RuleService service;
private final RuleUpdater updater;
+ private final UserSession userSession;
- public RubyRuleService(RuleService service, RuleUpdater updater) {
+ public RubyRuleService(RuleService service, RuleUpdater updater, UserSession userSession) {
this.service = service;
this.updater = updater;
+ this.userSession = userSession;
}
/**
query.setActivation(true);
}
- QueryContext options = new QueryContext();
+ QueryContext options = new QueryContext(userSession);
Integer pageSize = RubyUtils.toInteger(params.get("pageSize"));
int size = pageSize != null ? pageSize : 50;
if (size > -1) {
Result<Rule> result = service.search(query, options);
return new PagedResult<>(result.getHits(), PagingResult.create(options.getLimit(), pageIndex, result.getTotal()));
} else {
- List<Rule> rules = newArrayList(service.search(query, new QueryContext().setScroll(true)).scroll());
+ List<Rule> rules = newArrayList(service.search(query, new QueryContext(userSession).setScroll(true)).scroll());
return new PagedResult<>(rules, PagingResult.create(Integer.MAX_VALUE, 1, rules.size()));
}
}
* Used in manual_rules_controller.rb
*/
public List<Rule> searchManualRules() {
- return service.search(new RuleQuery().setRepositories(newArrayList(RuleDoc.MANUAL_REPOSITORY)).setSortField(RuleNormalizer.RuleField.NAME), new QueryContext()).getHits();
+ return service.search(new RuleQuery().setRepositories(newArrayList(RuleDoc.MANUAL_REPOSITORY)).setSortField(RuleNormalizer.RuleField.NAME), new QueryContext(userSession)).getHits();
}
// sqale
Strings.emptyToNull((String) params.get("debtRemediationOffset")))
);
}
- updater.update(update, UserSession.get());
+ updater.update(update, userSession);
}
/**
*/
package org.sonar.server.rule;
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+
import org.sonar.api.ServerSide;
import org.sonar.api.rule.RuleKey;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.server.search.Result;
import org.sonar.server.user.UserSession;
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Set;
-
/**
* @since 4.4
*/
private final RuleUpdater ruleUpdater;
private final RuleCreator ruleCreator;
private final RuleDeleter ruleDeleter;
+ private final UserSession userSession;
- public RuleService(RuleIndex index, RuleUpdater ruleUpdater, RuleCreator ruleCreator, RuleDeleter ruleDeleter) {
+ public RuleService(RuleIndex index, RuleUpdater ruleUpdater, RuleCreator ruleCreator, RuleDeleter ruleDeleter, UserSession userSession) {
this.index = index;
this.ruleUpdater = ruleUpdater;
this.ruleCreator = ruleCreator;
this.ruleDeleter = ruleDeleter;
+ this.userSession = userSession;
}
@CheckForNull
public void update(RuleUpdate update) {
checkPermission();
- ruleUpdater.update(update, UserSession.get());
+ ruleUpdater.update(update, userSession);
}
public RuleKey create(NewRule newRule) {
}
private void checkPermission() {
- UserSession userSession = UserSession.get();
userSession.checkLoggedIn();
userSession.checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
}
import com.google.common.collect.LinkedListMultimap;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Locale;
import org.apache.commons.lang.builder.CompareToBuilder;
import org.sonar.api.i18n.I18n;
import org.sonar.api.resources.Language;
import org.sonar.server.rule.RuleRepositories.Repository;
import org.sonar.server.user.UserSession;
-import java.util.Collections;
-import java.util.Comparator;
-import java.util.List;
-import java.util.Locale;
-
/**
* @since 4.4
*/
private final I18n i18n;
private final DebtModel debtModel;
private final QProfileLoader profileLoader;
+ private final UserSession userSession;
public AppAction(Languages languages, RuleRepositories ruleRepositories, I18n i18n,
- DebtModel debtModel, QProfileLoader profileLoader) {
+ DebtModel debtModel, QProfileLoader profileLoader, UserSession userSession) {
this.languages = languages;
this.ruleRepositories = ruleRepositories;
this.i18n = i18n;
this.debtModel = debtModel;
this.profileLoader = profileLoader;
+ this.userSession = userSession;
}
@Override
}
private void addPermissions(JsonWriter json) {
- json.prop("canWrite", UserSession.get().hasGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN));
+ json.prop("canWrite", userSession.hasGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN));
}
private void addProfiles(JsonWriter json) {
import java.util.Collection;
import java.util.Map;
+import org.sonar.server.user.UserSession;
/**
* Conversion of {@link org.sonar.server.rule.index.RuleDoc} to WS JSON document
private final DebtModel debtModel;
- public RuleMapping(final Languages languages, final MacroInterpreter macroInterpreter, final DebtModel debtModel) {
+ public RuleMapping(final Languages languages, final MacroInterpreter macroInterpreter, final DebtModel debtModel, UserSession userSession) {
+ super(userSession);
this.debtModel = debtModel;
mapBasicFields(languages);
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
+import org.sonar.server.user.UserSession;
/**
* @since 4.4
private final ActiveRuleCompleter activeRuleCompleter;
private final RuleMapping mapping;
- public SearchAction(RuleService service, ActiveRuleCompleter activeRuleCompleter, RuleMapping mapping) {
- super(SEARCH_ACTION);
+ public SearchAction(RuleService service, ActiveRuleCompleter activeRuleCompleter, RuleMapping mapping, UserSession userSession) {
+ super(SEARCH_ACTION, userSession);
this.ruleService = service;
this.activeRuleCompleter = activeRuleCompleter;
this.mapping = mapping;
package org.sonar.server.search;
import com.google.common.base.Preconditions;
-import org.sonar.server.user.UserSession;
-
-import javax.annotation.Nullable;
-
import java.util.Arrays;
import java.util.Collection;
import java.util.Set;
+import javax.annotation.Nullable;
+import org.sonar.server.user.UserSession;
import static com.google.common.collect.Sets.newHashSet;
import static com.google.common.collect.Sets.newLinkedHashSet;
private String userLogin;
private Set<String> userGroups = newHashSet();
- public QueryContext() {
- this.userLogin = UserSession.get().login();
- this.userGroups = UserSession.get().userGroups();
+ public QueryContext(UserSession userSession) {
+ this.userLogin = userSession.login();
+ this.userGroups = userSession.userGroups();
}
/**
import java.util.Arrays;
import java.util.List;
import java.util.Set;
+import org.sonar.server.user.UserSession;
/**
* Mapping of search documents (see {@link org.sonar.server.search.BaseDoc}) to WS JSON responses
private final Multimap<String, String> indexFieldsByWsFields = LinkedHashMultimap.create();
private final Multimap<String, Mapper> mappers = LinkedHashMultimap.create();
+ private final UserSession userSession;
+
+ protected BaseMapping(UserSession userSession) {
+ this.userSession = userSession;
+ }
/**
* All the WS supported fields
}
public QueryContext newQueryOptions(SearchOptions options) {
- QueryContext result = new QueryContext();
+ QueryContext result = new QueryContext(userSession);
result.setPage(options.page(), options.pageSize());
List<String> optionFields = options.fields();
if (optionFields != null) {
import java.util.List;
import java.util.Map;
import java.util.Set;
+import org.sonar.server.user.UserSession;
public abstract class SearchRequestHandler<QUERY, DOMAIN> implements RequestHandler {
public static final String PARAM_FACETS = "facets";
private final String actionName;
+ protected final UserSession userSession;
- protected SearchRequestHandler(String actionName) {
+ protected SearchRequestHandler(String actionName, UserSession userSession) {
this.actionName = actionName;
+ this.userSession = userSession;
}
protected abstract Result<DOMAIN> doSearch(QUERY query, QueryContext context);
protected QueryContext getQueryContext(Request request) {
int pageSize = request.mandatoryParamAsInt(PARAM_PAGE_SIZE);
- QueryContext queryContext = new QueryContext().addFieldsToReturn(request.paramAsStrings(PARAM_FIELDS));
+ QueryContext queryContext = new QueryContext(userSession).addFieldsToReturn(request.paramAsStrings(PARAM_FIELDS));
List<String> facets = request.paramAsStrings(PARAM_FACETS);
if(facets != null) {
queryContext.addFacets(facets);
import com.google.common.base.Function;
import com.google.common.io.CharStreams;
import com.google.common.io.Resources;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.Reader;
import org.apache.commons.io.Charsets;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.server.db.DbClient;
import org.sonar.server.user.UserSession;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.io.Reader;
-
public class HashAction implements SourcesAction {
private final DbClient dbClient;
+ private final UserSession userSession;
- public HashAction(DbClient dbClient) {
+ public HashAction(DbClient dbClient, UserSession userSession) {
this.dbClient = dbClient;
+ this.userSession = userSession;
}
@Override
try (DbSession session = dbClient.openSession(false)) {
final String componentKey = request.mandatoryParam("key");
final ComponentDto component = dbClient.componentDao().getByKey(session, componentKey);
- UserSession.get().checkProjectUuidPermission(UserRole.USER, component.projectUuid());
+ userSession.checkProjectUuidPermission(UserRole.USER, component.projectUuid());
response.stream().setMediaType("text/plain");
OutputStreamWriter writer = new OutputStreamWriter(response.stream().output(), Charsets.UTF_8);
package org.sonar.server.source.ws;
import com.google.common.io.Resources;
+import java.util.List;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.source.SourceService;
import org.sonar.server.user.UserSession;
-import java.util.List;
-
public class IndexAction implements SourcesAction {
private final DbClient dbClient;
private final SourceService sourceService;
+ private final UserSession userSession;
- public IndexAction(DbClient dbClient, SourceService sourceService) {
+ public IndexAction(DbClient dbClient, SourceService sourceService, UserSession userSession) {
this.dbClient = dbClient;
this.sourceService = sourceService;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) {
String fileKey = request.mandatoryParam("resource");
- UserSession.get().checkComponentPermission(UserRole.CODEVIEWER, fileKey);
+ userSession.checkComponentPermission(UserRole.CODEVIEWER, fileKey);
Integer from = request.mandatoryParamAsInt("from");
Integer to = request.paramAsInt("to");
try (DbSession session = dbClient.openSession(false)) {
package org.sonar.server.source.ws;
import com.google.common.io.Resources;
+import java.util.Date;
+import java.util.List;
import org.apache.commons.lang.ObjectUtils;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.server.source.index.SourceLineIndex;
import org.sonar.server.user.UserSession;
-import java.util.Date;
-import java.util.List;
-
public class LinesAction implements SourcesAction {
private static final String PARAM_UUID = "uuid";
private final SourceLineIndex sourceLineIndex;
private final HtmlSourceDecorator htmlSourceDecorator;
private final DbClient dbClient;
+ private final UserSession userSession;
- public LinesAction(DbClient dbClient, SourceLineIndex sourceLineIndex, HtmlSourceDecorator htmlSourceDecorator) {
+ public LinesAction(DbClient dbClient, SourceLineIndex sourceLineIndex, HtmlSourceDecorator htmlSourceDecorator, UserSession userSession) {
this.sourceLineIndex = sourceLineIndex;
this.htmlSourceDecorator = htmlSourceDecorator;
this.dbClient = dbClient;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) {
ComponentDto component = loadComponent(request);
- UserSession.get().checkProjectUuidPermission(UserRole.CODEVIEWER, component.projectUuid());
+ userSession.checkProjectUuidPermission(UserRole.CODEVIEWER, component.projectUuid());
int from = Math.max(request.mandatoryParamAsInt("from"), 1);
int to = (Integer) ObjectUtils.defaultIfNull(request.paramAsInt("to"), Integer.MAX_VALUE);
package org.sonar.server.source.ws;
import com.google.common.io.Resources;
+import java.io.IOException;
+import java.util.List;
import org.apache.commons.io.Charsets;
import org.apache.commons.io.IOUtils;
import org.sonar.api.server.ws.Request;
import org.sonar.server.source.SourceService;
import org.sonar.server.user.UserSession;
-import java.io.IOException;
-import java.util.List;
-
public class RawAction implements SourcesAction {
private final DbClient dbClient;
private final SourceService sourceService;
+ private final UserSession userSession;
- public RawAction(DbClient dbClient, SourceService sourceService) {
+ public RawAction(DbClient dbClient, SourceService sourceService, UserSession userSession) {
this.dbClient = dbClient;
this.sourceService = sourceService;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) {
String fileKey = request.mandatoryParam("key");
- UserSession.get().checkComponentPermission(UserRole.CODEVIEWER, fileKey);
+ userSession.checkComponentPermission(UserRole.CODEVIEWER, fileKey);
try (DbSession session = dbClient.openSession(false)) {
ComponentDto componentDto = dbClient.componentDao().getByKey(session, fileKey);
List<String> lines = sourceService.getLinesAsTxt(componentDto.uuid(), null, null);
import com.google.common.base.Strings;
import com.google.common.io.Resources;
+import java.util.Date;
+import java.util.List;
import org.apache.commons.lang.ObjectUtils;
import org.apache.commons.lang.builder.EqualsBuilder;
import org.sonar.api.server.ws.Request;
import org.sonar.server.source.index.SourceLineIndex;
import org.sonar.server.user.UserSession;
-import java.util.Date;
-import java.util.List;
-
public class ScmAction implements SourcesAction {
private final DbClient dbClient;
private final SourceLineIndex sourceLineIndex;
+ private final UserSession userSession;
- public ScmAction(DbClient dbClient, SourceLineIndex sourceLineIndex) {
+ public ScmAction(DbClient dbClient, SourceLineIndex sourceLineIndex, UserSession userSession) {
this.dbClient = dbClient;
this.sourceLineIndex = sourceLineIndex;
+ this.userSession = userSession;
}
@Override
DbSession session = dbClient.openSession(false);
try {
ComponentDto fileDto = dbClient.componentDao().getByKey(session, fileKey);
- UserSession.get().checkProjectUuidPermission(UserRole.CODEVIEWER, fileDto.projectUuid());
+ userSession.checkProjectUuidPermission(UserRole.CODEVIEWER, fileDto.projectUuid());
List<SourceLineDoc> sourceLines = sourceLineIndex.getLines(fileDto.uuid(), from, to);
if (sourceLines.isEmpty()) {
throw new NotFoundException("File '" + fileKey + "' has no sources");
package org.sonar.server.source.ws;
import com.google.common.io.Resources;
+import java.util.List;
import org.apache.commons.lang.ObjectUtils;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.server.source.SourceService;
import org.sonar.server.user.UserSession;
-import java.util.List;
-
public class ShowAction implements SourcesAction {
private final SourceService sourceService;
private final DbClient dbClient;
+ private final UserSession userSession;
- public ShowAction(SourceService sourceService, DbClient dbClient) {
+ public ShowAction(SourceService sourceService, DbClient dbClient, UserSession userSession) {
this.sourceService = sourceService;
this.dbClient = dbClient;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) {
String fileKey = request.mandatoryParam("key");
- UserSession.get().checkComponentPermission(UserRole.CODEVIEWER, fileKey);
+ userSession.checkComponentPermission(UserRole.CODEVIEWER, fileKey);
int from = Math.max(request.mandatoryParamAsInt("from"), 1);
int to = (Integer) ObjectUtils.defaultIfNull(request.paramAsInt("to"), Integer.MAX_VALUE);
package org.sonar.server.test;
-import com.google.common.collect.Maps;
+import java.util.Map;
+
+import javax.annotation.CheckForNull;
+
import org.sonar.api.ServerSide;
import org.sonar.api.measures.CoreMetrics;
import org.sonar.api.test.MutableTestable;
import org.sonar.server.measure.persistence.MeasureDao;
import org.sonar.server.user.UserSession;
-import javax.annotation.CheckForNull;
-
-import java.util.Map;
+import com.google.common.collect.Maps;
@ServerSide
public class CoverageService {
private final MyBatis myBatis;
private final MeasureDao measureDao;
private final SnapshotPerspectives snapshotPerspectives;
+ private final UserSession userSession;
- public CoverageService(MyBatis myBatis, MeasureDao measureDao, SnapshotPerspectives snapshotPerspectives) {
+ public CoverageService(MyBatis myBatis, MeasureDao measureDao, SnapshotPerspectives snapshotPerspectives, UserSession userSession) {
this.myBatis = myBatis;
this.measureDao = measureDao;
this.snapshotPerspectives = snapshotPerspectives;
+ this.userSession = userSession;
}
public void checkPermission(String fileKey) {
- UserSession.get().checkComponentPermission(UserRole.CODEVIEWER, fileKey);
+ userSession.checkComponentPermission(UserRole.CODEVIEWER, fileKey);
}
public Map<Integer, Integer> getHits(String fileKey, CoverageService.TYPE type) {
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.io.Resources;
+import java.util.List;
+import java.util.Map;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.test.index.TestIndex;
import org.sonar.server.user.UserSession;
-import java.util.List;
-import java.util.Map;
-
public class TestsCoveredFilesAction implements TestAction {
public static final String TEST_UUID = "testUuid";
private final DbClient dbClient;
private final TestIndex index;
+ private final UserSession userSession;
- public TestsCoveredFilesAction(DbClient dbClient, TestIndex index) {
+ public TestsCoveredFilesAction(DbClient dbClient, TestIndex index, UserSession userSession) {
this.dbClient = dbClient;
this.index = index;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) {
String testUuid = request.mandatoryParam(TEST_UUID);
- UserSession.get().checkComponentUuidPermission(UserRole.CODEVIEWER, index.searchByTestUuid(testUuid).fileUuid());
+ userSession.checkComponentUuidPermission(UserRole.CODEVIEWER, index.searchByTestUuid(testUuid).fileUuid());
List<CoveredFileDoc> coveredFiles = index.coveredFiles(testUuid);
Map<String, ComponentDto> componentsByUuid = buildComponentsByUuid(coveredFiles);
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.io.Resources;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.test.index.TestIndex;
import org.sonar.server.user.UserSession;
-import javax.annotation.Nullable;
-
-import java.util.List;
-import java.util.Map;
-
public class TestsListAction implements TestAction {
public static final String TEST_UUID = "testUuid";
public static final String TEST_FILE_UUID = "testFileUuid";
private final DbClient dbClient;
private final TestIndex testIndex;
+ private final UserSession userSession;
- public TestsListAction(DbClient dbClient, TestIndex testIndex) {
+ public TestsListAction(DbClient dbClient, TestIndex testIndex, UserSession userSession) {
this.dbClient = dbClient;
this.testIndex = testIndex;
+ this.userSession = userSession;
}
@Override
}
private SearchResult<TestDoc> searchTestsByTestFileKey(DbSession dbSession, String testFileKey, SearchOptions searchOptions) {
- UserSession.get().checkComponentPermission(UserRole.CODEVIEWER, testFileKey);
+ userSession.checkComponentPermission(UserRole.CODEVIEWER, testFileKey);
ComponentDto testFile = dbClient.componentDao().getByKey(dbSession, testFileKey);
return testIndex.searchByTestFileUuid(testFile.uuid(), searchOptions);
private void checkComponentUuidPermission(DbSession dbSession, String componentUuid) {
ComponentDto component = dbClient.componentDao().getByUuid(dbSession, componentUuid);
- UserSession.get().checkProjectUuidPermission(UserRole.CODEVIEWER, component.projectUuid());
+ userSession.checkProjectUuidPermission(UserRole.CODEVIEWER, component.projectUuid());
}
}
package org.sonar.server.ui;
import com.google.common.collect.Maps;
+import java.util.Date;
+import java.util.Locale;
+import java.util.Map;
+import javax.annotation.Nullable;
import org.apache.commons.lang.StringUtils;
import org.sonar.api.ServerSide;
import org.sonar.api.i18n.I18n;
import org.sonar.api.utils.Durations;
import org.sonar.server.user.UserSession;
-import javax.annotation.Nullable;
-
-import java.util.Date;
-import java.util.Locale;
-import java.util.Map;
-
/**
* Used through ruby code <pre>Internal.i18n</pre>
*
@ServerSide
public class JRubyI18n {
- private I18n i18n;
- private Durations durations;
+ private final I18n i18n;
+ private final Durations durations;
+ private final UserSession userSession;
private Map<String, Locale> localesByRubyKey = Maps.newHashMap();
- public JRubyI18n(I18n i18n, Durations durations) {
+ public JRubyI18n(I18n i18n, Durations durations, UserSession userSession) {
this.i18n = i18n;
this.durations = durations;
+ this.userSession = userSession;
}
Locale getLocale(String rubyKey) {
}
public String ageFromNow(Date date) {
- return i18n.ageFromNow(UserSession.get().locale(), date);
+ return i18n.ageFromNow(userSession.locale(), date);
}
public String formatDuration(Duration duration, String format) {
- return durations.format(UserSession.get().locale(), duration, Durations.DurationFormat.valueOf(format));
+ return durations.format(userSession.locale(), duration, Durations.DurationFormat.valueOf(format));
}
public String formatLongDuration(long duration, String format) {
}
public String formatDateTime(Date date) {
- return i18n.formatDateTime(UserSession.get().locale(), date);
+ return i18n.formatDateTime(userSession.locale(), date);
}
}
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Maps;
+import java.util.Collection;
+import java.util.Map;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.lang.builder.CompareToBuilder;
import org.sonar.core.component.ComponentDto;
import org.sonar.server.user.UserSession;
-import java.util.Collection;
-import java.util.Map;
-
@SuppressWarnings("rawtypes")
public class ViewProxy<V extends View> implements Comparable<ViewProxy> {
- private V view;
+ private final V view;
+ private final UserSession userSession;
private String[] sections = {NavigationSection.HOME};
private String[] userRoles = {};
private String[] resourceScopes = {};
private String[] mandatoryMeasures = {};
private String[] needOneOfMeasures = {};
- public ViewProxy(final V view) {
+ public ViewProxy(V view, UserSession userSession) {
this.view = view;
+ this.userSession = userSession;
initUserRoles(view);
initSections(view);
public boolean isUserAuthorized() {
boolean authorized = userRoles.length == 0;
for (String userRole : getUserRoles()) {
- authorized |= UserSession.get().hasGlobalPermission(userRole);
+ authorized |= userSession.hasGlobalPermission(userRole);
}
return authorized;
}
public boolean isUserAuthorized(ComponentDto component) {
boolean authorized = userRoles.length == 0;
for (String userRole : getUserRoles()) {
- authorized |= UserSession.get().hasProjectPermissionByUuid(userRole, component.uuid());
+ authorized |= userSession.hasProjectPermissionByUuid(userRole, component.uuid());
}
return authorized;
}
import java.util.List;
import java.util.Map;
import java.util.Set;
+import org.sonar.server.user.UserSession;
@ServerSide
public class Views {
private Map<String, ViewProxy<Widget>> widgetsPerId = Maps.newHashMap();
private Set<ViewProxy<Widget>> widgets = Sets.newTreeSet();
- public Views() {
+ private final UserSession userSession;
+
+ public Views(UserSession userSession) {
+ this.userSession = userSession;
}
- public Views(View[] views) {
+ public Views(UserSession userSession, View[] views) {
+ this.userSession = userSession;
for (View view : views) {
register(view);
}
private void register(View view) {
if (view instanceof Widget) {
- ViewProxy<Widget> proxy = new ViewProxy<Widget>((Widget) view);
+ ViewProxy<Widget> proxy = new ViewProxy<>((Widget) view, userSession);
widgets.add(proxy);
widgetsPerId.put(proxy.getId(), proxy);
} else if (view instanceof Page) {
- ViewProxy<Page> proxy = new ViewProxy<Page>((Page) view);
+ ViewProxy<Page> proxy = new ViewProxy<>((Page) view, userSession);
pagesPerId.put(proxy.getId(), proxy);
pages.add(proxy);
}
import com.google.common.base.Charsets;
import com.google.common.collect.Lists;
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
+import javax.annotation.Nullable;
import org.sonar.api.i18n.I18n;
import org.sonar.api.resources.Qualifiers;
import org.sonar.api.resources.ResourceType;
import org.sonar.server.ui.Views;
import org.sonar.server.user.UserSession;
-import javax.annotation.Nullable;
-
-import java.io.UnsupportedEncodingException;
-import java.net.URLEncoder;
-import java.util.Date;
-import java.util.List;
-import java.util.Locale;
-
public class ComponentNavigationAction implements NavigationAction {
private static final String PARAM_COMPONENT_KEY = "componentKey";
private final Views views;
private final I18n i18n;
private final ResourceTypes resourceTypes;
+ private final UserSession userSession;
- public ComponentNavigationAction(DbClient dbClient, ActiveDashboardDao activeDashboardDao, Views views, I18n i18n, ResourceTypes resourceTypes) {
+ public ComponentNavigationAction(DbClient dbClient, ActiveDashboardDao activeDashboardDao, Views views, I18n i18n, ResourceTypes resourceTypes, UserSession userSession) {
this.dbClient = dbClient;
this.activeDashboardDao = activeDashboardDao;
this.views = views;
this.i18n = i18n;
this.resourceTypes = resourceTypes;
+ this.userSession = userSession;
}
@Override
public void handle(Request request, Response response) throws Exception {
String componentKey = request.mandatoryParam(PARAM_COMPONENT_KEY);
- UserSession userSession = UserSession.get();
DbSession session = dbClient.openSession(false);
try {
*/
package org.sonar.server.ui.ws;
+import java.util.List;
import org.sonar.api.config.Settings;
import org.sonar.api.resources.ResourceType;
import org.sonar.api.resources.ResourceTypes;
import org.sonar.server.ui.Views;
import org.sonar.server.user.UserSession;
-import java.util.List;
-
public class GlobalNavigationAction implements NavigationAction {
private static final String ANONYMOUS = null;
private final Views views;
private final Settings settings;
private final ResourceTypes resourceTypes;
+ private final UserSession userSession;
- public GlobalNavigationAction(ActiveDashboardDao activeDashboardDao, Views views, Settings settings, ResourceTypes resourceTypes) {
+ public GlobalNavigationAction(ActiveDashboardDao activeDashboardDao, Views views, Settings settings, ResourceTypes resourceTypes, UserSession userSession) {
this.activeDashboardDao = activeDashboardDao;
this.views = views;
this.settings = settings;
this.resourceTypes = resourceTypes;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession userSession = UserSession.get();
-
List<DashboardDto> dashboards = activeDashboardDao.selectGlobalDashboardsForUserLogin(userSession.login());
if (dashboards.isEmpty()) {
dashboards = activeDashboardDao.selectGlobalDashboardsForUserLogin(ANONYMOUS);
private final Settings settings;
private final Views views;
private final I18n i18n;
+ private final UserSession userSession;
- public SettingsNavigationAction(Settings settings, Views views, I18n i18n) {
+ public SettingsNavigationAction(Settings settings, Views views, I18n i18n, UserSession userSession) {
this.views = views;
this.settings = settings;
this.i18n = i18n;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession userSession = UserSession.get();
boolean isAdmin = userSession.hasGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
JsonWriter json = response.newJsonWriter().beginObject();
if (isAdmin) {
for (ViewProxy<Page> page : views.getPages(NavigationSection.CONFIGURATION, null, null, null, null)) {
json.beginObject()
- .prop("name", i18n.message(UserSession.get().locale(), String.format("%s.page", page.getTitle()), page.getTitle()))
+ .prop("name", i18n.message(userSession.locale(), String.format("%s.page", page.getTitle()), page.getTitle()))
.prop("url", getPageUrl(page))
.endObject();
}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.user;
+
+import com.google.common.base.Objects;
+import com.google.common.base.Strings;
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.Sets;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+import org.sonar.api.security.DefaultGroups;
+import org.sonar.server.exceptions.ForbiddenException;
+import org.sonar.server.exceptions.UnauthorizedException;
+
+import static com.google.common.collect.Lists.newArrayList;
+import static com.google.common.collect.Maps.newHashMap;
+
+public abstract class AbstractUserSession<T extends AbstractUserSession> implements UserSession {
+ protected static final String INSUFFICIENT_PRIVILEGES_MESSAGE = "Insufficient privileges";
+
+ protected Integer userId;
+ protected String login;
+ protected Set<String> userGroups = Sets.newHashSet(DefaultGroups.ANYONE);
+ protected List<String> globalPermissions = Collections.emptyList();
+ protected HashMultimap<String, String> projectKeyByPermission = HashMultimap.create();
+ protected HashMultimap<String, String> projectUuidByPermission = HashMultimap.create();
+ protected Map<String, String> projectUuidByComponentUuid = newHashMap();
+ protected List<String> projectPermissions = newArrayList();
+ protected String name;
+ protected Locale locale = Locale.ENGLISH;
+
+ private final Class<T> clazz;
+
+ protected AbstractUserSession(Class<T> clazz) {
+ this.clazz = clazz;
+ }
+
+ @Override
+ @CheckForNull
+ public String login() {
+ return login;
+ }
+
+ protected T setLogin(@Nullable String s) {
+ this.login = Strings.emptyToNull(s);
+ return clazz.cast(this);
+ }
+
+ @Override
+ @CheckForNull
+ public String name() {
+ return name;
+ }
+
+ protected T setName(@Nullable String s) {
+ this.name = Strings.emptyToNull(s);
+ return clazz.cast(this);
+ }
+
+ @Override
+ @CheckForNull
+ public Integer userId() {
+ return userId;
+ }
+
+ protected T setUserId(@Nullable Integer userId) {
+ this.userId = userId;
+ return clazz.cast(this);
+ }
+
+ @Override
+ public Set<String> userGroups() {
+ return userGroups;
+ }
+
+ protected T setUserGroups(@Nullable String... userGroups) {
+ if (userGroups != null) {
+ this.userGroups.addAll(Arrays.asList(userGroups));
+ }
+ return clazz.cast(this);
+ }
+
+ @Override
+ public boolean isLoggedIn() {
+ return login != null;
+ }
+
+ @Override
+ public Locale locale() {
+ return locale;
+ }
+
+ protected T setLocale(@Nullable Locale l) {
+ this.locale = Objects.firstNonNull(l, Locale.ENGLISH);
+ return clazz.cast(this);
+ }
+
+ @Override
+ public UserSession checkLoggedIn() {
+ if (login == null) {
+ throw new UnauthorizedException("Authentication is required");
+ }
+ return this;
+ }
+
+ @Override
+ public UserSession checkGlobalPermission(String globalPermission) {
+ return checkGlobalPermission(globalPermission, null);
+ }
+
+ @Override
+ public UserSession checkGlobalPermission(String globalPermission, @Nullable String errorMessage) {
+ if (!hasGlobalPermission(globalPermission)) {
+ throw new ForbiddenException(errorMessage != null ? errorMessage : INSUFFICIENT_PRIVILEGES_MESSAGE);
+ }
+ return this;
+ }
+
+ @Override
+ public boolean hasGlobalPermission(String globalPermission) {
+ return globalPermissions().contains(globalPermission);
+ }
+
+ @Override
+ public UserSession checkProjectPermission(String projectPermission, String projectKey) {
+ if (!hasProjectPermission(projectPermission, projectKey)) {
+ throw new ForbiddenException(INSUFFICIENT_PRIVILEGES_MESSAGE);
+ }
+ return this;
+ }
+
+ @Override
+ public UserSession checkProjectUuidPermission(String projectPermission, String projectUuid) {
+ if (!hasProjectPermissionByUuid(projectPermission, projectUuid)) {
+ throw new ForbiddenException(INSUFFICIENT_PRIVILEGES_MESSAGE);
+ }
+ return this;
+ }
+
+ @Override
+ public UserSession checkComponentPermission(String projectPermission, String componentKey) {
+ if (!hasComponentPermission(projectPermission, componentKey)) {
+ throw new ForbiddenException(INSUFFICIENT_PRIVILEGES_MESSAGE);
+ }
+ return this;
+ }
+
+ @Override
+ public UserSession checkComponentUuidPermission(String permission, String componentUuid) {
+ if (!hasComponentUuidPermission(permission, componentUuid)) {
+ throw new ForbiddenException(INSUFFICIENT_PRIVILEGES_MESSAGE);
+ }
+ return this;
+ }
+}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.user;
+
+import java.util.Collections;
+import java.util.List;
+
+public final class AnonymousUserSession extends AbstractUserSession<AnonymousUserSession> {
+ public static final UserSession INSTANCE = new AnonymousUserSession();
+
+ private AnonymousUserSession() {
+ super(AnonymousUserSession.class);
+ }
+
+ @Override
+ public List<String> globalPermissions() {
+ return Collections.emptyList();
+ }
+
+ @Override
+ public boolean hasProjectPermission(String permission, String projectKey) {
+ return false;
+ }
+
+ @Override
+ public boolean hasProjectPermissionByUuid(String permission, String projectUuid) {
+ return false;
+ }
+
+ @Override
+ public boolean hasComponentPermission(String permission, String componentKey) {
+ return false;
+ }
+
+ @Override
+ public boolean hasComponentUuidPermission(String permission, String componentUuid) {
+ return false;
+ }
+}
private final UserIndex userIndex;
private final UserUpdater userUpdater;
private final UserFinder finder;
+ private final UserSession userSession;
- public DefaultUserService(UserIndex userIndex, UserUpdater userUpdater, UserFinder finder) {
+ public DefaultUserService(UserIndex userIndex, UserUpdater userUpdater, UserFinder finder, UserSession userSession) {
this.userIndex = userIndex;
this.userUpdater = userUpdater;
this.finder = finder;
+ this.userSession = userSession;
}
@Override
if (Strings.isNullOrEmpty(login)) {
throw new BadRequestException("Login is missing");
}
- UserSession userSession = UserSession.get();
userSession.checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
if (Objects.equal(userSession.login(), login)) {
throw new BadRequestException("Self-deactivation is not possible");
*/
package org.sonar.server.user;
+import java.util.Collections;
+import java.util.List;
import org.sonar.core.permission.GlobalPermissions;
import java.util.Locale;
* to the execution of the {@link #doPrivileged()} method.
*/
public abstract static class Task {
+ private final ThreadLocalUserSession threadLocalUserSession;
+ private UserSession oldUserSession;
+
+ protected Task(ThreadLocalUserSession threadLocalUserSession) {
+ this.threadLocalUserSession = threadLocalUserSession;
+ }
/**
* Code placed in this method will be executed in a privileged environment.
*/
protected abstract void doPrivileged();
+ private static class PrivilegedUserSession extends AbstractUserSession<PrivilegedUserSession> {
+
+ private PrivilegedUserSession() {
+ super(PrivilegedUserSession.class);
+ }
+
+ @Override
+ public boolean hasGlobalPermission(String globalPermission) {
+ return true;
+ }
+
+ @Override
+ public List<String> globalPermissions() {
+ return Collections.emptyList();
+ }
+
+ @Override
+ public boolean hasProjectPermission(String permission, String projectKey) {
+ return true;
+ }
+
+ @Override
+ public boolean hasProjectPermissionByUuid(String permission, String projectUuid) {
+ return true;
+ }
+
+ @Override
+ public boolean hasComponentPermission(String permission, String componentKey) {
+ return true;
+ }
+
+ @Override
+ public boolean hasComponentUuidPermission(String permission, String componentUuid) {
+ return true;
+ }
+ }
+
private void start() {
- UserSession.set(new UserSession() {
- @Override
- public boolean hasGlobalPermission(String globalPermission) {
- return true;
- }
- @Override
- public boolean hasProjectPermission(String permission, String projectKey) {
- return true;
- }
- }.setLocale(Locale.getDefault()));
+ oldUserSession = threadLocalUserSession.get();
+ threadLocalUserSession.set(new PrivilegedUserSession().setLocale(Locale.getDefault()));
}
private void stop() {
- UserSession.remove();
+ threadLocalUserSession.remove();
+ threadLocalUserSession.set(oldUserSession);
}
}
}
*/
package org.sonar.server.user;
-import org.sonar.server.ui.JRubyI18n;
+import java.util.List;
import javax.annotation.Nullable;
-import java.util.List;
+import org.sonar.core.platform.ComponentContainer;
+import org.sonar.core.resource.ResourceDao;
+import org.sonar.core.user.AuthorizationDao;
+import org.sonar.server.platform.Platform;
+import org.sonar.server.ui.JRubyI18n;
+
+import com.google.common.annotations.VisibleForTesting;
public class RubyUserSession {
+
+ private static RubyUserSession instance;
+
+ private static RubyUserSession getInstance() {
+ if (instance == null) {
+ instance = new RubyUserSession(Platform.getInstance());
+ }
+ return instance;
+ }
+
+ private final Platform platform;
+
/**
* Invoked by Ruby code - see application_controller.rb
*/
public static void setSession(@Nullable Integer userId, @Nullable String login, @Nullable String name, @Nullable List<String> userGroups, @Nullable String localeRubyKey) {
- UserSession session = new UserSession()
+ getInstance().setSessionImpl(userId, login, name, userGroups, localeRubyKey);
+ }
+
+ @VisibleForTesting
+ RubyUserSession(Platform platform) {
+ // Utility class
+ this.platform = platform;
+ }
+
+ public void setSessionImpl(@Nullable Integer userId, @Nullable String login, @Nullable String name, @Nullable List<String> userGroups, @Nullable String localeRubyKey) {
+ ComponentContainer container = platform.getContainer();
+ ThreadLocalUserSession threadLocalUserSession = container.getComponentByType(ThreadLocalUserSession.class);
+
+ UserSession session = new ServerUserSession(container.getComponentByType(AuthorizationDao.class),
+ container.getComponentByType(ResourceDao.class))
.setLogin(login)
.setName(name)
.setUserId(userId)
.setUserGroups(userGroups != null ? userGroups.toArray(new String[userGroups.size()]) : null)
.setLocale(JRubyI18n.toLocale(localeRubyKey));
- UserSession.set(session);
- }
-
- private RubyUserSession() {
- // Utility class
+ threadLocalUserSession.set(session);
}
}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.user;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import org.sonar.api.security.DefaultGroups;
+import org.sonar.api.utils.log.Logger;
+import org.sonar.api.utils.log.Loggers;
+import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.resource.ResourceDao;
+import org.sonar.core.resource.ResourceDto;
+import org.sonar.core.user.AuthorizationDao;
+
+import static com.google.common.collect.Maps.newHashMap;
+import static com.google.common.collect.Sets.newHashSet;
+
+/**
+ * Part of the current HTTP session
+ */
+public class ServerUserSession extends AbstractUserSession<ServerUserSession>
+ implements UserSession {
+
+ private static final Logger LOG = Loggers.get(ServerUserSession.class);
+
+ private Map<String, String> projectKeyByComponentKey = newHashMap();
+
+ private final AuthorizationDao authorizationDao;
+ private final ResourceDao resourceDao;
+
+ ServerUserSession(AuthorizationDao authorizationDao, ResourceDao resourceDao) {
+ super(ServerUserSession.class);
+ this.globalPermissions = null;
+ this.authorizationDao = authorizationDao;
+ this.resourceDao = resourceDao;
+ // Do not forget that when forceAuthentication is set to true, the Anyone group should not be set (but this will be check when
+ // authentication will be done in Java)
+ this.userGroups = newHashSet(DefaultGroups.ANYONE);
+ }
+
+ @Override
+ public List<String> globalPermissions() {
+ if (globalPermissions == null) {
+ List<String> permissionKeys = authorizationDao.selectGlobalPermissions(login);
+ globalPermissions = new ArrayList<>();
+ for (String permissionKey : permissionKeys) {
+ if (!GlobalPermissions.ALL.contains(permissionKey)) {
+ LOG.warn("Ignoring unknown permission {} for user {}", permissionKey, login);
+ } else {
+ globalPermissions.add(permissionKey);
+ }
+ }
+ }
+ return globalPermissions;
+ }
+
+ @Override
+ public boolean hasProjectPermission(String permission, String projectKey) {
+ if (!projectPermissions.contains(permission)) {
+ Collection<String> projectKeys = authorizationDao.selectAuthorizedRootProjectsKeys(userId, permission);
+ for (String key : projectKeys) {
+ projectKeyByPermission.put(permission, key);
+ }
+ projectPermissions.add(permission);
+ }
+ return projectKeyByPermission.get(permission).contains(projectKey);
+ }
+
+ @Override
+ public boolean hasProjectPermissionByUuid(String permission, String projectUuid) {
+ if (!projectPermissions.contains(permission)) {
+ Collection<String> projectUuids = authorizationDao.selectAuthorizedRootProjectsUuids(userId, permission);
+ addProjectPermission(permission, projectUuids);
+ }
+ return projectUuidByPermission.get(permission).contains(projectUuid);
+ }
+
+ private void addProjectPermission(String permission, Collection<String> authorizedProjectUuids) {
+ for (String key : authorizedProjectUuids) {
+ projectUuidByPermission.put(permission, key);
+ }
+ projectPermissions.add(permission);
+ }
+
+ @Override
+ public boolean hasComponentPermission(String permission, String componentKey) {
+ String projectKey = projectKeyByComponentKey.get(componentKey);
+ if (projectKey == null) {
+ ResourceDto project = resourceDao.getRootProjectByComponentKey(componentKey);
+ if (project == null) {
+ return false;
+ }
+ projectKey = project.getKey();
+ }
+ boolean hasComponentPermission = hasProjectPermission(permission, projectKey);
+ if (hasComponentPermission) {
+ projectKeyByComponentKey.put(componentKey, projectKey);
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public boolean hasComponentUuidPermission(String permission, String componentUuid) {
+ String projectUuid = projectUuidByComponentUuid.get(componentUuid);
+ if (projectUuid == null) {
+ ResourceDto project = resourceDao.getResource(componentUuid);
+ if (project == null) {
+ return false;
+ }
+ projectUuid = project.getProjectUuid();
+ }
+ boolean hasComponentPermission = hasProjectPermissionByUuid(permission, projectUuid);
+ if (hasComponentPermission) {
+ projectUuidByComponentUuid.put(componentUuid, projectUuid);
+ return true;
+ }
+ return false;
+ }
+
+}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.user;
+
+import com.google.common.base.Objects;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+
+/**
+ * Part of the current HTTP session
+ */
+public class ThreadLocalUserSession implements UserSession {
+
+ private static final ThreadLocal<UserSession> THREAD_LOCAL = new ThreadLocal<UserSession>();
+
+ public UserSession get() {
+ return Objects.firstNonNull(THREAD_LOCAL.get(), AnonymousUserSession.INSTANCE);
+ }
+
+ public void set(UserSession session) {
+ THREAD_LOCAL.set(session);
+ }
+
+ public void remove() {
+ THREAD_LOCAL.remove();
+ }
+
+ public boolean hasSession() {
+ return THREAD_LOCAL.get() != null;
+ }
+
+ @Override
+ @CheckForNull
+ public String login() {
+ return get().login();
+ }
+
+ @Override
+ @CheckForNull
+ public String name() {
+ return get().name();
+ }
+
+ @Override
+ @CheckForNull
+ public Integer userId() {
+ return get().userId();
+ }
+
+ @Override
+ public Set<String> userGroups() {
+ return get().userGroups();
+ }
+
+ @Override
+ public boolean isLoggedIn() {
+ return get().isLoggedIn();
+ }
+
+ @Override
+ public Locale locale() {
+ return get().locale();
+ }
+
+ @Override
+ public UserSession checkLoggedIn() {
+ return get().checkLoggedIn();
+ }
+
+ @Override
+ public UserSession checkGlobalPermission(String globalPermission) {
+ return get().checkGlobalPermission(globalPermission);
+ }
+
+ @Override
+ public UserSession checkGlobalPermission(String globalPermission, @Nullable String errorMessage) {
+ return get().checkGlobalPermission(globalPermission, errorMessage);
+ }
+
+ @Override
+ public boolean hasGlobalPermission(String globalPermission) {
+ return get().hasGlobalPermission(globalPermission);
+ }
+
+ @Override
+ public List<String> globalPermissions() {
+ return get().globalPermissions();
+ }
+
+ @Override
+ public UserSession checkProjectPermission(String projectPermission, String projectKey) {
+ return get().checkProjectPermission(projectPermission, projectKey);
+ }
+
+ @Override
+ public UserSession checkProjectUuidPermission(String projectPermission, String projectUuid) {
+ return get().checkProjectUuidPermission(projectPermission, projectUuid);
+ }
+
+ @Override
+ public boolean hasProjectPermission(String permission, String projectKey) {
+ return get().hasProjectPermission(permission, projectKey);
+ }
+
+ @Override
+ public boolean hasProjectPermissionByUuid(String permission, String projectUuid) {
+ return get().hasProjectPermissionByUuid(permission, projectUuid);
+ }
+
+ @Override
+ public UserSession checkComponentPermission(String projectPermission, String componentKey) {
+ return get().checkComponentPermission(projectPermission, componentKey);
+ }
+
+ @Override
+ public UserSession checkComponentUuidPermission(String permission, String componentUuid) {
+ return get().checkComponentUuidPermission(permission, componentUuid);
+ }
+
+ @Override
+ public boolean hasComponentPermission(String permission, String componentKey) {
+ return get().hasComponentPermission(permission, componentKey);
+ }
+
+ @Override
+ public boolean hasComponentUuidPermission(String permission, String componentUuid) {
+ return get().hasComponentUuidPermission(permission, componentUuid);
+ }
+}
*/
package org.sonar.server.user;
-import com.google.common.base.Objects;
-import com.google.common.base.Strings;
-import com.google.common.collect.HashMultimap;
-import org.sonar.api.security.DefaultGroups;
-import org.sonar.api.utils.log.Logger;
-import org.sonar.api.utils.log.Loggers;
-import org.sonar.core.permission.GlobalPermissions;
-import org.sonar.core.resource.ResourceDao;
-import org.sonar.core.resource.ResourceDto;
-import org.sonar.core.user.AuthorizationDao;
-import org.sonar.server.exceptions.ForbiddenException;
-import org.sonar.server.exceptions.UnauthorizedException;
-import org.sonar.server.platform.Platform;
-
-import javax.annotation.CheckForNull;
-import javax.annotation.Nullable;
-
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collection;
import java.util.List;
import java.util.Locale;
-import java.util.Map;
import java.util.Set;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
-import static com.google.common.collect.Lists.newArrayList;
-import static com.google.common.collect.Maps.newHashMap;
-import static com.google.common.collect.Sets.newHashSet;
-
-/**
- * Part of the current HTTP session
- */
-public class UserSession {
-
- public static final UserSession ANONYMOUS = new UserSession();
-
- private static final ThreadLocal<UserSession> THREAD_LOCAL = new ThreadLocal<UserSession>();
- private static final Logger LOG = Loggers.get(UserSession.class);
- private static final String INSUFFICIENT_PRIVILEGES_MESSAGE = "Insufficient privileges";
-
- private Integer userId;
- private String login;
- private String name;
- private Set<String> userGroups;
- private Locale locale = Locale.ENGLISH;
- List<String> globalPermissions = null;
-
- HashMultimap<String, String> projectKeyByPermission = HashMultimap.create();
- HashMultimap<String, String> projectUuidByPermission = HashMultimap.create();
- Map<String, String> projectKeyByComponentKey = newHashMap();
- Map<String, String> projectUuidByComponentUuid = newHashMap();
- List<String> projectPermissions = newArrayList();
-
- UserSession() {
- // Do not forget that when forceAuthentication is set to true, the Anyone group should not be set (but this will be check when
- // authentication will be done in Java)
- userGroups = newHashSet(DefaultGroups.ANYONE);
- }
-
+public interface UserSession {
@CheckForNull
- public String login() {
- return login;
- }
-
- UserSession setLogin(@Nullable String s) {
- this.login = Strings.emptyToNull(s);
- return this;
- }
+ String login();
@CheckForNull
- public String name() {
- return name;
- }
-
- UserSession setName(@Nullable String s) {
- this.name = Strings.emptyToNull(s);
- return this;
- }
+ String name();
@CheckForNull
- public Integer userId() {
- return userId;
- }
-
- UserSession setUserId(@Nullable Integer userId) {
- this.userId = userId;
- return this;
- }
-
- public Set<String> userGroups() {
- return userGroups;
- }
-
- UserSession setUserGroups(@Nullable String... userGroups) {
- if (userGroups != null) {
- this.userGroups.addAll(Arrays.asList(userGroups));
- }
- return this;
- }
+ Integer userId();
- public boolean isLoggedIn() {
- return login != null;
- }
+ Set<String> userGroups();
- public Locale locale() {
- return locale;
- }
+ boolean isLoggedIn();
- UserSession setLocale(@Nullable Locale l) {
- this.locale = Objects.firstNonNull(l, Locale.ENGLISH);
- return this;
- }
+ Locale locale();
- public UserSession checkLoggedIn() {
- if (login == null) {
- throw new UnauthorizedException("Authentication is required");
- }
- return this;
- }
+ /**
+ * Ensures that user is logged in otherwise throws {@link org.sonar.server.exceptions.UnauthorizedException}.
+ */
+ UserSession checkLoggedIn();
/**
- * Ensures that user implies the specified global permission. If not a {@link org.sonar.server.exceptions.ForbiddenException} is thrown.
+ * Ensures that user implies the specified global permission, otherwise throws a {@link org.sonar.server.exceptions.ForbiddenException}.
*/
- public UserSession checkGlobalPermission(String globalPermission) {
- return checkGlobalPermission(globalPermission, null);
- }
+ UserSession checkGlobalPermission(String globalPermission);
- public UserSession checkGlobalPermission(String globalPermission, @Nullable String errorMessage) {
- if (!hasGlobalPermission(globalPermission)) {
- throw new ForbiddenException(errorMessage != null ? errorMessage : INSUFFICIENT_PRIVILEGES_MESSAGE);
- }
- return this;
- }
+ /**
+ * Ensures that user implies the specified global permission, otherwise throws a {@link org.sonar.server.exceptions.ForbiddenException} with
+ * the specified error message.
+ */
+ UserSession checkGlobalPermission(String globalPermission, @Nullable String errorMessage);
/**
* Does the user have the given permission ?
*/
- public boolean hasGlobalPermission(String globalPermission) {
- return globalPermissions().contains(globalPermission);
- }
+ boolean hasGlobalPermission(String globalPermission);
- public List<String> globalPermissions() {
- if (globalPermissions == null) {
- List<String> permissionKeys = authorizationDao().selectGlobalPermissions(login);
- globalPermissions = new ArrayList<String>();
- for (String permissionKey : permissionKeys) {
- if (!GlobalPermissions.ALL.contains(permissionKey)) {
- LOG.warn("Ignoring unknown permission {} for user {}", permissionKey, login);
- } else {
- globalPermissions.add(permissionKey);
- }
- }
- }
- return globalPermissions;
- }
+ List<String> globalPermissions();
/**
- * Ensures that user implies the specified project permission. If not a {@link org.sonar.server.exceptions.ForbiddenException} is thrown.
+ * Ensures that user implies the specified project permission, otherwise throws a {@link org.sonar.server.exceptions.ForbiddenException}.
*/
- public UserSession checkProjectPermission(String projectPermission, String projectKey) {
- if (!hasProjectPermission(projectPermission, projectKey)) {
- throw new ForbiddenException(INSUFFICIENT_PRIVILEGES_MESSAGE);
- }
- return this;
- }
+ UserSession checkProjectPermission(String projectPermission, String projectKey);
/**
- * Ensures that user implies the specified project permission. If not a {@link org.sonar.server.exceptions.ForbiddenException} is thrown.
+ * Ensures that user implies the specified project permission, otherwise throws a {@link org.sonar.server.exceptions.ForbiddenException}.
*/
- public UserSession checkProjectUuidPermission(String projectPermission, String projectUuid) {
- if (!hasProjectPermissionByUuid(projectPermission, projectUuid)) {
- throw new ForbiddenException(INSUFFICIENT_PRIVILEGES_MESSAGE);
- }
- return this;
- }
+ UserSession checkProjectUuidPermission(String projectPermission, String projectUuid);
/**
* Does the user have the given project permission ?
*/
- public boolean hasProjectPermission(String permission, String projectKey) {
- if (!projectPermissions.contains(permission)) {
- Collection<String> projectKeys = authorizationDao().selectAuthorizedRootProjectsKeys(userId, permission);
- for (String key : projectKeys) {
- projectKeyByPermission.put(permission, key);
- }
- projectPermissions.add(permission);
- }
- return projectKeyByPermission.get(permission).contains(projectKey);
- }
+ boolean hasProjectPermission(String permission, String projectKey);
/**
* Does the user have the given project permission ?
*/
- public boolean hasProjectPermissionByUuid(String permission, String projectUuid) {
- if (!projectPermissions.contains(permission)) {
- Collection<String> projectUuids = authorizationDao().selectAuthorizedRootProjectsUuids(userId, permission);
- for (String key : projectUuids) {
- projectUuidByPermission.put(permission, key);
- }
- projectPermissions.add(permission);
- }
- return projectUuidByPermission.get(permission).contains(projectUuid);
- }
+ boolean hasProjectPermissionByUuid(String permission, String projectUuid);
/**
- * Ensures that user implies the specified project permission on a component. If not a {@link org.sonar.server.exceptions.ForbiddenException} is thrown.
+ * Ensures that user implies the specified project permission on a component, otherwise throws a {@link org.sonar.server.exceptions.ForbiddenException}.
*/
- public UserSession checkComponentPermission(String projectPermission, String componentKey) {
- if (!hasComponentPermission(projectPermission, componentKey)) {
- throw new ForbiddenException(INSUFFICIENT_PRIVILEGES_MESSAGE);
- }
- return this;
- }
+ UserSession checkComponentPermission(String projectPermission, String componentKey);
/**
- * Ensures that user implies the specified component permission on a component. If not a {@link org.sonar.server.exceptions.ForbiddenException} is thrown.
+ * Ensures that user implies the specified component permission on a component, otherwise throws a {@link org.sonar.server.exceptions.ForbiddenException}.
*/
- public UserSession checkComponentUuidPermission(String permission, String componentUuid) {
- if (!hasComponentUuidPermission(permission, componentUuid)) {
- throw new ForbiddenException(INSUFFICIENT_PRIVILEGES_MESSAGE);
- }
- return this;
- }
+ UserSession checkComponentUuidPermission(String permission, String componentUuid);
/**
* Does the user have the given project permission for a component key ?
*/
- public boolean hasComponentPermission(String permission, String componentKey) {
- String projectKey = projectKeyByComponentKey.get(componentKey);
- if (projectKey == null) {
- ResourceDto project = resourceDao().getRootProjectByComponentKey(componentKey);
- if (project == null) {
- return false;
- }
- projectKey = project.getKey();
- }
- boolean hasComponentPermission = hasProjectPermission(permission, projectKey);
- if (hasComponentPermission) {
- projectKeyByComponentKey.put(componentKey, projectKey);
- return true;
- }
- return false;
- }
+ boolean hasComponentPermission(String permission, String componentKey);
/**
* Does the user have the given project permission for a component uuid ?
*/
- public boolean hasComponentUuidPermission(String permission, String componentUuid) {
- String projectUuid = projectUuidByComponentUuid.get(componentUuid);
- if (projectUuid == null) {
- ResourceDto project = resourceDao().getResource(componentUuid);
- if (project == null) {
- return false;
- }
- projectUuid = project.getProjectUuid();
- }
- boolean hasComponentPermission = hasProjectPermissionByUuid(permission, projectUuid);
- if (hasComponentPermission) {
- projectUuidByComponentUuid.put(componentUuid, projectUuid);
- return true;
- }
- return false;
- }
-
- AuthorizationDao authorizationDao() {
- return Platform.component(AuthorizationDao.class);
- }
-
- ResourceDao resourceDao() {
- return Platform.component(ResourceDao.class);
- }
-
- public static UserSession get() {
- return Objects.firstNonNull(THREAD_LOCAL.get(), ANONYMOUS);
- }
-
- static void set(UserSession session) {
- THREAD_LOCAL.set(session);
- }
-
- static void remove() {
- THREAD_LOCAL.remove();
- }
-
- static boolean hasSession() {
- return THREAD_LOCAL.get() != null;
- }
+ boolean hasComponentUuidPermission(String permission, String componentUuid);
}
import javax.servlet.*;
import java.io.IOException;
+import org.sonar.api.utils.log.Loggers;
+import org.sonar.server.platform.Platform;
/**
* @since 3.6
*/
public class UserSessionFilter implements Filter {
+ private final Platform platform;
+
+ public UserSessionFilter() {
+ this.platform = Platform.getInstance();
+ }
+
+ public UserSessionFilter(Platform platform) {
+ this.platform = platform;
+ }
+
@Override
public void init(FilterConfig filterConfig) throws ServletException {
// nothing to do
try {
chain.doFilter(servletRequest, servletResponse);
} finally {
- UserSession.remove();
+ ThreadLocalUserSession userSession = platform.getContainer().getComponentByType(ThreadLocalUserSession.class);
+ if (userSession == null) {
+ Loggers.get(UserSessionFilter.class).error("Can not retrieve ThreadLocalUserSession from Platform");
+ }
+ else {
+ userSession.remove();
+ }
}
}
}
private static final String PARAM_PASSWORD = "password";
private final UserUpdater userUpdater;
+ private final UserSession userSession;
- public ChangePasswordAction(UserUpdater userUpdater) {
+ public ChangePasswordAction(UserUpdater userUpdater, UserSession userSession) {
this.userUpdater = userUpdater;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkLoggedIn().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkLoggedIn().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
String login = request.mandatoryParam(PARAM_LOGIN);
String password = request.mandatoryParam(PARAM_PASSWORD);
private final UserIndex index;
private final UserUpdater userUpdater;
private final I18n i18n;
+ private final UserSession userSession;
- public CreateAction(UserIndex index, UserUpdater userUpdater, I18n i18n) {
+ public CreateAction(UserIndex index, UserUpdater userUpdater, I18n i18n, UserSession userSession) {
this.index = index;
this.userUpdater = userUpdater;
this.i18n = i18n;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkLoggedIn().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkLoggedIn().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
String login = request.mandatoryParam(PARAM_LOGIN);
NewUser newUser = NewUser.create()
private void writeReactivationMessage(JsonWriter json, String login) {
json.name("infos").beginArray();
json.beginObject();
- String text = i18n.message(UserSession.get().locale(), "user.reactivated", "user.reactivated", login);
+ String text = i18n.message(userSession.locale(), "user.reactivated", "user.reactivated", login);
json.prop("msg", text);
json.endObject();
json.endArray();
import org.sonar.server.user.UserSession;
public class CurrentUserAction implements BaseUsersWsAction {
+ private final UserSession userSession;
+
+ public CurrentUserAction(UserSession userSession) {
+ this.userSession = userSession;
+ }
+
@Override
public void define(NewController context) {
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession session = UserSession.get();
JsonWriter json = response.newJsonWriter().beginObject();
- writeUserDetails(json, session);
+ writeUserDetails(json, userSession);
json.endObject().close();
}
private final UserIndex index;
private final UserUpdater userUpdater;
+ private final UserSession userSession;
- public DeactivateAction(UserIndex index, UserUpdater userUpdater) {
+ public DeactivateAction(UserIndex index, UserUpdater userUpdater, UserSession userSession) {
this.index = index;
this.userUpdater = userUpdater;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkLoggedIn().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkLoggedIn().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
String login = request.mandatoryParam(PARAM_LOGIN);
userUpdater.deactivateUserByLogin(login);
private final UserIndex index;
private final UserUpdater userUpdater;
+ private final UserSession userSession;
- public UpdateAction(UserIndex index, UserUpdater userUpdater) {
+ public UpdateAction(UserIndex index, UserUpdater userUpdater, UserSession userSession) {
this.index = index;
this.userUpdater = userUpdater;
+ this.userSession = userSession;
}
@Override
@Override
public void handle(Request request, Response response) throws Exception {
- UserSession.get().checkLoggedIn().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
+ userSession.checkLoggedIn().checkGlobalPermission(GlobalPermissions.SYSTEM_ADMIN);
String login = request.mandatoryParam(PARAM_LOGIN);
UpdateUser updateUser = UpdateUser.create(login);
package org.sonar.server.ws;
import com.google.common.base.Charsets;
+import java.io.OutputStreamWriter;
+import java.util.List;
+import javax.servlet.http.HttpServletResponse;
import org.picocontainer.Startable;
import org.sonar.api.ServerSide;
import org.sonar.api.i18n.I18n;
import org.sonar.server.plugins.MimeTypes;
import org.sonar.server.user.UserSession;
-import javax.servlet.http.HttpServletResponse;
-
-import java.io.OutputStreamWriter;
-import java.util.List;
-
/**
* @since 4.2
*/
public class WebServiceEngine implements Startable {
private final WebService.Context context;
-
private final I18n i18n;
+ private final UserSession userSession;
- public WebServiceEngine(WebService[] webServices, I18n i18n) {
+ public WebServiceEngine(WebService[] webServices, I18n i18n, UserSession userSession) {
+ this.userSession = userSession;
context = new WebService.Context();
for (WebService webService : webServices) {
webService.define(context);
try {
json.beginObject();
- errors.writeJson(json, i18n, UserSession.get().locale());
+ errors.writeJson(json, i18n, userSession.locale());
json.endObject();
} finally {
// TODO if close() fails, the runtime exception should not hide the
*/
package org.sonar.server.activity;
+import java.util.List;
+import java.util.Map;
import org.assertj.core.data.MapEntry;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.api.utils.System2;
import org.sonar.server.db.DbClient;
import org.sonar.server.es.EsTester;
import org.sonar.server.issue.db.IssueDao;
-
-import java.util.List;
-import java.util.Map;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
@ClassRule
public static DbTester db = new DbTester();
-
@ClassRule
public static EsTester es = new EsTester().addDefinitions(new ActivityIndexDefinition(new Settings()));
+ @Rule
+ public UserSessionRule userSession = UserSessionRule.standalone().logon();
System2 system = mock(System2.class);
ActivityService service;
ActivityIndexer indexer = new ActivityIndexer(dbClient, es.client());
// indexers are disabled by default
indexer.setEnabled(true);
- service = new ActivityService(dbClient, indexer);
+ service = new ActivityService(dbClient, indexer, userSession);
}
@Test
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.activity.Activity;
import org.sonar.server.activity.ActivityService;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
ActivitiesWebService ws;
ActivityService service;
activity.setData("foo", "bar");
service.save(activity);
- MockUserSession.set();
-
WsTester.TestRequest request = tester.wsTester().newGetRequest("api/activities", "search");
WsTester.Result result = request.execute();
assertThat(result.outputAsString()).contains("\"total\":1");
*/
package org.sonar.server.batch;
+import java.io.File;
import org.apache.commons.io.FileUtils;
import org.junit.Before;
import org.junit.Rule;
import org.sonar.core.properties.PropertiesDao;
import org.sonar.server.db.DbClient;
import org.sonar.server.issue.index.IssueIndex;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.io.File;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class BatchWsTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Rule
public TemporaryFolder temp = new TemporaryFolder();
@Before
public void before() {
tester = new WsTester(new BatchWs(batchIndex,
- new GlobalRepositoryAction(mock(DbClient.class), mock(PropertiesDao.class)),
+ new GlobalRepositoryAction(mock(DbClient.class), mock(PropertiesDao.class), userSessionRule),
new ProjectRepositoryAction(mock(ProjectRepositoryLoader.class)),
- new IssuesAction(mock(DbClient.class), mock(IssueIndex.class))));
+ new IssuesAction(mock(DbClient.class), mock(IssueIndex.class), userSessionRule)));
}
@Test
import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.measure.persistence.MetricDao;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static com.google.common.collect.Lists.newArrayList;
@RunWith(MockitoJUnitRunner.class)
public class GlobalRepositoryActionTest {
-
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Rule
public ExpectedException thrown = ExpectedException.none();
when(dbClient.openSession(false)).thenReturn(session);
when(dbClient.metricDao()).thenReturn(metricDao);
- tester = new WsTester(new BatchWs(mock(BatchIndex.class), new GlobalRepositoryAction(dbClient, propertiesDao)));
+ tester = new WsTester(new BatchWs(mock(BatchIndex.class), new GlobalRepositoryAction(dbClient, propertiesDao, userSessionRule)));
}
@Test
public void return_metrics() throws Exception {
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION, GlobalPermissions.PREVIEW_EXECUTION);
+
when(metricDao.selectEnabled(session)).thenReturn(newArrayList(
new MetricDto().setId(1).setKey("coverage").setDescription("Coverage by unit tests").setValueType("PERCENT").setQualitative(true)
.setWorstValue(0d).setBestValue(100d).setOptimizedBestValue(false).setDirection(1).setEnabled(true)
@Test
public void return_global_settings() throws Exception {
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION, GlobalPermissions.PREVIEW_EXECUTION);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION, GlobalPermissions.PREVIEW_EXECUTION);
when(propertiesDao.selectGlobalProperties(session)).thenReturn(newArrayList(
new PropertyDto().setKey("foo").setValue("bar"),
@Test
public void return_only_license_settings_without_scan_but_with_preview_permission() throws Exception {
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
when(propertiesDao.selectGlobalProperties(session)).thenReturn(newArrayList(
new PropertyDto().setKey("foo").setValue("bar"),
@Test
public void access_forbidden_without_scan_and_preview_permission() throws Exception {
- MockUserSession.set().setLogin("john").setGlobalPermissions();
+ userSessionRule.setGlobalPermissions();
when(propertiesDao.selectGlobalProperties(session)).thenReturn(newArrayList(
new PropertyDto().setKey("foo").setValue("bar"),
package org.sonar.server.batch;
+import java.io.ByteArrayInputStream;
+import java.util.Arrays;
+import javax.annotation.Nullable;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.sonar.api.config.Settings;
import org.sonar.server.issue.index.IssueIndex;
import org.sonar.server.issue.index.IssueIndexDefinition;
import org.sonar.server.issue.index.IssueIndexer;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import org.sonar.test.DbTests;
-import javax.annotation.Nullable;
-
-import java.io.ByteArrayInputStream;
-import java.util.Arrays;
-
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
@ClassRule
public static DbTester db = new DbTester();
-
@ClassRule
public static EsTester es = new EsTester().addDefinitions(new IssueIndexDefinition(new Settings()));
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
IssueIndex issueIndex;
IssueIndexer issueIndexer;
this.session = db.myBatis().openSession(false);
DbClient dbClient = new DbClient(db.database(), db.myBatis(), new IssueDao(db.myBatis()), new ComponentDao());
- issueIndex = new IssueIndex(es.client(), System2.INSTANCE);
+ issueIndex = new IssueIndex(es.client(), System2.INSTANCE, userSessionRule);
issueIndexer = new IssueIndexer(null, es.client());
issueAuthorizationIndexer = new IssueAuthorizationIndexer(null, es.client());
- issuesAction = new IssuesAction(dbClient, issueIndex);
+ issuesAction = new IssuesAction(dbClient, issueIndex, userSessionRule);
componentDao = new ComponentDao();
tester = new WsTester(new BatchWs(new BatchIndex(mock(Server.class)), issuesAction));
.setChecksum(null)
.setAssignee(null));
- MockUserSession.set().setLogin("henry").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
+ userSessionRule.logon("henry").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
WsTester.TestRequest request = tester.newGetRequest("batch", "issues").setParam("key", PROJECT_KEY);
.setChecksum("123456")
.setAssignee("john"));
- MockUserSession.set().setLogin("henry").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
+ userSessionRule.logon("henry").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
WsTester.TestRequest request = tester.newGetRequest("batch", "issues").setParam("key", PROJECT_KEY);
.setChecksum("123456")
.setAssignee("john"));
- MockUserSession.set().setLogin("henry").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
+ userSessionRule.logon("henry").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
WsTester.TestRequest request = tester.newGetRequest("batch", "issues").setParam("key", MODULE_KEY);
ServerIssue serverIssue = ServerIssue.parseDelimitedFrom(new ByteArrayInputStream(request.execute().output()));
.setChecksum("123456")
.setAssignee("john"));
- MockUserSession.set().setLogin("henry").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
+ userSessionRule.logon("henry").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
WsTester.TestRequest request = tester.newGetRequest("batch", "issues").setParam("key", FILE_KEY);
ServerIssue serverIssue = ServerIssue.parseDelimitedFrom(new ByteArrayInputStream(request.execute().output()));
.setChecksum("123456")
.setAssignee("john"));
- MockUserSession.set().setLogin("henry").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
+ userSessionRule.logon("henry").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
WsTester.TestRequest request = tester.newGetRequest("batch", "issues").setParam("key", MODULE_KEY);
ServerIssue previousIssue = ServerIssue.parseDelimitedFrom(new ByteArrayInputStream(request.execute().output()));
.setChecksum("123456")
.setAssignee("john"));
- MockUserSession.set().setLogin("henry").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
+ userSessionRule.logon("henry").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
WsTester.TestRequest request = tester.newGetRequest("batch", "issues").setParam("key", PROJECT_KEY);
ServerIssue serverIssue = ServerIssue.parseDelimitedFrom(new ByteArrayInputStream(request.execute().output()));
@Test(expected = ForbiddenException.class)
public void fail_without_preview_permission() throws Exception {
- MockUserSession.set().setLogin("henry").setGlobalPermissions(GlobalPermissions.PROVISIONING);
+ userSessionRule.logon("henry").setGlobalPermissions(GlobalPermissions.PROVISIONING);
WsTester.TestRequest request = tester.newGetRequest("batch", "issues").setParam("key", PROJECT_KEY);
request.execute();
package org.sonar.server.batch;
-import org.sonar.core.source.db.FileSourceDto.Type;
-import org.sonar.server.source.db.FileSourceDao;
-
import com.google.common.collect.ImmutableMap;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.Severity;
import org.sonar.core.rule.RuleDto;
import org.sonar.core.rule.RuleParamDto;
import org.sonar.core.source.db.FileSourceDto;
+import org.sonar.core.source.db.FileSourceDto.Type;
import org.sonar.server.component.ComponentTesting;
import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.qualityprofile.RuleActivation;
import org.sonar.server.qualityprofile.RuleActivator;
import org.sonar.server.rule.RuleTesting;
+import org.sonar.server.source.db.FileSourceDao;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester().addXoo();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbSession dbSession;
@Test
public void return_project_settings() {
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
addDefaultProfile();
@Test
public void not_returned_secured_settings_with_only_preview_permission() {
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION).addProjectUuidPermissions(UserRole.USER, project.uuid());
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION).addProjectUuidPermissions(UserRole.USER, project.uuid());
tester.get(DbClient.class).componentDao().insert(dbSession, project);
addDefaultProfile();
@Test
public void return_project_with_module_settings() {
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
addDefaultProfile();
@Test
public void return_project_with_module_settings_inherited_from_project() {
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
addDefaultProfile();
@Test
public void return_project_with_module_with_sub_module() {
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
addDefaultProfile();
@Test
public void return_project_with_two_modules() {
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
addDefaultProfile();
public void return_provisioned_project_settings() {
// No snapshot attached on the project -> provisioned project
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
addDefaultProfile();
// No module properties
ComponentDto subModule = ComponentTesting.newModuleDto(module);
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, subModule);
// Sub module properties
tester.get(DbClient.class).propertiesDao().setProperty(new PropertyDto().setKey("sonar.jira.login.secured").setValue("john").setResourceId(module.getId()), dbSession);
ComponentDto subModule = ComponentTesting.newModuleDto(module);
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, subModule);
// Sub module properties
// No module property
ComponentDto subModule = ComponentTesting.newModuleDto(module);
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, subModule);
// No sub module property
tester.get(DbClient.class).propertiesDao().setProperty(new PropertyDto().setKey("sonar.jira.project.key").setValue("SONAR-SERVER").setResourceId(module.getId()), dbSession);
ComponentDto subModule = ComponentTesting.newModuleDto(module);
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, subModule);
// No sub module property
Date ruleUpdatedAt = DateUtils.parseDateTime("2014-01-14T13:00:00+0100");
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
QualityProfileDto profileDto = QProfileTesting.newDto(QProfileName.createFor(ServerTester.Xoo.KEY, "SonarQube way"), "abcd").setRulesUpdatedAt(
Date ruleUpdatedAt = DateUtils.parseDateTime("2014-01-14T13:00:00+0100");
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
QualityProfileDto profileDto = QProfileTesting.newDto(QProfileName.createFor(ServerTester.Xoo.KEY, "SonarQube way"), "abcd").setRulesUpdatedAt(
Date ruleUpdatedAt = DateUtils.parseDateTime("2014-01-14T13:00:00+0100");
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
QualityProfileDto profileDto = QProfileTesting.newDto(QProfileName.createFor(ServerTester.Xoo.KEY, "SonarQube way"), "abcd").setRulesUpdatedAt(
@Test
public void return_quality_profiles_even_when_project_does_not_exists() {
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
Date ruleUpdatedAt = DateUtils.parseDateTime("2014-01-14T13:00:00+0100");
QualityProfileDto profileDto = QProfileTesting.newDto(QProfileName.createFor(ServerTester.Xoo.KEY, "SonarQube way"), "abcd").setRulesUpdatedAt(
// No snapshot attached on the project -> provisioned project
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
QualityProfileDto profileDto = QProfileTesting.newDto(QProfileName.createFor(ServerTester.Xoo.KEY, "SonarQube way"), "abcd").setRulesUpdatedAt(
@Test
public void fail_when_no_quality_profile_for_a_language() {
ComponentDto project = ComponentTesting.newProjectDto().setKey("org.codehaus.sonar:sonar");
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
dbSession.commit();
@Test
public void return_active_rules() {
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
QualityProfileDto profileDto = QProfileTesting.newDto(QProfileName.createFor(ServerTester.Xoo.KEY, "SonarQube way"), "abcd").setRulesUpdatedAt(
@Test
public void return_only_active_rules_from_project_profile() {
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
RuleKey ruleKey1 = RuleKey.of("squid", "AvoidCycle");
@Test
public void return_more_than_10_active_rules() {
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
QualityProfileDto profileDto = QProfileTesting.newDto(QProfileName.createFor(ServerTester.Xoo.KEY, "SonarQube way"), "abcd")
Date ruleUpdatedAt = DateUtils.parseDateTime("2014-01-14T13:00:00+0100");
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
QualityProfileDto profileDto = QProfileTesting.newDto(QProfileName.createFor(ServerTester.Xoo.KEY, "SonarQube way"), "abcd").setRulesUpdatedAt(
@Test
public void return_manual_rules() {
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
addDefaultProfile();
@Test
public void fail_if_no_permission() {
- MockUserSession.set().setLogin("john").setGlobalPermissions();
+ userSessionRule.logon("john").setGlobalPermissions();
ComponentDto project = ComponentTesting.newProjectDto();
tester.get(DbClient.class).componentDao().insert(dbSession, project);
@Test
public void fail_when_not_preview_and_only_dry_run_permission() {
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
ComponentDto project = ComponentTesting.newProjectDto();
tester.get(DbClient.class).componentDao().insert(dbSession, project);
@Test
public void return_file_data_from_single_project() {
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
addDefaultProfile();
@Test
public void return_file_data_from_multi_modules() {
ComponentDto project = ComponentTesting.newProjectDto();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, project);
addDefaultProfile();
tester.get(FileSourceDao.class).insert(newFileSourceDto(projectFile).setSrcHash("123456"));
ComponentDto module = ComponentTesting.newModuleDto(project);
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
tester.get(DbClient.class).componentDao().insert(dbSession, module);
// File on module
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.api.platform.Server;
import org.sonar.batch.protocol.input.BatchInput.User;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.server.es.EsTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.user.index.UserDoc;
import org.sonar.server.user.index.UserIndex;
import org.sonar.server.user.index.UserIndexDefinition;
@ClassRule
public static EsTester es = new EsTester().addDefinitions(new UserIndexDefinition(new Settings()));
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
UserIndex userIndex;
es.truncateIndices();
userIndex = new UserIndex(es.client());
- usersAction = new UsersAction(userIndex);
+ usersAction = new UsersAction(userIndex, userSessionRule);
tester = new WsTester(new BatchWs(new BatchIndex(mock(Server.class)), usersAction));
}
new UserDoc().setLogin("ada.lovelace").setName("Ada Lovelace").setActive(false),
new UserDoc().setLogin("grace.hopper").setName("Grace Hopper").setActive(true));
- MockUserSession.set().setLogin("sonarqtech").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
+ userSessionRule.logon("sonarqtech").setGlobalPermissions(GlobalPermissions.PREVIEW_EXECUTION);
WsTester.TestRequest request = tester.newGetRequest("batch", "users").setParam("logins", "ada.lovelace,grace.hopper");
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.security.DefaultGroups;
import org.sonar.api.web.UserRole;
import org.sonar.server.component.db.ComponentDao;
import org.sonar.server.db.DbClient;
import org.sonar.server.es.EsClient;
-import org.sonar.server.issue.index.IssueIndexDefinition;
import org.sonar.server.issue.IssueTesting;
import org.sonar.server.issue.db.IssueDao;
import org.sonar.server.issue.index.IssueIndex;
+import org.sonar.server.issue.index.IssueIndexDefinition;
import org.sonar.server.issue.index.IssueIndexer;
import org.sonar.server.permission.InternalPermissionService;
import org.sonar.server.permission.PermissionChange;
import org.sonar.server.rule.db.RuleDao;
import org.sonar.server.search.IndexClient;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
IndexClient index;
// project can be seen by anyone
session.commit();
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
tester.get(InternalPermissionService.class).addPermission(new PermissionChange().setComponentKey(project.getKey()).setGroup(DefaultGroups.ANYONE).setPermission(UserRole.USER));
assertThat(countIssueAuthorizationDocs()).isEqualTo(1);
package org.sonar.server.component;
+import java.util.Arrays;
+import java.util.Map;
import org.assertj.core.api.Fail;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.resources.Qualifiers;
import org.sonar.api.security.DefaultGroups;
import org.sonar.server.permission.PermissionChange;
import org.sonar.server.platform.Platform;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.Arrays;
-import java.util.Map;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession session;
session.commit();
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.ADMIN, project.uuid());
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.ADMIN, project.uuid());
service.updateKey(project.key(), "sample2:root");
session.commit();
session.commit();
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.ADMIN, project.uuid());
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.ADMIN, project.uuid());
service.updateKey(module.key(), "sample:root2:module");
session.commit();
session.commit();
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.ADMIN, provisionedProject.uuid());
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.ADMIN, provisionedProject.uuid());
service.updateKey(provisionedProject.key(), "provisionedProject2");
session.commit();
@Test(expected = ForbiddenException.class)
public void fail_to_update_project_key_without_admin_permission() {
ComponentDto project = createProject("sample:root");
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.USER, project.uuid());
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.USER, project.uuid());
service.updateKey(project.key(), "sample2:root");
}
session.commit();
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.ADMIN, project.uuid());
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.ADMIN, project.uuid());
Map<String, String> result = service.checkModuleKeysBeforeRenaming(project.key(), "sample", "sample2");
assertThat(result).hasSize(2);
session.commit();
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.ADMIN, project.uuid());
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.ADMIN, project.uuid());
Map<String, String> result = service.checkModuleKeysBeforeRenaming(project.key(), "sample:root", "foo");
assertThat(result).hasSize(2);
@Test(expected = ForbiddenException.class)
public void fail_to_check_module_keys_before_renaming_without_admin_permission() {
ComponentDto project = createProject("sample:root");
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.USER, project.uuid());
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.USER, project.uuid());
service.checkModuleKeysBeforeRenaming(project.key(), "sample", "sample2");
}
session.commit();
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.ADMIN, project.uuid());
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.ADMIN, project.uuid());
service.bulkUpdateKey(project.key(), "sample", "sample2");
session.commit();
session.commit();
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.ADMIN, provisionedProject.uuid());
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.ADMIN, provisionedProject.uuid());
service.bulkUpdateKey(provisionedProject.key(), "provisionedProject", "provisionedProject2");
session.commit();
@Test(expected = ForbiddenException.class)
public void fail_to_bulk_update_project_key_without_admin_permission() {
ComponentDto project = createProject("sample:root");
- MockUserSession.set().setLogin("john").addProjectPermissions(UserRole.USER, project.key());
+ userSessionRule.logon("john").addProjectPermissions(UserRole.USER, project.key());
service.bulkUpdateKey("sample:root", "sample", "sample2");
}
@Test
public void create_project() {
executeStartupTasksToCreateDefaultPermissionTemplate();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.PROVISIONING);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.PROVISIONING);
String key = service.create(NewComponent.create("struts", "Struts project"));
@Test
public void create_new_project_with_branch() {
executeStartupTasksToCreateDefaultPermissionTemplate();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.PROVISIONING);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.PROVISIONING);
String key = service.create(NewComponent.create("struts", "Struts project").setBranch("origin/branch"));
@Test
public void create_view() {
executeStartupTasksToCreateDefaultPermissionTemplate();
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.PROVISIONING);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.PROVISIONING);
String key = service.create(NewComponent.create("all-project", "All Projects").setQualifier(Qualifiers.VIEW));
@Test
public void fail_to_create_new_component_on_invalid_key() {
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.PROVISIONING);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.PROVISIONING);
try {
service.create(NewComponent.create("struts?parent", "Struts project"));
@Test
public void fail_to_create_new_component_on_invalid_branch() {
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.PROVISIONING);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.PROVISIONING);
try {
service.create(NewComponent.create("struts", "Struts project").setBranch("origin?branch"));
@Test
public void fail_to_create_new_component_if_key_already_exists() {
- MockUserSession.set().setLogin("john").setGlobalPermissions(GlobalPermissions.PROVISIONING);
+ userSessionRule.logon("john").setGlobalPermissions(GlobalPermissions.PROVISIONING);
ComponentDto project = ComponentTesting.newProjectDto().setKey("struts");
tester.get(ComponentDao.class).insert(session, project);
session.commit();
// project can be seen by anyone
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
tester.get(InternalPermissionService.class).addPermission(new PermissionChange().setComponentKey(project.getKey()).setGroup(DefaultGroups.ANYONE).setPermission(UserRole.USER));
- MockUserSession.set();
return project;
}
package org.sonar.server.component.ws;
+import java.util.List;
+import java.util.Locale;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.measure.persistence.MeasureDao;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.util.List;
-import java.util.Locale;
-
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyListOf;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class ComponentAppActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
static final String SUB_PROJECT_KEY = "org.codehaus.sonar:sonar-plugin-api";
static final String COMPONENT_KEY = "org.codehaus.sonar:sonar-plugin-api:src/main/java/org/sonar/api/Plugin.java";
when(measureDao.findByComponentKeyAndMetricKeys(eq(session), anyString(), anyListOf(String.class))).thenReturn(measures);
- tester = new WsTester(new ComponentsWs(new ComponentAppAction(dbClient, durations, i18n), mock(SearchAction.class)));
+ tester = new WsTester(new ComponentsWs(new ComponentAppAction(dbClient, durations, i18n, userSessionRule), mock(SearchAction.class)));
}
@Test
public void app() throws Exception {
- MockUserSession.set().setLogin("john").addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
+ userSessionRule.logon("john").addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
ComponentDto project = newProject();
ComponentDto file = ComponentTesting.newFileDto(project)
@Test
public void app_with_measures() throws Exception {
- MockUserSession.set().addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
+ userSessionRule.addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
ComponentDto project = newProject();
newComponent(project);
@Test
public void app_with_overall_measure() throws Exception {
- MockUserSession.set().addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
+ userSessionRule.addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
ComponentDto project = newProject();
newComponent(project);
@Test
public void app_with_ut_measure() throws Exception {
- MockUserSession.set().addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
+ userSessionRule.addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
ComponentDto project = newProject();
newComponent(project);
@Test
public void app_with_it_measure() throws Exception {
- MockUserSession.set().addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
+ userSessionRule.addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
ComponentDto project = newProject();
newComponent(project);
@Test
public void fail_on_unknown_component() {
- MockUserSession.set().setLogin("john").addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
+ userSessionRule.logon("john").addComponentPermission(UserRole.USER, SUB_PROJECT_KEY, COMPONENT_KEY);
when(componentDao.getNullableByUuid(session, COMPONENT_UUID)).thenReturn(null);
try {
package org.sonar.server.component.ws;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.i18n.I18n;
import org.sonar.api.server.ws.RailsHandler;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.Durations;
import org.sonar.server.db.DbClient;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
public class ComponentsWsTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
WebService.Controller controller;
@Before
public void setUp() {
- WsTester tester = new WsTester(new ComponentsWs(new ComponentAppAction(mock(DbClient.class), mock(Durations.class), mock(I18n.class)), new SearchAction(mock(DbClient.class))));
+ WsTester tester = new WsTester(new ComponentsWs(new ComponentAppAction(mock(DbClient.class), mock(Durations.class), mock(I18n.class), userSessionRule), new SearchAction(mock(DbClient.class), userSessionRule)));
controller = tester.controller("api/components");
}
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.server.ws.WebService.Param;
import org.sonar.api.utils.DateUtils;
import org.sonar.server.component.db.ComponentDao;
import org.sonar.server.component.db.SnapshotDao;
import org.sonar.server.db.DbClient;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import org.sonar.test.JsonAssert;
@ClassRule
public static DbTester db = new DbTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
WsTester ws;
DbClient dbClient;
ComponentDao componentDao;
@After
- public void tearDown() throws Exception {
+ public void tearDown() {
dbSession.close();
}
@Before
- public void setUp() throws Exception {
+ public void setUp() {
dbClient = new DbClient(db.database(), db.myBatis(), new ComponentDao(), new SnapshotDao(System2.INSTANCE));
dbSession = dbClient.openSession(false);
componentDao = dbClient.componentDao();
db.truncateTables();
- ws = new WsTester(new ProjectsWs(new ProvisionedProjectsAction(dbClient)));
+ ws = new WsTester(new ProjectsWs(new ProvisionedProjectsAction(dbClient, userSessionRule)));
}
@Test
public void all_provisioned_projects_without_analyzed_projects() throws Exception {
- MockUserSession.set().setGlobalPermissions(UserRole.ADMIN);
+ userSessionRule.setGlobalPermissions(UserRole.ADMIN);
ComponentDto analyzedProject = ComponentTesting.newProjectDto("analyzed-uuid-1");
componentDao.insert(dbSession, newProvisionedProject("1"), newProvisionedProject("2"));
analyzedProject = componentDao.insert(dbSession, analyzedProject);
@Test
public void provisioned_projects_with_correct_paginated() throws Exception {
- MockUserSession.set().setGlobalPermissions(UserRole.ADMIN);
+ userSessionRule.setGlobalPermissions(UserRole.ADMIN);
for (int i = 1; i <= 10; i++) {
componentDao.insert(dbSession, newProvisionedProject(String.valueOf(i)));
}
@Test
public void provisioned_projects_with_desired_fields() throws Exception {
- MockUserSession.set().setGlobalPermissions(UserRole.ADMIN);
+ userSessionRule.setGlobalPermissions(UserRole.ADMIN);
componentDao.insert(dbSession, newProvisionedProject("1"));
dbSession.commit();
@Test
public void provisioned_projects_with_query() throws Exception {
- MockUserSession.set().setGlobalPermissions(UserRole.ADMIN);
+ userSessionRule.setGlobalPermissions(UserRole.ADMIN);
componentDao.insert(dbSession, newProvisionedProject("1"), newProvisionedProject("2"));
dbSession.commit();
@Test
public void provisioned_projects_as_defined_in_the_example() throws Exception {
- MockUserSession.set().setGlobalPermissions(UserRole.ADMIN);
+ userSessionRule.setGlobalPermissions(UserRole.ADMIN);
ComponentDto hBaseProject = ComponentTesting.newProjectDto("ce4c03d6-430f-40a9-b777-ad877c00aa4d")
.setKey("org.apache.hbas:hbase")
.setName("HBase")
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.sonar.api.web.UserRole;
import org.sonar.server.component.db.ComponentDao;
import org.sonar.server.component.db.ComponentIndexDao;
import org.sonar.server.db.DbClient;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import org.sonar.test.DbTests;
@ClassRule
public static DbTester dbTester = new DbTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
WsTester tester;
DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(),
new ComponentDao(), new AuthorizationDao(dbTester.myBatis()), new ComponentIndexDao()
);
- tester = new WsTester(new ComponentsWs(mock(ComponentAppAction.class), new SearchAction(dbClient)));
+ tester = new WsTester(new ComponentsWs(mock(ComponentAppAction.class), new SearchAction(dbClient, userSessionRule)));
}
@Test
public void return_projects_from_view() throws Exception {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.USER, "EFGH");
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.USER, "EFGH");
WsTester.TestRequest request = tester.newGetRequest("api/components", "search").setParam("componentUuid", "EFGH").setParam("q", "st");
request.execute().assertJson(getClass(), "return_projects_from_view.json");
@Test
public void return_projects_from_subview() throws Exception {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- MockUserSession.set().setLogin("john").addComponentUuidPermission(UserRole.USER, "EFGH", "FGHI");
+ userSessionRule.logon("john").addComponentUuidPermission(UserRole.USER, "EFGH", "FGHI");
WsTester.TestRequest request = tester.newGetRequest("api/components", "search").setParam("componentUuid", "FGHI").setParam("q", "st");
request.execute().assertJson(getClass(), "return_projects_from_subview.json");
@Test
public void return_only_authorized_projects_from_view() throws Exception {
dbTester.prepareDbUnit(getClass(), "return_only_authorized_projects_from_view.xml");
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.USER, "EFGH");
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.USER, "EFGH");
WsTester.TestRequest request = tester.newGetRequest("api/components", "search").setParam("componentUuid", "EFGH").setParam("q", "st");
request.execute().assertJson(getClass(), "return_only_authorized_projects_from_view.json");
@Test
public void return_paged_result() throws Exception {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.USER, "EFGH");
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.USER, "EFGH");
WsTester.TestRequest request = tester.newGetRequest("api/components", "search").setParam("componentUuid", "EFGH").setParam("q", "st").setParam("p", "2").setParam("ps", "1");
request.execute().assertJson(getClass(), "return_paged_result.json");
@Test
public void return_only_first_page() throws Exception {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.USER, "EFGH");
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.USER, "EFGH");
WsTester.TestRequest request = tester.newGetRequest("api/components", "search").setParam("componentUuid", "EFGH").setParam("q", "st").setParam("p", "1").setParam("ps", "1");
request.execute().assertJson(getClass(), "return_only_first_page.json");
@Test
public void fail_when_search_param_is_too_short() throws Exception {
dbTester.prepareDbUnit(getClass(), "shared.xml");
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.USER, "EFGH");
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.USER, "EFGH");
WsTester.TestRequest request = tester.newGetRequest("api/components", "search").setParam("componentUuid", "EFGH").setParam("q", "s");
package org.sonar.server.computation.ws;
+import java.util.Date;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.core.computation.db.AnalysisReportDto;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.server.activity.ActivityService;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.util.Date;
-
/**
* TODO replace this medium test by a small test
*/
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
HistoryWsAction sut;
ActivityService activityService;
activity2.setData("submittedAt", new Date());
activityService.save(activity2);
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
WsTester.TestRequest request = tester.wsTester().newGetRequest("api/computation", "history");
request.execute().assertJson(getClass(), "list_history_reports.json");
@Test(expected = ForbiddenException.class)
public void requires_admin_right() throws Exception {
- MockUserSession.set();
-
WsTester.TestRequest request = tester.wsTester().newGetRequest("api/computation", "history");
request.execute();
}
package org.sonar.server.computation.ws;
+import java.io.InputStream;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.server.ws.WebService;
import org.sonar.core.computation.db.AnalysisReportDto;
import org.sonar.server.computation.ComputationThreadLauncher;
import org.sonar.server.computation.ReportQueue;
import org.sonar.server.exceptions.ForbiddenException;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.io.InputStream;
-
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
public class SubmitReportWsActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
ComputationThreadLauncher workerLauncher = mock(ComputationThreadLauncher.class);
ReportQueue queue = mock(ReportQueue.class);
@Before
public void before() {
- sut = new SubmitReportWsAction(queue, workerLauncher);
+ sut = new SubmitReportWsAction(queue, workerLauncher, userSessionRule);
wsTester = new WsTester(new ComputationWebService(sut));
}
@Test
public void add_element_to_queue_and_launch_analysis_task() throws Exception {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
AnalysisReportDto dto = mock(AnalysisReportDto.class);
when(dto.getId()).thenReturn(42L);
when(queue.add(any(String.class), any(InputStream.class))).thenReturn(new ReportQueue.Item(dto, null));
@Test(expected = ForbiddenException.class)
public void requires_scan_permission() throws Exception {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.DASHBOARD_SHARING);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.DASHBOARD_SHARING);
WsTester.TestRequest request = wsTester
.newGetRequest(ComputationWebService.API_ENDPOINT, "submit_report")
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.server.debt.DebtCharacteristic;
import org.sonar.api.server.debt.internal.DefaultDebtCharacteristic;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.server.platform.Platform;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester serverTester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(serverTester);
@Before
public void setUp() {
@Test
public void create_characteristic() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
DebtModelService debtModelService = serverTester.get(DebtModelService.class);
int nb = debtModelService.characteristics().size();
@Test
public void create_sub_characteristic() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
DebtModelService debtModelService = serverTester.get(DebtModelService.class);
package org.sonar.server.debt;
+import java.io.Reader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.sonar.server.rule.RuleDefinitionsLoader;
import org.sonar.server.rule.RuleOperations;
import org.sonar.server.rule.db.RuleDao;
-import org.sonar.server.user.MockUserSession;
-
-import java.io.Reader;
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.Date;
-import java.util.List;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Matchers.isNull;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class DebtModelBackupTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
+
@Mock
DbClient dbClient;
-
@Mock
DbSession session;
-
@Mock
DebtModelPluginRepository debtModelPluginRepository;
-
@Mock
CharacteristicDao dao;
-
@Mock
RuleDao ruleDao;
-
@Mock
DebtModelOperations debtModelOperations;
-
@Mock
RuleOperations ruleOperations;
-
@Mock
DebtCharacteristicsXMLImporter characteristicsXMLImporter;
-
@Mock
DebtRulesXMLImporter rulesXMLImporter;
-
@Mock
DebtModelXMLExporter debtModelXMLExporter;
-
@Mock
RuleDefinitionsLoader defLoader;
-
@Mock
System2 system2;
@Captor
ArgumentCaptor<CharacteristicDto> characteristicCaptor;
-
@Captor
ArgumentCaptor<RuleDto> ruleCaptor;
-
@Captor
ArgumentCaptor<ArrayList<RuleDebt>> ruleDebtListCaptor;
DebtModelBackup debtModelBackup;
@Before
- public void setUp() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ public void setUp() throws Exception {
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
when(system2.now()).thenReturn(now.getTime());
when(debtModelPluginRepository.createReaderForXMLFile("technical-debt")).thenReturn(defaultModelReader);
debtModelBackup = new DebtModelBackup(dbClient, debtModelOperations, ruleOperations, debtModelPluginRepository, characteristicsXMLImporter, rulesXMLImporter,
- debtModelXMLExporter, defLoader, system2);
+ debtModelXMLExporter, defLoader, system2, userSessionRule);
}
@Test
package org.sonar.server.debt;
+import java.util.Date;
import org.apache.ibatis.session.SqlSession;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.rule.db.RuleDao;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.Date;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
@RunWith(MockitoJUnitRunner.class)
public class DebtModelOperationsTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
+
@Mock
CharacteristicDao dao;
public void setUp() {
when(system2.now()).thenReturn(now.getTime());
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
currentId = 10;
// Associate an id when inserting an object to simulate the db id generator
when(dbClient.openSession(false)).thenReturn(session);
when(dbClient.ruleDao()).thenReturn(ruleDao);
when(dbClient.debtCharacteristicDao()).thenReturn(dao);
- service = new DebtModelOperations(dbClient, system2);
+ service = new DebtModelOperations(dbClient, system2, userSessionRule);
}
@Test
@Test
public void fail_to_create_sub_characteristic_when_wrong_permission() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.DASHBOARD_SHARING);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.DASHBOARD_SHARING);
try {
service.create("Compilation", 1);
import org.junit.Test;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.db.DbClient;
+import org.sonar.server.tester.AnonymousMockUserSession;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
@Before
public void setUp() {
- WsTester tester = new WsTester(new DependenciesWs(new ShowAction(mock(DbClient.class))));
+ WsTester tester = new WsTester(new DependenciesWs(new ShowAction(mock(DbClient.class), new AnonymousMockUserSession())));
controller = tester.controller("api/dependencies");
}
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.utils.System2;
import org.sonar.server.design.db.FileDependencyDao;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.NotFoundException;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static DbTester dbTester = new DbTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
DbClient dbClient;
dbTester.truncateTables();
dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao(), new SnapshotDao(System2.INSTANCE), new FileDependencyDao());
session = dbClient.openSession(false);
- tester = new WsTester(new DependenciesWs(new ShowAction(dbClient)));
+ tester = new WsTester(new DependenciesWs(new ShowAction(dbClient, userSessionRule)));
controller = tester.controller("api/dependencies");
initComponents();
.setCreatedAt(1000L));
session.commit();
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
tester.newGetRequest("api/dependencies", "show")
.setParam("fromParentUuid", DIR1_UUID)
@Test
public void return_nothing() throws Exception {
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
tester.newGetRequest("api/dependencies", "show")
.setParam("fromParentUuid", DIR1_UUID)
@Test(expected = ForbiddenException.class)
public void fail_if_no_user_permission_on_project() throws Exception {
- MockUserSession.set().addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
tester.newGetRequest("api/dependencies", "show")
.setParam("fromParentUuid", DIR1_UUID)
.setCreatedAt(1000L));
session.commit();
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
try {
tester.newGetRequest("api/dependencies", "show")
.setCreatedAt(1000L));
session.commit();
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
tester.newGetRequest("api/dependencies", "show")
.setParam("fromParentUuid", DIR1_UUID)
.setCreatedAt(1000L));
session.commit();
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
try {
tester.newGetRequest("api/dependencies", "show")
.setCreatedAt(1000L));
session.commit();
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
try {
tester.newGetRequest("api/dependencies", "show")
package org.sonar.server.duplication.ws;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.component.db.ComponentDao;
import org.sonar.server.db.DbClient;
import org.sonar.server.measure.persistence.MeasureDao;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
public class DuplicationsWsTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
WsTester tester = new WsTester(new DuplicationsWs(
- new ShowAction(mock(DbClient.class), mock(ComponentDao.class), mock(MeasureDao.class), mock(DuplicationsParser.class), mock(DuplicationsJsonWriter.class))));
+ new ShowAction(mock(DbClient.class), mock(ComponentDao.class), mock(MeasureDao.class), mock(DuplicationsParser.class), mock(DuplicationsJsonWriter.class), userSessionRule)));
@Test
public void define_ws() {
package org.sonar.server.duplication.ws;
import com.google.common.collect.Lists;
+import java.util.List;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.measure.persistence.MeasureDao;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.util.List;
-
import static com.google.common.collect.Lists.newArrayList;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
@RunWith(MockitoJUnitRunner.class)
public class ShowActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Mock
DbSession session;
@Before
public void setUp() {
when(dbClient.openSession(false)).thenReturn(session);
- tester = new WsTester(new DuplicationsWs(new ShowAction(dbClient, componentDao, measureDao, parser, duplicationsJsonWriter)));
+ tester = new WsTester(new DuplicationsWs(new ShowAction(dbClient, componentDao, measureDao, parser, duplicationsJsonWriter, userSessionRule)));
}
@Test
public void show_duplications() throws Exception {
String componentKey = "src/Foo.java";
- MockUserSession.set().addComponentPermission(UserRole.CODEVIEWER, "org.codehaus.sonar:sonar", componentKey);
+ userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "org.codehaus.sonar:sonar", componentKey);
ComponentDto componentDto = new ComponentDto().setId(10L);
when(componentDao.getNullableByKey(session, componentKey)).thenReturn(componentDto);
public void show_duplications_by_uuid() throws Exception {
String uuid = "ABCD";
String componentKey = "src/Foo.java";
- MockUserSession.set().addComponentPermission(UserRole.CODEVIEWER, "org.codehaus.sonar:sonar", componentKey);
+ userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "org.codehaus.sonar:sonar", componentKey);
when(componentDao.getByUuid(session, uuid)).thenReturn(new ComponentDto().setKey(componentKey));
@Test
public void no_duplications_when_no_data() throws Exception {
String componentKey = "src/Foo.java";
- MockUserSession.set().addComponentPermission(UserRole.CODEVIEWER, "org.codehaus.sonar:sonar", componentKey);
+ userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "org.codehaus.sonar:sonar", componentKey);
ComponentDto componentDto = new ComponentDto().setId(10L);
when(componentDao.getNullableByKey(session, componentKey)).thenReturn(componentDto);
@Test(expected = NotFoundException.class)
public void fail_when_file_not_found() throws Exception {
String componentKey = "src/Foo.java";
- MockUserSession.set().addComponentPermission(UserRole.CODEVIEWER, "org.codehaus.sonar:sonar", componentKey);
+ userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "org.codehaus.sonar:sonar", componentKey);
WsTester.TestRequest request = tester.newGetRequest("api/duplications", "show").setParam("key", componentKey);
request.execute();
import org.sonar.server.component.db.ComponentDao;
import org.sonar.server.db.DbClient;
import org.sonar.server.rule.RuleTesting;
+import org.sonar.server.user.ThreadLocalUserSession;
import org.sonar.server.user.UserSession;
import java.util.List;
actions.add("link-to-jira").setConditions(new AlwaysMatch()).setFunctions(function1, function2);
- assertThat(actionService.execute("ABCD", "link-to-jira", mock(UserSession.class))).isNotNull();
+ assertThat(actionService.execute("ABCD", "link-to-jira", mock(ThreadLocalUserSession.class))).isNotNull();
verify(function1).execute(any(Function.Context.class));
verify(function2).execute(any(Function.Context.class));
public void modify_issue_when_executing_a_function() {
Function function = new TweetFunction();
- UserSession userSession = mock(UserSession.class);
+ UserSession userSession = mock(ThreadLocalUserSession.class);
when(userSession.login()).thenReturn("arthur");
when(componentDao.getByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
public void inject_project_settings_when_executing_a_function() {
Function function = new TweetFunction();
- UserSession userSession = mock(UserSession.class);
+ UserSession userSession = mock(ThreadLocalUserSession.class);
when(userSession.login()).thenReturn("arthur");
when(componentDao.getByKey(session, "struts")).thenReturn(new ComponentDto().setKey("struts"));
actions.add("link-to-jira").setConditions(new AlwaysMatch()).setFunctions(function);
try {
- actionService.execute("ABCD", "tweet", mock(UserSession.class));
+ actionService.execute("ABCD", "tweet", mock(ThreadLocalUserSession.class));
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalArgumentException.class).hasMessage("Action is not found : tweet");
actions.add("link-to-jira").setConditions(new NeverMatch()).setFunctions(function);
try {
- actionService.execute("ABCD", "link-to-jira", mock(UserSession.class));
+ actionService.execute("ABCD", "link-to-jira", mock(ThreadLocalUserSession.class));
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalStateException.class).hasMessage("A condition is not respected");
import org.sonar.api.user.UserFinder;
import org.sonar.core.issue.IssueUpdater;
import org.sonar.core.user.DefaultUser;
-import org.sonar.server.user.UserSession;
+import org.sonar.server.user.ThreadLocalUserSession;
import java.util.List;
import java.util.Map;
List<Issue> issues = newArrayList((Issue) new DefaultIssue().setKey("ABC"));
when(userFinder.findByLogin(assignee)).thenReturn(user);
- assertThat(action.verify(properties, issues, mock(UserSession.class))).isTrue();
+ assertThat(action.verify(properties, issues, mock(ThreadLocalUserSession.class))).isTrue();
assertThat(properties.get(AssignAction.VERIFIED_ASSIGNEE)).isEqualTo(user);
}
List<Issue> issues = newArrayList((Issue) new DefaultIssue().setKey("ABC"));
when(userFinder.findByLogin(assignee)).thenReturn(null);
- action.verify(properties, issues, mock(UserSession.class));
+ action.verify(properties, issues, mock(ThreadLocalUserSession.class));
}
@Test
properties.put("assignee", assignee);
List<Issue> issues = newArrayList((Issue) new DefaultIssue().setKey("ABC"));
- action.verify(properties, issues, mock(UserSession.class));
- assertThat(action.verify(properties, issues, mock(UserSession.class))).isTrue();
+ action.verify(properties, issues, mock(ThreadLocalUserSession.class));
+ assertThat(action.verify(properties, issues, mock(ThreadLocalUserSession.class))).isTrue();
assertThat(properties.containsKey(AssignAction.VERIFIED_ASSIGNEE)).isTrue();
assertThat(properties.get(AssignAction.VERIFIED_ASSIGNEE)).isNull();
}
package org.sonar.server.issue;
import com.google.common.collect.Lists;
+import java.util.Map;
import org.junit.Before;
import org.junit.Test;
import org.sonar.api.issue.Issue;
import org.sonar.api.issue.internal.DefaultIssue;
import org.sonar.api.issue.internal.IssueChangeContext;
import org.sonar.core.issue.IssueUpdater;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.Map;
+import org.sonar.server.tester.AnonymousMockUserSession;
import static com.google.common.collect.Maps.newHashMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
public class CommentActionTest {
Map<String, Object> properties = newHashMap();
properties.put("unknwown", "unknown value");
try {
- action.verify(properties, Lists.<Issue>newArrayList(), MockUserSession.create());
+ action.verify(properties, Lists.<Issue>newArrayList(), new AnonymousMockUserSession());
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalArgumentException.class).hasMessage("Missing parameter : 'comment'");
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.sonar.api.issue.ActionPlan;
import org.sonar.server.exceptions.Message;
import org.sonar.server.issue.actionplan.ActionPlanService;
import org.sonar.server.issue.filter.IssueFilterService;
-import org.sonar.server.user.UserSession;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
+import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.user.ThreadLocalUserSession;
import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Maps.newHashMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
public class InternalRubyIssueServiceTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
IssueService issueService;
when(resourceDao.getResource(any(ResourceQuery.class))).thenReturn(project);
service = new InternalRubyIssueService(issueService, issueQueryService, commentService, changelogService, actionPlanService, resourceDao, actionService,
- issueFilterService, issueBulkChangeService);
+ issueFilterService, issueBulkChangeService, userSessionRule);
}
@Test
assertThat(result.ok()).isTrue();
ArgumentCaptor<ActionPlan> actionPlanCaptor = ArgumentCaptor.forClass(ActionPlan.class);
- verify(actionPlanService).create(actionPlanCaptor.capture(), any(UserSession.class));
+ verify(actionPlanService).create(actionPlanCaptor.capture(), any(ThreadLocalUserSession.class));
ActionPlan actionPlan = actionPlanCaptor.getValue();
assertThat(actionPlan).isNotNull();
@Test
public void update_action_plan() {
- when(actionPlanService.findByKey(eq("ABCD"), any(UserSession.class))).thenReturn(DefaultActionPlan.create("Long term"));
+ when(actionPlanService.findByKey(eq("ABCD"), any(ThreadLocalUserSession.class))).thenReturn(DefaultActionPlan.create("Long term"));
Map<String, String> parameters = newHashMap();
parameters.put("name", "New Long term");
assertThat(result.ok()).isTrue();
ArgumentCaptor<ActionPlan> actionPlanCaptor = ArgumentCaptor.forClass(ActionPlan.class);
- verify(actionPlanService).update(actionPlanCaptor.capture(), any(UserSession.class));
+ verify(actionPlanService).update(actionPlanCaptor.capture(), any(ThreadLocalUserSession.class));
ActionPlan actionPlan = actionPlanCaptor.getValue();
assertThat(actionPlan).isNotNull();
@Test
public void update_action_plan_with_new_project() {
- when(actionPlanService.findByKey(eq("ABCD"), any(UserSession.class))).thenReturn(DefaultActionPlan.create("Long term").setProjectKey("org.sonar.MultiSample"));
+ when(actionPlanService.findByKey(eq("ABCD"), any(ThreadLocalUserSession.class))).thenReturn(DefaultActionPlan.create("Long term").setProjectKey("org.sonar.MultiSample"));
Map<String, String> parameters = newHashMap();
parameters.put("name", "New Long term");
Result result = service.updateActionPlan("ABCD", parameters);
assertThat(result.ok()).isTrue();
- verify(actionPlanService).update(actionPlanCaptor.capture(), any(UserSession.class));
+ verify(actionPlanService).update(actionPlanCaptor.capture(), any(ThreadLocalUserSession.class));
ActionPlan actionPlan = actionPlanCaptor.getValue();
assertThat(actionPlan).isNotNull();
@Test
public void not_update_action_plan_when_action_plan_is_not_found() {
- when(actionPlanService.findByKey(eq("ABCD"), any(UserSession.class))).thenReturn(null);
+ when(actionPlanService.findByKey(eq("ABCD"), any(ThreadLocalUserSession.class))).thenReturn(null);
Result result = service.updateActionPlan("ABCD", null);
assertThat(result.ok()).isFalse();
@Test
public void delete_action_plan() {
- when(actionPlanService.findByKey(eq("ABCD"), any(UserSession.class))).thenReturn(DefaultActionPlan.create("Long term"));
+ when(actionPlanService.findByKey(eq("ABCD"), any(ThreadLocalUserSession.class))).thenReturn(DefaultActionPlan.create("Long term"));
Result result = service.deleteActionPlan("ABCD");
- verify(actionPlanService).delete(eq("ABCD"), any(UserSession.class));
+ verify(actionPlanService).delete(eq("ABCD"), any(ThreadLocalUserSession.class));
assertThat(result.ok()).isTrue();
}
@Test
public void not_delete_action_plan_if_action_plan_not_found() {
- when(actionPlanService.findByKey(eq("ABCD"), any(UserSession.class))).thenReturn(null);
+ when(actionPlanService.findByKey(eq("ABCD"), any(ThreadLocalUserSession.class))).thenReturn(null);
Result result = service.deleteActionPlan("ABCD");
- verify(actionPlanService, never()).delete(eq("ABCD"), any(UserSession.class));
+ verify(actionPlanService, never()).delete(eq("ABCD"), any(ThreadLocalUserSession.class));
assertThat(result.ok()).isFalse();
assertThat(result.errors()).contains(Result.Message.ofL10n("action_plans.errors.action_plan_does_not_exist", "ABCD"));
}
@Test
public void close_action_plan() {
- when(actionPlanService.findByKey(eq("ABCD"), any(UserSession.class))).thenReturn(DefaultActionPlan.create("Long term"));
+ when(actionPlanService.findByKey(eq("ABCD"), any(ThreadLocalUserSession.class))).thenReturn(DefaultActionPlan.create("Long term"));
Result result = service.closeActionPlan("ABCD");
- verify(actionPlanService).setStatus(eq("ABCD"), eq("CLOSED"), any(UserSession.class));
+ verify(actionPlanService).setStatus(eq("ABCD"), eq("CLOSED"), any(ThreadLocalUserSession.class));
assertThat(result.ok()).isTrue();
}
@Test
public void open_action_plan() {
- when(actionPlanService.findByKey(eq("ABCD"), any(UserSession.class))).thenReturn(DefaultActionPlan.create("Long term"));
+ when(actionPlanService.findByKey(eq("ABCD"), any(ThreadLocalUserSession.class))).thenReturn(DefaultActionPlan.create("Long term"));
Result result = service.openActionPlan("ABCD");
- verify(actionPlanService).setStatus(eq("ABCD"), eq("OPEN"), any(UserSession.class));
+ verify(actionPlanService).setStatus(eq("ABCD"), eq("OPEN"), any(ThreadLocalUserSession.class));
assertThat(result.ok()).isTrue();
}
service.createIssueFilter(parameters);
ArgumentCaptor<IssueFilterDto> issueFilterCaptor = ArgumentCaptor.forClass(IssueFilterDto.class);
- verify(issueFilterService).save(issueFilterCaptor.capture(), any(UserSession.class));
+ verify(issueFilterService).save(issueFilterCaptor.capture(), any(ThreadLocalUserSession.class));
IssueFilterDto issueFilter = issueFilterCaptor.getValue();
assertThat(issueFilter.getName()).isEqualTo("Long term");
assertThat(issueFilter.getDescription()).isEqualTo("Long term issues");
service.updateIssueFilter(parameters);
ArgumentCaptor<IssueFilterDto> issueFilterCaptor = ArgumentCaptor.forClass(IssueFilterDto.class);
- verify(issueFilterService).update(issueFilterCaptor.capture(), any(UserSession.class));
+ verify(issueFilterService).update(issueFilterCaptor.capture(), any(ThreadLocalUserSession.class));
IssueFilterDto issueFilter = issueFilterCaptor.getValue();
assertThat(issueFilter.getId()).isEqualTo(10L);
assertThat(issueFilter.getName()).isEqualTo("Long term");
public void update_data() {
Map<String, Object> data = newHashMap();
service.updateIssueFilterQuery(10L, data);
- verify(issueFilterService).updateFilterQuery(eq(10L), eq(data), any(UserSession.class));
+ verify(issueFilterService).updateFilterQuery(eq(10L), eq(data), any(ThreadLocalUserSession.class));
}
@Test
public void delete_issue_filter() {
service.deleteIssueFilter(1L);
- verify(issueFilterService).delete(eq(1L), any(UserSession.class));
+ verify(issueFilterService).delete(eq(1L), any(ThreadLocalUserSession.class));
}
@Test
service.copyIssueFilter(1L, parameters);
ArgumentCaptor<IssueFilterDto> issueFilterCaptor = ArgumentCaptor.forClass(IssueFilterDto.class);
- verify(issueFilterService).copy(eq(1L), issueFilterCaptor.capture(), any(UserSession.class));
+ verify(issueFilterService).copy(eq(1L), issueFilterCaptor.capture(), any(ThreadLocalUserSession.class));
IssueFilterDto issueFilter = issueFilterCaptor.getValue();
assertThat(issueFilter.getName()).isEqualTo("Copy of Long term");
assertThat(issueFilter.getDescription()).isEqualTo("Copy of Long term issues");
overrideProps.put("pageSize", 20);
overrideProps.put("pageIndex", 2);
- IssueQuery query = IssueQuery.builder().build();
+ IssueQuery query = IssueQuery.builder(userSessionRule).build();
when(issueQueryService.createFromMap(eq(overrideProps))).thenReturn(query);
service.execute(10L, overrideProps);
ArgumentCaptor<SearchOptions> contextArgumentCaptor = ArgumentCaptor.forClass(SearchOptions.class);
verify(issueFilterService).execute(issueQueryArgumentCaptor.capture(), contextArgumentCaptor.capture());
- verify(issueFilterService).find(eq(10L), any(UserSession.class));
+ verify(issueFilterService).find(eq(10L), any(ThreadLocalUserSession.class));
SearchOptions searchOptions = contextArgumentCaptor.getValue();
assertThat(searchOptions.getLimit()).isEqualTo(20);
@Test
public void find_user_issue_filters() {
service.findIssueFiltersForCurrentUser();
- verify(issueFilterService).findByUser(any(UserSession.class));
+ verify(issueFilterService).findByUser(any(ThreadLocalUserSession.class));
}
@Test
public void find_shared_issue_filters() {
service.findSharedFiltersForCurrentUser();
- verify(issueFilterService).findSharedFiltersWithoutUserFilters(any(UserSession.class));
+ verify(issueFilterService).findSharedFiltersWithoutUserFilters(any(ThreadLocalUserSession.class));
}
@Test
public void find_favourite_issue_filters() {
service.findFavouriteIssueFiltersForCurrentUser();
- verify(issueFilterService).findFavoriteFilters(any(UserSession.class));
+ verify(issueFilterService).findFavoriteFilters(any(ThreadLocalUserSession.class));
}
@Test
public void toggle_favourite_issue_filter() {
service.toggleFavouriteIssueFilter(10L);
- verify(issueFilterService).toggleFavouriteIssueFilter(eq(10L), any(UserSession.class));
+ verify(issueFilterService).toggleFavouriteIssueFilter(eq(10L), any(ThreadLocalUserSession.class));
}
@Test
public void check_if_user_is_authorized_to_see_issue_filter() {
IssueFilterDto issueFilter = new IssueFilterDto();
service.isUserAuthorized(issueFilter);
- verify(issueFilterService).getLoggedLogin(any(UserSession.class));
+ verify(issueFilterService).getLoggedLogin(any(ThreadLocalUserSession.class));
verify(issueFilterService).verifyCurrentUserCanReadFilter(eq(issueFilter), anyString());
}
@Test
public void check_if_user_can_share_issue_filter() {
service.canUserShareIssueFilter();
- verify(issueFilterService).canShareFilter(any(UserSession.class));
+ verify(issueFilterService).canShareFilter(any(ThreadLocalUserSession.class));
}
@Test
params.put("set_severity.severity", "MINOR");
params.put("plan.plan", "3.7");
service.bulkChange(params, "My comment", true);
- verify(issueBulkChangeService).execute(any(IssueBulkChangeQuery.class), any(UserSession.class));
+ verify(issueBulkChangeService).execute(any(IssueBulkChangeQuery.class), any(ThreadLocalUserSession.class));
}
@Test
public void list_tags_for_component() {
Map<String, Long> tags = ImmutableMap.of("tag1", 1L, "tag2", 2L, "tag3", 3L);
int pageSize = 42;
- IssueQuery query = IssueQuery.builder().build();
+ IssueQuery query = IssueQuery.builder(userSessionRule).build();
String componentUuid = "polop";
Map<String, Object> params = ImmutableMap.<String, Object>of("componentUuids", componentUuid, "resolved", false);
when(issueQueryService.createFromMap(params)).thenReturn(query);
package org.sonar.server.issue;
import com.google.common.base.Joiner;
+import java.util.List;
+import java.util.Map;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.issue.DefaultTransitions;
import org.sonar.api.issue.Issue;
import org.sonar.server.rule.RuleTesting;
import org.sonar.server.rule.db.RuleDao;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.user.UserSession;
-import java.util.List;
-import java.util.Map;
-
import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Maps.newHashMap;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession session;
// project can be seen by anyone
session.commit();
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
tester.get(InternalPermissionService.class).addPermission(new PermissionChange().setComponentKey(project.getKey()).setGroup(DefaultGroups.ANYONE).setPermission(UserRole.USER));
- userSession = MockUserSession.set()
- .setLogin("john")
+ userSession = userSessionRule.logon("john")
.addProjectPermissions(UserRole.USER, project.key());
}
//
// IssueBulkChangeService service;
//
-// UserSession userSession = MockUserSession.create().setLogin("john").setUserId(10);
+// UserSession userSession = new MockUserSession("john").setUserId(10);
//
// IssueDoc issue;
// Rule rule;
*/
package org.sonar.server.issue;
+import java.util.List;
+import java.util.Locale;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.sonar.api.issue.internal.FieldDiffs;
import org.sonar.api.utils.Duration;
import org.sonar.api.utils.Durations;
-
-import java.util.List;
-import java.util.Locale;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.any;
private static final Locale DEFAULT_LOCALE = Locale.getDefault();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
+
@Mock
private I18n i18n;
@Before
public void before() {
- formatter = new IssueChangelogFormatter(i18n, durations);
+ formatter = new IssueChangelogFormatter(i18n, durations, userSessionRule);
}
@Test
*/
package org.sonar.server.issue;
+import java.util.Arrays;
+import java.util.Locale;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.sonar.api.user.UserFinder;
import org.sonar.core.issue.db.IssueChangeDao;
import org.sonar.core.user.DefaultUser;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.Arrays;
-import java.util.Locale;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class IssueChangelogServiceTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
+
@Mock
IssueChangeDao changeDao;
@Before
public void setUp() {
- service = new IssueChangelogService(changeDao, userFinder, issueService, formatter);
+ service = new IssueChangelogService(changeDao, userFinder, issueService, formatter, userSessionRule);
}
@Test
@Test
public void format_diffs() {
FieldDiffs diffs = new FieldDiffs().setUserLogin("arthur").setDiff("severity", "MAJOR", "BLOCKER");
- MockUserSession.set();
+ userSessionRule.logon();
service.formatDiffs(diffs);
verify(formatter).format(any(Locale.class), eq(diffs));
}
package org.sonar.server.issue;
+import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.issue.Issue;
import org.sonar.api.issue.internal.DefaultIssueComment;
import org.sonar.server.rule.db.RuleDao;
import org.sonar.server.search.IndexClient;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.List;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
IndexClient indexClient;
// project can be seen by anyone
session.commit();
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
tester.get(InternalPermissionService.class).addPermission(new PermissionChange().setComponentKey(project.getKey()).setGroup(DefaultGroups.ANYONE).setPermission(UserRole.USER));
- MockUserSession.set().setLogin("gandalf");
+ userSessionRule.logon("gandalf");
session.commit();
}
session.commit();
tester.get(IssueIndexer.class).indexAll();
- service.addComment(issue.getKey(), "my comment", MockUserSession.get());
+ service.addComment(issue.getKey(), "my comment", userSessionRule);
List<DefaultIssueComment> comments = service.findComments(issue.getKey());
assertThat(comments).hasSize(1);
session.commit();
tester.get(IssueIndexer.class).indexAll();
- service.addComment(issue.getKey(), "my comment", MockUserSession.get());
+ service.addComment(issue.getKey(), "my comment", userSessionRule);
List<DefaultIssueComment> comments = service.findComments(issue.getKey());
assertThat(comments).hasSize(1);
package org.sonar.server.issue;
+import java.util.Collections;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.exceptions.UnauthorizedException;
import org.sonar.server.rule.RuleTesting;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.Collections;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class IssueCommentServiceTest {
-
- @Mock
+ @Mock
private DbClient dbClient;
@Mock
@Rule
public ExpectedException throwable = ExpectedException.none();
-
- @Before
- public void setUpUser() {
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
- }
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone().logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
@Before
public void setUp() {
when(issueService.getByKeyForUpdate(session, "ABCD")).thenReturn(issueDto);
when(issueCommentService.findComments(session, "ABCD")).thenReturn(newArrayList(new DefaultIssueComment()));
- issueCommentService.addComment("ABCD", "my comment", MockUserSession.get());
+ issueCommentService.addComment("ABCD", "my comment", userSessionRule);
verify(updater).addComment(eq(issueDto.toDefaultIssue()), eq("my comment"), any(IssueChangeContext.class));
verify(issueService).saveIssue(eq(session), eq(issueDto.toDefaultIssue()), any(IssueChangeContext.class), eq("my comment"));
@Test
public void should_be_logged_when_adding_comment() {
throwable.expect(UnauthorizedException.class);
+ userSessionRule.anonymous();
- MockUserSession.set().setLogin(null);
-
- issueCommentService.addComment("myIssue", "my comment", MockUserSession.get());
+ issueCommentService.addComment("myIssue", "my comment", userSessionRule);
verify(updater, never()).addComment(any(DefaultIssue.class), anyString(), any(IssueChangeContext.class));
verifyZeroInteractions(issueService);
public void should_prevent_adding_empty_comment() {
throwable.expect(BadRequestException.class);
- issueCommentService.addComment("myIssue", " ", MockUserSession.get());
+ issueCommentService.addComment("myIssue", " ", userSessionRule);
verify(updater, never()).addComment(any(DefaultIssue.class), anyString(), any(IssueChangeContext.class));
verifyZeroInteractions(issueService);
public void should_prevent_adding_null_comment() {
throwable.expect(BadRequestException.class);
- issueCommentService.addComment("myIssue", null, MockUserSession.get());
+ issueCommentService.addComment("myIssue", null, userSessionRule);
verify(updater, never()).addComment(any(DefaultIssue.class), anyString(), any(IssueChangeContext.class));
verifyZeroInteractions(issueService);
when(issueCommentService.findComments(session, "ABCD")).thenReturn(Collections.<DefaultIssueComment>emptyList());
try {
- issueCommentService.addComment("ABCD", "my comment", MockUserSession.get());
+ issueCommentService.addComment("ABCD", "my comment", userSessionRule);
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(BadRequestException.class).hasMessage("Fail to add a comment on issue ABCD");
public void should_delete_comment() {
when(changeDao.selectCommentByKey("ABCD")).thenReturn(new DefaultIssueComment().setUserLogin("admin").setIssueKey("EFGH"));
- issueCommentService.deleteComment("ABCD", MockUserSession.get());
+ issueCommentService.deleteComment("ABCD", userSessionRule);
verify(changeDao).delete("ABCD");
verify(issueService).getByKey("EFGH");
when(changeDao.selectCommentByKey("ABCD")).thenReturn(null);
- issueCommentService.deleteComment("ABCD", MockUserSession.get());
+ issueCommentService.deleteComment("ABCD", userSessionRule);
verify(changeDao, never()).delete(anyString());
}
when(changeDao.selectCommentByKey("ABCD")).thenReturn(new DefaultIssueComment().setUserLogin("julien"));
- issueCommentService.deleteComment("ABCD", MockUserSession.get());
+ issueCommentService.deleteComment("ABCD", userSessionRule);
verify(changeDao, never()).delete(anyString());
}
public void should_update_comment() {
when(changeDao.selectCommentByKey("ABCD")).thenReturn(new DefaultIssueComment().setIssueKey("EFGH").setUserLogin("admin"));
- issueCommentService.editComment("ABCD", "updated comment", MockUserSession.get());
+ issueCommentService.editComment("ABCD", "updated comment", userSessionRule);
verify(changeDao).update(any(IssueChangeDto.class));
verify(issueService).getByKey("EFGH");
when(changeDao.selectCommentByKey("ABCD")).thenReturn(null);
- issueCommentService.editComment("ABCD", "updated comment", MockUserSession.get());
+ issueCommentService.editComment("ABCD", "updated comment", userSessionRule);
verify(changeDao, never()).update(any(IssueChangeDto.class));
}
public void should_prevent_updating_empty_comment() {
throwable.expect(BadRequestException.class);
- issueCommentService.editComment("ABCD", "", MockUserSession.get());
+ issueCommentService.editComment("ABCD", "", userSessionRule);
verify(changeDao, never()).update(any(IssueChangeDto.class));
}
public void should_prevent_updating_null_comment() {
throwable.expect(BadRequestException.class);
- issueCommentService.editComment("ABCD", null, MockUserSession.get());
+ issueCommentService.editComment("ABCD", null, userSessionRule);
verify(changeDao, never()).update(any(IssueChangeDto.class));
}
when(changeDao.selectCommentByKey("ABCD")).thenReturn(new DefaultIssueComment().setUserLogin("julien"));
- issueCommentService.editComment("ABCD", "updated comment", MockUserSession.get());
+ issueCommentService.editComment("ABCD", "updated comment", userSessionRule);
verify(changeDao, never()).update(any(IssueChangeDto.class));
}
import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Date;
+import java.util.Map;
import org.assertj.core.api.Fail;
-import org.junit.After;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Matchers;
import org.sonar.server.component.ComponentService;
import org.sonar.server.component.db.ComponentDao;
import org.sonar.server.db.DbClient;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.*;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Maps.newHashMap;
@RunWith(MockitoJUnitRunner.class)
public class IssueQueryServiceTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Mock
DbClient dbClient;
}
});
- issueQueryService = new IssueQueryService(dbClient, componentService, system);
- }
-
- @After
- public void tearDown() {
- MockUserSession.set();
+ issueQueryService = new IssueQueryService(dbClient, componentService, system, userSessionRule);
}
@Test
when(componentService.getDistinctQualifiers(isA(DbSession.class), anyCollection())).thenReturn(Sets.newHashSet(Qualifiers.VIEW));
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, viewUuid);
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, viewUuid);
IssueQuery query = issueQueryService.createFromMap(map);
assertThat(query.viewUuids()).containsExactly(viewUuid);
when(componentService.getDistinctQualifiers(isA(DbSession.class), anyCollection())).thenReturn(Sets.newHashSet(Qualifiers.VIEW));
- MockUserSession.set();
-
IssueQuery query = issueQueryService.createFromMap(map);
assertThat(query.viewUuids()).isNotEmpty().doesNotContain(subViewUuid);
}
package org.sonar.server.issue;
import com.google.common.collect.Lists;
+import java.util.Date;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.issue.Issue;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.Severity;
-
-import java.util.Date;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
public class IssueQueryTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Test
public void build_query() {
- IssueQuery query = IssueQuery.builder()
+ IssueQuery query = IssueQuery.builder(userSessionRule)
.issueKeys(newArrayList("ABCDE"))
.severities(newArrayList(Severity.BLOCKER))
.statuses(Lists.newArrayList(Issue.STATUS_RESOLVED))
@Test
public void build_query_without_dates() {
- IssueQuery query = IssueQuery.builder()
+ IssueQuery query = IssueQuery.builder(userSessionRule)
.issueKeys(newArrayList("ABCDE"))
.createdAfter(null)
.createdBefore(null)
@Test
public void throw_exception_if_sort_is_not_valid() {
try {
- IssueQuery.builder()
+ IssueQuery.builder(userSessionRule)
.sort("UNKNOWN")
.build();
} catch (Exception e) {
@Test
public void collection_params_should_not_be_null_but_empty() {
- IssueQuery query = IssueQuery.builder()
+ IssueQuery query = IssueQuery.builder(userSessionRule)
.issueKeys(null)
.componentUuids(null)
.moduleUuids(null)
@Test
public void test_default_query() throws Exception {
- IssueQuery query = IssueQuery.builder().build();
+ IssueQuery query = IssueQuery.builder(userSessionRule).build();
assertThat(query.issueKeys()).isEmpty();
assertThat(query.componentUuids()).isEmpty();
assertThat(query.moduleUuids()).isEmpty();
@Test
public void should_accept_null_sort() {
- IssueQuery query = IssueQuery.builder().sort(null).build();
+ IssueQuery query = IssueQuery.builder(userSessionRule).sort(null).build();
assertThat(query.sort()).isNull();
}
}
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterators;
import com.google.common.collect.Sets;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.CoreProperties;
import org.sonar.api.config.Settings;
import org.sonar.server.rule.db.RuleDao;
import org.sonar.server.source.db.FileSourceDb;
import org.sonar.server.source.index.FileSourcesUpdaterHelper;
-import org.sonar.server.source.index.SourceLineResultSetIterator;
import org.sonar.server.source.index.SourceLineIndexer;
+import org.sonar.server.source.index.SourceLineResultSetIterator;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.user.NewUser;
import org.sonar.server.user.UserUpdater;
import org.sonar.server.user.db.GroupDao;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.List;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.entry;
import static org.junit.Assert.fail;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
IssueIndex IssueIndex;
saveIssue(IssueTesting.newDto(rule, file, project).setActionPlanKey("P1"));
saveIssue(IssueTesting.newDto(rule, file, project).setActionPlanKey("P2").setResolution("NONE"));
- SearchResult<IssueDoc> result = service.search(IssueQuery.builder().build(), new SearchOptions());
+ SearchResult<IssueDoc> result = service.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions());
assertThat(result.getDocs()).hasSize(2);
assertThat(result.getFacets().getNames()).isEmpty();
- result = service.search(IssueQuery.builder().build(), new SearchOptions().addFacets("actionPlans", "assignees"));
+ result = service.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions().addFacets("actionPlans", "assignees"));
assertThat(result.getFacets().getNames()).hasSize(2);
assertThat(result.getFacets().get("actionPlans")).hasSize(2);
assertThat(result.getFacets().get("assignees")).hasSize(1);
RuleDto rule = newRule();
ComponentDto project = newProject();
ComponentDto file = newFile(project);
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
IssueDto issue = saveIssue(IssueTesting.newDto(rule, file, project).setStatus(Issue.STATUS_OPEN));
RuleDto rule = newRule();
ComponentDto project = newProject();
ComponentDto file = newFile(project);
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
IssueDto issue = saveIssue(IssueTesting.newDto(rule, file, project));
RuleDto rule = newRule();
ComponentDto project = newProject();
ComponentDto file = newFile(project);
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
IssueDto issue = saveIssue(IssueTesting.newDto(rule, file, project).setAssignee("perceval"));
RuleDto rule = newRule();
ComponentDto project = newProject();
ComponentDto file = newFile(project);
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
IssueDto issue = saveIssue(IssueTesting.newDto(rule, file, project));
RuleDto rule = newRule();
ComponentDto project = newProject();
ComponentDto file = newFile(project);
- MockUserSession.set().setLogin("john").addProjectPermissions(UserRole.USER, project.key());
+ userSessionRule.logon("john").addProjectPermissions(UserRole.USER, project.key());
IssueDto issue = saveIssue(IssueTesting.newDto(rule, file, project));
RuleDto rule = newRule();
ComponentDto project = newProject();
ComponentDto file = newFile(project);
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
String actionPlanKey = "EFGH";
db.actionPlanDao().save(new ActionPlanDto().setKey(actionPlanKey).setProjectId(project.getId()));
RuleDto rule = newRule();
ComponentDto project = newProject();
ComponentDto file = newFile(project);
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
IssueDto issue = saveIssue(IssueTesting.newDto(rule, file, project));
try {
RuleDto rule = newRule();
ComponentDto project = newProject();
ComponentDto file = newFile(project);
- MockUserSession.set().setLogin("john").addProjectPermissions(UserRole.ISSUE_ADMIN, project.key());
+ userSessionRule.logon("john").addProjectPermissions(UserRole.ISSUE_ADMIN, project.key());
IssueDto issue = saveIssue(IssueTesting.newDto(rule, file, project).setSeverity(Severity.BLOCKER));
public void create_manual_issue() {
ComponentDto project = newProject();
ComponentDto file = newFile(project);
- MockUserSession.set().setLogin("john").addProjectPermissions(UserRole.USER, project.key());
+ userSessionRule.logon("john").addProjectPermissions(UserRole.USER, project.key());
RuleDto manualRule = RuleTesting.newManualRule("manualRuleKey");
tester.get(RuleDao.class).insert(session, manualRule);
newSourceLine(file, 1, "arthur");
createDefaultGroup();
newUser("arthur");
- MockUserSession.set().setLogin("john").addProjectPermissions(UserRole.USER, project.key());
+ userSessionRule.logon("john").addProjectPermissions(UserRole.USER, project.key());
RuleDto manualRule = RuleTesting.newManualRule("manualRuleKey");
tester.get(RuleDao.class).insert(session, manualRule);
public void create_manual_issue_with_major_severity_when_no_severity() {
ComponentDto project = newProject();
ComponentDto file = newFile(project);
- MockUserSession.set().setLogin("john").addProjectPermissions(UserRole.USER, project.key());
+ userSessionRule.logon("john").addProjectPermissions(UserRole.USER, project.key());
RuleDto manualRule = RuleTesting.newManualRule("manualRuleKey");
tester.get(RuleDao.class).insert(session, manualRule);
public void create_manual_issue_with_rule_name_when_no_message() {
ComponentDto project = newProject();
ComponentDto file = newFile(project);
- MockUserSession.set().setLogin("john").addProjectPermissions(UserRole.USER, project.key());
+ userSessionRule.logon("john").addProjectPermissions(UserRole.USER, project.key());
RuleDto manualRule = RuleTesting.newManualRule("manualRuleKey").setName("Manual rule name");
tester.get(RuleDao.class).insert(session, manualRule);
newSourceLine(file, 1, "unknown");
createDefaultGroup();
newUser("arthur");
- MockUserSession.set().setLogin("john").addProjectPermissions(UserRole.USER, project.key());
+ userSessionRule.logon("john").addProjectPermissions(UserRole.USER, project.key());
RuleDto manualRule = RuleTesting.newManualRule("manualRuleKey");
tester.get(RuleDao.class).insert(session, manualRule);
ComponentDto file = newFile(project);
// No author on line 1
newSourceLine(file, 1, "");
- MockUserSession.set().setLogin("john").addProjectPermissions(UserRole.USER, project.key());
+ userSessionRule.logon("john").addProjectPermissions(UserRole.USER, project.key());
RuleDto manualRule = RuleTesting.newManualRule("manualRuleKey");
tester.get(RuleDao.class).insert(session, manualRule);
RuleDto rule = newRule();
ComponentDto project = newProject();
ComponentDto file = newFile(project);
- MockUserSession.set().setLogin("john").addProjectPermissions(UserRole.USER, project.key());
+ userSessionRule.logon("john").addProjectPermissions(UserRole.USER, project.key());
try {
service.createManualIssue(file.key(), rule.getKey(), null, "Fix it", null, 2d);
public void fail_create_manual_issue_if_rule_does_not_exists() {
ComponentDto project = newProject();
ComponentDto file = newFile(project);
- MockUserSession.set().setLogin("john").addProjectPermissions(UserRole.USER, project.key());
+ userSessionRule.logon("john").addProjectPermissions(UserRole.USER, project.key());
service.createManualIssue(file.key(), RuleKey.of("rule", "unknown"), 10, "Fix it", null, 2d);
}
ComponentDto file = newFile(project);
// User has not the 'user' role on the project
- MockUserSession.set().setLogin("john").addProjectPermissions(UserRole.CODEVIEWER, project.key());
+ userSessionRule.logon("john").addProjectPermissions(UserRole.CODEVIEWER, project.key());
RuleDto manualRule = RuleTesting.newManualRule("manualRuleKey");
tester.get(RuleDao.class).insert(session, manualRule);
ComponentDto file = newFile(project);
saveIssue(IssueTesting.newDto(rule, file, project));
- List<IssueDoc> result = service.search(IssueQuery.builder().build(), new SearchOptions()).getDocs();
+ List<IssueDoc> result = service.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions()).getDocs();
assertThat(result).hasSize(1);
}
RuleDto rule = newRule();
ComponentDto project = newProject();
ComponentDto file = newFile(project);
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
IssueDto issue = saveIssue(IssueTesting.newDto(rule, file, project));
}
private IssueQuery projectQuery(String projectUuid) {
- return IssueQuery.builder().projectUuids(Arrays.asList(projectUuid)).resolved(false).build();
+ return IssueQuery.builder(userSessionRule).projectUuids(Arrays.asList(projectUuid)).resolved(false).build();
}
@Test
ComponentDto project = ComponentTesting.newProjectDto();
tester.get(ComponentDao.class).insert(session, project);
- MockUserSession.set().setLogin("admin").addProjectPermissions(UserRole.USER, project.key()).setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("admin").addProjectPermissions(UserRole.USER, project.key()).setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
session.commit();
// project can be seen by group "anyone"
tester.get(InternalPermissionService.class).addPermission(new PermissionChange().setComponentKey(project.getKey()).setGroup(DefaultGroups.ANYONE).setPermission(UserRole.USER));
- MockUserSession.set();
+ userSessionRule.logon();
return project;
}
package org.sonar.server.issue;
+import java.util.Date;
+import java.util.List;
import org.apache.commons.lang.time.DateUtils;
import org.assertj.core.api.Assertions;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.core.issue.db.IssueDto;
-
-import java.util.Date;
-import java.util.List;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
public class IssuesFinderSortTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Test
public void should_sort_by_assignee() {
IssueDto issue4 = new IssueDto().setId(4L).setAssignee(null);
List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3, issue4);
- IssueQuery query = IssueQuery.builder().sort(IssueQuery.SORT_BY_ASSIGNEE).asc(true).build();
+ IssueQuery query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_ASSIGNEE).asc(true).build();
IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query);
List<IssueDto> result = newArrayList(issuesFinderSort.sort());
IssueDto issue3 = new IssueDto().setId(3L).setStatus("OPEN");
List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3);
- IssueQuery query = IssueQuery.builder().sort(IssueQuery.SORT_BY_STATUS).asc(false).build();
+ IssueQuery query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_STATUS).asc(false).build();
IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query);
List<IssueDto> result = newArrayList(issuesFinderSort.sort());
IssueDto issue3 = new IssueDto().setId(3L).setSeverity("MAJOR");
List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3);
- IssueQuery query = IssueQuery.builder().sort(IssueQuery.SORT_BY_SEVERITY).asc(true).build();
+ IssueQuery query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_SEVERITY).asc(true).build();
IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query);
List<IssueDto> result = newArrayList(issuesFinderSort.sort());
IssueDto issue3 = new IssueDto().setId(3L).setSeverity("MAJOR");
List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3);
- IssueQuery query = IssueQuery.builder().sort(IssueQuery.SORT_BY_SEVERITY).asc(false).build();
+ IssueQuery query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_SEVERITY).asc(false).build();
IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query);
List<IssueDto> result = newArrayList(issuesFinderSort.sort());
IssueDto issue3 = new IssueDto().setId(3L).setIssueCreationDate(date2);
List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3);
- IssueQuery query = IssueQuery.builder().sort(IssueQuery.SORT_BY_CREATION_DATE).asc(false).build();
+ IssueQuery query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_CREATION_DATE).asc(false).build();
IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query);
List<IssueDto> result = newArrayList(issuesFinderSort.sort());
IssueDto issue3 = new IssueDto().setId(3L).setIssueUpdateDate(date2);
List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3);
- IssueQuery query = IssueQuery.builder().sort(IssueQuery.SORT_BY_UPDATE_DATE).asc(false).build();
+ IssueQuery query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_UPDATE_DATE).asc(false).build();
IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query);
List<IssueDto> result = newArrayList(issuesFinderSort.sort());
IssueDto issue3 = new IssueDto().setId(3L).setIssueCloseDate(date2);
List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3);
- IssueQuery query = IssueQuery.builder().sort(IssueQuery.SORT_BY_CLOSE_DATE).asc(false).build();
+ IssueQuery query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_CLOSE_DATE).asc(false).build();
IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query);
List<IssueDto> result = newArrayList(issuesFinderSort.sort());
IssueDto issue4 = new IssueDto().setId(4L).setAssignee(null);
List<IssueDto> dtoList = newArrayList(issue1, issue2, issue3, issue4);
- IssueQuery query = IssueQuery.builder().sort(null).build();
+ IssueQuery query = IssueQuery.builder(userSessionRule).sort(null).build();
IssuesFinderSort issuesFinderSort = new IssuesFinderSort(dtoList, query);
List<IssueDto> result = newArrayList(issuesFinderSort.sort());
import org.sonar.core.issue.DefaultActionPlan;
import org.sonar.core.issue.IssueUpdater;
import org.sonar.server.issue.actionplan.ActionPlanService;
-import org.sonar.server.user.UserSession;
+import org.sonar.server.user.ThreadLocalUserSession;
import java.util.List;
import java.util.Map;
ActionPlan actionPlan = new DefaultActionPlan().setProjectKey("struts");
List<Issue> issues = newArrayList((Issue) new DefaultIssue().setKey("ABC").setProjectKey("struts"));
- when(actionPlanService.findByKey(eq(planKey), any(UserSession.class))).thenReturn(actionPlan);
- assertThat(action.verify(properties, issues, mock(UserSession.class))).isTrue();
+ when(actionPlanService.findByKey(eq(planKey), any(ThreadLocalUserSession.class))).thenReturn(actionPlan);
+ assertThat(action.verify(properties, issues, mock(ThreadLocalUserSession.class))).isTrue();
assertThat(properties.get(PlanAction.VERIFIED_ACTION_PLAN)).isEqualTo(actionPlan);
}
properties.put("plan", planKey);
List<Issue> issues = newArrayList((Issue) new DefaultIssue().setKey("ABC").setProjectKey("struts"));
- when(actionPlanService.findByKey(eq(planKey), any(UserSession.class))).thenReturn(null);
- action.verify(properties, issues, mock(UserSession.class));
+ when(actionPlanService.findByKey(eq(planKey), any(ThreadLocalUserSession.class))).thenReturn(null);
+ action.verify(properties, issues, mock(ThreadLocalUserSession.class));
}
@Test
properties.put("plan", planKey);
List<Issue> issues = newArrayList((Issue) new DefaultIssue().setKey("ABC").setProjectKey("struts"));
- action.verify(properties, issues, mock(UserSession.class));
+ action.verify(properties, issues, mock(ThreadLocalUserSession.class));
assertThat(properties.containsKey(PlanAction.VERIFIED_ACTION_PLAN)).isTrue();
assertThat(properties.get(PlanAction.VERIFIED_ACTION_PLAN)).isNull();
}
Map<String, Object> properties = newHashMap();
properties.put("plan", planKey);
- when(actionPlanService.findByKey(eq(planKey), any(UserSession.class))).thenReturn(new DefaultActionPlan().setProjectKey("struts"));
+ when(actionPlanService.findByKey(eq(planKey), any(ThreadLocalUserSession.class))).thenReturn(new DefaultActionPlan().setProjectKey("struts"));
List<Issue> issues = newArrayList(new DefaultIssue().setKey("ABC").setProjectKey("struts"), (Issue) new DefaultIssue().setKey("ABE").setProjectKey("mybatis"));
- action.verify(properties, issues, mock(UserSession.class));
+ action.verify(properties, issues, mock(ThreadLocalUserSession.class));
}
@Test
package org.sonar.server.issue;
import com.google.common.collect.Lists;
+import java.util.Map;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.issue.Issue;
import org.sonar.api.issue.internal.DefaultIssue;
import org.sonar.api.issue.internal.IssueChangeContext;
import org.sonar.api.web.UserRole;
import org.sonar.core.issue.IssueUpdater;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.tester.AnonymousMockUserSession;
import org.sonar.server.user.UserSession;
-import org.sonar.server.user.UserSessionTestUtils;
-
-import java.util.Map;
import static com.google.common.collect.Maps.newHashMap;
import static org.assertj.core.api.Assertions.assertThat;
public class SetSeverityActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
+
+ private UserSession userSessionMock = mock(UserSession.class);
+
private SetSeverityAction action;
private IssueUpdater issueUpdater = mock(IssueUpdater.class);
- private UserSession userSession;
-
@Before
public void before() {
- action = new SetSeverityAction(issueUpdater);
- userSession = mock(UserSession.class);
- UserSessionTestUtils.setUserSession(userSession);
+ action = new SetSeverityAction(issueUpdater, userSessionRule);
+ userSessionRule.set(userSessionMock);
}
@Test
Map<String, Object> properties = newHashMap();
properties.put("unknwown", "unknown value");
try {
- action.verify(properties, Lists.<Issue>newArrayList(), MockUserSession.create());
+ action.verify(properties, Lists.<Issue>newArrayList(), new AnonymousMockUserSession());
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalArgumentException.class).hasMessage("Missing parameter : 'severity'");
@Test
public void should_support_only_unresolved_issues() {
- when(userSession.hasProjectPermission(UserRole.ISSUE_ADMIN, "foo:bar")).thenReturn(true);
+ when(userSessionMock.hasProjectPermission(UserRole.ISSUE_ADMIN, "foo:bar")).thenReturn(true);
assertThat(action.supports(new DefaultIssue().setProjectKey("foo:bar").setResolution(null))).isTrue();
assertThat(action.supports(new DefaultIssue().setProjectKey("foo:bar").setResolution(Issue.RESOLUTION_FIXED))).isFalse();
}
@Test
public void should_support_only_issues_with_issue_admin_permission() {
- when(userSession.hasProjectPermission(UserRole.ISSUE_ADMIN, "foo:bar")).thenReturn(true);
+ when(userSessionMock.hasProjectPermission(UserRole.ISSUE_ADMIN, "foo:bar")).thenReturn(true);
assertThat(action.supports(new DefaultIssue().setProjectKey("foo:bar").setResolution(null))).isTrue();
assertThat(action.supports(new DefaultIssue().setProjectKey("foo:bar2").setResolution(null))).isFalse();
}
package org.sonar.server.issue;
import com.google.common.collect.Lists;
+import java.util.Map;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.issue.Issue;
import org.sonar.api.issue.internal.DefaultIssue;
import org.sonar.api.issue.internal.IssueChangeContext;
import org.sonar.core.issue.workflow.IssueWorkflow;
import org.sonar.core.issue.workflow.Transition;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.Map;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Maps.newHashMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
public class TransitionActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
private TransitionAction action;
@Before
public void before() {
- action = new TransitionAction(workflow);
+ action = new TransitionAction(workflow, userSessionRule);
}
@Test
Map<String, Object> properties = newHashMap();
properties.put("unknwown", transition);
try {
- action.verify(properties, Lists.<Issue>newArrayList(), MockUserSession.create());
+ action.verify(properties, Lists.<Issue>newArrayList(), userSessionRule);
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalArgumentException.class).hasMessage("Missing parameter : 'transition'");
import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.NotFoundException;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.MockUserSession;
import org.sonar.server.user.UserSession;
import java.util.Collection;
String projectKey = "org.sonar.Sample";
- UserSession projectAdministratorUserSession = MockUserSession.create().setLogin("nicolas").setName("Nicolas").addProjectPermissions(UserRole.ADMIN, projectKey);
- UserSession projectUserSession = MockUserSession.create().setLogin("nicolas").setName("Nicolas").addProjectPermissions(UserRole.USER, projectKey);
- UserSession unauthorizedUserSession = MockUserSession.create().setLogin("nicolas").setName("Nicolas");
+ UserSession projectAdministratorUserSession = new MockUserSession("nicolas").setName("Nicolas").addProjectPermissions(UserRole.ADMIN, projectKey);
+ UserSession projectUserSession = new MockUserSession("nicolas").setName("Nicolas").addProjectPermissions(UserRole.USER, projectKey);
+ UserSession unauthorizedUserSession = new MockUserSession("nicolas").setName("Nicolas");
private ActionPlanService actionPlanService;
package org.sonar.server.issue.filter;
+import java.util.Arrays;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.sonar.core.issue.db.IssueFilterDto;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.util.Arrays;
-
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class AppActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Mock
IssueFilterService service;
@Before
public void setUp() {
- action = new AppAction(service, writer);
+ action = new AppAction(service, writer, userSessionRule);
tester = new WsTester(new IssueFilterWs(action, mock(ShowAction.class), mock(FavoritesAction.class)));
}
@Test
public void anonymous_app() throws Exception {
- MockUserSession.set().setLogin(null);
+ userSessionRule.anonymous();
tester.newGetRequest("api/issue_filters", "app").execute().assertJson(getClass(), "anonymous_page.json");
}
@Test
public void logged_in_app() throws Exception {
- MockUserSession.set().setLogin("eric").setUserId(123);
+ userSessionRule.logon("eric").setUserId(123);
tester.newGetRequest("api/issue_filters", "app").execute()
.assertJson(getClass(), "logged_in_page.json");
}
@Test
public void logged_in_app_with_favorites() throws Exception {
- MockUserSession session = MockUserSession.set().setLogin("eric").setUserId(123);
- when(service.findFavoriteFilters(session)).thenReturn(Arrays.asList(
+ userSessionRule.logon("eric").setUserId(123);
+ when(service.findFavoriteFilters(userSessionRule)).thenReturn(Arrays.asList(
new IssueFilterDto().setId(6L).setName("My issues"),
new IssueFilterDto().setId(13L).setName("Blocker issues")
));
@Test
public void logged_in_app_with_selected_filter() throws Exception {
- MockUserSession session = MockUserSession.set().setLogin("eric").setUserId(123);
- when(service.find(13L, session)).thenReturn(
+ userSessionRule.logon("eric").setUserId(123);
+ when(service.find(13L, userSessionRule)).thenReturn(
new IssueFilterDto().setId(13L).setName("Blocker issues").setData("severity=BLOCKER").setUserLogin("eric")
);
@Test
public void app_selected_filter_can_not_be_modified() throws Exception {
// logged-in user is 'eric' but filter is owned by 'simon'
- MockUserSession session = MockUserSession.set().setLogin("eric").setUserId(123).setGlobalPermissions("none");
- when(service.find(13L, session)).thenReturn(
+ userSessionRule.logon("eric").setUserId(123).setGlobalPermissions("none");
+ when(service.find(13L, userSessionRule)).thenReturn(
new IssueFilterDto().setId(13L).setName("Blocker issues").setData("severity=BLOCKER").setUserLogin("simon").setShared(true)
);
package org.sonar.server.issue.filter;
+import java.util.Arrays;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.sonar.core.issue.db.IssueFilterDto;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.util.Arrays;
-
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class FavoritesActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Mock
IssueFilterService service;
@Before
public void setUp() {
- action = new FavoritesAction(service);
+ action = new FavoritesAction(service, userSessionRule);
tester = new WsTester(new IssueFilterWs(mock(AppAction.class), mock(ShowAction.class), action));
}
@Test
public void favorites_of_anonymous() throws Exception {
- MockUserSession.set();
+ userSessionRule.logon();
tester.newGetRequest("api/issue_filters", "favorites").execute()
.assertJson("{\"favoriteFilters\": []}");
@Test
public void favorites_of_logged_in_user() throws Exception {
- MockUserSession session = MockUserSession.set().setLogin("eric").setUserId(123);
- when(service.findFavoriteFilters(session)).thenReturn(Arrays.asList(
+ userSessionRule.logon("eric").setUserId(123);
+ when(service.findFavoriteFilters(userSessionRule)).thenReturn(Arrays.asList(
new IssueFilterDto().setId(13L).setName("Blocker issues").setData("severity=BLOCKER").setUserLogin("simon").setShared(true)
));
import org.sonar.server.issue.IssueQuery;
import org.sonar.server.issue.index.IssueDoc;
import org.sonar.server.issue.index.IssueIndex;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.AnonymousMockUserSession;
+import org.sonar.server.tester.MockUserSession;
import org.sonar.server.user.UserSession;
import java.util.Collections;
IssueIndex issueIndex = mock(IssueIndex.class);
AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
IssueFilterSerializer issueFilterSerializer = mock(IssueFilterSerializer.class);
- UserSession userSession = MockUserSession.create().setLogin("john");
+ UserSession userSession = new MockUserSession("john");
IssueFilterService service = new IssueFilterService(issueFilterDao, issueFilterFavouriteDao, issueIndex, authorizationDao, issueFilterSerializer);
@Test
@Test
public void should_not_find_by_id_if_not_logged() {
- UserSession userSession = MockUserSession.create().setLogin(null);
try {
- service.find(1L, userSession);
+ service.find(1L, new AnonymousMockUserSession());
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(UnauthorizedException.class).hasMessage("User is not logged in");
@Test
public void should_not_find_by_user_if_not_logged() {
- UserSession userSession = MockUserSession.create().setLogin(null);
try {
- service.findByUser(userSession);
+ service.findByUser(new AnonymousMockUserSession());
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(UnauthorizedException.class).hasMessage("User is not logged in");
@Test
public void should_not_save_if_not_logged() {
- UserSession userSession = MockUserSession.create().setLogin(null);
try {
IssueFilterDto issueFilter = new IssueFilterDto().setName("My Issue");
- service.save(issueFilter, userSession);
+ service.save(issueFilter, new AnonymousMockUserSession());
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(UnauthorizedException.class).hasMessage("User is not logged in");
try {
IssueFilterDto issueFilter = new IssueFilterDto().setId(1L).setName("My filter").setShared(true).setUserLogin("new.owner");
- service.update(issueFilter, MockUserSession.create().setUserId(1).setLogin(currentUser));
+ service.update(issueFilter, new MockUserSession(currentUser).setUserId(1));
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(ForbiddenException.class).hasMessage("User is not authorized to change the owner of this filter");
@Test
public void should_execute_from_issue_query() {
- IssueQuery issueQuery = IssueQuery.builder().build();
+ IssueQuery issueQuery = IssueQuery.builder(userSession).build();
SearchOptions searchOptions = new SearchOptions().setPage(2, 50);
SearchResult<IssueDoc> result = mock(SearchResult.class);
@Test
public void should_not_find_favourite_issue_filter_if_not_logged() {
- UserSession userSession = MockUserSession.create().setLogin(null);
-
try {
- service.findFavoriteFilters(userSession);
+ service.findFavoriteFilters(new AnonymousMockUserSession());
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(UnauthorizedException.class).hasMessage("User is not logged in");
@Test
public void user_can_share_filter_if_logged_and_own_sharing_permission() {
when(authorizationDao.selectGlobalPermissions("john")).thenReturn(newArrayList(GlobalPermissions.DASHBOARD_SHARING));
- UserSession userSession = MockUserSession.create().setLogin("john");
+ UserSession userSession = new MockUserSession("john");
assertThat(service.canShareFilter(userSession)).isTrue();
- userSession = MockUserSession.create().setLogin(null);
- assertThat(service.canShareFilter(userSession)).isFalse();
+ assertThat(service.canShareFilter(new AnonymousMockUserSession())).isFalse();
when(authorizationDao.selectGlobalPermissions("john")).thenReturn(Collections.<String>emptyList());
- userSession = MockUserSession.create().setLogin("john");
+ userSession = new MockUserSession("john");
assertThat(service.canShareFilter(userSession)).isFalse();
}
import org.sonar.api.utils.text.JsonWriter;
import org.sonar.core.issue.db.IssueFilterDto;
import org.sonar.core.permission.GlobalPermissions;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.AnonymousMockUserSession;
+import org.sonar.server.tester.MockUserSession;
import org.sonar.server.user.UserSession;
import java.io.StringWriter;
@Test
public void write_filter() {
- UserSession userSession = MockUserSession.set();
- test(userSession,
+ test(new AnonymousMockUserSession(),
new IssueFilterDto()
.setId(13L)
.setName("Blocker issues")
@Test
public void can_modify_if_logged_user_own_filter() {
- UserSession userSession = MockUserSession.set().setLogin("simon");
- test(userSession,
+ test(new MockUserSession("simon"),
new IssueFilterDto()
.setId(13L)
.setName("Blocker issues")
@Test
public void can_modify_if_logged_user_has_permission() {
- UserSession userSession = MockUserSession.set().setLogin("simon").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ UserSession userSession = new MockUserSession("simon").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
test(userSession,
new IssueFilterDto()
.setId(13L)
package org.sonar.server.issue.filter;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.sonar.api.server.ws.WebService;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
@RunWith(MockitoJUnitRunner.class)
public class IssueFilterWsTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Mock
IssueFilterService service;
@Before
public void setUp() {
- ws = new IssueFilterWs(new AppAction(service, issueFilterWriter), new ShowAction(service, issueFilterWriter), new FavoritesAction(service));
+ ws = new IssueFilterWs(new AppAction(service, issueFilterWriter, userSessionRule), new ShowAction(service, issueFilterWriter, userSessionRule), new FavoritesAction(service, userSessionRule));
tester = new WsTester(ws);
}
package org.sonar.server.issue.filter;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.sonar.core.issue.db.IssueFilterDto;
import org.sonar.server.exceptions.NotFoundException;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
@RunWith(MockitoJUnitRunner.class)
public class ShowActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Mock
IssueFilterService service;
@Before
public void setUp() {
- action = new ShowAction(service, writer);
+ action = new ShowAction(service, writer, userSessionRule);
tester = new WsTester(new IssueFilterWs(mock(AppAction.class), action, mock(FavoritesAction.class)));
}
@Test
public void show_filter() throws Exception {
// logged-in user is 'eric' but filter is owned by 'simon'
- MockUserSession session = MockUserSession.set().setLogin("eric").setUserId(123).setGlobalPermissions("none");
- when(service.find(13L, session)).thenReturn(
+ userSessionRule.logon("eric").setUserId(123).setGlobalPermissions("none");
+ when(service.find(13L, userSessionRule)).thenReturn(
new IssueFilterDto().setId(13L).setName("Blocker issues").setDescription("All Blocker Issues").setData("severity=BLOCKER").setUserLogin("simon").setShared(true)
);
@Test
public void show_unknown_filter() throws Exception {
- MockUserSession session = MockUserSession.set().setLogin("eric").setUserId(123).setGlobalPermissions("none");
- when(service.find(42L, session)).thenThrow(new NotFoundException("Filter 42 does not exist"));
+ userSessionRule.logon("eric").setUserId(123).setGlobalPermissions("none");
+ when(service.find(42L, userSessionRule)).thenThrow(new NotFoundException("Filter 42 does not exist"));
try {
tester.newGetRequest("api/issue_filters", "show").setParam("id", "42").execute();
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Iterators;
import com.google.common.collect.Lists;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import java.util.TimeZone;
+import javax.annotation.Nullable;
import org.assertj.core.api.Fail;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.api.issue.Issue;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.issue.IssueQuery;
import org.sonar.server.issue.IssueTesting;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.view.index.ViewDoc;
import org.sonar.server.view.index.ViewIndexDefinition;
import org.sonar.server.view.index.ViewIndexer;
-import javax.annotation.Nullable;
-
-import java.util.*;
-
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.entry;
@ClassRule
public static EsTester tester = new EsTester().addDefinitions(new IssueIndexDefinition(new Settings()), new ViewIndexDefinition(new Settings()));
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
IssueIndex index;
when(system.getDefaultTimeZone()).thenReturn(TimeZone.getTimeZone("+01:00"));
when(system.now()).thenReturn(System.currentTimeMillis());
- index = new IssueIndex(tester.client(), system);
+ index = new IssueIndex(tester.client(), system, userSessionRule);
}
IssueTesting.newDoc("1", ComponentTesting.newFileDto(project)),
IssueTesting.newDoc("2", ComponentTesting.newFileDto(project)));
- assertThat(index.search(IssueQuery.builder().issueKeys(newArrayList("1", "2")).build(), new SearchOptions()).getDocs()).hasSize(2);
- assertThat(index.search(IssueQuery.builder().issueKeys(newArrayList("1")).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().issueKeys(newArrayList("3", "4")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).issueKeys(newArrayList("1", "2")).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).issueKeys(newArrayList("1")).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).issueKeys(newArrayList("3", "4")).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
IssueTesting.newDoc("ISSUE5", subModule),
IssueTesting.newDoc("ISSUE6", ComponentTesting.newFileDto(subModule)));
- assertThat(index.search(IssueQuery.builder().projectUuids(newArrayList(project.uuid())).build(), new SearchOptions()).getDocs()).hasSize(6);
- assertThat(index.search(IssueQuery.builder().projectUuids(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).projectUuids(newArrayList(project.uuid())).build(), new SearchOptions()).getDocs()).hasSize(6);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).projectUuids(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
IssueTesting.newDoc("ISSUE2", ComponentTesting.newFileDto(project)),
IssueTesting.newDoc("ISSUE3", ComponentTesting.newFileDto(project2)));
- SearchResult<IssueDoc> result = index.search(IssueQuery.builder().build(), new SearchOptions().addFacets(newArrayList("projectUuids")));
+ SearchResult<IssueDoc> result = index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions().addFacets(newArrayList("projectUuids")));
assertThat(result.getFacets().getNames()).containsOnly("projectUuids");
assertThat(result.getFacets().get("projectUuids")).containsOnly(entry("ABCD", 2L), entry("EFGH", 1L));
}
IssueTesting.newDoc("ISSUE5", subModule),
IssueTesting.newDoc("ISSUE2", file));
- assertThat(index.search(IssueQuery.builder().projectUuids(newArrayList(project.uuid())).moduleUuids(newArrayList(file.uuid())).build(), new SearchOptions()).getDocs())
+ assertThat(index.search(IssueQuery.builder(userSessionRule).projectUuids(newArrayList(project.uuid())).moduleUuids(newArrayList(file.uuid())).build(), new SearchOptions()).getDocs())
.isEmpty();
- assertThat(index.search(IssueQuery.builder().projectUuids(newArrayList(project.uuid())).moduleUuids(newArrayList(module.uuid())).build(), new SearchOptions()).getDocs())
+ assertThat(index.search(IssueQuery.builder(userSessionRule).projectUuids(newArrayList(project.uuid())).moduleUuids(newArrayList(module.uuid())).build(), new SearchOptions()).getDocs())
.hasSize(1);
- assertThat(index.search(IssueQuery.builder().projectUuids(newArrayList(project.uuid())).moduleUuids(newArrayList(subModule.uuid())).build(), new SearchOptions()).getDocs())
+ assertThat(index.search(IssueQuery.builder(userSessionRule).projectUuids(newArrayList(project.uuid())).moduleUuids(newArrayList(subModule.uuid())).build(), new SearchOptions()).getDocs())
.hasSize(2);
- assertThat(index.search(IssueQuery.builder().projectUuids(newArrayList(project.uuid())).moduleUuids(newArrayList(project.uuid())).build(), new SearchOptions()).getDocs())
+ assertThat(index.search(IssueQuery.builder(userSessionRule).projectUuids(newArrayList(project.uuid())).moduleUuids(newArrayList(project.uuid())).build(), new SearchOptions()).getDocs())
.isEmpty();
- assertThat(index.search(IssueQuery.builder().projectUuids(newArrayList(project.uuid())).moduleUuids(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).projectUuids(newArrayList(project.uuid())).moduleUuids(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
IssueTesting.newDoc("ISSUE5", subModule),
IssueTesting.newDoc("ISSUE6", file3));
- assertThat(index.search(IssueQuery.builder().fileUuids(newArrayList(file1.uuid(), file2.uuid(), file3.uuid())).build(), new SearchOptions())
+ assertThat(index.search(IssueQuery.builder(userSessionRule).fileUuids(newArrayList(file1.uuid(), file2.uuid(), file3.uuid())).build(), new SearchOptions())
.getDocs()).hasSize(3);
- assertThat(index.search(IssueQuery.builder().fileUuids(newArrayList(file1.uuid())).build(), new SearchOptions())
+ assertThat(index.search(IssueQuery.builder(userSessionRule).fileUuids(newArrayList(file1.uuid())).build(), new SearchOptions())
.getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().moduleRootUuids(newArrayList(subModule.uuid())).build(), new SearchOptions())
+ assertThat(index.search(IssueQuery.builder(userSessionRule).moduleRootUuids(newArrayList(subModule.uuid())).build(), new SearchOptions())
.getDocs()).hasSize(2);
- assertThat(index.search(IssueQuery.builder().moduleRootUuids(newArrayList(module.uuid())).build(), new SearchOptions())
+ assertThat(index.search(IssueQuery.builder(userSessionRule).moduleRootUuids(newArrayList(module.uuid())).build(), new SearchOptions())
.getDocs()).hasSize(4);
- assertThat(index.search(IssueQuery.builder().projectUuids(newArrayList(project.uuid())).build(), new SearchOptions())
+ assertThat(index.search(IssueQuery.builder(userSessionRule).projectUuids(newArrayList(project.uuid())).build(), new SearchOptions())
.getDocs()).hasSize(6);
- assertThat(index.search(IssueQuery.builder().viewUuids(newArrayList(view)).build(), new SearchOptions())
+ assertThat(index.search(IssueQuery.builder(userSessionRule).viewUuids(newArrayList(view)).build(), new SearchOptions())
.getDocs()).hasSize(6);
- assertThat(index.search(IssueQuery.builder().projectUuids(newArrayList("unknown")).build(), new SearchOptions())
+ assertThat(index.search(IssueQuery.builder(userSessionRule).projectUuids(newArrayList("unknown")).build(), new SearchOptions())
.getDocs()).isEmpty();
}
IssueTesting.newDoc("ISSUE5", subModule),
IssueTesting.newDoc("ISSUE6", file3));
- assertThat(index.search(IssueQuery.builder().projectUuids(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
- assertThat(index.search(IssueQuery.builder().projectUuids(newArrayList(project.uuid())).build(), new SearchOptions()).getDocs()).hasSize(6);
- assertThat(index.search(IssueQuery.builder().viewUuids(newArrayList(view)).build(), new SearchOptions()).getDocs()).hasSize(6);
- assertThat(index.search(IssueQuery.builder().moduleUuids(newArrayList(module.uuid())).build(), new SearchOptions()).getDocs()).hasSize(2);
- assertThat(index.search(IssueQuery.builder().moduleUuids(newArrayList(subModule.uuid())).build(), new SearchOptions()).getDocs()).hasSize(2); // XXX
+ assertThat(index.search(IssueQuery.builder(userSessionRule).projectUuids(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).projectUuids(newArrayList(project.uuid())).build(), new SearchOptions()).getDocs()).hasSize(6);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).viewUuids(newArrayList(view)).build(), new SearchOptions()).getDocs()).hasSize(6);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).moduleUuids(newArrayList(module.uuid())).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).moduleUuids(newArrayList(subModule.uuid())).build(), new SearchOptions()).getDocs()).hasSize(2); // XXX
// Misleading
// !
- assertThat(index.search(IssueQuery.builder().fileUuids(newArrayList(file1.uuid())).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().fileUuids(newArrayList(file1.uuid(), file2.uuid(), file3.uuid())).build(), new SearchOptions()).getDocs()).hasSize(3);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).fileUuids(newArrayList(file1.uuid())).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).fileUuids(newArrayList(file1.uuid(), file2.uuid(), file3.uuid())).build(), new SearchOptions()).getDocs()).hasSize(3);
}
@Test
IssueTesting.newDoc("ISSUE4", file2),
IssueTesting.newDoc("ISSUE5", file3));
- SearchResult<IssueDoc> result = index.search(IssueQuery.builder().build(), new SearchOptions().addFacets(newArrayList("fileUuids")));
+ SearchResult<IssueDoc> result = index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions().addFacets(newArrayList("fileUuids")));
assertThat(result.getFacets().getNames()).containsOnly("fileUuids");
assertThat(result.getFacets().get("fileUuids"))
.containsOnly(entry("A", 1L), entry("ABCD", 1L), entry("BCDE", 2L), entry("CDEF", 1L));
IssueTesting.newDoc("ISSUE1", file1).setDirectoryPath("/src/main/xoo"),
IssueTesting.newDoc("ISSUE2", file2).setDirectoryPath("/"));
- assertThat(index.search(IssueQuery.builder().directories(newArrayList("/src/main/xoo")).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().directories(newArrayList("/")).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().directories(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).directories(newArrayList("/src/main/xoo")).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).directories(newArrayList("/")).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).directories(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
IssueTesting.newDoc("ISSUE1", file1).setDirectoryPath("/src/main/xoo"),
IssueTesting.newDoc("ISSUE2", file2).setDirectoryPath("/"));
- SearchResult<IssueDoc> result = index.search(IssueQuery.builder().build(), new SearchOptions().addFacets(newArrayList("directories")));
+ SearchResult<IssueDoc> result = index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions().addFacets(newArrayList("directories")));
assertThat(result.getFacets().getNames()).containsOnly("directories");
assertThat(result.getFacets().get("directories")).containsOnly(entry("/src/main/xoo", 1L), entry("/", 1L));
}
String view2 = "CDEF";
indexView(view2, newArrayList(project2.uuid()));
- assertThat(index.search(IssueQuery.builder().viewUuids(newArrayList(view1)).build(), new SearchOptions()).getDocs()).hasSize(2);
- assertThat(index.search(IssueQuery.builder().viewUuids(newArrayList(view2)).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().viewUuids(newArrayList(view1, view2)).build(), new SearchOptions()).getDocs()).hasSize(3);
- assertThat(index.search(IssueQuery.builder().viewUuids(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).viewUuids(newArrayList(view1)).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).viewUuids(newArrayList(view2)).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).viewUuids(newArrayList(view1, view2)).build(), new SearchOptions()).getDocs()).hasSize(3);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).viewUuids(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
IssueTesting.newDoc("ISSUE1", file).setSeverity(Severity.INFO),
IssueTesting.newDoc("ISSUE2", file).setSeverity(Severity.MAJOR));
- assertThat(index.search(IssueQuery.builder().severities(newArrayList(Severity.INFO, Severity.MAJOR)).build(), new SearchOptions()).getDocs()).hasSize(2);
- assertThat(index.search(IssueQuery.builder().severities(newArrayList(Severity.INFO)).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().severities(newArrayList(Severity.BLOCKER)).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).severities(newArrayList(Severity.INFO, Severity.MAJOR)).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).severities(newArrayList(Severity.INFO)).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).severities(newArrayList(Severity.BLOCKER)).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
IssueTesting.newDoc("ISSUE2", file).setSeverity(Severity.INFO),
IssueTesting.newDoc("ISSUE3", file).setSeverity(Severity.MAJOR));
- SearchResult<IssueDoc> result = index.search(IssueQuery.builder().build(), new SearchOptions().addFacets(newArrayList("severities")));
+ SearchResult<IssueDoc> result = index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions().addFacets(newArrayList("severities")));
assertThat(result.getFacets().getNames()).containsOnly("severities");
assertThat(result.getFacets().get("severities")).containsOnly(entry("INFO", 2L), entry("MAJOR", 1L));
}
IssueTesting.newDoc("ISSUE1", file).setStatus(Issue.STATUS_CLOSED),
IssueTesting.newDoc("ISSUE2", file).setStatus(Issue.STATUS_OPEN));
- assertThat(index.search(IssueQuery.builder().statuses(newArrayList(Issue.STATUS_CLOSED, Issue.STATUS_OPEN)).build(), new SearchOptions()).getDocs()).hasSize(2);
- assertThat(index.search(IssueQuery.builder().statuses(newArrayList(Issue.STATUS_CLOSED)).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().statuses(newArrayList(Issue.STATUS_CONFIRMED)).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).statuses(newArrayList(Issue.STATUS_CLOSED, Issue.STATUS_OPEN)).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).statuses(newArrayList(Issue.STATUS_CLOSED)).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).statuses(newArrayList(Issue.STATUS_CONFIRMED)).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
IssueTesting.newDoc("ISSUE2", file).setStatus(Issue.STATUS_CLOSED),
IssueTesting.newDoc("ISSUE3", file).setStatus(Issue.STATUS_OPEN));
- SearchResult<IssueDoc> result = index.search(IssueQuery.builder().build(), new SearchOptions().addFacets(newArrayList("statuses")));
+ SearchResult<IssueDoc> result = index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions().addFacets(newArrayList("statuses")));
assertThat(result.getFacets().getNames()).containsOnly("statuses");
assertThat(result.getFacets().get("statuses")).containsOnly(entry("CLOSED", 2L), entry("OPEN", 1L));
}
IssueTesting.newDoc("ISSUE1", file).setResolution(Issue.RESOLUTION_FALSE_POSITIVE),
IssueTesting.newDoc("ISSUE2", file).setResolution(Issue.RESOLUTION_FIXED));
- assertThat(index.search(IssueQuery.builder().resolutions(newArrayList(Issue.RESOLUTION_FALSE_POSITIVE, Issue.RESOLUTION_FIXED)).build(), new SearchOptions()).getDocs())
+ assertThat(index.search(IssueQuery.builder(userSessionRule).resolutions(newArrayList(Issue.RESOLUTION_FALSE_POSITIVE, Issue.RESOLUTION_FIXED)).build(), new SearchOptions()).getDocs())
.hasSize(2);
- assertThat(index.search(IssueQuery.builder().resolutions(newArrayList(Issue.RESOLUTION_FALSE_POSITIVE)).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().resolutions(newArrayList(Issue.RESOLUTION_REMOVED)).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).resolutions(newArrayList(Issue.RESOLUTION_FALSE_POSITIVE)).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).resolutions(newArrayList(Issue.RESOLUTION_REMOVED)).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
IssueTesting.newDoc("ISSUE2", file).setResolution(Issue.RESOLUTION_FALSE_POSITIVE),
IssueTesting.newDoc("ISSUE3", file).setResolution(Issue.RESOLUTION_FIXED));
- SearchResult<IssueDoc> result = index.search(IssueQuery.builder().build(), new SearchOptions().addFacets(newArrayList("resolutions")));
+ SearchResult<IssueDoc> result = index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions().addFacets(newArrayList("resolutions")));
assertThat(result.getFacets().getNames()).containsOnly("resolutions");
assertThat(result.getFacets().get("resolutions")).containsOnly(entry("FALSE-POSITIVE", 2L), entry("FIXED", 1L));
}
IssueTesting.newDoc("ISSUE2", file).setStatus(Issue.STATUS_OPEN).setResolution(null),
IssueTesting.newDoc("ISSUE3", file).setStatus(Issue.STATUS_OPEN).setResolution(null));
- assertThat(index.search(IssueQuery.builder().resolved(true).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().resolved(false).build(), new SearchOptions()).getDocs()).hasSize(2);
- assertThat(index.search(IssueQuery.builder().resolved(null).build(), new SearchOptions()).getDocs()).hasSize(3);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).resolved(true).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).resolved(false).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).resolved(null).build(), new SearchOptions()).getDocs()).hasSize(3);
}
@Test
IssueTesting.newDoc("ISSUE1", file).setActionPlanKey("plan1"),
IssueTesting.newDoc("ISSUE2", file).setActionPlanKey("plan2"));
- assertThat(index.search(IssueQuery.builder().actionPlans(newArrayList("plan1")).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().actionPlans(newArrayList("plan1", "plan2")).build(), new SearchOptions()).getDocs()).hasSize(2);
- assertThat(index.search(IssueQuery.builder().actionPlans(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).actionPlans(newArrayList("plan1")).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).actionPlans(newArrayList("plan1", "plan2")).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).actionPlans(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
IssueTesting.newDoc("ISSUE1", file).setActionPlanKey("plan1"),
IssueTesting.newDoc("ISSUE2", file).setActionPlanKey("plan2"));
- SearchResult<IssueDoc> result = index.search(IssueQuery.builder().build(), new SearchOptions().addFacets(newArrayList("actionPlans")));
+ SearchResult<IssueDoc> result = index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions().addFacets(newArrayList("actionPlans")));
assertThat(result.getFacets().getNames()).containsOnly("actionPlans");
assertThat(result.getFacets().get("actionPlans")).containsOnly(entry("plan1", 1L), entry("plan2", 1L));
}
IssueTesting.newDoc("ISSUE2", file).setActionPlanKey(null),
IssueTesting.newDoc("ISSUE3", file).setActionPlanKey(null));
- assertThat(index.search(IssueQuery.builder().planned(true).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().planned(false).build(), new SearchOptions()).getDocs()).hasSize(2);
- assertThat(index.search(IssueQuery.builder().planned(null).build(), new SearchOptions()).getDocs()).hasSize(3);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).planned(true).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).planned(false).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).planned(null).build(), new SearchOptions()).getDocs()).hasSize(3);
}
@Test
indexIssues(IssueTesting.newDoc("ISSUE1", file).setRuleKey(ruleKey.toString()));
- assertThat(index.search(IssueQuery.builder().rules(newArrayList(ruleKey)).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().rules(newArrayList(RuleKey.of("rule", "without issue"))).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).rules(newArrayList(ruleKey)).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).rules(newArrayList(RuleKey.of("rule", "without issue"))).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
indexIssues(IssueTesting.newDoc("ISSUE1", file).setRuleKey(ruleKey.toString()).setLanguage("xoo"));
- assertThat(index.search(IssueQuery.builder().languages(newArrayList("xoo")).build(),
+ assertThat(index.search(IssueQuery.builder(userSessionRule).languages(newArrayList("xoo")).build(),
new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().languages(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).languages(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
indexIssues(IssueTesting.newDoc("ISSUE1", file).setRuleKey(ruleKey.toString()).setLanguage("xoo"));
- SearchResult<IssueDoc> result = index.search(IssueQuery.builder().build(), new SearchOptions().addFacets(newArrayList("languages")));
+ SearchResult<IssueDoc> result = index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions().addFacets(newArrayList("languages")));
assertThat(result.getFacets().getNames()).containsOnly("languages");
assertThat(result.getFacets().get("languages")).containsOnly(entry("xoo", 1L));
}
IssueTesting.newDoc("ISSUE2", file).setAssignee("simon"),
IssueTesting.newDoc("ISSUE3", file).setAssignee(null));
- assertThat(index.search(IssueQuery.builder().assignees(newArrayList("steph")).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().assignees(newArrayList("steph", "simon")).build(), new SearchOptions()).getDocs()).hasSize(2);
- assertThat(index.search(IssueQuery.builder().assignees(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).assignees(newArrayList("steph")).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).assignees(newArrayList("steph", "simon")).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).assignees(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
IssueTesting.newDoc("ISSUE3", file).setAssignee("simon"),
IssueTesting.newDoc("ISSUE4", file).setAssignee(null));
- SearchResult<IssueDoc> result = index.search(IssueQuery.builder().build(), new SearchOptions().addFacets(newArrayList("assignees")));
+ SearchResult<IssueDoc> result = index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions().addFacets(newArrayList("assignees")));
assertThat(result.getFacets().getNames()).containsOnly("assignees");
assertThat(result.getFacets().get("assignees")).containsOnly(entry("steph", 1L), entry("simon", 2L), entry("", 1L));
}
IssueTesting.newDoc("ISSUE3", file).setAssignee("simon"),
IssueTesting.newDoc("ISSUE4", file).setAssignee(null));
- SearchResult<IssueDoc> result = index.search(IssueQuery.builder().assignees(Arrays.asList("j-b")).build(), new SearchOptions().addFacets(newArrayList("assignees")));
+ SearchResult<IssueDoc> result = index.search(IssueQuery.builder(userSessionRule).assignees(Arrays.asList("j-b")).build(), new SearchOptions().addFacets(newArrayList("assignees")));
assertThat(result.getFacets().getNames()).containsOnly("assignees");
assertThat(result.getFacets().get("assignees")).containsOnly(entry("j-b", 1L), entry("simon", 2L), entry("", 1L));
}
IssueTesting.newDoc("ISSUE2", file).setAssignee(null),
IssueTesting.newDoc("ISSUE3", file).setAssignee(null));
- assertThat(index.search(IssueQuery.builder().assigned(true).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().assigned(false).build(), new SearchOptions()).getDocs()).hasSize(2);
- assertThat(index.search(IssueQuery.builder().assigned(null).build(), new SearchOptions()).getDocs()).hasSize(3);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).assigned(true).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).assigned(false).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).assigned(null).build(), new SearchOptions()).getDocs()).hasSize(3);
}
@Test
IssueTesting.newDoc("ISSUE1", file).setReporter("fabrice"),
IssueTesting.newDoc("ISSUE2", file).setReporter("stephane"));
- assertThat(index.search(IssueQuery.builder().reporters(newArrayList("fabrice", "stephane")).build(), new SearchOptions()).getDocs()).hasSize(2);
- assertThat(index.search(IssueQuery.builder().reporters(newArrayList("fabrice")).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().reporters(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).reporters(newArrayList("fabrice", "stephane")).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).reporters(newArrayList("fabrice")).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).reporters(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
IssueTesting.newDoc("ISSUE2", file).setAuthorLogin("simon"),
IssueTesting.newDoc("ISSUE3", file).setAssignee(null));
- assertThat(index.search(IssueQuery.builder().authors(newArrayList("steph")).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().authors(newArrayList("steph", "simon")).build(), new SearchOptions()).getDocs()).hasSize(2);
- assertThat(index.search(IssueQuery.builder().authors(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).authors(newArrayList("steph")).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).authors(newArrayList("steph", "simon")).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).authors(newArrayList("unknown")).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
IssueTesting.newDoc("ISSUE3", file).setAuthorLogin("simon"),
IssueTesting.newDoc("ISSUE4", file).setAuthorLogin(null));
- SearchResult<IssueDoc> result = index.search(IssueQuery.builder().build(), new SearchOptions().addFacets(newArrayList("authors")));
+ SearchResult<IssueDoc> result = index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions().addFacets(newArrayList("authors")));
assertThat(result.getFacets().getNames()).containsOnly("authors");
assertThat(result.getFacets().get("authors")).containsOnly(entry("steph", 1L), entry("simon", 2L));
}
IssueTesting.newDoc("ISSUE1", file).setFuncCreationDate(DateUtils.parseDate("2014-09-20")),
IssueTesting.newDoc("ISSUE2", file).setFuncCreationDate(DateUtils.parseDate("2014-09-23")));
- assertThat(index.search(IssueQuery.builder().createdAfter(DateUtils.parseDate("2014-09-19")).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).createdAfter(DateUtils.parseDate("2014-09-19")).build(), new SearchOptions()).getDocs()).hasSize(2);
// Lower bound is excluded
- assertThat(index.search(IssueQuery.builder().createdAfter(DateUtils.parseDate("2014-09-20")).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().createdAfter(DateUtils.parseDate("2014-09-21")).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().createdAfter(DateUtils.parseDate("2014-09-25")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).createdAfter(DateUtils.parseDate("2014-09-20")).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).createdAfter(DateUtils.parseDate("2014-09-21")).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).createdAfter(DateUtils.parseDate("2014-09-25")).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
IssueTesting.newDoc("ISSUE1", file).setFuncCreationDate(DateUtils.parseDate("2014-09-20")),
IssueTesting.newDoc("ISSUE2", file).setFuncCreationDate(DateUtils.parseDate("2014-09-23")));
- assertThat(index.search(IssueQuery.builder().createdBefore(DateUtils.parseDate("2014-09-19")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).createdBefore(DateUtils.parseDate("2014-09-19")).build(), new SearchOptions()).getDocs()).isEmpty();
// Upper bound is excluded
- assertThat(index.search(IssueQuery.builder().createdBefore(DateUtils.parseDate("2014-09-20")).build(), new SearchOptions()).getDocs()).isEmpty();
- assertThat(index.search(IssueQuery.builder().createdBefore(DateUtils.parseDate("2014-09-21")).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().createdBefore(DateUtils.parseDate("2014-09-25")).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).createdBefore(DateUtils.parseDate("2014-09-20")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).createdBefore(DateUtils.parseDate("2014-09-21")).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).createdBefore(DateUtils.parseDate("2014-09-25")).build(), new SearchOptions()).getDocs()).hasSize(2);
}
@Test
IssueTesting.newDoc("ISSUE2", file).setFuncCreationDate(DateUtils.parseDate("2014-09-23")));
// 19 < createdAt < 25
- assertThat(index.search(IssueQuery.builder()
+ assertThat(index.search(IssueQuery.builder(userSessionRule)
.createdAfter(DateUtils.parseDate("2014-09-19")).createdBefore(DateUtils.parseDate("2014-09-25"))
.build(), new SearchOptions()).getDocs()).hasSize(2);
// 20 < createdAt < 25: excludes first issue
- assertThat(index.search(IssueQuery.builder()
+ assertThat(index.search(IssueQuery.builder(userSessionRule)
.createdAfter(DateUtils.parseDate("2014-09-20")).createdBefore(DateUtils.parseDate("2014-09-25"))
.build(), new SearchOptions()).getDocs()).hasSize(1);
// 21 < createdAt < 25
- assertThat(index.search(IssueQuery.builder()
+ assertThat(index.search(IssueQuery.builder(userSessionRule)
.createdAfter(DateUtils.parseDate("2014-09-21")).createdBefore(DateUtils.parseDate("2014-09-25"))
.build(), new SearchOptions()).getDocs()).hasSize(1);
// 21 < createdAt < 24
- assertThat(index.search(IssueQuery.builder()
+ assertThat(index.search(IssueQuery.builder(userSessionRule)
.createdAfter(DateUtils.parseDate("2014-09-21")).createdBefore(DateUtils.parseDate("2014-09-24"))
.build(), new SearchOptions()).getDocs()).hasSize(1);
// 21 < createdAt < 23: excludes second issue
- assertThat(index.search(IssueQuery.builder()
+ assertThat(index.search(IssueQuery.builder(userSessionRule)
.createdAfter(DateUtils.parseDate("2014-09-21")).createdBefore(DateUtils.parseDate("2014-09-23"))
.build(), new SearchOptions()).getDocs()).isEmpty();
// 19 < createdAt < 21: only first issue
- assertThat(index.search(IssueQuery.builder()
+ assertThat(index.search(IssueQuery.builder(userSessionRule)
.createdAfter(DateUtils.parseDate("2014-09-19")).createdBefore(DateUtils.parseDate("2014-09-21"))
.build(), new SearchOptions()).getDocs()).hasSize(1);
// 20 < createdAt < 20: nothing
- assertThat(index.search(IssueQuery.builder()
+ assertThat(index.search(IssueQuery.builder(userSessionRule)
.createdAfter(DateUtils.parseDate("2014-09-20")).createdBefore(DateUtils.parseDate("2014-09-20"))
.build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
public void filter_by_created_before_must_be_lower_than_after() {
try {
- index.search(IssueQuery.builder().createdAfter(DateUtils.parseDate("2014-09-20")).createdBefore(DateUtils.parseDate("2014-09-19")).build(), new SearchOptions());
+ index.search(IssueQuery.builder(userSessionRule).createdAfter(DateUtils.parseDate("2014-09-20")).createdBefore(DateUtils.parseDate("2014-09-19")).build(), new SearchOptions());
Fail.failBecauseExceptionWasNotThrown(IllegalArgumentException.class);
} catch (IllegalArgumentException exception) {
assertThat(exception.getMessage()).isEqualTo("Start bound cannot be larger than end bound");
@Test
public void filter_by_created_after_must_not_be_in_future() {
try {
- index.search(IssueQuery.builder().createdAfter(new Date(Long.MAX_VALUE)).build(), new SearchOptions());
+ index.search(IssueQuery.builder(userSessionRule).createdAfter(new Date(Long.MAX_VALUE)).build(), new SearchOptions());
Fail.failBecauseExceptionWasNotThrown(IllegalArgumentException.class);
} catch (IllegalArgumentException exception) {
assertThat(exception.getMessage()).isEqualTo("Start bound cannot be in the future");
indexIssues(IssueTesting.newDoc("ISSUE1", file).setFuncCreationDate(DateUtils.parseDate("2014-09-20")));
- assertThat(index.search(IssueQuery.builder().createdAt(DateUtils.parseDate("2014-09-20")).build(), new SearchOptions()).getDocs()).hasSize(1);
- assertThat(index.search(IssueQuery.builder().createdAt(DateUtils.parseDate("2014-09-21")).build(), new SearchOptions()).getDocs()).isEmpty();
+ assertThat(index.search(IssueQuery.builder(userSessionRule).createdAt(DateUtils.parseDate("2014-09-20")).build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).createdAt(DateUtils.parseDate("2014-09-21")).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
SearchOptions options = fixtureForCreatedAtFacet();
- IssueQuery query = IssueQuery.builder()
+ IssueQuery query = IssueQuery.builder(userSessionRule)
.createdAfter(DateUtils.parseDateTime("2014-09-01T00:00:00+0100"))
.createdBefore(DateUtils.parseDateTime("2014-09-08T00:00:00+0100"))
.checkAuthorization(false)
SearchOptions SearchOptions = fixtureForCreatedAtFacet();
- Map<String, Long> createdAt = index.search(IssueQuery.builder()
+ Map<String, Long> createdAt = index.search(IssueQuery.builder(userSessionRule)
.createdAfter(DateUtils.parseDateTime("2014-09-01T00:00:00+0100"))
.createdBefore(DateUtils.parseDateTime("2014-09-21T00:00:00+0100")).build(),
SearchOptions).getFacets().get("createdAt");
SearchOptions SearchOptions = fixtureForCreatedAtFacet();
- Map<String, Long> createdAt = index.search(IssueQuery.builder()
+ Map<String, Long> createdAt = index.search(IssueQuery.builder(userSessionRule)
.createdAfter(DateUtils.parseDateTime("2014-09-01T00:00:00+0100"))
.createdBefore(DateUtils.parseDateTime("2015-01-19T00:00:00+0100")).build(),
SearchOptions).getFacets().get("createdAt");
public void facet_on_created_at_with_more_than_20_months() {
SearchOptions SearchOptions = fixtureForCreatedAtFacet();
- Map<String, Long> createdAt = index.search(IssueQuery.builder()
+ Map<String, Long> createdAt = index.search(IssueQuery.builder(userSessionRule)
.createdAfter(DateUtils.parseDateTime("2011-01-01T00:00:00+0100"))
.createdBefore(DateUtils.parseDateTime("2016-01-01T00:00:00+0100")).build(),
SearchOptions).getFacets().get("createdAt");
public void facet_on_created_at_with_bounds_outside_of_data() {
SearchOptions options = fixtureForCreatedAtFacet();
- Map<String, Long> createdAt = index.search(IssueQuery.builder()
+ Map<String, Long> createdAt = index.search(IssueQuery.builder(userSessionRule)
.createdAfter(DateUtils.parseDateTime("2009-01-01T00:00:00+0100"))
.createdBefore(DateUtils.parseDateTime("2016-01-01T00:00:00+0100"))
.build(), options).getFacets().get("createdAt");
public void facet_on_created_at_without_start_bound() {
SearchOptions SearchOptions = fixtureForCreatedAtFacet();
- Map<String, Long> createdAt = index.search(IssueQuery.builder()
+ Map<String, Long> createdAt = index.search(IssueQuery.builder(userSessionRule)
.createdBefore(DateUtils.parseDateTime("2016-01-01T00:00:00+0100")).build(),
SearchOptions).getFacets().get("createdAt");
assertThat(createdAt).containsOnly(
public void facet_on_created_at_without_issues() {
SearchOptions SearchOptions = new SearchOptions().addFacets("createdAt");
- Map<String, Long> createdAt = index.search(IssueQuery.builder().build(),
+ Map<String, Long> createdAt = index.search(IssueQuery.builder(userSessionRule).build(),
SearchOptions).getFacets().get("createdAt");
assertThat(createdAt).isEmpty();
}
indexIssues(IssueTesting.newDoc("ISSUE" + i, file));
}
- IssueQuery.Builder query = IssueQuery.builder();
+ IssueQuery.Builder query = IssueQuery.builder(userSessionRule);
// There are 12 issues in total, with 10 issues per page, the page 2 should only contain 2 elements
SearchResult<IssueDoc> result = index.search(query.build(), new SearchOptions().setPage(2, 10));
assertThat(result.getDocs()).hasSize(2);
assertThat(result.getTotal()).isEqualTo(12);
- result = index.search(IssueQuery.builder().build(), new SearchOptions().setOffset(0).setLimit(5));
+ result = index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions().setOffset(0).setLimit(5));
assertThat(result.getDocs()).hasSize(5);
assertThat(result.getTotal()).isEqualTo(12);
- result = index.search(IssueQuery.builder().build(), new SearchOptions().setOffset(2).setLimit(0));
+ result = index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions().setOffset(2).setLimit(0));
assertThat(result.getDocs()).hasSize(10);
assertThat(result.getTotal()).isEqualTo(12);
}
}
indexIssues(issues.toArray(new IssueDoc[] {}));
- IssueQuery.Builder query = IssueQuery.builder();
+ IssueQuery.Builder query = IssueQuery.builder(userSessionRule);
SearchResult<IssueDoc> result = index.search(query.build(), new SearchOptions().setLimit(Integer.MAX_VALUE));
assertThat(result.getDocs()).hasSize(SearchOptions.MAX_LIMIT);
}
IssueTesting.newDoc("ISSUE2", file).setStatus(Issue.STATUS_CLOSED),
IssueTesting.newDoc("ISSUE3", file).setStatus(Issue.STATUS_REOPENED));
- IssueQuery.Builder query = IssueQuery.builder().sort(IssueQuery.SORT_BY_STATUS).asc(true);
+ IssueQuery.Builder query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_STATUS).asc(true);
SearchResult<IssueDoc> result = index.search(query.build(), new SearchOptions());
assertThat(result.getDocs().get(0).status()).isEqualTo(Issue.STATUS_CLOSED);
assertThat(result.getDocs().get(1).status()).isEqualTo(Issue.STATUS_OPEN);
assertThat(result.getDocs().get(2).status()).isEqualTo(Issue.STATUS_REOPENED);
- query = IssueQuery.builder().sort(IssueQuery.SORT_BY_STATUS).asc(false);
+ query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_STATUS).asc(false);
result = index.search(query.build(), new SearchOptions());
assertThat(result.getDocs().get(0).status()).isEqualTo(Issue.STATUS_REOPENED);
assertThat(result.getDocs().get(1).status()).isEqualTo(Issue.STATUS_OPEN);
IssueTesting.newDoc("ISSUE4", file).setSeverity(Severity.CRITICAL),
IssueTesting.newDoc("ISSUE5", file).setSeverity(Severity.MAJOR));
- IssueQuery.Builder query = IssueQuery.builder().sort(IssueQuery.SORT_BY_SEVERITY).asc(true);
+ IssueQuery.Builder query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_SEVERITY).asc(true);
SearchResult<IssueDoc> result = index.search(query.build(), new SearchOptions());
assertThat(result.getDocs().get(0).severity()).isEqualTo(Severity.INFO);
assertThat(result.getDocs().get(1).severity()).isEqualTo(Severity.MINOR);
assertThat(result.getDocs().get(3).severity()).isEqualTo(Severity.CRITICAL);
assertThat(result.getDocs().get(4).severity()).isEqualTo(Severity.BLOCKER);
- query = IssueQuery.builder().sort(IssueQuery.SORT_BY_SEVERITY).asc(false);
+ query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_SEVERITY).asc(false);
result = index.search(query.build(), new SearchOptions());
assertThat(result.getDocs().get(0).severity()).isEqualTo(Severity.BLOCKER);
assertThat(result.getDocs().get(1).severity()).isEqualTo(Severity.CRITICAL);
IssueTesting.newDoc("ISSUE1", file).setAssignee("steph"),
IssueTesting.newDoc("ISSUE2", file).setAssignee("simon"));
- IssueQuery.Builder query = IssueQuery.builder().sort(IssueQuery.SORT_BY_ASSIGNEE).asc(true);
+ IssueQuery.Builder query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_ASSIGNEE).asc(true);
SearchResult<IssueDoc> result = index.search(query.build(), new SearchOptions());
assertThat(result.getDocs()).hasSize(2);
assertThat(result.getDocs().get(0).assignee()).isEqualTo("simon");
assertThat(result.getDocs().get(1).assignee()).isEqualTo("steph");
- query = IssueQuery.builder().sort(IssueQuery.SORT_BY_ASSIGNEE).asc(false);
+ query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_ASSIGNEE).asc(false);
result = index.search(query.build(), new SearchOptions());
assertThat(result.getDocs()).hasSize(2);
assertThat(result.getDocs().get(0).assignee()).isEqualTo("steph");
IssueTesting.newDoc("ISSUE1", file).setFuncCreationDate(DateUtils.parseDateTime("2014-09-23T00:00:00+0100")),
IssueTesting.newDoc("ISSUE2", file).setFuncCreationDate(DateUtils.parseDateTime("2014-09-24T00:00:00+0100")));
- IssueQuery.Builder query = IssueQuery.builder().sort(IssueQuery.SORT_BY_CREATION_DATE).asc(true);
+ IssueQuery.Builder query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_CREATION_DATE).asc(true);
SearchResult<IssueDoc> result = index.search(query.build(), new SearchOptions());
assertThat(result.getDocs()).hasSize(2);
assertThat(result.getDocs().get(0).creationDate()).isEqualTo(DateUtils.parseDateTime("2014-09-23T00:00:00+0100"));
assertThat(result.getDocs().get(1).creationDate()).isEqualTo(DateUtils.parseDateTime("2014-09-24T00:00:00+0100"));
- query = IssueQuery.builder().sort(IssueQuery.SORT_BY_CREATION_DATE).asc(false);
+ query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_CREATION_DATE).asc(false);
result = index.search(query.build(), new SearchOptions());
assertThat(result.getDocs()).hasSize(2);
assertThat(result.getDocs().get(0).creationDate()).isEqualTo(DateUtils.parseDateTime("2014-09-24T00:00:00+0100"));
IssueTesting.newDoc("ISSUE1", file).setFuncUpdateDate(DateUtils.parseDateTime("2014-09-23T00:00:00+0100")),
IssueTesting.newDoc("ISSUE2", file).setFuncUpdateDate(DateUtils.parseDateTime("2014-09-24T00:00:00+0100")));
- IssueQuery.Builder query = IssueQuery.builder().sort(IssueQuery.SORT_BY_UPDATE_DATE).asc(true);
+ IssueQuery.Builder query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_UPDATE_DATE).asc(true);
SearchResult<IssueDoc> result = index.search(query.build(), new SearchOptions());
assertThat(result.getDocs()).hasSize(2);
assertThat(result.getDocs().get(0).updateDate()).isEqualTo(DateUtils.parseDateTime("2014-09-23T00:00:00+0100"));
assertThat(result.getDocs().get(1).updateDate()).isEqualTo(DateUtils.parseDateTime("2014-09-24T00:00:00+0100"));
- query = IssueQuery.builder().sort(IssueQuery.SORT_BY_UPDATE_DATE).asc(false);
+ query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_UPDATE_DATE).asc(false);
result = index.search(query.build(), new SearchOptions());
assertThat(result.getDocs()).hasSize(2);
assertThat(result.getDocs().get(0).updateDate()).isEqualTo(DateUtils.parseDateTime("2014-09-24T00:00:00+0100"));
IssueTesting.newDoc("ISSUE2", file).setFuncCloseDate(DateUtils.parseDateTime("2014-09-24T00:00:00+0100")),
IssueTesting.newDoc("ISSUE3", file).setFuncCloseDate(null));
- IssueQuery.Builder query = IssueQuery.builder().sort(IssueQuery.SORT_BY_CLOSE_DATE).asc(true);
+ IssueQuery.Builder query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_CLOSE_DATE).asc(true);
SearchResult<IssueDoc> result = index.search(query.build(), new SearchOptions());
assertThat(result.getDocs()).hasSize(3);
assertThat(result.getDocs().get(0).closeDate()).isNull();
assertThat(result.getDocs().get(1).closeDate()).isEqualTo(DateUtils.parseDateTime("2014-09-23T00:00:00+0100"));
assertThat(result.getDocs().get(2).closeDate()).isEqualTo(DateUtils.parseDateTime("2014-09-24T00:00:00+0100"));
- query = IssueQuery.builder().sort(IssueQuery.SORT_BY_CLOSE_DATE).asc(false);
+ query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_CLOSE_DATE).asc(false);
result = index.search(query.build(), new SearchOptions());
assertThat(result.getDocs()).hasSize(3);
assertThat(result.getDocs().get(0).closeDate()).isEqualTo(DateUtils.parseDateTime("2014-09-24T00:00:00+0100"));
IssueTesting.newDoc("F2_3", file2).setLine(109));
// ascending sort -> F1 then F2. Line "0" first.
- IssueQuery.Builder query = IssueQuery.builder().sort(IssueQuery.SORT_BY_FILE_LINE).asc(true);
+ IssueQuery.Builder query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_FILE_LINE).asc(true);
SearchResult<IssueDoc> result = index.search(query.build(), new SearchOptions());
assertThat(result.getDocs()).hasSize(6);
assertThat(result.getDocs().get(0).key()).isEqualTo("F1_1");
assertThat(result.getDocs().get(5).key()).isEqualTo("F2_3");
// descending sort -> F2 then F1
- query = IssueQuery.builder().sort(IssueQuery.SORT_BY_FILE_LINE).asc(false);
+ query = IssueQuery.builder(userSessionRule).sort(IssueQuery.SORT_BY_FILE_LINE).asc(false);
result = index.search(query.build(), new SearchOptions());
assertThat(result.getDocs()).hasSize(6);
assertThat(result.getDocs().get(0).key()).isEqualTo("F2_3");
// project3 can be seen by nobody
indexIssue(IssueTesting.newDoc("ISSUE3", file3), null, null);
- MockUserSession.set().setUserGroups("sonar-users");
- assertThat(index.search(IssueQuery.builder().build(), new SearchOptions()).getDocs()).hasSize(1);
+ userSessionRule.logon().setUserGroups("sonar-users");
+ assertThat(index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions()).getDocs()).hasSize(1);
- MockUserSession.set().setUserGroups("sonar-admins");
- assertThat(index.search(IssueQuery.builder().build(), new SearchOptions()).getDocs()).hasSize(1);
+ userSessionRule.logon().setUserGroups("sonar-admins");
+ assertThat(index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions()).getDocs()).hasSize(1);
- MockUserSession.set().setUserGroups("sonar-users", "sonar-admins");
- assertThat(index.search(IssueQuery.builder().build(), new SearchOptions()).getDocs()).hasSize(2);
+ userSessionRule.logon().setUserGroups("sonar-users", "sonar-admins");
+ assertThat(index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions()).getDocs()).hasSize(2);
- MockUserSession.set().setUserGroups("another group");
- assertThat(index.search(IssueQuery.builder().build(), new SearchOptions()).getDocs()).isEmpty();
+ userSessionRule.logon().setUserGroups("another group");
+ assertThat(index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions()).getDocs()).isEmpty();
- MockUserSession.set().setUserGroups("sonar-users", "sonar-admins");
- assertThat(index.search(IssueQuery.builder().projectUuids(newArrayList(project3.uuid())).build(), new SearchOptions()).getDocs()).isEmpty();
+ userSessionRule.logon().setUserGroups("sonar-users", "sonar-admins");
+ assertThat(index.search(IssueQuery.builder(userSessionRule).projectUuids(newArrayList(project3.uuid())).build(), new SearchOptions()).getDocs()).isEmpty();
}
@Test
indexIssue(IssueTesting.newDoc("ISSUE2", file2), null, "max");
indexIssue(IssueTesting.newDoc("ISSUE3", file3), null, null);
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
- assertThat(index.search(IssueQuery.builder().build(), new SearchOptions()).getDocs()).hasSize(1);
+ assertThat(index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions()).getDocs()).hasSize(1);
- MockUserSession.set().setLogin("max");
- assertThat(index.search(IssueQuery.builder().build(), new SearchOptions()).getDocs()).hasSize(1);
+ userSessionRule.logon("max");
+ assertThat(index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions()).getDocs()).hasSize(1);
- MockUserSession.set().setLogin("another guy");
- assertThat(index.search(IssueQuery.builder().build(), new SearchOptions()).getDocs()).hasSize(0);
+ userSessionRule.logon("another guy");
+ assertThat(index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions()).getDocs()).hasSize(0);
- MockUserSession.set().setLogin("john");
- assertThat(index.search(IssueQuery.builder().projectUuids(newArrayList(project3.key())).build(), new SearchOptions()).getDocs()).hasSize(0);
+ userSessionRule.logon("john");
+ assertThat(index.search(IssueQuery.builder(userSessionRule).projectUuids(newArrayList(project3.key())).build(), new SearchOptions()).getDocs()).hasSize(0);
}
@Test
indexIssue(IssueTesting.newDoc("ISSUE1", file1), "sonar-users", "john");
indexIssue(IssueTesting.newDoc("ISSUE2", file2), null, "max");
- MockUserSession.set().setLogin("john").setUserGroups("sonar-users");
- assertThat(index.search(IssueQuery.builder().build(), new SearchOptions()).getDocs()).hasSize(1);
+ userSessionRule.logon("john").setUserGroups("sonar-users");
+ assertThat(index.search(IssueQuery.builder(userSessionRule).build(), new SearchOptions()).getDocs()).hasSize(1);
}
@Test
index.deleteClosedIssuesOfProjectBefore(project.uuid(), yesterday);
// ASSERT
- List<IssueDoc> issues = index.search(IssueQuery.builder().projectUuids(newArrayList(project.uuid())).build(), new SearchOptions()).getDocs();
+ List<IssueDoc> issues = index.search(IssueQuery.builder(userSessionRule).projectUuids(newArrayList(project.uuid())).build(), new SearchOptions()).getDocs();
List<Date> dates = newArrayList();
for (IssueDoc issue : issues) {
dates.add(issue.closeDate());
// project3 can be seen by nobody
indexIssue(IssueTesting.newDoc("ISSUE3", file2), null, null);
- MockUserSession.set().setUserGroups("sonar-users");
+ userSessionRule.setUserGroups("sonar-users");
assertThat(Lists.newArrayList(index.selectIssuesForBatch(project1))).hasSize(1);
- MockUserSession.set().setUserGroups("another group");
+ userSessionRule.setUserGroups("another group");
assertThat(Lists.newArrayList(index.selectIssuesForBatch(project2))).isEmpty();
}
package org.sonar.server.issue.ws;
+import java.io.StringWriter;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.sonar.core.issue.workflow.Transition;
import org.sonar.server.issue.ActionService;
import org.sonar.server.issue.IssueService;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.test.JsonAssert;
-import java.io.StringWriter;
-
import static com.google.common.collect.Lists.newArrayList;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
@RunWith(MockitoJUnitRunner.class)
public class IssueActionsWriterTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Mock
IssueService issueService;
@Before
public void setUp() {
- writer = new IssueActionsWriter(issueService, actionService);
+ writer = new IssueActionsWriter(issueService, actionService, userSessionRule);
}
@Test
.setProjectKey("sample")
.setRuleKey(RuleKey.of("squid", "AvoidCycle"));
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.ISSUE_ADMIN, "ABCD");
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.ISSUE_ADMIN, "ABCD");
testActions(issue,
"{\"actions\": " +
.setProjectKey("sample")
.setRuleKey(RuleKey.of("squid", "AvoidCycle"));
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
Action action = mock(Action.class);
when(action.key()).thenReturn("link-to-jira");
when(actionService.listAvailableActions(eq(issue))).thenReturn(newArrayList(action));
.setRuleKey(RuleKey.of("squid", "AvoidCycle"))
.setResolution("CLOSED");
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
testActions(issue,
"{\"actions\": " +
.setProjectKey("sample")
.setRuleKey(RuleKey.of("squid", "AvoidCycle"));
- MockUserSession.set();
-
testActions(issue,
"{\"actions\": []}");
}
.setRuleKey(RuleKey.of("squid", "AvoidCycle"))
.setAssignee("john");
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
testActions(issue,
"{\"actions\": " +
.setRuleKey(RuleKey.of("squid", "AvoidCycle"));
when(issueService.listTransitions(eq(issue))).thenReturn(newArrayList(Transition.create("reopen", "RESOLVED", "REOPEN")));
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
testTransitions(issue,
"{\"transitions\": [\n" +
.setProjectKey("sample")
.setRuleKey(RuleKey.of("squid", "AvoidCycle"));
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
testTransitions(issue,
"{\"transitions\": []}");
package org.sonar.server.issue.ws;
import com.google.common.collect.Lists;
+import java.util.Date;
+import java.util.List;
+import java.util.Locale;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.sonar.server.rule.Rule;
import org.sonar.server.rule.RuleService;
import org.sonar.server.source.SourceService;
-import org.sonar.server.user.MockUserSession;
-import org.sonar.server.user.UserSession;
+import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.user.ThreadLocalUserSession;
import org.sonar.server.ws.WsTester;
-import java.util.Date;
-import java.util.List;
-import java.util.Locale;
-
import static com.google.common.collect.Lists.newArrayList;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
@RunWith(MockitoJUnitRunner.class)
public class IssueShowActionTest {
+ @org.junit.Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
+
@Mock
DbClient dbClient;
when(i18n.message(any(Locale.class), eq("created"), eq((String) null))).thenReturn("Created");
tester = new WsTester(new IssuesWs(
- new IssueShowAction(dbClient, issueService, issueChangelogService, commentService,
- new IssueActionsWriter(issueService, actionService), actionPlanService, userFinder, debtModel, ruleService, i18n, durations)
+ new IssueShowAction(
+ dbClient, issueService, issueChangelogService, commentService,
+ new IssueActionsWriter(issueService, actionService, userSessionRule),
+ actionPlanService, userFinder, debtModel, ruleService, i18n, durations, userSessionRule)
));
}
.setCreationDate(issueCreationDate);
when(issueService.getByKey(issueKey)).thenReturn(issue);
- MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issueKey);
request.execute().assertJson(getClass(), "show_issue.json");
}
.setCreationDate(issueCreationDate);
when(issueService.getByKey(issueKey)).thenReturn(issue);
- MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issueKey);
request.execute().assertJson(getClass(), "show_issue_with_sub_project.json");
}
.setCreationDate(issueCreationDate);
when(issueService.getByKey(issueKey)).thenReturn(issue);
- MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issueKey);
request.execute().assertJson(getClass(), "show_issue_with_sub_project.json");
}
.setProjectUuid(project.uuid());
when(issueService.getByKey(issueKey)).thenReturn(issue);
- MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issueKey);
request.execute().assertJson(getClass(), "show_issue_on_removed_component.json");
}
.setActionPlanKey("AP-ABCD");
when(issueService.getByKey(issue.key())).thenReturn(issue);
- when(actionPlanService.findByKey(eq(issue.actionPlanKey()), any(UserSession.class))).thenReturn(new DefaultActionPlan().setKey("AP-ABCD").setName("Version 4.2"));
+ when(actionPlanService.findByKey(eq(issue.actionPlanKey()), any(ThreadLocalUserSession.class))).thenReturn(new DefaultActionPlan().setKey("AP-ABCD").setName("Version 4.2"));
- MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issue.key());
request.execute().assertJson(getClass(), "show_issue_with_action_plan.json");
}
when(userFinder.findByLogin("john")).thenReturn(new DefaultUser().setLogin("john").setName("John"));
when(userFinder.findByLogin("steven")).thenReturn(new DefaultUser().setLogin("steven").setName("Steven"));
- MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issue.key());
request.execute().assertJson(getClass(), "show_issue_with_users.json");
}
when(durations.encode(debt)).thenReturn("2h1min");
- MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issue.key());
request.execute().assertJson(getClass(), "show_issue_with_technical_debt.json");
}
when(debtModel.characteristicById(2)).thenReturn(new DefaultDebtCharacteristic().setKey("K2").setId(2).setName("Readability").setParentId(1));
when(debtModel.characteristicByKey("K2")).thenReturn(new DefaultDebtCharacteristic().setKey("K2").setId(2).setName("Readability").setParentId(1));
- MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issue.key());
request.execute().assertJson(getClass(), "show_issue_with_characteristics.json");
}
when(debtModel.characteristicById(2)).thenReturn(new DefaultDebtCharacteristic().setKey("K2").setId(2).setName("Readability").setParentId(1));
when(debtModel.characteristicByKey("K2")).thenReturn(new DefaultDebtCharacteristic().setKey("K2").setId(2).setName("Readability").setParentId(1));
- MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issue.key());
request.execute().assertJson(getClass(), "show_issue_with_characteristics.json");
}
when(i18n.ageFromNow(any(Locale.class), eq(updateDate))).thenReturn("9 days");
when(i18n.formatDateTime(any(Locale.class), eq(closedDate))).thenReturn("Jan 24, 2014 10:03 AM");
- MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issue.key());
request.execute().assertJson(getClass(), "show_issue_with_dates.json");
}
when(i18n.ageFromNow(any(Locale.class), eq(date1))).thenReturn("9 days");
when(i18n.ageFromNow(any(Locale.class), eq(date2))).thenReturn("10 days");
- MockUserSession.set().setLogin("arthur");
+ userSessionRule.logon("arthur");
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issue.key());
request.execute().assertJson(getClass(), "show_issue_with_comments.json");
}
when(issueService.listTransitions(eq(issue))).thenReturn(newArrayList(Transition.create("reopen", "RESOLVED", "REOPEN")));
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issue.key());
request.execute().assertJson(getClass(), "show_issue_with_transitions.json");
}
.setStatus("OPEN");
when(issueService.getByKey(issue.key())).thenReturn(issue);
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issue.key());
request.execute().assertJson(getClass(), "show_issue_with_actions.json");
}
when(i18n.formatDateTime(any(Locale.class), eq(date1))).thenReturn("Fev 22, 2014 10:03 AM");
when(i18n.formatDateTime(any(Locale.class), eq(date2))).thenReturn("Fev 23, 2014 10:03 AM");
- MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issue.key());
request.execute().assertJson(getClass(), "show_issue_with_changelog.json");
}
package org.sonar.server.issue.ws;
+import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.resources.Qualifiers;
import org.sonar.api.rule.RuleStatus;
import org.sonar.server.rule.RuleTesting;
import org.sonar.server.rule.db.RuleDao;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.view.index.ViewDoc;
import org.sonar.server.view.index.ViewIndexer;
import org.sonar.server.ws.WsTester;
import org.sonar.server.ws.WsTester.Result;
-import java.util.List;
-
import static com.google.common.collect.Lists.newArrayList;
public class SearchActionComponentsMediumTest {
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession session;
session.commit();
tester.get(IssueIndexer.class).indexAll();
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
WsTester.Result result = wsTester.newGetRequest(IssuesWs.API_ENDPOINT, SearchAction.SEARCH_ACTION)
.setParam("resolved", "false")
.setParam(WebService.Param.FACETS, "directories")
indexView(view.uuid(), newArrayList(project.uuid()));
setAnyoneProjectPermission(view, UserRole.USER);
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.USER, view.uuid());
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.USER, view.uuid());
wsTester.newGetRequest(IssuesWs.API_ENDPOINT, SearchAction.SEARCH_ACTION)
.setParam(IssueFilterParameters.COMPONENT_UUIDS, view.uuid())
setAnyoneProjectPermission(view, UserRole.USER);
// User has wrong permission on the view, no issue will be returned
- MockUserSession.set().setLogin("john").addProjectUuidPermissions(UserRole.CODEVIEWER, view.uuid());
+ userSessionRule.logon("john").addProjectUuidPermissions(UserRole.CODEVIEWER, view.uuid());
wsTester.newGetRequest(IssuesWs.API_ENDPOINT, SearchAction.SEARCH_ACTION)
.setParam(IssueFilterParameters.COMPONENT_UUIDS, view.uuid())
indexView(subView.uuid(), newArrayList(project.uuid()));
setAnyoneProjectPermission(view, UserRole.USER);
- MockUserSession.set().setLogin("john").addComponentUuidPermission(UserRole.USER, view.uuid(), subView.uuid());
+ userSessionRule.logon("john").addComponentUuidPermission(UserRole.USER, view.uuid(), subView.uuid());
wsTester.newGetRequest(IssuesWs.API_ENDPOINT, SearchAction.SEARCH_ACTION)
.setParam(IssueFilterParameters.COMPONENT_UUIDS, subView.uuid())
setAnyoneProjectPermission(view, UserRole.USER);
// User has wrong permission on the view, no issue will be returned
- MockUserSession.set().setLogin("john").addComponentUuidPermission(UserRole.CODEVIEWER, view.uuid(), subView.uuid());
+ userSessionRule.logon("john").addComponentUuidPermission(UserRole.CODEVIEWER, view.uuid(), subView.uuid());
wsTester.newGetRequest(IssuesWs.API_ENDPOINT, SearchAction.SEARCH_ACTION)
.setParam(IssueFilterParameters.COMPONENT_UUIDS, subView.uuid())
}
private void setAnyoneProjectPermission(ComponentDto project, String permission) {
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
tester.get(InternalPermissionService.class).addPermission(new PermissionChange().setComponentKey(project.getKey()).setGroup(DefaultGroups.ANYONE).setPermission(permission));
- MockUserSession.set();
}
private IssueDto insertIssue(IssueDto issue) {
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.rule.RuleStatus;
import org.sonar.api.security.DefaultGroups;
import org.sonar.api.utils.KeyValueFormat;
import org.sonar.api.web.UserRole;
import org.sonar.core.component.ComponentDto;
-import org.sonar.core.issue.db.*;
+import org.sonar.core.issue.db.ActionPlanDao;
+import org.sonar.core.issue.db.ActionPlanDto;
+import org.sonar.core.issue.db.IssueChangeDao;
+import org.sonar.core.issue.db.IssueChangeDto;
+import org.sonar.core.issue.db.IssueDto;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.rule.RuleDto;
import org.sonar.server.rule.db.RuleDao;
import org.sonar.server.search.QueryContext;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession session;
session.commit();
tester.get(IssueIndexer.class).indexAll();
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
WsTester.Result result = wsTester.newGetRequest(IssuesWs.API_ENDPOINT, SearchAction.SEARCH_ACTION).execute();
result.assertJson(this.getClass(), "issue_with_comment.json");
}
session.commit();
tester.get(IssueIndexer.class).indexAll();
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
WsTester.Result result = wsTester.newGetRequest(IssuesWs.API_ENDPOINT, SearchAction.SEARCH_ACTION).setParam(IssueFilterParameters.HIDE_COMMENTS, "true").execute();
result.assertJson(this.getClass(), "issue_with_comment_hidden.json");
assertThat(result.outputAsString()).doesNotContain("fabrice");
session.commit();
tester.get(IssueIndexer.class).indexAll();
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
WsTester.Result result = wsTester.newGetRequest(IssuesWs.API_ENDPOINT, SearchAction.SEARCH_ACTION)
.setParam("extra_fields", "actions,transitions,assigneeName,reporterName,actionPlanName").execute();
result.assertJson(this.getClass(), "issue_with_extra_fields.json");
session.commit();
tester.get(IssueIndexer.class).indexAll();
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
WsTester.Result result = wsTester.newGetRequest(IssuesWs.API_ENDPOINT, SearchAction.SEARCH_ACTION)
.setParam("resolved", "false")
.setParam(WebService.Param.FACETS, "statuses,severities,resolutions,projectUuids,rules,fileUuids,assignees,languages,actionPlans")
session.commit();
tester.get(IssueIndexer.class).indexAll();
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
WsTester.Result result = wsTester.newGetRequest(IssuesWs.API_ENDPOINT, SearchAction.SEARCH_ACTION)
.setParam("resolved", "false")
.setParam("severities", "MAJOR,MINOR")
session.commit();
tester.get(IssueIndexer.class).indexAll();
- MockUserSession.set().setLogin("john");
+ userSessionRule.logon("john");
wsTester.newGetRequest(IssuesWs.API_ENDPOINT, SearchAction.SEARCH_ACTION)
.setParam("resolved", "false")
.setParam("assignees", "__me__")
@Test
public void filter_by_assigned_to_me_unauthenticated() throws Exception {
- MockUserSession.set();
+ userSessionRule.logon();
ComponentDto project = insertComponent(ComponentTesting.newProjectDto("ABCD").setKey("MyProject"));
setDefaultProjectPermission(project);
session.commit();
tester.get(IssueIndexer.class).indexAll();
- MockUserSession.set().setLogin("john-bob.polop");
+ userSessionRule.logon("john-bob.polop");
wsTester.newGetRequest(IssuesWs.API_ENDPOINT, SearchAction.SEARCH_ACTION)
.setParam("resolved", "false")
.setParam("assignees", "alice")
private void setDefaultProjectPermission(ComponentDto project) {
// project can be seen by anyone and by code viewer
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
tester.get(InternalPermissionService.class).addPermission(new PermissionChange().setComponentKey(project.getKey()).setGroup(DefaultGroups.ANYONE).setPermission(UserRole.USER));
- MockUserSession.set();
+ userSessionRule.logon();
}
private ComponentDto insertComponent(ComponentDto component) {
package org.sonar.server.permission;
import com.google.common.collect.Maps;
+import java.util.Collection;
+import java.util.Map;
+import javax.annotation.Nullable;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.search.SearchHit;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.web.UserRole;
import org.sonar.core.component.ComponentDto;
import org.sonar.server.es.EsClient;
import org.sonar.server.issue.index.IssueIndexDefinition;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
-
-import javax.annotation.Nullable;
-
-import java.util.Collection;
-import java.util.Map;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession session;
@Test
public void add_project_permission_to_user() {
// init
- MockUserSession.set().setLogin("admin").addProjectPermissions(UserRole.ADMIN, project.key());
+ userSessionRule.logon("admin").addProjectPermissions(UserRole.ADMIN, project.key());
UserDto user = new UserDto().setLogin("john").setName("John");
db.userDao().insert(session, user);
session.commit();
@Test
public void remove_project_permission_to_user() {
- MockUserSession.set().setLogin("admin").addProjectPermissions(UserRole.ADMIN, project.key());
+ userSessionRule.logon("admin").addProjectPermissions(UserRole.ADMIN, project.key());
UserDto user1 = new UserDto().setLogin("user1").setName("User1");
db.userDao().insert(session, user1);
@Test
public void remove_all_component_user_permissions() {
- MockUserSession.set().setLogin("admin").addProjectPermissions(UserRole.ADMIN, project.key());
+ userSessionRule.logon("admin").addProjectPermissions(UserRole.ADMIN, project.key());
UserDto user = new UserDto().setLogin("user1").setName("User1");
db.userDao().insert(session, user);
@Test
public void add_and_remove_permission_to_group() {
// init
- MockUserSession.set().setLogin("admin").addProjectPermissions(UserRole.ADMIN, project.key());
+ userSessionRule.logon("admin").addProjectPermissions(UserRole.ADMIN, project.key());
GroupDto group = new GroupDto().setName("group1");
db.groupDao().insert(session, group);
session.commit();
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
+import java.util.List;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import org.sonar.api.web.UserRole;
-import org.sonar.core.permission.*;
+import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.permission.PermissionQuery;
+import org.sonar.core.permission.PermissionTemplateDao;
+import org.sonar.core.permission.PermissionTemplateDto;
+import org.sonar.core.permission.PermissionTemplateGroupDto;
+import org.sonar.core.permission.PermissionTemplateUserDto;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import org.sonar.core.properties.PropertiesDao;
import org.sonar.core.user.UserDao;
import org.sonar.core.user.UserDto;
import org.sonar.server.exceptions.BadRequestException;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.List;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class InternalPermissionTemplateServiceTest {
private static final PermissionTemplateDto DEFAULT_TEMPLATE =
new PermissionTemplateDto().setId(1L).setName(DEFAULT_KEY).setDescription(DEFAULT_DESC).setKeyPattern(DEFAULT_PATTERN);
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
+
@Mock
PermissionTemplateDao permissionTemplateDao;
@Before
public void setUp() {
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
MyBatis myBatis = mock(MyBatis.class);
when(myBatis.openSession(false)).thenReturn(session);
- service = new InternalPermissionTemplateService(myBatis, permissionTemplateDao, userDao, finder);
+ service = new InternalPermissionTemplateService(myBatis, permissionTemplateDao, userDao, finder, userSessionRule);
}
@Test
@Test
public void should_retrieve_all_permission_templates_from_project() {
- MockUserSession.set().setLogin("admin").addProjectPermissions(UserRole.ADMIN, "org.sample.Sample");
+ userSessionRule.logon("admin").addProjectPermissions(UserRole.ADMIN, "org.sample.Sample");
PermissionTemplateDto template1 =
new PermissionTemplateDto().setId(1L).setName("template1").setDescription("template1");
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.UnauthorizedException;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
-import static org.mockito.Mockito.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.stub;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
public class PermissionTemplateUpdaterTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
private static final UserDto DEFAULT_USER = new UserDto().setId(1L).setLogin("user").setName("user");
private static final GroupDto DEFAULT_GROUP = new GroupDto().setId(1L).setName("group");
@Before
public void setUpCommonMocks() {
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
userDao = mock(UserDao.class);
stub(userDao.selectActiveUserByLogin("user")).toReturn(DEFAULT_USER);
stub(userDao.selectGroupByName("group")).toReturn(DEFAULT_GROUP);
when(permissionTemplateDao.selectTemplateByKey("my_template")).thenReturn(new PermissionTemplateDto().setId(1L));
PermissionTemplateUpdater updater =
- new PermissionTemplateUpdater("my_template", UserRole.USER, "user", permissionTemplateDao, userDao) {
+ new PermissionTemplateUpdater("my_template", UserRole.USER, "user", permissionTemplateDao, userDao, userSessionRule) {
@Override
void doExecute(Long templateId, String permission) {
permissionTemplateDao.addUserPermission(1L, 1L, UserRole.USER);
when(permissionTemplateDao.selectTemplateByKey("my_template")).thenReturn(null);
PermissionTemplateUpdater updater =
- new PermissionTemplateUpdater("my_template", UserRole.USER, "user", permissionTemplateDao, userDao) {
+ new PermissionTemplateUpdater("my_template", UserRole.USER, "user", permissionTemplateDao, userDao, userSessionRule) {
@Override
void doExecute(Long templateId, String permission) {
}
when(permissionTemplateDao.selectTemplateByKey("my_template")).thenReturn(new PermissionTemplateDto().setId(1L));
PermissionTemplateUpdater updater =
- new PermissionTemplateUpdater("my_template", "invalid", "user", permissionTemplateDao, userDao) {
+ new PermissionTemplateUpdater("my_template", "invalid", "user", permissionTemplateDao, userDao, userSessionRule) {
@Override
void doExecute(Long templateId, String permission) {
}
expected.expect(UnauthorizedException.class);
expected.expectMessage("Authentication is required");
- MockUserSession.set();
+ userSessionRule.anonymous();
- PermissionTemplateUpdater updater = new PermissionTemplateUpdater(null, null, null, null, null) {
+ PermissionTemplateUpdater updater = new PermissionTemplateUpdater(null, null, null, null, null, userSessionRule) {
@Override
void doExecute(Long templateId, String permission) {
}
expected.expect(ForbiddenException.class);
expected.expectMessage("Insufficient privileges");
- MockUserSession.set().setLogin("user").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.logon("user").setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
- PermissionTemplateUpdater updater = new PermissionTemplateUpdater(null, null, null, null, null) {
+ PermissionTemplateUpdater updater = new PermissionTemplateUpdater(null, null, null, null, null, userSessionRule) {
@Override
void doExecute(Long templateId, String permission) {
}
package org.sonar.server.platform.ws;
import com.google.common.collect.ImmutableSet;
+import java.util.Date;
+import java.util.Locale;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.sonar.api.platform.Server;
import org.sonar.api.utils.DateUtils;
import org.sonar.core.i18n.DefaultI18n;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import org.sonar.server.ws.WsTester.Result;
-import java.util.Date;
-import java.util.Locale;
-
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.verifyZeroInteractions;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class L10nWsTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Mock
DefaultI18n i18n;
@Test
public void should_allow_client_to_cache_messages() throws Exception {
Locale locale = Locale.PRC;
- MockUserSession.set().setLocale(locale);
+ userSessionRule.setLocale(locale);
Date now = new Date();
Date aBitLater = new Date(now.getTime() + 1000);
when(server.getStartedAt()).thenReturn(now);
- Result result = new WsTester(new L10nWs(i18n, server)).newGetRequest("api/l10n", "index").setParam("ts", DateUtils.formatDateTime(aBitLater)).execute();
+ Result result = new WsTester(new L10nWs(i18n, server, userSessionRule)).newGetRequest("api/l10n", "index").setParam("ts", DateUtils.formatDateTime(aBitLater)).execute();
verifyZeroInteractions(i18n);
verify(server).getStartedAt();
@Test
public void should_return_all_l10n_messages_using_accept_header_with_cache_expired() throws Exception {
Locale locale = Locale.PRC;
- MockUserSession.set().setLocale(locale);
+ userSessionRule.setLocale(locale);
Date now = new Date();
Date aBitEarlier = new Date(now.getTime() - 1000);
when(i18n.message(locale, key2, key2)).thenReturn(key2);
when(i18n.message(locale, key3, key3)).thenReturn(key3);
- Result result = new WsTester(new L10nWs(i18n, server)).newGetRequest("api/l10n", "index").setParam("ts", DateUtils.formatDateTime(aBitEarlier)).execute();
+ Result result = new WsTester(new L10nWs(i18n, server, userSessionRule)).newGetRequest("api/l10n", "index").setParam("ts", DateUtils.formatDateTime(aBitEarlier)).execute();
verify(i18n).getPropertyKeys();
verify(i18n).message(locale, key1, key1);
verify(i18n).message(locale, key2, key2);
@Test
public void should_override_locale_when_locale_param_is_set() throws Exception {
Locale locale = Locale.PRC;
- MockUserSession.set().setLocale(locale);
+ userSessionRule.setLocale(locale);
Locale override = Locale.JAPANESE;
String key1 = "key1";
when(i18n.message(override, key2, key2)).thenReturn(key2);
when(i18n.message(override, key3, key3)).thenReturn(key3);
- Result result = new WsTester(new L10nWs(i18n, server)).newGetRequest("api/l10n", "index").setParam("locale", override.toString()).execute();
+ Result result = new WsTester(new L10nWs(i18n, server, userSessionRule)).newGetRequest("api/l10n", "index").setParam("locale", override.toString()).execute();
verify(i18n).getPropertyKeys();
verify(i18n).message(override, key1, key1);
verify(i18n).message(override, key2, key2);
package org.sonar.server.platform.ws;
+import java.util.LinkedHashMap;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.server.ws.Request;
import org.sonar.api.server.ws.Response;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.platform.monitoring.Monitor;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.util.LinkedHashMap;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class SystemInfoWsActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone().logon("login")
+ .setName("name");
Monitor monitor1 = mock(Monitor.class);
Monitor monitor2 = mock(Monitor.class);
- SystemInfoWsAction sut = new SystemInfoWsAction(monitor1, monitor2);
+ SystemInfoWsAction sut = new SystemInfoWsAction(userSessionRule, monitor1, monitor2);
@Test(expected = ForbiddenException.class)
public void should_fail_when_does_not_have_admin_right() {
- MockUserSession.set()
- .setLogin("login")
- .setName("name")
- .setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
sut.handle(mock(Request.class), mock(Response.class));
}
@Test
public void write_json() {
- MockUserSession.set()
- .setLogin("login")
- .setName("name")
- .setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
LinkedHashMap<String, Object> attributes1 = new LinkedHashMap<>();
attributes1.put("foo", "bar");
import org.sonar.api.config.Settings;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.platform.Platform;
+import org.sonar.server.tester.AnonymousMockUserSession;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
@Test
public void define() {
SystemRestartWsAction action1 = new SystemRestartWsAction(mock(Settings.class), mock(Platform.class));
- SystemInfoWsAction action2 = new SystemInfoWsAction();
+ SystemInfoWsAction action2 = new SystemInfoWsAction(new AnonymousMockUserSession());
SystemWs ws = new SystemWs(action1, action2);
WebService.Context context = new WebService.Context();
*/
package org.sonar.server.plugins.ws;
-import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.plugins.PluginDownloader;
import org.sonar.server.plugins.ServerPluginRepository;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
public class CancelAllPluginsWsActionTest {
private static final String DUMMY_CONTROLLER_KEY = "dummy";
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+
private PluginDownloader pluginDownloader = mock(PluginDownloader.class);
private ServerPluginRepository pluginRepository = mock(ServerPluginRepository.class);
- private CancelAllPluginsWsAction underTest = new CancelAllPluginsWsAction(pluginDownloader, pluginRepository);
+ private CancelAllPluginsWsAction underTest = new CancelAllPluginsWsAction(pluginDownloader, pluginRepository, userSessionRule);
private Request request = mock(Request.class);
private WsTester.TestResponse response = new WsTester.TestResponse();
@Rule
public ExpectedException expectedException = ExpectedException.none();
- @Before
- public void setUp() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
- }
-
@Test
public void action_cancel_all_is_defined() {
WsTester wsTester = new WsTester();
expectedException.expectMessage("Insufficient privileges");
// no permission on user
- MockUserSession.set().setGlobalPermissions();
+ userSessionRule.setGlobalPermissions();
underTest.handle(request, response);
}
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.plugins.PluginDownloader;
import org.sonar.server.plugins.UpdateCenterMatrixFactory;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import org.sonar.updatecenter.common.Plugin;
import org.sonar.updatecenter.common.PluginUpdate;
private static final String ACTION_KEY = "install";
private static final String KEY_PARAM = "key";
private static final String PLUGIN_KEY = "pluginKey";
+
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
private UpdateCenterMatrixFactory updateCenterFactory = mock(UpdateCenterMatrixFactory.class);
private UpdateCenter updateCenter = mock(UpdateCenter.class);
private PluginDownloader pluginDownloader = mock(PluginDownloader.class);
- private InstallPluginsWsAction underTest = new InstallPluginsWsAction(updateCenterFactory, pluginDownloader);
+ private InstallPluginsWsAction underTest = new InstallPluginsWsAction(updateCenterFactory, pluginDownloader, userSessionRule);
private WsTester wsTester = new WsTester(new PluginsWs(underTest));
private WsTester.TestRequest invalidRequest = wsTester.newPostRequest(CONTROLLER_KEY, ACTION_KEY);
public void wireMocks() {
when(updateCenterFactory.getUpdateCenter(anyBoolean())).thenReturn(updateCenter);
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
}
@Test
expectedException.expectMessage("Insufficient privileges");
// no permission on user
- MockUserSession.set().setGlobalPermissions();
+ userSessionRule.setGlobalPermissions();
validRequest.execute();
}
*/
package org.sonar.server.plugins.ws;
-import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.plugins.ServerPluginRepository;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
private static final String KEY_PARAM = "key";
private static final String PLUGIN_KEY = "findbugs";
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ @Rule
+ public ExpectedException expectedException = ExpectedException.none();
+
private ServerPluginRepository pluginRepository = mock(ServerPluginRepository.class);
- private UninstallPluginsWsAction underTest = new UninstallPluginsWsAction(pluginRepository);
+ private UninstallPluginsWsAction underTest = new UninstallPluginsWsAction(pluginRepository, userSessionRule);
private WsTester wsTester = new WsTester(new PluginsWs(underTest));
private Request invalidRequest = wsTester.newGetRequest(CONTROLLER_KEY, ACTION_KEY);
private Request validRequest = wsTester.newGetRequest(CONTROLLER_KEY, ACTION_KEY).setParam(KEY_PARAM, PLUGIN_KEY);
private WsTester.TestResponse response = new WsTester.TestResponse();
- @Rule
- public ExpectedException expectedException = ExpectedException.none();
-
- @Before
- public void setUp() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
- }
-
@Test
public void user_must_have_system_admin_permission() throws Exception {
expectedException.expect(ForbiddenException.class);
expectedException.expectMessage("Insufficient privileges");
// no permission on user
- MockUserSession.set().setGlobalPermissions();
+ userSessionRule.setGlobalPermissions();
underTest.handle(validRequest, response);
}
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.plugins.PluginDownloader;
import org.sonar.server.plugins.UpdateCenterMatrixFactory;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import org.sonar.updatecenter.common.Plugin;
import org.sonar.updatecenter.common.PluginUpdate;
private static final String KEY_PARAM = "key";
private static final String PLUGIN_KEY = "pluginKey";
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
+
private UpdateCenterMatrixFactory updateCenterFactory = mock(UpdateCenterMatrixFactory.class);
private UpdateCenter updateCenter = mock(UpdateCenter.class);
private PluginDownloader pluginDownloader = mock(PluginDownloader.class);
- private UpdatePluginsWsAction underTest = new UpdatePluginsWsAction(updateCenterFactory, pluginDownloader);
+ private UpdatePluginsWsAction underTest = new UpdatePluginsWsAction(updateCenterFactory, pluginDownloader, userSessionRule);
private WsTester wsTester = new WsTester(new PluginsWs(underTest));
private Request invalidRequest = wsTester.newGetRequest(CONTROLLER_KEY, ACTION_KEY);
public void setUp() {
when(updateCenterFactory.getUpdateCenter(anyBoolean())).thenReturn(updateCenter);
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
}
@Test
expectedException.expectMessage("Insufficient privileges");
// no permission on user
- MockUserSession.set().setGlobalPermissions();
+ userSessionRule.setGlobalPermissions();
underTest.handle(validRequest, response);
}
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.NotFoundException;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.user.AnonymousUserSession;
+import org.sonar.server.tester.MockUserSession;
import org.sonar.server.user.UserSession;
-import org.sonar.server.user.UserSessionTestUtils;
-
-import java.util.Collection;
-import java.util.Iterator;
-import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyLong;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class QualityGatesTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
+
@Mock
DbSession session;
static final String PROJECT_KEY = "SonarQube";
- UserSession authorizedProfileAdminUserSession = MockUserSession.create().setLogin("gaudol").setName("Olivier").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
- UserSession authorizedProjectAdminUserSession = MockUserSession.create().setLogin("gaudol").setName("Olivier").addProjectPermissions(UserRole.ADMIN, PROJECT_KEY);
- UserSession unauthorizedUserSession = MockUserSession.create().setLogin("polop").setName("Polop");
- UserSession unauthenticatedUserSession = MockUserSession.create();
+ UserSession authorizedProfileAdminUserSession = new MockUserSession("gaudol").setName("Olivier").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ UserSession authorizedProjectAdminUserSession = new MockUserSession("gaudol").setName("Olivier").addProjectPermissions(UserRole.ADMIN, PROJECT_KEY);
+ UserSession unauthorizedUserSession = new MockUserSession("polop").setName("Polop");
+ UserSession unauthenticatedUserSession = AnonymousUserSession.INSTANCE;
@Before
public void initialize() {
when(componentDao.getById(anyLong(), eq(session))).thenReturn(new ComponentDto().setId(1L).setKey(PROJECT_KEY));
when(myBatis.openSession(false)).thenReturn(session);
- qGates = new QualityGates(dao, conditionDao, metricFinder, propertiesDao, componentDao, myBatis);
- UserSessionTestUtils.setUserSession(authorizedProfileAdminUserSession);
+ qGates = new QualityGates(dao, conditionDao, metricFinder, propertiesDao, componentDao, myBatis, userSessionRule);
+ userSessionRule.set(authorizedProfileAdminUserSession);
}
@Test
@Test(expected = ForbiddenException.class)
public void should_fail_create_on_anonymous() {
- UserSessionTestUtils.setUserSession(unauthenticatedUserSession);
+ userSessionRule.set(unauthenticatedUserSession);
assertThat(qGates.currentUserHasWritePermission()).isFalse();
qGates.create("polop");
}
@Test(expected = ForbiddenException.class)
public void should_fail_create_on_missing_permission() {
- UserSessionTestUtils.setUserSession(unauthorizedUserSession);
+ userSessionRule.set(unauthorizedUserSession);
qGates.create("polop");
}
@Test
public void associate_project_with_project_admin_permission() {
- UserSessionTestUtils.setUserSession(authorizedProjectAdminUserSession);
+ userSessionRule.set(authorizedProjectAdminUserSession);
Long qGateId = 42L;
Long projectId = 24L;
@Test
public void dissociate_project_with_project_admin_permission() {
- UserSessionTestUtils.setUserSession(authorizedProjectAdminUserSession);
+ userSessionRule.set(authorizedProjectAdminUserSession);
Long qGateId = 42L;
Long projectId = 24L;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.RuleStatus;
import java.util.Date;
import java.util.List;
import java.util.Map;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
RuleDao dao;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.Severity;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.List;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession dbSession;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.rule.Severity;
import org.sonar.api.server.rule.RuleParamType;
import org.sonar.server.qualityprofile.index.ActiveRuleIndex;
import org.sonar.server.rule.RuleTesting;
import org.sonar.server.tester.ServerTester;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester().addXoo();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession dbSession;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.rule.Severity;
import org.sonar.api.server.rule.RuleParamType;
import java.util.List;
import java.util.Map;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession dbSession;
import java.io.Reader;
import java.io.Writer;
import java.util.List;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
XooRulesDefinition.class, XooProfileDefinition.class,
XooExporter.class, StandardExporter.class,
XooProfileImporter.class, XooProfileImporterWithMessages.class, XooProfileImporterWithError.class);
+ @org.junit.Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession dbSession;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.server.rule.RuleParamType;
import org.sonar.core.component.ComponentDto;
import org.sonar.server.rule.RuleTesting;
import org.sonar.server.search.IndexClient;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.tester.MockUserSession;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession dbSession;
assertThat(factory.getByProjectAndLanguage("org.codehaus.sonar:sonar", "xoo")).isNull();
tester.get(QProfileProjectOperations.class).addProject(profileDto.getKey(), project.uuid(),
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN), dbSession);
+ new MockUserSession("me").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN), dbSession);
dbSession.commit();
dbSession.clearCache();
assertThat(factory.getByProjectAndLanguage("org.codehaus.sonar:sonar", "xoo").getKey()).isEqualTo(XOO_P1_KEY);
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.web.UserRole;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.user.UserDto;
import org.sonar.server.db.DbClient;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.tester.MockUserSession;
import org.sonar.server.user.UserSession;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession dbSession;
static final String PROJECT_KEY = "SonarQube";
static final String PROJECT_UUID = "ABCD";
- UserSession authorizedProfileAdminUserSession = MockUserSession.create().setLogin("john").setName("John").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
- UserSession authorizedProjectAdminUserSession = MockUserSession.create().setLogin("john").setName("John").addProjectPermissions(UserRole.ADMIN, PROJECT_KEY);
+ UserSession authorizedProfileAdminUserSession = new MockUserSession("john").setName("John").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ UserSession authorizedProjectAdminUserSession = new MockUserSession("john").setName("John").addProjectPermissions(UserRole.ADMIN, PROJECT_KEY);
@Before
public void before() {
db.userDao().insert(dbSession, user);
tester.get(PermissionFacade.class).insertUserPermission(project1.getId(), user.getId(), UserRole.USER, dbSession);
tester.get(PermissionFacade.class).insertUserPermission(project2.getId(), user.getId(), UserRole.USER, dbSession);
- UserSession userSession = MockUserSession.set().setUserId(user.getId().intValue()).setLogin("john").setName("John")
+ UserSession userSession = userSessionRule.logon("john").setUserId(user.getId().intValue()).setName("John")
.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
dbSession.commit();
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.profiles.ProfileDefinition;
import org.sonar.api.profiles.RulesProfile;
import org.sonar.server.tester.ServerTester;
import javax.annotation.Nullable;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester().addXoo().addComponents(PROFILE_DEFS, RULE_DEFS);
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession dbSession;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
import com.google.common.collect.Multimap;
+import java.io.IOException;
+import java.io.Reader;
+import java.io.Writer;
+import java.util.List;
+import java.util.Map;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
import org.sonar.server.search.FacetValue;
import org.sonar.server.search.Result;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
-
-import java.io.IOException;
-import java.io.Reader;
-import java.io.Writer;
-import java.util.List;
-import java.util.Map;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.sonar.server.qualityprofile.QProfileTesting.XOO_P1_KEY;
@ClassRule
public static ServerTester tester = new ServerTester().addComponents(XooProfileImporter.class, XooExporter.class);
+ @org.junit.Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession dbSession;
@Test
public void create_profile() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN).setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
QualityProfileDto profile = service.create(QProfileName.createFor("xoo", "New Profile"), null).profile();
@Test
public void create_profile_with_xml() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN).setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
db.ruleDao().insert(dbSession, RuleTesting.newDto(RuleKey.of("xoo", "R1")).setLanguage("xoo").setSeverity("MINOR"));
dbSession.commit();
@Test
public void count_by_all_profiles() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN).setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
service.activate(XOO_P1_KEY, new RuleActivation(RuleTesting.XOO_X1).setSeverity("BLOCKER"));
service.activate(XOO_P2_KEY, new RuleActivation(RuleTesting.XOO_X1).setSeverity("BLOCKER"));
@Test
public void stat_for_all_profiles() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN).setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
service.activate(XOO_P1_KEY, new RuleActivation(RuleTesting.XOO_X1).setSeverity("MINOR"));
service.activate(XOO_P2_KEY, new RuleActivation(RuleTesting.XOO_X1).setSeverity("BLOCKER"));
@Test
public void count_by_deprecated() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN).setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
// create deprecated rule
RuleDto deprecatedXooRule = RuleTesting.newDto(RuleKey.of("xoo", "deprecated1"))
@Test
public void search_qprofile_activity() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN).setLogin("david");
+ userSessionRule.logon("david").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
UserDto user = new UserDto().setLogin("david").setName("David").setEmail("dav@id.com").setCreatedAt(System.currentTimeMillis()).setUpdatedAt(System.currentTimeMillis());
db.userDao().insert(dbSession, user);
@Test
public void search_qprofile_activity_without_severity() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN).setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
RuleKey ruleKey = RuleKey.of("xoo", "deleted_rule");
@Test
public void search_qprofile_activity_with_user_not_found() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN).setLogin("david");
+ userSessionRule.logon("david").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
// We need an actual rule in DB to test RuleName in Activity
db.ruleDao().getByKey(dbSession, RuleTesting.XOO_X1);
@Test
public void search_qprofile_activity_with_rule_not_found() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN).setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
RuleKey ruleKey = RuleKey.of("xoo", "deleted_rule");
@Test
public void set_default() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN).setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
assertThat(service.getDefault("xoo")).isNull();
package org.sonar.server.qualityprofile;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
-import org.sonar.server.user.UserSession;
+import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.user.ThreadLocalUserSession;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
@RunWith(MockitoJUnitRunner.class)
public class QProfilesTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Mock
QProfileProjectOperations projectOperations;
@Before
public void setUp() {
- qProfiles = new QProfiles(projectOperations, projectLookup, profileLookup);
+ qProfiles = new QProfiles(projectOperations, projectLookup, profileLookup, userSessionRule);
}
@Test
@Test
public void add_project() {
qProfiles.addProject("sonar-way-java", "ABCD");
- verify(projectOperations).addProject(eq("sonar-way-java"), eq("ABCD"), any(UserSession.class));
+ verify(projectOperations).addProject(eq("sonar-way-java"), eq("ABCD"), any(ThreadLocalUserSession.class));
}
@Test
public void remove_project_by_quality_profile_key() {
qProfiles.removeProject("sonar-way-java", "ABCD");
- verify(projectOperations).removeProject(eq("sonar-way-java"), eq("ABCD"), any(UserSession.class));
+ verify(projectOperations).removeProject(eq("sonar-way-java"), eq("ABCD"), any(ThreadLocalUserSession.class));
}
@Test
public void remove_project_by_language() {
qProfiles.removeProjectByLanguage("java", 10L);
- verify(projectOperations).removeProject(eq("java"), eq(10L), any(UserSession.class));
+ verify(projectOperations).removeProject(eq("java"), eq(10L), any(ThreadLocalUserSession.class));
}
@Test
public void remove_all_projects() {
qProfiles.removeAllProjects("sonar-way-java");
- verify(projectOperations).removeAllProjects(eq("sonar-way-java"), any(UserSession.class));
+ verify(projectOperations).removeAllProjects(eq("sonar-way-java"), any(ThreadLocalUserSession.class));
}
}
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Lists;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.RuleStatus;
import org.sonar.server.rule.index.RuleQuery;
import org.sonar.server.search.QueryContext;
import org.sonar.server.tester.ServerTester;
-
-import javax.annotation.Nullable;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
-import static org.sonar.server.qualityprofile.QProfileTesting.*;
+import static org.sonar.server.qualityprofile.QProfileTesting.XOO_P1_KEY;
+import static org.sonar.server.qualityprofile.QProfileTesting.XOO_P2_KEY;
+import static org.sonar.server.qualityprofile.QProfileTesting.XOO_P3_KEY;
public class RuleActivatorMediumTest {
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession dbSession;
// 0. No active rules so far (base case) and plenty rules available
verifyZeroActiveRules(XOO_P1_KEY);
assertThat(tester.get(RuleIndex.class)
- .search(new RuleQuery().setRepositories(Arrays.asList("bulk")), new QueryContext()).getTotal())
+ .search(new RuleQuery().setRepositories(Arrays.asList("bulk")), new QueryContext(userSessionRule)).getTotal())
.isEqualTo(bulkSize);
// 1. bulk activate all the rules
*/
package org.sonar.server.qualityprofile.ws;
+import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.RuleStatus;
import org.sonar.server.qualityprofile.QProfileTesting;
import org.sonar.server.qualityprofile.RuleActivator;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.util.List;
-
import static org.assertj.core.api.Assertions.assertThat;
public class QProfileChangeParentActionMediumTest {
// TODO Replace with DbTester + EsTester once DaoV2 is removed
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
QProfilesWs ws;
DbClient db;
ws = tester.get(QProfilesWs.class);
wsTester = tester.get(WsTester.class);
session = db.openSession(false);
- MockUserSession.set().setLogin("gandalf").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("gandalf").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
}
@After
@Test(expected = ForbiddenException.class)
public void fail_if_missing_permission() throws Exception {
- MockUserSession.set().setLogin("anakin");
+ userSessionRule.logon("anakin");
wsTester.newGetRequest(QProfilesWs.API_ENDPOINT, "change_parent")
.setParam(QProfileIdentificationParamUtils.PARAM_PROFILE_KEY, "polop")
.setParam("parentKey", "pulup")
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.RuleStatus;
import org.sonar.server.qualityprofile.QProfileName;
import org.sonar.server.qualityprofile.QProfileTesting;
import org.sonar.server.tester.ServerTester;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
public class QProfileCompareActionMediumTest {
.done();
}
});
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
private DbClient db;
package org.sonar.server.qualityprofile.ws;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.language.LanguageTesting;
import org.sonar.server.qualityprofile.QProfileCopier;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.mockito.Mockito.mock;
@RunWith(MockitoJUnitRunner.class)
public class QProfileCopyActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
+
private WsTester tester;
// TODO Replace with proper DbTester + EsTester medium test during removal of DaoV2
mock(RuleActivationActions.class),
mock(BulkRuleActivationActions.class),
mock(ProjectAssociationActions.class),
- new QProfileCopyAction(qProfileCopier, LanguageTesting.newLanguages("xoo"))));
+ new QProfileCopyAction(qProfileCopier, LanguageTesting.newLanguages("xoo"), userSessionRule)));
}
@Test
public void copy_nominal() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
String fromProfileKey = "xoo-sonar-way-23456";
String toName = "Other Sonar Way";
@Test
public void copy_with_parent() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
String fromProfileKey = "xoo-sonar-way-23456";
String toName = "Other Sonar Way";
@Test(expected = IllegalArgumentException.class)
public void fail_on_missing_key() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "copy")
.setParam("name", "Other Sonar Way")
@Test(expected = IllegalArgumentException.class)
public void fail_on_missing_name() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "copy")
.setParam("key", "sonar-way-xoo1-13245")
@Test(expected = ForbiddenException.class)
public void fail_on_missing_permission() throws Exception {
- MockUserSession.set().setLogin("obiwan");
+ userSessionRule.logon("obiwan");
tester.newPostRequest("api/qualityprofiles", "copy")
.setParam("key", "sonar-way-xoo1-13245")
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.core.persistence.DbSession;
import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.BadRequestException;
-import org.sonar.server.qualityprofile.*;
+import org.sonar.server.qualityprofile.QProfileExporters;
import org.sonar.server.qualityprofile.QProfileExportersTest.StandardExporter;
import org.sonar.server.qualityprofile.QProfileExportersTest.XooExporter;
import org.sonar.server.qualityprofile.QProfileExportersTest.XooProfileDefinition;
import org.sonar.server.qualityprofile.QProfileExportersTest.XooProfileImporterWithError;
import org.sonar.server.qualityprofile.QProfileExportersTest.XooProfileImporterWithMessages;
import org.sonar.server.qualityprofile.QProfileExportersTest.XooRulesDefinition;
+import org.sonar.server.qualityprofile.QProfileLoader;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
public class QProfileCreateActionMediumTest {
XooRulesDefinition.class, XooProfileDefinition.class,
XooExporter.class, StandardExporter.class,
XooProfileImporter.class, XooProfileImporterWithMessages.class, XooProfileImporterWithError.class);
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db;
DbSession dbSession;
@Test
public void create_nominal() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
wsTester.newPostRequest("api/qualityprofiles", "create")
.setParam("backup_XooProfileImporter", "a value for xoo importer")
@Test
public void create_with_messages() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
wsTester.newPostRequest("api/qualityprofiles", "create")
.setParam("backup_XooProfileImporter", "a value for xoo importer")
@Test(expected = BadRequestException.class)
public void fail_on_error_from_importer() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
wsTester.newPostRequest("api/qualityprofiles", "create")
.setParam("backup_XooProfileImporter", "a value for xoo importer")
package org.sonar.server.qualityprofile.ws;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.server.ws.WebService.Action;
import org.sonar.api.utils.System2;
import org.sonar.server.db.DbClient;
import org.sonar.server.language.LanguageTesting;
import org.sonar.server.qualityprofile.QProfileFactory;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static final DbTester db = new DbTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Test
public void should_not_fail_on_no_importers() throws Exception {
String xooKey = "xoo";
WsTester wsTester = new WsTester(new QProfilesWs(
mock(RuleActivationActions.class), mock(BulkRuleActivationActions.class), mock(ProjectAssociationActions.class),
- new QProfileCreateAction(dbClient, new QProfileFactory(dbClient), null, LanguageTesting.newLanguages(xooKey))));
+ new QProfileCreateAction(dbClient, new QProfileFactory(dbClient), null, LanguageTesting.newLanguages(xooKey), userSessionRule)));
Action create = wsTester.controller("api/qualityprofiles").action("create");
assertThat(create.params()).hasSize(2);
- MockUserSession.set().setLogin("anakin").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("anakin").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
wsTester.newPostRequest("api/qualityprofiles", "create")
.setParam("language", xooKey).setParam("name", "Yeehaw!").execute().assertJson(getClass(), "create-no-importer.json");
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.resources.Language;
import org.sonar.api.resources.Languages;
import org.sonar.server.qualityprofile.QProfileFactory;
import org.sonar.server.qualityprofile.db.ActiveRuleDao;
import org.sonar.server.rule.db.RuleDao;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static DbTester dbTester = new DbTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
private DbClient dbClient;
mock(RuleActivationActions.class),
mock(BulkRuleActivationActions.class),
mock(ProjectAssociationActions.class),
- new QProfileDeleteAction(new Languages(xoo1, xoo2), new QProfileFactory(dbClient), dbClient)));
+ new QProfileDeleteAction(new Languages(xoo1, xoo2), new QProfileFactory(dbClient), dbClient, userSessionRule)));
}
@After
qualityProfileDao.insertProjectProfileAssociation(project.uuid(), profileKey, session);
session.commit();
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "delete").setParam("profileKey", "sonar-way-xoo1-12345").execute().assertNoContent();
qualityProfileDao.insertProjectProfileAssociation(project.uuid(), profileKey, session);
session.commit();
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "delete").setParam("profileName", "Sonar way").setParam("language", xoo1.getKey()).execute().assertNoContent();
@Test(expected = ForbiddenException.class)
public void fail_on_missing_permission() throws Exception {
- MockUserSession.set().setLogin("obiwan");
+ userSessionRule.logon("obiwan");
tester.newPostRequest("api/qualityprofiles", "delete").execute();
}
@Test(expected = IllegalArgumentException.class)
public void fail_on_missing_arguments() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "delete").execute();
}
@Test(expected = IllegalArgumentException.class)
public void fail_on_missing_language() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "delete").setParam("profileName", "Polop").execute();
}
@Test(expected = IllegalArgumentException.class)
public void fail_on_missing_name() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "delete").setParam("language", xoo1.getKey()).execute();
}
@Test(expected = IllegalArgumentException.class)
public void fail_on_too_many_arguments() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "delete").setParam("profileName", "Polop").setParam("language", xoo1.getKey()).setParam("profileKey", "polop").execute();
}
@Test(expected = NotFoundException.class)
public void fail_on_unexisting_profile() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "delete").setParam("profileName", "Polop").setParam("language", xoo1.getKey()).execute();
}
}
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.mockito.Matchers;
import org.mockito.invocation.InvocationOnMock;
import org.sonar.server.qualityprofile.*;
import org.sonar.server.qualityprofile.index.ActiveRuleIndex;
import org.sonar.server.search.IndexClient;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import org.sonar.server.ws.WsTester.Result;
@ClassRule
public static final DbTester db = new DbTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
WsTester wsTester;
when(activeRuleIndex.findByProfile(Matchers.anyString())).thenReturn(Sets.<ActiveRule>newHashSet().iterator());
when(indexClient.get(ActiveRuleIndex.class)).thenReturn(activeRuleIndex);
- exporters = new QProfileExporters(new QProfileLoader(dbClient, indexClient), null, null, new ProfileExporter[] {exporter1, exporter2}, null);
+ exporters = new QProfileExporters(new QProfileLoader(dbClient, indexClient, userSessionRule), null, null, new ProfileExporter[] {exporter1, exporter2}, null);
wsTester = new WsTester(new QProfilesWs(mock(RuleActivationActions.class),
mock(BulkRuleActivationActions.class),
mock(ProjectAssociationActions.class),
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.RuleStatus;
import org.sonar.server.qualityprofile.RuleActivation;
import org.sonar.server.qualityprofile.RuleActivator;
import org.sonar.server.tester.ServerTester;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
public class QProfileInheritanceActionMediumTest {
@ClassRule
public static final ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
private WsTester wsTester;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import org.sonar.api.utils.System2;
import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.qualityprofile.QProfileTesting;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.user.db.UserDao;
import org.sonar.server.ws.WsTester;
import org.sonar.server.ws.WsTester.TestRequest;
@ClassRule
public static final DbTester dbTester = new DbTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
private WsTester wsTester;
mock(RuleActivationActions.class),
mock(BulkRuleActivationActions.class),
mock(ProjectAssociationActions.class),
- new QProfileProjectsAction(dbClient)));
+ new QProfileProjectsAction(dbClient, userSessionRule)));
- MockUserSession.set().setLogin("obiwan").setUserId(userId.intValue());
+ userSessionRule.logon("obiwan").setUserId(userId.intValue());
new UserDao(dbTester.myBatis(), mock(System2.class))
.insert(session, new UserDto()
.setActive(true)
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.utils.System2;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.qualityprofile.QProfileFactory;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static DbTester dbTester = new DbTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
private DbClient dbClient;
mock(RuleActivationActions.class),
mock(BulkRuleActivationActions.class),
mock(ProjectAssociationActions.class),
- new QProfileRenameAction(new QProfileFactory(dbClient))));
+ new QProfileRenameAction(new QProfileFactory(dbClient), userSessionRule)));
}
@After
@Test
public void rename_nominal() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "rename")
.setParam("key", "sonar-way-xoo2-23456")
@Test(expected = BadRequestException.class)
public void do_nothing_on_conflict() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "rename")
.setParam("key", "sonar-way-xoo2-23456")
@Test(expected = IllegalArgumentException.class)
public void fail_on_missing_key() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "rename")
.setParam("name", "Other Sonar Way")
@Test(expected = IllegalArgumentException.class)
public void fail_on_missing_name() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "rename")
.setParam("key", "sonar-way-xoo1-13245")
@Test(expected = ForbiddenException.class)
public void fail_on_missing_permission() throws Exception {
- MockUserSession.set().setLogin("obiwan");
+ userSessionRule.logon("obiwan");
tester.newPostRequest("api/qualityprofiles", "rename")
.setParam("key", "sonar-way-xoo1-13245")
@Test(expected = IllegalArgumentException.class)
public void fail_on_unknown_profile() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "rename")
.setParam("key", "polop")
*/
package org.sonar.server.qualityprofile.ws;
+import java.io.Reader;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.sonar.server.qualityprofile.BulkChangeResult;
import org.sonar.server.qualityprofile.QProfileBackuper;
import org.sonar.server.qualityprofile.QProfileName;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.io.Reader;
-
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.eq;
import static org.mockito.Mockito.mock;
@RunWith(MockitoJUnitRunner.class)
public class QProfileRestoreActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
// TODO Replace with proper DbTester + EsTester medium test once DaoV2 is removed
@Mock
mock(RuleActivationActions.class),
mock(BulkRuleActivationActions.class),
mock(ProjectAssociationActions.class),
- new QProfileRestoreAction(backuper, LanguageTesting.newLanguages("xoo"))));
+ new QProfileRestoreAction(backuper, LanguageTesting.newLanguages("xoo"), userSessionRule)));
}
@Test
public void restore_profile() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
QualityProfileDto profile = QualityProfileDto.createFor("xoo-sonar-way-12345")
.setDefault(false).setLanguage("xoo").setName("Sonar way");
@Test(expected = IllegalArgumentException.class)
public void fail_on_missing_backup() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newGetRequest("api/qualityprofiles", "restore").execute();
}
@Test(expected = ForbiddenException.class)
public void fail_on_misssing_permission() throws Exception {
- MockUserSession.set().setLogin("obiwan");
+ userSessionRule.logon("obiwan");
tester.newPostRequest("api/qualityprofiles", "restore").setParam("backup", "<polop><palap/></polop>").execute();
}
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.utils.System2;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.server.language.LanguageTesting;
import org.sonar.server.qualityprofile.QProfileFactory;
import org.sonar.server.qualityprofile.QProfileLookup;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static DbTester dbTester = new DbTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
private DbClient dbClient;
mock(RuleActivationActions.class),
mock(BulkRuleActivationActions.class),
mock(ProjectAssociationActions.class),
- new QProfileSetDefaultAction(LanguageTesting.newLanguages(xoo1Key, xoo2Key), new QProfileLookup(dbClient), new QProfileFactory(dbClient))));
+ new QProfileSetDefaultAction(LanguageTesting.newLanguages(xoo1Key, xoo2Key), new QProfileLookup(dbClient), new QProfileFactory(dbClient), userSessionRule)));
}
@After
@Test
public void set_default_profile_using_key() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
checkDefaultProfile(xoo1Key, "sonar-way-xoo1-12345");
@Test
public void set_default_profile_using_language_and_name() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
tester.newPostRequest("api/qualityprofiles", "set_default").setParam("language", xoo2Key).setParam("profileName", "Sonar way").execute().assertNoContent();
@Test
public void fail_to_set_default_profile_using_key() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
try {
tester.newPostRequest("api/qualityprofiles", "set_default").setParam("profileKey", "unknown-profile-666").execute();
@Test
public void fail_to_set_default_profile_using_language_and_name() throws Exception {
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
try {
tester.newPostRequest("api/qualityprofiles", "set_default").setParam("language", xoo2Key).setParam("profileName", "Unknown").execute();
@Test
public void fail_on_missing_permission() throws Exception {
- MockUserSession.set().setLogin("obiwan");
+ userSessionRule.logon("obiwan");
try {
tester.newPostRequest("api/qualityprofiles", "set_default").setParam("profileKey", "sonar-way-xoo2-23456").execute().assertNoContent();
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.RuleStatus;
import org.sonar.server.search.QueryContext;
import org.sonar.server.search.ws.SearchOptions;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester)
+ .logon("gandalf").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
QProfilesWs ws;
DbClient db;
ws = tester.get(QProfilesWs.class);
wsTester = tester.get(WsTester.class);
session = db.openSession(false);
- MockUserSession.set().setLogin("gandalf").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
-
}
@After
// 2. Assert ActiveRule with BLOCKER severity
assertThat(tester.get(RuleIndex.class).search(
new RuleQuery().setSeverities(ImmutableSet.of("BLOCKER")),
- new QueryContext()).getHits()).hasSize(2);
+ new QueryContext(userSessionRule)).getHits()).hasSize(2);
// 1. Activate Rule with query returning 2 hits
WsTester.TestRequest request = wsTester.newGetRequest(QProfilesWs.API_ENDPOINT, BulkRuleActivationActions.BULK_ACTIVATE_ACTION);
package org.sonar.server.qualityprofile.ws;
+import java.io.Reader;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.i18n.I18n;
import org.sonar.api.profiles.ProfileImporter;
import org.sonar.server.qualityprofile.QProfileExporters;
import org.sonar.server.qualityprofile.QProfileService;
import org.sonar.server.rule.RuleService;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.io.Reader;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
public class QProfilesWsTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
WebService.Controller controller;
controller = new WsTester(new QProfilesWs(
new RuleActivationActions(profileService),
- new BulkRuleActivationActions(profileService, ruleService, i18n),
- new ProjectAssociationActions(null, null, null, languages),
- new QProfileCreateAction(null, null, null, languages, importers),
+ new BulkRuleActivationActions(profileService, ruleService, i18n, userSessionRule),
+ new ProjectAssociationActions(null, null, null, languages, userSessionRule),
+ new QProfileCreateAction(null, null, null, languages, importers, userSessionRule),
new QProfileImportersAction(importers),
new QProfileRestoreBuiltInAction(null),
new QProfileSearchAction(languages, null, null, null),
- new QProfileSetDefaultAction(languages, null, null),
- new QProfileProjectsAction(null),
+ new QProfileSetDefaultAction(languages, null, null, userSessionRule),
+ new QProfileProjectsAction(null, userSessionRule),
new QProfileBackupAction(null, null, null, languages),
- new QProfileRestoreAction(null, languages),
+ new QProfileRestoreAction(null, languages, userSessionRule),
new QProfileChangelogAction(null, null, null, languages),
- new QProfileChangeParentAction(null, null, null, languages),
+ new QProfileChangeParentAction(null, null, null, languages, userSessionRule),
new QProfileCompareAction(null, null, null, languages),
- new QProfileCopyAction(null, languages),
- new QProfileDeleteAction(languages, null, null),
+ new QProfileCopyAction(null, languages, userSessionRule),
+ new QProfileDeleteAction(languages, null, null, userSessionRule),
new QProfileExportAction(null, null, null, mock(QProfileExporters.class), languages),
new QProfileExportersAction(),
new QProfileInheritanceAction(null, null, null, null, languages),
- new QProfileRenameAction(null)
+ new QProfileRenameAction(null, userSessionRule)
)).controller(QProfilesWs.API_ENDPOINT);
}
import org.sonar.server.tester.ServerTester;
import java.util.Collections;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @org.junit.Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
private DbClient dbClient;
private DefaultRuleFinder finder;
package org.sonar.server.rule;
import com.google.common.collect.ImmutableMap;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+import javax.annotation.Nullable;
import org.apache.commons.lang.time.DateUtils;
import org.junit.After;
import org.junit.Before;
import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
-import org.sonar.server.user.UserSession;
-
-import javax.annotation.Nullable;
-
-import java.util.Date;
-import java.util.List;
-import java.util.Map;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Sets.newHashSet;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static final ServerTester TESTER = new ServerTester().addXoo().addComponents(RULE_DEFS);
+ @org.junit.Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(TESTER);
RuleIndex ruleIndex;
ActiveRuleIndex activeRuleIndex;
assertThat(ruleParams).hasSize(2);
// verify es
- Result<Rule> searchResult = ruleIndex.search(new RuleQuery(), new QueryContext());
+ Result<Rule> searchResult = ruleIndex.search(new RuleQuery(), new QueryContext(userSessionRule));
assertThat(searchResult.getTotal()).isEqualTo(1);
assertThat(searchResult.getHits()).hasSize(1);
Rule rule = ruleIndex.getByKey(RuleKey.of("xoo", "x1"));
register(rules);
// verify that rules are indexed
- Result<Rule> searchResult = ruleIndex.search(new RuleQuery(), new QueryContext());
- searchResult = ruleIndex.search(new RuleQuery().setKey("xoo:x1"), new QueryContext());
+ Result<Rule> searchResult = ruleIndex.search(new RuleQuery(), new QueryContext(userSessionRule));
+ searchResult = ruleIndex.search(new RuleQuery().setKey("xoo:x1"), new QueryContext(userSessionRule));
assertThat(searchResult.getTotal()).isEqualTo(1);
assertThat(searchResult.getHits()).hasSize(1);
assertThat(searchResult.getHits().get(0).key()).isEqualTo(RuleKey.of("xoo", "x1"));
});
// Create a profile and activate rule
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN).setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP1());
dbSession.commit();
dbSession.clearCache();
register(rules);
// create a profile and activate rule
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN).setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP1());
dbSession.commit();
dbSession.clearCache();
});
// Create profile and activate rule
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN).setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP1());
dbSession.commit();
dbSession.clearCache();
assertThat(rule.tags()).isEmpty();
// User adds tag
- TESTER.get(RuleUpdater.class).update(RuleUpdate.createForPluginRule(RuleTesting.XOO_X1).setTags(newHashSet("tag2")), UserSession.get());
+ TESTER.get(RuleUpdater.class).update(RuleUpdate.createForPluginRule(RuleTesting.XOO_X1).setTags(newHashSet("tag2")), userSessionRule);
dbSession.clearCache();
rule = ruleIndex.getByKey(RuleTesting.XOO_X1);
assertThat(rule.systemTags()).containsOnly("tag1");
package org.sonar.server.rule;
import com.google.common.collect.ImmutableMap;
+import java.util.HashMap;
+import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.sonar.server.rule.index.RuleQuery;
import org.sonar.server.search.QueryContext;
import org.sonar.server.search.Result;
-import org.sonar.server.user.UserSession;
-
-import java.util.HashMap;
-import java.util.List;
+import org.sonar.server.tester.UserSessionRule;
+import org.sonar.server.user.ThreadLocalUserSession;
import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Maps.newHashMap;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class RubyRuleServiceTest {
+ @org.junit.Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
+
@Mock
RuleService ruleService;
@Before
public void setUp() {
- service = new RubyRuleService(ruleService, updater);
+ service = new RubyRuleService(ruleService, updater, userSessionRule);
}
@Test
service.updateRule(ImmutableMap.<String, Object>of("ruleKey", "squid:S001"));
- verify(updater).update(any(RuleUpdate.class), any(UserSession.class));
+ verify(updater).update(any(RuleUpdate.class), any(ThreadLocalUserSession.class));
}
@Test
import java.util.Collection;
import java.util.List;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @org.junit.Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
RuleDao dao = tester.get(RuleDao.class);
RuleIndex index = tester.get(RuleIndex.class);
assertThat(index.getByKey(RuleTesting.XOO_X2)).isNotNull();
// 2. assert find does not get REMOVED
- List<Rule> rules = index.search(new RuleQuery(), new QueryContext()).getHits();
+ List<Rule> rules = index.search(new RuleQuery(), new QueryContext(userSessionRule)).getHits();
assertThat(rules).hasSize(1);
assertThat(rules.get(0).key()).isEqualTo(RuleTesting.XOO_X1);
}
import org.sonar.server.tester.ServerTester;
import java.util.List;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @org.junit.Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbSession dbSession;
DbClient db = tester.get(DbClient.class);
import org.sonar.server.tester.ServerTester;
import java.util.List;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @org.junit.Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db = tester.get(DbClient.class);
RuleDao dao = tester.get(RuleDao.class);
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.rule.RuleOperations.RuleChange;
import org.sonar.server.rule.db.RuleDao;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.MockUserSession;
import org.sonar.server.user.UserSession;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class RuleOperationsTest {
-
@Mock
DbClient dbClient;
@Captor
ArgumentCaptor<RuleDto> ruleCaptor;
- UserSession authorizedUserSession = MockUserSession.create().setLogin("nicolas").setName("Nicolas").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ UserSession authorizedUserSession = new MockUserSession("nicolas").setName("Nicolas").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
RuleOperations operations;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Sets;
+import java.util.Collections;
+import java.util.Set;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
import org.sonar.server.rule.index.RuleIndex;
import org.sonar.server.rule.index.RuleNormalizer;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.Collections;
-import java.util.Set;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @org.junit.Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
RuleDao dao = tester.get(RuleDao.class);
RuleIndex index = tester.get(RuleIndex.class);
@Test
public void get_rule_by_key() {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
RuleKey key = RuleKey.of("java", "S001");
@Test
public void get_non_null_rule_by_key() {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
RuleKey key = RuleKey.of("java", "S001");
@Test
public void get_rule_by_key_escape_description_on_manual_rule() {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
+ userSessionRule.logon().logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
RuleDto manualRule = RuleTesting.newManualRule("My manual")
.setDescription("<div>Manual rule desc</div>");
@Test
public void get_rule_by_keys() {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
+ userSessionRule.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
dao.insert(dbSession, RuleTesting.newDto(RuleKey.of("java", "S001")));
dbSession.commit();
@Test
public void update_rule() {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
+ userSessionRule.logon("me").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
RuleKey key = RuleKey.of("java", "S001");
@Test(expected = UnauthorizedException.class)
public void do_not_update_if_not_granted() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
RuleKey key = RuleKey.of("java", "S001");
@Test
public void create_rule() {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
// Create template rule
RuleKey templateRuleKey = RuleKey.of("java", "S001");
@Test(expected = UnauthorizedException.class)
public void do_not_create_if_not_granted() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
service.create(NewRule.createForCustomRule("MY_CUSTOM", RuleKey.of("java", "S001")));
}
@Test
public void delete_rule() {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
+ userSessionRule.logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
// Create template rule
RuleKey templateRuleKey = RuleKey.of("java", "S001");
}
@Test(expected = UnauthorizedException.class)
- public void do_not_delete_if_not_granted() {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
+ public void do_not_delete_if_not_granted() throws Exception {
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SCAN_EXECUTION);
service.delete(RuleKey.of("java", "S001"));
}
*/
package org.sonar.server.rule;
-import org.sonar.server.search.BaseIndex;
-
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Sets;
+import java.util.Set;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
import org.sonar.server.qualityprofile.index.ActiveRuleIndex;
import org.sonar.server.rule.db.RuleDao;
import org.sonar.server.rule.index.RuleIndex;
+import org.sonar.server.search.BaseIndex;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
-import org.sonar.server.user.UserSession;
-
-import java.util.Set;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @org.junit.Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbClient db = tester.get(DbClient.class);
RuleDao ruleDao = tester.get(RuleDao.class);
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setTags(Sets.newHashSet("java9"));
try {
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
fail();
} catch (IllegalArgumentException e) {
assertThat(e).hasMessage("Rule with REMOVED status cannot be updated: squid:S001");
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY);
assertThat(update.isEmpty()).isTrue();
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
dbSession.clearCache();
RuleDto rule = ruleDao.getNullableByKey(dbSession, RULE_KEY);
@Test
public void set_markdown_note() {
- MockUserSession.set().setLogin("me");
+ userSessionRule.logon("me");
ruleDao.insert(dbSession, RuleTesting.newDto(RULE_KEY)
.setNoteData(null)
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY);
update.setMarkdownNote("my *note*");
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
dbSession.clearCache();
RuleDto rule = ruleDao.getNullableByKey(dbSession, RULE_KEY);
dbSession.commit();
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setMarkdownNote(null);
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
dbSession.clearCache();
RuleDto rule = ruleDao.getNullableByKey(dbSession, RULE_KEY);
// java8 is a system tag -> ignore
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setTags(Sets.newHashSet("bug", "java8"));
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
dbSession.clearCache();
RuleDto rule = ruleDao.getNullableByKey(dbSession, RULE_KEY);
dbSession.commit();
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY).setTags(null);
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
dbSession.clearCache();
RuleDto rule = ruleDao.getNullableByKey(dbSession, RULE_KEY);
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY)
.setDebtSubCharacteristic("SOFT_RELIABILITY")
.setDebtRemediationFunction(fn);
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
dbSession.clearCache();
// verify debt is overridden
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY)
.setDebtRemediationFunction(new DefaultDebtRemediationFunction(DebtRemediationFunction.Type.LINEAR, "2d", null));
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
dbSession.clearCache();
// verify debt is overridden
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY)
.setDebtRemediationFunction(new DefaultDebtRemediationFunction(DebtRemediationFunction.Type.CONSTANT_ISSUE, null, "10min"));
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
dbSession.clearCache();
// verify debt is overridden
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY)
.setDebtSubCharacteristic(RuleUpdate.DEFAULT_DEBT_CHARACTERISTIC);
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
dbSession.clearCache();
// verify debt is coming from default values
RuleUpdate update = RuleUpdate.createForPluginRule(RULE_KEY)
.setDebtSubCharacteristic(null);
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
// verify db
dbSession.clearCache();
.setSeverity("MAJOR")
.setStatus(RuleStatus.READY)
.setParameters(ImmutableMap.of("regex", "b.*"));
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
dbSession.clearCache();
.setMarkdownDescription("New description")
.setSeverity("MAJOR")
.setStatus(RuleStatus.READY);
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
dbSession.clearCache();
// Update custom rule parameter 'regex', add 'message' and remove 'format'
RuleUpdate update = RuleUpdate.createForCustomRule(customRule.getKey())
.setParameters(ImmutableMap.of("regex", "b.*", "message", "a message"));
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
dbSession.clearCache();
.setName("")
.setMarkdownDescription("New desc");
try {
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalArgumentException.class).hasMessage("The name is missing");
.setName("New name")
.setMarkdownDescription("");
try {
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
fail();
} catch (Exception e) {
assertThat(e).isInstanceOf(IllegalArgumentException.class).hasMessage("The description is missing");
.setName("New name")
.setMarkdownDescription("New description")
.setSeverity(Severity.CRITICAL);
- updater.update(update, UserSession.get());
+ updater.update(update, userSessionRule);
dbSession.clearCache();
import java.util.List;
import java.util.Map;
import java.util.Set;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @org.junit.Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
protected DbClient db;
// should not have any facet!
RuleQuery query = new RuleQuery();
- Result result = index.search(query, new QueryContext());
+ Result result = index.search(query, new QueryContext(userSessionRule));
assertThat(result.getFacets()).isEmpty();
// should not have any facet on non matching query!
- result = index.search(new RuleQuery().setQueryText("aeiou"), new QueryContext().addFacets(Arrays.asList("repositories")));
+ result = index.search(new RuleQuery().setQueryText("aeiou"), new QueryContext(userSessionRule).addFacets(Arrays.asList("repositories")));
assertThat(result.getFacets()).isEmpty();
// Repositories Facet is preset
- result = index.search(query, new QueryContext().addFacets(Arrays.asList("repositories", "tags")));
+ result = index.search(query, new QueryContext(userSessionRule).addFacets(Arrays.asList("repositories", "tags")));
assertThat(result.getFacets()).isNotNull();
assertThat(result.getFacets()).hasSize(2);
dao.insert(dbSession, RuleTesting.newDto(RuleKey.of("javascript", "S001")));
dbSession.commit();
- QueryContext options = new QueryContext().setFieldsToReturn(null);
+ QueryContext options = new QueryContext(userSessionRule).setFieldsToReturn(null);
Result<Rule> results = index.search(new RuleQuery(), options);
assertThat(results.getHits()).hasSize(1);
Rule hit = Iterables.getFirst(results.getHits(), null);
assertThat(hit.htmlDescription()).isNotNull();
assertThat(hit.name()).isNotNull();
- options = new QueryContext().setFieldsToReturn(Collections.<String>emptyList());
+ options = new QueryContext(userSessionRule).setFieldsToReturn(Collections.<String>emptyList());
results = index.search(new RuleQuery(), options);
assertThat(results.getHits()).hasSize(1);
hit = Iterables.getFirst(results.getHits(), null);
dao.insert(dbSession, RuleTesting.newDto(RuleKey.of("javascript", "S001")));
dbSession.commit();
- QueryContext options = new QueryContext();
+ QueryContext options = new QueryContext(userSessionRule);
options.addFieldsToReturn(RuleNormalizer.RuleField.LANGUAGE.field(), RuleNormalizer.RuleField.STATUS.field());
Result<Rule> results = index.search(new RuleQuery(), options);
assertThat(results.getHits()).hasSize(1);
// substring
RuleQuery query = new RuleQuery().setQueryText("test");
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(1);
// substring
query = new RuleQuery().setQueryText("partial match");
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(1);
// case-insensitive
query = new RuleQuery().setQueryText("TESTING");
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(1);
// not found
query = new RuleQuery().setQueryText("not present");
- assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).isEmpty();
}
@Test
// key
RuleQuery query = new RuleQuery().setQueryText("X001");
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(2);
// partial key does not match
query = new RuleQuery().setQueryText("X00");
// TODO fix non-partial match for Key search
- assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).isEmpty();
// repo:key -> nice-to-have !
query = new RuleQuery().setQueryText("javascript:X001");
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(1);
}
@Test
// key
RuleQuery query = new RuleQuery().setKey(RuleKey.of("javascript", "X001").toString());
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(1);
// partial key does not match
query = new RuleQuery().setKey("X001");
// TODO fix non-partial match for Key search
- assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).isEmpty();
}
@Test
dao.insert(dbSession, RuleTesting.newDto(RuleKey.of("java", "S002")));
dbSession.commit();
- Result results = index.search(new RuleQuery(), new QueryContext());
+ Result results = index.search(new RuleQuery(), new QueryContext(userSessionRule));
assertThat(results.getTotal()).isEqualTo(2);
assertThat(results.getHits()).hasSize(2);
}
dbSession.commit();
- Result results = index.search(new RuleQuery(), new QueryContext().setScroll(true));
+ Result results = index.search(new RuleQuery(), new QueryContext(userSessionRule).setScroll(true));
assertThat(results.getTotal()).isEqualTo(max);
assertThat(results.getHits()).hasSize(0);
.setDefaultRemediationFunction(null).setDefaultRemediationCoefficient(null));
dbSession.commit();
- assertThat(index.search(new RuleQuery().setHasDebtCharacteristic(null), new QueryContext()).getTotal()).isEqualTo(4);
- assertThat(index.search(new RuleQuery().setHasDebtCharacteristic(true), new QueryContext()).getTotal()).isEqualTo(2);
- assertThat(index.search(new RuleQuery().setHasDebtCharacteristic(false), new QueryContext()).getTotal()).isEqualTo(2);
+ assertThat(index.search(new RuleQuery().setHasDebtCharacteristic(null), new QueryContext(userSessionRule)).getTotal()).isEqualTo(4);
+ assertThat(index.search(new RuleQuery().setHasDebtCharacteristic(true), new QueryContext(userSessionRule)).getTotal()).isEqualTo(2);
+ assertThat(index.search(new RuleQuery().setHasDebtCharacteristic(false), new QueryContext(userSessionRule)).getTotal()).isEqualTo(2);
}
@Test
.setDefaultRemediationFunction(null).setDefaultRemediationCoefficient(null));
dbSession.commit();
- QueryContext withDebtCharFacet = new QueryContext().addFacets(Arrays.asList(RuleIndex.FACET_DEBT_CHARACTERISTICS));
+ QueryContext withDebtCharFacet = new QueryContext(userSessionRule).addFacets(Arrays.asList(RuleIndex.FACET_DEBT_CHARACTERISTICS));
// Facet show results on characs, subcharacs and uncharacterized rules
Result<Rule> result1 = index.search(new RuleQuery(), withDebtCharFacet);
dbSession.commit();
RuleQuery query = new RuleQuery().setRepositories(Arrays.asList("checkstyle", "pmd"));
- Result<Rule> results = index.search(query, new QueryContext());
+ Result<Rule> results = index.search(query, new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(1);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S002");
// no results
query = new RuleQuery().setRepositories(Arrays.asList("checkstyle"));
- assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).isEmpty();
// empty list => no filter
query = new RuleQuery().setRepositories(Collections.<String>emptyList());
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(2);
}
@Test
dbSession.commit();
RuleQuery query = new RuleQuery().setLanguages(Arrays.asList("cobol", "js"));
- Result<Rule> results = index.search(query, new QueryContext());
+ Result<Rule> results = index.search(query, new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(1);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S002");
// no results
query = new RuleQuery().setLanguages(Arrays.asList("cpp"));
- assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).isEmpty();
// empty list => no filter
query = new RuleQuery().setLanguages(Collections.<String>emptyList());
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(2);
// null list => no filter
query = new RuleQuery().setLanguages(null);
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(2);
}
@Test
Result<Rule> results;
// 0. we have 2 rules in index
- results = index.search(new RuleQuery(), new QueryContext());
+ results = index.search(new RuleQuery(), new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(2);
// filter by non-subChar
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of("toto"));
- assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).isEmpty();
// filter by subChar
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char11.getKey()));
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(1);
// filter by Char
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char1.getKey()));
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(1);
// filter by Char and SubChar
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char11.getKey(), char1.getKey()));
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(1);
// match by Char
query = new RuleQuery().setQueryText(char1.getKey());
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(1);
// match by SubChar
query = new RuleQuery().setQueryText(char11.getKey());
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(1);
// match by SubChar & Char
query = new RuleQuery().setQueryText(char11.getKey() + " " + char1.getKey());
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(1);
}
@Test
Result<Rule> results;
// 0. we have 4 rules in index
- results = index.search(new RuleQuery(), new QueryContext());
+ results = index.search(new RuleQuery(), new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(4);
// filter by subChar
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char11.getKey()));
- assertThat(ruleKeys(index.search(query, new QueryContext()).getHits())).containsOnly("S001", "S002", "S004");
+ assertThat(ruleKeys(index.search(query, new QueryContext(userSessionRule)).getHits())).containsOnly("S001", "S002", "S004");
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char21.getKey()));
- assertThat(ruleKeys(index.search(query, new QueryContext()).getHits())).containsOnly("S003");
+ assertThat(ruleKeys(index.search(query, new QueryContext(userSessionRule)).getHits())).containsOnly("S003");
// filter by Char
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char1.getKey()));
- assertThat(ruleKeys(index.search(query, new QueryContext()).getHits())).containsOnly("S001", "S002", "S004");
+ assertThat(ruleKeys(index.search(query, new QueryContext(userSessionRule)).getHits())).containsOnly("S001", "S002", "S004");
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char2.getKey()));
- assertThat(ruleKeys(index.search(query, new QueryContext()).getHits())).containsOnly("S003");
+ assertThat(ruleKeys(index.search(query, new QueryContext(userSessionRule)).getHits())).containsOnly("S003");
// filter by Char and SubChar
query = new RuleQuery().setDebtCharacteristics(ImmutableSet.of(char11.getKey(), char1.getKey(), char2.getKey(), char21.getKey()));
- assertThat(ruleKeys(index.search(query, new QueryContext()).getHits())).containsOnly("S001", "S002", "S003", "S004");
+ assertThat(ruleKeys(index.search(query, new QueryContext(userSessionRule)).getHits())).containsOnly("S001", "S002", "S003", "S004");
}
@Test
dbSession.commit();
RuleQuery query = new RuleQuery().setSeverities(Arrays.asList(Severity.INFO, Severity.MINOR));
- Result<Rule> results = index.search(query, new QueryContext());
+ Result<Rule> results = index.search(query, new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(1);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S002");
// no results
query = new RuleQuery().setSeverities(Arrays.asList(Severity.MINOR));
- assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).isEmpty();
// empty list => no filter
query = new RuleQuery().setSeverities(Collections.<String>emptyList());
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(2);
// null list => no filter
query = new RuleQuery().setSeverities(null);
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(2);
}
@Test
dbSession.commit();
RuleQuery query = new RuleQuery().setStatuses(Arrays.asList(RuleStatus.DEPRECATED, RuleStatus.READY));
- Result<Rule> results = index.search(query, new QueryContext());
+ Result<Rule> results = index.search(query, new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(1);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S002");
// no results
query = new RuleQuery().setStatuses(Arrays.asList(RuleStatus.DEPRECATED));
- assertThat(index.search(query, new QueryContext()).getHits()).isEmpty();
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).isEmpty();
// empty list => no filter
query = new RuleQuery().setStatuses(Collections.<RuleStatus>emptyList());
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(2);
// null list => no filter
query = new RuleQuery().setStatuses(null);
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(2);
}
@Test
// ascending
RuleQuery query = new RuleQuery().setSortField(RuleNormalizer.RuleField.NAME);
- Result<Rule> results = index.search(query, new QueryContext());
+ Result<Rule> results = index.search(query, new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(3);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S002");
assertThat(Iterables.getLast(results.getHits(), null).key().rule()).isEqualTo("S003");
// descending
query = new RuleQuery().setSortField(RuleNormalizer.RuleField.NAME).setAscendingSort(false);
- results = index.search(query, new QueryContext());
+ results = index.search(query, new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(3);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S003");
assertThat(Iterables.getLast(results.getHits(), null).key().rule()).isEqualTo("S002");
// 1. get all active rules.
Result<Rule> result = index.search(new RuleQuery().setActivation(true),
- new QueryContext());
+ new QueryContext(userSessionRule));
assertThat(result.getHits()).hasSize(2);
// 2. get all inactive rules.
result = index.search(new RuleQuery().setActivation(false),
- new QueryContext());
+ new QueryContext(userSessionRule));
assertThat(result.getHits()).hasSize(1);
assertThat(result.getHits().get(0).name()).isEqualTo(rule3.getName());
// 3. get all rules not active on profile
index.search(new RuleQuery().setActivation(false).setQProfileKey(qualityProfileDto2.getKey()),
- new QueryContext());
+ new QueryContext(userSessionRule));
// TODO
assertThat(result.getHits()).hasSize(1);
// 4. get all active rules on profile
result = index.search(new RuleQuery().setActivation(true)
.setQProfileKey(qualityProfileDto2.getKey()),
- new QueryContext());
+ new QueryContext(userSessionRule));
assertThat(result.getHits()).hasSize(1);
assertThat(result.getHits().get(0).name()).isEqualTo(rule1.getName());
// 0. get all rules
Result<Rule> result = index.search(new RuleQuery(),
- new QueryContext());
+ new QueryContext(userSessionRule));
assertThat(result.getHits()).hasSize(4);
// 1. get all active rules
result = index.search(new RuleQuery().setActivation(true),
- new QueryContext());
+ new QueryContext(userSessionRule));
assertThat(result.getHits()).hasSize(3);
// 2. get all inactive rules.
result = index.search(new RuleQuery().setActivation(false),
- new QueryContext());
+ new QueryContext(userSessionRule));
assertThat(result.getHits()).hasSize(1);
assertThat(result.getHits().get(0).name()).isEqualTo(rule4.getName());
result = index.search(new RuleQuery().setActivation(true)
.setQProfileKey(qualityProfileDto1.getKey())
.setInheritance(ImmutableSet.of(ActiveRule.Inheritance.INHERITED.name())),
- new QueryContext()
+ new QueryContext(userSessionRule)
);
assertThat(result.getHits()).hasSize(0);
result = index.search(new RuleQuery().setActivation(true)
.setQProfileKey(qualityProfileDto2.getKey())
.setInheritance(ImmutableSet.of(ActiveRule.Inheritance.INHERITED.name())),
- new QueryContext()
+ new QueryContext(userSessionRule)
);
assertThat(result.getHits()).hasSize(2);
result = index.search(new RuleQuery().setActivation(true)
.setQProfileKey(qualityProfileDto1.getKey())
.setInheritance(ImmutableSet.of(ActiveRule.Inheritance.OVERRIDES.name())),
- new QueryContext()
+ new QueryContext(userSessionRule)
);
assertThat(result.getHits()).hasSize(0);
result = index.search(new RuleQuery().setActivation(true)
.setQProfileKey(qualityProfileDto2.getKey())
.setInheritance(ImmutableSet.of(ActiveRule.Inheritance.OVERRIDES.name())),
- new QueryContext()
+ new QueryContext(userSessionRule)
);
assertThat(result.getHits()).hasSize(1);
.setQProfileKey(qualityProfileDto1.getKey())
.setInheritance(ImmutableSet.of(
ActiveRule.Inheritance.INHERITED.name(), ActiveRule.Inheritance.OVERRIDES.name())),
- new QueryContext()
+ new QueryContext(userSessionRule)
);
assertThat(result.getHits()).hasSize(0);
.setQProfileKey(qualityProfileDto2.getKey())
.setInheritance(ImmutableSet.of(
ActiveRule.Inheritance.INHERITED.name(), ActiveRule.Inheritance.OVERRIDES.name())),
- new QueryContext()
+ new QueryContext(userSessionRule)
);
assertThat(result.getHits()).hasSize(3);
}
// 1. get all active rules.
Result<Rule> result = index.search(new RuleQuery().setActivation(true).setQProfileKey(qualityProfileDto1.getKey()),
- new QueryContext());
+ new QueryContext(userSessionRule));
assertThat(result.getHits()).hasSize(2);
// 2. get rules with active severity critical.
result = index.search(new RuleQuery().setActivation(true).setQProfileKey(qualityProfileDto1.getKey()).setActiveSeverities(Arrays.asList("CRITICAL")),
- new QueryContext().addFacets(Arrays.asList(RuleIndex.FACET_ACTIVE_SEVERITIES)));
+ new QueryContext(userSessionRule).addFacets(Arrays.asList(RuleIndex.FACET_ACTIVE_SEVERITIES)));
assertThat(result.getHits()).hasSize(1);
assertThat(result.getHits().get(0).name()).isEqualTo(rule2.getName());
// check stickyness of active severity facet
// 3. count activation severities of all active rules
result = index.search(new RuleQuery(),
- new QueryContext().addFacets(Arrays.asList(RuleIndex.FACET_ACTIVE_SEVERITIES)));
+ new QueryContext(userSessionRule).addFacets(Arrays.asList(RuleIndex.FACET_ACTIVE_SEVERITIES)));
assertThat(result.getHits()).hasSize(3);
assertThat(result.getFacetValues(RuleIndex.FACET_ACTIVE_SEVERITIES)).containsOnly(new FacetValue("BLOCKER", 2), new FacetValue("CRITICAL", 1));
}
// find all
RuleQuery query = new RuleQuery();
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(2);
// tag1 in query
query = new RuleQuery().setQueryText("tag1");
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
- assertThat(Iterables.getFirst(index.search(query, new QueryContext()).getHits(), null).tags()).containsExactly("tag1");
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(1);
+ assertThat(Iterables.getFirst(index.search(query, new QueryContext(userSessionRule)).getHits(), null).tags()).containsExactly("tag1");
// tag1 and tag2 in query
query = new RuleQuery().setQueryText("tag1 tag2");
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(2);
// tag2 in filter
query = new RuleQuery().setTags(ImmutableSet.of("tag2"));
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
- assertThat(Iterables.getFirst(index.search(query, new QueryContext()).getHits(), null).tags()).containsExactly("tag2");
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(1);
+ assertThat(Iterables.getFirst(index.search(query, new QueryContext(userSessionRule)).getHits(), null).tags()).containsExactly("tag2");
// tag2 in filter and tag1 tag2 in query
query = new RuleQuery().setTags(ImmutableSet.of("tag2")).setQueryText("tag1");
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(0);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(0);
// tag2 in filter and tag1 in query
query = new RuleQuery().setTags(ImmutableSet.of("tag2")).setQueryText("tag1 tag2");
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(1);
- assertThat(Iterables.getFirst(index.search(query, new QueryContext()).getHits(), null).tags()).containsExactly("tag2");
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(1);
+ assertThat(Iterables.getFirst(index.search(query, new QueryContext(userSessionRule)).getHits(), null).tags()).containsExactly("tag2");
// null list => no filter
query = new RuleQuery().setTags(Collections.<String>emptySet());
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(2);
// null list => no filter
query = new RuleQuery().setTags(null);
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(2);
}
@Test
// find all
RuleQuery query = new RuleQuery();
- Result<Rule> results = index.search(query, new QueryContext());
+ Result<Rule> results = index.search(query, new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(2);
// Only template
query = new RuleQuery().setIsTemplate(true);
- results = index.search(query, new QueryContext());
+ results = index.search(query, new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(1);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S002");
assertThat(Iterables.getFirst(results.getHits(), null).isTemplate()).isTrue();
// Only not template
query = new RuleQuery().setIsTemplate(false);
- results = index.search(query, new QueryContext());
+ results = index.search(query, new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(1);
assertThat(Iterables.getFirst(results.getHits(), null).isTemplate()).isFalse();
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S001");
// null => no filter
query = new RuleQuery().setIsTemplate(null);
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(2);
}
@Test
// find all
RuleQuery query = new RuleQuery();
- Result<Rule> results = index.search(query, new QueryContext());
+ Result<Rule> results = index.search(query, new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(2);
// Only custom rule
query = new RuleQuery().setTemplateKey("java:S001");
- results = index.search(query, new QueryContext());
+ results = index.search(query, new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(1);
assertThat(Iterables.getFirst(results.getHits(), null).key().rule()).isEqualTo("S001_MY_CUSTOM");
assertThat(Iterables.getFirst(results.getHits(), null).templateKey()).isEqualTo(RuleKey.of("java", "S001"));
// null => no filter
query = new RuleQuery().setTemplateKey(null);
- assertThat(index.search(query, new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(query, new QueryContext(userSessionRule)).getHits()).hasSize(2);
}
@Test
// find all
RuleQuery query = new RuleQuery();
- Result<Rule> results = index.search(query, new QueryContext());
+ Result<Rule> results = index.search(query, new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(2);
// get params
// find all
RuleQuery query = new RuleQuery();
- Result<Rule> results = index.search(query, new QueryContext());
+ Result<Rule> results = index.search(query, new QueryContext(userSessionRule));
assertThat(results.getHits()).hasSize(2);
// find custom rule
dbSession.commit();
// from 0 to 1 included
- QueryContext options = new QueryContext();
+ QueryContext options = new QueryContext(userSessionRule);
options.setOffset(0).setLimit(2);
Result results = index.search(new RuleQuery(), options);
assertThat(results.getTotal()).isEqualTo(3);
dbSession.commit();
// 0. find all rules;
- assertThat(index.search(new RuleQuery(), new QueryContext()).getHits()).hasSize(2);
+ assertThat(index.search(new RuleQuery(), new QueryContext(userSessionRule)).getHits()).hasSize(2);
// 1. find all rules available since a date;
RuleQuery availableSinceQuery = new RuleQuery()
.setAvailableSince(since);
- List<Rule> hits = index.search(availableSinceQuery, new QueryContext()).getHits();
+ List<Rule> hits = index.search(availableSinceQuery, new QueryContext(userSessionRule)).getHits();
assertThat(hits).hasSize(1);
assertThat(hits.get(0).key()).isEqualTo(RuleKey.of("java", "S002"));
// 2. find no new rules since tomorrow.
RuleQuery availableSinceNowQuery = new RuleQuery()
.setAvailableSince(DateUtils.addDays(since, 1));
- assertThat(index.search(availableSinceNowQuery, new QueryContext()).getHits()).hasSize(0);
+ assertThat(index.search(availableSinceNowQuery, new QueryContext(userSessionRule)).getHits()).hasSize(0);
}
@Test
assertThat(rule.name()).isEqualTo(nameWithProtectedChars);
RuleQuery protectedCharsQuery = new RuleQuery().setQueryText(nameWithProtectedChars);
- List<Rule> results = index.search(protectedCharsQuery, new QueryContext()).getHits();
+ List<Rule> results = index.search(protectedCharsQuery, new QueryContext(userSessionRule)).getHits();
assertThat(results).hasSize(1);
assertThat(results.get(0).key()).isEqualTo(RuleTesting.XOO_X1);
}
// 0 assert Base
assertThat(index.countAll()).isEqualTo(9);
- assertThat(index.search(new RuleQuery(), new QueryContext()).getHits()).hasSize(9);
+ assertThat(index.search(new RuleQuery(), new QueryContext(userSessionRule)).getHits()).hasSize(9);
// 1 Facet with no filters at all
- Map<String, Collection<FacetValue>> facets = index.search(new RuleQuery(), new QueryContext().addFacets(Arrays.asList("languages", "repositories", "tags"))).getFacets();
+ Map<String, Collection<FacetValue>> facets = index.search(new RuleQuery(), new QueryContext(userSessionRule).addFacets(Arrays.asList("languages", "repositories", "tags"))).getFacets();
assertThat(facets.keySet()).hasSize(3);
assertThat(facets.get(RuleIndex.FACET_LANGUAGES)).extracting("key").containsOnly("cpp", "java", "cobol");
assertThat(facets.get(RuleIndex.FACET_REPOSITORIES)).extracting("key").containsOnly("xoo", "foo");
// -- lang facet should still have all language
Result<Rule> result = index.search(new RuleQuery()
.setLanguages(ImmutableList.<String>of("cpp"))
- , new QueryContext().addFacets(Arrays.asList("languages", "repositories", "tags")));
+ , new QueryContext(userSessionRule).addFacets(Arrays.asList("languages", "repositories", "tags")));
assertThat(result.getHits()).hasSize(3);
assertThat(result.getFacets()).hasSize(3);
assertThat(result.getFacets().get(RuleIndex.FACET_LANGUAGES)).extracting("key").containsOnly("cpp", "java", "cobol");
result = index.search(new RuleQuery()
.setLanguages(ImmutableList.<String>of("cpp"))
.setTags(ImmutableList.<String>of("T2"))
- , new QueryContext().addFacets(Arrays.asList("languages", "repositories", "tags")));
+ , new QueryContext(userSessionRule).addFacets(Arrays.asList("languages", "repositories", "tags")));
assertThat(result.getHits()).hasSize(1);
assertThat(result.getFacets().keySet()).hasSize(3);
assertThat(result.getFacets().get(RuleIndex.FACET_LANGUAGES)).extracting("key").containsOnly("cpp", "java");
result = index.search(new RuleQuery()
.setLanguages(ImmutableList.<String>of("cpp", "java"))
.setTags(ImmutableList.<String>of("T2"))
- , new QueryContext().addFacets(Arrays.asList("languages", "repositories", "tags")));
+ , new QueryContext(userSessionRule).addFacets(Arrays.asList("languages", "repositories", "tags")));
assertThat(result.getHits()).hasSize(2);
assertThat(result.getFacets().keySet()).hasSize(3);
assertThat(result.getFacets().get(RuleIndex.FACET_LANGUAGES)).extracting("key").containsOnly("cpp", "java");
package org.sonar.server.rule.ws;
import com.google.common.collect.ImmutableList;
+import java.util.Locale;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.sonar.server.qualityprofile.QProfileLoader;
import org.sonar.server.qualityprofile.QProfileTesting;
import org.sonar.server.rule.RuleRepositories;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.util.Locale;
-
import static org.mockito.Matchers.anyString;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.mock;
@RunWith(MockitoJUnitRunner.class)
public class AppActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Mock
Languages languages;
@Test
public void should_generate_app_init_info() throws Exception {
- AppAction app = new AppAction(languages, ruleRepositories, i18n, debtModel, profileLoader);
+ AppAction app = new AppAction(languages, ruleRepositories, i18n, debtModel, profileLoader, userSessionRule);
WsTester tester = new WsTester(new RulesWebService(app));
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
QualityProfileDto profile1 = QProfileTesting.newXooP1();
QualityProfileDto profile2 = QProfileTesting.newXooP2().setParentKee(QProfileTesting.XOO_P1_KEY);
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.runners.MockitoJUnitRunner;
import org.sonar.server.rule.RuleTesting;
import org.sonar.server.rule.db.RuleDao;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester).logon()
+ .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
WsTester wsTester;
RuleDao ruleDao;
@Test
public void create_custom_rule() throws Exception {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
// Template rule
RuleDto templateRule = ruleDao.insert(session, RuleTesting.newTemplateRule(RuleKey.of("java", "S001")));
RuleParamDto param = RuleParamDto.createFor(templateRule).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
@Test
public void create_manual_rule() throws Exception {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "create")
.setParam("manual_key", "MY_MANUAL")
.setParam("name", "My manual rule")
@Test
public void create_manual_rule_without_severity() throws Exception {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "create")
.setParam("manual_key", "MY_MANUAL")
.setParam("name", "My manual rule")
@Test
public void fail_if_custom_key_and_manual_key_parameters_are_not_set() {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
WsTester.TestRequest request = wsTester.newGetRequest("api/rules", "create")
.setParam("key", "MY_MANUAL")
.setParam("name", "My manual rule")
@Test
public void create_manual_rule_with_prevent_reactivation_param_to_true() throws Exception {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
String key = "MY_MANUAL";
// insert a removed rule
*/
package org.sonar.server.rule.ws;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.resources.Languages;
import org.sonar.api.server.debt.DebtModel;
import org.sonar.server.rule.index.RuleNormalizer;
import org.sonar.server.search.QueryContext;
import org.sonar.server.search.ws.SearchOptions;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.text.MacroInterpreter;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
public class RuleMappingTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
Languages languages = new Languages();
MacroInterpreter macroInterpreter = mock(MacroInterpreter.class);
@Test
public void toQueryOptions_load_all_fields() {
- RuleMapping mapping = new RuleMapping(languages, macroInterpreter, debtModel);
+ RuleMapping mapping = new RuleMapping(languages, macroInterpreter, debtModel, userSessionRule);
SimpleGetRequest request = new SimpleGetRequest();
request.setParam("p", "1");
request.setParam("ps", "10");
@Test
public void toQueryOptions_load_only_few_simple_fields() {
- RuleMapping mapping = new RuleMapping(languages, macroInterpreter, debtModel);
+ RuleMapping mapping = new RuleMapping(languages, macroInterpreter, debtModel, userSessionRule);
SimpleGetRequest request = new SimpleGetRequest();
request.setParam("p", "1");
request.setParam("ps", "10");
@Test
public void toQueryOptions_langName_requires_lang() {
- RuleMapping mapping = new RuleMapping(languages, macroInterpreter, debtModel);
+ RuleMapping mapping = new RuleMapping(languages, macroInterpreter, debtModel, userSessionRule);
SimpleGetRequest request = new SimpleGetRequest();
request.setParam("p", "1");
request.setParam("ps", "10");
@Test
public void toQueryOptions_debt_requires_group_of_fields() {
- RuleMapping mapping = new RuleMapping(languages, macroInterpreter, debtModel);
+ RuleMapping mapping = new RuleMapping(languages, macroInterpreter, debtModel, userSessionRule);
SimpleGetRequest request = new SimpleGetRequest();
request.setParam("p", "1");
request.setParam("ps", "10");
@Test
public void toQueryOptions_html_note_requires_markdown_note() {
- RuleMapping mapping = new RuleMapping(languages, macroInterpreter, debtModel);
+ RuleMapping mapping = new RuleMapping(languages, macroInterpreter, debtModel, userSessionRule);
SimpleGetRequest request = new SimpleGetRequest();
request.setParam("p", "1");
request.setParam("ps", "10");
@Test
public void toQueryOptions_debt_characteristics() {
- RuleMapping mapping = new RuleMapping(languages, macroInterpreter, debtModel);
+ RuleMapping mapping = new RuleMapping(languages, macroInterpreter, debtModel, userSessionRule);
SimpleGetRequest request = new SimpleGetRequest();
request.setParam("p", "1");
request.setParam("ps", "10");
@Test
public void toQueryOptions_debt_overloaded() {
- RuleMapping mapping = new RuleMapping(languages, macroInterpreter, debtModel);
+ RuleMapping mapping = new RuleMapping(languages, macroInterpreter, debtModel, userSessionRule);
SimpleGetRequest request = new SimpleGetRequest();
request.setParam("p", "1");
request.setParam("ps", "10");
package org.sonar.server.rule.ws;
import com.google.common.collect.ImmutableSet;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Date;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.RuleStatus;
import org.sonar.server.rule.index.RuleNormalizer;
import org.sonar.server.search.ws.SearchOptions;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.util.Calendar;
-import java.util.Collections;
-import java.util.Date;
-
import static org.assertj.core.api.Assertions.assertThat;
public class RulesWebServiceMediumTest {
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
private static final String API_ENDPOINT = "api/rules";
private static final String API_SEARCH_METHOD = "search";
session.commit();
session.clearCache();
- MockUserSession.set();
-
// 1. With Activation
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SHOW_METHOD);
request.setParam(ShowAction.PARAM_KEY, rule.getKey().toString());
@Test
public void search_no_rules() throws Exception {
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_FIELDS, "actives");
WsTester.Result result = request.execute();
ruleDao.insert(session, RuleTesting.newXooX2());
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchAction.PARAM_KEY, RuleTesting.XOO_X1.toString());
request.setParam(SearchOptions.PARAM_FIELDS, "actives");
ruleDao.insert(session, RuleTesting.newXooX2());
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
WsTester.Result result = request.execute();
ruleDao.insert(session, RuleTesting.newXooX2().setDescription("A *Xoo* rule").setDescriptionFormat(Format.MARKDOWN));
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD).setParam(SearchOptions.PARAM_FIELDS, "name,htmlDesc,mdDesc");
WsTester.Result result = request.execute();
);
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_FIELDS, "debtChar,debtCharName,debtSubChar,debtSubCharName,debtRemFn,debtOverloaded,defaultDebtChar,defaultDebtSubChar,defaultDebtRemFn");
request.setParam(SearchAction.PARAM_FACETS, "debt_characteristics");
);
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_FIELDS, "debtChar,debtCharName,debtSubChar,debtSubCharName,debtRemFn,debtOverloaded,defaultDebtChar,defaultDebtSubChar,defaultDebtRemFn");
WsTester.Result result = request.execute();
);
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_FIELDS, "debtChar,debtCharName,debtSubChar,debtSubCharName,debtRemFn,debtOverloaded,defaultDebtChar,defaultDebtSubChar,defaultDebtRemFn");
WsTester.Result result = request.execute();
);
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_FIELDS, "debtChar,debtCharName,debtSubChar,debtSubCharName,debtRemFn,debtOverloaded,defaultDebtChar,defaultDebtSubChar,defaultDebtRemFn");
WsTester.Result result = request.execute();
);
session.commit();
- MockUserSession.set();
WsTester.Result result = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD)
.setParam(SearchOptions.PARAM_FIELDS, "debtChar,debtCharName,debtSubChar,debtSubCharName,debtRemFn,debtOverloaded,defaultDebtChar,defaultDebtSubChar,defaultDebtRemFn")
.setParam("debt_characteristics", "SOFT_RELIABILITY")
ruleDao.insert(session, RuleTesting.newXooX2()).setTemplateId(templateRule.getId());
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_FIELDS, "isTemplate");
request.setParam(SearchAction.PARAM_IS_TEMPLATE, "true");
ruleDao.insert(session, RuleTesting.newXooX2()).setTemplateId(templateRule.getId());
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_FIELDS, "templateKey");
request.setParam(SearchAction.PARAM_TEMPLATE_KEY, "xoo:x1");
tester.get(ActiveRuleDao.class).insert(session, activeRule);
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_TEXT_QUERY, "x1");
request.setParam(SearchAction.PARAM_ACTIVATION, "true");
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_TEXT_QUERY, "x1");
request.setParam(SearchAction.PARAM_ACTIVATION, "true");
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_TEXT_QUERY, "x1");
request.setParam(SearchAction.PARAM_ACTIVATION, "true");
tester.get(ActiveRuleDao.class).addParam(session, activeRule, activeRuleParam2);
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_TEXT_QUERY, "x1");
request.setParam(SearchAction.PARAM_ACTIVATION, "true");
ruleDao.insert(session, rule2);
session.commit();
- MockUserSession.set();
tester.wsTester().newGetRequest(API_ENDPOINT, API_TAGS_METHOD).execute().assertJson(this.getClass(), "get_tags.json");
tester.wsTester().newGetRequest(API_ENDPOINT, API_TAGS_METHOD)
.setParam("ps", "1").execute().assertJson(this.getClass(), "get_tags_limited.json");
ruleDao.insert(session, rule);
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_FIELDS, "htmlNote, mdNote");
WsTester.Result result = request.execute();
.setSystemTags(ImmutableSet.of("tag2")));
session.commit();
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchAction.PARAM_TAGS, "tag1");
request.setParam(SearchOptions.PARAM_FIELDS, "sysTags, tags");
session.commit();
// 1. Sort Name Asc
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_FIELDS, "");
request.setParam(SearchOptions.PARAM_SORT, "name");
Date since = new Date();
// 1. find today's rules
- MockUserSession.set();
WsTester.TestRequest request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_FIELDS, "");
request.setParam(SearchAction.PARAM_AVAILABLE_SINCE, DateUtils.formatDate(since));
c.add(Calendar.DATE, 1); // number of days to add
// 2. no rules since tomorrow
- MockUserSession.set();
request = tester.wsTester().newGetRequest(API_ENDPOINT, API_SEARCH_METHOD);
request.setParam(SearchOptions.PARAM_FIELDS, "");
request.setParam(SearchAction.PARAM_AVAILABLE_SINCE, DateUtils.formatDate(c.getTime()));
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.RuleStatus;
import org.sonar.server.rule.RuleTesting;
import org.sonar.server.rule.db.RuleDao;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static com.google.common.collect.Sets.newHashSet;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester).logon()
+ .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
WsTester wsTester;
@Test
public void show_rule() throws Exception {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
RuleDto ruleDto = ruleDao.insert(session,
RuleTesting.newDto(RuleKey.of("java", "S001"))
.setName("Rule S001")
@Test
public void show_rule_with_default_debt_infos() throws Exception {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
CharacteristicDto characteristicDto = new CharacteristicDto().setKey("API").setName("Api").setEnabled(true);
tester.get(CharacteristicDao.class).insert(characteristicDto, session);
CharacteristicDto subCharacteristicDto = new CharacteristicDto().setKey("API_ABUSE").setName("API Abuse").setEnabled(true).setParentId(characteristicDto.getId());
@Test
public void show_rule_with_overridden_debt() throws Exception {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
CharacteristicDto characteristicDto = new CharacteristicDto().setKey("API").setName("Api").setEnabled(true);
tester.get(CharacteristicDao.class).insert(characteristicDto, session);
CharacteristicDto subCharacteristicDto = new CharacteristicDto().setKey("API_ABUSE").setName("API Abuse").setEnabled(true).setParentId(characteristicDto.getId());
@Test
public void show_rule_with_default_and_overridden_debt_infos() throws Exception {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
CharacteristicDto defaultCharacteristic = new CharacteristicDto().setKey("API").setName("Api").setEnabled(true);
tester.get(CharacteristicDao.class).insert(defaultCharacteristic, session);
CharacteristicDto defaultSubCharacteristic = new CharacteristicDto().setKey("API_ABUSE").setName("API Abuse").setEnabled(true).setParentId(defaultCharacteristic.getId());
@Test
public void show_rule_with_no_default_and_no_overridden_debt() throws Exception {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
RuleDto ruleDto = ruleDao.insert(session,
RuleTesting.newDto(RuleKey.of("java", "S001"))
.setName("Rule S001")
@Test
public void show_rule_with_overridden_disable_debt() throws Exception {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
RuleDto ruleDto = ruleDao.insert(session,
RuleTesting.newDto(RuleKey.of("java", "S001"))
.setName("Rule S001")
@Test
public void encode_html_description_of_custom_rule() throws Exception {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
// Template rule
RuleDto templateRule = ruleDao.insert(session, RuleTesting.newTemplateRule(RuleKey.of("java", "S001")));
session.commit();
@Test
public void encode_html_description_of_manual_rule() throws Exception {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
// Manual rule
NewRule manualRule = NewRule.createForManualRule("MY_MANUAL")
.setName("My manual")
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.rule.RuleKey;
import org.sonar.api.rule.RuleStatus;
import org.sonar.server.rule.RuleTesting;
import org.sonar.server.rule.db.RuleDao;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester).
+ logon().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
WsTester wsTester;
@Test
public void update_custom_rule() throws Exception {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
// Template rule
RuleDto templateRule = ruleDao.insert(session, RuleTesting.newTemplateRule(RuleKey.of("java", "S001")));
RuleParamDto param = RuleParamDto.createFor(templateRule).setName("regex").setType("STRING").setDescription("Reg ex").setDefaultValue(".*");
@Test
public void fail_to_update_custom_when_description_is_empty() {
- MockUserSession.set()
- .setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
- .setLogin("me");
-
// Template rule
RuleDto templateRule = ruleDao.insert(session, RuleTesting.newTemplateRule(RuleKey.of("java", "S001")));
package org.sonar.server.search;
import com.google.common.collect.ImmutableList;
+import java.util.Arrays;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.Arrays;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
public class QueryContextTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone().logon("john").setUserGroups("sonar-users");
QueryContext options;
@Before
public void setUp() {
- MockUserSession.set().setLogin("john").setUserGroups("sonar-users");
- options = new QueryContext();
+ options = new QueryContext(userSessionRule);
}
@Test
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.server.tester.ServerTester;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.Assert.fail;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
SearchClient searchClient;
*/
package org.sonar.server.source.ws;
+import org.junit.Rule;
import org.sonar.server.source.db.FileSourceDao;
import org.junit.After;
import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.NotFoundException;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import org.sonar.test.DbTests;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static DbTester db = new DbTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
DbSession session;
DbClient dbClient = new DbClient(db.database(), db.myBatis(), new FileSourceDao(db.myBatis()), new ComponentDao());
- tester = new WsTester(new SourcesWs(new HashAction(dbClient)));
+ tester = new WsTester(new SourcesWs(new HashAction(dbClient, userSessionRule)));
}
@After
@Test
public void show_hashes() throws Exception {
db.prepareDbUnit(getClass(), "shared.xml");
- MockUserSession.set().setLogin("polop").addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
+ userSessionRule.logon("polop").addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
WsTester.TestRequest request = tester.newGetRequest("api/sources", "hash").setParam("key", COMPONENT_KEY);
assertThat(request.execute().outputAsString()).isEqualTo("987654");
@Test
public void hashes_empty_if_no_source() throws Exception {
db.prepareDbUnit(getClass(), "no_source.xml");
- MockUserSession.set().setLogin("polop").addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
+ userSessionRule.logon("polop").addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
WsTester.TestRequest request = tester.newGetRequest("api/sources", "hash").setParam("key", COMPONENT_KEY);
request.execute().assertNoContent();
@Test
public void fail_to_show_hashes_if_file_does_not_exist() {
- MockUserSession.set().setLogin("polop").addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
+ userSessionRule.logon("polop").addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
try {
WsTester.TestRequest request = tester.newGetRequest("api/sources", "hash").setParam("key", COMPONENT_KEY);
request.execute();
public void fail_on_missing_permission() throws Exception {
db.prepareDbUnit(getClass(), "shared.xml");
- MockUserSession.set().setLogin("polop");
+ userSessionRule.logon("polop");
tester.newGetRequest("api/sources", "hash").setParam("key", COMPONENT_KEY).execute();
}
}
package org.sonar.server.source.ws;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.source.SourceService;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static com.google.common.collect.Lists.newArrayList;
@RunWith(MockitoJUnitRunner.class)
public class IndexActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Mock
DbClient dbClient;
public void setUp() {
when(dbClient.componentDao()).thenReturn(componentDao);
when(dbClient.openSession(false)).thenReturn(session);
- tester = new WsTester(new SourcesWs(new IndexAction(dbClient, sourceService)));
+ tester = new WsTester(new SourcesWs(new IndexAction(dbClient, sourceService, userSessionRule)));
}
@Test
public void get_json() throws Exception {
String fileKey = "src/Foo.java";
- MockUserSession.set().addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
+ userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
when(componentDao.getByKey(session, fileKey)).thenReturn(file);
when(sourceService.getLinesAsTxt(file.uuid(), 1, null)).thenReturn(newArrayList(
@Test
public void limit_range() throws Exception {
String fileKey = "src/Foo.java";
- MockUserSession.set().addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
+ userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
when(componentDao.getByKey(session, fileKey)).thenReturn(file);
when(sourceService.getLinesAsTxt(file.uuid(), 1, 2)).thenReturn(newArrayList(
@Test(expected = ForbiddenException.class)
public void requires_code_viewer_permission() throws Exception {
- MockUserSession.set();
tester.newGetRequest("api/sources", "index").setParam("resource", "any").execute();
}
@Test
public void close_db_session() throws Exception {
String fileKey = "src/Foo.java";
- MockUserSession.set().addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
+ userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
when(componentDao.getByKey(session, fileKey)).thenThrow(new NotFoundException());
WsTester.TestRequest request = tester.newGetRequest("api/sources", "index").setParam("resource", fileKey);
package org.sonar.server.source.ws;
import com.google.common.collect.ImmutableList;
+import java.util.Date;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.api.web.UserRole;
import org.sonar.server.source.index.SourceLineDoc;
import org.sonar.server.source.index.SourceLineIndex;
import org.sonar.server.source.index.SourceLineIndexDefinition;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.util.Date;
-
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.failBecauseExceptionWasNotThrown;
import static org.junit.Assert.fail;
@ClassRule
public static EsTester esTester = new EsTester().addDefinitions(new SourceLineIndexDefinition(new Settings()));
-
@ClassRule
public static DbTester dbTester = new DbTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
SourceLineIndex sourceLineIndex;
componentDao = new ComponentDao();
DbClient dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), componentDao);
session = dbClient.openSession(false);
- wsTester = new WsTester(new SourcesWs(new LinesAction(dbClient, sourceLineIndex, htmlSourceDecorator)));
-
- MockUserSession.set();
+ wsTester = new WsTester(new SourcesWs(new LinesAction(dbClient, sourceLineIndex, htmlSourceDecorator, userSessionRule)));
}
@After
esTester.putDocuments(SourceLineIndexDefinition.INDEX, SourceLineIndexDefinition.TYPE, line1, line2, line3);
- MockUserSession.set().setLogin("login").addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
+ userSessionRule.logon("login").addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
WsTester.TestRequest request = wsTester.newGetRequest("api/sources", "lines").setParam("uuid", FILE_UUID);
request.execute().assertJson(getClass(), "show_source.json");
public void fail_to_show_source_if_no_source_found() {
newFile();
- MockUserSession.set().setLogin("login").addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
+ userSessionRule.logon("login").addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
try {
WsTester.TestRequest request = wsTester.newGetRequest("api/sources", "lines").setParam("uuid", FILE_UUID);
public void show_source_with_from_and_to_params() throws Exception {
newFile();
- MockUserSession.set().setLogin("login").addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
+ userSessionRule.logon("login").addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
esTester.putDocuments(SourceLineIndexDefinition.INDEX, SourceLineIndexDefinition.TYPE,
new SourceLineDoc()
.setUpdateDate(new Date())
);
- MockUserSession.set().setLogin("login").addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
+ userSessionRule.logon("login").addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
WsTester.TestRequest request = wsTester.newGetRequest("api/sources", "lines").setParam("key", FILE_KEY);
request.execute().assertJson(getClass(), "show_source_by_file_key.json");
@Test
public void fail_when_no_uuid_or_key_param() throws Exception {
newFile();
- MockUserSession.set().setLogin("login").addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
+ userSessionRule.logon("login").addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
WsTester.TestRequest request = wsTester.newGetRequest("api/sources", "lines");
try {
public void should_check_permission() throws Exception {
newFile();
- MockUserSession.set().setLogin("login");
+ userSessionRule.logon("login");
wsTester.newGetRequest("api/sources", "lines")
.setParam("uuid", FILE_UUID)
package org.sonar.server.source.ws;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.source.SourceService;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static com.google.common.collect.Lists.newArrayList;
@RunWith(MockitoJUnitRunner.class)
public class RawActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Mock
DbClient dbClient;
public void setUp() {
when(dbClient.componentDao()).thenReturn(componentDao);
when(dbClient.openSession(false)).thenReturn(session);
- tester = new WsTester(new SourcesWs(new RawAction(dbClient, sourceService)));
+ tester = new WsTester(new SourcesWs(new RawAction(dbClient, sourceService, userSessionRule)));
}
@Test
public void get_txt() throws Exception {
String fileKey = "src/Foo.java";
- MockUserSession.set().addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
+ userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
when(componentDao.getByKey(session, fileKey)).thenReturn(file);
when(sourceService.getLinesAsTxt(file.uuid(), null, null)).thenReturn(newArrayList(
@Test(expected = ForbiddenException.class)
public void requires_code_viewer_permission() throws Exception {
- MockUserSession.set();
tester.newGetRequest("api/sources", "raw").setParam("key", "any").execute();
}
}
package org.sonar.server.source.ws;
+import java.util.Date;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.api.utils.DateUtils;
import org.sonar.server.source.index.SourceLineDoc;
import org.sonar.server.source.index.SourceLineIndex;
import org.sonar.server.source.index.SourceLineIndexDefinition;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.util.Date;
-
public class ScmActionTest {
private static final String FILE_KEY = "FILE_KEY";
@ClassRule
public static DbTester dbTester = new DbTester();
-
@ClassRule
public static EsTester esTester = new EsTester().addDefinitions(new SourceLineIndexDefinition(new Settings()));
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
WsTester tester;
dbClient = new DbClient(dbTester.database(), dbTester.myBatis(), new ComponentDao());
session = dbClient.openSession(false);
- tester = new WsTester(new SourcesWs(new ScmAction(dbClient, new SourceLineIndex(esTester.client()))));
+ tester = new WsTester(new SourcesWs(new ScmAction(dbClient, new SourceLineIndex(esTester.client()), userSessionRule)));
}
@After
@Test
public void show_scm() throws Exception {
initFile();
- MockUserSession.set().addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
esTester.putDocuments(SourceLineIndexDefinition.INDEX, SourceLineIndexDefinition.TYPE,
newSourceLine("julien", "123-456-789", DateUtils.parseDateTime("2015-03-30T12:34:56+0000"), 1)
@Test
public void show_scm_from_given_range_lines() throws Exception {
initFile();
- MockUserSession.set().addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
esTester.putDocuments(SourceLineIndexDefinition.INDEX, SourceLineIndexDefinition.TYPE,
newSourceLine("julien", "123-456-789", DateUtils.parseDateTime("2015-03-30T12:34:56+0000"), 1),
@Test
public void not_group_lines_by_commit() throws Exception {
initFile();
- MockUserSession.set().addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
// lines 1 and 2 are the same commit, but not 3 (different date)
esTester.putDocuments(SourceLineIndexDefinition.INDEX, SourceLineIndexDefinition.TYPE,
@Test
public void group_lines_by_commit() throws Exception {
initFile();
- MockUserSession.set().addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
// lines 1 and 2 are the same commit, but not 3 (different date)
esTester.putDocuments(SourceLineIndexDefinition.INDEX, SourceLineIndexDefinition.TYPE,
@Test
public void accept_negative_value_in_from_parameter() throws Exception {
initFile();
- MockUserSession.set().addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
esTester.putDocuments(SourceLineIndexDefinition.INDEX, SourceLineIndexDefinition.TYPE,
newSourceLine("julien", "123-456-789", DateUtils.parseDateTime("2015-03-30T12:34:56+0000"), 1),
@Test
public void return_empty_value_when_no_scm() throws Exception {
initFile();
- MockUserSession.set().addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, PROJECT_UUID);
esTester.putDocuments(SourceLineIndexDefinition.INDEX, SourceLineIndexDefinition.TYPE,
newSourceLine(null, null, null, 1)
@Test(expected = ForbiddenException.class)
public void fail_without_code_viewer_permission() throws Exception {
initFile();
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, PROJECT_UUID);
WsTester.TestRequest request = tester.newGetRequest("api/sources", "scm").setParam("key", FILE_KEY);
request.execute();
package org.sonar.server.source.ws;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.sonar.server.db.DbClient;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.source.SourceService;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static com.google.common.collect.Lists.newArrayList;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.anyInt;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class ShowActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
SourceService sourceService = mock(SourceService.class);
public void setUp() {
when(dbClient.componentDao()).thenReturn(componentDao);
when(dbClient.openSession(false)).thenReturn(session);
- tester = new WsTester(new SourcesWs(new ShowAction(sourceService, dbClient)));
+ tester = new WsTester(new SourcesWs(new ShowAction(sourceService, dbClient, userSessionRule)));
}
@Test
public void show_source() throws Exception {
String fileKey = "src/Foo.java";
- MockUserSession.set().addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
+ userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
when(componentDao.getByKey(session, fileKey)).thenReturn(file);
when(sourceService.getLinesAsHtml(eq(file.uuid()), anyInt(), anyInt())).thenReturn(newArrayList(
"/*",
@Test
public void show_source_with_from_and_to_params() throws Exception {
String fileKey = "src/Foo.java";
- MockUserSession.set().addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
+ userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
when(componentDao.getByKey(session, fileKey)).thenReturn(file);
when(sourceService.getLinesAsHtml(file.uuid(), 3, 5)).thenReturn(newArrayList(
" */",
@Test
public void show_source_accept_from_less_than_one() throws Exception {
String fileKey = "src/Foo.java";
- MockUserSession.set().addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
+ userSessionRule.addComponentPermission(UserRole.CODEVIEWER, "polop", fileKey);
when(componentDao.getByKey(session, fileKey)).thenReturn(file);
when(sourceService.getLinesAsHtml(file.uuid(), 1, 5)).thenReturn(newArrayList(
" */",
@Test(expected = ForbiddenException.class)
public void require_code_viewer() throws Exception {
String fileKey = "src/Foo.java";
- MockUserSession.set();
tester.newGetRequest("api/sources", "show").setParam("key", fileKey).execute();
}
}
package org.sonar.server.source.ws;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.db.DbClient;
import org.sonar.server.source.HtmlSourceDecorator;
import org.sonar.server.source.SourceService;
import org.sonar.server.source.index.SourceLineIndex;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
public class SourcesWsTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
- ShowAction showAction = new ShowAction(mock(SourceService.class), mock(DbClient.class));
- RawAction rawAction = new RawAction(mock(DbClient.class), mock(SourceService.class));
- LinesAction linesAction = new LinesAction(mock(DbClient.class), mock(SourceLineIndex.class), mock(HtmlSourceDecorator.class));
- HashAction hashAction = new HashAction(mock(DbClient.class));
- IndexAction indexAction = new IndexAction(mock(DbClient.class), mock(SourceService.class));
+ ShowAction showAction = new ShowAction(mock(SourceService.class), mock(DbClient.class), userSessionRule);
+ RawAction rawAction = new RawAction(mock(DbClient.class), mock(SourceService.class), userSessionRule);
+ LinesAction linesAction = new LinesAction(mock(DbClient.class), mock(SourceLineIndex.class), mock(HtmlSourceDecorator.class), userSessionRule);
+ HashAction hashAction = new HashAction(mock(DbClient.class), userSessionRule);
+ IndexAction indexAction = new IndexAction(mock(DbClient.class), mock(SourceService.class), userSessionRule);
WsTester tester = new WsTester(new SourcesWs(showAction, rawAction, linesAction, hashAction, indexAction));
@Test
package org.sonar.server.test;
+import java.util.Collections;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.sonar.core.persistence.DbSession;
import org.sonar.core.persistence.MyBatis;
import org.sonar.server.measure.persistence.MeasureDao;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.Collections;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.*;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.anyString;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class CoverageServiceTest {
static final String COMPONENT_KEY = "org.sonar.sample:Sample";
- @org.junit.Rule
+
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
+ @Rule
public ExpectedException thrown = ExpectedException.none();
@Mock
DbSession session;
public void setUp() {
MyBatis myBatis = mock(MyBatis.class);
when(myBatis.openSession(false)).thenReturn(session);
- service = new CoverageService(myBatis, measureDao, snapshotPerspectives);
+ service = new CoverageService(myBatis, measureDao, snapshotPerspectives, userSessionRule);
}
@Test
public void check_permission() {
String projectKey = "org.sonar.sample";
- MockUserSession.set().addComponentPermission(UserRole.CODEVIEWER, projectKey, COMPONENT_KEY);
+ userSessionRule.addComponentPermission(UserRole.CODEVIEWER, projectKey, COMPONENT_KEY);
service.checkPermission(COMPONENT_KEY);
}
package org.sonar.server.test.ws;
+import java.util.Arrays;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.web.UserRole;
import org.sonar.core.persistence.DbSession;
import org.sonar.server.db.DbClient;
import org.sonar.server.test.index.CoveredFileDoc;
import org.sonar.server.test.index.TestIndex;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.util.Arrays;
-
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyList;
import static org.mockito.Matchers.anyString;
import static org.sonar.server.test.ws.TestsCoveredFilesAction.TEST_UUID;
public class TestsCoveredFilesActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
WsTester ws;
private DbClient dbClient;
public void setUp() {
dbClient = mock(DbClient.class, RETURNS_DEEP_STUBS);
testIndex = mock(TestIndex.class, RETURNS_DEEP_STUBS);
- ws = new WsTester(new TestsWs(new TestsCoveredFilesAction(dbClient, testIndex)));
+ ws = new WsTester(new TestsWs(new TestsCoveredFilesAction(dbClient, testIndex, userSessionRule)));
}
@Test
public void covered_files() throws Exception {
- MockUserSession.set().addComponentUuidPermission(UserRole.CODEVIEWER, "SonarQube", "test-file-uuid");
+ userSessionRule.addComponentUuidPermission(UserRole.CODEVIEWER, "SonarQube", "test-file-uuid");
when(testIndex.searchByTestUuid(anyString()).fileUuid()).thenReturn("test-file-uuid");
when(testIndex.coveredFiles("test-uuid")).thenReturn(Arrays.asList(
package org.sonar.server.test.ws;
+import java.util.Arrays;
+import java.util.List;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.api.web.UserRole;
import org.sonar.server.test.index.TestDoc;
import org.sonar.server.test.index.TestIndex;
import org.sonar.server.test.index.TestIndexDefinition;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
-import java.util.Arrays;
-import java.util.List;
-
public class TestsListActionTest {
DbClient dbClient;
DbSession dbSession;
public static DbTester db = new DbTester();
@ClassRule
public static EsTester es = new EsTester().addDefinitions(new TestIndexDefinition(new Settings()));
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Before
public void setUp() {
es.truncateIndices();
testIndex = new TestIndex(es.client());
- ws = new WsTester(new TestsWs(new TestsListAction(dbClient, testIndex)));
+ ws = new WsTester(new TestsWs(new TestsListAction(dbClient, testIndex, userSessionRule)));
}
@After
@Test
public void list_based_on_test_uuid() throws Exception {
- MockUserSession.set().addProjectUuidPermissions(UserRole.CODEVIEWER, TestFile1.PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, TestFile1.PROJECT_UUID);
dbClient.componentDao().insert(dbSession, TestFile1.newDto());
dbSession.commit();
@Test
public void list_based_on_test_file_uuid() throws Exception {
- MockUserSession.set().addProjectUuidPermissions(UserRole.CODEVIEWER, TestFile1.PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, TestFile1.PROJECT_UUID);
dbClient.componentDao().insert(dbSession, TestFile1.newDto());
dbSession.commit();
@Test
public void list_based_on_test_file_key() throws Exception {
- MockUserSession.set().addComponentPermission(UserRole.CODEVIEWER, TestFile1.PROJECT_UUID, TestFile1.KEY);
+ userSessionRule.addComponentPermission(UserRole.CODEVIEWER, TestFile1.PROJECT_UUID, TestFile1.KEY);
dbClient.componentDao().insert(dbSession, TestFile1.newDto());
dbSession.commit();
@Test
public void list_based_on_main_file_and_line_number() throws Exception {
String mainFileUuid = "MAIN-FILE-UUID";
- MockUserSession.set().addProjectUuidPermissions(UserRole.CODEVIEWER, TestFile1.PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.CODEVIEWER, TestFile1.PROJECT_UUID);
dbClient.componentDao().insert(dbSession,
new ComponentDto()
.setUuid(TestFile1.FILE_UUID)
@Test(expected = ForbiddenException.class)
public void fail_when_no_sufficent_privilege_on_file_uuid() throws Exception {
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, TestFile1.PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, TestFile1.PROJECT_UUID);
dbClient.componentDao().insert(dbSession, TestFile1.newDto());
dbSession.commit();
ws.newGetRequest("api/tests", "list").setParam(TestsListAction.TEST_FILE_UUID, TestFile1.FILE_UUID).execute();
@Test(expected = ForbiddenException.class)
public void fail_when_no_sufficent_privilege_on_test_uuid() throws Exception {
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, TestFile1.PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, TestFile1.PROJECT_UUID);
dbClient.componentDao().insert(dbSession, TestFile1.newDto());
dbSession.commit();
ws.newGetRequest("api/tests", "list").setParam(TestsListAction.TEST_FILE_UUID, TestFile1.FILE_UUID).execute();
@Test(expected = ForbiddenException.class)
public void fail_when_no_sufficent_privilege_on_file_key() throws Exception {
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, TestFile1.PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, TestFile1.PROJECT_UUID);
dbClient.componentDao().insert(dbSession, TestFile1.newDto());
dbSession.commit();
ws.newGetRequest("api/tests", "list").setParam(TestsListAction.TEST_FILE_KEY, TestFile1.KEY).execute();
@Test(expected = ForbiddenException.class)
public void fail_when_no_sufficient_privilege_on_main_file_uuid() throws Exception {
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, TestFile1.PROJECT_UUID);
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, TestFile1.PROJECT_UUID);
String mainFileUuid = "MAIN-FILE-UUID";
dbClient.componentDao().insert(dbSession, new ComponentDto().setUuid(mainFileUuid).setProjectUuid(TestFile1.PROJECT_UUID));
dbSession.commit();
package org.sonar.server.test.ws;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.db.DbClient;
import org.sonar.server.test.index.TestIndex;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
public class TestsWsTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
WebService.Controller controller;
@Before
public void setUp() {
WsTester tester = new WsTester(new TestsWs(
- new TestsListAction(mock(DbClient.class), mock(TestIndex.class)),
- new TestsCoveredFilesAction(mock(DbClient.class), mock(TestIndex.class))));
+ new TestsListAction(mock(DbClient.class), mock(TestIndex.class), userSessionRule),
+ new TestsCoveredFilesAction(mock(DbClient.class), mock(TestIndex.class), userSessionRule)));
controller = tester.controller("api/tests");
}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.tester;
+
+import org.sonar.server.exceptions.UnauthorizedException;
+import org.sonar.server.user.UserSession;
+
+public class AnonymousMockUserSession extends MockUserSession {
+ public AnonymousMockUserSession() {
+ super();
+ }
+
+ @Override
+ public boolean isLoggedIn() {
+ return false;
+ }
+
+ @Override
+ public UserSession checkLoggedIn() {
+ throw new UnauthorizedException("Authentication is required");
+ }
+
+}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.tester;
+
+import com.google.common.base.Preconditions;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import javax.annotation.Nullable;
+import org.sonar.server.user.AbstractUserSession;
+import org.sonar.server.user.UserSession;
+
+import static com.google.common.collect.Lists.newArrayList;
+import static com.google.common.collect.Maps.newHashMap;
+
+public class MockUserSession extends AbstractUserSession<MockUserSession> implements UserSession {
+ private Map<String, String> projectKeyByComponentKey = newHashMap();
+
+ protected MockUserSession() {
+ super(MockUserSession.class);
+ }
+
+ public MockUserSession(String login) {
+ this();
+ setLogin(Preconditions.checkNotNull(login));
+ }
+
+ public MockUserSession(MockUserSession ruleUserSession) {
+ this();
+ this.userId = ruleUserSession.userId;
+ this.login = ruleUserSession.login;
+ this.userGroups = ruleUserSession.userGroups;
+ this.globalPermissions = ruleUserSession.globalPermissions;
+ this.projectKeyByPermission = ruleUserSession.projectKeyByPermission;
+ this.projectUuidByPermission = ruleUserSession.projectUuidByPermission;
+ this.projectUuidByComponentUuid = ruleUserSession.projectUuidByComponentUuid;
+ this.projectPermissions = ruleUserSession.projectPermissions;
+ this.name = ruleUserSession.name;
+ this.locale = ruleUserSession.locale;
+ }
+
+ @Override
+ public boolean isLoggedIn() {
+ return true;
+ }
+
+ public MockUserSession setGlobalPermissions(String... globalPermissions) {
+ this.globalPermissions = Arrays.asList(globalPermissions);
+ return this;
+ }
+
+ @Override
+ public MockUserSession setLogin(@Nullable String s) {
+ return super.setLogin(s);
+ }
+
+ @Override
+ public MockUserSession setName(@Nullable String s) {
+ return super.setName(s);
+ }
+
+ @Override
+ public MockUserSession setUserId(@Nullable Integer userId) {
+ return super.setUserId(userId);
+ }
+
+ @Override
+ public MockUserSession setUserGroups(@Nullable String... userGroups) {
+ return super.setUserGroups(userGroups);
+ }
+
+ @Override
+ public MockUserSession setLocale(@Nullable Locale l) {
+ return super.setLocale(l);
+ }
+
+ /**
+ * Deprecated, please use {@link #addProjectUuidPermissions}
+ */
+ @Deprecated
+ public MockUserSession addProjectPermissions(String projectPermission, String... projectKeys) {
+ this.projectPermissions.add(projectPermission);
+ this.projectKeyByPermission.putAll(projectPermission, newArrayList(projectKeys));
+ return this;
+ }
+
+ public MockUserSession addProjectUuidPermissions(String projectPermission, String... projectUuids) {
+ this.projectPermissions.add(projectPermission);
+ this.projectUuidByPermission.putAll(projectPermission, newArrayList(projectUuids));
+ return this;
+ }
+
+ /**
+ * Deprecated, please use {@link #addComponentUuidPermission}
+ */
+ @Deprecated
+ public MockUserSession addComponentPermission(String projectPermission, String projectKey, String componentKey) {
+ this.projectKeyByComponentKey.put(componentKey, projectKey);
+ addProjectPermissions(projectPermission, projectKey);
+ return this;
+ }
+
+ public MockUserSession addComponentUuidPermission(String projectPermission, String projectUuid, String componentUuid) {
+ this.projectUuidByComponentUuid.put(componentUuid, projectUuid);
+ addProjectUuidPermissions(projectPermission, projectUuid);
+ return this;
+ }
+
+ @Override
+ public List<String> globalPermissions() {
+ return globalPermissions;
+ }
+
+ @Override
+ public boolean hasProjectPermission(String permission, String projectKey) {
+ return projectPermissions.contains(permission) && projectKeyByPermission.get(permission).contains(projectKey);
+ }
+
+ @Override
+ public boolean hasProjectPermissionByUuid(String permission, String projectUuid) {
+ return projectPermissions.contains(permission) && projectUuidByPermission.get(permission).contains(projectUuid);
+ }
+
+ @Override
+ public boolean hasComponentPermission(String permission, String componentKey) {
+ String projectKey = projectKeyByComponentKey.get(componentKey);
+ return projectKey != null && hasProjectPermission(permission, projectKey);
+ }
+
+ @Override
+ public boolean hasComponentUuidPermission(String permission, String componentUuid) {
+ String projectUuid = projectUuidByComponentUuid.get(componentUuid);
+ return projectUuid != null && hasProjectPermissionByUuid(permission, projectUuid);
+ }
+}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.tester;
+
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class MockUserSessionTest {
+ @Test
+ public void set_mock_session() {
+ MockUserSession mock = new MockUserSession("simon").setUserGroups("sonar-users");
+
+ assertThat(mock.login()).isEqualTo("simon");
+ assertThat(mock.userGroups()).containsOnly("sonar-users", "Anyone");
+ assertThat(mock.globalPermissions()).isEmpty();
+ assertThat(mock.isLoggedIn()).isTrue();
+ }
+}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.tester;
+
+import com.google.common.base.Preconditions;
+import java.util.List;
+import java.util.Locale;
+import java.util.Set;
+import javax.annotation.CheckForNull;
+import javax.annotation.Nullable;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
+import org.sonar.server.user.ThreadLocalUserSession;
+import org.sonar.server.user.UserSession;
+
+import static com.google.common.base.Preconditions.checkNotNull;
+import static com.google.common.base.Preconditions.checkState;
+
+/**
+ * {@code UserSessionRule} is intended to be used as a {@link org.junit.Rule} to easily manage {@link UserSession} in
+ * unit tests.
+ * <p>
+ * It can be used as a {@link org.junit.ClassRule} but be careful not to modify its states from inside tests methods
+ * unless you purposely want to have side effects between each tests.
+ * </p>
+ * <p>
+ * {@code UserSessionRule} is intended to be used either standalone (in which case use the static factory method
+ * {@link #standalone()} or with {@link ServerTester} (in which case use static factory method
+ * {@link #forServerTester(ServerTester)}).
+ * </p>
+ * <p>
+ * In both cases, one can define user session behavior which should apply on all tests directly on the property, eg.:
+ * <pre>
+ * {@literal @}Rule
+ * public UserSessionRule userSessionRule = UserSessionRule.standalone().logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ * </pre>
+ * </p>
+ * <p>
+ * Behavior defined at property-level can obviously be override at test method level. For example, one could define
+ * all methods to use an authenticated session such as presented above but can easily overwrite that behavior in a
+ * specific test method as follow:
+ * <pre>
+ * {@literal @}Test
+ * public void test_method() {
+ * userSessionRule.standalone();
+ * {@literal [...]}
+ * }
+ * </pre>
+ * </p>
+ * <p>
+ * {@code UserSessionRule}, being standalone or associated to a {@link ServerTester}, emulates by default an anonymous
+ * session. Therefore, call {@code UserSessionRule.standalone()} is equivalent to calling
+ * {@code UserSessionRule.standalone().anonymous()}.
+ * </p>
+ * <p>
+ * To emulate an identified user, either use method {@link #logon(String)} if you want to specify the user's login, or
+ * method {@link #logon()} which will do the same but using the value of {@link #DEFAULT_LOGIN} as the user's login.
+ * </p>
+ */
+public class UserSessionRule implements TestRule, UserSession {
+ public static final String DEFAULT_LOGIN = "default_login";
+
+ @CheckForNull
+ private final ServerTester serverTester;
+ private UserSession currentUserSession;
+
+ private UserSessionRule(@Nullable ServerTester serverTester) {
+ this.serverTester = serverTester;
+ anonymous();
+ }
+
+ public static UserSessionRule standalone() {
+ return new UserSessionRule(null);
+ }
+
+ public static UserSessionRule forServerTester(ServerTester serverTester) {
+ return new UserSessionRule(Preconditions.checkNotNull(serverTester));
+ }
+
+ /**
+ * Log on with the default login {@link #DEFAULT_LOGIN}
+ */
+ public UserSessionRule logon() {
+ return logon(DEFAULT_LOGIN);
+ }
+
+ /**
+ * Log on with the specified login
+ */
+ public UserSessionRule logon(String login) {
+ setCurrentUserSession(new MockUserSession(login));
+ return this;
+ }
+
+ /**
+ * Disconnect/go anonymous
+ */
+ public UserSessionRule anonymous() {
+ setCurrentUserSession(new AnonymousMockUserSession());
+ return this;
+ }
+
+ @Override
+ public Statement apply(Statement statement, Description description) {
+ return this.statement(statement);
+ }
+
+ private Statement statement(final Statement base) {
+ return new Statement() {
+ public void evaluate() throws Throwable {
+ UserSessionRule.this.before();
+
+ try {
+ base.evaluate();
+ } finally {
+ UserSessionRule.this.after();
+ }
+
+ }
+ };
+ }
+
+ protected void before() throws Throwable {
+ setCurrentUserSession(currentUserSession);
+ }
+
+ protected void after() {
+ this.currentUserSession = null;
+ if (serverTester != null) {
+ serverTester.get(ThreadLocalUserSession.class).remove();
+ }
+ }
+
+ public void set(UserSession userSession) {
+ checkState(serverTester == null, "Can set a specific session and use ServerTester at the same time");
+ checkNotNull(userSession);
+ setCurrentUserSession(userSession);
+ }
+
+ public UserSessionRule setGlobalPermissions(String... globalPermissions) {
+ ensureMockUserSession().setGlobalPermissions(globalPermissions);
+ return this;
+ }
+
+ public UserSessionRule addProjectUuidPermissions(String projectPermission, String... projectUuids) {
+ ensureMockUserSession().addProjectUuidPermissions(projectPermission, projectUuids);
+ return this;
+ }
+
+ @Deprecated
+ public UserSessionRule addComponentPermission(String projectPermission, String projectKey, String componentKey) {
+ ensureMockUserSession().addComponentPermission(projectPermission, projectKey, componentKey);
+ return this;
+ }
+
+ @Deprecated
+ public UserSessionRule addProjectPermissions(String projectPermission, String... projectKeys) {
+ ensureMockUserSession().addProjectPermissions(projectPermission, projectKeys);
+ return this;
+ }
+
+ public UserSessionRule setUserId(@Nullable Integer userId) {
+ ensureMockUserSession().setUserId(userId);
+ return this;
+ }
+
+ public UserSessionRule setUserGroups(@Nullable String... userGroups) {
+ ensureMockUserSession().setUserGroups(userGroups);
+ return this;
+ }
+
+ public UserSessionRule setLocale(@Nullable Locale l) {
+ ensureMockUserSession().setLocale(l);
+ return this;
+ }
+
+ public UserSessionRule addComponentUuidPermission(String projectPermission, String projectUuid, String componentUuid) {
+ ensureMockUserSession().addComponentUuidPermission(projectPermission, projectUuid, componentUuid);
+ return this;
+ }
+
+ public UserSessionRule setName(@Nullable String s) {
+ ensureMockUserSession().setName(s);
+ return this;
+ }
+
+ private MockUserSession ensureMockUserSession() {
+ checkState(currentUserSession instanceof MockUserSession, "rule state can not be changed if a UserSession has explicitly been provided");
+ return (MockUserSession) currentUserSession;
+ }
+
+ private void setCurrentUserSession(UserSession userSession) {
+ this.currentUserSession = Preconditions.checkNotNull(userSession);
+ if (serverTester != null) {
+ serverTester.get(ThreadLocalUserSession.class).set(currentUserSession);
+ }
+ }
+
+ @Override
+ public List<String> globalPermissions() {
+ return currentUserSession.globalPermissions();
+ }
+
+ @Override
+ public boolean hasProjectPermission(String permission, String projectKey) {
+ return currentUserSession.hasProjectPermission(permission, projectKey);
+ }
+
+ @Override
+ public boolean hasProjectPermissionByUuid(String permission, String projectUuid) {
+ return currentUserSession.hasProjectPermissionByUuid(permission, projectUuid);
+ }
+
+ @Override
+ public boolean hasComponentPermission(String permission, String componentKey) {
+ return currentUserSession.hasComponentPermission(permission, componentKey);
+ }
+
+ @Override
+ public boolean hasComponentUuidPermission(String permission, String componentUuid) {
+ return currentUserSession.hasComponentUuidPermission(permission, componentUuid);
+ }
+
+ @Override
+ @CheckForNull
+ public String login() {
+ return currentUserSession.login();
+ }
+
+ @Override
+ @CheckForNull
+ public String name() {
+ return currentUserSession.name();
+ }
+
+ @Override
+ @CheckForNull
+ public Integer userId() {
+ return currentUserSession.userId();
+ }
+
+ @Override
+ public Set<String> userGroups() {
+ return currentUserSession.userGroups();
+ }
+
+ @Override
+ public boolean isLoggedIn() {
+ return currentUserSession.isLoggedIn();
+ }
+
+ @Override
+ public Locale locale() {
+ return currentUserSession.locale();
+ }
+
+ @Override
+ public UserSession checkLoggedIn() {
+ return currentUserSession.checkLoggedIn();
+ }
+
+ @Override
+ public UserSession checkGlobalPermission(String globalPermission) {
+ return currentUserSession.checkGlobalPermission(globalPermission);
+ }
+
+ @Override
+ public UserSession checkGlobalPermission(String globalPermission, @Nullable String errorMessage) {
+ return currentUserSession.checkGlobalPermission(globalPermission, errorMessage);
+ }
+
+ @Override
+ public boolean hasGlobalPermission(String globalPermission) {
+ return currentUserSession.hasGlobalPermission(globalPermission);
+ }
+
+ @Override
+ public UserSession checkProjectPermission(String projectPermission, String projectKey) {
+ return currentUserSession.checkProjectPermission(projectPermission, projectKey);
+ }
+
+ @Override
+ public UserSession checkProjectUuidPermission(String projectPermission, String projectUuid) {
+ return currentUserSession.checkProjectUuidPermission(projectPermission, projectUuid);
+ }
+
+ @Override
+ public UserSession checkComponentPermission(String projectPermission, String componentKey) {
+ return currentUserSession.checkComponentPermission(projectPermission, componentKey);
+ }
+
+ @Override
+ public UserSession checkComponentUuidPermission(String permission, String componentUuid) {
+ return currentUserSession.checkComponentUuidPermission(permission, componentUuid);
+ }
+
+
+}
*/
package org.sonar.server.ui;
+import java.util.Date;
+import java.util.Locale;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.sonar.api.i18n.I18n;
import org.sonar.api.utils.Duration;
import org.sonar.api.utils.Durations;
-
-import java.util.Date;
-import java.util.Locale;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Matchers.any;
@RunWith(MockitoJUnitRunner.class)
public class JRubyI18nTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
@Mock
I18n i18n;
@Before
public void setUp() {
- jRubyI18n = new JRubyI18n(i18n, durations);
+ jRubyI18n = new JRubyI18n(i18n, durations, userSessionRule);
}
@Test
package org.sonar.server.ui;
import com.google.common.collect.Lists;
+import java.util.List;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.sonar.api.web.WidgetProperty;
import org.sonar.api.web.WidgetPropertyType;
import org.sonar.api.web.WidgetScope;
-import org.sonar.server.user.MockUserSession;
-
-import java.util.List;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Iterables.getOnlyElement;
import static org.assertj.core.api.Assertions.assertThat;
public class ViewProxyTest {
+ @Rule
+ public UserSessionRule userSession = UserSessionRule.standalone();
@Rule
public ExpectedException exception = ExpectedException.none();
@Test
public void compareTo() {
- assertThat(new ViewProxy<FakeView>(new FakeView("aaa")).compareTo(new ViewProxy<FakeView>(new FakeView("bbb")))).isLessThan(0);
- assertThat(new ViewProxy<FakeView>(new FakeView("aaa")).compareTo(new ViewProxy<FakeView>(new FakeView("aaa")))).isZero();
- assertThat(new ViewProxy<FakeView>(new FakeView("bbb")).compareTo(new ViewProxy<FakeView>(new FakeView("aaa")))).isGreaterThan(0);
+ assertThat(new ViewProxy<>(new FakeView("aaa"), userSession).compareTo(new ViewProxy<>(new FakeView("bbb"), userSession))).isLessThan(0);
+ assertThat(new ViewProxy<>(new FakeView("aaa"), userSession).compareTo(new ViewProxy<>(new FakeView("aaa"), userSession))).isZero();
+ assertThat(new ViewProxy<>(new FakeView("bbb"), userSession).compareTo(new ViewProxy<>(new FakeView("aaa"), userSession))).isGreaterThan(0);
}
@Test
}
View view = new MyView();
- ViewProxy proxy = new ViewProxy<View>(view);
+ ViewProxy proxy = new ViewProxy<>(view, userSession);
assertThat(proxy.getTarget()).isEqualTo(view);
assertThat(proxy.getSections()).isEqualTo(new String[] {NavigationSection.RESOURCE});
}
}
View view = new MyView();
- ViewProxy proxy = new ViewProxy<View>(view);
+ ViewProxy proxy = new ViewProxy<>(view, userSession);
assertThat(proxy.getTarget()).isEqualTo(view);
assertThat(proxy.getSections()).isEqualTo(new String[] {NavigationSection.HOME});
}
}
- ViewProxy proxy = new ViewProxy<MyView>(new MyView());
+ ViewProxy proxy = new ViewProxy<>(new MyView(), userSession);
assertThat(proxy.isDefaultTab()).isTrue();
assertThat(proxy.getDefaultTabForMetrics()).isEmpty();
super("fake");
}
}
- ViewProxy proxy = new ViewProxy<MyView>(new MyView());
+ ViewProxy proxy = new ViewProxy<>(new MyView(), userSession);
assertThat(proxy.isDefaultTab()).isFalse();
assertThat(proxy.getDefaultTabForMetrics()).isEmpty();
super("fake");
}
}
- ViewProxy proxy = new ViewProxy<MyView>(new MyView());
+ ViewProxy proxy = new ViewProxy<>(new MyView(), userSession);
assertThat(proxy.isDefaultTab()).isFalse();
assertThat(proxy.getDefaultTabForMetrics()).isEqualTo(new String[] {"ncloc", "coverage"});
@Test
public void widget_should_be_editable() {
- ViewProxy<Widget> proxy = new ViewProxy<Widget>(new EditableWidget());
+ ViewProxy<Widget> proxy = new ViewProxy<Widget>(new EditableWidget(), userSession);
assertThat(proxy.isEditable()).isTrue();
assertThat(proxy.getWidgetProperties()).hasSize(3);
@Test
public void load_widget_properties_in_the_same_order_than_annotations() {
- ViewProxy<Widget> proxy = new ViewProxy<Widget>(new EditableWidget());
+ ViewProxy<Widget> proxy = new ViewProxy<Widget>(new EditableWidget(), userSession);
List<WidgetProperty> widgetProperties = Lists.newArrayList(proxy.getWidgetProperties());
assertThat(widgetProperties).hasSize(3);
@Test
public void widget_should_have_text_property() {
- ViewProxy<Widget> proxy = new ViewProxy<Widget>(new TextWidget());
+ ViewProxy<Widget> proxy = new ViewProxy<Widget>(new TextWidget(), userSession);
assertThat(getOnlyElement(proxy.getWidgetProperties()).type()).isEqualTo(WidgetPropertyType.TEXT);
}
@Test
public void widget_should_not_be_global_by_default() {
- ViewProxy<Widget> proxy = new ViewProxy<Widget>(new EditableWidget());
+ ViewProxy<Widget> proxy = new ViewProxy<Widget>(new EditableWidget(), userSession);
assertThat(proxy.isGlobal()).isFalse();
}
@Test
public void widget_should_be_global() {
- ViewProxy<Widget> proxy = new ViewProxy<Widget>(new GlobalWidget());
+ ViewProxy<Widget> proxy = new ViewProxy<Widget>(new GlobalWidget(), userSession);
assertThat(proxy.isGlobal()).isTrue();
}
exception.expectMessage("INVALID");
exception.expectMessage("WidgetWithInvalidScope");
- new ViewProxy<Widget>(new WidgetWithInvalidScope());
+ new ViewProxy<Widget>(new WidgetWithInvalidScope(), userSession);
}
@Test
public void widgetShouldRequireMandatoryProperties() {
- ViewProxy<Widget> proxy = new ViewProxy<Widget>(new EditableWidget());
+ ViewProxy<Widget> proxy = new ViewProxy<Widget>(new EditableWidget(), userSession);
assertThat(proxy.hasRequiredProperties()).isTrue();
}
@Test
public void widgetShouldDefineOnlyOptionalProperties() {
- ViewProxy<Widget> proxy = new ViewProxy<Widget>(new WidgetWithOptionalProperties());
+ ViewProxy<Widget> proxy = new ViewProxy<Widget>(new WidgetWithOptionalProperties(), userSession);
assertThat(proxy.hasRequiredProperties()).isFalse();
}
super("fake");
}
}
- ViewProxy proxy = new ViewProxy<MyView>(new MyView());
+ ViewProxy proxy = new ViewProxy<>(new MyView(), userSession);
assertThat(proxy.acceptsAvailableMeasures(new String[] {"lines", "ncloc", "coverage"})).isTrue();
}
super("fake");
}
}
- ViewProxy proxy = new ViewProxy<MyView>(new MyView());
+ ViewProxy proxy = new ViewProxy<>(new MyView(), userSession);
assertThat(proxy.acceptsAvailableMeasures(new String[] {"lines", "ncloc", "coverage"})).isTrue();
assertThat(proxy.acceptsAvailableMeasures(new String[] {"lines", "coverage"})).isFalse();
super("fake");
}
}
- ViewProxy proxy = new ViewProxy<MyView>(new MyView());
+ ViewProxy proxy = new ViewProxy<>(new MyView(), userSession);
assertThat(proxy.acceptsAvailableMeasures(new String[] {"lines", "coverage"})).isTrue();
assertThat(proxy.acceptsAvailableMeasures(new String[] {"complexity", "coverage"})).isFalse();
super("fake");
}
}
- ViewProxy proxy = new ViewProxy<MyView>(new MyView());
+ ViewProxy proxy = new ViewProxy<>(new MyView(), userSession);
// ok, mandatory measures and 1 needed measure
assertThat(proxy.acceptsAvailableMeasures(new String[] {"lines", "ncloc", "coverage", "duplications"})).isTrue();
}
}
- ViewProxy proxy = new ViewProxy<View>(new MyView());
+ ViewProxy proxy = new ViewProxy<>(new MyView(), userSession);
- MockUserSession.set();
assertThat(proxy.isUserAuthorized()).isTrue();
}
}
}
- ViewProxy proxy = new ViewProxy<View>(new MyView());
+ ViewProxy proxy = new ViewProxy<>(new MyView(), userSession);
- MockUserSession.set().setGlobalPermissions("palap");
+ userSession.setGlobalPermissions("palap");
assertThat(proxy.isUserAuthorized()).isTrue();
}
}
}
- ViewProxy proxy = new ViewProxy<View>(new MyView());
+ ViewProxy proxy = new ViewProxy<>(new MyView(), userSession);
- MockUserSession.set().setGlobalPermissions("pilip");
+ userSession.setGlobalPermissions("pilip");
assertThat(proxy.isUserAuthorized()).isFalse();
}
}
}
- ViewProxy proxy = new ViewProxy<View>(new MyView());
+ ViewProxy proxy = new ViewProxy<>(new MyView(), userSession);
- MockUserSession.set();
assertThat(proxy.isUserAuthorized(newProjectDto("abcd"))).isTrue();
}
}
}
- ViewProxy proxy = new ViewProxy<View>(new MyView());
+ ViewProxy proxy = new ViewProxy<>(new MyView(), userSession);
- MockUserSession.set().addProjectUuidPermissions("palap", "abcd");
+ userSession.addProjectUuidPermissions("palap", "abcd");
assertThat(proxy.isUserAuthorized(newProjectDto("abcd"))).isTrue();
}
}
}
- ViewProxy proxy = new ViewProxy<View>(new MyView());
+ ViewProxy proxy = new ViewProxy<>(new MyView(), userSession);
- MockUserSession.set().addProjectUuidPermissions("pilip", "abcd");
+ userSession.addProjectUuidPermissions("pilip", "abcd");
assertThat(proxy.isUserAuthorized(newProjectDto("abcd"))).isFalse();
}
}
*/
package org.sonar.server.ui;
+import java.util.List;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.resources.Java;
import org.sonar.api.resources.Qualifiers;
import org.sonar.api.web.Page;
import org.sonar.api.web.View;
import org.sonar.api.web.Widget;
-
-import java.util.List;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
public class ViewsTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
+
private static FakeResourceViewer FAKE_TAB = new FakeResourceViewer();
private static FakeWidget FAKE_WIDGET = new FakeWidget();
private static FakePage FAKE_PAGE = new FakePage();
@Test
public void should_get_page_by_id() {
- final Views views = new Views(VIEWS);
+ final Views views = new Views(userSessionRule, VIEWS);
assertThat(views.getPage("fake-page").getTarget().getClass()).isEqualTo(FakePage.class);
assertThat(views.getPage("fake-widget")).isNull();
assertThat(views.getPage("foo")).isNull();
@Test
public void should_get_pages_by_section() {
- final Views views = new Views(VIEWS);
+ final Views views = new Views(userSessionRule, VIEWS);
List<ViewProxy<Page>> pages = views.getPages(NavigationSection.RESOURCE);
assertThat(pages.size()).isEqualTo(1);
@Test
public void should_get_widgets() {
- final Views views = new Views(VIEWS);
+ final Views views = new Views(userSessionRule, VIEWS);
List<ViewProxy<Widget>> widgets = views.getWidgets(null, null, null, null);
assertThat(widgets.size()).isEqualTo(1);
assertThat(widgets.get(0).getTarget().getClass()).isEqualTo(FakeWidget.class);
@Test
public void should_sort_views_by_title() {
- final Views views = new Views(new View[] {new FakeWidget("ccc", "ccc"), new FakeWidget("aaa", "aaa"), new FakeWidget("bbb", "bbb")});
+ final Views views = new Views(userSessionRule, new View[] {new FakeWidget("ccc", "ccc"), new FakeWidget("aaa", "aaa"), new FakeWidget("bbb", "bbb")});
List<ViewProxy<Widget>> widgets = views.getWidgets(null, null, null, null);
assertThat(widgets.size()).isEqualTo(3);
assertThat(widgets.get(0).getId()).isEqualTo("aaa");
@Test
public void should_prefix_title_by_number_to_display_first() {
- final Views views = new Views(new View[] {new FakeWidget("other", "Other"), new FakeWidget("1id", "1widget"), new FakeWidget("2id", "2widget")});
+ final Views views = new Views(userSessionRule, new View[] {new FakeWidget("other", "Other"), new FakeWidget("1id", "1widget"), new FakeWidget("2id", "2widget")});
List<ViewProxy<Widget>> widgets = views.getWidgets(null, null, null, null);
assertThat(widgets.size()).isEqualTo(3);
assertThat(widgets.get(0).getId()).isEqualTo("1id");
*/
package org.sonar.server.ui.ws;
+import java.util.Date;
+import java.util.Locale;
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.measure.persistence.MeasureDao;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ui.Views;
-import org.sonar.server.user.MockUserSession;
import org.sonar.server.user.db.UserDao;
import org.sonar.server.ws.WsTester;
-import java.util.Date;
-import java.util.Locale;
-
import static org.mockito.Matchers.any;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@ClassRule
public static final DbTester dbTester = new DbTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
private DbSession session;
@Test(expected = IllegalArgumentException.class)
public void fail_on_missing_parameters() throws Exception {
- wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(null, null, null, null, null)));
+ wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(null, null, null, null, null, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").execute();
}
@Test(expected = NotFoundException.class)
public void fail_on_unexistent_key() throws Exception {
- wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, null, null, null, null)));
+ wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, null, null, null, null, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").setParam("componentKey", "polop").execute();
}
dbClient.componentDao().insert(session, ComponentTesting.newProjectDto("abcd").setKey("polop"));
session.commit();
- MockUserSession.set();
- wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, null, null, null, null)));
+ wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, null, null, null, null, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").setParam("componentKey", "polop").execute();
}
.setKey("polop").setName("Polop"));
session.commit();
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, "abcd");
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, "abcd");
wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, activeDashboardDao,
- new Views(), i18n, resourceTypes)));
+ new Views(userSessionRule), i18n, resourceTypes, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").setParam("componentKey", "polop").execute().assertJson(getClass(), "no_snapshot.json");
}
dbClient.propertiesDao().setProperty(new PropertyDto().setKey("favourite").setResourceId(project.getId()).setUserId((long) userId), session);
session.commit();
- MockUserSession.set().setLogin("obiwan").setUserId(userId).addProjectUuidPermissions(UserRole.USER, "abcd");
+ userSessionRule.logon("obiwan").setUserId(userId).addProjectUuidPermissions(UserRole.USER, "abcd");
wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, activeDashboardDao,
- new Views(), i18n, resourceTypes)));
+ new Views(userSessionRule), i18n, resourceTypes, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").setParam("componentKey", "polop").execute().assertJson(getClass(), "no_snapshot_user_favourite.json");
}
.setLast(true).setQualifier(project.qualifier()).setResourceId(project.getId()).setRootProjectId(project.getId()).setScope(project.scope()));
session.commit();
- MockUserSession.set().setLogin("obiwan").setUserId(userId).addProjectUuidPermissions(UserRole.USER, "abcd");
+ userSessionRule.logon("obiwan").setUserId(userId).addProjectUuidPermissions(UserRole.USER, "abcd");
wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, activeDashboardDao,
- new Views(), i18n, resourceTypes)));
+ new Views(userSessionRule), i18n, resourceTypes, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").setParam("componentKey", "polop").execute().assertJson(getClass(), "with_snapshot_and_connected_user.json");
}
activeDashboardDao.insert(new ActiveDashboardDto().setDashboardId(dashboard.getId()));
session.commit();
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, "abcd");
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, "abcd");
wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, activeDashboardDao,
- new Views(), i18n, resourceTypes)));
+ new Views(userSessionRule), i18n, resourceTypes, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").setParam("componentKey", "polop").execute().assertJson(getClass(), "with_dashboards.json");
}
activeDashboardDao.insert(new ActiveDashboardDto().setDashboardId(dashboard.getId()));
session.commit();
- MockUserSession.set().setLogin("obiwan").addProjectUuidPermissions(UserRole.USER, "abcd");
+ userSessionRule.logon("obiwan").addProjectUuidPermissions(UserRole.USER, "abcd");
wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, activeDashboardDao,
- new Views(), i18n, resourceTypes)));
+ new Views(userSessionRule), i18n, resourceTypes, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").setParam("componentKey", "polop").execute().assertJson(getClass(), "with_default_dashboards.json");
}
.setLast(true).setQualifier(project.qualifier()).setResourceId(project.getId()).setRootProjectId(project.getId()).setScope(project.scope()));
session.commit();
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, "abcd");
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, "abcd");
Views views = createViews();
wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, activeDashboardDao,
- views, i18n, resourceTypes)));
+ views, i18n, resourceTypes, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").setParam("componentKey", "polop").execute().assertJson(getClass(), "with_extensions.json");
}
.setLast(true).setQualifier(project.qualifier()).setResourceId(project.getId()).setRootProjectId(project.getId()).setScope(project.scope()));
session.commit();
- MockUserSession.set()
+ userSessionRule
.addProjectUuidPermissions(UserRole.USER, "abcd")
.addProjectUuidPermissions(UserRole.ADMIN, "abcd");
Views views = createViews();
wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, activeDashboardDao,
- views, i18n, resourceTypes)));
+ views, i18n, resourceTypes, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").setParam("componentKey", "polop").execute().assertJson(getClass(), "admin_with_extensions.json");
}
}
}
Page adminPage = new AdminPage();
- Views views = new Views(new Page[] {page1, page2, adminPage});
+ Views views = new Views(userSessionRule, new Page[] {page1, page2, adminPage});
return views;
}
.setKey("polop").setName("Polop").setLanguage(language));
session.commit();
- MockUserSession.set().setLogin("obiwan").setUserId(userId)
+ userSessionRule.logon("obiwan").setUserId(userId)
.addProjectUuidPermissions(UserRole.USER, "abcd")
.addProjectUuidPermissions(UserRole.ADMIN, "abcd");
Page page2 = new SecondPage();
wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, activeDashboardDao,
- new Views(new Page[] {page1, page2}), i18n, resourceTypes)));
+ new Views(userSessionRule, new Page[] {page1, page2}), i18n, resourceTypes, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").setParam("componentKey", "polop").execute().assertJson(getClass(), "with_admin_rights.json");
}
dbClient.componentDao().insert(session, project);
session.commit();
- MockUserSession.set().setLogin("obiwan").setUserId(userId)
+ userSessionRule.logon("obiwan").setUserId(userId)
.addProjectUuidPermissions(UserRole.USER, "abcd")
.addProjectUuidPermissions(UserRole.ADMIN, "abcd");
.thenReturn(projectResourceType);
wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, activeDashboardDao,
- new Views(), i18n, resourceTypes)));
+ new Views(userSessionRule), i18n, resourceTypes, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").setParam("componentKey", "polop").execute().assertJson(getClass(), "with_all_properties.json");
}
dbClient.componentDao().insert(session, project, module);
session.commit();
- MockUserSession.set().setLogin("obiwan").setUserId(userId)
+ userSessionRule.logon("obiwan").setUserId(userId)
.addProjectUuidPermissions(UserRole.USER, "abcd")
.addProjectUuidPermissions(UserRole.ADMIN, "abcd");
wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, activeDashboardDao,
- new Views(), i18n, resourceTypes)));
+ new Views(userSessionRule), i18n, resourceTypes, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").setParam("componentKey", "palap").execute().assertJson(getClass(), "on_module.json");
}
.setKey("polop").setName("Polop").setLanguage(language));
session.commit();
- MockUserSession.set().setLogin("obiwan").setUserId(userId)
+ userSessionRule.logon("obiwan").setUserId(userId)
.addProjectUuidPermissions(UserRole.USER, "abcd")
.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
Page page = new FirstPage();
wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, activeDashboardDao,
- new Views(new Page[] {page}), i18n, resourceTypes)));
+ new Views(userSessionRule, new Page[] {page}), i18n, resourceTypes, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").setParam("componentKey", "polop").execute().assertJson(getClass(), "quality_profile_admin.json");
}
session.commit();
- MockUserSession.set().addProjectUuidPermissions(UserRole.USER, "abcd");
+ userSessionRule.addProjectUuidPermissions(UserRole.USER, "abcd");
wsTester = new WsTester(new NavigationWs(new ComponentNavigationAction(dbClient, activeDashboardDao,
- new Views(), i18n, resourceTypes)));
+ new Views(userSessionRule), i18n, resourceTypes, userSessionRule)));
wsTester.newGetRequest("api/navigation", "component").setParam("componentKey", "palap:src/main/xoo/Source.xoo").execute().assertJson(getClass(), "breadcrumbs.json");
}
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.api.resources.ResourceType;
import org.sonar.core.persistence.DbTester;
import org.sonar.core.user.UserDto;
import org.sonar.server.db.DbClient;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ui.Views;
-import org.sonar.server.user.MockUserSession;
import org.sonar.server.user.db.UserDao;
import org.sonar.server.ws.WsTester;
@ClassRule
public static final DbTester dbTester = new DbTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
private DbSession session;
@Test
public void empty_call() throws Exception {
- wsTester = new WsTester(new NavigationWs(new GlobalNavigationAction(activeDashboardDao, new Views(), new Settings(), new ResourceTypes())));
-
- MockUserSession.set();
+ wsTester = new WsTester(new NavigationWs(new GlobalNavigationAction(activeDashboardDao, new Views(userSessionRule), new Settings(), new ResourceTypes(), userSessionRule)));
wsTester.newGetRequest("api/navigation", "global").execute().assertJson(getClass(), "empty.json");
}
.addRelations("PAL", "LAP")
.build()
});
- wsTester = new WsTester(new NavigationWs(new GlobalNavigationAction(activeDashboardDao, new Views(), new Settings(), resourceTypes)));
-
- MockUserSession.set();
+ wsTester = new WsTester(new NavigationWs(new GlobalNavigationAction(activeDashboardDao, new Views(userSessionRule), new Settings(), resourceTypes, userSessionRule)));
wsTester.newGetRequest("api/navigation", "global").execute().assertJson(getClass(), "with_qualifiers.json");
}
@Test
public void only_logo() throws Exception {
- wsTester = new WsTester(new NavigationWs(new GlobalNavigationAction(activeDashboardDao, new Views(),
+ wsTester = new WsTester(new NavigationWs(new GlobalNavigationAction(activeDashboardDao, new Views(userSessionRule),
new Settings()
.setProperty("sonar.lf.logoUrl", "http://some-server.tld/logo.png")
.setProperty("sonar.lf.logoWidthPx", "123"),
- new ResourceTypes())));
-
- MockUserSession.set();
+ new ResourceTypes(), userSessionRule)));
wsTester.newGetRequest("api/navigation", "global").execute().assertJson(getClass(), "only_logo.json");
}
public void nominal_call_for_anonymous() throws Exception {
nominalSetup();
- MockUserSession.set();
-
wsTester.newGetRequest("api/navigation", "global").execute().assertJson(getClass(), "anonymous.json");
}
public void nominal_call_for_user() throws Exception {
nominalSetup();
- MockUserSession.set().setLogin("obiwan");
+ userSessionRule.logon("obiwan");
wsTester.newGetRequest("api/navigation", "global").execute().assertJson(getClass(), "user.json");
}
public void nominal_call_for_admin() throws Exception {
nominalSetup();
- MockUserSession.set().setLogin("obiwan").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("obiwan").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
wsTester.newGetRequest("api/navigation", "global").execute().assertJson(getClass(), "admin.json");
}
public void nominal_call_for_user_without_configured_dashboards() throws Exception {
nominalSetup();
- MockUserSession.set().setLogin("anakin");
+ userSessionRule.logon("anakin");
wsTester.newGetRequest("api/navigation", "global").execute().assertJson(getClass(), "anonymous.json");
}
Settings settings = new Settings()
.setProperty("sonar.lf.logoUrl", "http://some-server.tld/logo.png")
.setProperty("sonar.lf.logoWidthPx", "123");
- wsTester = new WsTester(new NavigationWs(new GlobalNavigationAction(activeDashboardDao, createViews(), settings, new ResourceTypes())));
+ wsTester = new WsTester(new NavigationWs(new GlobalNavigationAction(activeDashboardDao, createViews(), settings, new ResourceTypes(), userSessionRule)));
}
private void createAndConfigureDashboardForUser() {
return "admin_page";
}
}
- return new Views(new View[] {page, controller, new AdminPage()});
+ return new Views(userSessionRule, new View[] {page, controller, new AdminPage()});
}
}
*/
package org.sonar.server.ui.ws;
+import java.util.Locale;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
import org.sonar.api.web.View;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.server.plugins.UpdateCenterClient;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ui.Views;
-import org.sonar.server.user.MockUserSession;
import org.sonar.server.ws.WsTester;
-import java.util.Locale;
-
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyString;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
public class SettingsNavigationActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
private WsTester wsTester;
@Test
public void empty() throws Exception {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
- wsTester = new WsTester(new NavigationWs(new SettingsNavigationAction(settings, new Views(), i18n)));
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ wsTester = new WsTester(new NavigationWs(new SettingsNavigationAction(settings, new Views(userSessionRule), i18n, userSessionRule)));
wsTester.newGetRequest("api/navigation", "settings").execute().assertJson(getClass(), "empty.json");
}
@Test
public void with_provisioning() throws Exception {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.PROVISIONING);
- wsTester = new WsTester(new NavigationWs(new SettingsNavigationAction(settings, new Views(), i18n)));
+ userSessionRule.setGlobalPermissions(GlobalPermissions.PROVISIONING);
+ wsTester = new WsTester(new NavigationWs(new SettingsNavigationAction(settings, new Views(userSessionRule), i18n, userSessionRule)));
wsTester.newGetRequest("api/navigation", "settings").execute().assertJson(getClass(), "with_provisioning.json");
}
@Test
public void with_views() throws Exception {
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
- wsTester = new WsTester(new NavigationWs(new SettingsNavigationAction(settings, createViews(), i18n)));
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ wsTester = new WsTester(new NavigationWs(new SettingsNavigationAction(settings, createViews(), i18n, userSessionRule)));
wsTester.newGetRequest("api/navigation", "settings").execute().assertJson(getClass(), "with_views.json");
}
@Test
public void with_update_center() throws Exception {
settings.setProperty(UpdateCenterClient.ACTIVATION_PROPERTY, true);
- MockUserSession.set().setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
- wsTester = new WsTester(new NavigationWs(new SettingsNavigationAction(settings, new Views(), i18n)));
+ userSessionRule.setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ wsTester = new WsTester(new NavigationWs(new SettingsNavigationAction(settings, new Views(userSessionRule), i18n, userSessionRule)));
wsTester.newGetRequest("api/navigation", "settings").execute().assertJson(getClass(), "with_update_center.json");
}
@Test
public void with_views_and_update_center_but_not_admin() throws Exception {
- MockUserSession.set();
settings.setProperty(UpdateCenterClient.ACTIVATION_PROPERTY, true);
- wsTester = new WsTester(new NavigationWs(new SettingsNavigationAction(settings, createViews(), i18n)));
+ wsTester = new WsTester(new NavigationWs(new SettingsNavigationAction(settings, createViews(), i18n, userSessionRule)));
wsTester.newGetRequest("api/navigation", "settings").execute().assertJson(getClass(), "empty.json");
}
Page page = new FirstPage();
Page controller = new SecondPage();
- return new Views(new View[] {page, controller});
+ return new Views(userSessionRule, new View[] {page, controller});
}
}
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.Maps;
+import java.util.Map;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.sonar.core.permission.GlobalPermissions;
import org.sonar.server.exceptions.BadRequestException;
import org.sonar.server.exceptions.ForbiddenException;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.user.index.UserIndex;
-import java.util.Map;
-
import static com.google.common.collect.Lists.newArrayList;
import static com.google.common.collect.Maps.newHashMap;
import static org.assertj.core.api.Assertions.assertThat;
@RunWith(MockitoJUnitRunner.class)
public class DefaultUserServiceTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
UserIndex userIndex = mock(UserIndex.class);
UserFinder finder = mock(UserFinder.class);
UserUpdater userUpdater = mock(UserUpdater.class);
- DefaultUserService service = new DefaultUserService(userIndex, userUpdater, finder);
+ DefaultUserService service = new DefaultUserService(userIndex, userUpdater, finder, userSessionRule);
@Rule
public ExpectedException thrown = ExpectedException.none();
@Test
public void self_deactivation_is_not_possible() {
try {
- MockUserSession.set().setLogin("simon").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("simon").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
service.deactivate("simon");
fail();
} catch (BadRequestException e) {
@Test
public void user_deactivation_requires_admin_permission() {
try {
- MockUserSession.set().setLogin("simon").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ userSessionRule.logon("simon").setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
service.deactivate("julien");
fail();
} catch (ForbiddenException e) {
@Test
public void deactivate_user() {
- MockUserSession.set().setLogin("simon").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("simon").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
service.deactivate("julien");
verify(userUpdater).deactivateUserByLogin("julien");
}
@Test
public void fail_to_deactivate_when_blank_login() {
- MockUserSession.set().setLogin("simon").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("simon").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
try {
service.deactivate("");
fail();
public class DoPrivilegedTest {
+ ThreadLocalUserSession threadLocalUserSession = new ThreadLocalUserSession();
+
@Test
public void should_allow_everything_in_privileged_block_only() {
- DoPrivileged.execute(new DoPrivileged.Task() {
+ DoPrivileged.execute(new DoPrivileged.Task(threadLocalUserSession) {
@Override
protected void doPrivileged() {
- UserSession userSession = UserSession.get();
+ UserSession userSession = threadLocalUserSession.get();
assertThat(userSession.isLoggedIn()).isFalse();
assertThat(userSession.hasGlobalPermission("any permission")).isTrue();
assertThat(userSession.hasProjectPermission("any permission", "any project")).isTrue();
}
});
- assertThat(UserSession.get().isLoggedIn()).isFalse();
+ assertThat(threadLocalUserSession.isLoggedIn()).isFalse();
}
@Test
public void should_lose_privileges_on_exception() {
try {
- DoPrivileged.execute(new DoPrivileged.Task() {
+ DoPrivileged.execute(new DoPrivileged.Task(threadLocalUserSession) {
@Override
protected void doPrivileged() {
- UserSession userSession = UserSession.get();
+ UserSession userSession = threadLocalUserSession.get();
assertThat(userSession.isLoggedIn()).isTrue();
assertThat(userSession.hasGlobalPermission("any permission")).isTrue();
assertThat(userSession.hasProjectPermission("any permission", "any project")).isTrue();
}
});
} catch(Throwable ignored) {
- assertThat(UserSession.get().isLoggedIn()).isFalse();
+ assertThat(threadLocalUserSession.isLoggedIn()).isFalse();
}
}
+++ /dev/null
-/*
- * SonarQube, open source software quality management tool.
- * Copyright (C) 2008-2014 SonarSource
- * mailto:contact AT sonarsource DOT com
- *
- * SonarQube is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * SonarQube is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.user;
-
-import com.google.common.collect.HashMultimap;
-import org.sonar.core.resource.ResourceDao;
-import org.sonar.core.user.AuthorizationDao;
-
-import javax.annotation.Nullable;
-
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Locale;
-
-import static com.google.common.collect.Lists.newArrayList;
-import static org.mockito.Mockito.mock;
-
-public class MockUserSession extends UserSession {
-
- private final AuthorizationDao authorizationDao;
-
- private final ResourceDao resourceDao;
-
- private MockUserSession() {
- globalPermissions = Collections.emptyList();
- projectKeyByPermission = HashMultimap.create();
- projectUuidByPermission = HashMultimap.create();
- authorizationDao = mock(AuthorizationDao.class);
- resourceDao = mock(ResourceDao.class);
- }
-
- public static MockUserSession set() {
- MockUserSession session = create();
- UserSession.set(session);
- return session;
- }
-
- public static MockUserSession create() {
- return new MockUserSession();
- }
-
- public MockUserSession setLocale(@Nullable Locale locale) {
- super.setLocale(locale);
- return this;
- }
-
- public MockUserSession setLogin(@Nullable String login) {
- super.setLogin(login);
- return this;
- }
-
- public MockUserSession setName(@Nullable String name) {
- super.setName(name);
- return this;
- }
-
- public MockUserSession setUserId(@Nullable Integer userId) {
- super.setUserId(userId);
- return this;
- }
-
- public MockUserSession setUserGroups(@Nullable String... userGroups) {
- super.setUserGroups(userGroups);
- return this;
- }
-
- public MockUserSession setGlobalPermissions(String... globalPermissions) {
- this.globalPermissions = Arrays.asList(globalPermissions);
- return this;
- }
-
- /**
- * Deprecated, please use {@link #addProjectUuidPermissions}
- */
- @Deprecated
- public MockUserSession addProjectPermissions(String projectPermission, String... projectKeys) {
- this.projectPermissions.add(projectPermission);
- this.projectKeyByPermission.putAll(projectPermission, newArrayList(projectKeys));
- return this;
- }
-
- public MockUserSession addProjectUuidPermissions(String projectPermission, String... projectUuids) {
- this.projectPermissions.add(projectPermission);
- this.projectUuidByPermission.putAll(projectPermission, newArrayList(projectUuids));
- return this;
- }
-
- /**
- * Deprecated, please use {@link #addComponentUuidPermission}
- */
- @Deprecated
- public MockUserSession addComponentPermission(String projectPermission, String projectKey, String componentKey) {
- this.projectKeyByComponentKey.put(componentKey, projectKey);
- addProjectPermissions(projectPermission, projectKey);
- return this;
- }
-
- public MockUserSession addComponentUuidPermission(String projectPermission, String projectUuid, String componentUuid) {
- this.projectUuidByComponentUuid.put(componentUuid, projectUuid);
- addProjectUuidPermissions(projectPermission, projectUuid);
- return this;
- }
-
- @Override
- AuthorizationDao authorizationDao() {
- return authorizationDao;
- }
-
- @Override
- ResourceDao resourceDao() {
- return resourceDao;
- }
-}
+++ /dev/null
-/*
- * SonarQube, open source software quality management tool.
- * Copyright (C) 2008-2014 SonarSource
- * mailto:contact AT sonarsource DOT com
- *
- * SonarQube is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * SonarQube is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.user;
-
-import org.junit.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-public class MockUserSessionTest {
- @Test
- public void set_mock_session() {
- MockUserSession.set().setLogin("simon").setUserGroups("sonar-users");
-
- UserSession mock = UserSession.get();
- assertThat(mock.login()).isEqualTo("simon");
- assertThat(mock.userGroups()).containsOnly("sonar-users", "Anyone");
- assertThat(mock.globalPermissions()).isEmpty();
- assertThat(mock.isLoggedIn()).isTrue();
- }
-}
*/
package org.sonar.server.user;
-import org.junit.Test;
-
import java.util.Locale;
+import org.junit.Before;
+import org.junit.Test;
+import org.sonar.core.platform.ComponentContainer;
+import org.sonar.server.platform.Platform;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
public class RubyUserSessionTest {
+ Platform platform = mock(Platform.class);
+ ComponentContainer componentContainer = mock(ComponentContainer.class);
+ ThreadLocalUserSession threadLocalUserSession = new ThreadLocalUserSession();
+ RubyUserSession underTest = new RubyUserSession(platform);
+
+ @Before
+ public void setUp() throws Exception {
+ when(platform.getContainer()).thenReturn(componentContainer);
+ when(componentContainer.getComponentByType(ThreadLocalUserSession.class)).thenReturn(threadLocalUserSession);
+ }
+
@Test
public void should_set_session() {
- RubyUserSession.setSession(123, "karadoc", "Karadoc", newArrayList("sonar-users"), "fr");
+ underTest.setSessionImpl(123, "karadoc", "Karadoc", newArrayList("sonar-users"), "fr");
- UserSession session = UserSession.get();
+ UserSession session = threadLocalUserSession.get();
assertThat(session).isNotNull();
assertThat(session.login()).isEqualTo("karadoc");
@Test
public void should_set_anonymous_session() {
- RubyUserSession.setSession(null, null, null, null, "fr");
+ underTest.setSessionImpl(null, null, null, null, "fr");
- UserSession session = UserSession.get();
+ UserSession session = threadLocalUserSession.get();
assertThat(session).isNotNull();
assertThat(session.login()).isNull();
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.user;
+
+import java.util.Arrays;
+import org.junit.Test;
+import org.sonar.api.web.UserRole;
+import org.sonar.core.component.ComponentDto;
+import org.sonar.core.permission.GlobalPermissions;
+import org.sonar.core.resource.ResourceDao;
+import org.sonar.core.resource.ResourceDto;
+import org.sonar.core.user.AuthorizationDao;
+import org.sonar.server.component.ComponentTesting;
+import org.sonar.server.exceptions.ForbiddenException;
+
+import static com.google.common.collect.Lists.newArrayList;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class ServerUserSessionTest {
+ AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
+ ResourceDao resourceDao = mock(ResourceDao.class);
+
+ @Test
+ public void login_should_not_be_empty() {
+ UserSession session = newServerUserSession().setLogin("");
+ assertThat(session.login()).isNull();
+ assertThat(session.isLoggedIn()).isFalse();
+ }
+
+ @Test
+ public void has_global_permission() {
+ UserSession session = newServerUserSession().setLogin("marius");
+
+ when(authorizationDao.selectGlobalPermissions("marius")).thenReturn(Arrays.asList("profileadmin", "admin"));
+
+ assertThat(session.hasGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN)).isTrue();
+ assertThat(session.hasGlobalPermission(GlobalPermissions.SYSTEM_ADMIN)).isTrue();
+ assertThat(session.hasGlobalPermission(GlobalPermissions.DASHBOARD_SHARING)).isFalse();
+ }
+
+ @Test
+ public void check_global_Permission_ok() {
+ UserSession session = newServerUserSession().setLogin("marius");
+
+ when(authorizationDao.selectGlobalPermissions("marius")).thenReturn(Arrays.asList("profileadmin", "admin"));
+
+ session.checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
+ }
+
+ @Test(expected = ForbiddenException.class)
+ public void check_global_Permission_ko() {
+ UserSession session = newServerUserSession().setLogin("marius");
+
+ when(authorizationDao.selectGlobalPermissions("marius")).thenReturn(Arrays.asList("profileadmin", "admin"));
+
+ session.checkGlobalPermission(GlobalPermissions.DASHBOARD_SHARING);
+ }
+
+ @Test
+ public void has_project_permission() {
+ UserSession session = newServerUserSession().setLogin("marius").setUserId(1);
+ when(authorizationDao.selectAuthorizedRootProjectsKeys(1, UserRole.USER)).thenReturn(newArrayList("com.foo:Bar"));
+
+ assertThat(session.hasProjectPermission(UserRole.USER, "com.foo:Bar")).isTrue();
+ assertThat(session.hasProjectPermission(UserRole.CODEVIEWER, "com.foo:Bar")).isFalse();
+ assertThat(session.hasProjectPermission(UserRole.ADMIN, "com.foo:Bar")).isFalse();
+ }
+
+ @Test
+ public void has_project_permission_by_uuid() {
+ UserSession session = newServerUserSession().setLogin("marius").setUserId(1);
+ when(authorizationDao.selectAuthorizedRootProjectsUuids(1, UserRole.USER)).thenReturn(newArrayList("ABCD"));
+
+ assertThat(session.hasProjectPermissionByUuid(UserRole.USER, "ABCD")).isTrue();
+ assertThat(session.hasProjectPermissionByUuid(UserRole.CODEVIEWER, "ABCD")).isFalse();
+ assertThat(session.hasProjectPermissionByUuid(UserRole.ADMIN, "ABCD")).isFalse();
+ }
+
+ @Test
+ public void check_project_permission_ok() {
+ UserSession session = newServerUserSession().setLogin("marius").setUserId(1);
+ when(authorizationDao.selectAuthorizedRootProjectsKeys(1, UserRole.USER)).thenReturn(newArrayList("com.foo:Bar"));
+
+ session.checkProjectPermission(UserRole.USER, "com.foo:Bar");
+ }
+
+ @Test(expected = ForbiddenException.class)
+ public void check_project_permission_ko() {
+ UserSession session = newServerUserSession().setLogin("marius").setUserId(1);
+ when(authorizationDao.selectAuthorizedRootProjectsKeys(1, UserRole.USER)).thenReturn(newArrayList("com.foo:Bar2"));
+
+ session.checkProjectPermission(UserRole.USER, "com.foo:Bar");
+ }
+
+ @Test
+ public void check_project_uuid_permission_ok() {
+ UserSession session = newServerUserSession().setLogin("marius").setUserId(1);
+
+ ComponentDto project = ComponentTesting.newProjectDto();
+ when(authorizationDao.selectAuthorizedRootProjectsUuids(1, UserRole.USER)).thenReturn(newArrayList(project.uuid()));
+
+ session.checkProjectUuidPermission(UserRole.USER, project.uuid());
+ }
+
+ @Test(expected = ForbiddenException.class)
+ public void check_project_uuid_permission_ko() {
+ UserSession session = newServerUserSession().setLogin("marius").setUserId(1);
+
+ ComponentDto project = ComponentTesting.newProjectDto();
+ when(authorizationDao.selectAuthorizedRootProjectsUuids(1, UserRole.USER)).thenReturn(newArrayList(project.uuid()));
+
+ session.checkProjectUuidPermission(UserRole.USER, "another project");
+ }
+
+ @Test
+ public void has_component_permission() {
+ UserSession session = newServerUserSession().setLogin("marius").setUserId(1);
+
+ String componentKey = "com.foo:Bar:BarFile.xoo";
+ when(resourceDao.getRootProjectByComponentKey(componentKey)).thenReturn(new ResourceDto().setKey(componentKey));
+ when(authorizationDao.selectAuthorizedRootProjectsKeys(1, UserRole.USER)).thenReturn(newArrayList(componentKey));
+
+ assertThat(session.hasComponentPermission(UserRole.USER, componentKey)).isTrue();
+ assertThat(session.hasComponentPermission(UserRole.CODEVIEWER, componentKey)).isFalse();
+ assertThat(session.hasComponentPermission(UserRole.ADMIN, componentKey)).isFalse();
+ }
+
+ @Test
+ public void check_component_key_permission_ok() {
+ UserSession session = newServerUserSession().setLogin("marius").setUserId(1);
+
+ when(resourceDao.getRootProjectByComponentKey("com.foo:Bar:BarFile.xoo")).thenReturn(new ResourceDto().setKey("com.foo:Bar"));
+ when(authorizationDao.selectAuthorizedRootProjectsKeys(1, UserRole.USER)).thenReturn(newArrayList("com.foo:Bar"));
+
+ session.checkComponentPermission(UserRole.USER, "com.foo:Bar:BarFile.xoo");
+ }
+
+ @Test(expected = ForbiddenException.class)
+ public void check_component_key_permission_ko() {
+ UserSession session = newServerUserSession().setLogin("marius").setUserId(1);
+
+ when(resourceDao.getRootProjectByComponentKey("com.foo:Bar:BarFile.xoo")).thenReturn(new ResourceDto().setKey("com.foo:Bar2"));
+ when(authorizationDao.selectAuthorizedRootProjectsKeys(1, UserRole.USER)).thenReturn(newArrayList("com.foo:Bar"));
+
+ session.checkComponentPermission(UserRole.USER, "com.foo:Bar:BarFile.xoo");
+ }
+
+ @Test
+ public void check_component_uuid_permission_ok() {
+ UserSession session = newServerUserSession().setLogin("marius").setUserId(1);
+
+ ComponentDto project = ComponentTesting.newProjectDto();
+ ComponentDto file = ComponentTesting.newFileDto(project, "file-uuid");
+ when(resourceDao.getResource("file-uuid")).thenReturn(new ResourceDto().setProjectUuid(project.uuid()));
+ when(authorizationDao.selectAuthorizedRootProjectsUuids(1, UserRole.USER)).thenReturn(newArrayList(project.uuid()));
+
+ session.checkComponentUuidPermission(UserRole.USER, file.uuid());
+ }
+
+ @Test(expected = ForbiddenException.class)
+ public void check_component_uuid_permission_ko() {
+ UserSession session = newServerUserSession().setLogin("marius").setUserId(1);
+
+ ComponentDto project = ComponentTesting.newProjectDto();
+ ComponentDto file = ComponentTesting.newFileDto(project, "file-uuid");
+ when(resourceDao.getResource("file-uuid")).thenReturn(new ResourceDto().setProjectUuid(project.uuid()));
+ when(authorizationDao.selectAuthorizedRootProjectsUuids(1, UserRole.USER)).thenReturn(newArrayList(project.uuid()));
+
+ session.checkComponentUuidPermission(UserRole.USER, "another-uuid");
+ }
+
+ @Test(expected = ForbiddenException.class)
+ public void check_component_key_permission_when_project_not_found() {
+ UserSession session = newServerUserSession().setLogin("marius").setUserId(1);
+
+ when(resourceDao.getRootProjectByComponentKey("com.foo:Bar:BarFile.xoo")).thenReturn(null);
+
+ session.checkComponentPermission(UserRole.USER, "com.foo:Bar:BarFile.xoo");
+ }
+
+ @Test(expected = ForbiddenException.class)
+ public void check_component_dto_permission_ko() {
+ UserSession session = newServerUserSession().setLogin("marius").setUserId(1);
+
+ ComponentDto project = ComponentTesting.newProjectDto();
+ when(authorizationDao.selectAuthorizedRootProjectsKeys(1, UserRole.USER)).thenReturn(newArrayList(project.uuid()));
+
+ session.checkComponentPermission(UserRole.USER, "another");
+ }
+
+ private ServerUserSession newServerUserSession() {
+ return new ServerUserSession(authorizationDao, resourceDao);
+ }
+
+}
--- /dev/null
+/*
+ * SonarQube, open source software quality management tool.
+ * Copyright (C) 2008-2014 SonarSource
+ * mailto:contact AT sonarsource DOT com
+ *
+ * SonarQube is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * SonarQube is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+ */
+package org.sonar.server.user;
+
+import java.util.Locale;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.sonar.server.tester.MockUserSession;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class ThreadLocalUserSessionTest {
+
+ ThreadLocalUserSession threadLocalUserSession = new ThreadLocalUserSession();
+ @org.junit.Rule
+ public ExpectedException thrown = ExpectedException.none();
+
+ @Before
+ public void setUp() throws Exception {
+ threadLocalUserSession.remove();
+ }
+
+ @Test
+ public void getSession_get_anonymous_by_default() throws Exception {
+ UserSession session = threadLocalUserSession.get();
+
+ assertThat(session).isNotNull();
+ assertThat(session.login()).isNull();
+ assertThat(session.userId()).isNull();
+ assertThat(session.isLoggedIn()).isFalse();
+ // default locale
+ assertThat(session.locale()).isEqualTo(Locale.ENGLISH);
+ }
+
+ @Test
+ public void get_session() throws Exception {
+ threadLocalUserSession.set(new MockUserSession("karadoc").setUserId(123).setLocale(Locale.FRENCH));
+
+ UserSession session = threadLocalUserSession.get();
+ assertThat(session).isNotNull();
+ assertThat(session.userId()).isEqualTo(123);
+ assertThat(session.login()).isEqualTo("karadoc");
+ assertThat(session.isLoggedIn()).isTrue();
+ assertThat(session.locale()).isEqualTo(Locale.FRENCH);
+ }
+
+}
*/
package org.sonar.server.user;
-import org.junit.Before;
-import org.junit.Test;
-
+import java.io.IOException;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
+import javax.servlet.ServletException;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.sonar.core.platform.ComponentContainer;
+import org.sonar.server.platform.Platform;
+import org.sonar.server.tester.MockUserSession;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
public class UserSessionFilterTest {
+ private ThreadLocalUserSession threadLocalUserSession = new ThreadLocalUserSession();
+ private Platform platform = mock(Platform.class);
+ private ComponentContainer componentContainer = mock(ComponentContainer.class);
@Before
public void setUp() {
+ when(platform.getContainer()).thenReturn(componentContainer);
+ when(componentContainer.getComponentByType(ThreadLocalUserSession.class)).thenReturn(threadLocalUserSession);
// for test isolation
- UserSession.remove();
+ threadLocalUserSession.remove();
+ }
+
+ @After
+ public void tearDown() throws Exception {
+ threadLocalUserSession.remove();
}
@Test
- public void should_cleanup_user_session_after_request_handling() throws Exception {
+ public void should_cleanup_user_session_after_request_handling() throws IOException, ServletException {
HttpServletRequest httpRequest = mock(HttpServletRequest.class);
ServletResponse httpResponse = mock(ServletResponse.class);
FilterChain chain = mock(FilterChain.class);
- MockUserSession.set().setUserId(123).setLogin("karadoc");
- assertThat(UserSession.hasSession()).isTrue();
- UserSessionFilter filter = new UserSessionFilter();
+ threadLocalUserSession.set(new MockUserSession("karadoc").setUserId(123));
+ assertThat(threadLocalUserSession.hasSession()).isTrue();
+ UserSessionFilter filter = new UserSessionFilter(platform);
filter.doFilter(httpRequest, httpResponse, chain);
verify(chain).doFilter(httpRequest, httpResponse);
- assertThat(UserSession.hasSession()).isFalse();
+ assertThat(threadLocalUserSession.hasSession()).isFalse();
}
@Test
- public void just_for_fun_and_coverage() throws Exception {
- UserSessionFilter filter = new UserSessionFilter();
+ public void just_for_fun_and_coverage() throws ServletException {
+ UserSessionFilter filter = new UserSessionFilter(platform);
filter.init(mock(FilterConfig.class));
filter.destroy();
// do not fail
+++ /dev/null
-/*
- * SonarQube, open source software quality management tool.
- * Copyright (C) 2008-2014 SonarSource
- * mailto:contact AT sonarsource DOT com
- *
- * SonarQube is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * SonarQube is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.user;
-
-import org.junit.Test;
-import org.junit.rules.ExpectedException;
-import org.sonar.api.web.UserRole;
-import org.sonar.core.component.ComponentDto;
-import org.sonar.core.permission.GlobalPermissions;
-import org.sonar.core.resource.ResourceDao;
-import org.sonar.core.resource.ResourceDto;
-import org.sonar.core.user.AuthorizationDao;
-import org.sonar.server.component.ComponentTesting;
-import org.sonar.server.exceptions.ForbiddenException;
-
-import javax.annotation.Nullable;
-import java.util.Arrays;
-import java.util.Locale;
-
-import static com.google.common.collect.Lists.newArrayList;
-import static org.assertj.core.api.Assertions.assertThat;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.when;
-
-public class UserSessionTest {
-
- @org.junit.Rule
- public ExpectedException thrown = ExpectedException.none();
-
- @Test
- public void getSession_get_anonymous_by_default() {
- UserSession.remove();
-
- UserSession session = UserSession.get();
-
- assertThat(session).isNotNull();
- assertThat(session.login()).isNull();
- assertThat(session.userId()).isNull();
- assertThat(session.isLoggedIn()).isFalse();
- // default locale
- assertThat(session.locale()).isEqualTo(Locale.ENGLISH);
- }
-
- @Test
- public void get_session() {
- UserSession.set(new UserSession().setUserId(123).setLogin("karadoc").setLocale(Locale.FRENCH));
-
- UserSession session = UserSession.get();
- assertThat(session).isNotNull();
- assertThat(session.userId()).isEqualTo(123);
- assertThat(session.login()).isEqualTo("karadoc");
- assertThat(session.isLoggedIn()).isTrue();
- assertThat(session.locale()).isEqualTo(Locale.FRENCH);
- }
-
- @Test
- public void login_should_not_be_empty() {
- UserSession session = new UserSession().setLogin("");
- assertThat(session.login()).isNull();
- assertThat(session.isLoggedIn()).isFalse();
- }
-
- @Test
- public void has_global_permission() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao);
-
- when(authorizationDao.selectGlobalPermissions("marius")).thenReturn(Arrays.asList("profileadmin", "admin"));
-
- assertThat(session.hasGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN)).isTrue();
- assertThat(session.hasGlobalPermission(GlobalPermissions.SYSTEM_ADMIN)).isTrue();
- assertThat(session.hasGlobalPermission(GlobalPermissions.DASHBOARD_SHARING)).isFalse();
- }
-
- @Test
- public void check_global_Permission_ok() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao);
-
- when(authorizationDao.selectGlobalPermissions("marius")).thenReturn(Arrays.asList("profileadmin", "admin"));
-
- session.checkGlobalPermission(GlobalPermissions.QUALITY_PROFILE_ADMIN);
- }
-
- @Test(expected = ForbiddenException.class)
- public void check_global_Permission_ko() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao);
-
- when(authorizationDao.selectGlobalPermissions("marius")).thenReturn(Arrays.asList("profileadmin", "admin"));
-
- session.checkGlobalPermission(GlobalPermissions.DASHBOARD_SHARING);
- }
-
- @Test
- public void has_project_permission() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao).setUserId(1);
- when(authorizationDao.selectAuthorizedRootProjectsKeys(1, UserRole.USER)).thenReturn(newArrayList("com.foo:Bar"));
-
- assertThat(session.hasProjectPermission(UserRole.USER, "com.foo:Bar")).isTrue();
- assertThat(session.hasProjectPermission(UserRole.CODEVIEWER, "com.foo:Bar")).isFalse();
- assertThat(session.hasProjectPermission(UserRole.ADMIN, "com.foo:Bar")).isFalse();
- }
-
- @Test
- public void has_project_permission_by_uuid() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao).setUserId(1);
- when(authorizationDao.selectAuthorizedRootProjectsUuids(1, UserRole.USER)).thenReturn(newArrayList("ABCD"));
-
- assertThat(session.hasProjectPermissionByUuid(UserRole.USER, "ABCD")).isTrue();
- assertThat(session.hasProjectPermissionByUuid(UserRole.CODEVIEWER, "ABCD")).isFalse();
- assertThat(session.hasProjectPermissionByUuid(UserRole.ADMIN, "ABCD")).isFalse();
- }
-
- @Test
- public void check_project_permission_ok() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao).setUserId(1);
- when(authorizationDao.selectAuthorizedRootProjectsKeys(1, UserRole.USER)).thenReturn(newArrayList("com.foo:Bar"));
-
- session.checkProjectPermission(UserRole.USER, "com.foo:Bar");
- }
-
- @Test(expected = ForbiddenException.class)
- public void check_project_permission_ko() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao).setUserId(1);
- when(authorizationDao.selectAuthorizedRootProjectsKeys(1, UserRole.USER)).thenReturn(newArrayList("com.foo:Bar2"));
-
- session.checkProjectPermission(UserRole.USER, "com.foo:Bar");
- }
-
- @Test
- public void check_project_uuid_permission_ok() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao).setUserId(1);
-
- ComponentDto project = ComponentTesting.newProjectDto();
- when(authorizationDao.selectAuthorizedRootProjectsUuids(1, UserRole.USER)).thenReturn(newArrayList(project.uuid()));
-
- session.checkProjectUuidPermission(UserRole.USER, project.uuid());
- }
-
- @Test(expected = ForbiddenException.class)
- public void check_project_uuid_permission_ko() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao).setUserId(1);
-
- ComponentDto project = ComponentTesting.newProjectDto();
- when(authorizationDao.selectAuthorizedRootProjectsUuids(1, UserRole.USER)).thenReturn(newArrayList(project.uuid()));
-
- session.checkProjectUuidPermission(UserRole.USER, "another project");
- }
-
- @Test
- public void has_component_permission() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- ResourceDao resourceDao = mock(ResourceDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao, resourceDao).setUserId(1);
-
- String componentKey = "com.foo:Bar:BarFile.xoo";
- when(resourceDao.getRootProjectByComponentKey(componentKey)).thenReturn(new ResourceDto().setKey(componentKey));
- when(authorizationDao.selectAuthorizedRootProjectsKeys(1, UserRole.USER)).thenReturn(newArrayList(componentKey));
-
- assertThat(session.hasComponentPermission(UserRole.USER, componentKey)).isTrue();
- assertThat(session.hasComponentPermission(UserRole.CODEVIEWER, componentKey)).isFalse();
- assertThat(session.hasComponentPermission(UserRole.ADMIN, componentKey)).isFalse();
- }
-
- @Test
- public void check_component_key_permission_ok() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- ResourceDao resourceDao = mock(ResourceDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao, resourceDao).setUserId(1);
-
- when(resourceDao.getRootProjectByComponentKey("com.foo:Bar:BarFile.xoo")).thenReturn(new ResourceDto().setKey("com.foo:Bar"));
- when(authorizationDao.selectAuthorizedRootProjectsKeys(1, UserRole.USER)).thenReturn(newArrayList("com.foo:Bar"));
-
- session.checkComponentPermission(UserRole.USER, "com.foo:Bar:BarFile.xoo");
- }
-
- @Test(expected = ForbiddenException.class)
- public void check_component_key_permission_ko() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- ResourceDao resourceDao = mock(ResourceDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao, resourceDao).setUserId(1);
-
- when(resourceDao.getRootProjectByComponentKey("com.foo:Bar:BarFile.xoo")).thenReturn(new ResourceDto().setKey("com.foo:Bar2"));
- when(authorizationDao.selectAuthorizedRootProjectsKeys(1, UserRole.USER)).thenReturn(newArrayList("com.foo:Bar"));
-
- session.checkComponentPermission(UserRole.USER, "com.foo:Bar:BarFile.xoo");
- }
-
- @Test
- public void check_component_uuid_permission_ok() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- ResourceDao resourceDao = mock(ResourceDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao,resourceDao).setUserId(1);
-
- ComponentDto project = ComponentTesting.newProjectDto();
- ComponentDto file = ComponentTesting.newFileDto(project, "file-uuid");
- when(resourceDao.getResource("file-uuid")).thenReturn(new ResourceDto().setProjectUuid(project.uuid()));
- when(authorizationDao.selectAuthorizedRootProjectsUuids(1, UserRole.USER)).thenReturn(newArrayList(project.uuid()));
-
- session.checkComponentUuidPermission(UserRole.USER, file.uuid());
- }
-
- @Test(expected = ForbiddenException.class)
- public void check_component_uuid_permission_ko() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- ResourceDao resourceDao = mock(ResourceDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao,resourceDao).setUserId(1);
-
- ComponentDto project = ComponentTesting.newProjectDto();
- ComponentDto file = ComponentTesting.newFileDto(project, "file-uuid");
- when(resourceDao.getResource("file-uuid")).thenReturn(new ResourceDto().setProjectUuid(project.uuid()));
- when(authorizationDao.selectAuthorizedRootProjectsUuids(1, UserRole.USER)).thenReturn(newArrayList(project.uuid()));
-
- session.checkComponentUuidPermission(UserRole.USER, "another-uuid");
- }
-
- @Test(expected = ForbiddenException.class)
- public void check_component_key_permission_when_project_not_found() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- ResourceDao resourceDao = mock(ResourceDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao, resourceDao).setUserId(1);
-
- when(resourceDao.getRootProjectByComponentKey("com.foo:Bar:BarFile.xoo")).thenReturn(null);
-
- session.checkComponentPermission(UserRole.USER, "com.foo:Bar:BarFile.xoo");
- }
-
- @Test(expected = ForbiddenException.class)
- public void check_component_dto_permission_ko() {
- AuthorizationDao authorizationDao = mock(AuthorizationDao.class);
- ResourceDao resourceDao = mock(ResourceDao.class);
- UserSession session = new SpyUserSession("marius", authorizationDao, resourceDao).setUserId(1);
-
- ComponentDto project = ComponentTesting.newProjectDto();
- when(authorizationDao.selectAuthorizedRootProjectsKeys(1, UserRole.USER)).thenReturn(newArrayList(project.uuid()));
-
- session.checkComponentPermission(UserRole.USER, "another");
- }
-
- static class SpyUserSession extends UserSession {
- private AuthorizationDao authorizationDao;
- private ResourceDao resourceDao;
-
- SpyUserSession(String login, AuthorizationDao authorizationDao) {
- this(login, authorizationDao, null);
- }
-
- SpyUserSession(String login, AuthorizationDao authorizationDao, @Nullable ResourceDao resourceDao) {
- this.authorizationDao = authorizationDao;
- this.resourceDao = resourceDao;
- setLogin(login);
- }
-
- @Override
- AuthorizationDao authorizationDao() {
- return authorizationDao;
- }
-
- @Override
- ResourceDao resourceDao() {
- return resourceDao;
- }
-
- }
-}
+++ /dev/null
-/*
- * SonarQube, open source software quality management tool.
- * Copyright (C) 2008-2014 SonarSource
- * mailto:contact AT sonarsource DOT com
- *
- * SonarQube is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 3 of the License, or (at your option) any later version.
- *
- * SonarQube is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
- */
-package org.sonar.server.user;
-
-public class UserSessionTestUtils {
-
- private UserSessionTestUtils() {
- // Utility class
- }
-
- public static void setUserSession(UserSession session) {
- UserSession.set(session);
- }
-}
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.es.EsTester;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.NotFoundException;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.user.NewUserNotifier;
import org.sonar.server.user.UserUpdater;
import org.sonar.server.user.db.GroupDao;
@ClassRule
public static final EsTester esTester = new EsTester().addDefinitions(new UserIndexDefinition(settings));
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone().logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
WebService.Controller controller;
userIndexer = (UserIndexer) new UserIndexer(dbClient, esTester.client()).setEnabled(true);
index = new UserIndex(esTester.client());
- tester = new WsTester(new UsersWs(new ChangePasswordAction(new UserUpdater(mock(NewUserNotifier.class), settings, dbClient, userIndexer, system2))));
+ tester = new WsTester(new UsersWs(new ChangePasswordAction(new UserUpdater(mock(NewUserNotifier.class), settings, dbClient, userIndexer, system2), userSessionRule)));
controller = tester.controller("api/users");
-
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
}
@After
public void fail_on_missing_permission() throws Exception {
createUser();
- MockUserSession.set().setLogin("polop");
+ userSessionRule.logon("polop");
tester.newPostRequest("api/users", "change_password")
.setParam("login", "john")
.execute();
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.sonar.server.db.DbClient;
import org.sonar.server.es.EsTester;
import org.sonar.server.exceptions.ForbiddenException;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.user.NewUserNotifier;
import org.sonar.server.user.UserUpdater;
import org.sonar.server.user.db.GroupDao;
@ClassRule
public static final EsTester esTester = new EsTester().addDefinitions(new UserIndexDefinition(settings));
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
WebService.Controller controller;
index = new UserIndex(esTester.client());
tester = new WsTester(new UsersWs(new CreateAction(index,
new UserUpdater(mock(NewUserNotifier.class), settings, dbClient, userIndexer, system2),
- i18n)));
+ i18n, userSessionRule)));
controller = tester.controller("api/users");
}
@Test
public void create_user() throws Exception {
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
tester.newPostRequest("api/users", "create")
.setParam("login", "john")
@Test
public void reactivate_user() throws Exception {
- MockUserSession.set().setLogin("admin").setLocale(Locale.FRENCH).setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("admin").setLocale(Locale.FRENCH).setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
dbClient.userDao().insert(session, new UserDto()
.setEmail("john@email.com")
@Test(expected = ForbiddenException.class)
public void fail_on_missing_permission() throws Exception {
- MockUserSession.set().setLogin("not_admin");
+ userSessionRule.logon("not_admin");
tester.newPostRequest("api/users", "create")
.setParam("login", "john")
package org.sonar.server.user.ws;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.core.permission.GlobalPermissions;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.ws.WsTester;
public class CurrentUserActionTest {
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
private WsTester tester;
@Before
public void before() {
- tester = new WsTester(new UsersWs(new CurrentUserAction()));
+ tester = new WsTester(new UsersWs(new CurrentUserAction(userSessionRule)));
}
@Test
public void anonymous() throws Exception {
- MockUserSession.set();
tester.newGetRequest("api/users", "current").execute().assertJson(getClass(), "anonymous.json");
}
@Test
public void authenticated() throws Exception {
- MockUserSession.set().setLogin("obiwan.kenobi").setName("Obiwan Kenobi")
+ userSessionRule.logon("obiwan.kenobi").setName("Obiwan Kenobi")
.setGlobalPermissions(GlobalPermissions.ALL.toArray(new String[0]));
tester.newGetRequest("api/users", "current").execute().assertJson(getClass(), "authenticated.json");
}
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.sonar.server.es.EsTester;
import org.sonar.server.exceptions.ForbiddenException;
import org.sonar.server.exceptions.NotFoundException;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.user.NewUserNotifier;
import org.sonar.server.user.UserUpdater;
import org.sonar.server.user.db.UserDao;
@ClassRule
public static final DbTester dbTester = new DbTester();
-
@ClassRule
public static final EsTester esTester = new EsTester().addDefinitions(new UserIndexDefinition(settings));
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
WebService.Controller controller;
userIndexer = (UserIndexer) new UserIndexer(dbClient, esTester.client()).setEnabled(true);
index = new UserIndex(esTester.client());
tester = new WsTester(new UsersWs(new DeactivateAction(index,
- new UserUpdater(mock(NewUserNotifier.class), settings, dbClient, userIndexer, system2))));
+ new UserUpdater(mock(NewUserNotifier.class), settings, dbClient, userIndexer, system2), userSessionRule)));
controller = tester.controller("api/users");
}
public void deactivate_user() throws Exception {
createUser();
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
tester.newPostRequest("api/users", "deactivate")
.setParam("login", "john")
.execute()
public void fail_on_missing_permission() throws Exception {
createUser();
- MockUserSession.set().setLogin("not_admin");
+ userSessionRule.logon("not_admin");
tester.newPostRequest("api/users", "deactivate")
.setParam("login", "john").execute();
}
@Test(expected = NotFoundException.class)
public void fail_on_unknown_user() throws Exception {
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
tester.newPostRequest("api/users", "deactivate")
.setParam("login", "john").execute();
}
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.config.Settings;
import org.sonar.api.server.ws.WebService;
import org.sonar.server.db.DbClient;
import org.sonar.server.es.EsTester;
import org.sonar.server.exceptions.ForbiddenException;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.user.NewUserNotifier;
import org.sonar.server.user.UserUpdater;
import org.sonar.server.user.db.GroupDao;
@ClassRule
public static final DbTester dbTester = new DbTester();
-
@ClassRule
public static final EsTester esTester = new EsTester().addDefinitions(new UserIndexDefinition(settings));
+ @Rule
+ public final UserSessionRule userSessionRule = UserSessionRule.standalone().logon("admin")
+ .setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
WebService.Controller controller;
userIndexer = (UserIndexer) new UserIndexer(dbClient, esTester.client()).setEnabled(true);
index = new UserIndex(esTester.client());
tester = new WsTester(new UsersWs(new UpdateAction(index,
- new UserUpdater(mock(NewUserNotifier.class), settings, dbClient, userIndexer, system2))));
+ new UserUpdater(mock(NewUserNotifier.class), settings, dbClient, userIndexer, system2), userSessionRule)));
controller = tester.controller("api/users");
-
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
}
@After
public void fail_on_missing_permission() throws Exception {
createUser();
- MockUserSession.set().setLogin("polop");
+ userSessionRule.logon("polop");
tester.newPostRequest("api/users", "update")
.setParam("login", "john")
.execute();
package org.sonar.server.user.ws;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.i18n.I18n;
import org.sonar.api.server.ws.RailsHandler;
import org.sonar.api.server.ws.WebService;
+import org.sonar.server.tester.UserSessionRule;
import org.sonar.server.user.UserUpdater;
import org.sonar.server.user.index.UserIndex;
import org.sonar.server.ws.WsTester;
import static org.mockito.Mockito.mock;
public class UsersWsTest {
-
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
WebService.Controller controller;
@Before
public void setUp() {
WsTester tester = new WsTester(new UsersWs(
- new CreateAction(mock(UserIndex.class), mock(UserUpdater.class), mock(I18n.class)),
- new UpdateAction(mock(UserIndex.class), mock(UserUpdater.class)),
- new CurrentUserAction(),
- new DeactivateAction(mock(UserIndex.class), mock(UserUpdater.class)),
- new ChangePasswordAction(mock(UserUpdater.class))));
+ new CreateAction(mock(UserIndex.class), mock(UserUpdater.class), mock(I18n.class), userSessionRule),
+ new UpdateAction(mock(UserIndex.class), mock(UserUpdater.class), userSessionRule),
+ new CurrentUserAction(userSessionRule),
+ new DeactivateAction(mock(UserIndex.class), mock(UserUpdater.class), userSessionRule),
+ new ChangePasswordAction(mock(UserUpdater.class), userSessionRule)));
controller = tester.controller("api/users");
}
import org.junit.After;
import org.junit.Before;
import org.junit.ClassRule;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.security.DefaultGroups;
import org.sonar.api.web.UserRole;
import org.sonar.server.rule.RuleTesting;
import org.sonar.server.rule.db.RuleDao;
import org.sonar.server.tester.ServerTester;
-import org.sonar.server.user.MockUserSession;
+import org.sonar.server.tester.UserSessionRule;
import static com.google.common.collect.Lists.newArrayList;
import static org.assertj.core.api.Assertions.assertThat;
@ClassRule
public static ServerTester tester = new ServerTester();
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.forServerTester(tester);
DbSession dbSession;
indexer.index(viewUuid);
// Execute issue query on view -> 1 issue on view
- SearchResult<IssueDoc> docs = tester.get(IssueIndex.class).search(IssueQuery.builder().viewUuids(newArrayList(viewUuid)).build(),
+ SearchResult<IssueDoc> docs = tester.get(IssueIndex.class).search(IssueQuery.builder(userSessionRule).viewUuids(newArrayList(viewUuid)).build(),
new SearchOptions());
assertThat(docs.getDocs()).hasSize(1);
indexer.index(viewUuid);
// Execute issue query on view -> issue of project2 are well taken into account : the cache has been cleared
- assertThat(tester.get(IssueIndex.class).search(IssueQuery.builder().viewUuids(newArrayList(viewUuid)).build(), new SearchOptions()).getDocs()).hasSize(2);
+ assertThat(tester.get(IssueIndex.class).search(IssueQuery.builder(userSessionRule).viewUuids(newArrayList(viewUuid)).build(), new SearchOptions()).getDocs()).hasSize(2);
}
private ComponentDto addProjectWithIssue(RuleDto rule) {
private void setDefaultProjectPermission(ComponentDto project) {
// project can be seen by anyone and by code viewer
- MockUserSession.set().setLogin("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
+ userSessionRule.logon("admin").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
tester.get(InternalPermissionService.class).addPermission(new PermissionChange().setComponentKey(project.getKey()).setGroup(DefaultGroups.ANYONE).setPermission(UserRole.USER));
- MockUserSession.set();
}
}
package org.sonar.server.ws;
import com.google.common.collect.Maps;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Locale;
+import java.util.Map;
+import javax.annotation.Nullable;
import org.apache.commons.io.IOUtils;
import org.junit.After;
import org.junit.Before;
+import org.junit.Rule;
import org.junit.Test;
import org.sonar.api.i18n.I18n;
import org.sonar.api.server.ws.Request;
import org.sonar.server.exceptions.Errors;
import org.sonar.server.exceptions.Message;
import org.sonar.server.plugins.MimeTypes;
-import org.sonar.server.user.MockUserSession;
-
-import javax.annotation.Nullable;
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.util.Locale;
-import java.util.Map;
+import org.sonar.server.tester.UserSessionRule;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
}
+ @Rule
+ public UserSessionRule userSessionRule = UserSessionRule.standalone();
I18n i18n = mock(I18n.class);
- WebServiceEngine engine = new WebServiceEngine(new WebService[] {new SystemWebService()}, i18n);
+ WebServiceEngine engine = new WebServiceEngine(new WebService[] {new SystemWebService()}, i18n, userSessionRule);
@Before
public void start() {
@Test
public void bad_request_with_i18n_message() {
- MockUserSession.set().setLocale(Locale.ENGLISH);
+ userSessionRule.setLocale(Locale.ENGLISH);
ValidatingRequest request = new SimpleRequest("GET").setParam("count", "3");
ServletResponse response = new ServletResponse();
when(i18n.message(Locale.ENGLISH, "bad.request.reason", "bad.request.reason", 0)).thenReturn("reason #0");
@Test
public void bad_request_with_multiple_i18n_messages() {
- MockUserSession.set().setLocale(Locale.ENGLISH);
+ userSessionRule.setLocale(Locale.ENGLISH);
ValidatingRequest request = new SimpleRequest("GET").setParam("count", "3");
ServletResponse response = new ServletResponse();
projects / sonarqube.git / commitdiff