← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Martin Pool
  • Date: 2005-10-04 06:44:50 UTC
  • mto: (1185.13.3)
  • mto: This revision was merged to the branch mainline in revision 1403.
  • Revision ID: mbp@sourcefrog.net-20051004064450-6437da8f84d41517
- add test that upgrade completes successfully

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/blackbox.py
26
26
it's normally invoked.
27
27
"""
28
28
 
 
29
from cStringIO import StringIO
 
30
import os
 
31
import shutil
29
32
import sys
 
33
import os
30
34
 
31
35
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
32
36
from bzrlib.branch import Branch
33
 
from bzrlib.commands import run_bzr
 
37
from bzrlib.osutils import has_symlinks
34
38
 
35
39
 
36
40
class ExternalBase(TestCaseInTempDir):
37
 
    def runbzr(self, args, retcode=0,backtick=False):
 
41
 
 
42
    def runbzr(self, args, retcode=0, backtick=False):
38
43
        if isinstance(args, basestring):
39
44
            args = args.split()
40
45
 
41
46
        if backtick:
42
 
            return self.backtick(['python', self.BZRPATH,] + args,
43
 
                           retcode=retcode)
 
47
            return self.run_bzr_captured(args, retcode=retcode)[0]
44
48
        else:
45
 
            return self.runcmd(['python', self.BZRPATH,] + args,
46
 
                           retcode=retcode)
 
49
            return self.run_bzr_captured(args, retcode=retcode)
47
50
 
48
51
 
49
52
class TestCommands(ExternalBase):
72
75
        f = file('.bzr/email', 'wt')
73
76
        f.write('Branch Identity <branch@identi.ty>')
74
77
        f.close()
 
78
        bzr_email = os.environ.get('BZREMAIL')
 
79
        if bzr_email is not None:
 
80
            del os.environ['BZREMAIL']
75
81
        whoami = self.runbzr("whoami",backtick=True)
76
82
        whoami_email = self.runbzr("whoami --email",backtick=True)
77
83
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
78
84
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
 
85
        # Verify that the environment variable overrides the value 
 
86
        # in the file
 
87
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
 
88
        whoami = self.runbzr("whoami",backtick=True)
 
89
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
90
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
 
91
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
 
92
        if bzr_email is not None:
 
93
            os.environ['BZREMAIL'] = bzr_email
79
94
 
80
95
    def test_invalid_commands(self):
81
96
        self.runbzr("pants", retcode=1)
92
107
    def test_ignore_patterns(self):
93
108
        from bzrlib.branch import Branch
94
109
        
95
 
        b = Branch('.', init=True)
 
110
        b = Branch.initialize('.')
96
111
        self.assertEquals(list(b.unknowns()), [])
97
112
 
98
113
        file('foo.tmp', 'wt').write('tmp files are ignored')
99
114
        self.assertEquals(list(b.unknowns()), [])
100
 
        assert self.backtick('bzr unknowns') == ''
 
115
        assert self.capture('unknowns') == ''
101
116
 
102
117
        file('foo.c', 'wt').write('int main() {}')
103
118
        self.assertEquals(list(b.unknowns()), ['foo.c'])
104
 
        assert self.backtick('bzr unknowns') == 'foo.c\n'
 
119
        assert self.capture('unknowns') == 'foo.c\n'
105
120
 
106
121
        self.runbzr(['add', 'foo.c'])
107
 
        assert self.backtick('bzr unknowns') == ''
 
122
        assert self.capture('unknowns') == ''
108
123
 
109
124
        # 'ignore' works when creating the .bzignore file
110
125
        file('foo.blah', 'wt').write('blah')
111
126
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
112
127
        self.runbzr('ignore *.blah')
113
128
        self.assertEquals(list(b.unknowns()), [])
114
 
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
 
129
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
115
130
 
116
131
        # 'ignore' works when then .bzrignore file already exists
117
132
        file('garh', 'wt').write('garh')
118
133
        self.assertEquals(list(b.unknowns()), ['garh'])
119
 
        assert self.backtick('bzr unknowns') == 'garh\n'
 
134
        assert self.capture('unknowns') == 'garh\n'
120
135
        self.runbzr('ignore garh')
121
136
        self.assertEquals(list(b.unknowns()), [])
122
 
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
 
137
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
123
138
 
124
139
    def test_revert(self):
125
 
        import os
126
140
        self.runbzr('init')
127
141
 
128
142
        file('hello', 'wt').write('foo')
132
146
        file('goodbye', 'wt').write('baz')
133
147
        self.runbzr('add goodbye')
134
148
        self.runbzr('commit -m setup goodbye')
135
 
        
 
149
 
136
150
        file('hello', 'wt').write('bar')
137
151
        file('goodbye', 'wt').write('qux')
138
152
        self.runbzr('revert hello')
147
161
        os.rmdir('revertdir')
148
162
        self.runbzr('revert')
149
163
 
150
 
    def skipped_test_mv_modes(self):
 
164
        os.symlink('/unlikely/to/exist', 'symlink')
 
165
        self.runbzr('add symlink')
 
166
        self.runbzr('commit -m f')
 
167
        os.unlink('symlink')
 
168
        self.runbzr('revert')
 
169
        
 
170
        file('hello', 'wt').write('xyz')
 
171
        self.runbzr('commit -m xyz hello')
 
172
        self.runbzr('revert -r 1 hello')
 
173
        self.check_file_contents('hello', 'foo')
 
174
        self.runbzr('revert hello')
 
175
        self.check_file_contents('hello', 'xyz')
 
176
        os.chdir('revertdir')
 
177
        self.runbzr('revert')
 
178
        os.chdir('..')
 
179
 
 
180
 
 
181
    def test_mv_modes(self):
151
182
        """Test two modes of operation for mv"""
152
183
        from bzrlib.branch import Branch
153
 
        b = Branch('.', init=True)
 
184
        b = Branch.initialize('.')
154
185
        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')
 
186
        self.run_bzr_captured(['add', self.test_dir])
 
187
        self.run_bzr_captured(['mv', 'a', 'b'])
 
188
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
189
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
190
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
191
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
 
192
 
160
193
 
161
194
    def test_main_version(self):
162
195
        """Check output from version command and master option is reasonable"""
182
215
        test.runbzr('add goodbye')
183
216
        test.runbzr('commit -m setup goodbye')
184
217
 
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')
 
218
    def test_export(self):
 
219
        os.mkdir('branch')
 
220
        os.chdir('branch')
 
221
        self.example_branch()
 
222
        self.runbzr('export ../latest')
 
223
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
 
224
        self.runbzr('export ../first -r 1')
 
225
        assert not os.path.exists('../first/goodbye')
 
226
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
 
227
        self.runbzr('export ../first.gz -r 1')
 
228
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
 
229
        self.runbzr('export ../first.bz2 -r 1')
 
230
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
 
231
        self.runbzr('export ../first.tar -r 1')
 
232
        assert os.path.isfile('../first.tar')
 
233
        from tarfile import TarFile
 
234
        tf = TarFile('../first.tar')
 
235
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
236
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
 
237
        self.runbzr('export ../first.tar.gz -r 1')
 
238
        assert os.path.isfile('../first.tar.gz')
 
239
        self.runbzr('export ../first.tbz2 -r 1')
 
240
        assert os.path.isfile('../first.tbz2')
 
241
        self.runbzr('export ../first.tar.bz2 -r 1')
 
242
        assert os.path.isfile('../first.tar.bz2')
 
243
        self.runbzr('export ../first.tar.tbz2 -r 1')
 
244
        assert os.path.isfile('../first.tar.tbz2')
 
245
        from bz2 import BZ2File
 
246
        tf = TarFile('../first.tar.tbz2', 
 
247
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
 
248
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
249
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
 
250
        self.runbzr('export ../first2.tar -r 1 --root pizza')
 
251
        tf = TarFile('../first2.tar')
 
252
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
253
 
 
254
    def test_diff(self):
 
255
        self.example_branch()
 
256
        file('hello', 'wt').write('hello world!')
 
257
        self.runbzr('commit -m fixing hello')
 
258
        output = self.runbzr('diff -r 2..3', backtick=1)
 
259
        self.assert_('\n+hello world!' in output)
 
260
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
261
        self.assert_('\n+baz' in output)
 
262
 
 
263
    def test_branch(self):
 
264
        """Branch from one branch to another."""
 
265
        os.mkdir('a')
 
266
        os.chdir('a')
 
267
        self.example_branch()
 
268
        os.chdir('..')
 
269
        self.runbzr('branch a b')
 
270
        self.runbzr('branch a c -r 1')
 
271
        os.chdir('b')
 
272
        self.runbzr('commit -m foo --unchanged')
 
273
        os.chdir('..')
 
274
        # naughty - abstraction violations RBC 20050928  
 
275
        print "test_branch used to delete the stores, how is this meant to work ?"
 
276
        #shutil.rmtree('a/.bzr/revision-store')
 
277
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
278
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
279
        self.runbzr('branch a d --basis b')
194
280
 
195
281
    def test_merge(self):
196
282
        from bzrlib.branch import Branch
197
 
        import os
198
283
        
199
284
        os.mkdir('a')
200
285
        os.chdir('a')
201
 
 
202
286
        self.example_branch()
203
287
        os.chdir('..')
204
288
        self.runbzr('branch a b')
214
298
        self.runbzr('merge ../b')
215
299
        self.check_file_contents('goodbye', 'quux')
216
300
        # 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
 
 
 
301
        a = Branch.open('.')
 
302
        b = Branch.open('../b')
 
303
        a.get_revision_xml(b.last_revision())
221
304
        self.log('pending merges: %s', a.pending_merges())
222
 
        #        assert a.pending_merges() == [b.last_patch()], "Assertion %s %s" \
223
 
        #        % (a.pending_merges(), b.last_patch())
224
 
 
225
 
 
 
305
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
 
306
        #        % (a.pending_merges(), b.last_revision())
 
307
 
 
308
    def test_merge_with_missing_file(self):
 
309
        """Merge handles missing file conflicts"""
 
310
        os.mkdir('a')
 
311
        os.chdir('a')
 
312
        os.mkdir('sub')
 
313
        print >> file('sub/a.txt', 'wb'), "hello"
 
314
        print >> file('b.txt', 'wb'), "hello"
 
315
        print >> file('sub/c.txt', 'wb'), "hello"
 
316
        self.runbzr('init')
 
317
        self.runbzr('add')
 
318
        self.runbzr(('commit', '-m', 'added a'))
 
319
        self.runbzr('branch . ../b')
 
320
        print >> file('sub/a.txt', 'ab'), "there"
 
321
        print >> file('b.txt', 'ab'), "there"
 
322
        print >> file('sub/c.txt', 'ab'), "there"
 
323
        self.runbzr(('commit', '-m', 'Added there'))
 
324
        os.unlink('sub/a.txt')
 
325
        os.unlink('sub/c.txt')
 
326
        os.rmdir('sub')
 
327
        os.unlink('b.txt')
 
328
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
329
        os.chdir('../b')
 
330
        print >> file('sub/a.txt', 'ab'), "something"
 
331
        print >> file('b.txt', 'ab'), "something"
 
332
        print >> file('sub/c.txt', 'ab'), "something"
 
333
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
334
        self.runbzr('merge ../a/')
 
335
        assert os.path.exists('sub/a.txt.THIS')
 
336
        assert os.path.exists('sub/a.txt.BASE')
 
337
        os.chdir('../a')
 
338
        self.runbzr('merge ../b/')
 
339
        assert os.path.exists('sub/a.txt.OTHER')
 
340
        assert os.path.exists('sub/a.txt.BASE')
 
341
 
 
342
    def test_pull(self):
 
343
        """Pull changes from one branch to another."""
 
344
        os.mkdir('a')
 
345
        os.chdir('a')
 
346
 
 
347
        self.example_branch()
 
348
        self.runbzr('pull', retcode=1)
 
349
        self.runbzr('missing', retcode=1)
 
350
        self.runbzr('missing .')
 
351
        self.runbzr('missing')
 
352
        self.runbzr('pull')
 
353
        self.runbzr('pull /', retcode=1)
 
354
        self.runbzr('pull')
 
355
 
 
356
        os.chdir('..')
 
357
        self.runbzr('branch a b')
 
358
        os.chdir('b')
 
359
        self.runbzr('pull')
 
360
        os.mkdir('subdir')
 
361
        self.runbzr('add subdir')
 
362
        self.runbzr('commit -m blah --unchanged')
 
363
        os.chdir('../a')
 
364
        a = Branch.open('.')
 
365
        b = Branch.open('../b')
 
366
        assert a.revision_history() == b.revision_history()[:-1]
 
367
        self.runbzr('pull ../b')
 
368
        assert a.revision_history() == b.revision_history()
 
369
        self.runbzr('commit -m blah2 --unchanged')
 
370
        os.chdir('../b')
 
371
        self.runbzr('commit -m blah3 --unchanged')
 
372
        self.runbzr('pull ../a', retcode=1)
 
373
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
374
        return
 
375
        os.chdir('../a')
 
376
        self.runbzr('merge ../b')
 
377
        self.runbzr('commit -m blah4 --unchanged')
 
378
        os.chdir('../b/subdir')
 
379
        self.runbzr('pull ../../a')
 
380
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
381
        self.runbzr('commit -m blah5 --unchanged')
 
382
        self.runbzr('commit -m blah6 --unchanged')
 
383
        os.chdir('..')
 
384
        self.runbzr('pull ../a')
 
385
        os.chdir('../a')
 
386
        self.runbzr('commit -m blah7 --unchanged')
 
387
        self.runbzr('merge ../b')
 
388
        self.runbzr('commit -m blah8 --unchanged')
 
389
        self.runbzr('pull ../b')
 
390
        self.runbzr('pull ../b')
 
391
        
226
392
    def test_add_reports(self):
227
393
        """add command prints the names of added files."""
228
 
        b = Branch('.', init=True)
 
394
        b = Branch.initialize('.')
229
395
        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
 
 
 
396
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
239
397
        # the ordering is not defined at the moment
240
 
        results = sorted(out.getvalue().rstrip('\n').split('\n'))
 
398
        results = sorted(out.rstrip('\n').split('\n'))
241
399
        self.assertEquals(['added dir',
242
 
                           'added dir/sub.txt',
 
400
                           'added dir'+os.sep+'sub.txt',
243
401
                           'added top.txt',],
244
402
                          results)
245
403
 
 
404
    def test_unknown_command(self):
 
405
        """Handling of unknown command."""
 
406
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
407
                                         retcode=1)
 
408
        self.assertEquals(out, '')
 
409
        err.index('unknown command')
 
410
        
 
411
 
 
412
def listdir_sorted(dir):
 
413
    L = os.listdir(dir)
 
414
    L.sort()
 
415
    return L
 
416
 
246
417
 
247
418
class OldTests(ExternalBase):
248
419
    """old tests moved from ./testbzr."""
250
421
    def test_bzr(self):
251
422
        from os import chdir, mkdir
252
423
        from os.path import exists
253
 
        import os
254
424
 
255
425
        runbzr = self.runbzr
256
 
        backtick = self.backtick
 
426
        capture = self.capture
257
427
        progress = self.log
258
428
 
259
429
        progress("basic branch creation")
261
431
        chdir('branch1')
262
432
        runbzr('init')
263
433
 
264
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
434
        self.assertEquals(capture('root').rstrip(),
265
435
                          os.path.join(self.test_dir, 'branch1'))
266
436
 
267
437
        progress("status of new file")
270
440
        f.write('hello world!\n')
271
441
        f.close()
272
442
 
273
 
        out = backtick("bzr unknowns")
274
 
        self.assertEquals(out, 'test.txt\n')
 
443
        self.assertEquals(capture('unknowns'), 'test.txt\n')
275
444
 
276
 
        out = backtick("bzr status")
 
445
        out = capture("status")
277
446
        assert out == 'unknown:\n  test.txt\n'
278
447
 
279
 
        out = backtick("bzr status --all")
 
448
        out = capture("status --all")
280
449
        assert out == "unknown:\n  test.txt\n"
281
450
 
282
 
        out = backtick("bzr status test.txt --all")
 
451
        out = capture("status test.txt --all")
283
452
        assert out == "unknown:\n  test.txt\n"
284
453
 
285
454
        f = file('test2.txt', 'wt')
286
455
        f.write('goodbye cruel world...\n')
287
456
        f.close()
288
457
 
289
 
        out = backtick("bzr status test.txt")
 
458
        out = capture("status test.txt")
290
459
        assert out == "unknown:\n  test.txt\n"
291
460
 
292
 
        out = backtick("bzr status")
 
461
        out = capture("status")
293
462
        assert out == ("unknown:\n"
294
463
                       "  test.txt\n"
295
464
                       "  test2.txt\n")
297
466
        os.unlink('test2.txt')
298
467
 
299
468
        progress("command aliases")
300
 
        out = backtick("bzr st --all")
 
469
        out = capture("st --all")
301
470
        assert out == ("unknown:\n"
302
471
                       "  test.txt\n")
303
472
 
304
 
        out = backtick("bzr stat")
 
473
        out = capture("stat")
305
474
        assert out == ("unknown:\n"
306
475
                       "  test.txt\n")
307
476
 
311
480
        runbzr("help commands")
312
481
        runbzr("help slartibartfast", 1)
313
482
 
314
 
        out = backtick("bzr help ci")
 
483
        out = capture("help ci")
315
484
        out.index('aliases: ')
316
485
 
317
486
        progress("can't rename unversioned file")
320
489
        progress("adding a file")
321
490
 
322
491
        runbzr("add test.txt")
323
 
        assert backtick("bzr unknowns") == ''
324
 
        assert backtick("bzr status --all") == ("added:\n"
 
492
        assert capture("unknowns") == ''
 
493
        assert capture("status --all") == ("added:\n"
325
494
                                                "  test.txt\n")
326
495
 
327
496
        progress("rename newly-added file")
329
498
        assert os.path.exists("hello.txt")
330
499
        assert not os.path.exists("test.txt")
331
500
 
332
 
        assert backtick("bzr revno") == '0\n'
 
501
        assert capture("revno") == '0\n'
333
502
 
334
503
        progress("add first revision")
335
504
        runbzr(['commit', '-m', 'add first revision'])
343
512
        runbzr("add sub1")
344
513
        runbzr("rename sub1 sub2")
345
514
        runbzr("move hello.txt sub2")
346
 
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
515
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
347
516
 
348
517
        assert exists("sub2")
349
518
        assert exists("sub2/hello.txt")
364
533
        runbzr(['commit', '-m', 'rename nested subdirectories'])
365
534
 
366
535
        chdir('sub1/sub2')
367
 
        self.assertEquals(backtick('bzr root')[:-1],
 
536
        self.assertEquals(capture('root')[:-1],
368
537
                          os.path.join(self.test_dir, 'branch1'))
369
538
        runbzr('move ../hello.txt .')
370
539
        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')
 
540
        self.assertEquals(capture('relpath hello.txt'),
 
541
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
542
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
373
543
        runbzr(['commit', '-m', 'move to parent directory'])
374
544
        chdir('..')
375
 
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
545
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
376
546
 
377
547
        runbzr('move sub2/hello.txt .')
378
548
        assert exists('hello.txt')
387
557
 
388
558
        runbzr('commit -F msg.tmp')
389
559
 
390
 
        assert backtick('bzr revno') == '5\n'
 
560
        assert capture('revno') == '5\n'
391
561
        runbzr('export -r 5 export-5.tmp')
392
562
        runbzr('export export.tmp')
393
563
 
395
565
        runbzr('log -v')
396
566
        runbzr('log -v --forward')
397
567
        runbzr('log -m', retcode=1)
398
 
        log_out = backtick('bzr log -m commit')
 
568
        log_out = capture('log -m commit')
399
569
        assert "this is my new commit" in log_out
400
570
        assert "rename nested" not in log_out
401
571
        assert 'revision-id' not in log_out
402
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
572
        assert 'revision-id' in capture('log --show-ids -m commit')
403
573
 
404
574
 
405
575
        progress("file with spaces in name")
415
585
 
416
586
        runbzr('info')
417
587
 
 
588
        if has_symlinks():
 
589
            progress("symlinks")
 
590
            mkdir('symlinks')
 
591
            chdir('symlinks')
 
592
            runbzr('init')
 
593
            os.symlink("NOWHERE1", "link1")
 
594
            runbzr('add link1')
 
595
            assert self.capture('unknowns') == ''
 
596
            runbzr(['commit', '-m', '1: added symlink link1'])
 
597
    
 
598
            mkdir('d1')
 
599
            runbzr('add d1')
 
600
            assert self.capture('unknowns') == ''
 
601
            os.symlink("NOWHERE2", "d1/link2")
 
602
            assert self.capture('unknowns') == 'd1/link2\n'
 
603
            # is d1/link2 found when adding d1
 
604
            runbzr('add d1')
 
605
            assert self.capture('unknowns') == ''
 
606
            os.symlink("NOWHERE3", "d1/link3")
 
607
            assert self.capture('unknowns') == 'd1/link3\n'
 
608
            runbzr(['commit', '-m', '2: added dir, symlink'])
 
609
    
 
610
            runbzr('rename d1 d2')
 
611
            runbzr('move d2/link2 .')
 
612
            runbzr('move link1 d2')
 
613
            assert os.readlink("./link2") == "NOWHERE2"
 
614
            assert os.readlink("d2/link1") == "NOWHERE1"
 
615
            runbzr('add d2/link3')
 
616
            runbzr('diff')
 
617
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
 
618
    
 
619
            os.unlink("link2")
 
620
            os.symlink("TARGET 2", "link2")
 
621
            os.unlink("d2/link1")
 
622
            os.symlink("TARGET 1", "d2/link1")
 
623
            runbzr('diff')
 
624
            assert self.capture("relpath d2/link1") == "d2/link1\n"
 
625
            runbzr(['commit', '-m', '4: retarget of two links'])
 
626
    
 
627
            runbzr('remove d2/link1')
 
628
            assert self.capture('unknowns') == 'd2/link1\n'
 
629
            runbzr(['commit', '-m', '5: remove d2/link1'])
 
630
    
 
631
            os.mkdir("d1")
 
632
            runbzr('add d1')
 
633
            runbzr('rename d2/link3 d1/link3new')
 
634
            assert self.capture('unknowns') == 'd2/link1\n'
 
635
            runbzr(['commit', '-m', '6: remove d2/link1, move/rename link3'])
 
636
            
 
637
            runbzr(['check'])
 
638
            
 
639
            runbzr(['export', '-r', '1', 'exp1.tmp'])
 
640
            chdir("exp1.tmp")
 
641
            assert listdir_sorted(".") == [ "link1" ]
 
642
            assert os.readlink("link1") == "NOWHERE1"
 
643
            chdir("..")
 
644
            
 
645
            runbzr(['export', '-r', '2', 'exp2.tmp'])
 
646
            chdir("exp2.tmp")
 
647
            assert listdir_sorted(".") == [ "d1", "link1" ]
 
648
            chdir("..")
 
649
            
 
650
            runbzr(['export', '-r', '3', 'exp3.tmp'])
 
651
            chdir("exp3.tmp")
 
652
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
653
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
654
            assert os.readlink("d2/link1") == "NOWHERE1"
 
655
            assert os.readlink("link2")    == "NOWHERE2"
 
656
            chdir("..")
 
657
            
 
658
            runbzr(['export', '-r', '4', 'exp4.tmp'])
 
659
            chdir("exp4.tmp")
 
660
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
661
            assert os.readlink("d2/link1") == "TARGET 1"
 
662
            assert os.readlink("link2")    == "TARGET 2"
 
663
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
664
            chdir("..")
 
665
            
 
666
            runbzr(['export', '-r', '5', 'exp5.tmp'])
 
667
            chdir("exp5.tmp")
 
668
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
669
            assert os.path.islink("link2")
 
670
            assert listdir_sorted("d2")== [ "link3" ]
 
671
            chdir("..")
 
672
            
 
673
            runbzr(['export', '-r', '6', 'exp6.tmp'])
 
674
            chdir("exp6.tmp")
 
675
            assert listdir_sorted(".") == [ "d1", "d2", "link2" ]
 
676
            assert listdir_sorted("d1") == [ "link3new" ]
 
677
            assert listdir_sorted("d2") == []
 
678
            assert os.readlink("d1/link3new") == "NOWHERE3"
 
679
            chdir("..")
 
680
        else:
 
681
            progress("skipping symlink tests")
 
682