~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Martin Pool
  • Date: 2005-07-07 08:02:16 UTC
  • Revision ID: mbp@sourcefrog.net-20050707080216-4e4d884bcf89eb8d
- Merge merge updates from aaron

  aaron.bentley@utoronto.ca-20050706170931-9d2551019af3578d

Show diffs side-by-side

added added

removed removed

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