← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

merge merge tweaks from aaron, which includes latest .dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/blackbox.py
26
26
it's normally invoked.
27
27
"""
28
28
 
29
 
# this code was previously in testbzr
30
 
 
31
 
from unittest import TestCase
32
 
from bzrlib.selftest import TestBase, InTempDir
33
 
 
34
 
 
35
 
 
36
 
class ExternalBase(InTempDir):
37
 
    def runbzr(self, args, retcode=0):
38
 
        try:
39
 
            import shutil
40
 
            from subprocess import call
41
 
        except ImportError, e:
42
 
            _need_subprocess()
43
 
            raise
44
 
 
 
29
from cStringIO import StringIO
 
30
import sys
 
31
import os
 
32
 
 
33
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
 
34
from bzrlib.branch import Branch
 
35
from bzrlib.commands import run_bzr
 
36
 
 
37
 
 
38
class ExternalBase(TestCaseInTempDir):
 
39
    def runbzr(self, args, retcode=0, backtick=False):
45
40
        if isinstance(args, basestring):
46
41
            args = args.split()
47
 
            
48
 
        return self.runcmd(['python', self.BZRPATH,] + args,
49
 
                           retcode=retcode)
50
 
 
51
 
 
52
 
 
53
 
class TestVersion(ExternalBase):
54
 
    def runTest(self):
55
 
        # output is intentionally passed through to stdout so that we
56
 
        # can see the version being tested
57
 
        self.runbzr(['version'])
58
 
 
59
 
 
60
 
 
61
 
class HelpCommands(ExternalBase):
62
 
    def runTest(self):
 
42
 
 
43
        if backtick:
 
44
            return self.run_bzr_captured(args, retcode=retcode)[0]
 
45
        else:
 
46
            return self.run_bzr_captured(args, retcode=retcode)
 
47
 
 
48
 
 
49
class TestCommands(ExternalBase):
 
50
 
 
51
    def test_help_commands(self):
63
52
        self.runbzr('--help')
64
53
        self.runbzr('help')
65
54
        self.runbzr('help commands')
66
55
        self.runbzr('help help')
67
56
        self.runbzr('commit -h')
68
57
 
69
 
 
70
 
class InitBranch(ExternalBase):
71
 
    def runTest(self):
72
 
        import os
 
58
    def test_init_branch(self):
73
59
        self.runbzr(['init'])
74
60
 
75
 
 
76
 
 
77
 
class UserIdentity(ExternalBase):
78
 
    def runTest(self):
 
61
    def test_whoami(self):
79
62
        # this should always identify something, if only "john@localhost"
80
63
        self.runbzr("whoami")
81
64
        self.runbzr("whoami --email")
82
 
        self.assertEquals(self.backtick("bzr whoami --email").count('@'),
83
 
                          1)
84
 
 
85
 
 
86
 
class InvalidCommands(ExternalBase):
87
 
    def runTest(self):
 
65
 
 
66
        self.assertEquals(self.runbzr("whoami --email",
 
67
                                      backtick=True).count('@'), 1)
 
68
        
 
69
    def test_whoami_branch(self):
 
70
        """branch specific user identity works."""
 
71
        self.runbzr('init')
 
72
        f = file('.bzr/email', 'wt')
 
73
        f.write('Branch Identity <branch@identi.ty>')
 
74
        f.close()
 
75
        bzr_email = os.environ.get('BZREMAIL')
 
76
        if bzr_email is not None:
 
77
            del os.environ['BZREMAIL']
 
78
        whoami = self.runbzr("whoami",backtick=True)
 
79
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
80
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
 
81
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
 
82
        # Verify that the environment variable overrides the value 
 
83
        # in the file
 
84
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
 
85
        whoami = self.runbzr("whoami",backtick=True)
 
86
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
87
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
 
88
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
 
89
        if bzr_email is not None:
 
90
            os.environ['BZREMAIL'] = bzr_email
 
91
 
 
92
    def test_invalid_commands(self):
88
93
        self.runbzr("pants", retcode=1)
89
94
        self.runbzr("--pants off", retcode=1)
90
95
        self.runbzr("diff --message foo", retcode=1)
91
96
 
92
 
 
93
 
 
94
 
class EmptyCommit(ExternalBase):
95
 
    def runTest(self):
 
97
    def test_empty_commit(self):
96
98
        self.runbzr("init")
97
99
        self.build_tree(['hello.txt'])
98
100
        self.runbzr("commit -m empty", retcode=1)
99
101
        self.runbzr("add hello.txt")
100
102
        self.runbzr("commit -m added")
101
103
 
102
 
 
103
 
 
104
 
class IgnorePatterns(ExternalBase):
105
 
    def runTest(self):
 
104
    def test_ignore_patterns(self):
106
105
        from bzrlib.branch import Branch
107
106
        
108
 
        b = Branch('.', init=True)
 
107
        b = Branch.initialize('.')
109
108
        self.assertEquals(list(b.unknowns()), [])
110
109
 
111
110
        file('foo.tmp', 'wt').write('tmp files are ignored')
112
111
        self.assertEquals(list(b.unknowns()), [])
113
 
        assert self.backtick('bzr unknowns') == ''
 
112
        assert self.capture('unknowns') == ''
114
113
 
115
114
        file('foo.c', 'wt').write('int main() {}')
116
115
        self.assertEquals(list(b.unknowns()), ['foo.c'])
117
 
        assert self.backtick('bzr unknowns') == 'foo.c\n'
 
116
        assert self.capture('unknowns') == 'foo.c\n'
118
117
 
119
118
        self.runbzr(['add', 'foo.c'])
120
 
        assert self.backtick('bzr unknowns') == ''
 
119
        assert self.capture('unknowns') == ''
121
120
 
122
121
        # 'ignore' works when creating the .bzignore file
123
122
        file('foo.blah', 'wt').write('blah')
129
128
        # 'ignore' works when then .bzrignore file already exists
130
129
        file('garh', 'wt').write('garh')
131
130
        self.assertEquals(list(b.unknowns()), ['garh'])
132
 
        assert self.backtick('bzr unknowns') == 'garh\n'
 
131
        assert self.capture('unknowns') == 'garh\n'
133
132
        self.runbzr('ignore garh')
134
133
        self.assertEquals(list(b.unknowns()), [])
135
134
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
136
 
        
137
 
 
 
135
 
 
136
    def test_revert(self):
 
137
        self.runbzr('init')
 
138
 
 
139
        file('hello', 'wt').write('foo')
 
140
        self.runbzr('add hello')
 
141
        self.runbzr('commit -m setup hello')
 
142
 
 
143
        file('goodbye', 'wt').write('baz')
 
144
        self.runbzr('add goodbye')
 
145
        self.runbzr('commit -m setup goodbye')
 
146
        
 
147
        file('hello', 'wt').write('bar')
 
148
        file('goodbye', 'wt').write('qux')
 
149
        self.runbzr('revert hello')
 
150
        self.check_file_contents('hello', 'foo')
 
151
        self.check_file_contents('goodbye', 'qux')
 
152
        self.runbzr('revert')
 
153
        self.check_file_contents('goodbye', 'baz')
 
154
 
 
155
        os.mkdir('revertdir')
 
156
        self.runbzr('add revertdir')
 
157
        self.runbzr('commit -m f')
 
158
        os.rmdir('revertdir')
 
159
        self.runbzr('revert')
 
160
 
 
161
        file('hello', 'wt').write('xyz')
 
162
        self.runbzr('commit -m xyz hello')
 
163
        self.runbzr('revert -r 1 hello')
 
164
        self.check_file_contents('hello', 'foo')
 
165
        self.runbzr('revert hello')
 
166
        self.check_file_contents('hello', 'xyz')
 
167
 
 
168
    def test_mv_modes(self):
 
169
        """Test two modes of operation for mv"""
 
170
        from bzrlib.branch import Branch
 
171
        b = Branch.initialize('.')
 
172
        self.build_tree(['a', 'c', 'subdir/'])
 
173
        self.run_bzr('add', self.test_dir)
 
174
        self.run_bzr('mv', 'a', 'b')
 
175
        self.run_bzr('mv', 'b', 'subdir')
 
176
        self.run_bzr('mv', 'subdir/b', 'a')
 
177
        self.run_bzr('mv', 'a', 'c', 'subdir')
 
178
        self.run_bzr('mv', 'subdir/a', 'subdir/newa')
 
179
 
 
180
 
 
181
    def test_main_version(self):
 
182
        """Check output from version command and master option is reasonable"""
 
183
        # output is intentionally passed through to stdout so that we
 
184
        # can see the version being tested
 
185
        output = self.runbzr('version', backtick=1)
 
186
        self.log('bzr version output:')
 
187
        self.log(output)
 
188
        self.assert_(output.startswith('bzr (bazaar-ng) '))
 
189
        self.assertNotEqual(output.index('Canonical'), -1)
 
190
        # make sure --version is consistent
 
191
        tmp_output = self.runbzr('--version', backtick=1)
 
192
        self.log('bzr --version output:')
 
193
        self.log(tmp_output)
 
194
        self.assertEquals(output, tmp_output)
 
195
 
 
196
    def example_branch(test):
 
197
        test.runbzr('init')
 
198
        file('hello', 'wt').write('foo')
 
199
        test.runbzr('add hello')
 
200
        test.runbzr('commit -m setup hello')
 
201
        file('goodbye', 'wt').write('baz')
 
202
        test.runbzr('add goodbye')
 
203
        test.runbzr('commit -m setup goodbye')
 
204
 
 
205
    def test_diff(self):
 
206
        self.example_branch()
 
207
        file('hello', 'wt').write('hello world!')
 
208
        self.runbzr('commit -m fixing hello')
 
209
        output = self.runbzr('diff -r 2..3', backtick=1)
 
210
        self.assert_('\n+hello world!' in output)
 
211
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
212
        self.assert_('\n+baz' in output)
 
213
 
 
214
    def test_diff(self):
 
215
        self.example_branch()
 
216
        file('hello', 'wt').write('hello world!')
 
217
        self.runbzr('commit -m fixing hello')
 
218
        output = self.runbzr('diff -r 2..3', backtick=1)
 
219
        self.assert_('\n+hello world!' in output)
 
220
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
221
        self.assert_('\n+baz' in output)
 
222
 
 
223
    def test_merge(self):
 
224
        from bzrlib.branch import Branch
 
225
        
 
226
        os.mkdir('a')
 
227
        os.chdir('a')
 
228
        self.example_branch()
 
229
        os.chdir('..')
 
230
        self.runbzr('branch a b')
 
231
        os.chdir('b')
 
232
        file('goodbye', 'wt').write('quux')
 
233
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
234
 
 
235
        os.chdir('../a')
 
236
        file('hello', 'wt').write('quuux')
 
237
        # We can't merge when there are in-tree changes
 
238
        self.runbzr('merge ../b', retcode=1)
 
239
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
240
        self.runbzr('merge ../b')
 
241
        self.check_file_contents('goodbye', 'quux')
 
242
        # Merging a branch pulls its revision into the tree
 
243
        a = Branch.open('.')
 
244
        b = Branch.open('../b')
 
245
        a.get_revision_xml(b.last_patch())
 
246
        self.log('pending merges: %s', a.pending_merges())
 
247
        #        assert a.pending_merges() == [b.last_patch()], "Assertion %s %s" \
 
248
        #        % (a.pending_merges(), b.last_patch())
 
249
 
 
250
    def test_pull(self):
 
251
        """Pull changes from one branch to another."""
 
252
        os.mkdir('a')
 
253
        os.chdir('a')
 
254
 
 
255
        self.example_branch()
 
256
        self.runbzr('pull', retcode=1)
 
257
        self.runbzr('missing', retcode=1)
 
258
        self.runbzr('missing .')
 
259
        self.runbzr('missing')
 
260
        self.runbzr('pull')
 
261
        self.runbzr('pull /', retcode=1)
 
262
        self.runbzr('pull')
 
263
 
 
264
        os.chdir('..')
 
265
        self.runbzr('branch a b')
 
266
        os.chdir('b')
 
267
        self.runbzr('pull')
 
268
        self.runbzr('commit -m blah --unchanged')
 
269
        os.chdir('../a')
 
270
        a = Branch.open('.')
 
271
        b = Branch.open('../b')
 
272
        assert a.revision_history() == b.revision_history()[:-1]
 
273
        self.runbzr('pull ../b')
 
274
        assert a.revision_history() == b.revision_history()
 
275
        self.runbzr('commit -m blah2 --unchanged')
 
276
        os.chdir('../b')
 
277
        self.runbzr('commit -m blah3 --unchanged')
 
278
        self.runbzr('pull ../a', retcode=1)
 
279
        os.chdir('../a')
 
280
        self.runbzr('merge ../b')
 
281
        self.runbzr('commit -m blah4 --unchanged')
 
282
        os.chdir('../b')
 
283
        self.runbzr('pull ../a')
 
284
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
285
        
 
286
    def test_add_reports(self):
 
287
        """add command prints the names of added files."""
 
288
        b = Branch.initialize('.')
 
289
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
290
        out = StringIO()
 
291
        ret = self.apply_redirected(None, out, None,
 
292
                                    run_bzr,
 
293
                                    ['add'])
 
294
        self.assertEquals(ret, 0)
 
295
        # the ordering is not defined at the moment
 
296
        results = sorted(out.getvalue().rstrip('\n').split('\n'))
 
297
        self.assertEquals(['added dir',
 
298
                           'added dir/sub.txt',
 
299
                           'added top.txt',],
 
300
                          results)
 
301
 
 
302
    def test_unknown_command(self):
 
303
        """Handling of unknown command."""
 
304
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
305
                                         retcode=1)
 
306
        self.assertEquals(out, '')
 
307
        err.index('unknown command')
 
308
        
138
309
 
139
310
 
140
311
class OldTests(ExternalBase):
141
 
    # old tests moved from ./testbzr
142
 
    def runTest(self):
 
312
    """old tests moved from ./testbzr."""
 
313
 
 
314
    def test_bzr(self):
143
315
        from os import chdir, mkdir
144
316
        from os.path import exists
145
 
        import os
146
317
 
147
318
        runbzr = self.runbzr
148
 
        backtick = self.backtick
 
319
        capture = self.capture
149
320
        progress = self.log
150
321
 
151
322
        progress("basic branch creation")
153
324
        chdir('branch1')
154
325
        runbzr('init')
155
326
 
156
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
327
        self.assertEquals(capture('root').rstrip(),
157
328
                          os.path.join(self.test_dir, 'branch1'))
158
329
 
159
330
        progress("status of new file")
162
333
        f.write('hello world!\n')
163
334
        f.close()
164
335
 
165
 
        out = backtick("bzr unknowns")
166
 
        self.assertEquals(out, 'test.txt\n')
 
336
        self.assertEquals(capture('unknowns'), 'test.txt\n')
167
337
 
168
 
        out = backtick("bzr status")
 
338
        out = capture("status")
169
339
        assert out == 'unknown:\n  test.txt\n'
170
340
 
171
 
        out = backtick("bzr status --all")
 
341
        out = capture("status --all")
172
342
        assert out == "unknown:\n  test.txt\n"
173
343
 
174
 
        out = backtick("bzr status test.txt --all")
 
344
        out = capture("status test.txt --all")
175
345
        assert out == "unknown:\n  test.txt\n"
176
346
 
177
347
        f = file('test2.txt', 'wt')
178
348
        f.write('goodbye cruel world...\n')
179
349
        f.close()
180
350
 
181
 
        out = backtick("bzr status test.txt")
 
351
        out = capture("status test.txt")
182
352
        assert out == "unknown:\n  test.txt\n"
183
353
 
184
 
        out = backtick("bzr status")
 
354
        out = capture("status")
185
355
        assert out == ("unknown:\n"
186
356
                       "  test.txt\n"
187
357
                       "  test2.txt\n")
189
359
        os.unlink('test2.txt')
190
360
 
191
361
        progress("command aliases")
192
 
        out = backtick("bzr st --all")
 
362
        out = capture("st --all")
193
363
        assert out == ("unknown:\n"
194
364
                       "  test.txt\n")
195
365
 
196
 
        out = backtick("bzr stat")
 
366
        out = capture("stat")
197
367
        assert out == ("unknown:\n"
198
368
                       "  test.txt\n")
199
369
 
203
373
        runbzr("help commands")
204
374
        runbzr("help slartibartfast", 1)
205
375
 
206
 
        out = backtick("bzr help ci")
 
376
        out = capture("help ci")
207
377
        out.index('aliases: ')
208
378
 
209
379
        progress("can't rename unversioned file")
212
382
        progress("adding a file")
213
383
 
214
384
        runbzr("add test.txt")
215
 
        assert backtick("bzr unknowns") == ''
216
 
        assert backtick("bzr status --all") == ("added:\n"
 
385
        assert capture("unknowns") == ''
 
386
        assert capture("status --all") == ("added:\n"
217
387
                                                "  test.txt\n")
218
388
 
219
389
        progress("rename newly-added file")
221
391
        assert os.path.exists("hello.txt")
222
392
        assert not os.path.exists("test.txt")
223
393
 
224
 
        assert backtick("bzr revno") == '0\n'
 
394
        assert capture("revno") == '0\n'
225
395
 
226
396
        progress("add first revision")
227
397
        runbzr(['commit', '-m', 'add first revision'])
235
405
        runbzr("add sub1")
236
406
        runbzr("rename sub1 sub2")
237
407
        runbzr("move hello.txt sub2")
238
 
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
408
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
239
409
 
240
410
        assert exists("sub2")
241
411
        assert exists("sub2/hello.txt")
256
426
        runbzr(['commit', '-m', 'rename nested subdirectories'])
257
427
 
258
428
        chdir('sub1/sub2')
259
 
        self.assertEquals(backtick('bzr root')[:-1],
 
429
        self.assertEquals(capture('root')[:-1],
260
430
                          os.path.join(self.test_dir, 'branch1'))
261
431
        runbzr('move ../hello.txt .')
262
432
        assert exists('./hello.txt')
263
 
        assert backtick('bzr relpath hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
264
 
        assert backtick('bzr relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
433
        self.assertEquals(capture('relpath hello.txt'),
 
434
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
435
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
265
436
        runbzr(['commit', '-m', 'move to parent directory'])
266
437
        chdir('..')
267
 
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
438
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
268
439
 
269
440
        runbzr('move sub2/hello.txt .')
270
441
        assert exists('hello.txt')
279
450
 
280
451
        runbzr('commit -F msg.tmp')
281
452
 
282
 
        assert backtick('bzr revno') == '5\n'
 
453
        assert capture('revno') == '5\n'
283
454
        runbzr('export -r 5 export-5.tmp')
284
455
        runbzr('export export.tmp')
285
456
 
287
458
        runbzr('log -v')
288
459
        runbzr('log -v --forward')
289
460
        runbzr('log -m', retcode=1)
290
 
        log_out = backtick('bzr log -m commit')
 
461
        log_out = capture('log -m commit')
291
462
        assert "this is my new commit" in log_out
292
463
        assert "rename nested" not in log_out
293
464
        assert 'revision-id' not in log_out
294
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
465
        assert 'revision-id' in capture('log --show-ids -m commit')
295
466
 
296
467
 
297
468
        progress("file with spaces in name")
307
478
 
308
479
        runbzr('info')
309
480
 
310
 
 
311
 
 
312
 
 
313
 
 
314
 
 
315
 
        chdir('..')
316
 
        chdir('..')
317
 
        progress('branch')
318
 
        assert os.path.exists('branch1')
319
 
        assert not os.path.exists('branch2')
320
 
        # Can't create a branch if it already exists
321
 
        runbzr('branch branch1', retcode=1)
322
 
        # Can't create a branch if its parent doesn't exist
323
 
        runbzr('branch /unlikely/to/exist', retcode=1)
324
 
        runbzr('branch branch1 branch2')
325
 
        assert exists('branch2')
326
 
        assert exists('branch2/sub1')
327
 
        assert exists('branch2/sub1/hello.txt')
328
 
        
329
 
        runbzr('branch --revision 0 branch1 branch3')
330
 
        assert not exists('branch3/sub1/hello.txt')
331
 
        runbzr('branch --revision 0..3 branch1 branch4', retcode=1)
332
 
 
333
 
        progress("pull")
334
 
        chdir('branch1')
335
 
        runbzr('pull', retcode=1)
336
 
        runbzr('pull ../branch2')
337
 
        chdir('.bzr')
338
 
        runbzr('pull')
339
 
        runbzr('commit --unchanged -m empty')
340
 
        runbzr('pull')
341
 
        chdir('../../branch2')
342
 
        runbzr('pull')
343
 
        runbzr('commit --unchanged -m empty')
344
 
        chdir('../branch1')
345
 
        runbzr('commit --unchanged -m empty')
346
 
        runbzr('pull', retcode=1)
347
 
        chdir ('..')
348
 
 
349
 
        progress('status after remove')
350
 
        mkdir('status-after-remove')
351
 
        # see mail from William Dodé, 2005-05-25
352
 
        # $ bzr init; touch a; bzr add a; bzr commit -m "add a"
353
 
        #     * looking for changes...
354
 
        #     added a
355
 
        #     * commited r1
356
 
        #     $ bzr remove a
357
 
        #     $ bzr status
358
 
        #     bzr: local variable 'kind' referenced before assignment
359
 
        #     at /vrac/python/bazaar-ng/bzrlib/diff.py:286 in compare_trees()
360
 
        #     see ~/.bzr.log for debug information
361
 
        chdir('status-after-remove')
362
 
        runbzr('init')
363
 
        file('a', 'w').write('foo')
364
 
        runbzr('add a')
365
 
        runbzr(['commit', '-m', 'add a'])
366
 
        runbzr('remove a')
367
 
        runbzr('status')
368
 
 
369
 
        chdir('..')
370
 
 
371
 
 
372
 
 
373
 
        progress("recursive and non-recursive add")
374
 
        mkdir('no-recurse')
375
 
        chdir('no-recurse')
376
 
        runbzr('init')
377
 
        mkdir('foo')
378
 
        fp = os.path.join('foo', 'test.txt')
379
 
        f = file(fp, 'w')
380
 
        f.write('hello!\n')
381
 
        f.close()
382
 
        runbzr('add --no-recurse foo')
383
 
        runbzr('file-id foo')
384
 
        runbzr('file-id ' + fp, 1)      # not versioned yet
385
 
        runbzr('commit -m add-dir-only')
386
 
 
387
 
        self.runbzr('file-id ' + fp, 1)      # still not versioned 
388
 
 
389
 
        self.runbzr('add foo')
390
 
        self.runbzr('file-id ' + fp)
391
 
        self.runbzr('commit -m add-sub-file')
392
 
 
393
 
        chdir('..')
394
 
 
395
 
 
396
 
 
397
 
class RevertCommand(ExternalBase):
398
 
    def runTest(self):
399
 
        self.runbzr('init')
400
 
 
401
 
        file('hello', 'wt').write('foo')
402
 
        self.runbzr('add hello')
403
 
        self.runbzr('commit -m setup hello')
404
 
        
405
 
        file('hello', 'wt').write('bar')
406
 
        self.runbzr('revert hello')
407
 
        self.check_file_contents('hello', 'foo')
408