← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Robert Collins
  • Date: 2005-10-11 08:31:29 UTC
  • Revision ID: robertc@lifelesslap.robertcollins.net-20051011083129-fa720bc6cd6c039f
inline and simplify branch.find_branch_root, it should just try to create a branch at each step, which is simpler than probing for a specific dir and has less round trips.

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
        
 
177
        file('hello', 'wt').write('xyz')
 
178
        self.runbzr('commit -m xyz hello')
 
179
        self.runbzr('revert -r 1 hello')
 
180
        self.check_file_contents('hello', 'foo')
 
181
        self.runbzr('revert hello')
 
182
        self.check_file_contents('hello', 'xyz')
 
183
        os.chdir('revertdir')
 
184
        self.runbzr('revert')
 
185
        os.chdir('..')
 
186
 
 
187
 
 
188
    def test_mv_modes(self):
151
189
        """Test two modes of operation for mv"""
152
190
        from bzrlib.branch import Branch
153
 
        b = Branch('.', init=True)
 
191
        b = Branch.initialize('.')
154
192
        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')
 
193
        self.run_bzr_captured(['add', self.test_dir])
 
194
        self.run_bzr_captured(['mv', 'a', 'b'])
 
195
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
196
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
197
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
198
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
160
199
 
161
200
    def test_main_version(self):
162
201
        """Check output from version command and master option is reasonable"""
182
221
        test.runbzr('add goodbye')
183
222
        test.runbzr('commit -m setup goodbye')
184
223
 
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')
 
224
    def test_export(self):
 
225
        os.mkdir('branch')
 
226
        os.chdir('branch')
 
227
        self.example_branch()
 
228
        self.runbzr('export ../latest')
 
229
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
 
230
        self.runbzr('export ../first -r 1')
 
231
        assert not os.path.exists('../first/goodbye')
 
232
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
 
233
        self.runbzr('export ../first.gz -r 1')
 
234
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
 
235
        self.runbzr('export ../first.bz2 -r 1')
 
236
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
 
237
        self.runbzr('export ../first.tar -r 1')
 
238
        assert os.path.isfile('../first.tar')
 
239
        from tarfile import TarFile
 
240
        tf = TarFile('../first.tar')
 
241
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
242
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
 
243
        self.runbzr('export ../first.tar.gz -r 1')
 
244
        assert os.path.isfile('../first.tar.gz')
 
245
        self.runbzr('export ../first.tbz2 -r 1')
 
246
        assert os.path.isfile('../first.tbz2')
 
247
        self.runbzr('export ../first.tar.bz2 -r 1')
 
248
        assert os.path.isfile('../first.tar.bz2')
 
249
        self.runbzr('export ../first.tar.tbz2 -r 1')
 
250
        assert os.path.isfile('../first.tar.tbz2')
 
251
        from bz2 import BZ2File
 
252
        tf = TarFile('../first.tar.tbz2', 
 
253
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
 
254
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
255
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
 
256
        self.runbzr('export ../first2.tar -r 1 --root pizza')
 
257
        tf = TarFile('../first2.tar')
 
258
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
259
 
 
260
    def test_diff(self):
 
261
        self.example_branch()
 
262
        file('hello', 'wt').write('hello world!')
 
263
        self.runbzr('commit -m fixing hello')
 
264
        output = self.runbzr('diff -r 2..3', backtick=1)
 
265
        self.assert_('\n+hello world!' in output)
 
266
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
267
        self.assert_('\n+baz' in output)
 
268
 
 
269
    def test_diff_branches(self):
 
270
        self.build_tree(['branch1/', 'branch1/file', 'branch2/'])
 
271
        branch = Branch.initialize('branch1')
 
272
        branch.add(['file'])
 
273
        branch.commit('add file')
 
274
        copy_branch(branch, 'branch2')
 
275
        print >> open('branch2/file', 'w'), 'new content'
 
276
        branch2 = Branch.open('branch2')
 
277
        branch2.commit('update file')
 
278
        # should open branch1 and diff against branch2, 
 
279
        output = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 'branch1'])
 
280
        self.assertEquals(("=== modified file 'file'\n"
 
281
                           "--- file\n"
 
282
                           "+++ file\n"
 
283
                           "@@ -1,1 +1,1 @@\n"
 
284
                           "-new content\n"
 
285
                           "+contents of branch1/file\n"
 
286
                           "\n", ''), output)
 
287
 
 
288
    def test_branch(self):
 
289
        """Branch from one branch to another."""
 
290
        os.mkdir('a')
 
291
        os.chdir('a')
 
292
        self.example_branch()
 
293
        os.chdir('..')
 
294
        self.runbzr('branch a b')
 
295
        self.runbzr('branch a c -r 1')
 
296
        os.chdir('b')
 
297
        self.runbzr('commit -m foo --unchanged')
 
298
        os.chdir('..')
 
299
        # naughty - abstraction violations RBC 20050928  
 
300
        print "test_branch used to delete the stores, how is this meant to work ?"
 
301
        #shutil.rmtree('a/.bzr/revision-store')
 
302
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
303
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
304
        self.runbzr('branch a d --basis b')
194
305
 
195
306
    def test_merge(self):
196
307
        from bzrlib.branch import Branch
197
 
        import os
198
308
        
199
309
        os.mkdir('a')
200
310
        os.chdir('a')
201
 
 
202
311
        self.example_branch()
203
312
        os.chdir('..')
204
313
        self.runbzr('branch a b')
214
323
        self.runbzr('merge ../b')
215
324
        self.check_file_contents('goodbye', 'quux')
216
325
        # 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
 
 
 
326
        a = Branch.open('.')
 
327
        b = Branch.open('../b')
 
328
        a.get_revision_xml(b.last_revision())
221
329
        self.log('pending merges: %s', a.pending_merges())
222
 
        #        assert a.pending_merges() == [b.last_patch()], "Assertion %s %s" \
 
330
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
223
331
        #        % (a.pending_merges(), b.last_patch())
224
332
 
225
 
 
 
333
    def test_merge_with_missing_file(self):
 
334
        """Merge handles missing file conflicts"""
 
335
        os.mkdir('a')
 
336
        os.chdir('a')
 
337
        os.mkdir('sub')
 
338
        print >> file('sub/a.txt', 'wb'), "hello"
 
339
        print >> file('b.txt', 'wb'), "hello"
 
340
        print >> file('sub/c.txt', 'wb'), "hello"
 
341
        self.runbzr('init')
 
342
        self.runbzr('add')
 
343
        self.runbzr(('commit', '-m', 'added a'))
 
344
        self.runbzr('branch . ../b')
 
345
        print >> file('sub/a.txt', 'ab'), "there"
 
346
        print >> file('b.txt', 'ab'), "there"
 
347
        print >> file('sub/c.txt', 'ab'), "there"
 
348
        self.runbzr(('commit', '-m', 'Added there'))
 
349
        os.unlink('sub/a.txt')
 
350
        os.unlink('sub/c.txt')
 
351
        os.rmdir('sub')
 
352
        os.unlink('b.txt')
 
353
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
354
        os.chdir('../b')
 
355
        print >> file('sub/a.txt', 'ab'), "something"
 
356
        print >> file('b.txt', 'ab'), "something"
 
357
        print >> file('sub/c.txt', 'ab'), "something"
 
358
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
359
        self.runbzr('merge ../a/')
 
360
        assert os.path.exists('sub/a.txt.THIS')
 
361
        assert os.path.exists('sub/a.txt.BASE')
 
362
        os.chdir('../a')
 
363
        self.runbzr('merge ../b/')
 
364
        assert os.path.exists('sub/a.txt.OTHER')
 
365
        assert os.path.exists('sub/a.txt.BASE')
 
366
 
 
367
    def test_pull(self):
 
368
        """Pull changes from one branch to another."""
 
369
        os.mkdir('a')
 
370
        os.chdir('a')
 
371
 
 
372
        self.example_branch()
 
373
        self.runbzr('pull', retcode=1)
 
374
        self.runbzr('missing', retcode=1)
 
375
        self.runbzr('missing .')
 
376
        self.runbzr('missing')
 
377
        self.runbzr('pull')
 
378
        self.runbzr('pull /', retcode=1)
 
379
        self.runbzr('pull')
 
380
 
 
381
        os.chdir('..')
 
382
        self.runbzr('branch a b')
 
383
        os.chdir('b')
 
384
        self.runbzr('pull')
 
385
        os.mkdir('subdir')
 
386
        self.runbzr('add subdir')
 
387
        self.runbzr('commit -m blah --unchanged')
 
388
        os.chdir('../a')
 
389
        a = Branch.open('.')
 
390
        b = Branch.open('../b')
 
391
        assert a.revision_history() == b.revision_history()[:-1]
 
392
        self.runbzr('pull ../b')
 
393
        assert a.revision_history() == b.revision_history()
 
394
        self.runbzr('commit -m blah2 --unchanged')
 
395
        os.chdir('../b')
 
396
        self.runbzr('commit -m blah3 --unchanged')
 
397
        self.runbzr('pull ../a', retcode=1)
 
398
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
399
        return
 
400
        os.chdir('../a')
 
401
        self.runbzr('merge ../b')
 
402
        self.runbzr('commit -m blah4 --unchanged')
 
403
        os.chdir('../b/subdir')
 
404
        self.runbzr('pull ../../a')
 
405
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
406
        self.runbzr('commit -m blah5 --unchanged')
 
407
        self.runbzr('commit -m blah6 --unchanged')
 
408
        os.chdir('..')
 
409
        self.runbzr('pull ../a')
 
410
        os.chdir('../a')
 
411
        self.runbzr('commit -m blah7 --unchanged')
 
412
        self.runbzr('merge ../b')
 
413
        self.runbzr('commit -m blah8 --unchanged')
 
414
        self.runbzr('pull ../b')
 
415
        self.runbzr('pull ../b')
 
416
 
 
417
    def test_locations(self):
 
418
        """Using and remembering different locations"""
 
419
        os.mkdir('a')
 
420
        os.chdir('a')
 
421
        self.runbzr('init')
 
422
        self.runbzr('commit -m unchanged --unchanged')
 
423
        self.runbzr('pull', retcode=1)
 
424
        self.runbzr('merge', retcode=1)
 
425
        self.runbzr('branch . ../b')
 
426
        os.chdir('../b')
 
427
        self.runbzr('pull')
 
428
        self.runbzr('branch . ../c')
 
429
        self.runbzr('pull ../c')
 
430
        self.runbzr('merge')
 
431
        os.chdir('../a')
 
432
        self.runbzr('pull ../b')
 
433
        self.runbzr('pull')
 
434
        self.runbzr('pull ../c')
 
435
        self.runbzr('branch ../c ../d')
 
436
        shutil.rmtree('../c')
 
437
        self.runbzr('pull')
 
438
        os.chdir('../b')
 
439
        self.runbzr('pull')
 
440
        os.chdir('../d')
 
441
        self.runbzr('pull', retcode=1)
 
442
        self.runbzr('pull ../a --remember')
 
443
        self.runbzr('pull')
 
444
        
226
445
    def test_add_reports(self):
227
446
        """add command prints the names of added files."""
228
 
        b = Branch('.', init=True)
 
447
        b = Branch.initialize('.')
229
448
        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
 
 
 
449
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
239
450
        # the ordering is not defined at the moment
240
 
        results = sorted(out.getvalue().rstrip('\n').split('\n'))
 
451
        results = sorted(out.rstrip('\n').split('\n'))
241
452
        self.assertEquals(['added dir',
242
 
                           'added dir/sub.txt',
 
453
                           'added dir'+os.sep+'sub.txt',
243
454
                           'added top.txt',],
244
455
                          results)
245
456
 
 
457
    def test_unknown_command(self):
 
458
        """Handling of unknown command."""
 
459
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
460
                                         retcode=1)
 
461
        self.assertEquals(out, '')
 
462
        err.index('unknown command')
 
463
 
 
464
    def test_conflicts(self):
 
465
        """Handling of merge conflicts"""
 
466
        os.mkdir('base')
 
467
        os.chdir('base')
 
468
        file('hello', 'wb').write("hi world")
 
469
        file('answer', 'wb').write("42")
 
470
        self.runbzr('init')
 
471
        self.runbzr('add')
 
472
        self.runbzr('commit -m base')
 
473
        self.runbzr('branch . ../other')
 
474
        self.runbzr('branch . ../this')
 
475
        os.chdir('../other')
 
476
        file('hello', 'wb').write("Hello.")
 
477
        file('answer', 'wb').write("Is anyone there?")
 
478
        self.runbzr('commit -m other')
 
479
        os.chdir('../this')
 
480
        file('hello', 'wb').write("Hello, world")
 
481
        self.runbzr('mv answer question')
 
482
        file('question', 'wb').write("What do you get when you multiply six"
 
483
                                   "times nine?")
 
484
        self.runbzr('commit -m this')
 
485
        self.runbzr('merge ../other')
 
486
        result = self.runbzr('conflicts', backtick=1)
 
487
        self.assertEquals(result, "hello\nquestion\n")
 
488
        result = self.runbzr('status', backtick=1)
 
489
        assert "conflicts:\n  hello\n  question\n" in result, result
 
490
        self.runbzr('resolve hello')
 
491
        result = self.runbzr('conflicts', backtick=1)
 
492
        self.assertEquals(result, "question\n")
 
493
        self.runbzr('commit -m conflicts', retcode=1)
 
494
        self.runbzr('resolve --all')
 
495
        result = self.runbzr('conflicts', backtick=1)
 
496
        self.runbzr('commit -m conflicts')
 
497
        self.assertEquals(result, "")
 
498
 
 
499
def listdir_sorted(dir):
 
500
    L = os.listdir(dir)
 
501
    L.sort()
 
502
    return L
 
503
 
246
504
 
247
505
class OldTests(ExternalBase):
248
506
    """old tests moved from ./testbzr."""
250
508
    def test_bzr(self):
251
509
        from os import chdir, mkdir
252
510
        from os.path import exists
253
 
        import os
254
511
 
255
512
        runbzr = self.runbzr
256
 
        backtick = self.backtick
 
513
        capture = self.capture
257
514
        progress = self.log
258
515
 
259
516
        progress("basic branch creation")
261
518
        chdir('branch1')
262
519
        runbzr('init')
263
520
 
264
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
521
        self.assertEquals(capture('root').rstrip(),
265
522
                          os.path.join(self.test_dir, 'branch1'))
266
523
 
267
524
        progress("status of new file")
270
527
        f.write('hello world!\n')
271
528
        f.close()
272
529
 
273
 
        out = backtick("bzr unknowns")
274
 
        self.assertEquals(out, 'test.txt\n')
 
530
        self.assertEquals(capture('unknowns'), 'test.txt\n')
275
531
 
276
 
        out = backtick("bzr status")
 
532
        out = capture("status")
277
533
        assert out == 'unknown:\n  test.txt\n'
278
534
 
279
 
        out = backtick("bzr status --all")
 
535
        out = capture("status --all")
280
536
        assert out == "unknown:\n  test.txt\n"
281
537
 
282
 
        out = backtick("bzr status test.txt --all")
 
538
        out = capture("status test.txt --all")
283
539
        assert out == "unknown:\n  test.txt\n"
284
540
 
285
541
        f = file('test2.txt', 'wt')
286
542
        f.write('goodbye cruel world...\n')
287
543
        f.close()
288
544
 
289
 
        out = backtick("bzr status test.txt")
 
545
        out = capture("status test.txt")
290
546
        assert out == "unknown:\n  test.txt\n"
291
547
 
292
 
        out = backtick("bzr status")
 
548
        out = capture("status")
293
549
        assert out == ("unknown:\n"
294
550
                       "  test.txt\n"
295
551
                       "  test2.txt\n")
297
553
        os.unlink('test2.txt')
298
554
 
299
555
        progress("command aliases")
300
 
        out = backtick("bzr st --all")
 
556
        out = capture("st --all")
301
557
        assert out == ("unknown:\n"
302
558
                       "  test.txt\n")
303
559
 
304
 
        out = backtick("bzr stat")
 
560
        out = capture("stat")
305
561
        assert out == ("unknown:\n"
306
562
                       "  test.txt\n")
307
563
 
311
567
        runbzr("help commands")
312
568
        runbzr("help slartibartfast", 1)
313
569
 
314
 
        out = backtick("bzr help ci")
 
570
        out = capture("help ci")
315
571
        out.index('aliases: ')
316
572
 
317
573
        progress("can't rename unversioned file")
320
576
        progress("adding a file")
321
577
 
322
578
        runbzr("add test.txt")
323
 
        assert backtick("bzr unknowns") == ''
324
 
        assert backtick("bzr status --all") == ("added:\n"
 
579
        assert capture("unknowns") == ''
 
580
        assert capture("status --all") == ("added:\n"
325
581
                                                "  test.txt\n")
326
582
 
327
583
        progress("rename newly-added file")
329
585
        assert os.path.exists("hello.txt")
330
586
        assert not os.path.exists("test.txt")
331
587
 
332
 
        assert backtick("bzr revno") == '0\n'
 
588
        assert capture("revno") == '0\n'
333
589
 
334
590
        progress("add first revision")
335
591
        runbzr(['commit', '-m', 'add first revision'])
343
599
        runbzr("add sub1")
344
600
        runbzr("rename sub1 sub2")
345
601
        runbzr("move hello.txt sub2")
346
 
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
602
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
347
603
 
348
604
        assert exists("sub2")
349
605
        assert exists("sub2/hello.txt")
364
620
        runbzr(['commit', '-m', 'rename nested subdirectories'])
365
621
 
366
622
        chdir('sub1/sub2')
367
 
        self.assertEquals(backtick('bzr root')[:-1],
 
623
        self.assertEquals(capture('root')[:-1],
368
624
                          os.path.join(self.test_dir, 'branch1'))
369
625
        runbzr('move ../hello.txt .')
370
626
        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')
 
627
        self.assertEquals(capture('relpath hello.txt'),
 
628
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
629
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
373
630
        runbzr(['commit', '-m', 'move to parent directory'])
374
631
        chdir('..')
375
 
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
632
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
376
633
 
377
634
        runbzr('move sub2/hello.txt .')
378
635
        assert exists('hello.txt')
387
644
 
388
645
        runbzr('commit -F msg.tmp')
389
646
 
390
 
        assert backtick('bzr revno') == '5\n'
 
647
        assert capture('revno') == '5\n'
391
648
        runbzr('export -r 5 export-5.tmp')
392
649
        runbzr('export export.tmp')
393
650
 
395
652
        runbzr('log -v')
396
653
        runbzr('log -v --forward')
397
654
        runbzr('log -m', retcode=1)
398
 
        log_out = backtick('bzr log -m commit')
 
655
        log_out = capture('log -m commit')
399
656
        assert "this is my new commit" in log_out
400
657
        assert "rename nested" not in log_out
401
658
        assert 'revision-id' not in log_out
402
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
659
        assert 'revision-id' in capture('log --show-ids -m commit')
403
660
 
404
661
 
405
662
        progress("file with spaces in name")
415
672
 
416
673
        runbzr('info')
417
674
 
 
675
        if has_symlinks():
 
676
            progress("symlinks")
 
677
            mkdir('symlinks')
 
678
            chdir('symlinks')
 
679
            runbzr('init')
 
680
            os.symlink("NOWHERE1", "link1")
 
681
            runbzr('add link1')
 
682
            assert self.capture('unknowns') == ''
 
683
            runbzr(['commit', '-m', '1: added symlink link1'])
 
684
    
 
685
            mkdir('d1')
 
686
            runbzr('add d1')
 
687
            assert self.capture('unknowns') == ''
 
688
            os.symlink("NOWHERE2", "d1/link2")
 
689
            assert self.capture('unknowns') == 'd1/link2\n'
 
690
            # is d1/link2 found when adding d1
 
691
            runbzr('add d1')
 
692
            assert self.capture('unknowns') == ''
 
693
            os.symlink("NOWHERE3", "d1/link3")
 
694
            assert self.capture('unknowns') == 'd1/link3\n'
 
695
            runbzr(['commit', '-m', '2: added dir, symlink'])
 
696
    
 
697
            runbzr('rename d1 d2')
 
698
            runbzr('move d2/link2 .')
 
699
            runbzr('move link1 d2')
 
700
            assert os.readlink("./link2") == "NOWHERE2"
 
701
            assert os.readlink("d2/link1") == "NOWHERE1"
 
702
            runbzr('add d2/link3')
 
703
            runbzr('diff')
 
704
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
 
705
    
 
706
            os.unlink("link2")
 
707
            os.symlink("TARGET 2", "link2")
 
708
            os.unlink("d2/link1")
 
709
            os.symlink("TARGET 1", "d2/link1")
 
710
            runbzr('diff')
 
711
            assert self.capture("relpath d2/link1") == "d2/link1\n"
 
712
            runbzr(['commit', '-m', '4: retarget of two links'])
 
713
    
 
714
            runbzr('remove d2/link1')
 
715
            assert self.capture('unknowns') == 'd2/link1\n'
 
716
            runbzr(['commit', '-m', '5: remove d2/link1'])
 
717
            # try with the rm alias
 
718
            runbzr('add d2/link1')
 
719
            runbzr(['commit', '-m', '6: add d2/link1'])
 
720
            runbzr('rm d2/link1')
 
721
            assert self.capture('unknowns') == 'd2/link1\n'
 
722
            runbzr(['commit', '-m', '7: remove d2/link1'])
 
723
    
 
724
            os.mkdir("d1")
 
725
            runbzr('add d1')
 
726
            runbzr('rename d2/link3 d1/link3new')
 
727
            assert self.capture('unknowns') == 'd2/link1\n'
 
728
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
 
729
            
 
730
            runbzr(['check'])
 
731
            
 
732
            runbzr(['export', '-r', '1', 'exp1.tmp'])
 
733
            chdir("exp1.tmp")
 
734
            assert listdir_sorted(".") == [ "link1" ]
 
735
            assert os.readlink("link1") == "NOWHERE1"
 
736
            chdir("..")
 
737
            
 
738
            runbzr(['export', '-r', '2', 'exp2.tmp'])
 
739
            chdir("exp2.tmp")
 
740
            assert listdir_sorted(".") == [ "d1", "link1" ]
 
741
            chdir("..")
 
742
            
 
743
            runbzr(['export', '-r', '3', 'exp3.tmp'])
 
744
            chdir("exp3.tmp")
 
745
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
746
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
747
            assert os.readlink("d2/link1") == "NOWHERE1"
 
748
            assert os.readlink("link2")    == "NOWHERE2"
 
749
            chdir("..")
 
750
            
 
751
            runbzr(['export', '-r', '4', 'exp4.tmp'])
 
752
            chdir("exp4.tmp")
 
753
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
754
            assert os.readlink("d2/link1") == "TARGET 1"
 
755
            assert os.readlink("link2")    == "TARGET 2"
 
756
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
757
            chdir("..")
 
758
            
 
759
            runbzr(['export', '-r', '5', 'exp5.tmp'])
 
760
            chdir("exp5.tmp")
 
761
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
762
            assert os.path.islink("link2")
 
763
            assert listdir_sorted("d2")== [ "link3" ]
 
764
            chdir("..")
 
765
            
 
766
            runbzr(['export', '-r', '8', 'exp6.tmp'])
 
767
            chdir("exp6.tmp")
 
768
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
 
769
            assert listdir_sorted("d1") == [ "link3new" ]
 
770
            assert listdir_sorted("d2") == []
 
771
            assert os.readlink("d1/link3new") == "NOWHERE3"
 
772
            chdir("..")
 
773
        else:
 
774
            progress("skipping symlink tests")
 
775
 
 
776
 
 
777
class HttpTests(TestCaseWithWebserver):
 
778
    """Test bzr ui commands against remote branches."""
 
779
 
 
780
    def test_branch(self):
 
781
        os.mkdir('from')
 
782
        branch = Branch.initialize('from')
 
783
        branch.commit('empty commit for nonsense', allow_pointless=True)
 
784
        url = self.get_remote_url('from')
 
785
        self.run_bzr('branch', url, 'to')
 
786
        branch = Branch.open('to')
 
787
        self.assertEqual(1, len(branch.revision_history()))