Mercurial > hg4j
annotate test/org/tmatesoft/hg/test/TestCommit.java @ 713:661e77dc88ba tip
Mac support: respect Mac alternatives of command-line arguments for common unix tools
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Sun, 03 Aug 2014 18:09:00 +0200 |
parents | 4fd317a2fecf |
children |
rev | line source |
---|---|
534
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
1 /* |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
2 * Copyright (c) 2013 TMate Software Ltd |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
3 * |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
4 * This program is free software; you can redistribute it and/or modify |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
5 * it under the terms of the GNU General Public License as published by |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
6 * the Free Software Foundation; version 2 of the License. |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
7 * |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
8 * This program is distributed in the hope that it will be useful, |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
11 * GNU General Public License for more details. |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
12 * |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
13 * For information on how to redistribute this software under |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
14 * the terms of a license other than GNU General Public License |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
15 * contact TMate Software at support@hg4j.com |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
16 */ |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
17 package org.tmatesoft.hg.test; |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
18 |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
19 import static org.junit.Assert.*; |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
20 import static org.tmatesoft.hg.repo.HgRepository.*; |
539
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
21 |
538
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
22 import java.io.File; |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
23 import java.util.List; |
538
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
24 |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
25 import org.junit.Rule; |
534
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
26 import org.junit.Test; |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
27 import org.tmatesoft.hg.core.HgAddRemoveCommand; |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
28 import org.tmatesoft.hg.core.HgCatCommand; |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
29 import org.tmatesoft.hg.core.HgChangeset; |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
30 import org.tmatesoft.hg.core.HgCommitCommand; |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
31 import org.tmatesoft.hg.core.HgLogCommand; |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
32 import org.tmatesoft.hg.core.HgStatus.Kind; |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
33 import org.tmatesoft.hg.core.HgStatusCommand; |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
34 import org.tmatesoft.hg.core.Nodeid; |
617
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
35 import org.tmatesoft.hg.core.SessionContext; |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
36 import org.tmatesoft.hg.internal.ByteArrayChannel; |
617
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
37 import org.tmatesoft.hg.internal.COWTransaction; |
591
e447384f3771
CommitFacility as internal class; refactored infrastructure around internals (access to RevlogStream)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
588
diff
changeset
|
38 import org.tmatesoft.hg.internal.CommitFacility; |
628
6526d8adbc0f
Explicit HgRuntimeException to facilitate easy switch from runtime to checked exceptions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
626
diff
changeset
|
39 import org.tmatesoft.hg.internal.DataSerializer.ByteArrayDataSource; |
621
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
40 import org.tmatesoft.hg.internal.DirstateReader; |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
41 import org.tmatesoft.hg.internal.FileContentSupplier; |
591
e447384f3771
CommitFacility as internal class; refactored infrastructure around internals (access to RevlogStream)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
588
diff
changeset
|
42 import org.tmatesoft.hg.internal.Internals; |
617
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
43 import org.tmatesoft.hg.internal.Transaction; |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
44 import org.tmatesoft.hg.repo.HgDataFile; |
538
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
45 import org.tmatesoft.hg.repo.HgLookup; |
652
cd77bf51b562
Push: tests. Commit respects phases.new-commit setting. Fix outgoing when changes are not children of common (Issue 47)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
636
diff
changeset
|
46 import org.tmatesoft.hg.repo.HgPhase; |
538
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
47 import org.tmatesoft.hg.repo.HgRepository; |
652
cd77bf51b562
Push: tests. Commit respects phases.new-commit setting. Fix outgoing when changes are not children of common (Issue 47)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
636
diff
changeset
|
48 import org.tmatesoft.hg.repo.HgRepositoryFiles; |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
49 import org.tmatesoft.hg.util.Outcome; |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
50 import org.tmatesoft.hg.util.Path; |
534
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
51 |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
52 /** |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
53 * Handy for debug to see patch content: |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
54 * ...RevlogDump /tmp/test-commit2non-empty/.hg/ store/data/file1.i dumpData |
534
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
55 * |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
56 * @author Artem Tikhomirov |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
57 * @author TMate Software Ltd. |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
58 */ |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
59 public class TestCommit { |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
60 |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
61 @Rule |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
62 public ErrorCollectorExt errorCollector = new ErrorCollectorExt(); |
617
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
63 |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
64 private final Transaction.Factory trFactory = new COWTransaction.Factory(); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
65 // { |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
66 // public Transaction create(Source ctxSource) { |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
67 // return new Transaction.NoRollback(); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
68 // } |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
69 // }; |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
70 |
534
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
71 @Test |
538
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
72 public void testCommitToNonEmpty() throws Exception { |
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
73 File repoLoc = RepoUtils.initEmptyTempRepo("test-commit2non-empty"); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
74 RepoUtils.createFile(new File(repoLoc, "file1"), "hello\n"); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
75 new ExecHelper(new OutputParser.Stub(), repoLoc).run("hg", "commit", "--addremove", "-m", "FIRST"); |
538
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
76 // |
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
77 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
591
e447384f3771
CommitFacility as internal class; refactored infrastructure around internals (access to RevlogStream)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
588
diff
changeset
|
78 CommitFacility cf = new CommitFacility(Internals.getInstance(hgRepo), 0); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
79 HgDataFile df = hgRepo.getFileNode("file1"); |
618
7c0d2ce340b8
Refactor approach how content finds it way down to a commit revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
617
diff
changeset
|
80 cf.add(df, new ByteArrayDataSource("hello\nworld".getBytes())); |
617
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
81 Transaction tr = newTransaction(hgRepo); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
82 Nodeid secondRev = cf.commit("SECOND", tr); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
83 tr.commit(); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
84 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
85 List<HgChangeset> commits = new HgLogCommand(hgRepo).execute(); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
86 errorCollector.assertEquals(2, commits.size()); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
87 HgChangeset c1 = commits.get(0); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
88 HgChangeset c2 = commits.get(1); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
89 errorCollector.assertEquals("FIRST", c1.getComment()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
90 errorCollector.assertEquals("SECOND", c2.getComment()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
91 errorCollector.assertEquals(df.getPath(), c2.getAffectedFiles().get(0)); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
92 errorCollector.assertEquals(c1.getNodeid(), c2.getFirstParentRevision()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
93 errorCollector.assertEquals(Nodeid.NULL, c2.getSecondParentRevision()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
94 errorCollector.assertEquals(secondRev, c2.getNodeid()); |
539
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
95 } |
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
96 |
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
97 @Test |
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
98 public void testCommitToEmpty() throws Exception { |
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
99 File repoLoc = RepoUtils.initEmptyTempRepo("test-commit2empty"); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
100 String fname = "file1"; |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
101 RepoUtils.createFile(new File(repoLoc, fname), null); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
102 new ExecHelper(new OutputParser.Stub(), repoLoc).run("hg", "add", fname); |
539
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
103 // |
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
104 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
105 assertEquals("[sanity]", 0, new HgLogCommand(hgRepo).execute().size()); |
591
e447384f3771
CommitFacility as internal class; refactored infrastructure around internals (access to RevlogStream)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
588
diff
changeset
|
106 CommitFacility cf = new CommitFacility(Internals.getInstance(hgRepo), NO_REVISION); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
107 HgDataFile df = hgRepo.getFileNode(fname); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
108 final byte[] initialContent = "hello\nworld".getBytes(); |
618
7c0d2ce340b8
Refactor approach how content finds it way down to a commit revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
617
diff
changeset
|
109 cf.add(df, new ByteArrayDataSource(initialContent)); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
110 String comment = "commit 1"; |
617
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
111 Transaction tr = newTransaction(hgRepo); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
112 Nodeid c1Rev = cf.commit(comment, tr); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
113 tr.commit(); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
114 List<HgChangeset> commits = new HgLogCommand(hgRepo).execute(); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
115 errorCollector.assertEquals(1, commits.size()); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
116 HgChangeset c1 = commits.get(0); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
117 errorCollector.assertEquals(1, c1.getAffectedFiles().size()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
118 errorCollector.assertEquals(df.getPath(), c1.getAffectedFiles().get(0)); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
119 errorCollector.assertEquals(0, c1.getRevisionIndex()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
120 errorCollector.assertEquals(Nodeid.NULL, c1.getFirstParentRevision()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
121 errorCollector.assertEquals(Nodeid.NULL, c1.getSecondParentRevision()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
122 errorCollector.assertEquals(HgRepository.DEFAULT_BRANCH_NAME, c1.getBranch()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
123 errorCollector.assertEquals(comment, c1.getComment()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
124 errorCollector.assertEquals(c1Rev, c1.getNodeid()); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
125 ByteArrayChannel bac = new ByteArrayChannel(); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
126 new HgCatCommand(hgRepo).file(df.getPath()).execute(bac); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
127 assertArrayEquals(initialContent, bac.toArray()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
128 } |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
129 |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
130 @Test |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
131 public void testCommitIntoBranch() throws Exception { |
613
f41dd9a3b8af
Remove few Experimental annotations as the API they've marked graduates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
612
diff
changeset
|
132 File repoLoc = RepoUtils.cloneRepoToTempLocation("log-1", "test-commit2branch", false); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
133 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
134 HgDataFile dfD = hgRepo.getFileNode("d"); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
135 assertTrue("[sanity]", dfD.exists()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
136 File fileD = new File(repoLoc, "d"); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
137 assertTrue("[sanity]", fileD.canRead()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
138 final int parentCsetRevIndex = hgRepo.getChangelog().getLastRevision(); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
139 HgChangeset parentCset = new HgLogCommand(hgRepo).range(parentCsetRevIndex, parentCsetRevIndex).execute().get(0); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
140 assertEquals("[sanity]", DEFAULT_BRANCH_NAME, parentCset.getBranch()); |
621
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
141 assertEquals("[sanity]", DEFAULT_BRANCH_NAME, hgRepo.getWorkingCopyBranchName()); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
142 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
143 RepoUtils.modifyFileAppend(fileD, "A CHANGE\n"); |
591
e447384f3771
CommitFacility as internal class; refactored infrastructure around internals (access to RevlogStream)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
588
diff
changeset
|
144 CommitFacility cf = new CommitFacility(Internals.getInstance(hgRepo), parentCsetRevIndex); |
618
7c0d2ce340b8
Refactor approach how content finds it way down to a commit revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
617
diff
changeset
|
145 FileContentSupplier contentProvider = new FileContentSupplier(hgRepo, fileD); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
146 cf.add(dfD, contentProvider); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
147 cf.branch("branch1"); |
617
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
148 Transaction tr = newTransaction(hgRepo); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
149 Nodeid commitRev1 = cf.commit("FIRST", tr); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
150 tr.commit(); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
151 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
152 List<HgChangeset> commits = new HgLogCommand(hgRepo).range(parentCsetRevIndex+1, TIP).execute(); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
153 assertEquals(1, commits.size()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
154 HgChangeset c1 = commits.get(0); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
155 errorCollector.assertEquals(c1.getNodeid(), commitRev1); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
156 errorCollector.assertEquals("branch1", c1.getBranch()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
157 errorCollector.assertEquals("FIRST", c1.getComment()); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
158 // |
621
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
159 // check if cached value in hgRepo got updated |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
160 errorCollector.assertEquals("branch1", hgRepo.getWorkingCopyBranchName()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
161 // |
660
4fd317a2fecf
Pull: phase1 get remote changes and add local revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
652
diff
changeset
|
162 RepoUtils.assertHgVerifyOk(errorCollector, repoLoc); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
163 } |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
164 |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
165 /** |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
166 * use own add and remove commands and then commit |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
167 */ |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
168 @Test |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
169 public void testCommitWithAddRemove() throws Exception { |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
170 File repoLoc = RepoUtils.cloneRepoToTempLocation("log-1", "test-add-remove-commit", false); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
171 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
172 assertTrue("[sanity]", hgRepo.getFileNode("d").exists()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
173 assertTrue("[sanity]", new File(repoLoc, "d").canRead()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
174 RepoUtils.createFile(new File(repoLoc, "xx"), "xyz"); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
175 new HgAddRemoveCommand(hgRepo).add(Path.create("xx")).remove(Path.create("d")).execute(); |
591
e447384f3771
CommitFacility as internal class; refactored infrastructure around internals (access to RevlogStream)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
588
diff
changeset
|
176 CommitFacility cf = new CommitFacility(Internals.getInstance(hgRepo), hgRepo.getChangelog().getLastRevision()); |
618
7c0d2ce340b8
Refactor approach how content finds it way down to a commit revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
617
diff
changeset
|
177 FileContentSupplier contentProvider = new FileContentSupplier(hgRepo, new File(repoLoc, "xx")); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
178 cf.add(hgRepo.getFileNode("xx"), contentProvider); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
179 cf.forget(hgRepo.getFileNode("d")); |
617
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
180 Transaction tr = newTransaction(hgRepo); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
181 Nodeid commitRev = cf.commit("Commit with add/remove cmd", tr); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
182 tr.commit(); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
183 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
184 List<HgChangeset> commits = new HgLogCommand(hgRepo).changeset(commitRev).execute(); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
185 HgChangeset cmt = commits.get(0); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
186 errorCollector.assertEquals(1, cmt.getAddedFiles().size()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
187 errorCollector.assertEquals("xx", cmt.getAddedFiles().get(0).getPath().toString()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
188 errorCollector.assertEquals(1, cmt.getRemovedFiles().size()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
189 errorCollector.assertEquals("d", cmt.getRemovedFiles().get(0).toString()); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
190 ByteArrayChannel sink = new ByteArrayChannel(); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
191 new HgCatCommand(hgRepo).file(Path.create("xx")).changeset(commitRev).execute(sink); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
192 assertArrayEquals("xyz".getBytes(), sink.toArray()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
193 // |
660
4fd317a2fecf
Pull: phase1 get remote changes and add local revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
652
diff
changeset
|
194 RepoUtils.assertHgVerifyOk(errorCollector, repoLoc); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
195 } |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
196 /** |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
197 * perform few commits one by one, into different branches |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
198 */ |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
199 @Test |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
200 public void testSequentialCommits() throws Exception { |
613
f41dd9a3b8af
Remove few Experimental annotations as the API they've marked graduates
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
612
diff
changeset
|
201 File repoLoc = RepoUtils.cloneRepoToTempLocation("log-1", "test-sequential-commits", false); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
202 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
203 HgDataFile dfD = hgRepo.getFileNode("d"); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
204 assertTrue("[sanity]", dfD.exists()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
205 File fileD = new File(repoLoc, "d"); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
206 assertTrue("[sanity]", fileD.canRead()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
207 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
208 RepoUtils.modifyFileAppend(fileD, " 1 \n"); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
209 final int parentCsetRevIndex = hgRepo.getChangelog().getLastRevision(); |
591
e447384f3771
CommitFacility as internal class; refactored infrastructure around internals (access to RevlogStream)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
588
diff
changeset
|
210 CommitFacility cf = new CommitFacility(Internals.getInstance(hgRepo), parentCsetRevIndex); |
618
7c0d2ce340b8
Refactor approach how content finds it way down to a commit revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
617
diff
changeset
|
211 FileContentSupplier contentProvider = new FileContentSupplier(hgRepo, fileD); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
212 cf.add(dfD, contentProvider); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
213 cf.branch("branch1"); |
617
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
214 Transaction tr = newTransaction(hgRepo); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
215 Nodeid commitRev1 = cf.commit("FIRST", tr); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
216 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
217 RepoUtils.modifyFileAppend(fileD, " 2 \n"); |
618
7c0d2ce340b8
Refactor approach how content finds it way down to a commit revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
617
diff
changeset
|
218 cf.add(dfD, contentProvider = new FileContentSupplier(hgRepo, fileD)); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
219 cf.branch("branch2"); |
617
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
220 Nodeid commitRev2 = cf.commit("SECOND", tr); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
221 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
222 RepoUtils.modifyFileAppend(fileD, " 2 \n"); |
618
7c0d2ce340b8
Refactor approach how content finds it way down to a commit revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
617
diff
changeset
|
223 cf.add(dfD, contentProvider = new FileContentSupplier(hgRepo, fileD)); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
224 cf.branch(DEFAULT_BRANCH_NAME); |
617
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
225 Nodeid commitRev3 = cf.commit("THIRD", tr); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
226 tr.commit(); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
227 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
228 List<HgChangeset> commits = new HgLogCommand(hgRepo).range(parentCsetRevIndex+1, TIP).execute(); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
229 assertEquals(3, commits.size()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
230 HgChangeset c1 = commits.get(0); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
231 HgChangeset c2 = commits.get(1); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
232 HgChangeset c3 = commits.get(2); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
233 errorCollector.assertEquals(c1.getNodeid(), commitRev1); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
234 errorCollector.assertEquals(c2.getNodeid(), commitRev2); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
235 errorCollector.assertEquals(c3.getNodeid(), commitRev3); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
236 errorCollector.assertEquals("branch1", c1.getBranch()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
237 errorCollector.assertEquals("branch2", c2.getBranch()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
238 errorCollector.assertEquals(DEFAULT_BRANCH_NAME, c3.getBranch()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
239 errorCollector.assertEquals("FIRST", c1.getComment()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
240 errorCollector.assertEquals("SECOND", c2.getComment()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
241 errorCollector.assertEquals("THIRD", c3.getComment()); |
660
4fd317a2fecf
Pull: phase1 get remote changes and add local revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
652
diff
changeset
|
242 RepoUtils.assertHgVerifyOk(errorCollector, repoLoc); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
243 } |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
244 |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
245 @Test |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
246 public void testCommandBasics() throws Exception { |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
247 File repoLoc = RepoUtils.cloneRepoToTempLocation("log-1", "test-commit-cmd", false); |
652
cd77bf51b562
Push: tests. Commit respects phases.new-commit setting. Fix outgoing when changes are not children of common (Issue 47)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
636
diff
changeset
|
248 // PhasesHelper relies on file existence to tell phase enablement |
cd77bf51b562
Push: tests. Commit respects phases.new-commit setting. Fix outgoing when changes are not children of common (Issue 47)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
636
diff
changeset
|
249 RepoUtils.createFile(new File(repoLoc, HgRepositoryFiles.Phaseroots.getPath()), ""); |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
250 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
251 HgDataFile dfB = hgRepo.getFileNode("b"); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
252 assertTrue("[sanity]", dfB.exists()); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
253 File fileB = new File(repoLoc, "b"); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
254 assertTrue("[sanity]", fileB.canRead()); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
255 RepoUtils.modifyFileAppend(fileB, " 1 \n"); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
256 |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
257 HgCommitCommand cmd = new HgCommitCommand(hgRepo); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
258 assertFalse(cmd.isMergeCommit()); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
259 Outcome r = cmd.message("FIRST").execute(); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
260 errorCollector.assertTrue(r.isOk()); |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
261 Nodeid c1 = cmd.getCommittedRevision(); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
262 |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
263 // check that modified files are no longer reported as such |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
264 TestStatus.StatusCollector status = new TestStatus.StatusCollector(); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
265 new HgStatusCommand(hgRepo).all().execute(status); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
266 errorCollector.assertTrue(status.getErrors().isEmpty()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
267 errorCollector.assertTrue(status.get(Kind.Modified).isEmpty()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
268 errorCollector.assertEquals(1, status.get(dfB.getPath()).size()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
269 errorCollector.assertTrue(status.get(dfB.getPath()).contains(Kind.Clean)); |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
270 |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
271 HgDataFile dfD = hgRepo.getFileNode("d"); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
272 assertTrue("[sanity]", dfD.exists()); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
273 File fileD = new File(repoLoc, "d"); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
274 assertTrue("[sanity]", fileD.canRead()); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
275 // |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
276 RepoUtils.modifyFileAppend(fileD, " 1 \n"); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
277 cmd = new HgCommitCommand(hgRepo); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
278 assertFalse(cmd.isMergeCommit()); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
279 r = cmd.message("SECOND").execute(); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
280 errorCollector.assertTrue(r.isOk()); |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
281 Nodeid c2 = cmd.getCommittedRevision(); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
282 // |
636
ffce73efa2c2
HgCommitCommand: save last commit message
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
628
diff
changeset
|
283 errorCollector.assertEquals("SECOND", hgRepo.getCommitLastMessage()); |
ffce73efa2c2
HgCommitCommand: save last commit message
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
628
diff
changeset
|
284 // |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
285 int lastRev = hgRepo.getChangelog().getLastRevision(); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
286 List<HgChangeset> csets = new HgLogCommand(hgRepo).range(lastRev-1, lastRev).execute(); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
287 errorCollector.assertEquals(csets.get(0).getNodeid(), c1); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
288 errorCollector.assertEquals(csets.get(1).getNodeid(), c2); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
289 errorCollector.assertEquals(csets.get(0).getComment(), "FIRST"); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
290 errorCollector.assertEquals(csets.get(1).getComment(), "SECOND"); |
660
4fd317a2fecf
Pull: phase1 get remote changes and add local revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
652
diff
changeset
|
291 RepoUtils.assertHgVerifyOk(errorCollector, repoLoc); |
652
cd77bf51b562
Push: tests. Commit respects phases.new-commit setting. Fix outgoing when changes are not children of common (Issue 47)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
636
diff
changeset
|
292 // new commits are drafts by default, check our commit respects this |
cd77bf51b562
Push: tests. Commit respects phases.new-commit setting. Fix outgoing when changes are not children of common (Issue 47)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
636
diff
changeset
|
293 // TODO more tests with children of changesets with draft, secret or public phases (latter - |
cd77bf51b562
Push: tests. Commit respects phases.new-commit setting. Fix outgoing when changes are not children of common (Issue 47)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
636
diff
changeset
|
294 // new commit is child of public, but there are other commits with draft/secret phases - ensure they are intact) |
cd77bf51b562
Push: tests. Commit respects phases.new-commit setting. Fix outgoing when changes are not children of common (Issue 47)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
636
diff
changeset
|
295 assertEquals(HgPhase.Draft, HgPhase.parse(hgRepo.getConfiguration().getStringValue("phases", "new-commit", HgPhase.Draft.mercurialString()))); |
cd77bf51b562
Push: tests. Commit respects phases.new-commit setting. Fix outgoing when changes are not children of common (Issue 47)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
636
diff
changeset
|
296 errorCollector.assertEquals(HgPhase.Draft, csets.get(0).getPhase()); |
cd77bf51b562
Push: tests. Commit respects phases.new-commit setting. Fix outgoing when changes are not children of common (Issue 47)
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
636
diff
changeset
|
297 errorCollector.assertEquals(HgPhase.Draft, csets.get(1).getPhase()); |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
298 } |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
299 |
605
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
300 @Test |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
301 public void testUpdateActiveBookmark() throws Exception { |
612
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
302 File repoLoc = RepoUtils.cloneRepoToTempLocation("log-1", "test-commit-bookmark-update", false); |
605
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
303 ExecHelper eh = new ExecHelper(new OutputParser.Stub(), repoLoc); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
304 String activeBookmark = "bm1"; |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
305 eh.run("hg", "bookmarks", activeBookmark); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
306 |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
307 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
308 assertEquals("[sanity]", activeBookmark, hgRepo.getBookmarks().getActiveBookmarkName()); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
309 Nodeid activeBookmarkRevision = hgRepo.getBookmarks().getRevision(activeBookmark); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
310 assertEquals("[sanity]", activeBookmarkRevision, hgRepo.getWorkingCopyParents().first()); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
311 |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
312 HgDataFile dfD = hgRepo.getFileNode("d"); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
313 File fileD = new File(repoLoc, "d"); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
314 assertTrue("[sanity]", dfD.exists()); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
315 assertTrue("[sanity]", fileD.canRead()); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
316 |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
317 RepoUtils.modifyFileAppend(fileD, " 1 \n"); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
318 HgCommitCommand cmd = new HgCommitCommand(hgRepo).message("FIRST"); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
319 Outcome r = cmd.execute(); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
320 errorCollector.assertTrue(r.isOk()); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
321 Nodeid c = cmd.getCommittedRevision(); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
322 |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
323 errorCollector.assertEquals(activeBookmark, hgRepo.getBookmarks().getActiveBookmarkName()); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
324 errorCollector.assertEquals(c, hgRepo.getBookmarks().getRevision(activeBookmark)); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
325 // reload repo, and repeat the check |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
326 hgRepo = new HgLookup().detect(repoLoc); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
327 errorCollector.assertEquals(activeBookmark, hgRepo.getBookmarks().getActiveBookmarkName()); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
328 errorCollector.assertEquals(c, hgRepo.getBookmarks().getRevision(activeBookmark)); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
329 } |
612
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
330 |
624
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
331 /** |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
332 * from the wiki: |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
333 * "active bookmarks are automatically updated when committing to the changeset they are pointing to" |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
334 * Synopsis: commit 1 (c1), hg bookmark active (points to commit1), make commit 2, hg bookmark -f -r c1 active, commit 3, check active still points to c1 |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
335 */ |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
336 @Test |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
337 public void testNoBookmarkUpdate() throws Exception { |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
338 File repoLoc = RepoUtils.cloneRepoToTempLocation("log-1", "test-no-bookmark-upd", false); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
339 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
340 assertNull("[sanity]", hgRepo.getBookmarks().getActiveBookmarkName()); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
341 ExecHelper eh = new ExecHelper(new OutputParser.Stub(), repoLoc); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
342 String activeBookmark = "bm1"; |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
343 eh.run("hg", "bookmarks", activeBookmark); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
344 assertEquals("Bookmarks has to reload", activeBookmark, hgRepo.getBookmarks().getActiveBookmarkName()); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
345 Nodeid initialBookmarkRevision = hgRepo.getBookmarks().getRevision(activeBookmark); // c1 |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
346 assertEquals("[sanity]", initialBookmarkRevision, hgRepo.getWorkingCopyParents().first()); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
347 |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
348 File fileD = new File(repoLoc, "d"); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
349 assertTrue("[sanity]", fileD.canRead()); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
350 RepoUtils.modifyFileAppend(fileD, " 1 \n"); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
351 HgCommitCommand cmd = new HgCommitCommand(hgRepo).message("FIRST"); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
352 Outcome r = cmd.execute(); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
353 errorCollector.assertTrue(r.isOk()); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
354 Nodeid c2 = cmd.getCommittedRevision(); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
355 errorCollector.assertEquals(c2, hgRepo.getBookmarks().getRevision(activeBookmark)); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
356 // |
626
5afc7eedb3dd
@since, TODOs. Tests: add 1 sec to deal with fs timestamp granularity on linux
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
357 if (!Internals.runningOnWindows()) { |
5afc7eedb3dd
@since, TODOs. Tests: add 1 sec to deal with fs timestamp granularity on linux
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
358 // need change to happen not the same moment as the last commit (and read of bookmark file) |
5afc7eedb3dd
@since, TODOs. Tests: add 1 sec to deal with fs timestamp granularity on linux
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
359 Thread.sleep(1000); // XXX remove once better file change detection in place |
5afc7eedb3dd
@since, TODOs. Tests: add 1 sec to deal with fs timestamp granularity on linux
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
624
diff
changeset
|
360 } |
624
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
361 eh.run("hg", "bookmark", activeBookmark, "--force", "--rev", initialBookmarkRevision.toString()); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
362 // |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
363 RepoUtils.modifyFileAppend(fileD, " 2 \n"); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
364 cmd = new HgCommitCommand(hgRepo).message("SECOND"); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
365 r = cmd.execute(); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
366 errorCollector.assertTrue(r.isOk()); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
367 //Nodeid c3 = cmd.getCommittedRevision(); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
368 errorCollector.assertEquals(initialBookmarkRevision, hgRepo.getBookmarks().getRevision(activeBookmark)); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
369 } |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
370 |
612
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
371 @Test |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
372 public void testRefreshTagsAndBranches() throws Exception { |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
373 File repoLoc = RepoUtils.cloneRepoToTempLocation("log-branches", "test-refresh-after-commit", false); |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
374 final String tag = "tag.refresh", branch = "branch-refresh"; |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
375 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
376 assertFalse(hgRepo.getTags().getAllTags().containsKey(tag)); |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
377 assertNull(hgRepo.getBranches().getBranch(branch)); |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
378 RepoUtils.modifyFileAppend(new File(repoLoc, "a"), "whatever"); |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
379 // |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
380 final int parentCsetRevIndex = hgRepo.getChangelog().getLastRevision(); |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
381 // HgCommitCommand can't do branch yet |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
382 CommitFacility cf = new CommitFacility(Internals.getInstance(hgRepo), parentCsetRevIndex); |
618
7c0d2ce340b8
Refactor approach how content finds it way down to a commit revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
617
diff
changeset
|
383 cf.add(hgRepo.getFileNode("a"), new FileContentSupplier(hgRepo, new File(repoLoc, "a"))); |
612
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
384 cf.branch(branch); |
617
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
385 Transaction tr = newTransaction(hgRepo); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
386 Nodeid commit = cf.commit("FIRST", tr); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
387 tr.commit(); |
612
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
388 errorCollector.assertEquals("commit with branch shall update WC", branch, hgRepo.getWorkingCopyBranchName()); |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
389 |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
390 ExecHelper eh = new ExecHelper(new OutputParser.Stub(), repoLoc); |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
391 eh.run("hg", "tag", tag); |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
392 assertEquals("[sanity]", 0, eh.getExitValue()); |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
393 |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
394 errorCollector.assertTrue(hgRepo.getTags().getAllTags().containsKey(tag)); |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
395 errorCollector.assertFalse(hgRepo.getBranches().getBranch(branch) == null); |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
396 errorCollector.assertTrue(hgRepo.getTags().tagged(tag).contains(commit)); |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
397 errorCollector.assertTrue(hgRepo.getTags().tags(commit).contains(tag)); |
dca70c0b1f74
Test tags, branches and hgingore information get refreshed on external (and/or internal) change
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
607
diff
changeset
|
398 } |
605
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
399 |
621
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
400 @Test |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
401 public void testAddedFilesGetStream() throws Exception { |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
402 File repoLoc = RepoUtils.cloneRepoToTempLocation("log-1", "test-commit-addfile-stream", false); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
403 final File newFile = new File(repoLoc, "xx"); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
404 final byte[] newFileContent = "xyz".getBytes(); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
405 RepoUtils.createFile(newFile, newFileContent); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
406 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
407 new HgAddRemoveCommand(hgRepo).add(Path.create("xx")).execute(); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
408 // save the reference to HgDataFile without valid RevlogStream (entry in the dirstate |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
409 // doesn't make it valid) |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
410 final HgDataFile newFileNode = hgRepo.getFileNode("xx"); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
411 assertFalse(newFileNode.exists()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
412 HgCommitCommand cmd = new HgCommitCommand(hgRepo).message("FIRST"); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
413 Outcome r = cmd.execute(); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
414 errorCollector.assertTrue(r.isOk()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
415 TestStatus.StatusCollector status = new TestStatus.StatusCollector(); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
416 new HgStatusCommand(hgRepo).all().execute(status); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
417 errorCollector.assertTrue(status.getErrors().isEmpty()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
418 errorCollector.assertTrue(status.get(Kind.Added).isEmpty()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
419 errorCollector.assertTrue(status.get(newFileNode.getPath()).contains(Kind.Clean)); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
420 // |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
421 errorCollector.assertTrue(newFileNode.exists()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
422 final ByteArrayChannel read1 = new ByteArrayChannel(); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
423 newFileNode.content(0, read1); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
424 errorCollector.assertEquals("Read from existing HgDataFile instance", newFileContent, read1.toArray()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
425 final ByteArrayChannel read2 = new ByteArrayChannel(); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
426 hgRepo.getFileNode(newFileNode.getPath()).content(0, read2); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
427 errorCollector.assertEquals("Read from fresh HgDataFile instance", newFileContent, read2.toArray()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
428 } |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
429 |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
430 @Test |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
431 public void testRollback() throws Exception { |
623
fedc54356091
Update tests for Windows; TestCommit: use copy of a repo (not clone) to preserve old timestamps
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
621
diff
changeset
|
432 // Important: copy, not a clone of a repo to ensure old timestamps |
fedc54356091
Update tests for Windows; TestCommit: use copy of a repo (not clone) to preserve old timestamps
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
621
diff
changeset
|
433 // on repository files. Otherwise, there're chances transacition.rollback() |
fedc54356091
Update tests for Windows; TestCommit: use copy of a repo (not clone) to preserve old timestamps
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
621
diff
changeset
|
434 // would happen the very second (when fs timestamp granularity is second) |
fedc54356091
Update tests for Windows; TestCommit: use copy of a repo (not clone) to preserve old timestamps
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
621
diff
changeset
|
435 // repository got cloned, and RevlogChangeMonitor won't notice the file change |
fedc54356091
Update tests for Windows; TestCommit: use copy of a repo (not clone) to preserve old timestamps
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
621
diff
changeset
|
436 // (timestamp is the same, file size increased (CommitFacility) and decreased |
fedc54356091
Update tests for Windows; TestCommit: use copy of a repo (not clone) to preserve old timestamps
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
621
diff
changeset
|
437 // on rollback back to memorized value), and subsequent hgRepo access would fail |
fedc54356091
Update tests for Windows; TestCommit: use copy of a repo (not clone) to preserve old timestamps
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
621
diff
changeset
|
438 // trying to read more (due to Revlog#revisionAdded) revisions than there are in |
fedc54356091
Update tests for Windows; TestCommit: use copy of a repo (not clone) to preserve old timestamps
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
621
diff
changeset
|
439 // the store file. |
fedc54356091
Update tests for Windows; TestCommit: use copy of a repo (not clone) to preserve old timestamps
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
621
diff
changeset
|
440 // With copy and original timestamps we pretend commit happens to an existing repository |
fedc54356091
Update tests for Windows; TestCommit: use copy of a repo (not clone) to preserve old timestamps
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
621
diff
changeset
|
441 // in a regular manner (it's unlikely to have commits within the same second in a real life) |
fedc54356091
Update tests for Windows; TestCommit: use copy of a repo (not clone) to preserve old timestamps
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
621
diff
changeset
|
442 // XXX Note, once we have more robust method to detect file changes (e.g. Java7), this |
fedc54356091
Update tests for Windows; TestCommit: use copy of a repo (not clone) to preserve old timestamps
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
621
diff
changeset
|
443 // approach shall be abandoned. |
fedc54356091
Update tests for Windows; TestCommit: use copy of a repo (not clone) to preserve old timestamps
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
621
diff
changeset
|
444 File repoLoc = RepoUtils.copyRepoToTempLocation("log-1", "test-commit-rollback"); |
621
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
445 final Path newFilePath = Path.create("xx"); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
446 final File newFile = new File(repoLoc, newFilePath.toString()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
447 RepoUtils.createFile(newFile, "xyz"); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
448 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
449 HgDataFile dfB = hgRepo.getFileNode("b"); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
450 HgDataFile dfD = hgRepo.getFileNode("d"); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
451 assertTrue("[sanity]", dfB.exists()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
452 assertTrue("[sanity]", dfD.exists()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
453 final File modifiedFile = new File(repoLoc, "b"); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
454 RepoUtils.modifyFileAppend(modifiedFile, " 1 \n"); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
455 // |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
456 new HgAddRemoveCommand(hgRepo).add(newFilePath).remove(dfD.getPath()).execute(); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
457 // |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
458 TestStatus.StatusCollector status = new TestStatus.StatusCollector(); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
459 new HgStatusCommand(hgRepo).all().execute(status); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
460 assertTrue(status.getErrors().isEmpty()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
461 assertTrue(status.get(Kind.Added).contains(newFilePath)); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
462 assertTrue(status.get(Kind.Modified).contains(dfB.getPath())); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
463 assertTrue(status.get(Kind.Removed).contains(dfD.getPath())); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
464 assertEquals(DEFAULT_BRANCH_NAME, hgRepo.getWorkingCopyBranchName()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
465 // |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
466 final int lastClogRevision = hgRepo.getChangelog().getLastRevision(); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
467 final int lastManifestRev = hgRepo.getManifest().getLastRevision(); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
468 CommitFacility cf = new CommitFacility(Internals.getInstance(hgRepo), lastClogRevision); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
469 cf.add(hgRepo.getFileNode("xx"), new FileContentSupplier(hgRepo, newFile)); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
470 cf.add(dfB, new FileContentSupplier(hgRepo, modifiedFile)); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
471 cf.forget(dfD); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
472 cf.branch("another-branch"); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
473 Transaction tr = newTransaction(hgRepo); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
474 Nodeid commitRev = cf.commit("Commit to fail", tr); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
475 tr.rollback(); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
476 // |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
477 errorCollector.assertEquals(lastClogRevision, hgRepo.getChangelog().getLastRevision()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
478 errorCollector.assertEquals(lastManifestRev, hgRepo.getManifest().getLastRevision()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
479 errorCollector.assertEquals(DEFAULT_BRANCH_NAME, DirstateReader.readBranch(Internals.getInstance(hgRepo))); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
480 errorCollector.assertFalse(hgRepo.getChangelog().isKnown(commitRev)); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
481 errorCollector.assertFalse(hgRepo.getFileNode("xx").exists()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
482 // check dirstate |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
483 status = new TestStatus.StatusCollector(); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
484 new HgStatusCommand(hgRepo).all().execute(status); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
485 errorCollector.assertTrue(status.getErrors().isEmpty()); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
486 errorCollector.assertTrue(status.get(Kind.Added).contains(newFilePath)); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
487 errorCollector.assertTrue(status.get(Kind.Modified).contains(dfB.getPath())); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
488 errorCollector.assertTrue(status.get(Kind.Removed).contains(dfD.getPath())); |
99ad1e3a4e4d
RevlogStream: be aware of existence (not HgDataFile), facilitate use of an added HgDataFile over a commit; Rollback: be more sensitive about file changes (file size is not enough: write/rollback leaves it intact); tests
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
618
diff
changeset
|
489 |
660
4fd317a2fecf
Pull: phase1 get remote changes and add local revisions
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
652
diff
changeset
|
490 RepoUtils.assertHgVerifyOk(errorCollector, repoLoc); |
538
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
491 } |
617
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
492 |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
493 private Transaction newTransaction(SessionContext.Source ctxSource) { |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
494 return trFactory.create(ctxSource); |
65c01508f002
Rollback support for commands that modify repository. Strategy to keep complete copy of a file being changed
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
613
diff
changeset
|
495 } |
539
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
496 |
538
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
497 public static void main(String[] args) throws Exception { |
539
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
498 new TestCommit().testCommitToEmpty(); |
534
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
499 } |
243202f1bda5
Commit: refactor revision creation code from clone command to work separately, fit into existing library structure
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
diff
changeset
|
500 } |