← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/blackbox/test_log.py

  • Committer: Vincent Ladeuil
  • Date: 2010-01-15 13:21:15 UTC
  • mto: (4955.4.3 respect-direction)
  • mto: This revision was merged to the branch mainline in revision 4985.
  • Revision ID: v.ladeuil+lp@free.fr-20100115132115-ijwx7we4sosw5lrj
Simplify tests.

* bzrlib/tests/blackbox/test_log.py:
(TestLogWithLogCatcher): Plug a log formatter that captures the
revisions without displaying them.
(TestLogRevSpecs): All the tests only care about the revisions
displayed, not how they are displayed.
(TestLogErrors): Move some more error tests here.
(TestLogRevSpecsWithPaths): Specific tests in specific class.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/blackbox/test_log.py
21
21
import re
22
22
 
23
23
from bzrlib import (
 
24
    log,
24
25
    osutils,
25
26
    tests,
26
27
    )
91
92
        self.assertEqualDiff(expected, test_log.normalize_log(out))
92
93
 
93
94
 
94
 
class TestLogRevSpecs(TestLog):
 
95
class TestLogWithLogCatcher(TestLog):
 
96
 
 
97
    def setUp(self):
 
98
        super(TestLogWithLogCatcher, self).setUp()
 
99
        # Install a default log formatter that captures the revisions but
 
100
        # produces no output
 
101
        self.log_catcher = test_log.LogCatcher()
 
102
        class MyLogFormatter(test_log.LogCatcher):
 
103
 
 
104
            def __new__(klass, *args, **kwargs):
 
105
                # Always return our own log formatter acting as a singleton
 
106
                return self.log_catcher
 
107
 
 
108
        orig = log.log_formatter_registry.get_default
 
109
        def restore():
 
110
            log.log_formatter_registry.get_default = orig
 
111
        self.addCleanup(restore)
 
112
 
 
113
        def getme(branch):
 
114
                # Always return our own log formatter class hijacking the
 
115
                # default behavior (which requires setting up a config
 
116
                # variable)
 
117
            return MyLogFormatter
 
118
        log.log_formatter_registry.get_default = getme
 
119
 
 
120
    def get_captured_revnos(self):
 
121
        return [r.revno for r in self.log_catcher.revisions]
 
122
 
 
123
    def assertLogRevnos(self, args, expected_revnos):
 
124
        self.run_bzr(['log'] + args)
 
125
        self.assertEqual(expected_revnos, self.get_captured_revnos())
 
126
 
 
127
 
 
128
class TestLogRevSpecs(TestLogWithLogCatcher):
 
129
 
 
130
    def test_log_no_revspec(self):
 
131
        self.make_linear_branch()
 
132
        self.assertLogRevnos([], ['3', '2', '1'])
95
133
 
96
134
    def test_log_null_end_revspec(self):
97
135
        self.make_linear_branch()
98
 
        log = self.run_bzr(['log'])[0]
99
 
        self.assertTrue('revno: 1\n' in log)
100
 
        self.assertTrue('revno: 2\n' in log)
101
 
        self.assertTrue('revno: 3\n' in log)
102
 
        self.assertTrue('message:\n  message1\n' in log)
103
 
        self.assertTrue('message:\n  message2\n' in log)
104
 
        self.assertTrue('message:\n  message3\n' in log)
105
 
 
106
 
        full_log = self.run_bzr(['log'])[0]
107
 
        log = self.run_bzr("log -r 1..")[0]
108
 
        self.assertEqualDiff(log, full_log)
 
136
        self.assertLogRevnos(['-r1..'], ['3', '2', '1'])
109
137
 
110
138
    def test_log_null_begin_revspec(self):
111
139
        self.make_linear_branch()
112
 
        full_log = self.run_bzr(['log'])[0]
113
 
        log = self.run_bzr("log -r ..3")[0]
114
 
        self.assertEqualDiff(full_log, log)
 
140
        self.assertLogRevnos(['-r..3'], ['3', '2', '1'])
115
141
 
116
142
    def test_log_null_both_revspecs(self):
117
143
        self.make_linear_branch()
118
 
        full_log = self.run_bzr(['log'])[0]
119
 
        log = self.run_bzr("log -r ..")[0]
120
 
        self.assertEqualDiff(full_log, log)
121
 
 
122
 
    def test_log_zero_revspec(self):
123
 
        self.make_minimal_branch()
124
 
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
125
 
                           ['log', '-r0'])
126
 
 
127
 
    def test_log_zero_begin_revspec(self):
128
 
        self.make_linear_branch()
129
 
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
130
 
                           ['log', '-r0..2'])
131
 
 
132
 
    def test_log_zero_end_revspec(self):
133
 
        self.make_linear_branch()
134
 
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
135
 
                           ['log', '-r-2..0'])
 
144
        self.assertLogRevnos(['-r..'], ['3', '2', '1'])
136
145
 
137
146
    def test_log_negative_begin_revspec_full_log(self):
138
147
        self.make_linear_branch()
139
 
        full_log = self.run_bzr(['log'])[0]
140
 
        log = self.run_bzr("log -r -3..")[0]
141
 
        self.assertEqualDiff(full_log, log)
 
148
        self.assertLogRevnos(['-r-3..'], ['3', '2', '1'])
142
149
 
143
150
    def test_log_negative_both_revspec_full_log(self):
144
151
        self.make_linear_branch()
145
 
        full_log = self.run_bzr(['log'])[0]
146
 
        log = self.run_bzr("log -r -3..-1")[0]
147
 
        self.assertEqualDiff(full_log, log)
 
152
        self.assertLogRevnos(['-r-3..-1'], ['3', '2', '1'])
148
153
 
149
154
    def test_log_negative_both_revspec_partial(self):
150
155
        self.make_linear_branch()
151
 
        log = self.run_bzr("log -r -3..-2")[0]
152
 
        self.assertTrue('revno: 1\n' in log)
153
 
        self.assertTrue('revno: 2\n' in log)
154
 
        self.assertTrue('revno: 3\n' not in log)
 
156
        self.assertLogRevnos(['-r-3..-2'], ['2', '1'])
155
157
 
156
158
    def test_log_negative_begin_revspec(self):
157
159
        self.make_linear_branch()
158
 
        log = self.run_bzr("log -r -2..")[0]
159
 
        self.assertTrue('revno: 1\n' not in log)
160
 
        self.assertTrue('revno: 2\n' in log)
161
 
        self.assertTrue('revno: 3\n' in log)
 
160
        self.assertLogRevnos(['-r-2..'], ['3', '2'])
162
161
 
163
162
    def test_log_positive_revspecs(self):
164
163
        self.make_linear_branch()
165
 
        full_log = self.run_bzr(['log'])[0]
166
 
        log = self.run_bzr("log -r 1..3")[0]
167
 
        self.assertEqualDiff(full_log, log)
 
164
        self.assertLogRevnos(['-r1..3'], ['3', '2', '1'])
168
165
 
169
166
    def test_log_dotted_revspecs(self):
170
167
        self.make_merged_branch()
171
 
        log = self.run_bzr("log -n0 -r 1..1.1.1")[0]
172
 
        self.assertRevnos(log, (1, '1.1.1'), (2, 3, '1.1.2', 4))
173
 
 
174
 
    def test_log_reversed_revspecs(self):
175
 
        self.make_linear_branch()
176
 
        self.run_bzr_error(('bzr: ERROR: Start revision must be older than '
177
 
                            'the end revision.\n',),
178
 
                           ['log', '-r3..1'])
179
 
 
180
 
    def test_log_reversed_dotted_revspecs(self):
181
 
        self.make_merged_branch()
182
 
        self.run_bzr_error(('bzr: ERROR: Start revision not found in '
183
 
                            'left-hand history of end revision.\n',),
184
 
                           "log -r 1.1.1..1")
185
 
 
186
 
    def test_log_revno_n_path(self):
187
 
        self.make_linear_branch('branch1')
188
 
        self.make_linear_branch('branch2')
189
 
        # Swapped revisions
190
 
        self.run_bzr("log -r revno:2:branch1..revno:3:branch2", retcode=3)[0]
191
 
        # Correct order
192
 
        log = self.run_bzr("log -r revno:1:branch2..revno:3:branch2")[0]
193
 
        full_log = self.run_bzr(['log'], working_dir='branch2')[0]
194
 
        self.assertEqualDiff(full_log, log)
195
 
        log = self.run_bzr("log -r revno:1:branch2")[0]
196
 
        self.assertTrue('revno: 1\n' in log)
197
 
        self.assertTrue('revno: 2\n' not in log)
198
 
        self.assertTrue('branch nick: branch2\n' in log)
199
 
        self.assertTrue('branch nick: branch1\n' not in log)
 
168
        self.assertLogRevnos(['-n0', '-r1..1.1.1'], ['1.1.1', '1'])
200
169
 
201
170
    def test_log_limit(self):
202
171
        tree = self.make_branch_and_tree('.')
203
172
        # We want more commits than our batch size starts at
204
173
        for pos in range(10):
205
174
            tree.commit("%s" % pos)
206
 
        log = self.run_bzr("log --limit 2")[0]
207
 
        self.assertNotContainsRe(log, r'revno: 1\n')
208
 
        self.assertNotContainsRe(log, r'revno: 2\n')
209
 
        self.assertNotContainsRe(log, r'revno: 3\n')
210
 
        self.assertNotContainsRe(log, r'revno: 4\n')
211
 
        self.assertNotContainsRe(log, r'revno: 5\n')
212
 
        self.assertNotContainsRe(log, r'revno: 6\n')
213
 
        self.assertNotContainsRe(log, r'revno: 7\n')
214
 
        self.assertNotContainsRe(log, r'revno: 8\n')
215
 
        self.assertContainsRe(log, r'revno: 9\n')
216
 
        self.assertContainsRe(log, r'revno: 10\n')
 
175
        self.assertLogRevnos(['--limit', '2'], ['10', '9'])
217
176
 
218
177
    def test_log_limit_short(self):
219
178
        self.make_linear_branch()
220
 
        log = self.run_bzr("log -l 2")[0]
221
 
        self.assertNotContainsRe(log, r'revno: 1\n')
222
 
        self.assertContainsRe(log, r'revno: 2\n')
223
 
        self.assertContainsRe(log, r'revno: 3\n')
 
179
        self.assertLogRevnos(['-l', '2'], ['3', '2'])
 
180
 
 
181
 
 
182
class TestLogRevSpecsWithPaths(TestLogWithLogCatcher):
 
183
 
 
184
    def test_log_revno_n_path_wrong_namespace(self):
 
185
        self.make_linear_branch('branch1')
 
186
        self.make_linear_branch('branch2')
 
187
        # There is no guarantee that a path exist between two arbitrary
 
188
        # revisions.
 
189
        self.run_bzr("log -r revno:2:branch1..revno:3:branch2", retcode=3)
 
190
        # But may be it's worth trying though ? -- vila 100115
 
191
 
 
192
    def test_log_revno_n_path_correct_order(self):
 
193
        self.make_linear_branch('branch2')
 
194
        self.assertLogRevnos(['-rrevno:1:branch2..revno:3:branch2'],
 
195
                             ['3', '2','1'])
 
196
 
 
197
    def test_log_revno_n_path(self):
 
198
        self.make_linear_branch('branch2')
 
199
        self.assertLogRevnos(['-rrevno:1:branch2'],
 
200
                             ['1'])
 
201
        rev_props = self.log_catcher.revisions[0].rev.properties
 
202
        self.assertEqual('branch2', rev_props['branch-nick'])
224
203
 
225
204
 
226
205
class TestLogErrors(TestLog):
227
206
 
 
207
    def test_log_zero_revspec(self):
 
208
        self.make_minimal_branch()
 
209
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
 
210
                           ['log', '-r0'])
 
211
 
 
212
    def test_log_zero_begin_revspec(self):
 
213
        self.make_linear_branch()
 
214
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
 
215
                           ['log', '-r0..2'])
 
216
 
 
217
    def test_log_zero_end_revspec(self):
 
218
        self.make_linear_branch()
 
219
        self.run_bzr_error(['bzr: ERROR: Logging revision 0 is invalid.'],
 
220
                           ['log', '-r-2..0'])
 
221
 
228
222
    def test_log_nonexistent_revno(self):
229
223
        self.make_minimal_branch()
230
224
        (out, err) = self.run_bzr_error(
279
273
                              'Path unknown at end or start of revision range: '
280
274
                              'does-not-exist')
281
275
 
 
276
    def test_log_reversed_revspecs(self):
 
277
        self.make_linear_branch()
 
278
        self.run_bzr_error(('bzr: ERROR: Start revision must be older than '
 
279
                            'the end revision.\n',),
 
280
                           ['log', '-r3..1'])
 
281
 
 
282
    def test_log_reversed_dotted_revspecs(self):
 
283
        self.make_merged_branch()
 
284
        self.run_bzr_error(('bzr: ERROR: Start revision not found in '
 
285
                            'left-hand history of end revision.\n',),
 
286
                           "log -r 1.1.1..1")
 
287
 
282
288
    def test_log_bad_message_re(self):
283
289
        """Bad --message argument gives a sensible message
284
290