← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: abentley
  • Date: 2005-10-16 23:56:25 UTC
  • mto: (1185.25.1)
  • mto: This revision was merged to the branch mainline in revision 1460.
  • Revision ID: abentley@lappy-20051016235625-f2e4f5d4ff1e889c
Cleanups for pull

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/blackbox.py
19
19
"""Black-box tests for bzr.
20
20
 
21
21
These check that it behaves properly when it's invoked through the regular
22
 
command-line interface.
23
 
 
24
 
This always reinvokes bzr through a new Python interpreter, which is a
25
 
bit inefficient but arguably tests in a way more representative of how
26
 
it's normally invoked.
 
22
command-line interface. This doesn't actually run a new interpreter but 
 
23
rather starts again from the run_bzr function.
27
24
"""
28
25
 
 
26
 
 
27
from cStringIO import StringIO
 
28
import os
 
29
import shutil
29
30
import sys
 
31
import os
30
32
 
 
33
from bzrlib.branch import Branch
 
34
from bzrlib.clone import copy_branch
 
35
from bzrlib.errors import BzrCommandError
 
36
from bzrlib.osutils import has_symlinks
31
37
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
32
 
from bzrlib.branch import Branch
33
 
from bzrlib.commands import run_bzr
 
38
from bzrlib.selftest.HTTPTestUtil import TestCaseWithWebserver
34
39
 
35
40
 
36
41
class ExternalBase(TestCaseInTempDir):
37
 
    def runbzr(self, args, retcode=0,backtick=False):
 
42
 
 
43
    def runbzr(self, args, retcode=0, backtick=False):
38
44
        if isinstance(args, basestring):
39
45
            args = args.split()
40
46
 
41
47
        if backtick:
42
 
            return self.backtick(['python', self.BZRPATH,] + args,
43
 
                           retcode=retcode)
 
48
            return self.run_bzr_captured(args, retcode=retcode)[0]
44
49
        else:
45
 
            return self.runcmd(['python', self.BZRPATH,] + args,
46
 
                           retcode=retcode)
 
50
            return self.run_bzr_captured(args, retcode=retcode)
47
51
 
48
52
 
49
53
class TestCommands(ExternalBase):
72
76
        f = file('.bzr/email', 'wt')
73
77
        f.write('Branch Identity <branch@identi.ty>')
74
78
        f.close()
 
79
        bzr_email = os.environ.get('BZREMAIL')
 
80
        if bzr_email is not None:
 
81
            del os.environ['BZREMAIL']
75
82
        whoami = self.runbzr("whoami",backtick=True)
76
83
        whoami_email = self.runbzr("whoami --email",backtick=True)
77
84
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
78
85
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
 
86
        # Verify that the environment variable overrides the value 
 
87
        # in the file
 
88
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
 
89
        whoami = self.runbzr("whoami",backtick=True)
 
90
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
91
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
 
92
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
 
93
        if bzr_email is not None:
 
94
            os.environ['BZREMAIL'] = bzr_email
79
95
 
80
96
    def test_invalid_commands(self):
81
97
        self.runbzr("pants", retcode=1)
89
105
        self.runbzr("add hello.txt")
90
106
        self.runbzr("commit -m added")
91
107
 
 
108
    def test_empty_commit_message(self):
 
109
        self.runbzr("init")
 
110
        file('foo.c', 'wt').write('int main() {}')
 
111
        self.runbzr(['add', 'foo.c'])
 
112
        self.runbzr(["commit", "-m", ""] , retcode=1) 
 
113
 
92
114
    def test_ignore_patterns(self):
93
115
        from bzrlib.branch import Branch
94
116
        
95
 
        b = Branch('.', init=True)
 
117
        b = Branch.initialize('.')
96
118
        self.assertEquals(list(b.unknowns()), [])
97
119
 
98
120
        file('foo.tmp', 'wt').write('tmp files are ignored')
99
121
        self.assertEquals(list(b.unknowns()), [])
100
 
        assert self.backtick('bzr unknowns') == ''
 
122
        assert self.capture('unknowns') == ''
101
123
 
102
124
        file('foo.c', 'wt').write('int main() {}')
103
125
        self.assertEquals(list(b.unknowns()), ['foo.c'])
104
 
        assert self.backtick('bzr unknowns') == 'foo.c\n'
 
126
        assert self.capture('unknowns') == 'foo.c\n'
105
127
 
106
128
        self.runbzr(['add', 'foo.c'])
107
 
        assert self.backtick('bzr unknowns') == ''
 
129
        assert self.capture('unknowns') == ''
108
130
 
109
131
        # 'ignore' works when creating the .bzignore file
110
132
        file('foo.blah', 'wt').write('blah')
111
133
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
112
134
        self.runbzr('ignore *.blah')
113
135
        self.assertEquals(list(b.unknowns()), [])
114
 
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
 
136
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
115
137
 
116
138
        # 'ignore' works when then .bzrignore file already exists
117
139
        file('garh', 'wt').write('garh')
118
140
        self.assertEquals(list(b.unknowns()), ['garh'])
119
 
        assert self.backtick('bzr unknowns') == 'garh\n'
 
141
        assert self.capture('unknowns') == 'garh\n'
120
142
        self.runbzr('ignore garh')
121
143
        self.assertEquals(list(b.unknowns()), [])
122
 
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
 
144
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
123
145
 
124
146
    def test_revert(self):
125
 
        import os
126
147
        self.runbzr('init')
127
148
 
128
149
        file('hello', 'wt').write('foo')
132
153
        file('goodbye', 'wt').write('baz')
133
154
        self.runbzr('add goodbye')
134
155
        self.runbzr('commit -m setup goodbye')
135
 
        
 
156
 
136
157
        file('hello', 'wt').write('bar')
137
158
        file('goodbye', 'wt').write('qux')
138
159
        self.runbzr('revert hello')
147
168
        os.rmdir('revertdir')
148
169
        self.runbzr('revert')
149
170
 
150
 
    def skipped_test_mv_modes(self):
 
171
        os.symlink('/unlikely/to/exist', 'symlink')
 
172
        self.runbzr('add symlink')
 
173
        self.runbzr('commit -m f')
 
174
        os.unlink('symlink')
 
175
        self.runbzr('revert')
 
176
        self.failUnlessExists('symlink')
 
177
        os.unlink('symlink')
 
178
        os.symlink('a-different-path', 'symlink')
 
179
        self.runbzr('revert')
 
180
        self.assertEqual('/unlikely/to/exist',
 
181
                         os.readlink('symlink'))
 
182
        
 
183
        file('hello', 'wt').write('xyz')
 
184
        self.runbzr('commit -m xyz hello')
 
185
        self.runbzr('revert -r 1 hello')
 
186
        self.check_file_contents('hello', 'foo')
 
187
        self.runbzr('revert hello')
 
188
        self.check_file_contents('hello', 'xyz')
 
189
        os.chdir('revertdir')
 
190
        self.runbzr('revert')
 
191
        os.chdir('..')
 
192
 
 
193
 
 
194
    def test_mv_modes(self):
151
195
        """Test two modes of operation for mv"""
152
196
        from bzrlib.branch import Branch
153
 
        b = Branch('.', init=True)
 
197
        b = Branch.initialize('.')
154
198
        self.build_tree(['a', 'c', 'subdir/'])
155
 
        self.run_bzr('mv', 'a', 'b')
156
 
        self.run_bzr('mv', 'b', 'subdir')
157
 
        self.run_bzr('mv', 'subdir/b', 'a')
158
 
        self.run_bzr('mv', 'a', 'b', 'subdir')
159
 
        self.run_bzr('mv', 'subdir/a', 'subdir/newa')
 
199
        self.run_bzr_captured(['add', self.test_dir])
 
200
        self.run_bzr_captured(['mv', 'a', 'b'])
 
201
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
202
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
203
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
204
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
160
205
 
161
206
    def test_main_version(self):
162
207
        """Check output from version command and master option is reasonable"""
182
227
        test.runbzr('add goodbye')
183
228
        test.runbzr('commit -m setup goodbye')
184
229
 
185
 
    def test_revert(self):
186
 
        self.example_branch()
187
 
        file('hello', 'wt').write('bar')
188
 
        file('goodbye', 'wt').write('qux')
189
 
        self.runbzr('revert hello')
190
 
        self.check_file_contents('hello', 'foo')
191
 
        self.check_file_contents('goodbye', 'qux')
192
 
        self.runbzr('revert')
193
 
        self.check_file_contents('goodbye', 'baz')
 
230
    def test_export(self):
 
231
        os.mkdir('branch')
 
232
        os.chdir('branch')
 
233
        self.example_branch()
 
234
        self.runbzr('export ../latest')
 
235
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
 
236
        self.runbzr('export ../first -r 1')
 
237
        assert not os.path.exists('../first/goodbye')
 
238
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
 
239
        self.runbzr('export ../first.gz -r 1')
 
240
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
 
241
        self.runbzr('export ../first.bz2 -r 1')
 
242
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
 
243
        self.runbzr('export ../first.tar -r 1')
 
244
        assert os.path.isfile('../first.tar')
 
245
        from tarfile import TarFile
 
246
        tf = TarFile('../first.tar')
 
247
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
248
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
 
249
        self.runbzr('export ../first.tar.gz -r 1')
 
250
        assert os.path.isfile('../first.tar.gz')
 
251
        self.runbzr('export ../first.tbz2 -r 1')
 
252
        assert os.path.isfile('../first.tbz2')
 
253
        self.runbzr('export ../first.tar.bz2 -r 1')
 
254
        assert os.path.isfile('../first.tar.bz2')
 
255
        self.runbzr('export ../first.tar.tbz2 -r 1')
 
256
        assert os.path.isfile('../first.tar.tbz2')
 
257
        from bz2 import BZ2File
 
258
        tf = TarFile('../first.tar.tbz2', 
 
259
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
 
260
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
261
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
 
262
        self.runbzr('export ../first2.tar -r 1 --root pizza')
 
263
        tf = TarFile('../first2.tar')
 
264
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
265
 
 
266
    def test_diff(self):
 
267
        self.example_branch()
 
268
        file('hello', 'wt').write('hello world!')
 
269
        self.runbzr('commit -m fixing hello')
 
270
        output = self.runbzr('diff -r 2..3', backtick=1)
 
271
        self.assert_('\n+hello world!' in output)
 
272
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
273
        self.assert_('\n+baz' in output)
 
274
 
 
275
    def test_diff_branches(self):
 
276
        self.build_tree(['branch1/', 'branch1/file', 'branch2/'])
 
277
        branch = Branch.initialize('branch1')
 
278
        branch.add(['file'])
 
279
        branch.commit('add file')
 
280
        copy_branch(branch, 'branch2')
 
281
        print >> open('branch2/file', 'w'), 'new content'
 
282
        branch2 = Branch.open('branch2')
 
283
        branch2.commit('update file')
 
284
        # should open branch1 and diff against branch2, 
 
285
        output = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 'branch1'])
 
286
        self.assertEquals(("=== modified file 'file'\n"
 
287
                           "--- file\n"
 
288
                           "+++ file\n"
 
289
                           "@@ -1,1 +1,1 @@\n"
 
290
                           "-new content\n"
 
291
                           "+contents of branch1/file\n"
 
292
                           "\n", ''), output)
 
293
 
 
294
    def test_branch(self):
 
295
        """Branch from one branch to another."""
 
296
        os.mkdir('a')
 
297
        os.chdir('a')
 
298
        self.example_branch()
 
299
        os.chdir('..')
 
300
        self.runbzr('branch a b')
 
301
        self.runbzr('branch a c -r 1')
 
302
        os.chdir('b')
 
303
        self.runbzr('commit -m foo --unchanged')
 
304
        os.chdir('..')
 
305
        # naughty - abstraction violations RBC 20050928  
 
306
        print "test_branch used to delete the stores, how is this meant to work ?"
 
307
        #shutil.rmtree('a/.bzr/revision-store')
 
308
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
309
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
310
        self.runbzr('branch a d --basis b')
194
311
 
195
312
    def test_merge(self):
196
313
        from bzrlib.branch import Branch
197
 
        import os
198
314
        
199
315
        os.mkdir('a')
200
316
        os.chdir('a')
201
 
 
202
317
        self.example_branch()
203
318
        os.chdir('..')
204
319
        self.runbzr('branch a b')
214
329
        self.runbzr('merge ../b')
215
330
        self.check_file_contents('goodbye', 'quux')
216
331
        # 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
 
 
 
332
        a = Branch.open('.')
 
333
        b = Branch.open('../b')
 
334
        a.get_revision_xml(b.last_revision())
221
335
        self.log('pending merges: %s', a.pending_merges())
222
 
        #        assert a.pending_merges() == [b.last_patch()], "Assertion %s %s" \
 
336
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
223
337
        #        % (a.pending_merges(), b.last_patch())
224
338
 
225
 
 
 
339
    def test_merge_with_missing_file(self):
 
340
        """Merge handles missing file conflicts"""
 
341
        os.mkdir('a')
 
342
        os.chdir('a')
 
343
        os.mkdir('sub')
 
344
        print >> file('sub/a.txt', 'wb'), "hello"
 
345
        print >> file('b.txt', 'wb'), "hello"
 
346
        print >> file('sub/c.txt', 'wb'), "hello"
 
347
        self.runbzr('init')
 
348
        self.runbzr('add')
 
349
        self.runbzr(('commit', '-m', 'added a'))
 
350
        self.runbzr('branch . ../b')
 
351
        print >> file('sub/a.txt', 'ab'), "there"
 
352
        print >> file('b.txt', 'ab'), "there"
 
353
        print >> file('sub/c.txt', 'ab'), "there"
 
354
        self.runbzr(('commit', '-m', 'Added there'))
 
355
        os.unlink('sub/a.txt')
 
356
        os.unlink('sub/c.txt')
 
357
        os.rmdir('sub')
 
358
        os.unlink('b.txt')
 
359
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
360
        os.chdir('../b')
 
361
        print >> file('sub/a.txt', 'ab'), "something"
 
362
        print >> file('b.txt', 'ab'), "something"
 
363
        print >> file('sub/c.txt', 'ab'), "something"
 
364
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
365
        self.runbzr('merge ../a/')
 
366
        assert os.path.exists('sub/a.txt.THIS')
 
367
        assert os.path.exists('sub/a.txt.BASE')
 
368
        os.chdir('../a')
 
369
        self.runbzr('merge ../b/')
 
370
        assert os.path.exists('sub/a.txt.OTHER')
 
371
        assert os.path.exists('sub/a.txt.BASE')
 
372
 
 
373
    def test_pull(self):
 
374
        """Pull changes from one branch to another."""
 
375
        os.mkdir('a')
 
376
        os.chdir('a')
 
377
 
 
378
        self.example_branch()
 
379
        self.runbzr('pull', retcode=1)
 
380
        self.runbzr('missing', retcode=1)
 
381
        self.runbzr('missing .')
 
382
        self.runbzr('missing')
 
383
        self.runbzr('pull')
 
384
        self.runbzr('pull /', retcode=1)
 
385
        self.runbzr('pull')
 
386
 
 
387
        os.chdir('..')
 
388
        self.runbzr('branch a b')
 
389
        os.chdir('b')
 
390
        self.runbzr('pull')
 
391
        os.mkdir('subdir')
 
392
        self.runbzr('add subdir')
 
393
        self.runbzr('commit -m blah --unchanged')
 
394
        os.chdir('../a')
 
395
        a = Branch.open('.')
 
396
        b = Branch.open('../b')
 
397
        assert a.revision_history() == b.revision_history()[:-1]
 
398
        self.runbzr('pull ../b')
 
399
        assert a.revision_history() == b.revision_history()
 
400
        self.runbzr('commit -m blah2 --unchanged')
 
401
        os.chdir('../b')
 
402
        self.runbzr('commit -m blah3 --unchanged')
 
403
        self.runbzr('pull ../a', retcode=1)
 
404
        os.chdir('../a')
 
405
        self.runbzr('merge ../b')
 
406
        self.runbzr('commit -m blah4 --unchanged')
 
407
        os.chdir('../b/subdir')
 
408
        self.runbzr('pull ../../a')
 
409
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
410
        self.runbzr('commit -m blah5 --unchanged')
 
411
        self.runbzr('commit -m blah6 --unchanged')
 
412
        os.chdir('..')
 
413
        self.runbzr('pull ../a')
 
414
        os.chdir('../a')
 
415
        self.runbzr('commit -m blah7 --unchanged')
 
416
        self.runbzr('merge ../b')
 
417
        self.runbzr('commit -m blah8 --unchanged')
 
418
        self.runbzr('pull ../b')
 
419
        self.runbzr('pull ../b')
 
420
 
 
421
    def test_locations(self):
 
422
        """Using and remembering different locations"""
 
423
        os.mkdir('a')
 
424
        os.chdir('a')
 
425
        self.runbzr('init')
 
426
        self.runbzr('commit -m unchanged --unchanged')
 
427
        self.runbzr('pull', retcode=1)
 
428
        self.runbzr('merge', retcode=1)
 
429
        self.runbzr('branch . ../b')
 
430
        os.chdir('../b')
 
431
        self.runbzr('pull')
 
432
        self.runbzr('branch . ../c')
 
433
        self.runbzr('pull ../c')
 
434
        self.runbzr('merge')
 
435
        os.chdir('../a')
 
436
        self.runbzr('pull ../b')
 
437
        self.runbzr('pull')
 
438
        self.runbzr('pull ../c')
 
439
        self.runbzr('branch ../c ../d')
 
440
        shutil.rmtree('../c')
 
441
        self.runbzr('pull')
 
442
        os.chdir('../b')
 
443
        self.runbzr('pull')
 
444
        os.chdir('../d')
 
445
        self.runbzr('pull', retcode=1)
 
446
        self.runbzr('pull ../a --remember')
 
447
        self.runbzr('pull')
 
448
        
226
449
    def test_add_reports(self):
227
450
        """add command prints the names of added files."""
228
 
        b = Branch('.', init=True)
 
451
        b = Branch.initialize('.')
229
452
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
230
 
 
231
 
        from cStringIO import StringIO
232
 
        out = StringIO()
233
 
 
234
 
        ret = self.apply_redirected(None, out, None,
235
 
                                    run_bzr,
236
 
                                    ['add'])
237
 
        self.assertEquals(ret, 0)
238
 
 
 
453
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
239
454
        # the ordering is not defined at the moment
240
 
        results = sorted(out.getvalue().rstrip('\n').split('\n'))
 
455
        results = sorted(out.rstrip('\n').split('\n'))
241
456
        self.assertEquals(['added dir',
242
 
                           'added dir/sub.txt',
 
457
                           'added dir'+os.sep+'sub.txt',
243
458
                           'added top.txt',],
244
459
                          results)
245
460
 
 
461
    def test_add_quiet_is(self):
 
462
        """add -q does not print the names of added files."""
 
463
        b = Branch.initialize('.')
 
464
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
465
        out = self.run_bzr_captured(['add', '-q'], retcode = 0)[0]
 
466
        # the ordering is not defined at the moment
 
467
        results = sorted(out.rstrip('\n').split('\n'))
 
468
        self.assertEquals([''], results)
 
469
 
 
470
    def test_unknown_command(self):
 
471
        """Handling of unknown command."""
 
472
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
473
                                         retcode=1)
 
474
        self.assertEquals(out, '')
 
475
        err.index('unknown command')
 
476
 
 
477
    def test_conflicts(self):
 
478
        """Handling of merge conflicts"""
 
479
        os.mkdir('base')
 
480
        os.chdir('base')
 
481
        file('hello', 'wb').write("hi world")
 
482
        file('answer', 'wb').write("42")
 
483
        self.runbzr('init')
 
484
        self.runbzr('add')
 
485
        self.runbzr('commit -m base')
 
486
        self.runbzr('branch . ../other')
 
487
        self.runbzr('branch . ../this')
 
488
        os.chdir('../other')
 
489
        file('hello', 'wb').write("Hello.")
 
490
        file('answer', 'wb').write("Is anyone there?")
 
491
        self.runbzr('commit -m other')
 
492
        os.chdir('../this')
 
493
        file('hello', 'wb').write("Hello, world")
 
494
        self.runbzr('mv answer question')
 
495
        file('question', 'wb').write("What do you get when you multiply six"
 
496
                                   "times nine?")
 
497
        self.runbzr('commit -m this')
 
498
        self.runbzr('merge ../other')
 
499
        result = self.runbzr('conflicts', backtick=1)
 
500
        self.assertEquals(result, "hello\nquestion\n")
 
501
        result = self.runbzr('status', backtick=1)
 
502
        assert "conflicts:\n  hello\n  question\n" in result, result
 
503
        self.runbzr('resolve hello')
 
504
        result = self.runbzr('conflicts', backtick=1)
 
505
        self.assertEquals(result, "question\n")
 
506
        self.runbzr('commit -m conflicts', retcode=1)
 
507
        self.runbzr('resolve --all')
 
508
        result = self.runbzr('conflicts', backtick=1)
 
509
        self.runbzr('commit -m conflicts')
 
510
        self.assertEquals(result, "")
 
511
 
 
512
def listdir_sorted(dir):
 
513
    L = os.listdir(dir)
 
514
    L.sort()
 
515
    return L
 
516
 
246
517
 
247
518
class OldTests(ExternalBase):
248
519
    """old tests moved from ./testbzr."""
250
521
    def test_bzr(self):
251
522
        from os import chdir, mkdir
252
523
        from os.path import exists
253
 
        import os
254
524
 
255
525
        runbzr = self.runbzr
256
 
        backtick = self.backtick
 
526
        capture = self.capture
257
527
        progress = self.log
258
528
 
259
529
        progress("basic branch creation")
261
531
        chdir('branch1')
262
532
        runbzr('init')
263
533
 
264
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
534
        self.assertEquals(capture('root').rstrip(),
265
535
                          os.path.join(self.test_dir, 'branch1'))
266
536
 
267
537
        progress("status of new file")
270
540
        f.write('hello world!\n')
271
541
        f.close()
272
542
 
273
 
        out = backtick("bzr unknowns")
274
 
        self.assertEquals(out, 'test.txt\n')
 
543
        self.assertEquals(capture('unknowns'), 'test.txt\n')
275
544
 
276
 
        out = backtick("bzr status")
 
545
        out = capture("status")
277
546
        assert out == 'unknown:\n  test.txt\n'
278
547
 
279
 
        out = backtick("bzr status --all")
 
548
        out = capture("status --all")
280
549
        assert out == "unknown:\n  test.txt\n"
281
550
 
282
 
        out = backtick("bzr status test.txt --all")
 
551
        out = capture("status test.txt --all")
283
552
        assert out == "unknown:\n  test.txt\n"
284
553
 
285
554
        f = file('test2.txt', 'wt')
286
555
        f.write('goodbye cruel world...\n')
287
556
        f.close()
288
557
 
289
 
        out = backtick("bzr status test.txt")
 
558
        out = capture("status test.txt")
290
559
        assert out == "unknown:\n  test.txt\n"
291
560
 
292
 
        out = backtick("bzr status")
 
561
        out = capture("status")
293
562
        assert out == ("unknown:\n"
294
563
                       "  test.txt\n"
295
564
                       "  test2.txt\n")
297
566
        os.unlink('test2.txt')
298
567
 
299
568
        progress("command aliases")
300
 
        out = backtick("bzr st --all")
 
569
        out = capture("st --all")
301
570
        assert out == ("unknown:\n"
302
571
                       "  test.txt\n")
303
572
 
304
 
        out = backtick("bzr stat")
 
573
        out = capture("stat")
305
574
        assert out == ("unknown:\n"
306
575
                       "  test.txt\n")
307
576
 
311
580
        runbzr("help commands")
312
581
        runbzr("help slartibartfast", 1)
313
582
 
314
 
        out = backtick("bzr help ci")
 
583
        out = capture("help ci")
315
584
        out.index('aliases: ')
316
585
 
317
586
        progress("can't rename unversioned file")
320
589
        progress("adding a file")
321
590
 
322
591
        runbzr("add test.txt")
323
 
        assert backtick("bzr unknowns") == ''
324
 
        assert backtick("bzr status --all") == ("added:\n"
 
592
        assert capture("unknowns") == ''
 
593
        assert capture("status --all") == ("added:\n"
325
594
                                                "  test.txt\n")
326
595
 
327
596
        progress("rename newly-added file")
329
598
        assert os.path.exists("hello.txt")
330
599
        assert not os.path.exists("test.txt")
331
600
 
332
 
        assert backtick("bzr revno") == '0\n'
 
601
        assert capture("revno") == '0\n'
333
602
 
334
603
        progress("add first revision")
335
604
        runbzr(['commit', '-m', 'add first revision'])
343
612
        runbzr("add sub1")
344
613
        runbzr("rename sub1 sub2")
345
614
        runbzr("move hello.txt sub2")
346
 
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
615
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
347
616
 
348
617
        assert exists("sub2")
349
618
        assert exists("sub2/hello.txt")
364
633
        runbzr(['commit', '-m', 'rename nested subdirectories'])
365
634
 
366
635
        chdir('sub1/sub2')
367
 
        self.assertEquals(backtick('bzr root')[:-1],
 
636
        self.assertEquals(capture('root')[:-1],
368
637
                          os.path.join(self.test_dir, 'branch1'))
369
638
        runbzr('move ../hello.txt .')
370
639
        assert exists('./hello.txt')
371
 
        assert backtick('bzr relpath hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
372
 
        assert backtick('bzr relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
640
        self.assertEquals(capture('relpath hello.txt'),
 
641
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
642
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
373
643
        runbzr(['commit', '-m', 'move to parent directory'])
374
644
        chdir('..')
375
 
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
645
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
376
646
 
377
647
        runbzr('move sub2/hello.txt .')
378
648
        assert exists('hello.txt')
382
652
        f.close()
383
653
 
384
654
        f = file('msg.tmp', 'wt')
385
 
        f.write('this is my new commit\n')
 
655
        f.write('this is my new commit\nand it has multiple lines, for fun')
386
656
        f.close()
387
657
 
388
658
        runbzr('commit -F msg.tmp')
389
659
 
390
 
        assert backtick('bzr revno') == '5\n'
 
660
        assert capture('revno') == '5\n'
391
661
        runbzr('export -r 5 export-5.tmp')
392
662
        runbzr('export export.tmp')
393
663
 
395
665
        runbzr('log -v')
396
666
        runbzr('log -v --forward')
397
667
        runbzr('log -m', retcode=1)
398
 
        log_out = backtick('bzr log -m commit')
399
 
        assert "this is my new commit" in log_out
 
668
        log_out = capture('log -m commit')
 
669
        assert "this is my new commit\n  and" in log_out
400
670
        assert "rename nested" not in log_out
401
671
        assert 'revision-id' not in log_out
402
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
672
        assert 'revision-id' in capture('log --show-ids -m commit')
 
673
 
 
674
        log_out = capture('log --line')
 
675
        for line in log_out.splitlines():
 
676
            assert len(line) <= 79, len(line)
 
677
        assert "this is my new commit and" in log_out
403
678
 
404
679
 
405
680
        progress("file with spaces in name")
415
690
 
416
691
        runbzr('info')
417
692
 
 
693
        if has_symlinks():
 
694
            progress("symlinks")
 
695
            mkdir('symlinks')
 
696
            chdir('symlinks')
 
697
            runbzr('init')
 
698
            os.symlink("NOWHERE1", "link1")
 
699
            runbzr('add link1')
 
700
            assert self.capture('unknowns') == ''
 
701
            runbzr(['commit', '-m', '1: added symlink link1'])
 
702
    
 
703
            mkdir('d1')
 
704
            runbzr('add d1')
 
705
            assert self.capture('unknowns') == ''
 
706
            os.symlink("NOWHERE2", "d1/link2")
 
707
            assert self.capture('unknowns') == 'd1/link2\n'
 
708
            # is d1/link2 found when adding d1
 
709
            runbzr('add d1')
 
710
            assert self.capture('unknowns') == ''
 
711
            os.symlink("NOWHERE3", "d1/link3")
 
712
            assert self.capture('unknowns') == 'd1/link3\n'
 
713
            runbzr(['commit', '-m', '2: added dir, symlink'])
 
714
    
 
715
            runbzr('rename d1 d2')
 
716
            runbzr('move d2/link2 .')
 
717
            runbzr('move link1 d2')
 
718
            assert os.readlink("./link2") == "NOWHERE2"
 
719
            assert os.readlink("d2/link1") == "NOWHERE1"
 
720
            runbzr('add d2/link3')
 
721
            runbzr('diff')
 
722
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
 
723
    
 
724
            os.unlink("link2")
 
725
            os.symlink("TARGET 2", "link2")
 
726
            os.unlink("d2/link1")
 
727
            os.symlink("TARGET 1", "d2/link1")
 
728
            runbzr('diff')
 
729
            assert self.capture("relpath d2/link1") == "d2/link1\n"
 
730
            runbzr(['commit', '-m', '4: retarget of two links'])
 
731
    
 
732
            runbzr('remove d2/link1')
 
733
            assert self.capture('unknowns') == 'd2/link1\n'
 
734
            runbzr(['commit', '-m', '5: remove d2/link1'])
 
735
            # try with the rm alias
 
736
            runbzr('add d2/link1')
 
737
            runbzr(['commit', '-m', '6: add d2/link1'])
 
738
            runbzr('rm d2/link1')
 
739
            assert self.capture('unknowns') == 'd2/link1\n'
 
740
            runbzr(['commit', '-m', '7: remove d2/link1'])
 
741
    
 
742
            os.mkdir("d1")
 
743
            runbzr('add d1')
 
744
            runbzr('rename d2/link3 d1/link3new')
 
745
            assert self.capture('unknowns') == 'd2/link1\n'
 
746
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
 
747
            
 
748
            runbzr(['check'])
 
749
            
 
750
            runbzr(['export', '-r', '1', 'exp1.tmp'])
 
751
            chdir("exp1.tmp")
 
752
            assert listdir_sorted(".") == [ "link1" ]
 
753
            assert os.readlink("link1") == "NOWHERE1"
 
754
            chdir("..")
 
755
            
 
756
            runbzr(['export', '-r', '2', 'exp2.tmp'])
 
757
            chdir("exp2.tmp")
 
758
            assert listdir_sorted(".") == [ "d1", "link1" ]
 
759
            chdir("..")
 
760
            
 
761
            runbzr(['export', '-r', '3', 'exp3.tmp'])
 
762
            chdir("exp3.tmp")
 
763
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
764
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
765
            assert os.readlink("d2/link1") == "NOWHERE1"
 
766
            assert os.readlink("link2")    == "NOWHERE2"
 
767
            chdir("..")
 
768
            
 
769
            runbzr(['export', '-r', '4', 'exp4.tmp'])
 
770
            chdir("exp4.tmp")
 
771
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
772
            assert os.readlink("d2/link1") == "TARGET 1"
 
773
            assert os.readlink("link2")    == "TARGET 2"
 
774
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
775
            chdir("..")
 
776
            
 
777
            runbzr(['export', '-r', '5', 'exp5.tmp'])
 
778
            chdir("exp5.tmp")
 
779
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
780
            assert os.path.islink("link2")
 
781
            assert listdir_sorted("d2")== [ "link3" ]
 
782
            chdir("..")
 
783
            
 
784
            runbzr(['export', '-r', '8', 'exp6.tmp'])
 
785
            chdir("exp6.tmp")
 
786
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
 
787
            assert listdir_sorted("d1") == [ "link3new" ]
 
788
            assert listdir_sorted("d2") == []
 
789
            assert os.readlink("d1/link3new") == "NOWHERE3"
 
790
            chdir("..")
 
791
        else:
 
792
            progress("skipping symlink tests")
 
793
 
 
794
 
 
795
class HttpTests(TestCaseWithWebserver):
 
796
    """Test bzr ui commands against remote branches."""
 
797
 
 
798
    def test_branch(self):
 
799
        os.mkdir('from')
 
800
        branch = Branch.initialize('from')
 
801
        branch.commit('empty commit for nonsense', allow_pointless=True)
 
802
        url = self.get_remote_url('from')
 
803
        self.run_bzr('branch', url, 'to')
 
804
        branch = Branch.open('to')
 
805
        self.assertEqual(1, len(branch.revision_history()))