Mercurial > hg4j
annotate test/org/tmatesoft/hg/test/TestCommit.java @ 652:cd77bf51b562
Push: tests. Commit respects phases.new-commit setting. Fix outgoing when changes are not children of common (Issue 47)
author | Artem Tikhomirov <tikhomirov.artem@gmail.com> |
---|---|
date | Tue, 02 Jul 2013 23:21:16 +0200 |
parents | ffce73efa2c2 |
children | 4fd317a2fecf |
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.io.IOException; |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
24 import java.util.List; |
538
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
25 |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
26 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
|
27 import org.junit.Test; |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
28 import org.tmatesoft.hg.core.HgAddRemoveCommand; |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
29 import org.tmatesoft.hg.core.HgCatCommand; |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
30 import org.tmatesoft.hg.core.HgChangeset; |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
31 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
|
32 import org.tmatesoft.hg.core.HgLogCommand; |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
33 import org.tmatesoft.hg.core.HgStatus.Kind; |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
34 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
|
35 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
|
36 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
|
37 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
|
38 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
|
39 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
|
40 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
|
41 import org.tmatesoft.hg.internal.DirstateReader; |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
42 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
|
43 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
|
44 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
|
45 import org.tmatesoft.hg.repo.HgDataFile; |
538
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
46 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
|
47 import org.tmatesoft.hg.repo.HgPhase; |
538
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
48 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
|
49 import org.tmatesoft.hg.repo.HgRepositoryFiles; |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
50 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
|
51 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
|
52 |
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
|
53 /** |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
54 * 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
|
55 * ...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
|
56 * |
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 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
|
58 * @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
|
59 */ |
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 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
|
61 |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
62 @Rule |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
63 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
|
64 |
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 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
|
66 // { |
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 // 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
|
68 // 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
|
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 // }; |
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
|
71 |
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
|
72 @Test |
538
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
73 public void testCommitToNonEmpty() throws Exception { |
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
74 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
|
75 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
|
76 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
|
77 // |
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
78 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
|
79 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
|
80 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
|
81 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
|
82 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
|
83 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
|
84 tr.commit(); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
85 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
86 List<HgChangeset> commits = new HgLogCommand(hgRepo).execute(); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
87 errorCollector.assertEquals(2, commits.size()); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
88 HgChangeset c1 = commits.get(0); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
89 HgChangeset c2 = commits.get(1); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
90 errorCollector.assertEquals("FIRST", c1.getComment()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
91 errorCollector.assertEquals("SECOND", c2.getComment()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
92 errorCollector.assertEquals(df.getPath(), c2.getAffectedFiles().get(0)); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
93 errorCollector.assertEquals(c1.getNodeid(), c2.getFirstParentRevision()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
94 errorCollector.assertEquals(Nodeid.NULL, c2.getSecondParentRevision()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
95 errorCollector.assertEquals(secondRev, c2.getNodeid()); |
539
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 |
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
98 @Test |
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
99 public void testCommitToEmpty() throws Exception { |
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
100 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
|
101 String fname = "file1"; |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
102 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
|
103 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
|
104 // |
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
105 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
|
106 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
|
107 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
|
108 HgDataFile df = hgRepo.getFileNode(fname); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
109 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
|
110 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
|
111 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
|
112 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
|
113 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
|
114 tr.commit(); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
115 List<HgChangeset> commits = new HgLogCommand(hgRepo).execute(); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
116 errorCollector.assertEquals(1, commits.size()); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
117 HgChangeset c1 = commits.get(0); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
118 errorCollector.assertEquals(1, c1.getAffectedFiles().size()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
119 errorCollector.assertEquals(df.getPath(), c1.getAffectedFiles().get(0)); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
120 errorCollector.assertEquals(0, c1.getRevisionIndex()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
121 errorCollector.assertEquals(Nodeid.NULL, c1.getFirstParentRevision()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
122 errorCollector.assertEquals(Nodeid.NULL, c1.getSecondParentRevision()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
123 errorCollector.assertEquals(HgRepository.DEFAULT_BRANCH_NAME, c1.getBranch()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
124 errorCollector.assertEquals(comment, c1.getComment()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
125 errorCollector.assertEquals(c1Rev, c1.getNodeid()); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
126 ByteArrayChannel bac = new ByteArrayChannel(); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
127 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
|
128 assertArrayEquals(initialContent, bac.toArray()); |
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 |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
131 @Test |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
132 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
|
133 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
|
134 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
135 HgDataFile dfD = hgRepo.getFileNode("d"); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
136 assertTrue("[sanity]", dfD.exists()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
137 File fileD = new File(repoLoc, "d"); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
138 assertTrue("[sanity]", fileD.canRead()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
139 final int parentCsetRevIndex = hgRepo.getChangelog().getLastRevision(); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
140 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
|
141 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
|
142 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
|
143 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
144 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
|
145 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
|
146 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
|
147 cf.add(dfD, contentProvider); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
148 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
|
149 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
|
150 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
|
151 tr.commit(); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
152 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
153 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
|
154 assertEquals(1, commits.size()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
155 HgChangeset c1 = commits.get(0); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
156 errorCollector.assertEquals(c1.getNodeid(), commitRev1); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
157 errorCollector.assertEquals("branch1", c1.getBranch()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
158 errorCollector.assertEquals("FIRST", c1.getComment()); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
159 // |
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
|
160 // 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
|
161 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
|
162 // |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
163 assertHgVerifyOk(repoLoc); |
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 /** |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
167 * 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
|
168 */ |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
169 @Test |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
170 public void testCommitWithAddRemove() throws Exception { |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
171 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
|
172 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
173 assertTrue("[sanity]", hgRepo.getFileNode("d").exists()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
174 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
|
175 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
|
176 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
|
177 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
|
178 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
|
179 cf.add(hgRepo.getFileNode("xx"), contentProvider); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
180 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
|
181 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
|
182 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
|
183 tr.commit(); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
184 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
185 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
|
186 HgChangeset cmt = commits.get(0); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
187 errorCollector.assertEquals(1, cmt.getAddedFiles().size()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
188 errorCollector.assertEquals("xx", cmt.getAddedFiles().get(0).getPath().toString()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
189 errorCollector.assertEquals(1, cmt.getRemovedFiles().size()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
190 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
|
191 ByteArrayChannel sink = new ByteArrayChannel(); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
192 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
|
193 assertArrayEquals("xyz".getBytes(), sink.toArray()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
194 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
195 assertHgVerifyOk(repoLoc); |
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 /** |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
198 * 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
|
199 */ |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
200 @Test |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
201 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
|
202 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
|
203 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
204 HgDataFile dfD = hgRepo.getFileNode("d"); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
205 assertTrue("[sanity]", dfD.exists()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
206 File fileD = new File(repoLoc, "d"); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
207 assertTrue("[sanity]", fileD.canRead()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
208 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
209 RepoUtils.modifyFileAppend(fileD, " 1 \n"); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
210 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
|
211 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
|
212 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
|
213 cf.add(dfD, contentProvider); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
214 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
|
215 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
|
216 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
|
217 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
218 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
|
219 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
|
220 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
|
221 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
|
222 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
223 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
|
224 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
|
225 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
|
226 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
|
227 tr.commit(); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
228 // |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
229 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
|
230 assertEquals(3, commits.size()); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
231 HgChangeset c1 = commits.get(0); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
232 HgChangeset c2 = commits.get(1); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
233 HgChangeset c3 = commits.get(2); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
234 errorCollector.assertEquals(c1.getNodeid(), commitRev1); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
235 errorCollector.assertEquals(c2.getNodeid(), commitRev2); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
236 errorCollector.assertEquals(c3.getNodeid(), commitRev3); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
237 errorCollector.assertEquals("branch1", c1.getBranch()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
238 errorCollector.assertEquals("branch2", c2.getBranch()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
239 errorCollector.assertEquals(DEFAULT_BRANCH_NAME, c3.getBranch()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
240 errorCollector.assertEquals("FIRST", c1.getComment()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
241 errorCollector.assertEquals("SECOND", c2.getComment()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
242 errorCollector.assertEquals("THIRD", c3.getComment()); |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
243 assertHgVerifyOk(repoLoc); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
244 } |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
245 |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
246 @Test |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
247 public void testCommandBasics() throws Exception { |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
248 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
|
249 // 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
|
250 RepoUtils.createFile(new File(repoLoc, HgRepositoryFiles.Phaseroots.getPath()), ""); |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
251 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
252 HgDataFile dfB = hgRepo.getFileNode("b"); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
253 assertTrue("[sanity]", dfB.exists()); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
254 File fileB = new File(repoLoc, "b"); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
255 assertTrue("[sanity]", fileB.canRead()); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
256 RepoUtils.modifyFileAppend(fileB, " 1 \n"); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
257 |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
258 HgCommitCommand cmd = new HgCommitCommand(hgRepo); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
259 assertFalse(cmd.isMergeCommit()); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
260 Outcome r = cmd.message("FIRST").execute(); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
261 errorCollector.assertTrue(r.isOk()); |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
262 Nodeid c1 = cmd.getCommittedRevision(); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
263 |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
264 // 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
|
265 TestStatus.StatusCollector status = new TestStatus.StatusCollector(); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
266 new HgStatusCommand(hgRepo).all().execute(status); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
267 errorCollector.assertTrue(status.getErrors().isEmpty()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
268 errorCollector.assertTrue(status.get(Kind.Modified).isEmpty()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
269 errorCollector.assertEquals(1, status.get(dfB.getPath()).size()); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
270 errorCollector.assertTrue(status.get(dfB.getPath()).contains(Kind.Clean)); |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
271 |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
272 HgDataFile dfD = hgRepo.getFileNode("d"); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
273 assertTrue("[sanity]", dfD.exists()); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
274 File fileD = new File(repoLoc, "d"); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
275 assertTrue("[sanity]", fileD.canRead()); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
276 // |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
277 RepoUtils.modifyFileAppend(fileD, " 1 \n"); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
278 cmd = new HgCommitCommand(hgRepo); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
279 assertFalse(cmd.isMergeCommit()); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
280 r = cmd.message("SECOND").execute(); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
281 errorCollector.assertTrue(r.isOk()); |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
282 Nodeid c2 = cmd.getCommittedRevision(); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
283 // |
636
ffce73efa2c2
HgCommitCommand: save last commit message
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
628
diff
changeset
|
284 errorCollector.assertEquals("SECOND", hgRepo.getCommitLastMessage()); |
ffce73efa2c2
HgCommitCommand: save last commit message
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
628
diff
changeset
|
285 // |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
286 int lastRev = hgRepo.getChangelog().getLastRevision(); |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
287 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
|
288 errorCollector.assertEquals(csets.get(0).getNodeid(), c1); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
289 errorCollector.assertEquals(csets.get(1).getNodeid(), c2); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
290 errorCollector.assertEquals(csets.get(0).getComment(), "FIRST"); |
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
291 errorCollector.assertEquals(csets.get(1).getComment(), "SECOND"); |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
292 assertHgVerifyOk(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
|
293 // 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
|
294 // 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
|
295 // 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
|
296 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
|
297 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
|
298 errorCollector.assertEquals(HgPhase.Draft, csets.get(1).getPhase()); |
586
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
299 } |
73c20c648c1f
HgCommitCommand initial support
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
565
diff
changeset
|
300 |
605
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
301 @Test |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
302 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
|
303 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
|
304 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
|
305 String activeBookmark = "bm1"; |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
306 eh.run("hg", "bookmarks", activeBookmark); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
307 |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
308 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
309 assertEquals("[sanity]", activeBookmark, hgRepo.getBookmarks().getActiveBookmarkName()); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
310 Nodeid activeBookmarkRevision = hgRepo.getBookmarks().getRevision(activeBookmark); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
311 assertEquals("[sanity]", activeBookmarkRevision, hgRepo.getWorkingCopyParents().first()); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
312 |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
313 HgDataFile dfD = hgRepo.getFileNode("d"); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
314 File fileD = new File(repoLoc, "d"); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
315 assertTrue("[sanity]", dfD.exists()); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
316 assertTrue("[sanity]", fileD.canRead()); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
317 |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
318 RepoUtils.modifyFileAppend(fileD, " 1 \n"); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
319 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
|
320 Outcome r = cmd.execute(); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
321 errorCollector.assertTrue(r.isOk()); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
322 Nodeid c = cmd.getCommittedRevision(); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
323 |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
324 errorCollector.assertEquals(activeBookmark, hgRepo.getBookmarks().getActiveBookmarkName()); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
325 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
|
326 // reload repo, and repeat the check |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
327 hgRepo = new HgLookup().detect(repoLoc); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
328 errorCollector.assertEquals(activeBookmark, hgRepo.getBookmarks().getActiveBookmarkName()); |
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
329 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
|
330 } |
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
|
331 |
624
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
332 /** |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
333 * from the wiki: |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
334 * "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
|
335 * 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
|
336 */ |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
337 @Test |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
338 public void testNoBookmarkUpdate() throws Exception { |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
339 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
|
340 HgRepository hgRepo = new HgLookup().detect(repoLoc); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
341 assertNull("[sanity]", hgRepo.getBookmarks().getActiveBookmarkName()); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
342 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
|
343 String activeBookmark = "bm1"; |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
344 eh.run("hg", "bookmarks", activeBookmark); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
345 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
|
346 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
|
347 assertEquals("[sanity]", initialBookmarkRevision, hgRepo.getWorkingCopyParents().first()); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
348 |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
349 File fileD = new File(repoLoc, "d"); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
350 assertTrue("[sanity]", fileD.canRead()); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
351 RepoUtils.modifyFileAppend(fileD, " 1 \n"); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
352 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
|
353 Outcome r = cmd.execute(); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
354 errorCollector.assertTrue(r.isOk()); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
355 Nodeid c2 = cmd.getCommittedRevision(); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
356 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
|
357 // |
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
|
358 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
|
359 // 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
|
360 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
|
361 } |
624
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
362 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
|
363 // |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
364 RepoUtils.modifyFileAppend(fileD, " 2 \n"); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
365 cmd = new HgCommitCommand(hgRepo).message("SECOND"); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
366 r = cmd.execute(); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
367 errorCollector.assertTrue(r.isOk()); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
368 //Nodeid c3 = cmd.getCommittedRevision(); |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
369 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
|
370 } |
507602cb4fb3
FIXMEs and TODOs: pay some technical debt
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
623
diff
changeset
|
371 |
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
|
372 @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
|
373 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
|
374 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
|
375 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
|
376 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
|
377 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
|
378 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
|
379 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
|
380 // |
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 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
|
382 // 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
|
383 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
|
384 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
|
385 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
|
386 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
|
387 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
|
388 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
|
389 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
|
390 |
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 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
|
392 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
|
393 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
|
394 |
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.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
|
396 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
|
397 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
|
398 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
|
399 } |
605
c56edf42be64
Commit: update active bookmark with new revision
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
591
diff
changeset
|
400 |
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
|
401 @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
|
402 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
|
403 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
|
404 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
|
405 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
|
406 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
|
407 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
|
408 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
|
409 // 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
|
410 // 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
|
411 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
|
412 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
|
413 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
|
414 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
|
415 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
|
416 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
|
417 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
|
418 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
|
419 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
|
420 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
|
421 // |
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 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
|
423 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
|
424 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
|
425 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
|
426 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
|
427 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
|
428 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
|
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 |
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 @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
|
432 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
|
433 // 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
|
434 // 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
|
435 // 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
|
436 // 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
|
437 // (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
|
438 // 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
|
439 // 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
|
440 // 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
|
441 // 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
|
442 // 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
|
443 // 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
|
444 // 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
|
445 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
|
446 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
|
447 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
|
448 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
|
449 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
|
450 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
|
451 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
|
452 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
|
453 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
|
454 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
|
455 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
|
456 // |
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 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
|
458 // |
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 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
|
460 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
|
461 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
|
462 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
|
463 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
|
464 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
|
465 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
|
466 // |
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 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
|
468 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
|
469 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
|
470 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
|
471 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
|
472 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
|
473 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
|
474 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
|
475 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
|
476 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
|
477 // |
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(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
|
479 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
|
480 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
|
481 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
|
482 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
|
483 // 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
|
484 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
|
485 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
|
486 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
|
487 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
|
488 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
|
489 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
|
490 |
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
|
491 assertHgVerifyOk(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
|
492 } |
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
|
493 |
559
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
494 private void assertHgVerifyOk(File repoLoc) throws InterruptedException, IOException { |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
495 ExecHelper verifyRun = new ExecHelper(new OutputParser.Stub(), repoLoc); |
6ca3d0c5b4bc
Commit: tests and fixes for defects discovered
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
539
diff
changeset
|
496 verifyRun.run("hg", "verify"); |
588
41218d84842a
Update dirstate after commit
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
586
diff
changeset
|
497 errorCollector.assertEquals("hg verify", 0, verifyRun.getExitValue()); |
538
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
498 } |
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
|
499 |
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
|
500 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
|
501 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
|
502 } |
539
9edfd5a223b8
Commit: handle empty repository case
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
538
diff
changeset
|
503 |
538
dd4f6311af52
Commit: first working version
Artem Tikhomirov <tikhomirov.artem@gmail.com>
parents:
534
diff
changeset
|
504 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
|
505 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
|
506 } |
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
|
507 } |