@Test
public void deactivate_user() throws Exception {
MockUserSession.set().setLogin("simon").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
service.deactivate("julien");
verify(dao).deactivateUserByLogin("julien");
verify(userService).index();
}
@Test
public void search_qprofile_activity_with_rule_not_found() throws InterruptedException {
MockUserSession.set()
.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
.setLogin("me");
RuleKey ruleKey = RuleKey.of("xoo", "deleted_rule");
tester
.get(ActivityService.class)
.write(
dbSession,
Activity.Type.QPROFILE,
ActiveRuleChange.createFor(
ActiveRuleChange.Type.ACTIVATED, ActiveRuleKey.of(XOO_P1_KEY, ruleKey))
.setSeverity(Severity.MAJOR)
.setParameter("max", "10"));
dbSession.commit();
Result<QProfileActivity> activities =
service.searchActivities(new QProfileActivityQuery(), new QueryContext());
assertThat(activities.getHits()).hasSize(1);
QProfileActivity activity = activities.getHits().get(0);
assertThat(activity.ruleKey()).isEqualTo(ruleKey);
assertThat(activity.ruleName()).isNull();
}
@Test
public void stat_for_all_profiles() {
MockUserSession.set()
.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
.setLogin("me");
service.activate(XOO_P1_KEY, new RuleActivation(RuleTesting.XOO_X1).setSeverity("MINOR"));
service.activate(XOO_P2_KEY, new RuleActivation(RuleTesting.XOO_X1).setSeverity("BLOCKER"));
dbSession.clearCache();
Map<String, Multimap<String, FacetValue>> stats = loader.getAllProfileStats();
assertThat(stats.size()).isEqualTo(2);
assertThat(stats.get(XOO_P1_KEY).size()).isEqualTo(3);
assertThat(
stats.get(XOO_P1_KEY).get(ActiveRuleNormalizer.ActiveRuleField.SEVERITY.field()).size())
.isEqualTo(1);
assertThat(
stats
.get(XOO_P1_KEY)
.get(ActiveRuleNormalizer.ActiveRuleField.INHERITANCE.field())
.size())
.isEqualTo(1);
assertThat(stats.get(XOO_P1_KEY).get("countActiveRules").size()).isEqualTo(1);
}
@Test
public void search_qprofile_activity_with_user_not_found() throws InterruptedException {
MockUserSession.set()
.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
.setLogin("david");
// We need an actual rule in DB to test RuleName in Activity
db.ruleDao().getByKey(dbSession, RuleTesting.XOO_X1);
tester
.get(ActivityService.class)
.write(
dbSession,
Activity.Type.QPROFILE,
ActiveRuleChange.createFor(
ActiveRuleChange.Type.ACTIVATED,
ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1))
.setSeverity(Severity.MAJOR)
.setParameter("max", "10"));
dbSession.commit();
Result<QProfileActivity> activities =
service.searchActivities(new QProfileActivityQuery(), new QueryContext());
assertThat(activities.getHits()).hasSize(1);
QProfileActivity activity = activities.getHits().get(0);
assertThat(activity.login()).isEqualTo("david");
assertThat(activity.authorName()).isNull();
}
@Test
public void do_not_deactivate_removed_rules_if_repository_accidentaly_uninstalled()
throws Exception {
MockUserSession.set()
.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
.setLogin("me");
// create a profile and activate rule
db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP1());
dbSession.commit();
dbSession.clearCache();
RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1);
tester.get(QProfileService.class).activate(QProfileTesting.XOO_P1_KEY, activation);
dbSession.clearCache();
// restart without x1, x2, template1 -> keep active rule of x1
rulesDefinition.includeX1 = false;
rulesDefinition.includeX2 = false;
rulesDefinition.includeTemplate1 = false;
tester.get(Platform.class).executeStartupTasks();
dbSession.clearCache();
assertThat(db.ruleDao().getByKey(dbSession, RuleTesting.XOO_X1).getStatus())
.isEqualTo(RuleStatus.REMOVED);
assertThat(db.ruleDao().getByKey(dbSession, RuleTesting.XOO_X2).getStatus())
.isEqualTo(RuleStatus.REMOVED);
assertThat(db.activeRuleDao().findByProfileKey(dbSession, QProfileTesting.XOO_P1_KEY))
.hasSize(1);
}
@Test
public void deactivate_removed_rules_only_if_repository_still_exists() throws Exception {
MockUserSession.set()
.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
.setLogin("me");
// create a profile and activate rule
db.qualityProfileDao().insert(dbSession, QProfileTesting.newXooP1());
dbSession.commit();
dbSession.clearCache();
RuleActivation activation = new RuleActivation(RuleTesting.XOO_X1);
tester.get(QProfileService.class).activate(QProfileTesting.XOO_P1_KEY, activation);
dbSession.clearCache();
// restart, x2 still exists -> deactivate x1
rulesDefinition.includeX1 = false;
rulesDefinition.includeX2 = true;
tester.get(Platform.class).executeStartupTasks();
dbSession.clearCache();
assertThat(db.ruleDao().getByKey(dbSession, RuleKey.of("xoo", "x1")).getStatus())
.isEqualTo(RuleStatus.REMOVED);
assertThat(db.ruleDao().getByKey(dbSession, RuleKey.of("xoo", "x2")).getStatus())
.isEqualTo(RuleStatus.READY);
assertThat(db.activeRuleDao().findByProfileKey(dbSession, QProfileTesting.XOO_P1_KEY))
.hasSize(0);
}
@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();
}
@Test
public void self_deactivation_is_not_possible() throws Exception {
try {
MockUserSession.set().setLogin("simon").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
service.deactivate("simon");
fail();
} catch (BadRequestException e) {
assertThat(e).hasMessage("Self-deactivation is not possible");
verify(dao, never()).deactivateUserByLogin("simon");
}
}
@Test
public void fail_to_deactivate_when_blank_login() throws Exception {
MockUserSession.set().setLogin("simon").setGlobalPermissions(GlobalPermissions.SYSTEM_ADMIN);
try {
service.deactivate("");
fail();
} catch (BadRequestException e) {
assertThat(e).hasMessage("Login is missing");
verifyZeroInteractions(dao);
}
}
@Test
public void user_deactivation_requires_admin_permission() throws Exception {
try {
MockUserSession.set()
.setLogin("simon")
.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
service.deactivate("julien");
fail();
} catch (ForbiddenException e) {
verify(dao, never()).deactivateUserByLogin("simon");
}
}
@Test
public void set_default() throws Exception {
MockUserSession.set()
.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
.setLogin("me");
assertThat(service.getDefault("xoo")).isNull();
service.setDefault(XOO_P1_KEY);
dbSession.clearCache();
assertThat(service.getDefault("xoo").getKey()).isEqualTo(XOO_P1_KEY);
}
@Test
public void count_by_all_profiles() throws Exception {
MockUserSession.set()
.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
.setLogin("me");
service.activate(XOO_P1_KEY, new RuleActivation(RuleTesting.XOO_X1).setSeverity("BLOCKER"));
service.activate(XOO_P2_KEY, new RuleActivation(RuleTesting.XOO_X1).setSeverity("BLOCKER"));
dbSession.clearCache();
Map<String, Long> counts = loader.countAllActiveRules();
assertThat(counts).hasSize(2);
assertThat(counts.keySet()).containsOnly(XOO_P1_KEY, XOO_P2_KEY);
assertThat(counts.values()).containsOnly(1L, 1L);
}
@Test
public void search_qprofile_activity() throws InterruptedException {
MockUserSession.set()
.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
.setLogin("david");
UserDto user =
new UserDto()
.setLogin("david")
.setName("David")
.setEmail("*****@*****.**")
.setCreatedAt(new Date())
.setUpdatedAt(new Date());
db.userDao().insert(dbSession, user);
// We need an actual rule in DB to test RuleName in Activity
RuleDto rule = db.ruleDao().getByKey(dbSession, RuleTesting.XOO_X1);
tester
.get(ActivityService.class)
.write(
dbSession,
Activity.Type.QPROFILE,
ActiveRuleChange.createFor(
ActiveRuleChange.Type.ACTIVATED,
ActiveRuleKey.of(XOO_P1_KEY, RuleTesting.XOO_X1))
.setSeverity(Severity.MAJOR)
.setParameter("max", "10"));
dbSession.commit();
Result<QProfileActivity> activities =
service.searchActivities(new QProfileActivityQuery(), new QueryContext());
assertThat(activities.getHits()).hasSize(1);
QProfileActivity activity = activities.getHits().get(0);
assertThat(activity.type()).isEqualTo(Activity.Type.QPROFILE);
assertThat(activity.action()).isEqualTo(ActiveRuleChange.Type.ACTIVATED.name());
assertThat(activity.ruleKey()).isEqualTo(RuleTesting.XOO_X1);
assertThat(activity.profileKey()).isEqualTo(XOO_P1_KEY);
assertThat(activity.severity()).isEqualTo(Severity.MAJOR);
assertThat(activity.ruleName()).isEqualTo(rule.getName());
assertThat(activity.login()).isEqualTo("david");
assertThat(activity.authorName()).isEqualTo("David");
assertThat(activity.parameters()).hasSize(1);
assertThat(activity.parameters().get("max")).isEqualTo("10");
}
@Test
public void add_tags() throws Exception {
String ruleKey = "squid:AvoidCycle";
Rule rule = createStandardRule();
when(rules.findByKey(RuleKey.of("squid", "AvoidCycle"))).thenReturn(rule);
MockUserSession.set().setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
WsTester.TestRequest request =
tester.newRequest("add_tags").setParam("key", ruleKey).setParam("tags", "tag1,tag2");
request.execute().assertNoContent();
ArgumentCaptor<Object> newTagsCaptor = ArgumentCaptor.forClass(Object.class);
verify(rules).updateRuleTags(isA(Integer.class), newTagsCaptor.capture());
Object newTags = newTagsCaptor.getValue();
assertThat(newTags).isInstanceOf(List.class);
assertThat((List<String>) newTags).hasSize(4).containsOnly("admin1", "admin2", "tag1", "tag2");
}
@Before
public void setUp() throws Exception {
when(myBatis.openSession(false)).thenReturn(session);
definitions = newArrayList();
backup =
new QProfileBackup(
myBatis,
qProfileOperations,
qProfileActiveRuleOperations,
ruleDao,
definitions,
defaultProfilesCache,
dryRunCache);
MockUserSession.set()
.setLogin("nicolas")
.setName("Nicolas")
.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN);
}
@Test
public void count_by_deprecated() throws Exception {
MockUserSession.set()
.setGlobalPermissions(GlobalPermissions.QUALITY_PROFILE_ADMIN)
.setLogin("me");
// create deprecated rule
RuleDto deprecatedXooRule =
RuleTesting.newDto(RuleKey.of("xoo", "deprecated1"))
.setSeverity("MINOR")
.setLanguage("xoo")
.setStatus(RuleStatus.DEPRECATED);
db.ruleDao().insert(dbSession, deprecatedXooRule);
dbSession.commit();
// active some rules
service.activate(
XOO_P1_KEY, new RuleActivation(deprecatedXooRule.getKey()).setSeverity("BLOCKER"));
service.activate(XOO_P1_KEY, new RuleActivation(RuleTesting.XOO_X1).setSeverity("BLOCKER"));
dbSession.commit();
assertThat(loader.countDeprecatedActiveRulesByProfile(XOO_P1_KEY)).isEqualTo(1);
}