Ability to fetch all heads only if build's commit is not found on the agent
[teamcity/git-plugin.git] / git-tests / src / jetbrains / buildServer / buildTriggers / vcs / git / tests / AgentVcsSupportTest.java
1 /*
2  * Copyright 2000-2014 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     myVcsSupport.updateSources(root2, CheckoutRules.DEFAULT, "d47dda159b27b9a8c4cee4ce98e4435eb5b17168", myCheckoutDir, createRunningBuild(true), false);
654     File mirrorAfterBuild = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(remoteRepo));
655     then(mirrorAfterBuild).isNotEqualTo(mirror);//repository was remapped to another dir
656   }
657
658
659   //we run ls-remote during outdated refs cleanup which is needed to
660   //successfully checkout when ref a/b is renamed to A/b on win or mac (TW-28735).
661   //If we continue silently this can cause performance problems (TW-44944)
662   @TestFor(issues = "TW-44944")
663   public void should_fail_when_ls_remote_fails() throws Exception {
664     LoggingGitMetaFactory loggingFactory = new LoggingGitMetaFactory();
665     myVcsSupport = myBuilder.setGitMetaFactory(loggingFactory).build();
666
667     File repo = dataFile("repo_for_fetch.1");
668     File remoteRepo = myTempFiles.createTempDir();
669     copyRepository(repo, remoteRepo);
670
671     //run build to prepare working dir
672     VcsRootImpl root = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(remoteRepo)).build();
673     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "add81050184d3c818560bdd8839f50024c188586", myCheckoutDir, createRunningBuild(false), false);
674
675     loggingFactory.addCallback(LsRemoteCommand.class.getName() + ".call", new GitCommandProxyCallback() {
676       @Override
677       public void call(final Method method, final Object[] args) throws VcsException {
678         throw new VcsException("TEST ERROR");
679       }
680     });
681
682     //ls-remote will fail during this build
683     try {
684       myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "d47dda159b27b9a8c4cee4ce98e4435eb5b17168", myCheckoutDir, createRunningBuild(false), false);
685       fail("should fail");
686     } catch (VcsException e) {
687       assertTrue(true);
688     }
689   }
690
691
692   public void do_not_delete_mirror_if_remote_ref_not_found() throws Exception {
693     MockFS fs = new MockFS();
694     myVcsSupport = myBuilder.setFS(fs).build();
695
696     File mirror = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(myMainRepo));
697     fs.makeDeleteFail(mirror);//if plugin will remove mirror it will fail and try to remap
698     myRoot = vcsRoot().withBranch("refs/heads/unknown").withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).build();
699     try {
700       String unknownRevision = "abababababababababababababababababababab";
701       myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, unknownRevision, myCheckoutDir, createRunningBuild(true), false);
702       fail("update on unknown branch should fail");
703     } catch (VcsException e) {
704       File mirrorAfterFailure = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(myMainRepo));
705       then(mirrorAfterFailure).isEqualTo(mirror);//failure should not cause delete or remap
706     }
707   }
708
709
710   public void do_not_delete_mirror_on_timeout() throws Exception {
711     MockFS fs = new MockFS();
712     myVcsSupport = myBuilder.setFS(fs).build();
713
714     String unreachableRepository = "git://some.org/unreachable.git";
715     File mirror = myBuilder.getMirrorManager().getMirrorDir(unreachableRepository);
716     fs.makeDeleteFail(mirror);//if plugin will remove mirror it will fail and try to remap
717     myRoot = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(unreachableRepository).build();
718     try {
719       String revision = "abababababababababababababababababababab";
720       AgentRunningBuild build = runningBuild().useLocalMirrors(true).sharedConfigParams("teamcity.git.idle.timeout.seconds", "1").build();
721       myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, revision, myCheckoutDir, build, false);
722       fail("update on unreachable repository should fail");
723     } catch (VcsException e) {
724       if (e instanceof GitExecTimeout) {
725         File mirrorAfterFailure = myBuilder.getMirrorManager().getMirrorDir(unreachableRepository);
726         then(mirrorAfterFailure)
727           .overridingErrorMessage("Mirror changed after error " + e.toString())
728           .isEqualTo(mirror);//failure should not cause delete or remap
729       } else {
730         //on some platforms fetch from unknown host doesn't result in timeout error
731         throw new SkipException("Not a timeout error: " + e.toString());
732       }
733     }
734   }
735
736
737   @TestFor(issues = "TW-43884")
738   public void mirror_delete_can_be_disabled() throws Exception {
739     MockFS fs = new MockFS();
740     LoggingGitMetaFactory loggingFactory = new LoggingGitMetaFactory();
741     myVcsSupport = myBuilder.setGitMetaFactory(loggingFactory).setFS(fs).build();
742
743     File repo = dataFile("repo_for_fetch.1");
744     File remoteRepo = myTempFiles.createTempDir();
745     copyRepository(repo, remoteRepo);
746
747     //run build to prepare mirror
748     VcsRootImpl root = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(remoteRepo)).build();
749     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "add81050184d3c818560bdd8839f50024c188586", myCheckoutDir, createRunningBuild(true), false);
750
751     //update remote repo: add personal branch
752     delete(remoteRepo);
753     File updatedRepo = dataFile("repo_for_fetch.2.personal");
754     copyRepository(updatedRepo, remoteRepo);
755
756
757     //create refs/heads/personal/1 so that incremental fetch will fail
758     AtomicInteger invocationCount = new AtomicInteger(0);
759     loggingFactory.addCallback(FetchCommand.class.getName() + ".call", new GitCommandProxyCallback() {
760       @Override
761       public void call(final Method method, final Object[] args) throws VcsException {
762         if (invocationCount.getAndIncrement() == 0)
763           throw new VcsException("TEST ERROR");
764       }
765     });
766     File mirror = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(remoteRepo));
767
768     VcsRootImpl root2 = vcsRoot().withAgentGitPath(getGitPath()).withBranch("refs/heads/personal").withFetchUrl(GitUtils.toURL(remoteRepo)).build();
769     fs.makeDeleteFail(mirror);
770     try {
771       AgentRunningBuild build = runningBuild().useLocalMirrors(true).sharedConfigParams(AgentRuntimeProperties.FAIL_ON_CLEAN_CHECKOUT, "true").build();
772       myVcsSupport.updateSources(root2, CheckoutRules.DEFAULT, "d47dda159b27b9a8c4cee4ce98e4435eb5b17168", myCheckoutDir, build, false);
773       fail("Should fail");
774     } catch (VcsException e) {
775       File mirrorAfterBuild = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(remoteRepo));
776       then(mirrorAfterBuild).isEqualTo(mirror);//should fail on first fetch attempt and not remap or delete the mirror
777     }
778   }
779
780
781   public void checkout_tag() throws Exception {
782     myRoot.addProperty(Constants.BRANCH_NAME, "refs/tags/v1.0");
783     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, myBuild, false);
784
785     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
786     Ref tagRef = r.getRef("refs/tags/v1.0");
787     assertNotNull(tagRef);
788   }
789
790
791   @TestFor(issues = "TW-38247")
792   public void checkout_revision_reachable_from_tag() throws Exception {
793     myRoot.addProperty(Constants.BRANCH_NAME, "refs/tags/v1.0");
794     String revisionInBuild = "2c7e90053e0f7a5dd25ea2a16ef8909ba71826f6";
795     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, revisionInBuild, myCheckoutDir, myBuild, false);
796
797     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
798     String workingDirRevision = r.getAllRefs().get("HEAD").getObjectId().name();
799     assertEquals("Wrong revision on agent", revisionInBuild, workingDirRevision);
800   }
801
802
803   public void do_not_create_branch_when_checkout_tag() throws Exception {
804     myRoot.addProperty(Constants.BRANCH_NAME, "refs/tags/v1.0");
805     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, myBuild, false);
806
807     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
808     Map<String, Ref> refs = r.getRefDatabase().getRefs("refs/");
809     assertTrue(refs.containsKey("tags/v1.0"));
810     assertTrue(refs.containsKey("tags/v0.7"));//it is reachable from refs/tags/v1.0
811     assertTrue(refs.containsKey("tags/v0.5"));//also reachable
812     assertEquals(3, refs.size());
813   }
814
815
816   @TestFor(issues = "TW-23707")
817   public void do_not_create_remote_branch_unexisting_in_remote_repository() throws Exception {
818     myRoot.addProperty(Constants.BRANCH_NAME, "refs/changes/1/1");
819     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "5711cbfe566b6c92e331f95d4b236483f4532eed", myCheckoutDir, myBuild, false);
820     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
821     assertEquals("5711cbfe566b6c92e331f95d4b236483f4532eed", r.getBranch());//checkout a detached commit
822     Map<String, Ref> refs = r.getAllRefs();
823     assertFalse(refs.containsKey("refs/heads/refs/changes/1/1"));
824     assertFalse(refs.containsKey("refs/remotes/origin/changes/1/1"));
825   }
826
827
828   public void checkout_tag_after_branch() throws Exception {
829     myRoot.addProperty(Constants.BRANCH_NAME, "sub-submodule");
830     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, myBuild, false);
831
832     myRoot.addProperty(Constants.BRANCH_NAME, "refs/tags/v1.0");
833     myVcsSupport.updateSources(myRoot, new CheckoutRules(""),
834                                GitUtils.makeVersion("465ad9f630e451b9f2b782ffb09804c6a98c4bb9", 1289483394000L), myCheckoutDir, myBuild,
835                                false);
836     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
837     Ref headRef = r.getRef("HEAD");
838     assertEquals("465ad9f630e451b9f2b782ffb09804c6a98c4bb9", headRef.getObjectId().name());
839   }
840
841
842   public void should_checkout_tags_reachable_from_branch() throws Exception {
843     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, myBuild, false);
844     assertTagExists("refs/tags/v0.5");
845     assertTagExists("refs/tags/v1.0");
846   }
847
848
849   @Test(dataProvider = "mirrors")
850   public void deleted_tag_in_remote_repository_should_be_deleted_in_local_repository(Boolean useMirrors) throws Exception {
851     AgentRunningBuild build = createRunningBuild(useMirrors);
852     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, build, false);
853     removeTag(myMainRepo, "refs/tags/v0.5");
854
855     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, build, false);
856     assertNoTagExist("refs/tags/v0.5");
857   }
858
859
860   @Test(dataProvider = "mirrors")
861   public void updated_tag_in_remote_repository_should_be_updated_in_local_repository(Boolean useMirrors) throws Exception {
862     AgentRunningBuild build = createRunningBuild(useMirrors);
863     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, build, false);
864
865     final String newCommit = "2c7e90053e0f7a5dd25ea2a16ef8909ba71826f6";
866     updateRef(myMainRepo, "refs/tags/v1.0", newCommit);
867
868     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, build, false);
869     assertTagExists("refs/tags/v1.0");
870     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
871     Ref tag = r.getRef("refs/tags/v1.0");
872     assertEquals("Local tag is not updated", newCommit, tag.getObjectId().name());
873   }
874
875
876   @TestFor(issues = "TW-47805")
877   public void no_redundant_fetches_for_pull_requests() throws Exception {
878     LoggingGitMetaFactory loggingFactory = new LoggingGitMetaFactory();
879     myVcsSupport = myBuilder.setGitMetaFactory(loggingFactory).setFS(new MockFS()).build();
880
881     //create pull-request in remote repo
882     myRoot.addProperty(Constants.BRANCH_NAME, "refs/changes/1/1");
883     updateRef(myMainRepo, "refs/pull/1/head", "5711cbfe566b6c92e331f95d4b236483f4532eed");
884
885     //run build on pull-request
886     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "5711cbfe566b6c92e331f95d4b236483f4532eed", myCheckoutDir, myBuild, false);
887
888     //run build again
889     int fetchesBefore = loggingFactory.getNumberOfCalls(FetchCommand.class);
890     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "5711cbfe566b6c92e331f95d4b236483f4532eed", myCheckoutDir, myBuild, false);
891
892     //there should be no fetches in the second build
893     int redundantFetches = loggingFactory.getNumberOfCalls(FetchCommand.class) - fetchesBefore;
894     then(redundantFetches).isEqualTo(0);
895   }
896
897
898   @Test(dataProvider = "mirrors")
899   public void fetch_all_heads(boolean useMirrors) throws Exception {
900     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.USE_MIRRORS, String.valueOf(useMirrors),
901                                                      PluginConfigImpl.FETCH_ALL_HEADS, "true"));
902
903     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, build, false);
904
905     Repository remoteRepo = new RepositoryBuilder().setBare().setGitDir(myMainRepo).build();
906     Set<String> remoteHeads = remoteRepo.getRefDatabase().getRefs("refs/heads/").keySet();
907
908     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
909     then(r.getRefDatabase().getRefs("refs/remotes/origin/").keySet()).containsAll(remoteHeads);
910   }
911
912
913   @TestFor(issues = "TW-50714")
914   @Test(dataProvider = "mirrors")
915   public void fetch_all_heads__non_head_ref(boolean useMirrors) throws Exception {
916     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.FETCH_ALL_HEADS, "true"));
917
918     myRoot = vcsRoot().withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).withUseMirrors(useMirrors).withBranch("refs/pull/1").build();
919
920     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "b896070465af79121c9a4eb5300ecff29453c164", myCheckoutDir, build, false);
921   }
922
923
924   @Test(dataProvider = "mirrors")
925   public void fetch_all_heads_before_build_branch(boolean useMirrors) throws Exception {
926     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.USE_MIRRORS, String.valueOf(useMirrors),
927                                                      PluginConfigImpl.FETCH_ALL_HEADS, "beforeBuildBranch"));
928
929     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, build, false);
930
931     Repository remoteRepo = new RepositoryBuilder().setBare().setGitDir(myMainRepo).build();
932     Set<String> remoteHeads = remoteRepo.getRefDatabase().getRefs("refs/heads/").keySet();
933
934     //local repo should contain all heads since build's commit wasn't on the agent
935     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
936     then(r.getRefDatabase().getRefs("refs/remotes/origin/").keySet()).containsAll(remoteHeads);
937   }
938
939
940   @Test(dataProvider = "mirrors")
941   public void fetch_all_heads_before_build_branch_commit_found(boolean useMirrors) throws Exception {
942     //run build to make sure commit is on the agent
943     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.USE_MIRRORS, String.valueOf(useMirrors)));
944     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, build, false);
945
946     //run build with fetch_all_head before build's branch
947     build = createRunningBuild(map(PluginConfigImpl.USE_MIRRORS, String.valueOf(useMirrors),
948                                    PluginConfigImpl.FETCH_ALL_HEADS, "beforeBuildBranch"));
949     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, build, false);
950
951     //local repo shouldn't contain all heads since build commit was already on the agent and no fetch is required
952     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
953     then(r.getRefDatabase().getRefs("refs/remotes/origin/").keySet()).containsOnly("master");
954   }
955
956
957   private void removeTag(@NotNull File dotGitDir, @NotNull String tagName) {
958     delete(tagFile(dotGitDir, tagName));
959   }
960
961   private void updateRef(@NotNull File dotGitDir, @NotNull String refName, @NotNull String commit) throws IOException {
962     File tagFile = tagFile(dotGitDir, refName);
963     FileUtil.writeToFile(tagFile, commit.getBytes());
964   }
965
966   private File tagFile(@NotNull File dotGitDir, @NotNull String tagName) {
967     return new File(dotGitDir, tagName.replaceAll("/", Matcher.quoteReplacement(File.separator)));
968   }
969
970   private void assertNoTagExist(String tag) throws IOException {
971     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
972     assertNull("tag \'" + tag + "\' exists", r.getRef(tag));
973   }
974
975   private void assertTagExists(String tag) throws IOException {
976     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
977     assertNotNull("tag \'" + tag + "\' doesn't exist", r.getRef(tag));
978   }
979
980   @DataProvider(name = "mirrors")
981   public Object[][] mirrors() {
982     return new Object[][] {{true}, {false}};
983   }
984
985   @Test(dataProvider = "mirrors")
986   public void should_do_fetch_if_ref_is_outdated(Boolean useMirrors) throws Exception {
987     AgentRunningBuild build = createRunningBuild(useMirrors);
988     final File remote = myTempFiles.createTempDir();
989     copyRepository(dataFile("repo_for_fetch.2.personal"), remote);
990     VcsRootImpl masterRoot = createRoot(remote, "master");
991     VcsRootImpl personalRoot = createRoot(remote, "personal");
992
993     myVcsSupport.updateSources(personalRoot, new CheckoutRules(""), "d47dda159b27b9a8c4cee4ce98e4435eb5b17168@1303829462000", myCheckoutDir, build, false);
994     myVcsSupport.updateSources(masterRoot,   new CheckoutRules(""), "add81050184d3c818560bdd8839f50024c188586@1303829295000", myCheckoutDir, build, false);
995
996     FileUtil.delete(remote);
997     copyRepository(dataFile("repo_for_fetch.2"), remote);
998
999     myVcsSupport.updateSources(masterRoot, new CheckoutRules(""), "d47dda159b27b9a8c4cee4ce98e4435eb5b17168@1303829462000", myCheckoutDir,
1000                                build, false);
1001   }
1002
1003
1004   @Test(dataProvider = "mirrors")
1005   public void test_update_on_revision_from_feature_branch(Boolean useMirrors) throws Exception {
1006     AgentRunningBuild build = createRunningBuild(useMirrors);
1007     final File remote = myTempFiles.createTempDir();
1008     copyRepository(dataFile("repo_for_fetch.2.personal"), remote);
1009     VcsRootImpl root = createRoot(remote, "master");
1010     String commitFromFeatureBranch = "d47dda159b27b9a8c4cee4ce98e4435eb5b17168";
1011     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, commitFromFeatureBranch, myCheckoutDir, build, false);
1012   }
1013
1014
1015   @Test(dataProvider = "mirrors")
1016   public void should_use_branch_specified_in_build_parameter(Boolean useMirrors) throws Exception {
1017     final File remote = myTempFiles.createTempDir();
1018     copyRepository(dataFile("repo_for_fetch.2.personal"), remote);
1019     VcsRootImpl root = createRoot(remote, "master");
1020
1021     AgentRunningBuild build = createRunningBuild(map(PluginConfigImpl.USE_MIRRORS, String.valueOf(useMirrors)));
1022     String commitFromFeatureBranch = "d47dda159b27b9a8c4cee4ce98e4435eb5b17168";
1023     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, commitFromFeatureBranch, myCheckoutDir, build, false);
1024     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
1025     assertEquals("master", r.getBranch());
1026
1027     build = createRunningBuild(map(PluginConfigImpl.USE_MIRRORS, String.valueOf(useMirrors),
1028                                    GitUtils.getGitRootBranchParamName(root), "refs/heads/personal"));
1029     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, commitFromFeatureBranch, myCheckoutDir, build, false);
1030     r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
1031     assertEquals("personal", r.getBranch());
1032   }
1033
1034
1035   @Test
1036   public void test_shallow_clone() throws Exception {
1037     AgentRunningBuild build = createRunningBuild(new HashMap<String, String>() {{
1038       put(PluginConfigImpl.USE_MIRRORS, "true");
1039       put(PluginConfigImpl.USE_SHALLOW_CLONE, "true");
1040     }});
1041     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitVcsSupportTest.VERSION_TEST_HEAD, myCheckoutDir, build, false);
1042   }
1043
1044
1045   @TestFor(issues = "TW-27677")
1046   public void shallow_clone_in_non_master_branch() throws Exception {
1047     AgentRunningBuild build = createRunningBuild(new HashMap<String, String>() {{
1048       put(PluginConfigImpl.USE_MIRRORS, "true");
1049       put(PluginConfigImpl.USE_SHALLOW_CLONE, "true");
1050       put(GitUtils.getGitRootBranchParamName(myRoot), "refs/heads/version-test");//build on non-master branch
1051     }});
1052     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "2276eaf76a658f96b5cf3eb25f3e1fda90f6b653", myCheckoutDir, build, false);
1053   }
1054
1055
1056   @TestFor(issues = "TW-37122")
1057   public void shallow_clone_on_tag() throws Exception {
1058     myRoot.addProperty(Constants.BRANCH_NAME, "refs/tags/v1.0");
1059     AgentRunningBuild build = createRunningBuild(new HashMap<String, String>() {{
1060       put(PluginConfigImpl.USE_MIRRORS, "true");
1061       put(PluginConfigImpl.USE_SHALLOW_CLONE, "true");
1062     }});
1063     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, build, false);
1064   }
1065
1066
1067   @TestFor(issues = "TW-20165")
1068   public void push_with_local_mirrors_should_go_to_original_repository() throws Exception {
1069     AgentRunningBuild build = createRunningBuild(true);
1070     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, GitUtils.makeVersion("465ad9f630e451b9f2b782ffb09804c6a98c4bb9", 1289483394000L), myCheckoutDir, build, false);
1071
1072     final File fileToChange = new File(myCheckoutDir, "file");
1073     FileUtil.writeToFile(fileToChange, "text".getBytes());
1074
1075     Repository r = new RepositoryBuilder().setWorkTree(myCheckoutDir).build();
1076     Git git = new Git(r);
1077     git.add().addFilepattern("file").call();
1078     RevCommit commitDuringTheBuild = git.commit().setMessage("Commit during the build").call();
1079     new PushCommand().run(getGitPath(), myCheckoutDir.getAbsolutePath());//push using native git, seems like jgit doesn't respect url.insteadOf settings
1080
1081     Repository remote = new RepositoryBuilder().setGitDir(myMainRepo).build();
1082     assertTrue("Push didn't go to the remote repository", remote.hasObject(commitDuringTheBuild));
1083   }
1084
1085
1086   @TestFor(issues = "TW-28735")
1087   public void fetch_branch_with_same_name_but_different_register() throws Exception {
1088     AgentRunningBuild buildWithMirrorsEnabled = createRunningBuild(true);
1089     myRoot = vcsRoot().withBranch("refs/heads/master").withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).build();
1090     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, buildWithMirrorsEnabled, false);
1091
1092     //rename master->Master
1093     Repository r = new RepositoryBuilder().setGitDir(myMainRepo).build();
1094     r.renameRef("refs/heads/master", "refs/heads/Master").rename();
1095
1096     myRoot = vcsRoot().withBranch("refs/heads/Master").withAgentGitPath(getGitPath()).withFetchUrl(GitUtils.toURL(myMainRepo)).build();
1097     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, buildWithMirrorsEnabled, false);
1098   }
1099
1100
1101   @TestFor(issues = "TW-46266")
1102   public void should_not_use_custom_clone_on_server() throws Exception {
1103     File serverCustomCloneDir = myTempFiles.createTempDir();
1104     VcsRootImpl root = vcsRoot()
1105       .withAgentGitPath(getGitPath())
1106       .withFetchUrl(GitUtils.toURL(myMainRepo))
1107       .withRepositoryPathOnServer(serverCustomCloneDir.getCanonicalPath())
1108       .build();
1109
1110     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, createRunningBuild(true), false);
1111
1112     then(serverCustomCloneDir.listFiles()).isEmpty();
1113   }
1114
1115
1116   @TestFor(issues = "TW-44844")
1117   @Test(dataProviderClass = BaseRemoteRepositoryTest.class, dataProvider = "true,false")
1118   public void handle_files_marked_as_unchanged(boolean switchBranch) throws Exception {
1119     //checkout
1120     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "97442a720324a0bd092fb9235f72246dc8b345bc", myCheckoutDir, myBuild, false);
1121
1122     //modify file
1123     File f = new File(myCheckoutDir, "dir/a.txt");
1124     writeFileAndReportErrors(f, "update by build script");
1125
1126     //git update-index --no-assume-unchanged <file>
1127     Process updateIndex = new ProcessBuilder().directory(myCheckoutDir).command(getGitPath(), "update-index", "--assume-unchanged", "dir/a.txt").start();
1128     updateIndex.waitFor();
1129     if (updateIndex.exitValue() != 0) {
1130       fail("git update-index failed, exit code " + updateIndex.exitValue() +
1131            "\nstdout: " + StreamUtil.readText(updateIndex.getInputStream()) +
1132            "\nstderr: " + StreamUtil.readText(updateIndex.getErrorStream()));
1133     }
1134
1135     //update to commit which changes the file
1136     if (switchBranch)
1137       myBuild = createRunningBuild(map(GitUtils.getGitRootBranchParamName(myRoot), "refs/heads/personal-branch1"));
1138     myVcsSupport.updateSources(myRoot, CheckoutRules.DEFAULT, "ad4528ed5c84092fdbe9e0502163cf8d6e6141e7", myCheckoutDir, myBuild, false);
1139     then(FileUtil.readFile(f)).doesNotContain("update by build script");
1140   }
1141
1142
1143   @TestFor(issues = "TW-40313")
1144   public void should_remove_orphaned_indexes() throws Exception {
1145     //checkout
1146     VcsRootImpl root = vcsRoot()
1147       .withAgentGitPath(getGitPath())
1148       .withFetchUrl(GitUtils.toURL(myMainRepo))
1149       .build();
1150
1151     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, createRunningBuild(true), false);
1152
1153     //create orphaned idx files
1154     File mirror = myBuilder.getMirrorManager().getMirrorDir(GitUtils.toURL(myMainRepo));
1155     File idxInMirror = new File(new File(new File(mirror, "objects"), "pack"), "whatever.idx");
1156     FileUtil.writeFileAndReportErrors(idxInMirror, "whatever");
1157     File idxInCheckoutDir = new File(new File(new File(mirror, "objects"), "pack"), "whatever.idx");
1158     FileUtil.writeFileAndReportErrors(idxInCheckoutDir, "whatever");
1159
1160     //checkout again
1161     myVcsSupport.updateSources(root, CheckoutRules.DEFAULT, "465ad9f630e451b9f2b782ffb09804c6a98c4bb9", myCheckoutDir, createRunningBuild(true), false);
1162
1163     //orphaned idx files are removed
1164     then(idxInCheckoutDir).doesNotExist();
1165     then(idxInMirror).doesNotExist();
1166   }
1167
1168
1169   private VcsRootImpl createRoot(final File remote, final String branch) throws IOException {
1170     myVcsRootId++;
1171     return new VcsRootImpl(myVcsRootId, new HashMap<String, String>() {{
1172       put(VcsRootImpl.VCS_NAME_PROP, Constants.VCS_NAME);
1173       put(VcsRootImpl.VCS_ROOT_NAME_PROP, "test" + myVcsRootId);
1174       put(Constants.FETCH_URL, GitUtils.toURL(remote));
1175       put(Constants.AGENT_GIT_PATH, getGitPath());
1176       put(Constants.BRANCH_NAME, branch);
1177     }});
1178   }
1179
1180
1181   private void testSubSubmoduleCheckout(boolean recursiveSubmoduleCheckout) throws Exception {
1182     myRoot.addProperty(Constants.BRANCH_NAME, "sub-submodule");
1183     if (recursiveSubmoduleCheckout) {
1184       myRoot.addProperty(Constants.SUBMODULES_CHECKOUT, SubmodulesCheckoutPolicy.CHECKOUT.name());
1185     } else {
1186       myRoot.addProperty(Constants.SUBMODULES_CHECKOUT, SubmodulesCheckoutPolicy.NON_RECURSIVE_CHECKOUT.name());
1187     }
1188
1189     myVcsSupport.updateSources(myRoot, new CheckoutRules(""), GitVcsSupportTest.AFTER_FIRST_LEVEL_SUBMODULE_ADDED_VERSION,
1190                                myCheckoutDir, myBuild, false);
1191
1192     assertTrue(new File(myCheckoutDir, "first-level-submodule" + File.separator + "submoduleFile.txt").exists());
1193     if (recursiveSubmoduleCheckout) {
1194       assertTrue(new File (myCheckoutDir, "first-level-submodule" + File.separator + "sub-sub" + File.separator + "file.txt").exists());
1195       assertTrue(new File (myCheckoutDir, "first-level-submodule" + File.separator + "sub-sub" + File.separator + "new file.txt").exists());
1196     } else {
1197       assertFalse(new File (myCheckoutDir, "first-level-submodule" + File.separator + "sub-sub" + File.separator + "file.txt").exists());
1198       assertFalse(new File (myCheckoutDir, "first-level-submodule" + File.separator + "sub-sub" + File.separator + "new file.txt").exists());
1199     }
1200   }
1201
1202
1203   private AgentRunningBuild createRunningBuild(boolean useLocalMirrors) {
1204     return runningBuild().useLocalMirrors(useLocalMirrors).build();
1205   }
1206
1207
1208   private AgentRunningBuild createRunningBuild(final Map<String, String> sharedConfigParameters) {
1209     return runningBuild().sharedConfigParams(sharedConfigParameters).build();
1210   }
1211
1212
1213   private void copyRepository(File src, File dst) throws IOException {
1214     copyDir(src, dst);
1215     new File(dst, "refs" + File.separator + "heads").mkdirs();
1216   }
1217
1218
1219   private class PushCommand {
1220     void run(String gitPath, String workDirectory) throws Exception {
1221       File tmpDir = new File(FileUtil.getTempDirectory());
1222       GitCommandLine cmd = new GitCommandLine(null, SystemInfo.isUnix ? new UnixScriptGen(tmpDir, new EscapeEchoArgumentUnix())
1223                                                                       : new WinScriptGen(tmpDir, new EscapeEchoArgumentWin()),
1224                                               tmpDir,
1225                                               true,
1226                                               GitProgressLogger.NO_OP,
1227                                               GitVersion.MIN,
1228                                               new HashMap<String, String>(),
1229                                               new NoBuildContext());
1230       cmd.setExePath(gitPath);
1231       cmd.setWorkingDirectory(new File(workDirectory));
1232       cmd.addParameters("push", "origin", "master");
1233       CommandUtil.runCommand(cmd);
1234     }
1235   }
1236 }