~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

- store revision properties in revision xml

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
405
        return
 
406
        os.chdir('../a')
 
407
        self.runbzr('merge ../b')
 
408
        self.runbzr('commit -m blah4 --unchanged')
 
409
        os.chdir('../b/subdir')
 
410
        self.runbzr('pull ../../a')
 
411
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
412
        self.runbzr('commit -m blah5 --unchanged')
 
413
        self.runbzr('commit -m blah6 --unchanged')
 
414
        os.chdir('..')
 
415
        self.runbzr('pull ../a')
 
416
        os.chdir('../a')
 
417
        self.runbzr('commit -m blah7 --unchanged')
 
418
        self.runbzr('merge ../b')
 
419
        self.runbzr('commit -m blah8 --unchanged')
 
420
        self.runbzr('pull ../b')
 
421
        self.runbzr('pull ../b')
 
422
 
 
423
    def test_locations(self):
 
424
        """Using and remembering different locations"""
 
425
        os.mkdir('a')
 
426
        os.chdir('a')
 
427
        self.runbzr('init')
 
428
        self.runbzr('commit -m unchanged --unchanged')
 
429
        self.runbzr('pull', retcode=1)
 
430
        self.runbzr('merge', retcode=1)
 
431
        self.runbzr('branch . ../b')
 
432
        os.chdir('../b')
 
433
        self.runbzr('pull')
 
434
        self.runbzr('branch . ../c')
 
435
        self.runbzr('pull ../c')
 
436
        self.runbzr('merge')
 
437
        os.chdir('../a')
 
438
        self.runbzr('pull ../b')
 
439
        self.runbzr('pull')
 
440
        self.runbzr('pull ../c')
 
441
        self.runbzr('branch ../c ../d')
 
442
        shutil.rmtree('../c')
 
443
        self.runbzr('pull')
 
444
        os.chdir('../b')
 
445
        self.runbzr('pull')
 
446
        os.chdir('../d')
 
447
        self.runbzr('pull', retcode=1)
 
448
        self.runbzr('pull ../a --remember')
 
449
        self.runbzr('pull')
 
450
        
226
451
    def test_add_reports(self):
227
452
        """add command prints the names of added files."""
228
 
        b = Branch('.', init=True)
 
453
        b = Branch.initialize('.')
229
454
        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
 
 
 
455
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
239
456
        # the ordering is not defined at the moment
240
 
        results = sorted(out.getvalue().rstrip('\n').split('\n'))
 
457
        results = sorted(out.rstrip('\n').split('\n'))
241
458
        self.assertEquals(['added dir',
242
 
                           'added dir/sub.txt',
 
459
                           'added dir'+os.sep+'sub.txt',
243
460
                           'added top.txt',],
244
461
                          results)
245
462
 
 
463
    def test_add_quiet_is(self):
 
464
        """add -q does not print the names of added files."""
 
465
        b = Branch.initialize('.')
 
466
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
467
        out = self.run_bzr_captured(['add', '-q'], retcode = 0)[0]
 
468
        # the ordering is not defined at the moment
 
469
        results = sorted(out.rstrip('\n').split('\n'))
 
470
        self.assertEquals([''], results)
 
471
 
 
472
    def test_unknown_command(self):
 
473
        """Handling of unknown command."""
 
474
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
475
                                         retcode=1)
 
476
        self.assertEquals(out, '')
 
477
        err.index('unknown command')
 
478
 
 
479
    def test_conflicts(self):
 
480
        """Handling of merge conflicts"""
 
481
        os.mkdir('base')
 
482
        os.chdir('base')
 
483
        file('hello', 'wb').write("hi world")
 
484
        file('answer', 'wb').write("42")
 
485
        self.runbzr('init')
 
486
        self.runbzr('add')
 
487
        self.runbzr('commit -m base')
 
488
        self.runbzr('branch . ../other')
 
489
        self.runbzr('branch . ../this')
 
490
        os.chdir('../other')
 
491
        file('hello', 'wb').write("Hello.")
 
492
        file('answer', 'wb').write("Is anyone there?")
 
493
        self.runbzr('commit -m other')
 
494
        os.chdir('../this')
 
495
        file('hello', 'wb').write("Hello, world")
 
496
        self.runbzr('mv answer question')
 
497
        file('question', 'wb').write("What do you get when you multiply six"
 
498
                                   "times nine?")
 
499
        self.runbzr('commit -m this')
 
500
        self.runbzr('merge ../other')
 
501
        result = self.runbzr('conflicts', backtick=1)
 
502
        self.assertEquals(result, "hello\nquestion\n")
 
503
        result = self.runbzr('status', backtick=1)
 
504
        assert "conflicts:\n  hello\n  question\n" in result, result
 
505
        self.runbzr('resolve hello')
 
506
        result = self.runbzr('conflicts', backtick=1)
 
507
        self.assertEquals(result, "question\n")
 
508
        self.runbzr('commit -m conflicts', retcode=1)
 
509
        self.runbzr('resolve --all')
 
510
        result = self.runbzr('conflicts', backtick=1)
 
511
        self.runbzr('commit -m conflicts')
 
512
        self.assertEquals(result, "")
 
513
 
 
514
def listdir_sorted(dir):
 
515
    L = os.listdir(dir)
 
516
    L.sort()
 
517
    return L
 
518
 
246
519
 
247
520
class OldTests(ExternalBase):
248
521
    """old tests moved from ./testbzr."""
250
523
    def test_bzr(self):
251
524
        from os import chdir, mkdir
252
525
        from os.path import exists
253
 
        import os
254
526
 
255
527
        runbzr = self.runbzr
256
 
        backtick = self.backtick
 
528
        capture = self.capture
257
529
        progress = self.log
258
530
 
259
531
        progress("basic branch creation")
261
533
        chdir('branch1')
262
534
        runbzr('init')
263
535
 
264
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
536
        self.assertEquals(capture('root').rstrip(),
265
537
                          os.path.join(self.test_dir, 'branch1'))
266
538
 
267
539
        progress("status of new file")
270
542
        f.write('hello world!\n')
271
543
        f.close()
272
544
 
273
 
        out = backtick("bzr unknowns")
274
 
        self.assertEquals(out, 'test.txt\n')
 
545
        self.assertEquals(capture('unknowns'), 'test.txt\n')
275
546
 
276
 
        out = backtick("bzr status")
 
547
        out = capture("status")
277
548
        assert out == 'unknown:\n  test.txt\n'
278
549
 
279
 
        out = backtick("bzr status --all")
 
550
        out = capture("status --all")
280
551
        assert out == "unknown:\n  test.txt\n"
281
552
 
282
 
        out = backtick("bzr status test.txt --all")
 
553
        out = capture("status test.txt --all")
283
554
        assert out == "unknown:\n  test.txt\n"
284
555
 
285
556
        f = file('test2.txt', 'wt')
286
557
        f.write('goodbye cruel world...\n')
287
558
        f.close()
288
559
 
289
 
        out = backtick("bzr status test.txt")
 
560
        out = capture("status test.txt")
290
561
        assert out == "unknown:\n  test.txt\n"
291
562
 
292
 
        out = backtick("bzr status")
 
563
        out = capture("status")
293
564
        assert out == ("unknown:\n"
294
565
                       "  test.txt\n"
295
566
                       "  test2.txt\n")
297
568
        os.unlink('test2.txt')
298
569
 
299
570
        progress("command aliases")
300
 
        out = backtick("bzr st --all")
 
571
        out = capture("st --all")
301
572
        assert out == ("unknown:\n"
302
573
                       "  test.txt\n")
303
574
 
304
 
        out = backtick("bzr stat")
 
575
        out = capture("stat")
305
576
        assert out == ("unknown:\n"
306
577
                       "  test.txt\n")
307
578
 
311
582
        runbzr("help commands")
312
583
        runbzr("help slartibartfast", 1)
313
584
 
314
 
        out = backtick("bzr help ci")
 
585
        out = capture("help ci")
315
586
        out.index('aliases: ')
316
587
 
317
588
        progress("can't rename unversioned file")
320
591
        progress("adding a file")
321
592
 
322
593
        runbzr("add test.txt")
323
 
        assert backtick("bzr unknowns") == ''
324
 
        assert backtick("bzr status --all") == ("added:\n"
 
594
        assert capture("unknowns") == ''
 
595
        assert capture("status --all") == ("added:\n"
325
596
                                                "  test.txt\n")
326
597
 
327
598
        progress("rename newly-added file")
329
600
        assert os.path.exists("hello.txt")
330
601
        assert not os.path.exists("test.txt")
331
602
 
332
 
        assert backtick("bzr revno") == '0\n'
 
603
        assert capture("revno") == '0\n'
333
604
 
334
605
        progress("add first revision")
335
606
        runbzr(['commit', '-m', 'add first revision'])
343
614
        runbzr("add sub1")
344
615
        runbzr("rename sub1 sub2")
345
616
        runbzr("move hello.txt sub2")
346
 
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
617
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
347
618
 
348
619
        assert exists("sub2")
349
620
        assert exists("sub2/hello.txt")
364
635
        runbzr(['commit', '-m', 'rename nested subdirectories'])
365
636
 
366
637
        chdir('sub1/sub2')
367
 
        self.assertEquals(backtick('bzr root')[:-1],
 
638
        self.assertEquals(capture('root')[:-1],
368
639
                          os.path.join(self.test_dir, 'branch1'))
369
640
        runbzr('move ../hello.txt .')
370
641
        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')
 
642
        self.assertEquals(capture('relpath hello.txt'),
 
643
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
644
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
373
645
        runbzr(['commit', '-m', 'move to parent directory'])
374
646
        chdir('..')
375
 
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
647
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
376
648
 
377
649
        runbzr('move sub2/hello.txt .')
378
650
        assert exists('hello.txt')
387
659
 
388
660
        runbzr('commit -F msg.tmp')
389
661
 
390
 
        assert backtick('bzr revno') == '5\n'
 
662
        assert capture('revno') == '5\n'
391
663
        runbzr('export -r 5 export-5.tmp')
392
664
        runbzr('export export.tmp')
393
665
 
395
667
        runbzr('log -v')
396
668
        runbzr('log -v --forward')
397
669
        runbzr('log -m', retcode=1)
398
 
        log_out = backtick('bzr log -m commit')
 
670
        log_out = capture('log -m commit')
399
671
        assert "this is my new commit" in log_out
400
672
        assert "rename nested" not in log_out
401
673
        assert 'revision-id' not in log_out
402
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
674
        assert 'revision-id' in capture('log --show-ids -m commit')
403
675
 
404
676
 
405
677
        progress("file with spaces in name")
415
687
 
416
688
        runbzr('info')
417
689
 
 
690
        if has_symlinks():
 
691
            progress("symlinks")
 
692
            mkdir('symlinks')
 
693
            chdir('symlinks')
 
694
            runbzr('init')
 
695
            os.symlink("NOWHERE1", "link1")
 
696
            runbzr('add link1')
 
697
            assert self.capture('unknowns') == ''
 
698
            runbzr(['commit', '-m', '1: added symlink link1'])
 
699
    
 
700
            mkdir('d1')
 
701
            runbzr('add d1')
 
702
            assert self.capture('unknowns') == ''
 
703
            os.symlink("NOWHERE2", "d1/link2")
 
704
            assert self.capture('unknowns') == 'd1/link2\n'
 
705
            # is d1/link2 found when adding d1
 
706
            runbzr('add d1')
 
707
            assert self.capture('unknowns') == ''
 
708
            os.symlink("NOWHERE3", "d1/link3")
 
709
            assert self.capture('unknowns') == 'd1/link3\n'
 
710
            runbzr(['commit', '-m', '2: added dir, symlink'])
 
711
    
 
712
            runbzr('rename d1 d2')
 
713
            runbzr('move d2/link2 .')
 
714
            runbzr('move link1 d2')
 
715
            assert os.readlink("./link2") == "NOWHERE2"
 
716
            assert os.readlink("d2/link1") == "NOWHERE1"
 
717
            runbzr('add d2/link3')
 
718
            runbzr('diff')
 
719
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
 
720
    
 
721
            os.unlink("link2")
 
722
            os.symlink("TARGET 2", "link2")
 
723
            os.unlink("d2/link1")
 
724
            os.symlink("TARGET 1", "d2/link1")
 
725
            runbzr('diff')
 
726
            assert self.capture("relpath d2/link1") == "d2/link1\n"
 
727
            runbzr(['commit', '-m', '4: retarget of two links'])
 
728
    
 
729
            runbzr('remove d2/link1')
 
730
            assert self.capture('unknowns') == 'd2/link1\n'
 
731
            runbzr(['commit', '-m', '5: remove d2/link1'])
 
732
            # try with the rm alias
 
733
            runbzr('add d2/link1')
 
734
            runbzr(['commit', '-m', '6: add d2/link1'])
 
735
            runbzr('rm d2/link1')
 
736
            assert self.capture('unknowns') == 'd2/link1\n'
 
737
            runbzr(['commit', '-m', '7: remove d2/link1'])
 
738
    
 
739
            os.mkdir("d1")
 
740
            runbzr('add d1')
 
741
            runbzr('rename d2/link3 d1/link3new')
 
742
            assert self.capture('unknowns') == 'd2/link1\n'
 
743
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
 
744
            
 
745
            runbzr(['check'])
 
746
            
 
747
            runbzr(['export', '-r', '1', 'exp1.tmp'])
 
748
            chdir("exp1.tmp")
 
749
            assert listdir_sorted(".") == [ "link1" ]
 
750
            assert os.readlink("link1") == "NOWHERE1"
 
751
            chdir("..")
 
752
            
 
753
            runbzr(['export', '-r', '2', 'exp2.tmp'])
 
754
            chdir("exp2.tmp")
 
755
            assert listdir_sorted(".") == [ "d1", "link1" ]
 
756
            chdir("..")
 
757
            
 
758
            runbzr(['export', '-r', '3', 'exp3.tmp'])
 
759
            chdir("exp3.tmp")
 
760
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
761
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
762
            assert os.readlink("d2/link1") == "NOWHERE1"
 
763
            assert os.readlink("link2")    == "NOWHERE2"
 
764
            chdir("..")
 
765
            
 
766
            runbzr(['export', '-r', '4', 'exp4.tmp'])
 
767
            chdir("exp4.tmp")
 
768
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
769
            assert os.readlink("d2/link1") == "TARGET 1"
 
770
            assert os.readlink("link2")    == "TARGET 2"
 
771
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
772
            chdir("..")
 
773
            
 
774
            runbzr(['export', '-r', '5', 'exp5.tmp'])
 
775
            chdir("exp5.tmp")
 
776
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
777
            assert os.path.islink("link2")
 
778
            assert listdir_sorted("d2")== [ "link3" ]
 
779
            chdir("..")
 
780
            
 
781
            runbzr(['export', '-r', '8', 'exp6.tmp'])
 
782
            chdir("exp6.tmp")
 
783
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
 
784
            assert listdir_sorted("d1") == [ "link3new" ]
 
785
            assert listdir_sorted("d2") == []
 
786
            assert os.readlink("d1/link3new") == "NOWHERE3"
 
787
            chdir("..")
 
788
        else:
 
789
            progress("skipping symlink tests")
 
790
 
 
791
 
 
792
class HttpTests(TestCaseWithWebserver):
 
793
    """Test bzr ui commands against remote branches."""
 
794
 
 
795
    def test_branch(self):
 
796
        os.mkdir('from')
 
797
        branch = Branch.initialize('from')
 
798
        branch.commit('empty commit for nonsense', allow_pointless=True)
 
799
        url = self.get_remote_url('from')
 
800
        self.run_bzr('branch', url, 'to')
 
801
        branch = Branch.open('to')
 
802
        self.assertEqual(1, len(branch.revision_history()))