@Test
public void testEditComment() throws Exception {
enableSilentOperation(VcsConfiguration.StandardConfirmation.ADD);
final VirtualFile file = createFileInCommand("a.txt", "old content");
final ChangeListManager changeListManager = ChangeListManager.getInstance(myProject);
changeListManager.ensureUpToDate(false);
final String listName = "test";
final LocalChangeList list = changeListManager.addChangeList(listName, null);
changeListManager.moveChangesTo(list, new Change[] {changeListManager.getChange(file)});
final String finalText = "final text";
myScheme.doTest(
new Runnable() {
public void run() {
final String intermediate = "intermediate text";
changeListManager.editComment(list.getName(), intermediate);
assert changeListManager.findChangeList(listName) != null;
LocalChangeList list = changeListManager.findChangeList(listName);
assert intermediate.equals(list.getComment());
changeListManager.editComment(list.getName(), finalText);
list = changeListManager.findChangeList(listName);
assert finalText.equals(list.getComment());
}
});
LocalChangeList changedList = changeListManager.findChangeList(listName);
assert finalText.equals(changedList.getComment());
changeListManager.ensureUpToDate(false);
changedList = changeListManager.findChangeList(listName);
assert finalText.equals(changedList.getComment());
}
@Test
public void testRemove() throws Exception {
enableSilentOperation(VcsConfiguration.StandardConfirmation.ADD);
final VirtualFile file = createFileInCommand("a.txt", "old content");
final VirtualFile fileB = createFileInCommand("b.txt", "old content");
final ChangeListManager changeListManager = ChangeListManager.getInstance(myProject);
changeListManager.ensureUpToDate(false);
final LocalChangeList list = changeListManager.addChangeList("test", null);
changeListManager.moveChangesTo(list, new Change[] {changeListManager.getChange(file)});
myScheme.doTest(
new Runnable() {
@Override
public void run() {
changeListManager.removeChangeList(list.getName());
assert changeListManager.findChangeList(list.getName()) == null;
checkFilesAreInList(
new VirtualFile[] {file, fileB}, myDefaulListName, changeListManager);
}
});
assert changeListManager.findChangeList(list.getName()) == null;
checkFilesAreInList(new VirtualFile[] {file, fileB}, myDefaulListName, changeListManager);
changeListManager.ensureUpToDate(false);
assert changeListManager.findChangeList(list.getName()) == null;
checkFilesAreInList(new VirtualFile[] {file, fileB}, myDefaulListName, changeListManager);
}
@Test
public void testSetActive() throws Exception {
enableSilentOperation(VcsConfiguration.StandardConfirmation.ADD);
final VirtualFile file = createFileInCommand("a.txt", "old content");
final ChangeListManager changeListManager = ChangeListManager.getInstance(myProject);
changeListManager.ensureUpToDate(false);
final LocalChangeList list = changeListManager.addChangeList("test", null);
final LocalChangeList target = changeListManager.addChangeList("target", null);
changeListManager.moveChangesTo(list, new Change[] {changeListManager.getChange(file)});
myScheme.doTest(
new Runnable() {
@Override
public void run() {
changeListManager.setDefaultChangeList(target);
assert changeListManager.getDefaultChangeList().getName().equals(target.getName());
}
});
assert changeListManager.getDefaultChangeList().getName().equals(target.getName());
changeListManager.ensureUpToDate(false);
assert changeListManager.getDefaultChangeList().getName().equals(target.getName());
}
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 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
}
@Test
public void testDoubleMoveBack() throws Exception {
enableSilentOperation(VcsConfiguration.StandardConfirmation.ADD);
final VirtualFile file = createFileInCommand("a.txt", "old content");
final ChangeListManager changeListManager = ChangeListManager.getInstance(myProject);
changeListManager.ensureUpToDate(false);
final LocalChangeList list = changeListManager.addChangeList("test", null);
final LocalChangeList target = changeListManager.addChangeList("target", null);
changeListManager.moveChangesTo(list, new Change[] {changeListManager.getChange(file)});
myScheme.doTest(
new Runnable() {
@Override
public void run() {
changeListManager.moveChangesTo(
target, new Change[] {changeListManager.getChange(file)});
checkFilesAreInList(new VirtualFile[] {file}, target.getName(), changeListManager);
changeListManager.moveChangesTo(list, new Change[] {changeListManager.getChange(file)});
checkFilesAreInList(new VirtualFile[] {file}, list.getName(), changeListManager);
}
});
checkFilesAreInList(new VirtualFile[] {file}, list.getName(), changeListManager);
changeListManager.ensureUpToDate(false);
checkFilesAreInList(new VirtualFile[] {file}, list.getName(), changeListManager);
}
public void processChangeLists(final List<LocalChangeList> lists) {
final ProjectLevelVcsManager plVcsManager =
ProjectLevelVcsManager.getInstanceChecked(myProject);
plVcsManager.startBackgroundVcsOperation();
try {
final SVNChangelistClient client = createChangelistClient();
for (LocalChangeList list : lists) {
if (!list.isDefault()) {
final Collection<Change> changes = list.getChanges();
for (Change change : changes) {
correctListForRevision(
plVcsManager, change.getBeforeRevision(), client, list.getName());
correctListForRevision(plVcsManager, change.getAfterRevision(), client, list.getName());
}
}
}
} finally {
final Application appManager = ApplicationManager.getApplication();
if (appManager.isDispatchThread()) {
appManager.executeOnPooledThread(
new Runnable() {
@Override
public void run() {
plVcsManager.stopBackgroundVcsOperation();
}
});
} else {
plVcsManager.stopBackgroundVcsOperation();
}
}
}
@Override
public void rebuildList() {
if (myInRebuildList) return;
try {
myInRebuildList = true;
if (myChangesToDisplay == null) {
// changes set not fixed === local changes
final ChangeListManager manager = ChangeListManager.getInstance(myProject);
myChangeListsMap = new HashMap<Change, LocalChangeList>();
final List<LocalChangeList> lists = manager.getChangeListsCopy();
Collection<Change> allChanges = new ArrayList<Change>();
for (LocalChangeList list : lists) {
final Collection<Change> changes = list.getChanges();
allChanges.addAll(changes);
for (Change change : changes) {
myChangeListsMap.put(change, list);
}
}
myAllChanges = allChanges;
// refresh selected list also
updateListsInChooser();
}
super.rebuildList();
if (myRebuildListListener != null) {
myRebuildListListener.run();
}
} finally {
myInRebuildList = false;
}
}
private static String debugRealListContent(final LocalChangeList list) {
final StringBuilder sb = new StringBuilder(list.getName() + ": ");
final Collection<Change> changeCollection = list.getChanges();
for (Change change : changeCollection) {
sb.append(change.toString()).append(' ');
}
return sb.toString();
}
@Override
public void trackContext(LocalChangeList changeList) {
ChangeListInfo changeListInfo = new ChangeListInfo(changeList);
String changeListName = changeList.getName();
LocalTaskImpl task = createLocalTask(changeListName);
task.addChangelist(changeListInfo);
addTask(task);
if (changeList.isDefault()) {
activateTask(task, false);
}
}
private Intersection getMergeAllIntersection(List<LocalChangeList> localChangeLists) {
final Intersection intersection = new Intersection();
for (LocalChangeList localChangeList : localChangeLists) {
final Collection<Change> localChanges = localChangeList.getChanges();
for (Change localChange : localChanges) {
intersection.add(localChangeList.getName(), localChangeList.getComment(), localChange);
}
}
return intersection;
}
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);
}
@Nullable
private static Consumer<Collection<FilePath>> createMover(
final Project project, final LocalChangeList targetChangeList) {
final ChangeListManager clm = ChangeListManager.getInstance(project);
if (targetChangeList == null || clm.getDefaultListName().equals(targetChangeList.getName()))
return null;
return new FilesMover(clm, targetChangeList);
}
@Nullable
private Intersection checkIntersection(
@Nullable final List<CommittedChangeList> lists, List<LocalChangeList> localChangeLists) {
if (lists == null || lists.isEmpty()) {
return null;
}
final Set<FilePath> mergePaths = new HashSet<FilePath>();
for (CommittedChangeList list : lists) {
final SvnChangeList svnList = (SvnChangeList) list;
final List<String> paths = new ArrayList<String>(svnList.getAddedPaths());
paths.addAll(svnList.getChangedPaths());
paths.addAll(svnList.getDeletedPaths());
for (String path : paths) {
final File localPath = getLocalPath(path);
if (localPath != null) {
mergePaths.add(new FilePathImpl(localPath, false));
}
}
}
final Intersection intersection = new Intersection();
for (LocalChangeList localChangeList : localChangeLists) {
final Collection<Change> localChanges = localChangeList.getChanges();
for (Change localChange : localChanges) {
final FilePath before =
localChange.getBeforeRevision() == null
? null
: localChange.getBeforeRevision().getFile();
final FilePath after =
localChange.getAfterRevision() == null
? null
: localChange.getAfterRevision().getFile();
if ((before != null && mergePaths.contains(before))
|| (after != null && mergePaths.contains(after))) {
intersection.add(localChangeList.getName(), localChangeList.getComment(), localChange);
}
}
}
return intersection;
}
public static void checkFilesAreInList(
final String listName, final ChangeListManager manager, final VirtualFile... files) {
assert manager.findChangeList(listName) != null;
final LocalChangeList list = manager.findChangeList(listName);
final Collection<Change> changes = list.getChanges();
assert changes.size() == files.length
: "size: " + changes.size() + " " + debugRealListContent(list);
for (Change change : changes) {
final VirtualFile vf = change.getAfterRevision().getFile().getVirtualFile();
boolean found = false;
for (VirtualFile file : files) {
if (file.equals(vf)) {
found = true;
break;
}
}
assert found == true : debugRealListContent(list);
}
}
@Override
public void onChangeListSelected(LocalChangeList list) {
Object data = list.getData();
if (data instanceof VcsFullCommitDetails) {
VcsFullCommitDetails commit = (VcsFullCommitDetails) data;
String author =
String.format("%s <%s>", commit.getAuthor().getName(), commit.getAuthor().getEmail());
myAuthor.getEditor().setItem(author);
myAuthorDate = new Date(commit.getTime());
}
}
public static void checkDeletedFilesAreInList(
final VirtualFile[] files, final String listName, final ChangeListManager manager) {
assert manager.findChangeList(listName) != null;
final LocalChangeList list = manager.findChangeList(listName);
final Collection<Change> changes = list.getChanges();
assert changes.size() == files.length : debugRealListContent(list);
for (Change change : changes) {
final File vf = change.getBeforeRevision().getFile().getIOFile();
boolean found = false;
for (VirtualFile vfile : files) {
final File file = new File(vfile.getPath());
if (file.equals(vf)) {
found = true;
break;
}
}
assert found == true : debugRealListContent(list);
}
}
@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;
}
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;
}
private void createChangelist(final ContinuationPause context) {
final ChangeListManager listManager = ChangeListManager.getInstance(myProject);
String name = myTitle;
int i = 1;
boolean updateDefaultList = false;
while (true) {
final LocalChangeList changeList = listManager.findChangeList(name);
if (changeList == null) {
final LocalChangeList newList = listManager.addChangeList(name, null);
listManager.setDefaultChangeList(newList);
updateDefaultList = true;
break;
}
if (changeList.getChanges().isEmpty()) {
if (!changeList.isDefault()) {
listManager.setDefaultChangeList(changeList);
updateDefaultList = true;
}
break;
}
name = myTitle + " (" + i + ")";
++i;
}
if (updateDefaultList) {
context.suspend();
listManager.invokeAfterUpdate(
new Runnable() {
public void run() {
context.ping();
}
},
InvokeAfterUpdateMode.BACKGROUND_NOT_CANCELLABLE_NOT_AWT,
"",
ModalityState.NON_MODAL);
}
}
public void testSaveContextOnCommit() throws Exception {
myTaskManager.getState().saveContextOnCommit = true;
assertEquals(1, myTaskManager.getLocalTasks().size());
assertEquals(1, myChangeListManager.getChangeListsCopy().size());
LocalChangeList changeList = addChangeList("New Changelist", "");
assertEquals(1, myTaskManager.getLocalTasks().size());
assertEquals(2, myChangeListManager.getChangeListsCopy().size());
CommitChangeListDialog.commitChanges(
getProject(), Collections.<Change>emptyList(), changeList, null, changeList.getName());
assertEquals(2, myTaskManager.getLocalTasks().size()); // extra task created
assertEquals(2, myChangeListManager.getChangeListsCopy().size());
assertTrue(
ContainerUtil.exists(
myTaskManager.getLocalTasks(),
task -> {
return task.getSummary().equals("New Changelist");
}));
}
@Override
public void render(
final ChangesBrowserNodeRenderer renderer,
final boolean selected,
final boolean expanded,
final boolean hasFocus) {
if (userObject instanceof LocalChangeList) {
final LocalChangeList list = ((LocalChangeList) userObject);
renderer.appendTextWithIssueLinks(
list.getName(),
list.isDefault()
? SimpleTextAttributes.REGULAR_BOLD_ATTRIBUTES
: SimpleTextAttributes.REGULAR_ATTRIBUTES);
appendCount(renderer);
for (ChangeListDecorator decorator : myDecorators) {
decorator.decorateChangeList(list, renderer, selected, expanded, hasFocus);
}
final String freezed = myClManager.isFreezed();
if (freezed != null) {
renderer.append(" " + freezed, SimpleTextAttributes.GRAYED_ATTRIBUTES);
} else if (myClManager.isInUpdate()) {
renderer.append(
" " + VcsBundle.message("changes.nodetitle.updating"),
SimpleTextAttributes.GRAYED_ATTRIBUTES);
}
if (!myChangeListRemoteState.getState()) {
renderer.append(" ");
renderer.append(
VcsBundle.message("changes.nodetitle.have.outdated.files"),
SimpleTextAttributes.ERROR_ATTRIBUTES);
}
} else {
renderer.append(getUserObject().getName(), SimpleTextAttributes.SIMPLE_CELL_ATTRIBUTES);
appendCount(renderer);
}
}
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());
}
