/brz/remove-bazaar

To get this branch, use:
bzr branch http://gegoxaren.bato24.eu/bzr/brz/remove-bazaar

« back to all changes in this revision

Viewing changes to breezy/tests/test_bisect.py

  • Committer: Robert Collins
  • Date: 2007-04-19 02:27:44 UTC
  • mto: This revision was merged to the branch mainline in revision 2426.
  • Revision ID: robertc@robertcollins.net-20070419022744-pfdqz42kp1wizh43
``make docs`` now creates a man page at ``man1/bzr.1`` fixing bug 107388.
(Robert Collins)

Show diffs side-by-side

added added

removed removed

Lines of Context:
breezy/tests/test_bisect.py
1
 
# Copyright (C) 2007-2010 Canonical Ltd
2
 
#
3
 
# This program is free software; you can redistribute it and/or modify
4
 
# it under the terms of the GNU General Public License as published by
5
 
# the Free Software Foundation; either version 2 of the License, or
6
 
# (at your option) any later version.
7
 
#
8
 
# This program is distributed in the hope that it will be useful,
9
 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
 
# GNU General Public License for more details.
12
 
#
13
 
# You should have received a copy of the GNU General Public License
14
 
# along with this program; if not, write to the Free Software
15
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
 
 
17
 
"Test suite for the bzr bisect plugin."
18
 
 
19
 
from io import StringIO
20
 
import os
21
 
import shutil
22
 
 
23
 
from ..controldir import ControlDir
24
 
from .. import bisect
25
 
from . import (
26
 
    TestCaseWithTransport,
27
 
    TestSkipped,
28
 
    )
29
 
 
30
 
 
31
 
class BisectTestCase(TestCaseWithTransport):
32
 
    """Test harness specific to the bisect plugin."""
33
 
 
34
 
    def assertRevno(self, rev):
35
 
        """Make sure we're at the right revision."""
36
 
 
37
 
        rev_contents = {1: "one", 1.1: "one dot one", 1.2: "one dot two",
38
 
                        1.3: "one dot three", 2: "two", 3: "three",
39
 
                        4: "four", 5: "five"}
40
 
 
41
 
        with open("test_file") as f:
42
 
            content = f.read().strip()
43
 
        if content != rev_contents[rev]:
44
 
            rev_ids = dict((rev_contents[k], k) for k in rev_contents)
45
 
            found_rev = rev_ids[content]
46
 
            raise AssertionError("expected rev %0.1f, found rev %0.1f"
47
 
                                 % (rev, found_rev))
48
 
 
49
 
    def setUp(self):
50
 
        """Set up tests."""
51
 
 
52
 
        # These tests assume a branch with five revisions, and
53
 
        # a branch from version 1 containing three revisions
54
 
        # merged at version 2.
55
 
 
56
 
        TestCaseWithTransport.setUp(self)
57
 
 
58
 
        self.tree = self.make_branch_and_tree(".")
59
 
 
60
 
        test_file = open("test_file", "w")
61
 
        test_file.write("one")
62
 
        test_file.close()
63
 
        self.tree.add(self.tree.relpath(os.path.join(os.getcwd(),
64
 
                                                     'test_file')))
65
 
        test_file_append = open("test_file_append", "a")
66
 
        test_file_append.write("one\n")
67
 
        test_file_append.close()
68
 
        self.tree.add(self.tree.relpath(os.path.join(os.getcwd(),
69
 
                                                     'test_file_append')))
70
 
        self.tree.commit(message="add test files")
71
 
 
72
 
        ControlDir.open(".").sprout("../temp-clone")
73
 
        clone_bzrdir = ControlDir.open("../temp-clone")
74
 
        clone_tree = clone_bzrdir.open_workingtree()
75
 
        for content in ["one dot one", "one dot two", "one dot three"]:
76
 
            test_file = open("../temp-clone/test_file", "w")
77
 
            test_file.write(content)
78
 
            test_file.close()
79
 
            test_file_append = open("../temp-clone/test_file_append", "a")
80
 
            test_file_append.write(content + "\n")
81
 
            test_file_append.close()
82
 
            clone_tree.commit(message="make branch test change")
83
 
            saved_subtree_revid = clone_tree.branch.last_revision()
84
 
 
85
 
        self.tree.merge_from_branch(clone_tree.branch)
86
 
        test_file = open("test_file", "w")
87
 
        test_file.write("two")
88
 
        test_file.close()
89
 
        test_file_append = open("test_file_append", "a")
90
 
        test_file_append.write("two\n")
91
 
        test_file_append.close()
92
 
        self.tree.commit(message="merge external branch")
93
 
        shutil.rmtree("../temp-clone")
94
 
 
95
 
        self.subtree_rev = saved_subtree_revid
96
 
 
97
 
        file_contents = ["three", "four", "five"]
98
 
        for content in file_contents:
99
 
            test_file = open("test_file", "w")
100
 
            test_file.write(content)
101
 
            test_file.close()
102
 
            test_file_append = open("test_file_append", "a")
103
 
            test_file_append.write(content + "\n")
104
 
            test_file_append.close()
105
 
            self.tree.commit(message="make test change")
106
 
 
107
 
 
108
 
class BisectHarnessTests(BisectTestCase):
109
 
    """Tests for the harness itself."""
110
 
 
111
 
    def testLastRev(self):
112
 
        """Test that the last revision is correct."""
113
 
        repo = self.tree.branch.repository
114
 
        top_revtree = repo.revision_tree(self.tree.last_revision())
115
 
        top_revtree.lock_read()
116
 
        top_file = top_revtree.get_file("test_file")
117
 
        test_content = top_file.read().strip()
118
 
        top_file.close()
119
 
        top_revtree.unlock()
120
 
        self.assertEqual(test_content, b"five")
121
 
 
122
 
    def testSubtreeRev(self):
123
 
        """Test that the last revision in a subtree is correct."""
124
 
        repo = self.tree.branch.repository
125
 
        sub_revtree = repo.revision_tree(self.subtree_rev)
126
 
        sub_revtree.lock_read()
127
 
        with sub_revtree.get_file("test_file") as sub_file:
128
 
            test_content = sub_file.read().strip()
129
 
        sub_revtree.unlock()
130
 
        self.assertEqual(test_content, b"one dot three")
131
 
 
132
 
 
133
 
class BisectCurrentUnitTests(BisectTestCase):
134
 
    """Test the BisectCurrent class."""
135
 
 
136
 
    def testShowLog(self):
137
 
        """Test that the log can be shown."""
138
 
        # Not a very good test; just makes sure the code doesn't fail,
139
 
        # not that the output makes any sense.
140
 
        sio = StringIO()
141
 
        bisect.BisectCurrent(self.tree.controldir).show_rev_log(outf=sio)
142
 
 
143
 
    def testShowLogSubtree(self):
144
 
        """Test that a subtree's log can be shown."""
145
 
        current = bisect.BisectCurrent(self.tree.controldir)
146
 
        current.switch(self.subtree_rev)
147
 
        sio = StringIO()
148
 
        current.show_rev_log(outf=sio)
149
 
 
150
 
    def testSwitchVersions(self):
151
 
        """Test switching versions."""
152
 
        current = bisect.BisectCurrent(self.tree.controldir)
153
 
        self.assertRevno(5)
154
 
        current.switch(4)
155
 
        self.assertRevno(4)
156
 
 
157
 
    def testReset(self):
158
 
        """Test resetting the working tree to a non-bisected state."""
159
 
        current = bisect.BisectCurrent(self.tree.controldir)
160
 
        current.switch(4)
161
 
        current.reset()
162
 
        self.assertRevno(5)
163
 
        self.assertFalse(os.path.exists(
164
 
            os.path.join('.bzr', bisect.BISECT_REV_PATH)))
165
 
 
166
 
    def testIsMergePoint(self):
167
 
        """Test merge point detection."""
168
 
        current = bisect.BisectCurrent(self.tree.controldir)
169
 
        self.assertRevno(5)
170
 
        self.assertFalse(current.is_merge_point())
171
 
        current.switch(2)
172
 
        self.assertTrue(current.is_merge_point())
173
 
 
174
 
 
175
 
class BisectLogUnitTests(BisectTestCase):
176
 
    """Test the BisectLog class."""
177
 
 
178
 
    def testCreateBlank(self):
179
 
        """Test creation of new log."""
180
 
        bisect_log = bisect.BisectLog(self.tree.controldir)
181
 
        bisect_log.save()
182
 
        self.assertTrue(
183
 
            os.path.exists(os.path.join('.bzr', bisect.BISECT_INFO_PATH)))
184
 
 
185
 
    def testLoad(self):
186
 
        """Test loading a log."""
187
 
        preloaded_log = open(os.path.join(
188
 
            '.bzr', bisect.BISECT_INFO_PATH), "w")
189
 
        preloaded_log.write("rev1 yes\nrev2 no\nrev3 yes\n")
190
 
        preloaded_log.close()
191
 
 
192
 
        bisect_log = bisect.BisectLog(self.tree.controldir)
193
 
        self.assertEqual(len(bisect_log._items), 3)
194
 
        self.assertEqual(bisect_log._items[0], (b"rev1", "yes"))
195
 
        self.assertEqual(bisect_log._items[1], (b"rev2", "no"))
196
 
        self.assertEqual(bisect_log._items[2], (b"rev3", "yes"))
197
 
 
198
 
    def testSave(self):
199
 
        """Test saving the log."""
200
 
        bisect_log = bisect.BisectLog(self.tree.controldir)
201
 
        bisect_log._items = [
202
 
            (b"rev1", "yes"), (b"rev2", "no"), (b"rev3", "yes")]
203
 
        bisect_log.save()
204
 
 
205
 
        with open(os.path.join('.bzr', bisect.BISECT_INFO_PATH), 'rb') as logfile:
206
 
            self.assertEqual(logfile.read(), b"rev1 yes\nrev2 no\nrev3 yes\n")