/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: 2005-10-19 10:11:57 UTC
  • mfrom: (1185.16.78)
  • mto: This revision was merged to the branch mainline in revision 1470.
  • Revision ID: robertc@robertcollins.net-20051019101157-17438d311e746b4f
merge from upstream

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