public void testSaveContextOnCommitForExistingTask() throws Exception {
myTaskManager.getState().saveContextOnCommit = true;
assertEquals(1, myTaskManager.getLocalTasks().size());
Task task = myRepository.findTask("TEST-001");
assertNotNull(task);
assertEquals(
1, myChangeListManager.getChangeListsCopy().size()); // default change list should be here
activateAndCreateChangelist(task);
myChangeListManager.waitUntilRefreshed();
assertEquals(2, myTaskManager.getLocalTasks().size());
List<LocalChangeList> copy = myChangeListManager.getChangeListsCopy();
assertEquals(copy.toString(), 2, copy.size());
LocalTask localTask = myTaskManager.getActiveTask();
List<ChangeListInfo> changelists = localTask.getChangeLists();
ChangeListInfo info = changelists.get(0);
LocalChangeList changeList = myChangeListManager.getChangeList(info.id);
assertNotNull(changeList);
CommitChangeListDialog.commitChanges(
getProject(), Collections.<Change>emptyList(), changeList, null, changeList.getName());
assertEquals(2, myTaskManager.getLocalTasks().size()); // no extra task created
assertEquals(2, myChangeListManager.getChangeListsCopy().size());
assertEquals(
localTask, myTaskManager.getAssociatedTask(changeList)); // association should survive
}
public void testRemoveChangelistViaVcsAction() throws Exception {
Task task = myRepository.findTask("TEST-001");
assertNotNull(task);
activateAndCreateChangelist(task);
myChangeListManager.waitUntilRefreshed();
LocalTask defaultTask = myTaskManager.findTask(LocalTaskImpl.DEFAULT_TASK_ID);
assertNotNull(defaultTask);
activateAndCreateChangelist(defaultTask);
myChangeListManager.waitUntilRefreshed();
assertEquals(defaultTask, myTaskManager.getActiveTask());
LocalTask anotherTask = myTaskManager.findTask("TEST-001");
assertNotNull(anotherTask);
LocalChangeList defaultChangeList =
myChangeListManager.findChangeList(LocalChangeList.DEFAULT_NAME);
assertNotNull(defaultChangeList);
LocalChangeList anotherChangeList = myChangeListManager.findChangeList("TEST-001 Summary");
assertNotNull(anotherChangeList);
removeChangeList(anotherChangeList);
assertEquals(1, anotherTask.getChangeLists().size());
assertEquals(1, defaultTask.getChangeLists().size());
assertEquals(1, myChangeListManager.getChangeListsCopy().size());
assertEquals(defaultTask, myTaskManager.getAssociatedTask(defaultChangeList));
assertEquals(LocalChangeList.DEFAULT_NAME, defaultChangeList.getName());
}
public void mergeBranch(LocalTask task) {
VcsTaskHandler.TaskInfo original = fromBranches(task.getBranches(true));
VcsTaskHandler.TaskInfo feature = fromBranches(task.getBranches(false));
VcsTaskHandler[] handlers = VcsTaskHandler.getAllHandlers(myProject);
for (VcsTaskHandler handler : handlers) {
handler.closeTask(feature, original);
}
}
@Override
public void disassociateFromTask(LocalChangeList changeList) {
ChangeListInfo changeListInfo = new ChangeListInfo(changeList);
for (LocalTask localTask : getLocalTasks()) {
if (localTask.getChangeLists().contains(changeListInfo)) {
localTask.removeChangelist(changeListInfo);
}
}
}
@Override
public void removeTask(LocalTask task) {
if (task.isDefault()) return;
if (myActiveTask.equals(task)) {
activateTask(myTasks.get(LocalTaskImpl.DEFAULT_TASK_ID), true);
}
myTasks.remove(task.getId());
myDispatcher.getMulticaster().taskRemoved(task);
myContextManager.removeContext(task);
}
public void decorateChangeList(
LocalChangeList changeList,
ColoredTreeCellRenderer cellRenderer,
boolean selected,
boolean expanded,
boolean hasFocus) {
LocalTask task = getAssociatedTask(changeList);
if (task != null && task.isIssue()) {
cellRenderer.setIcon(task.getIcon());
}
}
@Nullable
@Override
public LocalTask getAssociatedTask(LocalChangeList list) {
for (LocalTask task : getLocalTasks()) {
for (ChangeListInfo changeListInfo : task.getChangeLists()) {
if (changeListInfo.id.equals(list.getId())) {
return task;
}
}
}
return null;
}
public void initComponent() {
if (!ApplicationManager.getApplication().isUnitTestMode()) {
myCacheRefreshTimer =
UIUtil.createNamedTimer(
"TaskManager refresh",
myConfig.updateInterval * 60 * 1000,
new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (myConfig.updateEnabled && !myUpdating) {
updateIssues(null);
}
}
});
myCacheRefreshTimer.setInitialDelay(0);
StartupManager.getInstance(myProject)
.registerPostStartupActivity(
new Runnable() {
public void run() {
myCacheRefreshTimer.start();
}
});
}
// make sure that the default task is exist
LocalTask defaultTask = findTask(LocalTaskImpl.DEFAULT_TASK_ID);
if (defaultTask == null) {
defaultTask = createDefaultTask();
addTask(defaultTask);
}
// search for active task
LocalTask activeTask = null;
final List<LocalTask> tasks = getLocalTasks();
Collections.sort(tasks, TASK_UPDATE_COMPARATOR);
for (LocalTask task : tasks) {
if (activeTask == null) {
if (task.isActive()) {
activeTask = task;
}
} else {
task.setActive(false);
}
}
if (activeTask == null) {
activeTask = defaultTask;
}
myActiveTask = activeTask;
doActivate(myActiveTask, false);
myDispatcher.getMulticaster().taskActivated(myActiveTask);
}
public void projectOpened() {
TaskProjectConfiguration projectConfiguration = getProjectConfiguration();
servers:
for (TaskProjectConfiguration.SharedServer server : projectConfiguration.servers) {
if (server.type == null || server.url == null) {
continue;
}
for (TaskRepositoryType<?> repositoryType : TaskRepositoryType.getRepositoryTypes()) {
if (repositoryType.getName().equals(server.type)) {
for (TaskRepository repository : myRepositories) {
if (!repositoryType.equals(repository.getRepositoryType())) {
continue;
}
if (server.url.equals(repository.getUrl())) {
continue servers;
}
}
TaskRepository repository = repositoryType.createRepository();
repository.setUrl(server.url);
myRepositories.add(repository);
}
}
}
myContextManager.pack(200, 50);
// make sure the task is associated with default changelist
LocalTask defaultTask = findTask(LocalTaskImpl.DEFAULT_TASK_ID);
LocalChangeList defaultList = myChangeListManager.findChangeList(LocalChangeList.DEFAULT_NAME);
if (defaultList != null && defaultTask != null) {
ChangeListInfo listInfo = new ChangeListInfo(defaultList);
if (!defaultTask.getChangeLists().contains(listInfo)) {
defaultTask.addChangelist(listInfo);
}
}
// remove already not existing changelists from tasks changelists
for (LocalTask localTask : getLocalTasks()) {
for (Iterator<ChangeListInfo> iterator = localTask.getChangeLists().iterator();
iterator.hasNext(); ) {
final ChangeListInfo changeListInfo = iterator.next();
if (myChangeListManager.getChangeList(changeListInfo.id) == null) {
iterator.remove();
}
}
}
myChangeListManager.addChangeListListener(myChangeListListener);
}
private void createChangeList(LocalTask task, String name, @Nullable String comment) {
LocalChangeList changeList = myChangeListManager.findChangeList(name);
if (changeList == null) {
changeList = myChangeListManager.addChangeList(name, comment);
} else {
final LocalTask associatedTask = getAssociatedTask(changeList);
if (associatedTask != null) {
associatedTask.removeChangelist(new ChangeListInfo(changeList));
}
changeList.setComment(comment);
}
task.addChangelist(new ChangeListInfo(changeList));
myChangeListManager.setDefaultChangeList(changeList);
}
public void testTrackContext() {
myTaskManager.getState().trackContextForNewChangelist = true;
addChangeList("New Changelist", "");
assertEquals(2, myTaskManager.getLocalTasks().size());
assertEquals(2, myChangeListManager.getChangeListsCopy().size());
LocalChangeList newChangeList = myChangeListManager.findChangeList("New Changelist");
assertNotNull(newChangeList);
LocalTask newTask = myTaskManager.getAssociatedTask(newChangeList);
assertNotNull(newTask);
assertEquals("New Changelist", newTask.getSummary());
myTaskManager.getState().trackContextForNewChangelist = false;
}
public void testCreateComment() throws Exception {
myRepository.setShouldFormatCommitMessage(true);
myRepository.setCommitMessageFormat("{id} {summary} {number} {project}");
Task task = myRepository.findTask("TEST-001");
assertNotNull(task);
activateAndCreateChangelist(task);
myChangeListManager.waitUntilRefreshed();
LocalTask localTask = myTaskManager.getActiveTask();
assertNotNull(localTask);
assertEquals("TEST-001", localTask.getId());
List<ChangeListInfo> lists = localTask.getChangeLists();
assertEquals(1, lists.size());
assertEquals("TEST-001 Summary 001 TEST", lists.get(0).comment);
}
@Override
public LocalTask put(String key, LocalTask task) {
LocalTask result = super.put(key, task);
if (size() > myConfig.taskHistoryLength) {
ArrayList<LocalTask> list = new ArrayList<LocalTask>(values());
Collections.sort(list, TASK_UPDATE_COMPARATOR);
for (LocalTask oldest : list) {
if (!oldest.isDefault()) {
remove(oldest);
break;
}
}
}
return result;
}
private LocalTask doActivate(Task origin, boolean explicitly) {
final LocalTaskImpl task =
origin instanceof LocalTaskImpl ? (LocalTaskImpl) origin : new LocalTaskImpl(origin);
if (explicitly) {
task.setUpdated(new Date());
}
myActiveTask.setActive(false);
task.setActive(true);
addTask(task);
if (task.isIssue()) {
StartupManager.getInstance(myProject)
.runWhenProjectIsInitialized(
new Runnable() {
public void run() {
ProgressManager.getInstance()
.run(
new com.intellij.openapi.progress.Task.Backgroundable(
myProject, "Updating " + task.getId()) {
public void run(@NotNull ProgressIndicator indicator) {
updateIssue(task.getId());
}
});
}
});
}
LocalTask oldActiveTask = myActiveTask;
boolean isChanged = !task.equals(oldActiveTask);
myActiveTask = task;
if (isChanged) {
myDispatcher.getMulticaster().taskDeactivated(oldActiveTask);
myDispatcher.getMulticaster().taskActivated(task);
}
return task;
}
public void testInitialState() {
assertEquals(1, myTaskManager.getLocalTasks().size());
final LocalTask defaultTask = myTaskManager.getLocalTasks().get(0);
assertEquals(defaultTask, myTaskManager.getActiveTask());
assertTrue(defaultTask.isDefault());
assertEquals(1, myChangeListManager.getChangeListsCopy().size());
assertEquals(1, defaultTask.getChangeLists().size());
assertEquals(
defaultTask,
myTaskManager.getAssociatedTask(myChangeListManager.getChangeListsCopy().get(0)));
assertEquals(
defaultTask.getChangeLists().get(0).id,
myChangeListManager.getChangeListsCopy().get(0).getId());
assertEquals(
defaultTask.getChangeLists().get(0),
new ChangeListInfo(myChangeListManager.getChangeListsCopy().get(0)));
}
@Override
public boolean isLocallyClosed(final LocalTask localTask) {
if (isVcsEnabled()) {
List<ChangeListInfo> lists = localTask.getChangeLists();
if (lists.isEmpty()) return true;
for (ChangeListInfo list : lists) {
if (StringUtil.isEmpty(list.id)) {
return true;
}
}
}
return false;
}
@Nullable
@Override
public Task updateIssue(@NotNull String id) {
for (TaskRepository repository : getAllRepositories()) {
if (repository.extractId(id) == null) {
continue;
}
try {
Task issue = repository.findTask(id);
if (issue != null) {
LocalTask localTask = findTask(id);
if (localTask != null) {
localTask.updateFromIssue(issue);
return localTask;
}
return issue;
}
} catch (Exception e) {
LOG.info(e);
}
}
return null;
}
private LocalTask restoreVcsContext(LocalTask task) {
if (!isVcsEnabled()) return task;
List<ChangeListInfo> changeLists = task.getChangeLists();
if (!changeLists.isEmpty()) {
ChangeListInfo info = changeLists.get(0);
LocalChangeList changeList = myChangeListManager.getChangeList(info.id);
if (changeList == null) {
changeList = myChangeListManager.addChangeList(info.name, info.comment);
info.id = changeList.getId();
}
myChangeListManager.setDefaultChangeList(changeList);
}
List<BranchInfo> branches = task.getBranches(false);
VcsTaskHandler.TaskInfo info = fromBranches(branches);
VcsTaskHandler[] handlers = VcsTaskHandler.getAllHandlers(myProject);
for (VcsTaskHandler handler : handlers) {
handler.switchToTask(info);
}
return task;
}
public void testSwitchingTasks() throws Exception {
final LocalTask defaultTask = myTaskManager.getLocalTasks().get(0);
Task task = myRepository.findTask("TEST-001");
assertNotNull(task);
myTaskManager.activateTask(task, false);
assertEquals(2, myTaskManager.getLocalTasks().size());
LocalTask localTask = myTaskManager.getActiveTask();
assertEquals(task, localTask);
assertEquals(0, localTask.getChangeLists().size());
assertEquals(1, defaultTask.getChangeLists().size());
assertEquals(1, myChangeListManager.getChangeListsCopy().size());
assertEquals(
defaultTask,
myTaskManager.getAssociatedTask(myChangeListManager.getChangeListsCopy().get(0)));
myTaskManager.activateTask(defaultTask, false);
assertEquals(0, localTask.getChangeLists().size());
assertEquals(1, defaultTask.getChangeLists().size());
assertEquals(1, myChangeListManager.getChangeListsCopy().size());
assertEquals(
defaultTask,
myTaskManager.getAssociatedTask(myChangeListManager.getChangeListsCopy().get(0)));
activateAndCreateChangelist(localTask);
assertEquals(1, localTask.getChangeLists().size());
assertEquals(1, defaultTask.getChangeLists().size());
assertEquals(2, myChangeListManager.getChangeListsCopy().size());
LocalChangeList activeChangeList = myChangeListManager.getDefaultChangeList();
LocalChangeList anotherChangeList =
myChangeListManager
.getChangeListsCopy()
.get(1 - myChangeListManager.getChangeListsCopy().indexOf(activeChangeList));
assertNotNull(activeChangeList);
assertEquals(localTask, myTaskManager.getAssociatedTask(activeChangeList));
assertEquals("TEST-001 Summary", activeChangeList.getName());
assertEquals(defaultTask, myTaskManager.getAssociatedTask(anotherChangeList));
assertEquals(LocalChangeList.DEFAULT_NAME, anotherChangeList.getName());
myTaskManager.activateTask(defaultTask, false);
myChangeListManager.waitUntilRefreshed();
assertEquals(1, localTask.getChangeLists().size());
assertEquals(1, defaultTask.getChangeLists().size());
assertEquals(2, myChangeListManager.getChangeListsCopy().size());
activeChangeList = myChangeListManager.getDefaultChangeList();
anotherChangeList =
myChangeListManager
.getChangeListsCopy()
.get(1 - myChangeListManager.getChangeListsCopy().indexOf(activeChangeList));
assertNotNull(activeChangeList);
assertEquals(defaultTask, myTaskManager.getAssociatedTask(activeChangeList));
assertEquals(LocalChangeList.DEFAULT_NAME, activeChangeList.getName());
assertEquals(localTask, myTaskManager.getAssociatedTask(anotherChangeList));
assertEquals("TEST-001 Summary", anotherChangeList.getName());
}
private static void addBranches(LocalTask task, VcsTaskHandler.TaskInfo info, boolean original) {
List<BranchInfo> branchInfos = BranchInfo.fromTaskInfo(info, original);
for (BranchInfo branchInfo : branchInfos) {
task.addBranch(branchInfo);
}
}
private void activateAndCreateChangelist(Task task) {
LocalTask localTask = myTaskManager.activateTask(task, false);
if (localTask.getChangeLists().isEmpty()) {
myTaskManager.createChangeList(localTask, myTaskManager.getChangelistName(localTask));
}
}
private void saveActiveTask() {
myContextManager.saveContext(myActiveTask);
myActiveTask.setUpdated(new Date());
}
