platform/vcs-impl/testSrc/com/intellij/openapi/vcs/LocalChangesUnderRootsTest.java

   1 /*
   2  * Copyright 2000-2015 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.openapi.vcs;
  17
  18 import com.intellij.openapi.util.Pair;
  19 import com.intellij.openapi.vcs.changes.Change;
  20 import com.intellij.openapi.vcs.changes.ChangeListManager;
  21 import com.intellij.openapi.vcs.changes.ChangeListManagerImpl;
  22 import com.intellij.openapi.vcs.changes.ContentRevision;
  23 import com.intellij.openapi.vcs.changes.committed.MockAbstractVcs;
  24 import com.intellij.openapi.vcs.changes.ui.ChangesComparator;
  25 import com.intellij.openapi.vcs.history.VcsRevisionNumber;
  26 import com.intellij.openapi.vcs.impl.LocalChangesUnderRoots;
  27 import com.intellij.openapi.vcs.impl.projectlevelman.AllVcses;
  28 import com.intellij.openapi.vcs.impl.projectlevelman.AllVcsesI;
  29 import com.intellij.openapi.vfs.VirtualFile;
  30 import com.intellij.testFramework.PlatformTestCase;
  31 import com.intellij.testFramework.VfsTestUtil;
  32 import com.intellij.testFramework.vcs.MockChangeListManager;
  33 import com.intellij.testFramework.vcs.MockContentRevision;
  34 import com.intellij.vcsUtil.VcsUtil;
  35
  36 import java.lang.reflect.Field;
  37 import java.util.*;
  38
  39 /**
  40  * @author Kirill Likhodedov
  41  */
  42 public class LocalChangesUnderRootsTest extends PlatformTestCase {
  43
  44   private LocalChangesUnderRoots myLocalChangesUnderRoots;
  45   private MockChangeListManager myChangeListManager;
  46   private VirtualFile myBaseDir;
  47
  48   @Override
  49   protected void setUp() throws Exception {
  50     super.setUp();
  51
  52     myChangeListManager = new MockChangeListManager();
  53     myBaseDir = myProject.getBaseDir();
  54     myLocalChangesUnderRoots = new LocalChangesUnderRoots(ChangeListManager.getInstance(myProject),
  55                                                           ProjectLevelVcsManager.getInstance(myProject));
  56
  57     substituteChangeListManager();
  58   }
  59
  60   @Override
  61   protected void tearDown() throws Exception {
  62     ((ChangeListManagerImpl) ChangeListManager.getInstance(myProject)).stopEveryThingIfInTestMode();
  63     super.tearDown();
  64   }
  65
  66   // This is not good, but declaring MockChangeListManager might break other tests
  67   private void substituteChangeListManager() throws NoSuchFieldException, IllegalAccessException {
  68     Field myChangeManager = LocalChangesUnderRoots.class.getDeclaredField("myChangeManager");
  69     myChangeManager.setAccessible(true);
  70     myChangeManager.set(myLocalChangesUnderRoots, myChangeListManager);
  71   }
  72
  73   public void testChangesInTwoGitRoots() {
  74     AllVcsesI myVcses = AllVcses.getInstance(myProject);
  75     myVcses.registerManually(new MockAbstractVcs(myProject, "Mock"));
  76
  77     List<VirtualFile> roots = createRootStructure(
  78       Pair.create(myBaseDir.getPath(), "Mock"),
  79       Pair.create("community", "Mock")
  80     );
  81
  82     Change changeBeforeCommunity = createChangeForPath("a.txt");
  83     Change changeAfterCommunity = createChangeForPath("readme.txt");
  84     Change changeInCommunity = createChangeForPath("community/com.txt");
  85     myChangeListManager.addChanges(changeBeforeCommunity, changeAfterCommunity, changeInCommunity);
  86
  87     Map<VirtualFile, Collection<Change>> expected = new HashMap<VirtualFile, Collection<Change>>();
  88     expected.put(roots.get(0), Arrays.asList(changeBeforeCommunity, changeAfterCommunity));
  89     expected.put(roots.get(1), Collections.singletonList(changeInCommunity));
  90
  91     Map<VirtualFile, Collection<Change>> changesUnderRoots = myLocalChangesUnderRoots.getChangesUnderRoots(roots);
  92     assertEqualMaps(expected, changesUnderRoots);
  93   }
  94
  95   private static void assertEqualMaps(Map<VirtualFile, Collection<Change>> expected, Map<VirtualFile, Collection<Change>> actual) {
  96     assertEquals("Maps size is different. " + expectedActualMessage(expected, actual), expected.size(), actual.size());
  97     for (Map.Entry<VirtualFile, Collection<Change>> expectedEntry : expected.entrySet()) {
  98       VirtualFile root = expectedEntry.getKey();
  99       if (!actual.containsKey(root)) {
 100         fail("Didn't find root [" + root + "]. " + expectedActualMessage(expected, actual));
 101       }
 102       List<Change> expectedChanges = new ArrayList<Change>(expectedEntry.getValue());
 103       List<Change> actualChanges = new ArrayList<Change>(actual.get(root));
 104       Collections.sort(expectedChanges, ChangesComparator.getInstance(false));
 105       Collections.sort(actualChanges, ChangesComparator.getInstance(false));
 106       assertEquals("Changes not equal for root [" + root + "]. " + expectedActualMessage(expected, actual), expectedChanges, actualChanges);
 107     }
 108   }
 109
 110   private static String expectedActualMessage(Object expected, Object actual) {
 111     return "\nExpected:\n " + expected + "\nActual:\n" + actual;
 112   }
 113
 114   private List<VirtualFile> createRootStructure(Pair<String, String>... pathAndVcs) {
 115     List<VirtualFile> roots = new ArrayList<VirtualFile>();
 116     List<VcsDirectoryMapping> mappings = new ArrayList<VcsDirectoryMapping>();
 117     for (Pair<String, String> pathAndVc : pathAndVcs) {
 118       String path = pathAndVc.first;
 119       String vcs = pathAndVc.second;
 120
 121       VirtualFile vf;
 122       if (path.equals(myBaseDir.getPath())) {
 123         vf = myBaseDir;
 124       } else {
 125         vf = VfsTestUtil.createDir(myBaseDir, path);
 126       }
 127
 128       mappings.add(new VcsDirectoryMapping(vf.getPath(), vcs));
 129       roots.add(vf);
 130     }
 131     ProjectLevelVcsManager.getInstance(myProject).setDirectoryMappings(mappings);
 132     return roots;
 133   }
 134
 135   private Change createChangeForPath(String path) {
 136     VirtualFile file = VfsTestUtil.createFile(myBaseDir, path);
 137     FilePath filePath = VcsUtil.getFilePath(file);
 138     ContentRevision beforeRevision = new MockContentRevision(filePath, new VcsRevisionNumber.Int(1));
 139     ContentRevision afterRevision = new MockContentRevision(filePath, new VcsRevisionNumber.Int(2));
 140     return new Change(beforeRevision, afterRevision);
 141   }
 142
 143 }