270d8ba550bf86ea05f0554b00b72d9ee43be91a
[teamcity/git-plugin.git] / git-tests / src / jetbrains / buildServer / buildTriggers / vcs / git / tests / AgentVcsSupportTest.java
1 /*
2  * Copyright 2000-2018 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
17 package jetbrains.buildServer.buildTriggers.vcs.git.tests;
18
19 import com.intellij.openapi.util.SystemInfo;
20 import com.intellij.openapi.util.io.StreamUtil;
21 import jetbrains.buildServer.TempFiles;
22 import jetbrains.buildServer.TestInternalProperties;
23 import jetbrains.buildServer.agent.AgentRunningBuild;
24 import jetbrains.buildServer.agent.AgentRuntimeProperties;
25 import jetbrains.buildServer.buildTriggers.vcs.git.*;
26 import jetbrains.buildServer.buildTriggers.vcs.git.Constants;
27 import jetbrains.buildServer.buildTriggers.vcs.git.agent.*;
28 import jetbrains.buildServer.buildTriggers.vcs.git.agent.PluginConfigImpl;
29 import jetbrains.buildServer.buildTriggers.vcs.git.agent.command.FetchCommand;
30 import jetbrains.buildServer.buildTriggers.vcs.git.agent.command.LsRemoteCommand;
31 import jetbrains.buildServer.buildTriggers.vcs.git.agent.command.UpdateRefCommand;
32 import jetbrains.buildServer.buildTriggers.vcs.git.agent.command.impl.*;
33 import jetbrains.buildServer.buildTriggers.vcs.git.agent.errors.GitExecTimeout;
34 import jetbrains.buildServer.ssh.VcsRootSshKeyManager;
35 import jetbrains.buildServer.util.FileUtil;
36 import jetbrains.buildServer.util.TestFor;
37 import jetbrains.buildServer.vcs.CheckoutRules;
38 import jetbrains.buildServer.vcs.VcsException;
39 import jetbrains.buildServer.vcs.impl.VcsRootImpl;
40 import org.eclipse.jgit.api.Git;
41 import org.eclipse.jgit.lib.*;
42 import org.eclipse.jgit.revwalk.RevCommit;
43 import org.eclipse.jgit.transport.URIish;
44 import org.jetbrains.annotations.NotNull;
45 import org.jetbrains.annotations.Nullable;
46 import org.testng.SkipException;
47 import org.testng.annotations.AfterMethod;
48 import org.testng.annotations.BeforeMethod;
49 import org.testng.annotations.DataProvider;
50 import org.testng.annotations.Test;
51
52 import java.io.File;
53 import java.io.FileFilter;
54 import java.io.FileReader;
55 import java.io.IOException;
56 import java.lang.reflect.Method;
57 import java.util.HashMap;
58 import java.util.Map;
59 import java.util.Set;
60 import java.util.concurrent.atomic.AtomicInteger;
61 import java.util.regex.Matcher;
62
63 import static com.intellij.openapi.util.io.FileUtil.copyDir;
64 import static com.intellij.openapi.util.io.FileUtil.delete;
65 import static jetbrains.buildServer.buildTriggers.vcs.git.tests.GitTestUtil.dataFile;
66 import static jetbrains.buildServer.buildTriggers.vcs.git.tests.GitVersionProvider.getGitPath;
67 import static jetbrains.buildServer.buildTriggers.vcs.git.tests.VcsRootBuilder.vcsRoot;
68 import static jetbrains.buildServer.buildTriggers.vcs.git.tests.builders.AgentRunningBuildBuilder.runningBuild;
69 import static jetbrains.buildServer.util.FileUtil.writeFileAndReportErrors;
70 import static jetbrains.buildServer.util.Util.map;
71 import static org.assertj.core.api.BDDAssertions.then;
72 import static org.testng.AssertJUnit.*;
73
74 /**
75  * @author dmitry.neverov
76  */
77 @Test
78 public class AgentVcsSupportTest {
79
80   private TempFiles myTempFiles;
81   private File myMainRepo;
82   private File myCheckoutDir;
83   private VcsRootImpl myRoot;
84   private int myVcsRootId = 0;
85   private GitAgentVcsSupport myVcsSupport;
86   private AgentRunningBuild myBuild;
87   private AgentSupportBuilder myBuilder;
88
89   @BeforeMethod
90   public void setUp() throws Exception {
91     TestInternalProperties.init();
92     myTempFiles = new TempFiles();
93
94     File repositoriesDir = myTempFiles.createTempDir();
95
96     File masterRep = dataFile("repo.git");
97     myMainRepo = new File(repositoriesDir, "repo.git");
98     copyRepository(masterRep, myMainRepo);
99
100     File submoduleRep = dataFile("submodule.git");
101     copyRepository(submoduleRep, new File(repositoriesDir, "submodule.git"));
102
103     File submoduleRep2 = dataFile("sub-submodule.git");
104     copyRepository(submoduleRep2, new File(repositoriesDir, "sub-submodule.git"));
105
106     myCheckoutDir = myTempFiles.createTempDir();
107     myBuilder = new AgentSupportBuilder(myTempFiles);
108     myVcsSupport = myBuilder.build();
109     myBuild = createRunningBuild(true);
110     myRoot = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).build();
111   }
112
113
114   @AfterMethod
115   protected void tearDown() throws Exception {
116     myTempFiles.cleanup();
117   }
118
119
120   @TestFor(issues = "TW-33401")
121   @Test(dataProvider = "mirrors")
122   public void should_not_remove_remote_tracking_branches(Boolean useMirrors) throws Exception {
123     VcsRootSshKeyManagerProvider provider = new VcsRootSshKeyManagerProvider() {
124       @Nullable
125       public VcsRootSshKeyManager getSshKeyManager() {
126         return null;
127       }
128     };
129     LoggingGitMetaFactory loggingFactory = new LoggingGitMetaFactory();
130
131     GitAgentVcsSupport git = myBuilder.setSshKeyProvider(provider).setGitMetaFactory(loggingFactory).build();
132
133     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.USE_MIRRORS, useMirrors.toString()));
134
135     git.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, build, false);
136     loggingFactory.clear();
137
138     //we already have everything we need for this update, no fetch should be executed
139     git.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, build, false);
140
141     assertFalse("Refs removed: " + loggingFactory.getInvokedMethods(UpdateRefCommand.class),
142                 loggingFactory.getInvokedMethods(UpdateRefCommand.class).contains("delete"));
143     assertTrue("Redundant fetch", loggingFactory.getInvokedMethods(FetchCommand.class).isEmpty());
144   }
145
146
147   @TestFor(issues = "TW-42249")
148   public void should_not_invoke_fetch_in_working_dir_after_clean_checkout() throws Exception {
149     VcsRootSshKeyManagerProvider provider = new VcsRootSshKeyManagerProvider() {
150       @Nullable
151       public VcsRootSshKeyManager getSshKeyManager() {
152         return null;
153       }
154     };
155     LoggingGitMetaFactory loggingFactory = new LoggingGitMetaFactory();
156     GitAgentVcsSupport git = myBuilder.setSshKeyProvider(provider).setGitMetaFactory(loggingFactory).build();
157
158     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.VCS_ROOT_MIRRORS_STRATEGY,
159                                                      PluginConfigImpl.VCS_ROOT_MIRRORS_STRATEGY_ALTERNATES));
160
161     myRoot = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).withUseMirrors(true).build();
162     git.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, build, false);
163
164     assertEquals("Redundant fetch", 1, loggingFactory.getNumberOfCalls(FetchCommand.class));
165   }
166
167
168   @TestFor(issues = {"TW-42551", "TW-46857"})
169   public void should_set_remote_tracking_branch() throws Exception {
170     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.VCS_ROOT_MIRRORS_STRATEGY,
171                                                      PluginConfigImpl.VCS_ROOT_MIRRORS_STRATEGY_ALTERNATES));
172
173     myRoot = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).withUseMirrors(true).build();
174     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, build, false);
175
176     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
177     then(new BranchConfig(r.getConfig(), "master").getRemoteTrackingBranch()).isEqualTo("refs/remotes/origin/master");
178
179     //TW-46857
180     myRoot = vcsRoot().withAgentGitPath(getGitPath()).withBranch("personal-branch2").withFetchUrl(GitUtils.toURL(myMainRepo)).withUseMirrors(true).build();
181     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "3df61e6f11a5a9b919cb3f786a83fdd09f058617", myCheckoutDir, build, false);
182     then(new BranchConfig(r.getConfig(), "personal-branch2").getRemoteTrackingBranch()).isEqualTo("refs/remotes/origin/personal-branch2");
183   }
184
185
186   @TestFor(issues = "TW-46854")
187   @Test(dataProvider = "mirrors")
188   public void should_update_remote_tracking_branch_in_case_of_fast_forward_update(boolean useMirrors) throws Exception {
189     File remoteRepo = myTempFiles.createTempDir();
190
191     copyRepository(dataFile("repo_for_fetch.2"), remoteRepo);
192     VcsRootImpl root = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(remoteRepo).withUseMirrors(useMirrors).build();
193     String buildBranchParam = GitUtils.getGitRootBranchParamName(root);
194
195     //run build in master branch
196     AgentRunningBuild build = createRunningBuild(map(buildBranchParam, "refs/heads/master"));
197     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "d47dda159b27b9a8c4cee4ce98e4435eb5b17168", myCheckoutDir, build, false);
198
199     //fast-forward update master to point to the same commit as master
200     Repository remote = new RepositoryBuilder().setGitDir(remoteRepo).build();
201     RefUpdate refUpdate = remote.updateRef("refs/heads/personal");
202     refUpdate.setNewObjectId(ObjectId.fromString("add81050184d3c818560bdd8839f50024c188586"));
203     refUpdate.update();
204
205     //run build in personal branch
206     build = createRunningBuild(map(buildBranchParam, "refs/heads/personal"));
207     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "add81050184d3c818560bdd8839f50024c188586", myCheckoutDir, build, false);
208
209     //fast-forward update personal branch to point to the same commit as master
210     refUpdate = remote.updateRef("refs/heads/personal");
211     refUpdate.setNewObjectId(ObjectId.fromString("d47dda159b27b9a8c4cee4ce98e4435eb5b17168"));
212     refUpdate.update();
213
214     //run build on updated personal branch
215     build = createRunningBuild(map(buildBranchParam, "refs/heads/personal"));
216     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "d47dda159b27b9a8c4cee4ce98e4435eb5b17168", myCheckoutDir, build, false);
217
218     //both branch and its remote-tracking branch should be updated
219     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
220     then(r.getAllRefs().get("refs/heads/personal").getObjectId().name()).isEqualTo("d47dda159b27b9a8c4cee4ce98e4435eb5b17168");
221     then(r.getAllRefs().get("refs/remotes/origin/personal").getObjectId().name()).isEqualTo("d47dda159b27b9a8c4cee4ce98e4435eb5b17168");
222   }
223
224
225   /**
226    * Test work normally if .git/index.lock file exists
227    */
228   public void testRecoverIndexLock() throws Exception {
229     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD,
230                                myCheckoutDir, myBuild, false);
231
232     //emulate incorrect git termination (in this it could leave index.lock file)
233     FileUtil.copy(new File(myCheckoutDir, ".git" + File.separator + "index"),
234                   new File(myCheckoutDir, ".git" + File.separator + "index.lock"));
235
236     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.CUD1_VERSION, myCheckoutDir, myBuild, false);
237   }
238
239
240   /**
241    * Test work normally if .git/refs/heads/<branch>.lock file exists
242    */
243   public void testRecoverRefLock() throws Exception {
244     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, myBuild, false);
245
246     String firstCommitInPatchTests = GitUtils.makeVersion("a894d7d58ffde625019a9ecf8267f5f1d1e5c341", 1245766034000L);
247     myRoot.addProperty(Constants.BRANCH_NAME, "patch-tests");
248     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), firstCommitInPatchTests, myCheckoutDir, myBuild, false);
249
250     myRoot.addProperty(Constants.BRANCH_NAME, "master");
251     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, myBuild, false);
252
253     //emulate incorrect git termination (in this it could leave refs/heads/<branch-name>.lock file)
254     FileUtil.createIfDoesntExist(new File(myCheckoutDir, ".git" + File.separator + GitUtils.expandRef("master") + ".lock"));
255     //should recover from locked ref if previous checkout was on the same branch:
256     myRoot.addProperty(Constants.BRANCH_NAME, "master");
257     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), firstCommitInPatchTests, myCheckoutDir, myBuild, false);
258
259     //emulate incorrect git termination (in this it could leave refs/heads/<branch-name>.lock file)
260     FileUtil.createIfDoesntExist(new File(myCheckoutDir, ".git" + File.separator + GitUtils.expandRef("patch-tests") + ".lock"));
261     //should recover from locked ref if previous checkout was on a different branch:
262     myRoot.addProperty(Constants.BRANCH_NAME, "patch-tests");
263     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), firstCommitInPatchTests, myCheckoutDir, myBuild, false);
264   }
265
266
267   @TestFor(issues = "TW-31381")
268   public void recover_from_ref_lock_during_fetch() throws Exception {
269     File repo = dataFile("repo_for_fetch.2.personal");
270     File remoteRepo = myTempFiles.createTempDir();
271     copyRepository(repo, remoteRepo);
272
273     final String fetchUrl = GitUtils.toURL(remoteRepo);
274     VcsRootImpl root = vcsRoot().withBranch("refs/heads/master").withAgentGitPath(getGitPath()).withFetchUrl(fetchUrl).build();
275     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "add81050184d3c818560bdd8839f50024c188586", myCheckoutDir, myBuild, false);
276
277     //update remote branch master
278     delete(remoteRepo);
279     File updatedRepo = dataFile("repo_for_fetch.2");
280     copyRepository(updatedRepo, remoteRepo);
281
282     File mirror = myBuilder.getMirrorManager().getMirrorDir(fetchUrl);
283     FileUtil.createIfDoesntExist(new File(mirror, "refs/heads/master.lock"));
284     FileUtil.createIfDoesntExist(new File(myCheckoutDir, ".git/refs/heads/master.lock"));
285     FileUtil.createIfDoesntExist(new File(myCheckoutDir, ".git/refs/remotes/origin/master.lock"));
286
287
288     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "d47dda159b27b9a8c4cee4ce98e4435eb5b17168", myCheckoutDir, myBuild, false);
289   }
290
291
292   @TestFor(issues = "TW-31039")
293   @Test(dataProvider = "mirrors")
294   public void build_on_pull_request(Boolean useMirrors) throws Exception {
295     //Remote repo contains a pull request branch refs/changes/2/1 which is not under refs/heads/*,
296     //this branch points to a commit which is not reachable from the default branch in vcs root
297     //and from any other branches under refs/heads/.
298
299     //Ensure that once we pass a pull request branch name, checkout it successful
300     VcsRootImpl root = createRoot(myMainRepo, "master");
301     String pullRequestCommit = "ea5e05051fbfaa7d8da97586807b009cbfebae9d";
302     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.USE_MIRRORS, String.valueOf(useMirrors),
303                                                      GitUtils.getGitRootBranchParamName(root), "refs/changes/2/1"));
304     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, pullRequestCommit, myCheckoutDir, build, false);
305   }
306
307
308   /**
309    * Test checkout submodules on agent. Machine that runs this test should have git installed.
310    */
311   public void testSubmodulesCheckout() throws Exception {
312     myRoot.addProperty(Constants.BRANCH_NAME, "patch-tests");
313     myRoot.addProperty(Constants.SUBMODULES_CHECKOUT, SubmodulesCheckoutPolicy.CHECKOUT.name());
314
315     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.SUBMODULE_ADDED_VERSION,
316                                myCheckoutDir, myBuild, false);
317
318     assertTrue(new File(myCheckoutDir, "submodule" + File.separator + "file.txt").exists());
319   }
320
321
322   /**
323    * Test non-recursive submodules checkout: submodules of submodules are not retrieved
324    */
325   public void testSubSubmodulesCheckoutNonRecursive() throws Exception {
326     testSubSubmoduleCheckout(false);
327   }
328
329
330   /**
331    * Test recursive submodules checkout: submodules of submodules are retrieved
332    */
333   public void testSubSubmodulesCheckoutRecursive() throws Exception {
334     testSubSubmoduleCheckout(true);
335   }
336
337
338   @TestFor(issues = "TW-27043")
339   public void clean_files_in_submodules() throws Exception {
340     //vcs root with submodules which cleans all untracked files on every build:
341     myRoot.addProperty(Constants.BRANCH_NAME, "sub-submodule");
342     myRoot.addProperty(Constants.SUBMODULES_CHECKOUT, SubmodulesCheckoutPolicy.CHECKOUT.name());
343     myRoot.addProperty(Constants.AGENT_CLEAN_FILES_POLICY, AgentCleanFilesPolicy.ALL_UNTRACKED.name());
344     myRoot.addProperty(Constants.AGENT_CLEAN_POLICY, AgentCleanPolicy.ALWAYS.name());
345
346     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "ce6044093939bb47283439d97a1c80f759669ff5", myCheckoutDir, myBuild, false);
347
348     //create untracked files inside submodules
349     File submoduleDir = new File(myCheckoutDir, "first-level-submodule");
350     File subSubmoduleDir = new File(submoduleDir, "sub-sub");
351     File untrackedFileSubmodule = new File(submoduleDir, "untracked");
352     File untrackedFileSubSubmodule = new File(subSubmoduleDir, "untracked");
353     assertTrue(untrackedFileSubmodule.createNewFile());
354     assertTrue(untrackedFileSubSubmodule.createNewFile());
355
356     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "ce6044093939bb47283439d97a1c80f759669ff5", myCheckoutDir, myBuild, false);
357
358     assertFalse(untrackedFileSubmodule.exists());
359     assertFalse(untrackedFileSubSubmodule.exists());
360   }
361
362
363   @DataProvider(name = "ignoredLongFileNames")
364   public Object[][] ignoredLongFileNames() {
365     return new Object[][] {{true}, {false}};
366   }
367
368   @TestFor(issues = "TW-35545")
369   @Test(dataProvider = "ignoredLongFileNames")
370   public void clean_files_with_long_names(Boolean filesWithLongNamesIgnored) throws Exception {
371     myRoot.addProperty(Constants.AGENT_CLEAN_FILES_POLICY, AgentCleanFilesPolicy.ALL_UNTRACKED.name());
372     myRoot.addProperty(Constants.AGENT_CLEAN_POLICY, AgentCleanPolicy.ALWAYS.name());
373
374     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "2276eaf76a658f96b5cf3eb25f3e1fda90f6b653", myCheckoutDir, myBuild, false);
375
376     File dirWithLongName = new File(myCheckoutDir, "dirWithLongName");
377     for (int i = 0; i < 20; i++) {
378       dirWithLongName = new File(dirWithLongName, "dirWithLongName");
379     }
380     dirWithLongName.mkdirs();
381
382     File fileWithLongName = new File(dirWithLongName, "test");
383     writeFileAndReportErrors(fileWithLongName, "test");
384
385     if (filesWithLongNamesIgnored) {
386       File exclude = new File(myCheckoutDir, ".git/info/exclude".replaceAll("/", Matcher.quoteReplacement(File.separator)));
387       writeFileAndReportErrors(exclude, "dirWithLongName\n");
388     }
389
390     assertTrue(fileWithLongName.exists());
391
392     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "2276eaf76a658f96b5cf3eb25f3e1fda90f6b653", myCheckoutDir, myBuild, false);
393
394     assertFalse(fileWithLongName.exists());
395   }
396
397
398   public void should_create_bare_repository_in_caches_dir() throws Exception {
399     File mirrorsDir = myBuilder.getAgentConfiguration().getCacheDirectory("git");
400     assertTrue(mirrorsDir.listFiles(new FileFilter() {
401       public boolean accept(File f) {
402         return f.isDirectory();
403       }
404     }).length == 0);
405
406     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, myBuild, false);
407
408     GitVcsRoot root = new GitVcsRoot(myBuilder.getMirrorManager(), myRoot);
409     File bareRepositoryDir = root.getRepositoryDir();
410     assertTrue(bareRepositoryDir.exists());
411     //check some dirs that should be present in the bare repository:
412     File objectsDir = new File(bareRepositoryDir, "objects");
413     assertTrue(new File(bareRepositoryDir, "info").exists());
414     assertTrue(objectsDir.exists());
415     assertTrue(new File(bareRepositoryDir, "refs").exists());
416
417     String config = FileUtil.loadTextAndClose(new FileReader(new File(bareRepositoryDir, "config")));
418     assertTrue(config.contains("[remote \"origin\"]"));
419     String remoteUrl = "url = " + root.getRepositoryFetchURL();
420     assertTrue(config.contains(remoteUrl));
421
422     File packDir = new File(objectsDir, "pack");
423     boolean looseObjectsExists = objectsDir.listFiles().length > 2;//2 - because there are 2 dirs there: info and pack
424     boolean packFilesExists = packDir.listFiles().length >=2; //at least one pack file with its index exists
425     boolean fetchWasDone = looseObjectsExists || packFilesExists;
426     assertTrue(fetchWasDone);
427   }
428
429
430   public void old_cloned_repository_should_use_local_mirror() throws Exception {
431     AgentRunningBuild buildBeforeUsingMirrors = createRunningBuild(false);
432     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, buildBeforeUsingMirrors, false);
433     AgentRunningBuild buildWithMirrorsEnabled = createRunningBuild(true);
434     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, buildWithMirrorsEnabled, false);
435     GitVcsRoot root = new GitVcsRoot(myBuilder.getMirrorManager(), myRoot);
436     String localMirrorUrl = new URIish(root.getRepositoryDir().toURI().toASCIIString()).toString();
437     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
438     assertEquals(root.getRepositoryFetchURL().toString(), r.getConfig().getString("url", localMirrorUrl, "insteadOf"));
439   }
440
441
442   public void do_not_use_mirror_if_agent_property_set_to_false() throws Exception {
443     AgentRunningBuild build2 = createRunningBuild(false);
444     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, build2, false);
445     File gitConfigFile = new File(myCheckoutDir, ".git" + File.separator + "config");
446     String config = FileUtil.loadTextAndClose(new FileReader(gitConfigFile));
447     assertFalse(config, config.contains("insteadOf"));
448   }
449
450
451   public void stop_use_mirror_if_agent_property_changed_to_false() throws Exception {
452     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, myBuild, false);
453
454     AgentRunningBuild build2 = createRunningBuild(false);
455     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, build2, false);
456
457     File gitConfigFile = new File(myCheckoutDir, ".git" + File.separator + "config");
458     String config = FileUtil.loadTextAndClose(new FileReader(gitConfigFile));
459     assertFalse(config, config.contains("insteadOf"));
460   }
461
462
463   public void stop_use_any_mirror_if_agent_property_changed_to_false() throws Exception {
464     AgentRunningBuild build2 = createRunningBuild(false);
465     GitVcsRoot root = new GitVcsRoot(myBuilder.getMirrorManager(), myRoot);
466     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, build2, false);
467
468     //add some mirror
469     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
470     StoredConfig config = r.getConfig();
471     config.setString("url", "/some/path", "insteadOf", root.getRepositoryFetchURL().toString());
472     config.save();
473
474     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, build2, false);
475     config = new RepositoryBuilder().setWorkTree(myCheckoutDir).build().getConfig();
476     assertTrue(config.getSubsections("url").isEmpty());
477   }
478
479
480   public void stop_using_alternates_when_mirrors_are_disabled_in_vcs_root_option() throws Exception {
481     myRoot = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).withUseMirrors(true).build();
482     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "2276eaf76a658f96b5cf3eb25f3e1fda90f6b653", myCheckoutDir, myBuild, false);
483
484     myRoot = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).withUseMirrors(false).build();
485     AgentRunningBuild build2 = createRunningBuild(false);
486     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "2276eaf76a658f96b5cf3eb25f3e1fda90f6b653", myCheckoutDir, build2, false);
487
488     assertFalse("Build uses alternates when they disabled in VCS root settings",
489                 new File(myCheckoutDir, ".git/objects/info/alternates").exists());
490   }
491
492
493   public void stop_using_alternates_when_mirror_strategy_changed() throws Exception {
494     myRoot = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).withUseMirrors(true).build();
495     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "2276eaf76a658f96b5cf3eb25f3e1fda90f6b653", myCheckoutDir, myBuild, false);
496
497     AgentRunningBuild build2 = createRunningBuild(
498       map(PluginConfigImpl.VCS_ROOT_MIRRORS_STRATEGY, PluginConfigImpl.VCS_ROOT_MIRRORS_STRATEGY_MIRRORS_ONLY));
499     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "2276eaf76a658f96b5cf3eb25f3e1fda90f6b653", myCheckoutDir, build2, false);
500
501     assertFalse("Build uses alternates when they disabled in VCS root settings",
502                 new File(myCheckoutDir, ".git/objects/info/alternates").exists());
503   }
504
505
506   public void stop_using_mirrors_when_mirrors_are_disabled_in_vcs_root_option() throws Exception {
507     myRoot = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).withUseMirrors(true).build();
508     AgentRunningBuild build1 = createRunningBuild(map(PluginConfigImpl.VCS_ROOT_MIRRORS_STRATEGY, PluginConfigImpl.VCS_ROOT_MIRRORS_STRATEGY_MIRRORS_ONLY));
509     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "2276eaf76a658f96b5cf3eb25f3e1fda90f6b653", myCheckoutDir, build1, false);
510
511     myRoot = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).withUseMirrors(false).build();
512     AgentRunningBuild build2 = createRunningBuild(false);
513     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "2276eaf76a658f96b5cf3eb25f3e1fda90f6b653", myCheckoutDir, build2, false);
514
515     StoredConfig config = new RepositoryBuilder().setWorkTree(myCheckoutDir).build().getConfig();
516     assertTrue(config.getSubsections("url").isEmpty());
517   }
518
519
520   @TestFor(issues = "TW-25839")
521   public void update_should_not_fail_if_local_mirror_is_corrupted() throws Exception {
522     AgentRunningBuild buildWithMirrorsEnabled = createRunningBuild(true);
523     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, buildWithMirrorsEnabled, false);
524
525     //corrupt local mirror
526     GitVcsRoot root = new GitVcsRoot(myBuilder.getMirrorManager(), myRoot);
527     File mirror = myBuilder.getMirrorManager().getMirrorDir(root.getRepositoryFetchURL().toString());
528     File[] children = mirror.listFiles();
529     if (children != null) {
530       for (File child : children) {
531         delete(child);
532       }
533     }
534
535     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, buildWithMirrorsEnabled,
536                                false);
537   }
538
539
540   @TestFor(issues = "TW-29291")
541   public void shallow_clone_should_check_if_auxiliary_branch_already_exists() throws Exception {
542     AgentRunningBuild build = createRunningBuild(new HashMap<String, String>() {{
543       put(PluginConfigImpl.USE_MIRRORS, "true");
544       put(PluginConfigImpl.USE_SHALLOW_CLONE, "true");
545     }});
546     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "2276eaf76a658f96b5cf3eb25f3e1fda90f6b653", myCheckoutDir, build, true);
547
548     //manually create a branch tmp_branch_for_build with, it seems like it wasn't removed due to errors in previous checkouts
549     GitVcsRoot root = new GitVcsRoot(myBuilder.getMirrorManager(), myRoot);
550     File mirror = myBuilder.getMirrorManager().getMirrorDir(root.getRepositoryFetchURL().toString());
551     File emptyBranchFile = new File(mirror, "refs" + File.separator + "heads" + File.separator + "tmp_branch_for_build");
552     FileUtil.writeToFile(emptyBranchFile, "2276eaf76a658f96b5cf3eb25f3e1fda90f6b653\n".getBytes());
553
554     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "2276eaf76a658f96b5cf3eb25f3e1fda90f6b653", myCheckoutDir, build, true);
555   }
556
557
558   public void when_fetch_for_mirror_failed_remove_it_and_try_again() throws Exception {
559     File repo = dataFile("repo_for_fetch.1");
560     File remoteRepo = myTempFiles.createTempDir();
561     copyRepository(repo, remoteRepo);
562
563     VcsRootImpl root = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(remoteRepo)).build();
564
565     AgentRunningBuild buildWithMirrors = createRunningBuild(true);
566     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "add81050184d3c818560bdd8839f50024c188586", myCheckoutDir, buildWithMirrors, false);
567
568     //create branch tmp in the mirror
569     File mirror = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(remoteRepo));
570     Repository r = new RepositoryBuilder().setBare().setGitDir(mirror).build();
571     RefUpdate update = r.updateRef("refs/heads/tmp");
572     update.setNewObjectId(ObjectId.fromString("add81050184d3c818560bdd8839f50024c188586"));
573     update.update();
574
575     //update remote repo
576     delete(remoteRepo);
577     File updatedRepo = dataFile("repo_for_fetch.2.personal");
578     copyRepository(updatedRepo, remoteRepo);
579
580     //create branch tmp/1 in remote repo, so fetch will fail
581     r = new RepositoryBuilder().setBare().setGitDir(remoteRepo).build();
582     update = r.updateRef("refs/heads/tmp/1");
583     update.setNewObjectId(ObjectId.fromString("d47dda159b27b9a8c4cee4ce98e4435eb5b17168"));
584     update.update();
585
586     //update succeeds
587     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "d47dda159b27b9a8c4cee4ce98e4435eb5b17168", myCheckoutDir, buildWithMirrors, false);
588   }
589
590
591   public void should_handle_ref_pointing_to_invalid_object() throws Exception {
592     File repo = dataFile("repo_for_fetch.1");
593     File remoteRepo = myTempFiles.createTempDir();
594     copyRepository(repo, remoteRepo);
595     VcsRootImpl root = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(remoteRepo)).withUseMirrors(true).build();
596
597     //first build
598     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.VCS_ROOT_MIRRORS_STRATEGY, PluginConfigImpl.VCS_ROOT_MIRRORS_STRATEGY_ALTERNATES));
599     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "add81050184d3c818560bdd8839f50024c188586", myCheckoutDir, build, false);
600
601     //create ref pointing to invalid object
602     File gitDir = new File(myCheckoutDir, ".git");
603     String invalidObject = "bba7fbcc200b4968e6abd2f7d475dc15306cafc1";
604     FileUtil.writeFile(new File(gitDir, "refs/heads/brokenRef"), invalidObject);
605
606     //update remote repo
607     delete(remoteRepo);
608     File updatedRepo = dataFile("repo_for_fetch.3");
609     copyRepository(updatedRepo, remoteRepo);
610
611     //second build
612     build = createRunningBuild(map(PluginConfigImpl.VCS_ROOT_MIRRORS_STRATEGY, PluginConfigImpl.VCS_ROOT_MIRRORS_STRATEGY_ALTERNATES));
613     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "bba7fbcc200b4968e6abd2f7d475dc15306cafc6", myCheckoutDir, build, false);
614     then(new File(gitDir, "refs/heads/brokenRef")).doesNotExist();
615   }
616
617
618   @TestFor(issues = "TW-43884")
619   public void should_remap_mirror_if_its_fetch_and_remove_failed() throws Exception {
620     MockFS fs = new MockFS();
621     LoggingGitMetaFactory loggingFactory = new LoggingGitMetaFactory();
622     myVcsSupport = myBuilder.setGitMetaFactory(loggingFactory).setFS(fs).build();
623
624     File repo = dataFile("repo_for_fetch.1");
625     File remoteRepo = myTempFiles.createTempDir();
626     copyRepository(repo, remoteRepo);
627
628     //run build to prepare mirror
629     VcsRootImpl root = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(remoteRepo)).build();
630     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "add81050184d3c818560bdd8839f50024c188586", myCheckoutDir, createRunningBuild(true), false);
631
632     //update remote repo: add personal branch
633     delete(remoteRepo);
634     File updatedRepo = dataFile("repo_for_fetch.2.personal");
635     copyRepository(updatedRepo, remoteRepo);
636
637
638     //make first fetch in local mirror to fail:
639     AtomicInteger invocationCount = new AtomicInteger(0);
640     loggingFactory.addCallback(FetchCommand.class.getName() + ".call", new GitCommandProxyCallback() {
641       @Override
642       public void call(final Method method, final Object[] args) throws VcsException {
643         if (invocationCount.getAndIncrement() == 0)
644           throw new VcsException("TEST ERROR");
645       }
646     });
647     File mirror = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(remoteRepo));
648
649     //try to fetch unknown branch, fetch fails and delete of the mirror also fails
650     //build should succeed anyway
651     fs.makeDeleteFail(mirror);
652     VcsRootImpl root2 = vcsRoot().withAgentGitPath(getGitPath()).withBranch("refs/heads/personal").withFetchUrl(GitUtils.toURL(remoteRepo)).build();
653     AgentRunningBuild build = runningBuild()
654       .useLocalMirrors(true)
655       .sharedConfigParams("teamcity.git.fetchMirrorRetryTimeouts", "")
656       .build();
657     myVcsSupport.updateSources(root2, CheckoutRules.DEFAULT, "d47dda159b27b9a8c4cee4ce98e4435eb5b17168", myCheckoutDir, build, false);
658     File mirrorAfterBuild = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(remoteRepo));
659     then(mirrorAfterBuild).isNotEqualTo(mirror);//repository was remapped to another dir
660   }
661
662   @TestFor(issues = "TW-56415")
663   public void should_retry_fetch_mirror() throws Exception {
664     MockFS fs = new MockFS();
665     LoggingGitMetaFactory loggingFactory = new LoggingGitMetaFactory();
666     myVcsSupport = myBuilder.setGitMetaFactory(loggingFactory).setFS(fs).build();
667
668     File repo = dataFile("repo_for_fetch.1");
669     File remoteRepo = myTempFiles.createTempDir();
670     copyRepository(repo, remoteRepo);
671
672     //run build to prepare mirror
673     VcsRootImpl root = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(remoteRepo)).build();
674     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "add81050184d3c818560bdd8839f50024c188586", myCheckoutDir, createRunningBuild(true), false);
675
676     //update remote repo: add personal branch
677     delete(remoteRepo);
678     File updatedRepo = dataFile("repo_for_fetch.2.personal");
679     copyRepository(updatedRepo, remoteRepo);
680
681
682     //make first fetch in local mirror to fail:
683     AtomicInteger invocationCount = new AtomicInteger(0);
684     loggingFactory.addCallback(FetchCommand.class.getName() + ".call", new GitCommandProxyCallback() {
685       @Override
686       public void call(final Method method, final Object[] args) throws VcsException {
687         if (invocationCount.getAndIncrement() == 0)
688           throw new VcsException("TEST ERROR");
689       }
690     });
691     File mirror = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(remoteRepo));
692
693     //try to fetch unknown branch, first fetch fails, second succeeds. If it's not ensure that delete of the mirror also fails
694     //build should succeed anyway
695     fs.makeDeleteFail(mirror);
696     VcsRootImpl root2 = vcsRoot().withAgentGitPath(getGitPath()).withBranch("refs/heads/personal").withFetchUrl(GitUtils.toURL(remoteRepo)).build();
697     AgentRunningBuild build = runningBuild()
698       .useLocalMirrors(true)
699       .sharedConfigParams("teamcity.git.fetchMirrorRetryTimeouts", "0")
700       .build();
701     myVcsSupport.updateSources(root2, CheckoutRules.DEFAULT, "d47dda159b27b9a8c4cee4ce98e4435eb5b17168", myCheckoutDir, build, false);
702     File mirrorAfterBuild = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(remoteRepo));
703     then(mirrorAfterBuild).isEqualTo(mirror);//repository was remapped to another dir
704   }
705
706
707   //we run ls-remote during outdated refs cleanup which is needed to
708   //successfully checkout when ref a/b is renamed to A/b on win or mac (TW-28735).
709   //If we continue silently this can cause performance problems (TW-44944)
710   @TestFor(issues = "TW-44944")
711   public void should_fail_when_ls_remote_fails() throws Exception {
712     LoggingGitMetaFactory loggingFactory = new LoggingGitMetaFactory();
713     myVcsSupport = myBuilder.setGitMetaFactory(loggingFactory).build();
714
715     File repo = dataFile("repo_for_fetch.1");
716     File remoteRepo = myTempFiles.createTempDir();
717     copyRepository(repo, remoteRepo);
718
719     //run build to prepare working dir
720     VcsRootImpl root = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(remoteRepo)).build();
721     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "add81050184d3c818560bdd8839f50024c188586", myCheckoutDir, createRunningBuild(false), false);
722
723     loggingFactory.addCallback(LsRemoteCommand.class.getName() + ".call", new GitCommandProxyCallback() {
724       @Override
725       public void call(final Method method, final Object[] args) throws VcsException {
726         throw new VcsException("TEST ERROR");
727       }
728     });
729
730     //ls-remote will fail during this build
731     try {
732       myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "d47dda159b27b9a8c4cee4ce98e4435eb5b17168", myCheckoutDir, createRunningBuild(false), false);
733       fail("should fail");
734     } catch (VcsException e) {
735       assertTrue(true);
736     }
737   }
738
739
740   public void do_not_delete_mirror_if_remote_ref_not_found() throws Exception {
741     MockFS fs = new MockFS();
742     myVcsSupport = myBuilder.setFS(fs).build();
743
744     File mirror = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(myMainRepo));
745     fs.makeDeleteFail(mirror);//if plugin will remove mirror it will fail and try to remap
746     myRoot = vcsRoot().withBranch("refs/heads/unknown").withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).build();
747     try {
748       String unknownRevision = "abababababababababababababababababababab";
749       myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, unknownRevision, myCheckoutDir, createRunningBuild(true), false);
750       fail("update on unknown branch should fail");
751     } catch (VcsException e) {
752       File mirrorAfterFailure = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(myMainRepo));
753       then(mirrorAfterFailure).isEqualTo(mirror);//failure should not cause delete or remap
754     }
755   }
756
757
758   public void do_not_delete_mirror_on_timeout() throws Exception {
759     MockFS fs = new MockFS();
760     myVcsSupport = myBuilder.setFS(fs).build();
761
762     String unreachableRepository = "git://some.org/unreachable.git";
763     File mirror = myBuilder.getMirrorManager().getMirrorDir(unreachableRepository);
764     fs.makeDeleteFail(mirror);//if plugin will remove mirror it will fail and try to remap
765     myRoot = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(unreachableRepository).build();
766     try {
767       String revision = "abababababababababababababababababababab";
768       AgentRunningBuild build = runningBuild().useLocalMirrors(true).sharedConfigParams("teamcity.git.idle.timeout.seconds", "1").build();
769       myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, revision, myCheckoutDir, build, false);
770       fail("update on unreachable repository should fail");
771     } catch (VcsException e) {
772       if (e instanceof GitExecTimeout) {
773         File mirrorAfterFailure = myBuilder.getMirrorManager().getMirrorDir(unreachableRepository);
774         then(mirrorAfterFailure)
775           .overridingErrorMessage("Mirror changed after error " + e.toString())
776           .isEqualTo(mirror);//failure should not cause delete or remap
777       } else {
778         //on some platforms fetch from unknown host doesn't result in timeout error
779         throw new SkipException("Not a timeout error: " + e.toString());
780       }
781     }
782   }
783
784
785   @TestFor(issues = "TW-43884")
786   public void mirror_delete_can_be_disabled() throws Exception {
787     MockFS fs = new MockFS();
788     LoggingGitMetaFactory loggingFactory = new LoggingGitMetaFactory();
789     myVcsSupport = myBuilder.setGitMetaFactory(loggingFactory).setFS(fs).build();
790
791     File repo = dataFile("repo_for_fetch.1");
792     File remoteRepo = myTempFiles.createTempDir();
793     copyRepository(repo, remoteRepo);
794
795     //run build to prepare mirror
796     VcsRootImpl root = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(remoteRepo)).build();
797     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "add81050184d3c818560bdd8839f50024c188586", myCheckoutDir, createRunningBuild(true), false);
798
799     //update remote repo: add personal branch
800     delete(remoteRepo);
801     File updatedRepo = dataFile("repo_for_fetch.2.personal");
802     copyRepository(updatedRepo, remoteRepo);
803
804
805     //create refs/heads/personal/1 so that incremental fetch will fail
806     AtomicInteger invocationCount = new AtomicInteger(0);
807     loggingFactory.addCallback(FetchCommand.class.getName() + ".call", new GitCommandProxyCallback() {
808       @Override
809       public void call(final Method method, final Object[] args) throws VcsException {
810         if (invocationCount.getAndIncrement() <= 1)
811           throw new VcsException("TEST ERROR");
812       }
813     });
814     File mirror = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(remoteRepo));
815
816     VcsRootImpl root2 = vcsRoot().withAgentGitPath(getGitPath()).withBranch("refs/heads/personal").withFetchUrl(GitUtils.toURL(remoteRepo)).build();
817     fs.makeDeleteFail(mirror);
818     try {
819       AgentRunningBuild build = runningBuild()
820         .useLocalMirrors(true)
821         .sharedConfigParams(AgentRuntimeProperties.FAIL_ON_CLEAN_CHECKOUT, "true")
822         .sharedConfigParams("teamcity.git.fetchMirrorRetryTimeouts", "0")
823         .build();
824       myVcsSupport.updateSources(root2, CheckoutRules.DEFAULT, "d47dda159b27b9a8c4cee4ce98e4435eb5b17168", myCheckoutDir, build, false);
825       fail("Should fail");
826     } catch (VcsException e) {
827       File mirrorAfterBuild = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(remoteRepo));
828       then(mirrorAfterBuild).isEqualTo(mirror);//should fail on first fetch attempt and not remap or delete the mirror
829     }
830   }
831
832
833   public void checkout_tag() throws Exception {
834     myRoot.addProperty(Constants.BRANCH_NAME, "refs/tags/v1.0");
835     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, myBuild, false);
836
837     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
838     Ref tagRef = r.getRef("refs/tags/v1.0");
839     assertNotNull(tagRef);
840   }
841
842
843   @TestFor(issues = "TW-38247")
844   public void checkout_revision_reachable_from_tag() throws Exception {
845     myRoot.addProperty(Constants.BRANCH_NAME, "refs/tags/v1.0");
846     String revisionInBuild = "2c7e90053e0f7a5dd25ea2a16ef8909ba71826f6";
847     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, revisionInBuild, myCheckoutDir, myBuild, false);
848
849     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
850     String workingDirRevision = r.getAllRefs().get("HEAD").getObjectId().name();
851     assertEquals("Wrong revision on agent", revisionInBuild, workingDirRevision);
852   }
853
854
855   public void do_not_create_branch_when_checkout_tag() throws Exception {
856     myRoot.addProperty(Constants.BRANCH_NAME, "refs/tags/v1.0");
857     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, myBuild, false);
858
859     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
860     Map<String, Ref> refs = r.getRefDatabase().getRefs("refs/");
861     assertTrue(refs.containsKey("tags/v1.0"));
862     assertTrue(refs.containsKey("tags/v0.7"));//it is reachable from refs/tags/v1.0
863     assertTrue(refs.containsKey("tags/v0.5"));//also reachable
864     assertEquals(3, refs.size());
865   }
866
867
868   @TestFor(issues = "TW-23707")
869   public void do_not_create_remote_branch_unexisting_in_remote_repository() throws Exception {
870     myRoot.addProperty(Constants.BRANCH_NAME, "refs/changes/1/1");
871     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "5711cbfe566b6c92e331f95d4b236483f4532eed", myCheckoutDir, myBuild, false);
872     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
873     assertEquals("5711cbfe566b6c92e331f95d4b236483f4532eed", r.getBranch());//checkout a detached commit
874     Map<String, Ref> refs = r.getAllRefs();
875     assertFalse(refs.containsKey("refs/heads/refs/changes/1/1"));
876     assertFalse(refs.containsKey("refs/remotes/origin/changes/1/1"));
877   }
878
879
880   public void checkout_tag_after_branch() throws Exception {
881     myRoot.addProperty(Constants.BRANCH_NAME, "sub-submodule");
882     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, myBuild, false);
883
884     myRoot.addProperty(Constants.BRANCH_NAME, "refs/tags/v1.0");
885     myVcsSupport.updateSources(myRoot, new CheckoutRules(""),
886                                GitUtils.makeVersion("465ad9f630e451b9f2b782ffb09804c6a98c4bb9", 1289483394000L), myCheckoutDir, myBuild,
887                                false);
888     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
889     Ref headRef = r.getRef("HEAD");
890     assertEquals("465ad9f630e451b9f2b782ffb09804c6a98c4bb9", headRef.getObjectId().name());
891   }
892
893
894   public void should_checkout_tags_reachable_from_branch() throws Exception {
895     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, myBuild, false);
896     assertTagExists("refs/tags/v0.5");
897     assertTagExists("refs/tags/v1.0");
898   }
899
900
901   @Test(dataProvider = "mirrors")
902   public void deleted_tag_in_remote_repository_should_be_deleted_in_local_repository(Boolean useMirrors) throws Exception {
903     AgentRunningBuild build = createRunningBuild(useMirrors);
904     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, build, false);
905     removeTag(myMainRepo, "refs/tags/v0.5");
906
907     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, build, false);
908     assertNoTagExist("refs/tags/v0.5");
909   }
910
911
912   @Test(dataProvider = "mirrors")
913   public void updated_tag_in_remote_repository_should_be_updated_in_local_repository(Boolean useMirrors) throws Exception {
914     AgentRunningBuild build = createRunningBuild(useMirrors);
915     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, build, false);
916
917     final String newCommit = "2c7e90053e0f7a5dd25ea2a16ef8909ba71826f6";
918     updateRef(myMainRepo, "refs/tags/v1.0", newCommit);
919
920     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, build, false);
921     assertTagExists("refs/tags/v1.0");
922     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
923     Ref tag = r.getRef("refs/tags/v1.0");
924     assertEquals("Local tag is not updated", newCommit, tag.getObjectId().name());
925   }
926
927
928   @TestFor(issues = "TW-47805")
929   public void no_redundant_fetches_for_pull_requests() throws Exception {
930     LoggingGitMetaFactory loggingFactory = new LoggingGitMetaFactory();
931     myVcsSupport = myBuilder.setGitMetaFactory(loggingFactory).setFS(new MockFS()).build();
932
933     //create pull-request in remote repo
934     myRoot.addProperty(Constants.BRANCH_NAME, "refs/changes/1/1");
935     updateRef(myMainRepo, "refs/pull/1/head", "5711cbfe566b6c92e331f95d4b236483f4532eed");
936
937     //run build on pull-request
938     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "5711cbfe566b6c92e331f95d4b236483f4532eed", myCheckoutDir, myBuild, false);
939
940     //run build again
941     int fetchesBefore = loggingFactory.getNumberOfCalls(FetchCommand.class);
942     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "5711cbfe566b6c92e331f95d4b236483f4532eed", myCheckoutDir, myBuild, false);
943
944     //there should be no fetches in the second build
945     int redundantFetches = loggingFactory.getNumberOfCalls(FetchCommand.class) - fetchesBefore;
946     then(redundantFetches).isEqualTo(0);
947   }
948
949
950   @Test(dataProvider = "mirrors")
951   public void fetch_all_heads(boolean useMirrors) throws Exception {
952     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.USE_MIRRORS, String.valueOf(useMirrors),
953                                                      PluginConfigImpl.FETCH_ALL_HEADS, "true"));
954
955     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, build, false);
956
957     Repository remoteRepo = new RepositoryBuilder().setBare().setGitDir(myMainRepo).build();
958     Set<String> remoteHeads = remoteRepo.getRefDatabase().getRefs("refs/heads/").keySet();
959
960     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
961     then(r.getRefDatabase().getRefs("refs/remotes/origin/").keySet()).containsAll(remoteHeads);
962   }
963
964
965   @TestFor(issues = "TW-50714")
966   @Test(dataProvider = "mirrors")
967   public void fetch_all_heads__non_head_ref(boolean useMirrors) throws Exception {
968     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.FETCH_ALL_HEADS, "true"));
969
970     myRoot = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).withUseMirrors(useMirrors).withBranch("refs/pull/1").build();
971
972     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "b896070465af79121c9a4eb5300ecff29453c164", myCheckoutDir, build, false);
973   }
974
975
976   @Test(dataProvider = "mirrors")
977   public void fetch_all_heads_before_build_branch(boolean useMirrors) throws Exception {
978     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.USE_MIRRORS, String.valueOf(useMirrors),
979                                                      PluginConfigImpl.FETCH_ALL_HEADS, "beforeBuildBranch"));
980
981     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, build, false);
982
983     Repository remoteRepo = new RepositoryBuilder().setBare().setGitDir(myMainRepo).build();
984     Set<String> remoteHeads = remoteRepo.getRefDatabase().getRefs("refs/heads/").keySet();
985
986     //local repo should contain all heads since build's commit wasn't on the agent
987     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
988     then(r.getRefDatabase().getRefs("refs/remotes/origin/").keySet()).containsAll(remoteHeads);
989   }
990
991
992   @Test(dataProvider = "mirrors")
993   public void fetch_all_heads_before_build_branch_commit_found(boolean useMirrors) throws Exception {
994     //run build to make sure commit is on the agent
995     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.USE_MIRRORS, String.valueOf(useMirrors)));
996     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, build, false);
997
998     //run build with fetch_all_head before build's branch
999     build = createRunningBuild(map(PluginConfigImpl.USE_MIRRORS, String.valueOf(useMirrors),
1000                                    PluginConfigImpl.FETCH_ALL_HEADS, "beforeBuildBranch"));
1001     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, build, false);
1002
1003     //local repo shouldn't contain all heads since build commit was already on the agent and no fetch is required
1004     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
1005     then(r.getRefDatabase().getRefs("refs/remotes/origin/").keySet()).containsOnly("master");
1006   }
1007
1008
1009   private void removeTag(@NotNull File dotGitDir, @NotNull String tagName) {
1010     delete(tagFile(dotGitDir, tagName));
1011   }
1012
1013   private void updateRef(@NotNull File dotGitDir, @NotNull String refName, @NotNull String commit) throws IOException {
1014     File tagFile = tagFile(dotGitDir, refName);
1015     FileUtil.writeToFile(tagFile, commit.getBytes());
1016   }
1017
1018   private File tagFile(@NotNull File dotGitDir, @NotNull String tagName) {
1019     return new File(dotGitDir, tagName.replaceAll("/", Matcher.quoteReplacement(File.separator)));
1020   }
1021
1022   private void assertNoTagExist(String tag) throws IOException {
1023     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
1024     assertNull("tag \'" + tag + "\' exists", r.getRef(tag));
1025   }
1026
1027   private void assertTagExists(String tag) throws IOException {
1028     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
1029     assertNotNull("tag \'" + tag + "\' doesn't exist", r.getRef(tag));
1030   }
1031
1032   @DataProvider(name = "mirrors")
1033   public Object[][] mirrors() {
1034     return new Object[][] {{true}, {false}};
1035   }
1036
1037   @Test(dataProvider = "mirrors")
1038   public void should_do_fetch_if_ref_is_outdated(Boolean useMirrors) throws Exception {
1039     AgentRunningBuild build = createRunningBuild(useMirrors);
1040     final File remote = myTempFiles.createTempDir();
1041     copyRepository(dataFile("repo_for_fetch.2.personal"), remote);
1042     VcsRootImpl masterRoot = createRoot(remote, "master");
1043     VcsRootImpl personalRoot = createRoot(remote, "personal");
1044
1045     myVcsSupport.updateSources(personalRoot, new CheckoutRules(""), "d47dda159b27b9a8c4cee4ce98e4435eb5b17168@1303829462000", myCheckoutDir, build, false);
1046     myVcsSupport.updateSources(masterRoot,   new CheckoutRules(""), "add81050184d3c818560bdd8839f50024c188586@1303829295000", myCheckoutDir, build, false);
1047
1048     FileUtil.delete(remote);
1049     copyRepository(dataFile("repo_for_fetch.2"), remote);
1050
1051     myVcsSupport.updateSources(masterRoot, new CheckoutRules(""), "d47dda159b27b9a8c4cee4ce98e4435eb5b17168@1303829462000", myCheckoutDir,
1052                                build, false);
1053   }
1054
1055
1056   @Test(dataProvider = "mirrors")
1057   public void test_update_on_revision_from_feature_branch(Boolean useMirrors) throws Exception {
1058     AgentRunningBuild build = createRunningBuild(useMirrors);
1059     final File remote = myTempFiles.createTempDir();
1060     copyRepository(dataFile("repo_for_fetch.2.personal"), remote);
1061     VcsRootImpl root = createRoot(remote, "master");
1062     String commitFromFeatureBranch = "d47dda159b27b9a8c4cee4ce98e4435eb5b17168";
1063     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, commitFromFeatureBranch, myCheckoutDir, build, false);
1064   }
1065
1066
1067   @Test(dataProvider = "mirrors")
1068   public void should_use_branch_specified_in_build_parameter(Boolean useMirrors) throws Exception {
1069     final File remote = myTempFiles.createTempDir();
1070     copyRepository(dataFile("repo_for_fetch.2.personal"), remote);
1071     VcsRootImpl root = createRoot(remote, "master");
1072
1073     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.USE_MIRRORS, String.valueOf(useMirrors)));
1074     String commitFromFeatureBranch = "d47dda159b27b9a8c4cee4ce98e4435eb5b17168";
1075     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, commitFromFeatureBranch, myCheckoutDir, build, false);
1076     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
1077     assertEquals("master", r.getBranch());
1078
1079     build = createRunningBuild(map(PluginConfigImpl.USE_MIRRORS, String.valueOf(useMirrors),
1080                                    GitUtils.getGitRootBranchParamName(root), "refs/heads/personal"));
1081     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, commitFromFeatureBranch, myCheckoutDir, build, false);
1082     r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
1083     assertEquals("personal", r.getBranch());
1084   }
1085
1086
1087   @Test
1088   public void test_shallow_clone() throws Exception {
1089     AgentRunningBuild build = createRunningBuild(new HashMap<String, String>() {{
1090       put(PluginConfigImpl.USE_MIRRORS, "true");
1091       put(PluginConfigImpl.USE_SHALLOW_CLONE, "true");
1092     }});
1093     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, build, false);
1094   }
1095
1096
1097   @TestFor(issues = "TW-27677")
1098   public void shallow_clone_in_non_master_branch() throws Exception {
1099     AgentRunningBuild build = createRunningBuild(new HashMap<String, String>() {{
1100       put(PluginConfigImpl.USE_MIRRORS, "true");
1101       put(PluginConfigImpl.USE_SHALLOW_CLONE, "true");
1102       put(GitUtils.getGitRootBranchParamName(myRoot), "refs/heads/version-test");//build on non-master branch
1103     }});
1104     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "2276eaf76a658f96b5cf3eb25f3e1fda90f6b653", myCheckoutDir, build, false);
1105   }
1106
1107
1108   @TestFor(issues = "TW-37122")
1109   public void shallow_clone_on_tag() throws Exception {
1110     myRoot.addProperty(Constants.BRANCH_NAME, "refs/tags/v1.0");
1111     AgentRunningBuild build = createRunningBuild(new HashMap<String, String>() {{
1112       put(PluginConfigImpl.USE_MIRRORS, "true");
1113       put(PluginConfigImpl.USE_SHALLOW_CLONE, "true");
1114     }});
1115     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, build, false);
1116   }
1117
1118
1119   @TestFor(issues = "TW-20165")
1120   public void push_with_local_mirrors_should_go_to_original_repository() throws Exception {
1121     AgentRunningBuild build = createRunningBuild(true);
1122     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitUtils.makeVersion("465ad9f630e451b9f2b782ffb09804c6a98c4bb9", 1289483394000L), myCheckoutDir, build, false);
1123
1124     final File fileToChange = new File(myCheckoutDir, "file");
1125     FileUtil.writeToFile(fileToChange, "text".getBytes());
1126
1127     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
1128     Git git = new Git(r);
1129     git.add().addFilepattern("file").call();
1130     RevCommit commitDuringTheBuild = git.commit().setMessage("Commit during the build").call();
1131     new PushCommand().run(getGitPath(), myCheckoutDir.getAbsolutePath());//push using native git, seems like jgit doesn't respect url.insteadOf settings
1132
1133     Repository remote = new RepositoryBuilder().setGitDir(myMainRepo).build();
1134     assertTrue("Push didn't go to the remote repository", remote.hasObject(commitDuringTheBuild));
1135   }
1136
1137
1138   @TestFor(issues = "TW-28735")
1139   public void fetch_branch_with_same_name_but_different_register() throws Exception {
1140     AgentRunningBuild buildWithMirrorsEnabled = createRunningBuild(true);
1141     myRoot = vcsRoot().withBranch("refs/heads/master").withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).build();
1142     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, buildWithMirrorsEnabled, false);
1143
1144     //rename master->Master
1145     Repository r = new RepositoryBuilder().setGitDir(myMainRepo).build();
1146     r.renameRef("refs/heads/master", "refs/heads/Master").rename();
1147
1148     myRoot = vcsRoot().withBranch("refs/heads/Master").withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).build();
1149     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, buildWithMirrorsEnabled, false);
1150   }
1151
1152
1153   @TestFor(issues = "TW-46266")
1154   public void should_not_use_custom_clone_on_server() throws Exception {
1155     File serverCustomCloneDir = myTempFiles.createTempDir();
1156     VcsRootImpl root = vcsRoot()
1157       .withAgentGitPath(getGitPath())
1158       .withFetchUrl(GitUtils.toURL(myMainRepo))
1159       .withRepositoryPathOnServer(serverCustomCloneDir.getCanonicalPath())
1160       .build();
1161
1162     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, createRunningBuild(true), false);
1163
1164     then(serverCustomCloneDir.listFiles()).isEmpty();
1165   }
1166
1167
1168   @TestFor(issues = "TW-44844")
1169   @Test(dataProviderClass = BaseRemoteRepositoryTest.class, dataProvider = "true,false")
1170   public void handle_files_marked_as_unchanged(boolean switchBranch) throws Exception {
1171     //checkout
1172     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "97442a720324a0bd092fb9235f72246dc8b345bc", myCheckoutDir, myBuild, false);
1173
1174     //modify file
1175     File f = new File(myCheckoutDir, "dir/a.txt");
1176     writeFileAndReportErrors(f, "update by build script");
1177
1178     //git update-index --no-assume-unchanged <file>
1179     Process updateIndex = new ProcessBuilder().directory(myCheckoutDir).command(getGitPath(), "update-index", "--assume-unchanged", "dir/a.txt").start();
1180     updateIndex.waitFor();
1181     if (updateIndex.exitValue() != 0) {
1182       fail("git update-index failed, exit code " + updateIndex.exitValue() +
1183            "\nstdout: " + StreamUtil.readText(updateIndex.getInputStream()) +
1184            "\nstderr: " + StreamUtil.readText(updateIndex.getErrorStream()));
1185     }
1186
1187     //update to commit which changes the file
1188     if (switchBranch)
1189       myBuild = createRunningBuild(map(GitUtils.getGitRootBranchParamName(myRoot), "refs/heads/personal-branch1"));
1190     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "ad4528ed5c84092fdbe9e0502163cf8d6e6141e7", myCheckoutDir, myBuild, false);
1191     then(FileUtil.readFile(f)).doesNotContain("update by build script");
1192   }
1193
1194
1195   @TestFor(issues = "TW-40313")
1196   public void should_remove_orphaned_indexes() throws Exception {
1197     //checkout
1198     VcsRootImpl root = vcsRoot()
1199       .withAgentGitPath(getGitPath())
1200       .withFetchUrl(GitUtils.toURL(myMainRepo))
1201       .build();
1202
1203     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, createRunningBuild(true), false);
1204
1205     //create orphaned idx files
1206     File mirror = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(myMainRepo));
1207     File idxInMirror = new File(new File(new File(mirror, "objects"), "pack"), "whatever.idx");
1208     FileUtil.writeFileAndReportErrors(idxInMirror, "whatever");
1209     File idxInCheckoutDir = new File(new File(new File(mirror, "objects"), "pack"), "whatever.idx");
1210     FileUtil.writeFileAndReportErrors(idxInCheckoutDir, "whatever");
1211
1212     //checkout again
1213     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, createRunningBuild(true), false);
1214
1215     //orphaned idx files are removed
1216     then(idxInCheckoutDir).doesNotExist();
1217     then(idxInMirror).doesNotExist();
1218   }
1219
1220
1221   private VcsRootImpl createRoot(final File remote, final String branch) throws IOException {
1222     myVcsRootId++;
1223     return new VcsRootImpl(myVcsRootId, new HashMap<String, String>() {{
1224       put(VcsRootImpl.VCS_NAME_PROP, Constants.VCS_NAME);
1225       put(VcsRootImpl.VCS_ROOT_NAME_PROP, "test" + myVcsRootId);
1226       put(Constants.FETCH_URL, GitUtils.toURL(remote));
1227       put(Constants.AGENT_GIT_PATH, getGitPath());
1228       put(Constants.BRANCH_NAME, branch);
1229     }});
1230   }
1231
1232
1233   private void testSubSubmoduleCheckout(boolean recursiveSubmoduleCheckout) throws Exception {
1234     myRoot.addProperty(Constants.BRANCH_NAME, "sub-submodule");
1235     if (recursiveSubmoduleCheckout) {
1236       myRoot.addProperty(Constants.SUBMODULES_CHECKOUT, SubmodulesCheckoutPolicy.CHECKOUT.name());
1237     } else {
1238       myRoot.addProperty(Constants.SUBMODULES_CHECKOUT, SubmodulesCheckoutPolicy.NON_RECURSIVE_CHECKOUT.name());
1239     }
1240
1241     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.AFTER_FIRST_LEVEL_SUBMODULE_ADDED_VERSION,
1242                                myCheckoutDir, myBuild, false);
1243
1244     assertTrue(new File(myCheckoutDir, "first-level-submodule" + File.separator + "submoduleFile.txt").exists());
1245     if (recursiveSubmoduleCheckout) {
1246       assertTrue(new File (myCheckoutDir, "first-level-submodule" + File.separator + "sub-sub" + File.separator + "file.txt").exists());
1247       assertTrue(new File (myCheckoutDir, "first-level-submodule" + File.separator + "sub-sub" + File.separator + "new file.txt").exists());
1248     } else {
1249       assertFalse(new File (myCheckoutDir, "first-level-submodule" + File.separator + "sub-sub" + File.separator + "file.txt").exists());
1250       assertFalse(new File (myCheckoutDir, "first-level-submodule" + File.separator + "sub-sub" + File.separator + "new file.txt").exists());
1251     }
1252   }
1253
1254
1255   private AgentRunningBuild createRunningBuild(boolean useLocalMirrors) {
1256     return runningBuild().useLocalMirrors(useLocalMirrors).build();
1257   }
1258
1259
1260   private AgentRunningBuild createRunningBuild(final Map<String, String> sharedConfigParameters) {
1261     return runningBuild().sharedConfigParams(sharedConfigParameters).build();
1262   }
1263
1264
1265   private void copyRepository(File src, File dst) throws IOException {
1266     copyDir(src, dst);
1267     new File(dst, "refs" + File.separator + "heads").mkdirs();
1268   }
1269
1270
1271   private class PushCommand {
1272     void run(String gitPath, String workDirectory) throws Exception {
1273       File tmpDir = new File(FileUtil.getTempDirectory());
1274       GitCommandLine cmd = new GitCommandLine(null, SystemInfo.isUnix ? new UnixScriptGen(tmpDir, new EscapeEchoArgumentUnix())
1275                                                                       : new WinScriptGen(tmpDir, new EscapeEchoArgumentWin()),
1276                                               tmpDir,
1277                                               true,
1278                                               GitProgressLogger.NO_OP,
1279                                               GitVersion.MIN,
1280                                               new HashMap<String, String>(),
1281                                               new NoBuildContext());
1282       cmd.setExePath(gitPath);
1283       cmd.setWorkingDirectory(new File(workDirectory));
1284       cmd.addParameters("push", "origin", "master");
1285       CommandUtil.runCommand(cmd);
1286     }
1287   }
1288 }