← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Aaron Bentley
  • Date: 2005-10-03 16:53:39 UTC
  • mto: (1185.25.1)
  • mto: This revision was merged to the branch mainline in revision 1419.
  • Revision ID: abentley@panoramicfeedback.com-20051003165339-9ee4d484477fd164
Ignored user-installed plugins

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
from cStringIO import StringIO
 
30
import os
 
31
import shutil
29
32
import sys
30
33
 
31
 
from bzrlib.selftest import InTempDir, BzrTestBase
32
 
 
33
 
 
34
 
 
35
 
class ExternalBase(InTempDir):
36
 
    def runbzr(self, args, retcode=0,backtick=False):
37
 
        try:
38
 
            import shutil
39
 
            from subprocess import call
40
 
        except ImportError, e:
41
 
            _need_subprocess()
42
 
            raise
43
 
 
 
34
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
 
35
from bzrlib.branch import Branch
 
36
 
 
37
 
 
38
class ExternalBase(TestCaseInTempDir):
 
39
 
 
40
    def runbzr(self, args, retcode=0, backtick=False):
44
41
        if isinstance(args, basestring):
45
42
            args = args.split()
46
43
 
47
44
        if backtick:
48
 
            return self.backtick(['python', self.BZRPATH,] + args,
49
 
                           retcode=retcode)
 
45
            return self.run_bzr_captured(args, retcode=retcode)[0]
50
46
        else:
51
 
            return self.runcmd(['python', self.BZRPATH,] + args,
52
 
                           retcode=retcode)
53
 
 
54
 
 
55
 
 
56
 
class MvCommand(BzrTestBase):
57
 
    def runbzr(self):
58
 
        """Test two modes of operation for mv"""
59
 
        b = Branch('.', init=True)
60
 
        self.build_tree(['a', 'c', 'subdir/'])
61
 
        self.run_bzr('mv', 'a', 'b')
62
 
        self.run_bzr('mv', 'b', 'subdir')
63
 
        self.run_bzr('mv', 'subdir/b', 'a')
64
 
        self.run_bzr('mv', 'a', 'b', 'subdir')
65
 
        self.run_bzr('mv', 'subdir/a', 'subdir/newa')
66
 
 
67
 
 
68
 
 
69
 
class TestVersion(BzrTestBase):
70
 
    """Check output from version command and master option is reasonable"""
71
 
    def runTest(self):
72
 
        # output is intentionally passed through to stdout so that we
73
 
        # can see the version being tested
74
 
        from cStringIO import StringIO
75
 
        save_out = sys.stdout
76
 
        try:
77
 
            sys.stdout = tmp_out = StringIO()
78
 
            
79
 
            self.run_bzr('version')
80
 
        finally:
81
 
            sys.stdout = save_out
82
 
 
83
 
        output = tmp_out.getvalue()
84
 
        self.log('bzr version output:')
85
 
        self.log(output)
86
 
        
87
 
        self.assert_(output.startswith('bzr (bazaar-ng) '))
88
 
        self.assertNotEqual(output.index('Canonical'), -1)
89
 
 
90
 
        # make sure --version is consistent
91
 
        try:
92
 
            sys.stdout = tmp_out = StringIO()
93
 
            
94
 
            self.run_bzr('--version')
95
 
        finally:
96
 
            sys.stdout = save_out
97
 
 
98
 
        self.log('bzr --version output:')
99
 
        self.log(tmp_out.getvalue())
100
 
 
101
 
        self.assertEquals(output, tmp_out.getvalue())
102
 
 
103
 
 
104
 
        
105
 
 
106
 
 
107
 
class HelpCommands(ExternalBase):
108
 
    def runTest(self):
 
47
            return self.run_bzr_captured(args, retcode=retcode)
 
48
 
 
49
 
 
50
class TestCommands(ExternalBase):
 
51
 
 
52
    def test_help_commands(self):
109
53
        self.runbzr('--help')
110
54
        self.runbzr('help')
111
55
        self.runbzr('help commands')
112
56
        self.runbzr('help help')
113
57
        self.runbzr('commit -h')
114
58
 
115
 
 
116
 
class InitBranch(ExternalBase):
117
 
    def runTest(self):
118
 
        import os
 
59
    def test_init_branch(self):
119
60
        self.runbzr(['init'])
120
61
 
121
 
 
122
 
class UserIdentity(ExternalBase):
123
 
    def runTest(self):
 
62
    def test_whoami(self):
124
63
        # this should always identify something, if only "john@localhost"
125
64
        self.runbzr("whoami")
126
65
        self.runbzr("whoami --email")
128
67
        self.assertEquals(self.runbzr("whoami --email",
129
68
                                      backtick=True).count('@'), 1)
130
69
        
131
 
class UserIdentityBranch(ExternalBase):
132
 
    def runTest(self):
133
 
        # tests branch specific user identity
 
70
    def test_whoami_branch(self):
 
71
        """branch specific user identity works."""
134
72
        self.runbzr('init')
135
73
        f = file('.bzr/email', 'wt')
136
74
        f.write('Branch Identity <branch@identi.ty>')
137
75
        f.close()
 
76
        bzr_email = os.environ.get('BZREMAIL')
 
77
        if bzr_email is not None:
 
78
            del os.environ['BZREMAIL']
138
79
        whoami = self.runbzr("whoami",backtick=True)
139
80
        whoami_email = self.runbzr("whoami --email",backtick=True)
140
81
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
141
82
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
142
 
 
143
 
 
144
 
class InvalidCommands(ExternalBase):
145
 
    def runTest(self):
 
83
        # Verify that the environment variable overrides the value 
 
84
        # in the file
 
85
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
 
86
        whoami = self.runbzr("whoami",backtick=True)
 
87
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
88
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
 
89
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
 
90
        if bzr_email is not None:
 
91
            os.environ['BZREMAIL'] = bzr_email
 
92
 
 
93
    def test_invalid_commands(self):
146
94
        self.runbzr("pants", retcode=1)
147
95
        self.runbzr("--pants off", retcode=1)
148
96
        self.runbzr("diff --message foo", retcode=1)
149
97
 
150
 
 
151
 
 
152
 
class EmptyCommit(ExternalBase):
153
 
    def runTest(self):
 
98
    def test_empty_commit(self):
154
99
        self.runbzr("init")
155
100
        self.build_tree(['hello.txt'])
156
101
        self.runbzr("commit -m empty", retcode=1)
157
102
        self.runbzr("add hello.txt")
158
103
        self.runbzr("commit -m added")
159
104
 
160
 
 
161
 
 
162
 
class IgnorePatterns(ExternalBase):
163
 
    def runTest(self):
 
105
    def test_ignore_patterns(self):
164
106
        from bzrlib.branch import Branch
165
107
        
166
 
        b = Branch('.', init=True)
 
108
        b = Branch.initialize('.')
167
109
        self.assertEquals(list(b.unknowns()), [])
168
110
 
169
111
        file('foo.tmp', 'wt').write('tmp files are ignored')
170
112
        self.assertEquals(list(b.unknowns()), [])
171
 
        assert self.backtick('bzr unknowns') == ''
 
113
        assert self.capture('unknowns') == ''
172
114
 
173
115
        file('foo.c', 'wt').write('int main() {}')
174
116
        self.assertEquals(list(b.unknowns()), ['foo.c'])
175
 
        assert self.backtick('bzr unknowns') == 'foo.c\n'
 
117
        assert self.capture('unknowns') == 'foo.c\n'
176
118
 
177
119
        self.runbzr(['add', 'foo.c'])
178
 
        assert self.backtick('bzr unknowns') == ''
 
120
        assert self.capture('unknowns') == ''
179
121
 
180
122
        # 'ignore' works when creating the .bzignore file
181
123
        file('foo.blah', 'wt').write('blah')
182
124
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
183
125
        self.runbzr('ignore *.blah')
184
126
        self.assertEquals(list(b.unknowns()), [])
185
 
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
 
127
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
186
128
 
187
129
        # 'ignore' works when then .bzrignore file already exists
188
130
        file('garh', 'wt').write('garh')
189
131
        self.assertEquals(list(b.unknowns()), ['garh'])
190
 
        assert self.backtick('bzr unknowns') == 'garh\n'
 
132
        assert self.capture('unknowns') == 'garh\n'
191
133
        self.runbzr('ignore garh')
192
134
        self.assertEquals(list(b.unknowns()), [])
193
 
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
194
 
        
195
 
 
 
135
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
 
136
 
 
137
    def test_revert(self):
 
138
        self.runbzr('init')
 
139
 
 
140
        file('hello', 'wt').write('foo')
 
141
        self.runbzr('add hello')
 
142
        self.runbzr('commit -m setup hello')
 
143
 
 
144
        file('goodbye', 'wt').write('baz')
 
145
        self.runbzr('add goodbye')
 
146
        self.runbzr('commit -m setup goodbye')
 
147
        
 
148
        file('hello', 'wt').write('bar')
 
149
        file('goodbye', 'wt').write('qux')
 
150
        self.runbzr('revert hello')
 
151
        self.check_file_contents('hello', 'foo')
 
152
        self.check_file_contents('goodbye', 'qux')
 
153
        self.runbzr('revert')
 
154
        self.check_file_contents('goodbye', 'baz')
 
155
 
 
156
        os.mkdir('revertdir')
 
157
        self.runbzr('add revertdir')
 
158
        self.runbzr('commit -m f')
 
159
        os.rmdir('revertdir')
 
160
        self.runbzr('revert')
 
161
 
 
162
        file('hello', 'wt').write('xyz')
 
163
        self.runbzr('commit -m xyz hello')
 
164
        self.runbzr('revert -r 1 hello')
 
165
        self.check_file_contents('hello', 'foo')
 
166
        self.runbzr('revert hello')
 
167
        self.check_file_contents('hello', 'xyz')
 
168
        os.chdir('revertdir')
 
169
        self.runbzr('revert')
 
170
        os.chdir('..')
 
171
 
 
172
 
 
173
    def test_mv_modes(self):
 
174
        """Test two modes of operation for mv"""
 
175
        from bzrlib.branch import Branch
 
176
        b = Branch.initialize('.')
 
177
        self.build_tree(['a', 'c', 'subdir/'])
 
178
        self.run_bzr_captured(['add', self.test_dir])
 
179
        self.run_bzr_captured(['mv', 'a', 'b'])
 
180
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
181
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
182
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
183
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
 
184
 
 
185
 
 
186
    def test_main_version(self):
 
187
        """Check output from version command and master option is reasonable"""
 
188
        # output is intentionally passed through to stdout so that we
 
189
        # can see the version being tested
 
190
        output = self.runbzr('version', backtick=1)
 
191
        self.log('bzr version output:')
 
192
        self.log(output)
 
193
        self.assert_(output.startswith('bzr (bazaar-ng) '))
 
194
        self.assertNotEqual(output.index('Canonical'), -1)
 
195
        # make sure --version is consistent
 
196
        tmp_output = self.runbzr('--version', backtick=1)
 
197
        self.log('bzr --version output:')
 
198
        self.log(tmp_output)
 
199
        self.assertEquals(output, tmp_output)
 
200
 
 
201
    def example_branch(test):
 
202
        test.runbzr('init')
 
203
        file('hello', 'wt').write('foo')
 
204
        test.runbzr('add hello')
 
205
        test.runbzr('commit -m setup hello')
 
206
        file('goodbye', 'wt').write('baz')
 
207
        test.runbzr('add goodbye')
 
208
        test.runbzr('commit -m setup goodbye')
 
209
 
 
210
    def test_export(self):
 
211
        os.mkdir('branch')
 
212
        os.chdir('branch')
 
213
        self.example_branch()
 
214
        self.runbzr('export ../latest')
 
215
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
 
216
        self.runbzr('export ../first -r 1')
 
217
        assert not os.path.exists('../first/goodbye')
 
218
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
 
219
        self.runbzr('export ../first.gz -r 1')
 
220
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
 
221
        self.runbzr('export ../first.bz2 -r 1')
 
222
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
 
223
        self.runbzr('export ../first.tar -r 1')
 
224
        assert os.path.isfile('../first.tar')
 
225
        from tarfile import TarFile
 
226
        tf = TarFile('../first.tar')
 
227
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
228
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
 
229
        self.runbzr('export ../first.tar.gz -r 1')
 
230
        assert os.path.isfile('../first.tar.gz')
 
231
        self.runbzr('export ../first.tbz2 -r 1')
 
232
        assert os.path.isfile('../first.tbz2')
 
233
        self.runbzr('export ../first.tar.bz2 -r 1')
 
234
        assert os.path.isfile('../first.tar.bz2')
 
235
        self.runbzr('export ../first.tar.tbz2 -r 1')
 
236
        assert os.path.isfile('../first.tar.tbz2')
 
237
        from bz2 import BZ2File
 
238
        tf = TarFile('../first.tar.tbz2', 
 
239
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
 
240
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
241
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
 
242
        self.runbzr('export ../first2.tar -r 1 --root pizza')
 
243
        tf = TarFile('../first2.tar')
 
244
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
245
 
 
246
    def test_diff(self):
 
247
        self.example_branch()
 
248
        file('hello', 'wt').write('hello world!')
 
249
        self.runbzr('commit -m fixing hello')
 
250
        output = self.runbzr('diff -r 2..3', backtick=1)
 
251
        self.assert_('\n+hello world!' in output)
 
252
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
253
        self.assert_('\n+baz' in output)
 
254
 
 
255
    def test_branch(self):
 
256
        """Branch from one branch to another."""
 
257
        os.mkdir('a')
 
258
        os.chdir('a')
 
259
        self.example_branch()
 
260
        os.chdir('..')
 
261
        self.runbzr('branch a b')
 
262
        self.runbzr('branch a c -r 1')
 
263
        os.chdir('b')
 
264
        self.runbzr('commit -m foo --unchanged')
 
265
        os.chdir('..')
 
266
        # naughty - abstraction violations RBC 20050928  
 
267
        print "test_branch used to delete the stores, how is this meant to work ?"
 
268
        #shutil.rmtree('a/.bzr/revision-store')
 
269
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
270
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
271
        self.runbzr('branch a d --basis b')
 
272
 
 
273
    def test_merge(self):
 
274
        from bzrlib.branch import Branch
 
275
        
 
276
        os.mkdir('a')
 
277
        os.chdir('a')
 
278
        self.example_branch()
 
279
        os.chdir('..')
 
280
        self.runbzr('branch a b')
 
281
        os.chdir('b')
 
282
        file('goodbye', 'wt').write('quux')
 
283
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
284
 
 
285
        os.chdir('../a')
 
286
        file('hello', 'wt').write('quuux')
 
287
        # We can't merge when there are in-tree changes
 
288
        self.runbzr('merge ../b', retcode=1)
 
289
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
290
        self.runbzr('merge ../b')
 
291
        self.check_file_contents('goodbye', 'quux')
 
292
        # Merging a branch pulls its revision into the tree
 
293
        a = Branch.open('.')
 
294
        b = Branch.open('../b')
 
295
        a.get_revision_xml(b.last_revision())
 
296
        self.log('pending merges: %s', a.pending_merges())
 
297
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
 
298
        #        % (a.pending_merges(), b.last_patch())
 
299
 
 
300
    def test_merge_with_missing_file(self):
 
301
        """Merge handles missing file conflicts"""
 
302
        os.mkdir('a')
 
303
        os.chdir('a')
 
304
        os.mkdir('sub')
 
305
        print >> file('sub/a.txt', 'wb'), "hello"
 
306
        self.runbzr('init')
 
307
        self.runbzr('add')
 
308
        self.runbzr(('commit', '-m', 'added a'))
 
309
        self.runbzr('branch . ../b')
 
310
        print >> file('sub/a.txt', 'ab'), "there"
 
311
        self.runbzr(('commit', '-m', 'Added there'))
 
312
        os.unlink('sub/a.txt')
 
313
        os.rmdir('sub')
 
314
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
315
        os.chdir('../b')
 
316
        print >> file('sub/a.txt', 'ab'), "something"
 
317
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
318
        self.runbzr('merge ../a/')
 
319
        assert os.path.exists('sub/a.txt.THIS')
 
320
        assert os.path.exists('sub/a.txt.BASE')
 
321
 
 
322
    def test_pull(self):
 
323
        """Pull changes from one branch to another."""
 
324
        os.mkdir('a')
 
325
        os.chdir('a')
 
326
 
 
327
        self.example_branch()
 
328
        self.runbzr('pull', retcode=1)
 
329
        self.runbzr('missing', retcode=1)
 
330
        self.runbzr('missing .')
 
331
        self.runbzr('missing')
 
332
        self.runbzr('pull')
 
333
        self.runbzr('pull /', retcode=1)
 
334
        self.runbzr('pull')
 
335
 
 
336
        os.chdir('..')
 
337
        self.runbzr('branch a b')
 
338
        os.chdir('b')
 
339
        self.runbzr('pull')
 
340
        os.mkdir('subdir')
 
341
        self.runbzr('add subdir')
 
342
        self.runbzr('commit -m blah --unchanged')
 
343
        os.chdir('../a')
 
344
        a = Branch.open('.')
 
345
        b = Branch.open('../b')
 
346
        assert a.revision_history() == b.revision_history()[:-1]
 
347
        self.runbzr('pull ../b')
 
348
        assert a.revision_history() == b.revision_history()
 
349
        self.runbzr('commit -m blah2 --unchanged')
 
350
        os.chdir('../b')
 
351
        self.runbzr('commit -m blah3 --unchanged')
 
352
        self.runbzr('pull ../a', retcode=1)
 
353
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
354
        return
 
355
        os.chdir('../a')
 
356
        self.runbzr('merge ../b')
 
357
        self.runbzr('commit -m blah4 --unchanged')
 
358
        os.chdir('../b/subdir')
 
359
        self.runbzr('pull ../../a')
 
360
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
361
        self.runbzr('commit -m blah5 --unchanged')
 
362
        self.runbzr('commit -m blah6 --unchanged')
 
363
        os.chdir('..')
 
364
        self.runbzr('pull ../a')
 
365
        os.chdir('../a')
 
366
        self.runbzr('commit -m blah7 --unchanged')
 
367
        self.runbzr('merge ../b')
 
368
        self.runbzr('commit -m blah8 --unchanged')
 
369
        self.runbzr('pull ../b')
 
370
        self.runbzr('pull ../b')
 
371
        
 
372
    def test_add_reports(self):
 
373
        """add command prints the names of added files."""
 
374
        b = Branch.initialize('.')
 
375
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
376
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
 
377
        # the ordering is not defined at the moment
 
378
        results = sorted(out.rstrip('\n').split('\n'))
 
379
        self.assertEquals(['added dir',
 
380
                           'added dir'+os.sep+'sub.txt',
 
381
                           'added top.txt',],
 
382
                          results)
 
383
 
 
384
    def test_unknown_command(self):
 
385
        """Handling of unknown command."""
 
386
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
387
                                         retcode=1)
 
388
        self.assertEquals(out, '')
 
389
        err.index('unknown command')
 
390
        
196
391
 
197
392
 
198
393
class OldTests(ExternalBase):
199
 
    # old tests moved from ./testbzr
200
 
    def runTest(self):
 
394
    """old tests moved from ./testbzr."""
 
395
 
 
396
    def test_bzr(self):
201
397
        from os import chdir, mkdir
202
398
        from os.path import exists
203
 
        import os
204
399
 
205
400
        runbzr = self.runbzr
206
 
        backtick = self.backtick
 
401
        capture = self.capture
207
402
        progress = self.log
208
403
 
209
404
        progress("basic branch creation")
211
406
        chdir('branch1')
212
407
        runbzr('init')
213
408
 
214
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
409
        self.assertEquals(capture('root').rstrip(),
215
410
                          os.path.join(self.test_dir, 'branch1'))
216
411
 
217
412
        progress("status of new file")
220
415
        f.write('hello world!\n')
221
416
        f.close()
222
417
 
223
 
        out = backtick("bzr unknowns")
224
 
        self.assertEquals(out, 'test.txt\n')
 
418
        self.assertEquals(capture('unknowns'), 'test.txt\n')
225
419
 
226
 
        out = backtick("bzr status")
 
420
        out = capture("status")
227
421
        assert out == 'unknown:\n  test.txt\n'
228
422
 
229
 
        out = backtick("bzr status --all")
 
423
        out = capture("status --all")
230
424
        assert out == "unknown:\n  test.txt\n"
231
425
 
232
 
        out = backtick("bzr status test.txt --all")
 
426
        out = capture("status test.txt --all")
233
427
        assert out == "unknown:\n  test.txt\n"
234
428
 
235
429
        f = file('test2.txt', 'wt')
236
430
        f.write('goodbye cruel world...\n')
237
431
        f.close()
238
432
 
239
 
        out = backtick("bzr status test.txt")
 
433
        out = capture("status test.txt")
240
434
        assert out == "unknown:\n  test.txt\n"
241
435
 
242
 
        out = backtick("bzr status")
 
436
        out = capture("status")
243
437
        assert out == ("unknown:\n"
244
438
                       "  test.txt\n"
245
439
                       "  test2.txt\n")
247
441
        os.unlink('test2.txt')
248
442
 
249
443
        progress("command aliases")
250
 
        out = backtick("bzr st --all")
 
444
        out = capture("st --all")
251
445
        assert out == ("unknown:\n"
252
446
                       "  test.txt\n")
253
447
 
254
 
        out = backtick("bzr stat")
 
448
        out = capture("stat")
255
449
        assert out == ("unknown:\n"
256
450
                       "  test.txt\n")
257
451
 
261
455
        runbzr("help commands")
262
456
        runbzr("help slartibartfast", 1)
263
457
 
264
 
        out = backtick("bzr help ci")
 
458
        out = capture("help ci")
265
459
        out.index('aliases: ')
266
460
 
267
461
        progress("can't rename unversioned file")
270
464
        progress("adding a file")
271
465
 
272
466
        runbzr("add test.txt")
273
 
        assert backtick("bzr unknowns") == ''
274
 
        assert backtick("bzr status --all") == ("added:\n"
 
467
        assert capture("unknowns") == ''
 
468
        assert capture("status --all") == ("added:\n"
275
469
                                                "  test.txt\n")
276
470
 
277
471
        progress("rename newly-added file")
279
473
        assert os.path.exists("hello.txt")
280
474
        assert not os.path.exists("test.txt")
281
475
 
282
 
        assert backtick("bzr revno") == '0\n'
 
476
        assert capture("revno") == '0\n'
283
477
 
284
478
        progress("add first revision")
285
479
        runbzr(['commit', '-m', 'add first revision'])
293
487
        runbzr("add sub1")
294
488
        runbzr("rename sub1 sub2")
295
489
        runbzr("move hello.txt sub2")
296
 
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
490
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
297
491
 
298
492
        assert exists("sub2")
299
493
        assert exists("sub2/hello.txt")
314
508
        runbzr(['commit', '-m', 'rename nested subdirectories'])
315
509
 
316
510
        chdir('sub1/sub2')
317
 
        self.assertEquals(backtick('bzr root')[:-1],
 
511
        self.assertEquals(capture('root')[:-1],
318
512
                          os.path.join(self.test_dir, 'branch1'))
319
513
        runbzr('move ../hello.txt .')
320
514
        assert exists('./hello.txt')
321
 
        assert backtick('bzr relpath hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
322
 
        assert backtick('bzr relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
515
        self.assertEquals(capture('relpath hello.txt'),
 
516
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
517
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
323
518
        runbzr(['commit', '-m', 'move to parent directory'])
324
519
        chdir('..')
325
 
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
520
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
326
521
 
327
522
        runbzr('move sub2/hello.txt .')
328
523
        assert exists('hello.txt')
337
532
 
338
533
        runbzr('commit -F msg.tmp')
339
534
 
340
 
        assert backtick('bzr revno') == '5\n'
 
535
        assert capture('revno') == '5\n'
341
536
        runbzr('export -r 5 export-5.tmp')
342
537
        runbzr('export export.tmp')
343
538
 
345
540
        runbzr('log -v')
346
541
        runbzr('log -v --forward')
347
542
        runbzr('log -m', retcode=1)
348
 
        log_out = backtick('bzr log -m commit')
 
543
        log_out = capture('log -m commit')
349
544
        assert "this is my new commit" in log_out
350
545
        assert "rename nested" not in log_out
351
546
        assert 'revision-id' not in log_out
352
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
547
        assert 'revision-id' in capture('log --show-ids -m commit')
353
548
 
354
549
 
355
550
        progress("file with spaces in name")
365
560
 
366
561
        runbzr('info')
367
562
 
368
 
 
369
 
 
370
 
 
371
 
 
372
 
 
373
 
class RevertCommand(ExternalBase):
374
 
    def runTest(self):
375
 
        self.runbzr('init')
376
 
 
377
 
        file('hello', 'wt').write('foo')
378
 
        self.runbzr('add hello')
379
 
        self.runbzr('commit -m setup hello')
380
 
 
381
 
        file('goodbye', 'wt').write('baz')
382
 
        self.runbzr('add goodbye')
383
 
        self.runbzr('commit -m setup goodbye')
384
 
        
385
 
        file('hello', 'wt').write('bar')
386
 
        file('goodbye', 'wt').write('qux')
387
 
        self.runbzr('revert hello')
388
 
        self.check_file_contents('hello', 'foo')
389
 
        self.check_file_contents('goodbye', 'qux')
390
 
        self.runbzr('revert')
391
 
        self.check_file_contents('goodbye', 'baz')
392