return session.getMapper(mapperClass);
}
+ @CheckForNull
public DTO getNullableByKey(DbSession session, KEY key) {
return doGetNullableByKey(session, key);
}
import org.sonar.api.component.Component;
import org.sonar.api.config.Settings;
import org.sonar.api.issue.Issue;
-import org.sonar.api.issue.IssueQuery;
-import org.sonar.api.issue.IssueQueryResult;
import org.sonar.api.issue.action.Action;
import org.sonar.api.issue.action.Actions;
import org.sonar.api.issue.action.Function;
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.core.issue.db.IssueStorage;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.properties.PropertiesDao;
import org.sonar.core.properties.PropertyDto;
+import org.sonar.server.db.DbClient;
import org.sonar.server.user.UserSession;
import javax.annotation.CheckForNull;
*/
public class ActionService implements ServerComponent {
- private final DefaultIssueFinder finder;
+ private final DbClient dbClient;
+ private final IssueService issueService;
private final IssueStorage issueStorage;
private final IssueUpdater updater;
private final Settings settings;
private final PropertiesDao propertiesDao;
private final Actions actions;
- public ActionService(DefaultIssueFinder finder, IssueStorage issueStorage, IssueUpdater updater, Settings settings, PropertiesDao propertiesDao, Actions actions) {
- this.finder = finder;
+ public ActionService(DbClient dbClient, IssueService issueService, IssueStorage issueStorage, IssueUpdater updater, Settings settings, PropertiesDao propertiesDao, Actions actions) {
+ this.dbClient = dbClient;
+ this.issueService = issueService;
this.issueStorage = issueStorage;
this.updater = updater;
this.settings = settings;
}
public List<Action> listAvailableActions(String issueKey) {
- IssueQueryResult queryResult = loadIssue(issueKey);
- final DefaultIssue issue = (DefaultIssue) queryResult.first();
- return listAvailableActions(issue);
+ return listAvailableActions(issueService.getIssueByKey(issueKey));
}
public List<Action> listAvailableActions(final Issue issue) {
public Issue execute(String issueKey, String actionKey, UserSession userSession) {
Preconditions.checkArgument(!Strings.isNullOrEmpty(actionKey), "Missing action");
- IssueQueryResult queryResult = loadIssue(issueKey);
- DefaultIssue issue = (DefaultIssue) queryResult.first();
- Action action = getAction(actionKey);
- if (action == null) {
- throw new IllegalArgumentException("Action is not found : " + actionKey);
- }
- if (!action.supports(issue)) {
- throw new IllegalStateException("A condition is not respected");
- }
+ DbSession session = dbClient.openSession(false);
+ try {
+ DefaultIssue issue = issueService.getIssueByKey(session, issueKey);
+ Action action = getAction(actionKey);
+ if (action == null) {
+ throw new IllegalArgumentException("Action is not found : " + actionKey);
+ }
+ if (!action.supports(issue)) {
+ throw new IllegalStateException("A condition is not respected");
+ }
- IssueChangeContext changeContext = IssueChangeContext.createUser(new Date(), userSession.login());
- Component project = queryResult.project(issue);
- FunctionContext functionContext = new FunctionContext(issue, updater, changeContext, getProjectSettings(project));
- for (Function function : action.functions()) {
- function.execute(functionContext);
+ IssueChangeContext changeContext = IssueChangeContext.createUser(new Date(), userSession.login());
+ Component project = dbClient.componentDao().getByKey(session, issue.projectKey());
+ FunctionContext functionContext = new FunctionContext(issue, updater, changeContext, getProjectSettings(project));
+ for (Function function : action.functions()) {
+ function.execute(functionContext);
+ }
+ issueStorage.save(issue);
+ return issue;
+ } finally {
+ session.close();
}
- issueStorage.save(issue);
- return issue;
- }
-
- public IssueQueryResult loadIssue(String issueKey) {
- IssueQuery query = IssueQuery.builder().issueKeys(newArrayList(issueKey)).requiredRole(UserRole.USER).build();
- return finder.find(query);
}
@CheckForNull
import org.sonar.core.issue.IssueNotifications;
import org.sonar.core.issue.IssueUpdater;
import org.sonar.core.issue.db.IssueDao;
-import org.sonar.core.issue.db.IssueDto;
import org.sonar.core.issue.db.IssueStorage;
import org.sonar.core.issue.workflow.IssueWorkflow;
import org.sonar.core.issue.workflow.Transition;
private final PreviewCache dryRunCache;
public DefaultIssueService(DbClient dbClient, IndexClient indexClient,
- IssueWorkflow workflow,
- IssueStorage issueStorage,
- IssueUpdater issueUpdater,
- IssueNotifications issueNotifications,
- ActionPlanService actionPlanService,
- RuleFinder ruleFinder,
- IssueDao issueDao,
- UserFinder userFinder,
- PreviewCache dryRunCache) {
+ IssueWorkflow workflow,
+ IssueStorage issueStorage,
+ IssueUpdater issueUpdater,
+ IssueNotifications issueNotifications,
+ ActionPlanService actionPlanService,
+ RuleFinder ruleFinder,
+ IssueDao issueDao,
+ UserFinder userFinder,
+ PreviewCache dryRunCache) {
this.dbClient = dbClient;
this.indexClient = indexClient;
this.workflow = workflow;
public List<Transition> listTransitions(String issueKey) {
DbSession session = dbClient.openSession(false);
try {
- IssueDto issueDto = getByKey(session, issueKey);
- return listTransitions(issueDto.toDefaultIssue());
+ return listTransitions(getIssueByKey(session, issueKey));
} finally {
session.close();
}
DbSession session = dbClient.openSession(false);
try {
- IssueDto issueDto = getByKey(session, issueKey);
- DefaultIssue defaultIssue = issueDto.toDefaultIssue();
+ DefaultIssue defaultIssue = getIssueByKey(session, issueKey);
IssueChangeContext context = IssueChangeContext.createUser(new Date(), UserSession.get().login());
checkTransitionPermission(transitionKey, UserSession.get(), defaultIssue);
if (workflow.doTransition(defaultIssue, transitionKey, context)) {
DbSession session = dbClient.openSession(false);
try {
- IssueDto issueDto = getByKey(session, issueKey);
- DefaultIssue issue = issueDto.toDefaultIssue();
+ DefaultIssue issue = getIssueByKey(session, issueKey);
User user = null;
if (!Strings.isNullOrEmpty(assignee)) {
user = userFinder.findByLogin(assignee);
throw new NotFoundException("Unknown action plan: " + actionPlanKey);
}
}
- IssueDto issueDto = getByKey(session, issueKey);
- DefaultIssue issue = issueDto.toDefaultIssue();
+ DefaultIssue issue = getIssueByKey(session, issueKey);
IssueChangeContext context = IssueChangeContext.createUser(new Date(), UserSession.get().login());
if (issueUpdater.plan(issue, actionPlan, context)) {
DbSession session = dbClient.openSession(false);
try {
- IssueDto issueDto = getByKey(session, issueKey);
- DefaultIssue issue = issueDto.toDefaultIssue();
+ DefaultIssue issue = getIssueByKey(session, issueKey);
UserSession.get().checkProjectPermission(UserRole.ISSUE_ADMIN, issue.projectKey());
IssueChangeContext context = IssueChangeContext.createUser(new Date(), UserSession.get().login());
@Override
public DefaultIssue createManualIssue(String componentKey, RuleKey ruleKey, @Nullable Integer line, @Nullable String message, @Nullable String severity,
- @Nullable Double effortToFix) {
+ @Nullable Double effortToFix) {
verifyLoggedIn();
DbSession session = dbClient.openSession(false);
return aggregation;
}
- public IssueDto getByKey(DbSession session, String key) {
- // Load with index to check permission
+ public DefaultIssue getIssueByKey(DbSession session, String key) {
+ // Load from index to check permission
indexClient.get(IssueIndex.class).getByKey(key);
- return dbClient.issueDao().getByKey(session, key);
+ return dbClient.issueDao().getByKey(session, key).toDefaultIssue();
+ }
+
+ public DefaultIssue getIssueByKey(String key) {
+ DbSession session = dbClient.openSession(false);
+ try {
+ // Load from index to check permission
+ indexClient.get(IssueIndex.class).getByKey(key);
+ return dbClient.issueDao().getByKey(session, key).toDefaultIssue();
+ } finally {
+ session.close();
+ }
}
private void saveIssue(DbSession session, DefaultIssue issue, IssueChangeContext context) {
// TODO result should be replaced by an aggregation object in IssueIndex
Multiset<String> findSeveritiesByComponent(String componentKey, @Nullable Date periodDate, DbSession session);
+ DefaultIssue getIssueByKey(DbSession session, String key);
+
+ DefaultIssue getIssueByKey(String key);
+
}
* Never return null, but return an empty list if the issue does not exist.
*/
public List<Transition> listTransitions(String issueKey) {
- Issue issue = loadIssue(issueKey).first();
+ Issue issue = getIssueByKey(issueKey);
return listTransitions(issue);
}
return rule;
}
- public IssueQueryResult loadIssue(String issueKey) {
- // TODO use IssueIndex for ACL
- // TODO load DTO
- IssueQueryResult result = finder.find(IssueQuery.builder().issueKeys(Arrays.asList(issueKey)).requiredRole(UserRole.USER).build());
- if (result.issues().size() != 1) {
- // TODO throw 404
- throw new IllegalArgumentException("Issue not found: " + issueKey);
- }
- return result;
- }
-
public List<String> listStatus() {
return workflow.statusKeys();
}
return aggregation;
}
+ public IssueQueryResult loadIssue(String issueKey) {
+ // TODO use IssueIndex for ACL
+ // TODO load DTO
+ IssueQueryResult result = finder.find(IssueQuery.builder().issueKeys(Arrays.asList(issueKey)).requiredRole(UserRole.USER).build());
+ if (result.issues().size() != 1) {
+ // TODO throw 404
+ throw new IllegalArgumentException("Issue not found: " + issueKey);
+ }
+ return result;
+ }
+
+ @Override
+ public DefaultIssue getIssueByKey(DbSession session, String key) {
+ return (DefaultIssue) loadIssue(key).first();
+ }
+
+ @Override
+ public DefaultIssue getIssueByKey(String key) {
+ return (DefaultIssue) loadIssue(key).first();
+ }
}
*/
package org.sonar.server.issue.ws;
-import com.google.common.base.Predicate;
-import com.google.common.collect.Iterables;
import com.google.common.io.Resources;
-import org.sonar.api.component.Component;
import org.sonar.api.i18n.I18n;
import org.sonar.api.issue.ActionPlan;
import org.sonar.api.issue.Issue;
import org.sonar.api.issue.IssueComment;
-import org.sonar.api.issue.IssueFinder;
-import org.sonar.api.issue.IssueQuery;
-import org.sonar.api.issue.IssueQueryResult;
import org.sonar.api.issue.internal.DefaultIssue;
import org.sonar.api.issue.internal.FieldDiffs;
import org.sonar.api.server.debt.DebtCharacteristic;
import org.sonar.api.server.ws.Response;
import org.sonar.api.server.ws.WebService;
import org.sonar.api.user.User;
+import org.sonar.api.user.UserFinder;
import org.sonar.api.utils.DateUtils;
import org.sonar.api.utils.Duration;
import org.sonar.api.utils.Durations;
import org.sonar.api.utils.text.JsonWriter;
-import org.sonar.api.web.UserRole;
import org.sonar.core.component.ComponentDto;
+import org.sonar.core.persistence.DbSession;
import org.sonar.markdown.Markdown;
+import org.sonar.server.db.DbClient;
import org.sonar.server.debt.DebtModelService;
-import org.sonar.server.exceptions.NotFoundException;
import org.sonar.server.issue.IssueChangelog;
import org.sonar.server.issue.IssueChangelogService;
+import org.sonar.server.issue.IssueService;
+import org.sonar.server.issue.actionplan.ActionPlanService;
+import org.sonar.server.rule.Rule;
+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.Date;
import java.util.List;
+import java.util.Map;
+
+import static com.google.common.collect.Maps.newHashMap;
public class IssueShowAction implements RequestHandler {
public static final String SHOW_ACTION = "show";
- private final IssueFinder issueFinder;
+ private final DbClient dbClient;
+
+ private final IssueService issueService;
private final IssueChangelogService issueChangelogService;
private final IssueActionsWriter actionsWriter;
+ private final ActionPlanService actionPlanService;
+ private final UserFinder userFinder;
private final DebtModelService debtModel;
+ private final RuleService ruleService;
private final I18n i18n;
private final Durations durations;
- public IssueShowAction(IssueFinder issueFinder, IssueChangelogService issueChangelogService, IssueActionsWriter actionsWriter,
- DebtModelService debtModel, I18n i18n, Durations durations) {
- this.issueFinder = issueFinder;
+ public IssueShowAction(DbClient dbClient, IssueService issueService, IssueChangelogService issueChangelogService, IssueActionsWriter actionsWriter,
+ ActionPlanService actionPlanService, UserFinder userFinder, DebtModelService debtModel, RuleService ruleService, I18n i18n, Durations durations) {
+ this.dbClient = dbClient;
+ this.issueService = issueService;
this.issueChangelogService = issueChangelogService;
this.actionsWriter = actionsWriter;
+ this.actionPlanService = actionPlanService;
+ this.userFinder = userFinder;
this.debtModel = debtModel;
+ this.ruleService = ruleService;
this.i18n = i18n;
this.durations = durations;
}
@Override
public void handle(Request request, Response response) {
String issueKey = request.mandatoryParam("key");
- IssueQueryResult queryResult = issueFinder.find(IssueQuery.builder()
- .requiredRole(UserRole.USER)
- .issueKeys(Arrays.asList(issueKey)).build());
- if (queryResult.issues().size() != 1) {
- throw new NotFoundException("Issue not found: " + issueKey);
- }
- DefaultIssue issue = (DefaultIssue) queryResult.first();
JsonWriter json = response.newJsonWriter();
json.beginObject().name("issue").beginObject();
- writeIssue(queryResult, issue, json);
- actionsWriter.writeActions(issue, json);
- actionsWriter.writeTransitions(issue, json);
- writeComments(queryResult, issue, json);
- writeChangelog(issue, json);
+ DbSession session = dbClient.openSession(false);
+ try {
+ DefaultIssue issue = issueService.getIssueByKey(session, issueKey);
+
+ writeIssue(session, issue, json);
+ actionsWriter.writeActions(issue, json);
+ actionsWriter.writeTransitions(issue, json);
+ writeComments(issue, json);
+ writeChangelog(issue, json);
+
+ } finally {
+ session.close();
+ }
json.endObject().endObject().close();
}
- private void writeIssue(IssueQueryResult result, DefaultIssue issue, JsonWriter json) {
+ private void writeIssue(DbSession session, DefaultIssue issue, JsonWriter json) {
String actionPlanKey = issue.actionPlanKey();
- ActionPlan actionPlan = result.actionPlan(issue);
+ ActionPlan actionPlan = actionPlanService.findByKey(actionPlanKey, UserSession.get());
Duration debt = issue.debt();
+ Rule rule = ruleService.getNonNullByKey(issue.ruleKey());
Date updateDate = issue.updateDate();
Date closeDate = issue.closeDate();
json
.prop("key", issue.key())
.prop("rule", issue.ruleKey().toString())
- .prop("ruleName", result.rule(issue).getName())
+ .prop("ruleName", rule.name())
.prop("line", issue.line())
.prop("message", issue.message())
.prop("resolution", issue.resolution())
.prop("closeDate", closeDate != null ? DateUtils.formatDateTime(closeDate) : null)
.prop("fCloseDate", formatDate(issue.closeDate()));
- addComponents(result, issue, json);
- addUserWithLabel(result, issue.assignee(), "assignee", json);
- addUserWithLabel(result, issue.reporter(), "reporter", json);
- addCharacteristics(result, issue, json);
+ addComponents(session, issue, json);
+ addUserWithLabel(issue.assignee(), "assignee", json);
+ addUserWithLabel(issue.reporter(), "reporter", json);
+ addCharacteristics(rule, json);
}
- private void addComponents(IssueQueryResult result, DefaultIssue issue, JsonWriter json) {
+ private void addComponents(DbSession session, DefaultIssue issue, JsonWriter json) {
// component, module and project can be null if they were removed
- ComponentDto component = (ComponentDto) result.component(issue);
- ComponentDto subProject = (ComponentDto) getSubProject(result, component);
- ComponentDto project = (ComponentDto) geProject(result, component);
+ ComponentDto component = dbClient.componentDao().getNullableByKey(session, issue.componentKey());
+ ComponentDto subProject = component != null ? dbClient.componentDao().getNullableById(component.subProjectId(), session) : null;
+ ComponentDto project = component != null ? dbClient.componentDao().getNullableById(component.projectId(), session) : null;
String projectName = project != null ? project.longName() != null ? project.longName() : project.name() : null;
// Do not display sub project long name if sub project and project are the same
.prop("subProjectName", subProjectName);
}
- private void writeComments(IssueQueryResult queryResult, Issue issue, JsonWriter json) {
+ private void writeComments(Issue issue, JsonWriter json) {
json.name("comments").beginArray();
String login = UserSession.get().login();
+
+ Map<String, User> usersByLogin = newHashMap();
+ for (IssueComment comment : issue.comments()) {
+ String userLogin = comment.userLogin();
+ User user = usersByLogin.get(userLogin);
+ if (user == null) {
+ user = userFinder.findByLogin(userLogin);
+ if (user != null) {
+ usersByLogin.put(userLogin, user);
+ }
+ }
+ }
+
for (IssueComment comment : issue.comments()) {
String userLogin = comment.userLogin();
- User user = userLogin != null ? queryResult.user(userLogin) : null;
+ User user = usersByLogin.get(userLogin);
json
.beginObject()
.prop("key", comment.key())
json.endArray();
}
- private static void addUserWithLabel(IssueQueryResult result, @Nullable String value, String field, JsonWriter json) {
+ private void addUserWithLabel(@Nullable String value, String field, JsonWriter json) {
if (value != null) {
- User user = result.user(value);
+ User user = userFinder.findByLogin(value);
json
.prop(field, value)
.prop(field + "Name", user != null ? user.name() : null);
return null;
}
- /**
- * Can be null on project or on removed component
- */
- @CheckForNull
- private Component getSubProject(IssueQueryResult result, @Nullable final ComponentDto component) {
- if (component != null) {
- return Iterables.find(result.components(), new Predicate<Component>() {
- @Override
- public boolean apply(Component input) {
- Long subProjectId = component.subProjectId();
- return subProjectId != null && subProjectId.equals(((ComponentDto) input).getId());
- }
- }, null);
- }
- return null;
- }
-
- /**
- * Can be null on removed component
- */
- @CheckForNull
- private Component geProject(IssueQueryResult result, @Nullable final ComponentDto component) {
- if (component != null) {
- return Iterables.find(result.components(), new Predicate<Component>() {
- @Override
- public boolean apply(Component input) {
- return component.projectId().equals(((ComponentDto) input).getId());
- }
- }, null);
- }
- return null;
- }
-
- private void addCharacteristics(IssueQueryResult result, DefaultIssue issue, JsonWriter json) {
- String subCharacteristicKey = result.rule(issue).getCharacteristicKey() != null ? result.rule(issue).getCharacteristicKey() : result.rule(issue).getDefaultCharacteristicKey();
+ private void addCharacteristics(Rule rule, JsonWriter json) {
+ String subCharacteristicKey = rule.debtCharacteristicKey();
DebtCharacteristic subCharacteristic = characteristicByKey(subCharacteristicKey);
if (subCharacteristic != null) {
json.prop("subCharacteristic", subCharacteristic.name());
import org.sonar.api.component.Component;
import org.sonar.api.config.Settings;
import org.sonar.api.issue.Issue;
-import org.sonar.api.issue.IssueQuery;
-import org.sonar.api.issue.IssueQueryResult;
import org.sonar.api.issue.action.Actions;
import org.sonar.api.issue.action.Function;
import org.sonar.api.issue.condition.Condition;
import org.sonar.api.issue.internal.DefaultIssue;
import org.sonar.api.issue.internal.IssueChangeContext;
-import org.sonar.core.issue.DefaultIssueQueryResult;
+import org.sonar.core.component.ComponentDto;
import org.sonar.core.issue.IssueUpdater;
import org.sonar.core.issue.db.IssueStorage;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.properties.PropertiesDao;
import org.sonar.core.properties.PropertyDto;
+import org.sonar.server.component.db.ComponentDao;
+import org.sonar.server.db.DbClient;
import org.sonar.server.user.UserSession;
-import java.util.Collections;
import java.util.List;
import static com.google.common.collect.Lists.newArrayList;
public class ActionServiceTest {
- DefaultIssueFinder finder;
+ DbClient dbClient;
+ DbSession session;
+
+ ComponentDao componentDao;
+ IssueService issueService;
IssueStorage issueStorage;
IssueUpdater updater;
PropertiesDao propertiesDao;
@Before
public void before() {
- finder = mock(DefaultIssueFinder.class);
+ dbClient = mock(DbClient.class);
+ session = mock(DbSession.class);
+ when(dbClient.openSession(false)).thenReturn(session);
+
+ componentDao = mock(ComponentDao.class);
+ when(dbClient.componentDao()).thenReturn(componentDao);
+ issueService = mock(IssueService.class);
issueStorage = mock(IssueStorage.class);
updater = mock(IssueUpdater.class);
propertiesDao = mock(PropertiesDao.class);
settings = new Settings();
actions = new Actions();
- actionService = new ActionService(finder, issueStorage, updater, settings, propertiesDao, actions);
+ actionService = new ActionService(dbClient, issueService, issueStorage, updater, settings, propertiesDao, actions);
}
@Test
Function function1 = mock(Function.class);
Function function2 = mock(Function.class);
- Issue issue = new DefaultIssue().setKey("ABCD");
- IssueQueryResult issueQueryResult = mock(DefaultIssueQueryResult.class);
- when(issueQueryResult.first()).thenReturn(issue);
-
- when(issueQueryResult.project(issue)).thenReturn(mock(Component.class));
- when(finder.find(any(IssueQuery.class))).thenReturn(issueQueryResult);
+ DefaultIssue issue = new DefaultIssue().setKey("ABCD");
+ when(componentDao.getByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
+ when(issueService.getIssueByKey(session, "ABCD")).thenReturn(issue);
actions.add("link-to-jira").setConditions(new AlwaysMatch()).setFunctions(function1, function2);
when(userSession.login()).thenReturn("arthur");
DefaultIssue issue = new DefaultIssue().setKey("ABCD");
- IssueQueryResult issueQueryResult = mock(DefaultIssueQueryResult.class);
- when(issueQueryResult.first()).thenReturn(issue);
- when(issueQueryResult.project(issue)).thenReturn(mock(Component.class));
-
- when(finder.find(any(IssueQuery.class))).thenReturn(issueQueryResult);
+ when(componentDao.getByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
+ when(issueService.getIssueByKey(session, "ABCD")).thenReturn(issue);
actions.add("link-to-jira").setConditions(new AlwaysMatch()).setFunctions(function);
assertThat(actionService.execute("ABCD", "link-to-jira", userSession)).isNotNull();
UserSession userSession = mock(UserSession.class);
when(userSession.login()).thenReturn("arthur");
- DefaultIssue issue = new DefaultIssue().setKey("ABCD");
- IssueQueryResult issueQueryResult = mock(DefaultIssueQueryResult.class);
- when(issueQueryResult.first()).thenReturn(issue);
- Component project = mock(Component.class);
- when(project.key()).thenReturn("struts");
- when(issueQueryResult.project(issue)).thenReturn(project);
-
- when(finder.find(any(IssueQuery.class))).thenReturn(issueQueryResult);
+ DefaultIssue issue = new DefaultIssue().setKey("ABCD").setProjectKey("struts");
+ when(componentDao.getByKey(session, "struts")).thenReturn(new ComponentDto().setKey("struts"));
+ when(issueService.getIssueByKey(session, "ABCD")).thenReturn(issue);
actions.add("link-to-jira").setConditions(new AlwaysMatch()).setFunctions(function);
assertThat(actionService.execute("ABCD", "link-to-jira", userSession)).isNotNull();
verify(propertiesDao).selectProjectProperties(eq("struts"));
}
- @Test
- public void not_execute_function_if_issue_not_found() {
- Function function = mock(Function.class);
-
- IssueQueryResult issueQueryResult = new DefaultIssueQueryResult(Collections.<Issue>emptyList());
- when(finder.find(any(IssueQuery.class))).thenReturn(issueQueryResult);
-
- actions.add("link-to-jira").setConditions(new AlwaysMatch()).setFunctions(function);
- try {
- actionService.execute("ABCD", "link-to-jira", mock(UserSession.class));
- fail();
- } catch (Exception e) {
- assertThat(e).isInstanceOf(IllegalStateException.class).hasMessage("No issue found");
- }
- verifyZeroInteractions(function);
- }
-
@Test
public void not_execute_function_if_action_not_found() {
Function function = mock(Function.class);
- Issue issue = new DefaultIssue().setKey("ABCD");
- IssueQueryResult issueQueryResult = new DefaultIssueQueryResult(newArrayList(issue));
- when(finder.find(any(IssueQuery.class))).thenReturn(issueQueryResult);
+ DefaultIssue issue = new DefaultIssue().setKey("ABCD");
+ when(componentDao.getByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
+ when(issueService.getIssueByKey(session, "ABCD")).thenReturn(issue);
actions.add("link-to-jira").setConditions(new AlwaysMatch()).setFunctions(function);
try {
public void not_execute_function_if_action_is_not_supported() {
Function function = mock(Function.class);
- Issue issue = new DefaultIssue().setKey("ABCD");
- IssueQueryResult issueQueryResult = new DefaultIssueQueryResult(newArrayList(issue));
- when(finder.find(any(IssueQuery.class))).thenReturn(issueQueryResult);
+ DefaultIssue issue = new DefaultIssue().setKey("ABCD");
+ when(componentDao.getByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
+ when(issueService.getIssueByKey(session, "ABCD")).thenReturn(issue);
actions.add("link-to-jira").setConditions(new NeverMatch()).setFunctions(function);
try {
@Test
public void list_available_supported_actions() {
- Issue issue = new DefaultIssue().setKey("ABCD");
- IssueQueryResult issueQueryResult = new DefaultIssueQueryResult(newArrayList(issue));
- when(finder.find(any(IssueQuery.class))).thenReturn(issueQueryResult);
+ DefaultIssue issue = new DefaultIssue().setKey("ABCD");
+ when(componentDao.getByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
+ when(issueService.getIssueByKey(session, "ABCD")).thenReturn(issue);
actions.add("link-to-jira").setConditions(new AlwaysMatch());
actions.add("tweet").setConditions(new NeverMatch());
assertThat(actionService.listAvailableActions("ABCD")).hasSize(1);
}
- @Test
- public void list_available_actions_throw_exception_if_issue_not_found() {
- IssueQueryResult issueQueryResult = new DefaultIssueQueryResult(Collections.<Issue>emptyList());
- when(finder.find(any(IssueQuery.class))).thenReturn(issueQueryResult);
-
- actions.add("link-to-jira").setConditions(new AlwaysMatch());
- actions.add("tweet").setConditions(new NeverMatch());
- try {
- actionService.listAvailableActions("ABCD");
- fail();
- } catch (Exception e) {
- assertThat(e).isInstanceOf(IllegalStateException.class).hasMessage("No issue found");
- }
- }
-
@Test
public void return_no_action() {
- Issue issue = new DefaultIssue().setKey("ABCD");
- IssueQueryResult issueQueryResult = new DefaultIssueQueryResult(newArrayList(issue));
- when(finder.find(any(IssueQuery.class))).thenReturn(issueQueryResult);
+ DefaultIssue issue = new DefaultIssue().setKey("ABCD");
+ when(componentDao.getByKey(eq(session), anyString())).thenReturn(mock(ComponentDto.class));
+ when(issueService.getIssueByKey(session, "ABCD")).thenReturn(issue);
assertThat(actionService.listAvailableActions("ABCD")).isEmpty();
}
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
-import org.sonar.api.component.Component;
import org.sonar.api.i18n.I18n;
-import org.sonar.api.issue.ActionPlan;
import org.sonar.api.issue.Issue;
-import org.sonar.api.issue.IssueFinder;
-import org.sonar.api.issue.IssueQuery;
import org.sonar.api.issue.internal.DefaultIssue;
import org.sonar.api.issue.internal.DefaultIssueComment;
import org.sonar.api.issue.internal.FieldDiffs;
import org.sonar.api.rule.RuleKey;
-import org.sonar.api.rules.Rule;
import org.sonar.api.server.debt.internal.DefaultDebtCharacteristic;
import org.sonar.api.user.User;
+import org.sonar.api.user.UserFinder;
import org.sonar.api.utils.DateUtils;
import org.sonar.api.utils.Duration;
import org.sonar.api.utils.Durations;
import org.sonar.core.component.ComponentDto;
import org.sonar.core.issue.DefaultActionPlan;
-import org.sonar.core.issue.DefaultIssueQueryResult;
import org.sonar.core.issue.workflow.Transition;
+import org.sonar.core.persistence.DbSession;
import org.sonar.core.user.DefaultUser;
+import org.sonar.server.component.db.ComponentDao;
+import org.sonar.server.db.DbClient;
import org.sonar.server.debt.DebtModelService;
import org.sonar.server.issue.ActionService;
import org.sonar.server.issue.IssueChangelog;
import org.sonar.server.issue.IssueChangelogService;
import org.sonar.server.issue.IssueService;
+import org.sonar.server.issue.actionplan.ActionPlanService;
+import org.sonar.server.rule.Rule;
+import org.sonar.server.rule.RuleService;
import org.sonar.server.user.MockUserSession;
+import org.sonar.server.user.UserSession;
import org.sonar.server.ws.WsTester;
-import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
+/**
+ * TODO Should be replaced by medium tests, as there are too many dependencies
+ */
@RunWith(MockitoJUnitRunner.class)
public class IssueShowActionTest {
@Mock
- IssueFinder issueFinder;
+ DbClient dbClient;
+
+ @Mock
+ DbSession session;
+
+ @Mock
+ ComponentDao componentDao;
@Mock
IssueService issueService;
@Mock
IssueChangelogService issueChangelogService;
+ @Mock
+ ActionPlanService actionPlanService;
+
@Mock
ActionService actionService;
+ @Mock
+ UserFinder userFinder;
+
@Mock
DebtModelService debtModel;
+ @Mock
+ RuleService ruleService;
+
@Mock
I18n i18n;
@Mock
Durations durations;
- List<Issue> issues;
- DefaultIssueQueryResult result;
-
Date issueCreationDate;
+ Rule rule;
+
WsTester tester;
@Before
public void setUp() throws Exception {
- issues = new ArrayList<Issue>();
- result = new DefaultIssueQueryResult(issues);
- result.addRules(newArrayList(Rule.create("squid", "AvoidCycle").setName("Avoid cycle")));
- when(issueFinder.find(any(IssueQuery.class))).thenReturn(result);
+ when(dbClient.openSession(false)).thenReturn(session);
+ when(dbClient.componentDao()).thenReturn(componentDao);
+
+ rule = mock(Rule.class);
+ when(rule.key()).thenReturn(RuleKey.of("squid", "AvoidCycle"));
+ when(rule.name()).thenReturn("Avoid cycle");
+ when(ruleService.getNonNullByKey(rule.key())).thenReturn(rule);
when(issueChangelogService.changelog(any(Issue.class))).thenReturn(mock(IssueChangelog.class));
when(i18n.message(any(Locale.class), eq("created"), eq((String) null))).thenReturn("Created");
- tester = new WsTester(new IssuesWs(new IssueShowAction(issueFinder, issueChangelogService, new IssueActionsWriter(issueService, actionService), debtModel, i18n, durations),
+ tester = new WsTester(new IssuesWs(
+ new IssueShowAction(dbClient, issueService, issueChangelogService,
+ new IssueActionsWriter(issueService, actionService), actionPlanService, userFinder, debtModel, ruleService, i18n, durations),
mock(IssueSearchAction.class)));
}
@Test
public void show_issue() throws Exception {
String issueKey = "ABCD";
- Issue issue = new DefaultIssue()
+ DefaultIssue issue = new DefaultIssue()
.setKey(issueKey)
.setComponentKey("org.sonar.server.issue.IssueClient")
.setProjectKey("org.sonar.Sonar")
.setStatus("CLOSED")
.setSeverity("MAJOR")
.setCreationDate(issueCreationDate);
- issues.add(issue);
+ when(issueService.getIssueByKey(session, issueKey)).thenReturn(issue);
- result.addComponents(Lists.<Component>newArrayList(new ComponentDto()
+ ComponentDto file = new ComponentDto()
.setId(10L)
.setKey("org.sonar.server.issue.IssueClient")
.setLongName("SonarQube :: Issue Client")
.setName("SonarQube :: Issue Client")
.setQualifier("FIL")
.setSubProjectId(1L)
- .setProjectId(1L)
- ));
+ .setProjectId(1L);
+ when(componentDao.getNullableByKey(session, file.key())).thenReturn(file);
- result.addComponents(Lists.<Component>newArrayList(new ComponentDto()
+ ComponentDto project = new ComponentDto()
.setId(1L)
.setKey("org.sonar.Sonar")
.setLongName("SonarQube")
.setName("SonarQube")
- .setProjectId(1L)
- ));
+ .setProjectId(1L);
+ when(componentDao.getNullableById(file.projectId(), session)).thenReturn(project);
MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issueKey);
@Test
public void show_issue_with_sub_project() throws Exception {
String issueKey = "ABCD";
- Issue issue = new DefaultIssue()
+ DefaultIssue issue = new DefaultIssue()
.setKey(issueKey)
.setComponentKey("org.sonar.server.issue.IssueClient")
.setProjectKey("org.sonar.Sonar")
.setStatus("CLOSED")
.setSeverity("MAJOR")
.setCreationDate(issueCreationDate);
- issues.add(issue);
+ when(issueService.getIssueByKey(session, issueKey)).thenReturn(issue);
// File
- result.addComponents(Lists.<Component>newArrayList(new ComponentDto()
+ ComponentDto file = new ComponentDto()
.setId(10L)
.setKey("org.sonar.server.issue.IssueClient")
.setLongName("SonarQube :: Issue Client")
.setQualifier("FIL")
.setSubProjectId(2L)
- .setProjectId(1L)));
+ .setProjectId(1L);
+ when(componentDao.getNullableByKey(session, file.key())).thenReturn(file);
// Module
- result.addComponents(Lists.<Component>newArrayList(new ComponentDto()
+ ComponentDto module = new ComponentDto()
.setId(2L)
.setKey("org.sonar.server.Server")
.setLongName("SonarQube :: Server")
.setQualifier("BRC")
.setSubProjectId(1L)
- .setProjectId(1L)));
+ .setProjectId(1L);
+ when(componentDao.getNullableById(file.subProjectId(), session)).thenReturn(module);
// Project
- result.addComponents(Lists.<Component>newArrayList(new ComponentDto()
+ ComponentDto project = new ComponentDto()
.setId(1L)
.setKey("org.sonar.Sonar")
- .setLongName("SonarQube")));
+ .setLongName("SonarQube");
+ when(componentDao.getNullableById(file.projectId(), session)).thenReturn(project);
MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issueKey);
@Test
public void use_project_and_sub_project_names_if_no_long_name() throws Exception {
String issueKey = "ABCD";
- Issue issue = new DefaultIssue()
+ DefaultIssue issue = new DefaultIssue()
.setKey(issueKey)
.setComponentKey("org.sonar.server.issue.IssueClient")
.setProjectKey("org.sonar.Sonar")
.setStatus("CLOSED")
.setSeverity("MAJOR")
.setCreationDate(issueCreationDate);
- issues.add(issue);
+ when(issueService.getIssueByKey(session, issueKey)).thenReturn(issue);
// File
- result.addComponents(Lists.<Component>newArrayList(new ComponentDto()
+ ComponentDto file = new ComponentDto()
.setId(10L)
.setKey("org.sonar.server.issue.IssueClient")
.setLongName("SonarQube :: Issue Client")
.setQualifier("FIL")
.setSubProjectId(2L)
- .setProjectId(1L)));
+ .setProjectId(1L);
+ when(componentDao.getNullableByKey(session, file.key())).thenReturn(file);
// Module
- result.addComponents(Lists.<Component>newArrayList(new ComponentDto()
+ ComponentDto module = new ComponentDto()
.setId(2L)
.setKey("org.sonar.server.Server")
.setName("SonarQube :: Server")
.setQualifier("BRC")
.setSubProjectId(1L)
- .setProjectId(1L)));
+ .setProjectId(1L);
+ when(componentDao.getNullableById(file.subProjectId(), session)).thenReturn(module);
// Project
- result.addComponents(Lists.<Component>newArrayList(new ComponentDto()
+ ComponentDto project = new ComponentDto()
.setId(1L)
.setKey("org.sonar.Sonar")
- .setName("SonarQube")));
+ .setName("SonarQube");
+ when(componentDao.getNullableById(file.projectId(), session)).thenReturn(project);
MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issueKey);
@Test
public void show_issue_on_removed_component() throws Exception {
String issueKey = "ABCD";
- Issue issue = createIssue();
- issues.add(issue);
+ DefaultIssue issue = createIssue();
+ when(issueService.getIssueByKey(session, issueKey)).thenReturn(issue);
- Component project = mock(Component.class);
+ ComponentDto project = mock(ComponentDto.class);
when(project.key()).thenReturn("org.sonar.Sonar");
when(project.longName()).thenReturn("SonarQube");
- result.addProjects(newArrayList(project));
+ when(componentDao.getNullableByKey(session, project.key())).thenReturn(project);
MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issueKey);
@Test
public void show_issue_on_removed_project_and_component() throws Exception {
String issueKey = "ABCD";
- Issue issue = createIssue();
- issues.add(issue);
+ DefaultIssue issue = createIssue();
+ when(issueService.getIssueByKey(session, issueKey)).thenReturn(issue);
MockUserSession.set();
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issueKey);
@Test
public void show_issue_with_action_plan() throws Exception {
- Issue issue = createStandardIssue()
+ DefaultIssue issue = createStandardIssue()
.setActionPlanKey("AP-ABCD");
- issues.add(issue);
+ when(issueService.getIssueByKey(session, issue.key())).thenReturn(issue);
- result.addActionPlans(newArrayList((ActionPlan) new DefaultActionPlan().setKey("AP-ABCD").setName("Version 4.2")));
+ when(actionPlanService.findByKey(eq(issue.actionPlanKey()), any(UserSession.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());
@Test
public void show_issue_with_users() throws Exception {
- Issue issue = createStandardIssue()
+ DefaultIssue issue = createStandardIssue()
.setAssignee("john")
.setReporter("steven")
.setAuthorLogin("Henry");
- issues.add(issue);
+ when(issueService.getIssueByKey(session, issue.key())).thenReturn(issue);
- result.addUsers(Lists.<User>newArrayList(
- new DefaultUser().setLogin("john").setName("John"),
- new DefaultUser().setLogin("steven").setName("Steven")
- ));
+ 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());
@Test
public void show_issue_with_technical_debt() throws Exception {
Duration debt = (Duration.create(7260L));
- Issue issue = createStandardIssue().setDebt(debt);
- issues.add(issue);
+ DefaultIssue issue = createStandardIssue().setDebt(debt);
+ when(issueService.getIssueByKey(session, issue.key())).thenReturn(issue);
when(durations.encode(debt)).thenReturn("2h1min");
@Test
public void show_issue_with_user_characteristics() throws Exception {
- Issue issue = createStandardIssue().setDebt(Duration.create(7260L));
- issues.add(issue);
+ DefaultIssue issue = createStandardIssue().setDebt(Duration.create(7260L));
+ when(issueService.getIssueByKey(session, issue.key())).thenReturn(issue);
- result.rule(issue).setCharacteristicKey("K2");
+ when(rule.debtCharacteristicKey()).thenReturn("K2");
when(debtModel.characteristicById(1)).thenReturn(new DefaultDebtCharacteristic().setKey("K1").setId(1).setName("Maintainability"));
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));
@Test
public void show_issue_with_default_characteristics() throws Exception {
- Issue issue = createStandardIssue().setDebt(Duration.create(7260L));
- issues.add(issue);
+ DefaultIssue issue = createStandardIssue().setDebt(Duration.create(7260L));
+ when(issueService.getIssueByKey(session, issue.key())).thenReturn(issue);
- result.rule(issue).setDefaultCharacteristicKey("K2");
+ when(rule.debtCharacteristicKey()).thenReturn("K2");
when(debtModel.characteristicById(1)).thenReturn(new DefaultDebtCharacteristic().setKey("K1").setId(1).setName("Maintainability"));
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));
request.execute().assertJson(getClass(), "show_issue_with_characteristics.json");
}
- @Test
- public void use_user_characteristic_if_both_characteristic_ids_are_defined() throws Exception {
- Issue issue = createStandardIssue().setDebt(Duration.create(7260L));
- issues.add(issue);
-
- result.rule(issue).setCharacteristicKey("K2");
- when(debtModel.characteristicById(1)).thenReturn(new DefaultDebtCharacteristic().setKey("K1").setId(1).setName("Maintainability"));
- 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));
-
- result.rule(issue).setDefaultCharacteristicKey("K20");
- when(debtModel.characteristicById(10)).thenReturn(new DefaultDebtCharacteristic().setKey("K10").setId(10).setName("Default Maintainability"));
- when(debtModel.characteristicById(20)).thenReturn(new DefaultDebtCharacteristic().setKey("K20").setId(20).setName("Default Readability").setParentId(10));
- when(debtModel.characteristicByKey("K20")).thenReturn(new DefaultDebtCharacteristic().setKey("K20").setId(20).setName("Default Readability").setParentId(10));
-
- MockUserSession.set();
- WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issue.key());
- request.execute().assertJson(getClass(), "show_issue_with_characteristics.json");
- }
-
@Test
public void show_issue_with_dates() throws Exception {
Date creationDate = DateUtils.parseDateTime("2014-01-22T19:10:03+0100");
Date updateDate = DateUtils.parseDateTime("2014-01-23T19:10:03+0100");
Date closedDate = DateUtils.parseDateTime("2014-01-24T19:10:03+0100");
- Issue issue = createStandardIssue()
+ DefaultIssue issue = createStandardIssue()
.setCreationDate(creationDate)
.setUpdateDate(updateDate)
.setCloseDate(closedDate);
- issues.add(issue);
+ when(issueService.getIssueByKey(session, issue.key())).thenReturn(issue);
when(i18n.formatDateTime(any(Locale.class), eq(creationDate))).thenReturn("Jan 22, 2014 10:03 AM");
when(i18n.formatDateTime(any(Locale.class), eq(updateDate))).thenReturn("Jan 23, 2014 10:03 AM");
Date date1 = DateUtils.parseDateTime("2014-02-22T19:10:03+0100");
Date date2 = DateUtils.parseDateTime("2014-02-23T19:10:03+0100");
- Issue issue = createStandardIssue()
+ DefaultIssue issue = createStandardIssue()
.addComment(
new DefaultIssueComment()
.setKey("COMMENT-ABCD")
.setUserLogin("arthur")
.setCreatedAt(date2)
);
- issues.add(issue);
- result.addUsers(Lists.<User>newArrayList(
- new DefaultUser().setLogin("john").setName("John"),
- new DefaultUser().setLogin("arthur").setName("Arthur")
- ));
+ when(issueService.getIssueByKey(session, issue.key())).thenReturn(issue);
+
+ when(userFinder.findByLogin("john")).thenReturn(new DefaultUser().setLogin("john").setName("John"));
+ when(userFinder.findByLogin("arthur")).thenReturn(new DefaultUser().setLogin("arthur").setName("Arthur"));
when(i18n.ageFromNow(any(Locale.class), eq(date1))).thenReturn("9 days");
when(i18n.ageFromNow(any(Locale.class), eq(date2))).thenReturn("10 days");
DefaultIssue issue = createStandardIssue()
.setStatus("RESOLVED")
.setResolution("FIXED");
- issues.add(issue);
+ when(issueService.getIssueByKey(session, issue.key())).thenReturn(issue);
when(issueService.listTransitions(eq(issue))).thenReturn(newArrayList(Transition.create("reopen", "RESOLVED", "REOPEN")));
public void show_issue_with_actions() throws Exception {
DefaultIssue issue = createStandardIssue()
.setStatus("OPEN");
- issues.add(issue);
+ when(issueService.getIssueByKey(session, issue.key())).thenReturn(issue);
MockUserSession.set().setLogin("john");
WsTester.TestRequest request = tester.newGetRequest("api/issues", "show").setParam("key", issue.key());
@Test
public void show_issue_with_changelog() throws Exception {
- Issue issue = createStandardIssue();
- issues.add(issue);
+ DefaultIssue issue = createStandardIssue();
+ when(issueService.getIssueByKey(session, issue.key())).thenReturn(issue);
Date date1 = DateUtils.parseDateTime("2014-02-22T19:10:03+0100");
Date date2 = DateUtils.parseDateTime("2014-02-23T19:10:03+0100");
}
private void addComponentAndProject() {
- result.addComponents(Lists.<Component>newArrayList(new ComponentDto()
+ ComponentDto file = new ComponentDto()
.setId(10L)
.setKey("org.sonar.server.issue.IssueClient")
.setLongName("SonarQube :: Issue Client")
+ .setName("SonarQube :: Issue Client")
.setQualifier("FIL")
.setSubProjectId(1L)
- .setProjectId(1L)
- ));
+ .setProjectId(1L);
+ when(componentDao.getNullableByKey(session, file.key())).thenReturn(file);
- result.addComponents(Lists.<Component>newArrayList(new ComponentDto()
+ ComponentDto project = new ComponentDto()
.setId(1L)
.setKey("org.sonar.Sonar")
.setLongName("SonarQube")
- .setProjectId(1L)
- ));
+ .setName("SonarQube")
+ .setProjectId(1L);
+ when(componentDao.getNullableById(file.projectId(), session)).thenReturn(project);
}
}
import org.sonar.api.issue.IssueFinder;
import org.sonar.api.server.ws.RailsHandler;
import org.sonar.api.server.ws.WebService;
+import org.sonar.api.user.UserFinder;
import org.sonar.api.utils.Durations;
+import org.sonar.server.db.DbClient;
import org.sonar.server.debt.DebtModelService;
import org.sonar.server.issue.IssueChangelogService;
+import org.sonar.server.issue.IssueService;
+import org.sonar.server.issue.actionplan.ActionPlanService;
+import org.sonar.server.rule.RuleService;
import org.sonar.server.ws.WsTester;
import static org.fest.assertions.Assertions.assertThat;
I18n i18n = mock(I18n.class);
Durations durations = mock(Durations.class);
- showAction = new IssueShowAction(issueFinder, issueChangelogService, actionsWriter, debtModelService, i18n, durations);
+ showAction = new IssueShowAction(mock(DbClient.class), mock(IssueService.class), issueChangelogService, actionsWriter, mock(ActionPlanService.class), mock(UserFinder.class), debtModelService, mock(RuleService.class), i18n, durations);
searchAction = new IssueSearchAction(issueFinder, actionsWriter, i18n, durations);
tester = new WsTester(new IssuesWs(showAction, searchAction));
}
projects / sonarqube.git / commitdiff