← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

Refactored the export code to make it easier to add new export formats.

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 re
 
30
import shutil
29
31
import sys
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):
58
62
    def test_init_branch(self):
59
63
        self.runbzr(['init'])
60
64
 
 
65
        # Can it handle subdirectories as well?
 
66
        self.runbzr('init subdir1')
 
67
        self.assert_(os.path.exists('subdir1'))
 
68
        self.assert_(os.path.exists('subdir1/.bzr'))
 
69
 
 
70
        self.runbzr('init subdir2/nothere', retcode=2)
 
71
        
 
72
        os.mkdir('subdir2')
 
73
        self.runbzr('init subdir2')
 
74
        self.runbzr('init subdir2', retcode=1)
 
75
 
 
76
        self.runbzr('init subdir2/subsubdir1')
 
77
        self.assert_(os.path.exists('subdir2/subsubdir1/.bzr'))
 
78
 
61
79
    def test_whoami(self):
62
80
        # this should always identify something, if only "john@localhost"
63
81
        self.runbzr("whoami")
72
90
        f = file('.bzr/email', 'wt')
73
91
        f.write('Branch Identity <branch@identi.ty>')
74
92
        f.close()
 
93
        bzr_email = os.environ.get('BZREMAIL')
 
94
        if bzr_email is not None:
 
95
            del os.environ['BZREMAIL']
75
96
        whoami = self.runbzr("whoami",backtick=True)
76
97
        whoami_email = self.runbzr("whoami --email",backtick=True)
77
98
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
78
99
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
 
100
        # Verify that the environment variable overrides the value 
 
101
        # in the file
 
102
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
 
103
        whoami = self.runbzr("whoami",backtick=True)
 
104
        whoami_email = self.runbzr("whoami --email",backtick=True)
 
105
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
 
106
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
 
107
        if bzr_email is not None:
 
108
            os.environ['BZREMAIL'] = bzr_email
79
109
 
80
110
    def test_invalid_commands(self):
81
111
        self.runbzr("pants", retcode=1)
89
119
        self.runbzr("add hello.txt")
90
120
        self.runbzr("commit -m added")
91
121
 
 
122
    def test_empty_commit_message(self):
 
123
        self.runbzr("init")
 
124
        file('foo.c', 'wt').write('int main() {}')
 
125
        self.runbzr(['add', 'foo.c'])
 
126
        self.runbzr(["commit", "-m", ""] , retcode=1) 
 
127
 
 
128
    def test_other_branch_commit(self):
 
129
        # this branch is to ensure consistent behaviour, whether we're run
 
130
        # inside a branch, or not.
 
131
        os.mkdir('empty_branch')
 
132
        os.chdir('empty_branch')
 
133
        self.runbzr('init')
 
134
        os.mkdir('branch')
 
135
        os.chdir('branch')
 
136
        self.runbzr('init')
 
137
        file('foo.c', 'wt').write('int main() {}')
 
138
        file('bar.c', 'wt').write('int main() {}')
 
139
        os.chdir('..')
 
140
        self.runbzr(['add', 'branch/foo.c'])
 
141
        self.runbzr(['add', 'branch'])
 
142
        # can't commit files in different trees; sane error
 
143
        self.runbzr('commit -m newstuff branch/foo.c .', retcode=1)
 
144
        self.runbzr('commit -m newstuff branch/foo.c')
 
145
        self.runbzr('commit -m newstuff branch')
 
146
        self.runbzr('commit -m newstuff branch', retcode=1)
 
147
 
 
148
 
92
149
    def test_ignore_patterns(self):
93
150
        from bzrlib.branch import Branch
94
151
        
97
154
 
98
155
        file('foo.tmp', 'wt').write('tmp files are ignored')
99
156
        self.assertEquals(list(b.unknowns()), [])
100
 
        assert self.backtick('bzr unknowns') == ''
 
157
        self.assertEquals(self.capture('unknowns'), '')
101
158
 
102
159
        file('foo.c', 'wt').write('int main() {}')
103
160
        self.assertEquals(list(b.unknowns()), ['foo.c'])
104
 
        assert self.backtick('bzr unknowns') == 'foo.c\n'
 
161
        self.assertEquals(self.capture('unknowns'), 'foo.c\n')
105
162
 
106
163
        self.runbzr(['add', 'foo.c'])
107
 
        assert self.backtick('bzr unknowns') == ''
 
164
        self.assertEquals(self.capture('unknowns'), '')
108
165
 
109
166
        # 'ignore' works when creating the .bzignore file
110
167
        file('foo.blah', 'wt').write('blah')
111
168
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
112
169
        self.runbzr('ignore *.blah')
113
170
        self.assertEquals(list(b.unknowns()), [])
114
 
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
 
171
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')
115
172
 
116
173
        # 'ignore' works when then .bzrignore file already exists
117
174
        file('garh', 'wt').write('garh')
118
175
        self.assertEquals(list(b.unknowns()), ['garh'])
119
 
        assert self.backtick('bzr unknowns') == 'garh\n'
 
176
        self.assertEquals(self.capture('unknowns'), 'garh\n')
120
177
        self.runbzr('ignore garh')
121
178
        self.assertEquals(list(b.unknowns()), [])
122
 
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
 
179
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')
123
180
 
124
181
    def test_revert(self):
125
 
        import os
126
182
        self.runbzr('init')
127
183
 
128
184
        file('hello', 'wt').write('foo')
132
188
        file('goodbye', 'wt').write('baz')
133
189
        self.runbzr('add goodbye')
134
190
        self.runbzr('commit -m setup goodbye')
135
 
        
 
191
 
136
192
        file('hello', 'wt').write('bar')
137
193
        file('goodbye', 'wt').write('qux')
138
194
        self.runbzr('revert hello')
147
203
        os.rmdir('revertdir')
148
204
        self.runbzr('revert')
149
205
 
150
 
    def skipped_test_mv_modes(self):
 
206
        os.symlink('/unlikely/to/exist', 'symlink')
 
207
        self.runbzr('add symlink')
 
208
        self.runbzr('commit -m f')
 
209
        os.unlink('symlink')
 
210
        self.runbzr('revert')
 
211
        self.failUnlessExists('symlink')
 
212
        os.unlink('symlink')
 
213
        os.symlink('a-different-path', 'symlink')
 
214
        self.runbzr('revert')
 
215
        self.assertEqual('/unlikely/to/exist',
 
216
                         os.readlink('symlink'))
 
217
        
 
218
        file('hello', 'wt').write('xyz')
 
219
        self.runbzr('commit -m xyz hello')
 
220
        self.runbzr('revert -r 1 hello')
 
221
        self.check_file_contents('hello', 'foo')
 
222
        self.runbzr('revert hello')
 
223
        self.check_file_contents('hello', 'xyz')
 
224
        os.chdir('revertdir')
 
225
        self.runbzr('revert')
 
226
        os.chdir('..')
 
227
 
 
228
 
 
229
    def test_mv_modes(self):
151
230
        """Test two modes of operation for mv"""
152
231
        from bzrlib.branch import Branch
153
232
        b = Branch.initialize('.')
154
233
        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')
 
234
        self.run_bzr_captured(['add', self.test_dir])
 
235
        self.run_bzr_captured(['mv', 'a', 'b'])
 
236
        self.run_bzr_captured(['mv', 'b', 'subdir'])
 
237
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
 
238
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
 
239
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
160
240
 
161
241
    def test_main_version(self):
162
242
        """Check output from version command and master option is reasonable"""
182
262
        test.runbzr('add goodbye')
183
263
        test.runbzr('commit -m setup goodbye')
184
264
 
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')
 
265
    def test_export(self):
 
266
        os.mkdir('branch')
 
267
        os.chdir('branch')
 
268
        self.example_branch()
 
269
        self.runbzr('export ../latest')
 
270
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
 
271
        self.runbzr('export ../first -r 1')
 
272
        self.assert_(not os.path.exists('../first/goodbye'))
 
273
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
 
274
        self.runbzr('export ../first.gz -r 1')
 
275
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
 
276
        self.runbzr('export ../first.bz2 -r 1')
 
277
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
 
278
        self.runbzr('export ../first.tar -r 1')
 
279
        self.assert_(os.path.isfile('../first.tar'))
 
280
        from tarfile import TarFile
 
281
        tf = TarFile('../first.tar')
 
282
        self.assert_('first/hello' in tf.getnames(), tf.getnames())
 
283
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
 
284
        self.runbzr('export ../first.tar.gz -r 1')
 
285
        self.assert_(os.path.isfile('../first.tar.gz'))
 
286
        self.runbzr('export ../first.tbz2 -r 1')
 
287
        self.assert_(os.path.isfile('../first.tbz2'))
 
288
        self.runbzr('export ../first.tar.bz2 -r 1')
 
289
        self.assert_(os.path.isfile('../first.tar.bz2'))
 
290
        self.runbzr('export ../first.tar.tbz2 -r 1')
 
291
        self.assert_(os.path.isfile('../first.tar.tbz2'))
 
292
        from bz2 import BZ2File
 
293
        tf = TarFile('../first.tar.tbz2', 
 
294
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
 
295
        self.assert_('first.tar/hello' in tf.getnames(), tf.getnames())
 
296
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
 
297
        self.runbzr('export ../first2.tar -r 1 --root pizza')
 
298
        tf = TarFile('../first2.tar')
 
299
        self.assert_('pizza/hello' in tf.getnames(), tf.getnames())
 
300
 
 
301
    def test_diff(self):
 
302
        self.example_branch()
 
303
        file('hello', 'wt').write('hello world!')
 
304
        self.runbzr('commit -m fixing hello')
 
305
        output = self.runbzr('diff -r 2..3', backtick=1, retcode=1)
 
306
        self.assert_('\n+hello world!' in output)
 
307
        output = self.runbzr('diff -r last:3..last:1', backtick=1, retcode=1)
 
308
        self.assert_('\n+baz' in output)
 
309
 
 
310
    def test_diff_branches(self):
 
311
        self.build_tree(['branch1/', 'branch1/file', 'branch2/'])
 
312
        branch = Branch.initialize('branch1')
 
313
        branch.add(['file'])
 
314
        branch.working_tree().commit('add file')
 
315
        copy_branch(branch, 'branch2')
 
316
        print >> open('branch2/file', 'w'), 'new content'
 
317
        branch2 = Branch.open('branch2')
 
318
        branch2.working_tree().commit('update file')
 
319
        # should open branch1 and diff against branch2, 
 
320
        output = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 
 
321
                                        'branch1'],
 
322
                                       retcode=1)
 
323
        self.assertEquals(("=== modified file 'file'\n"
 
324
                           "--- file\n"
 
325
                           "+++ file\n"
 
326
                           "@@ -1,1 +1,1 @@\n"
 
327
                           "-new content\n"
 
328
                           "+contents of branch1/file\n"
 
329
                           "\n", ''), output)
 
330
 
 
331
    def test_branch(self):
 
332
        """Branch from one branch to another."""
 
333
        os.mkdir('a')
 
334
        os.chdir('a')
 
335
        self.example_branch()
 
336
        os.chdir('..')
 
337
        self.runbzr('branch a b')
 
338
        self.assertFileEqual('b\n', 'b/.bzr/branch-name')
 
339
        self.runbzr('branch a c -r 1')
 
340
        os.chdir('b')
 
341
        self.runbzr('commit -m foo --unchanged')
 
342
        os.chdir('..')
 
343
        # naughty - abstraction violations RBC 20050928  
 
344
        print "test_branch used to delete the stores, how is this meant to work ?"
 
345
        #shutil.rmtree('a/.bzr/revision-store')
 
346
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
347
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
348
        self.runbzr('branch a d --basis b')
194
349
 
195
350
    def test_merge(self):
196
351
        from bzrlib.branch import Branch
197
 
        import os
198
352
        
199
353
        os.mkdir('a')
200
354
        os.chdir('a')
201
 
 
202
355
        self.example_branch()
203
356
        os.chdir('..')
204
357
        self.runbzr('branch a b')
211
364
        # We can't merge when there are in-tree changes
212
365
        self.runbzr('merge ../b', retcode=1)
213
366
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
214
 
        self.runbzr('merge ../b')
 
367
        self.runbzr('merge ../b -r last:1..last:1 --merge-type blooof',
 
368
                    retcode=1)
 
369
        self.runbzr('merge ../b -r last:1..last:1 --merge-type merge3')
 
370
        self.runbzr('revert --no-backup')
 
371
        self.runbzr('merge ../b -r last:1..last:1 --merge-type weave')
 
372
        self.runbzr('revert --no-backup')
 
373
        self.runbzr('merge ../b -r last:1..last:1 --reprocess')
 
374
        self.runbzr('revert --no-backup')
 
375
        self.runbzr('merge ../b -r last:1')
215
376
        self.check_file_contents('goodbye', 'quux')
216
377
        # Merging a branch pulls its revision into the tree
217
378
        a = Branch.open('.')
218
379
        b = Branch.open('../b')
219
 
        a.get_revision_xml(b.last_patch())
220
 
 
221
 
        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
 
 
 
380
        a.get_revision_xml(b.last_revision())
 
381
        self.log('pending merges: %s', a.working_tree().pending_merges())
 
382
        self.assertEquals(a.working_tree().pending_merges(),
 
383
                          [b.last_revision()])
 
384
        self.runbzr('commit -m merged')
 
385
        self.runbzr('merge ../b -r last:1')
 
386
        self.assertEqual(Branch.open('.').working_tree().pending_merges(), [])
 
387
 
 
388
    def test_merge_with_missing_file(self):
 
389
        """Merge handles missing file conflicts"""
 
390
        os.mkdir('a')
 
391
        os.chdir('a')
 
392
        os.mkdir('sub')
 
393
        print >> file('sub/a.txt', 'wb'), "hello"
 
394
        print >> file('b.txt', 'wb'), "hello"
 
395
        print >> file('sub/c.txt', 'wb'), "hello"
 
396
        self.runbzr('init')
 
397
        self.runbzr('add')
 
398
        self.runbzr(('commit', '-m', 'added a'))
 
399
        self.runbzr('branch . ../b')
 
400
        print >> file('sub/a.txt', 'ab'), "there"
 
401
        print >> file('b.txt', 'ab'), "there"
 
402
        print >> file('sub/c.txt', 'ab'), "there"
 
403
        self.runbzr(('commit', '-m', 'Added there'))
 
404
        os.unlink('sub/a.txt')
 
405
        os.unlink('sub/c.txt')
 
406
        os.rmdir('sub')
 
407
        os.unlink('b.txt')
 
408
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
409
        os.chdir('../b')
 
410
        print >> file('sub/a.txt', 'ab'), "something"
 
411
        print >> file('b.txt', 'ab'), "something"
 
412
        print >> file('sub/c.txt', 'ab'), "something"
 
413
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
414
        self.runbzr('merge ../a/', retcode=1)
 
415
        self.assert_(os.path.exists('sub/a.txt.THIS'))
 
416
        self.assert_(os.path.exists('sub/a.txt.BASE'))
 
417
        os.chdir('../a')
 
418
        self.runbzr('merge ../b/', retcode=1)
 
419
        self.assert_(os.path.exists('sub/a.txt.OTHER'))
 
420
        self.assert_(os.path.exists('sub/a.txt.BASE'))
 
421
 
 
422
    def test_pull(self):
 
423
        """Pull changes from one branch to another."""
 
424
        os.mkdir('a')
 
425
        os.chdir('a')
 
426
 
 
427
        self.example_branch()
 
428
        self.runbzr('pull', retcode=1)
 
429
        self.runbzr('missing', retcode=1)
 
430
        self.runbzr('missing .')
 
431
        self.runbzr('missing')
 
432
        self.runbzr('pull')
 
433
        self.runbzr('pull /', retcode=1)
 
434
        self.runbzr('pull')
 
435
 
 
436
        os.chdir('..')
 
437
        self.runbzr('branch a b')
 
438
        os.chdir('b')
 
439
        self.runbzr('pull')
 
440
        os.mkdir('subdir')
 
441
        self.runbzr('add subdir')
 
442
        self.runbzr('commit -m blah --unchanged')
 
443
        os.chdir('../a')
 
444
        a = Branch.open('.')
 
445
        b = Branch.open('../b')
 
446
        self.assertEquals(a.revision_history(), b.revision_history()[:-1])
 
447
        self.runbzr('pull ../b')
 
448
        self.assertEquals(a.revision_history(), b.revision_history())
 
449
        self.runbzr('commit -m blah2 --unchanged')
 
450
        os.chdir('../b')
 
451
        self.runbzr('commit -m blah3 --unchanged')
 
452
        # no overwrite
 
453
        self.runbzr('pull ../a', retcode=1)
 
454
        os.chdir('..')
 
455
        self.runbzr('branch b overwriteme')
 
456
        os.chdir('overwriteme')
 
457
        self.runbzr('pull --overwrite ../a')
 
458
        overwritten = Branch.open('.')
 
459
        self.assertEqual(overwritten.revision_history(),
 
460
                         a.revision_history())
 
461
        os.chdir('../a')
 
462
        self.runbzr('merge ../b')
 
463
        self.runbzr('commit -m blah4 --unchanged')
 
464
        os.chdir('../b/subdir')
 
465
        self.runbzr('pull ../../a')
 
466
        self.assertEquals(a.revision_history()[-1], b.revision_history()[-1])
 
467
        self.runbzr('commit -m blah5 --unchanged')
 
468
        self.runbzr('commit -m blah6 --unchanged')
 
469
        os.chdir('..')
 
470
        self.runbzr('pull ../a')
 
471
        os.chdir('../a')
 
472
        self.runbzr('commit -m blah7 --unchanged')
 
473
        self.runbzr('merge ../b')
 
474
        self.runbzr('commit -m blah8 --unchanged')
 
475
        self.runbzr('pull ../b')
 
476
        self.runbzr('pull ../b')
 
477
 
 
478
    def test_ls(self):
 
479
        """Test the abilities of 'bzr ls'"""
 
480
        bzr = self.runbzr
 
481
        def bzrout(*args, **kwargs):
 
482
            kwargs['backtick'] = True
 
483
            return self.runbzr(*args, **kwargs)
 
484
 
 
485
        def ls_equals(value, *args):
 
486
            out = self.runbzr(['ls'] + list(args), backtick=True)
 
487
            self.assertEquals(out, value)
 
488
 
 
489
        bzr('init')
 
490
        open('a', 'wb').write('hello\n')
 
491
 
 
492
        # Can't supply both
 
493
        bzr('ls --verbose --null', retcode=1)
 
494
 
 
495
        ls_equals('a\n')
 
496
        ls_equals('?        a\n', '--verbose')
 
497
        ls_equals('a\n', '--unknown')
 
498
        ls_equals('', '--ignored')
 
499
        ls_equals('', '--versioned')
 
500
        ls_equals('a\n', '--unknown', '--ignored', '--versioned')
 
501
        ls_equals('', '--ignored', '--versioned')
 
502
        ls_equals('a\0', '--null')
 
503
 
 
504
        bzr('add a')
 
505
        ls_equals('V        a\n', '--verbose')
 
506
        bzr('commit -m add')
 
507
        
 
508
        os.mkdir('subdir')
 
509
        ls_equals('V        a\n'
 
510
                  '?        subdir/\n'
 
511
                  , '--verbose')
 
512
        open('subdir/b', 'wb').write('b\n')
 
513
        bzr('add')
 
514
        ls_equals('V        a\n'
 
515
                  'V        subdir/\n'
 
516
                  'V        subdir/b\n'
 
517
                  , '--verbose')
 
518
        bzr('commit -m subdir')
 
519
 
 
520
        ls_equals('a\n'
 
521
                  'subdir\n'
 
522
                  , '--non-recursive')
 
523
 
 
524
        ls_equals('V        a\n'
 
525
                  'V        subdir/\n'
 
526
                  , '--verbose', '--non-recursive')
 
527
 
 
528
        # Check what happens in a sub-directory
 
529
        os.chdir('subdir')
 
530
        ls_equals('b\n')
 
531
        ls_equals('b\0'
 
532
                  , '--null')
 
533
        ls_equals('a\n'
 
534
                  'subdir\n'
 
535
                  'subdir/b\n'
 
536
                  , '--from-root')
 
537
        ls_equals('a\0'
 
538
                  'subdir\0'
 
539
                  'subdir/b\0'
 
540
                  , '--from-root', '--null')
 
541
        ls_equals('a\n'
 
542
                  'subdir\n'
 
543
                  , '--from-root', '--non-recursive')
 
544
 
 
545
        os.chdir('..')
 
546
 
 
547
        # Check what happens when we supply a specific revision
 
548
        ls_equals('a\n', '--revision', '1')
 
549
        ls_equals('V        a\n'
 
550
                  , '--verbose', '--revision', '1')
 
551
 
 
552
        os.chdir('subdir')
 
553
        ls_equals('', '--revision', '1')
 
554
 
 
555
        # Now try to do ignored files.
 
556
        os.chdir('..')
 
557
        open('blah.py', 'wb').write('unknown\n')
 
558
        open('blah.pyo', 'wb').write('ignored\n')
 
559
        ls_equals('a\n'
 
560
                  'blah.py\n'
 
561
                  'blah.pyo\n'
 
562
                  'subdir\n'
 
563
                  'subdir/b\n')
 
564
        ls_equals('V        a\n'
 
565
                  '?        blah.py\n'
 
566
                  'I        blah.pyo\n'
 
567
                  'V        subdir/\n'
 
568
                  'V        subdir/b\n'
 
569
                  , '--verbose')
 
570
        ls_equals('blah.pyo\n'
 
571
                  , '--ignored')
 
572
        ls_equals('blah.py\n'
 
573
                  , '--unknown')
 
574
        ls_equals('a\n'
 
575
                  'subdir\n'
 
576
                  'subdir/b\n'
 
577
                  , '--versioned')
 
578
 
 
579
    def test_pull_verbose(self):
 
580
        """Pull changes from one branch to another and watch the output."""
 
581
 
 
582
        os.mkdir('a')
 
583
        os.chdir('a')
 
584
 
 
585
        bzr = self.runbzr
 
586
        self.example_branch()
 
587
 
 
588
        os.chdir('..')
 
589
        bzr('branch a b')
 
590
        os.chdir('b')
 
591
        open('b', 'wb').write('else\n')
 
592
        bzr('add b')
 
593
        bzr(['commit', '-m', 'added b'])
 
594
 
 
595
        os.chdir('../a')
 
596
        out = bzr('pull --verbose ../b', backtick=True)
 
597
        self.failIfEqual(out.find('Added Revisions:'), -1)
 
598
        self.failIfEqual(out.find('message:\n  added b'), -1)
 
599
        self.failIfEqual(out.find('added:\n  b'), -1)
 
600
 
 
601
        # Check that --overwrite --verbose prints out the removed entries
 
602
        bzr('commit -m foo --unchanged')
 
603
        os.chdir('../b')
 
604
        bzr('commit -m baz --unchanged')
 
605
        bzr('pull ../a', retcode=1)
 
606
        out = bzr('pull --overwrite --verbose ../a', backtick=1)
 
607
 
 
608
        remove_loc = out.find('Removed Revisions:')
 
609
        self.failIfEqual(remove_loc, -1)
 
610
        added_loc = out.find('Added Revisions:')
 
611
        self.failIfEqual(added_loc, -1)
 
612
 
 
613
        removed_message = out.find('message:\n  baz')
 
614
        self.failIfEqual(removed_message, -1)
 
615
        self.failUnless(remove_loc < removed_message < added_loc)
 
616
 
 
617
        added_message = out.find('message:\n  foo')
 
618
        self.failIfEqual(added_message, -1)
 
619
        self.failUnless(added_loc < added_message)
 
620
        
 
621
    def test_locations(self):
 
622
        """Using and remembering different locations"""
 
623
        os.mkdir('a')
 
624
        os.chdir('a')
 
625
        self.runbzr('init')
 
626
        self.runbzr('commit -m unchanged --unchanged')
 
627
        self.runbzr('pull', retcode=1)
 
628
        self.runbzr('merge', retcode=1)
 
629
        self.runbzr('branch . ../b')
 
630
        os.chdir('../b')
 
631
        self.runbzr('pull')
 
632
        self.runbzr('branch . ../c')
 
633
        self.runbzr('pull ../c')
 
634
        self.runbzr('merge')
 
635
        os.chdir('../a')
 
636
        self.runbzr('pull ../b')
 
637
        self.runbzr('pull')
 
638
        self.runbzr('pull ../c')
 
639
        self.runbzr('branch ../c ../d')
 
640
        shutil.rmtree('../c')
 
641
        self.runbzr('pull')
 
642
        os.chdir('../b')
 
643
        self.runbzr('pull')
 
644
        os.chdir('../d')
 
645
        self.runbzr('pull', retcode=1)
 
646
        self.runbzr('pull ../a --remember')
 
647
        self.runbzr('pull')
 
648
        
226
649
    def test_add_reports(self):
227
650
        """add command prints the names of added files."""
228
651
        b = Branch.initialize('.')
229
652
        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
 
 
 
653
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
239
654
        # the ordering is not defined at the moment
240
 
        results = sorted(out.getvalue().rstrip('\n').split('\n'))
 
655
        results = sorted(out.rstrip('\n').split('\n'))
241
656
        self.assertEquals(['added dir',
242
 
                           'added dir/sub.txt',
 
657
                           'added dir'+os.sep+'sub.txt',
243
658
                           'added top.txt',],
244
659
                          results)
245
660
 
 
661
    def test_add_quiet_is(self):
 
662
        """add -q does not print the names of added files."""
 
663
        b = Branch.initialize('.')
 
664
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
665
        out = self.run_bzr_captured(['add', '-q'], retcode = 0)[0]
 
666
        # the ordering is not defined at the moment
 
667
        results = sorted(out.rstrip('\n').split('\n'))
 
668
        self.assertEquals([''], results)
 
669
 
 
670
    def test_unknown_command(self):
 
671
        """Handling of unknown command."""
 
672
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
673
                                         retcode=1)
 
674
        self.assertEquals(out, '')
 
675
        err.index('unknown command')
 
676
 
 
677
    def test_conflicts(self):
 
678
        """Handling of merge conflicts"""
 
679
        os.mkdir('base')
 
680
        os.chdir('base')
 
681
        file('hello', 'wb').write("hi world")
 
682
        file('answer', 'wb').write("42")
 
683
        self.runbzr('init')
 
684
        self.runbzr('add')
 
685
        self.runbzr('commit -m base')
 
686
        self.runbzr('branch . ../other')
 
687
        self.runbzr('branch . ../this')
 
688
        os.chdir('../other')
 
689
        file('hello', 'wb').write("Hello.")
 
690
        file('answer', 'wb').write("Is anyone there?")
 
691
        self.runbzr('commit -m other')
 
692
        os.chdir('../this')
 
693
        file('hello', 'wb').write("Hello, world")
 
694
        self.runbzr('mv answer question')
 
695
        file('question', 'wb').write("What do you get when you multiply six"
 
696
                                   "times nine?")
 
697
        self.runbzr('commit -m this')
 
698
        self.runbzr('merge ../other --show-base', retcode=1)
 
699
        conflict_text = file('hello').read()
 
700
        self.assert_('<<<<<<<' in conflict_text)
 
701
        self.assert_('>>>>>>>' in conflict_text)
 
702
        self.assert_('=======' in conflict_text)
 
703
        self.assert_('|||||||' in conflict_text)
 
704
        self.assert_('hi world' in conflict_text)
 
705
        self.runbzr('revert')
 
706
        self.runbzr('resolve --all')
 
707
        self.runbzr('merge ../other', retcode=1)
 
708
        conflict_text = file('hello').read()
 
709
        self.assert_('|||||||' not in conflict_text)
 
710
        self.assert_('hi world' not in conflict_text)
 
711
        result = self.runbzr('conflicts', backtick=1)
 
712
        self.assertEquals(result, "hello\nquestion\n")
 
713
        result = self.runbzr('status', backtick=1)
 
714
        self.assert_("conflicts:\n  hello\n  question\n" in result, result)
 
715
        self.runbzr('resolve hello')
 
716
        result = self.runbzr('conflicts', backtick=1)
 
717
        self.assertEquals(result, "question\n")
 
718
        self.runbzr('commit -m conflicts', retcode=1)
 
719
        self.runbzr('resolve --all')
 
720
        result = self.runbzr('conflicts', backtick=1)
 
721
        self.runbzr('commit -m conflicts')
 
722
        self.assertEquals(result, "")
 
723
 
 
724
    def test_resign(self):
 
725
        """Test re signing of data."""
 
726
        import bzrlib.gpg
 
727
        oldstrategy = bzrlib.gpg.GPGStrategy
 
728
        branch = Branch.initialize('.')
 
729
        branch.working_tree().commit("base", allow_pointless=True, rev_id='A')
 
730
        try:
 
731
            # monkey patch gpg signing mechanism
 
732
            from bzrlib.testament import Testament
 
733
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
 
734
            self.runbzr('re-sign -r revid:A')
 
735
            self.assertEqual(Testament.from_revision(branch,'A').as_short_text(),
 
736
                             branch.revision_store.get('A', 'sig').read())
 
737
        finally:
 
738
            bzrlib.gpg.GPGStrategy = oldstrategy
 
739
            
 
740
    def test_resign_range(self):
 
741
        import bzrlib.gpg
 
742
        oldstrategy = bzrlib.gpg.GPGStrategy
 
743
        branch = Branch.initialize('.')
 
744
        branch.working_tree().commit("base", allow_pointless=True, rev_id='A')
 
745
        branch.working_tree().commit("base", allow_pointless=True, rev_id='B')
 
746
        branch.working_tree().commit("base", allow_pointless=True, rev_id='C')
 
747
        try:
 
748
            # monkey patch gpg signing mechanism
 
749
            from bzrlib.testament import Testament
 
750
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
 
751
            self.runbzr('re-sign -r 1..')
 
752
            self.assertEqual(Testament.from_revision(branch,'A').as_short_text(),
 
753
                             branch.revision_store.get('A', 'sig').read())
 
754
            self.assertEqual(Testament.from_revision(branch,'B').as_short_text(),
 
755
                             branch.revision_store.get('B', 'sig').read())
 
756
            self.assertEqual(Testament.from_revision(branch,'C').as_short_text(),
 
757
                             branch.revision_store.get('C', 'sig').read())
 
758
        finally:
 
759
            bzrlib.gpg.GPGStrategy = oldstrategy
 
760
 
 
761
    def test_push(self):
 
762
        # create a source branch
 
763
        os.mkdir('my-branch')
 
764
        os.chdir('my-branch')
 
765
        self.example_branch()
 
766
 
 
767
        # with no push target, fail
 
768
        self.runbzr('push', retcode=1)
 
769
        # with an explicit target work
 
770
        self.runbzr('push ../output-branch')
 
771
        # with an implicit target work
 
772
        self.runbzr('push')
 
773
        # nothing missing
 
774
        self.runbzr('missing ../output-branch')
 
775
        # advance this branch
 
776
        self.runbzr('commit --unchanged -m unchanged')
 
777
 
 
778
        os.chdir('../output-branch')
 
779
        # should be a diff as we have not pushed the tree
 
780
        self.runbzr('diff', retcode=1)
 
781
        self.runbzr('revert')
 
782
        # but not now.
 
783
        self.runbzr('diff')
 
784
        # diverge the branches
 
785
        self.runbzr('commit --unchanged -m unchanged')
 
786
        os.chdir('../my-branch')
 
787
        # cannot push now
 
788
        self.runbzr('push', retcode=1)
 
789
        # and there are difference
 
790
        self.runbzr('missing ../output-branch', retcode=1)
 
791
        # but we can force a push
 
792
        self.runbzr('push --overwrite')
 
793
        # nothing missing
 
794
        self.runbzr('missing ../output-branch')
 
795
        
 
796
        # pushing to a new dir with no parent should fail
 
797
        self.runbzr('push ../missing/new-branch', retcode=1)
 
798
        # unless we provide --create-prefix
 
799
        self.runbzr('push --create-prefix ../missing/new-branch')
 
800
        # nothing missing
 
801
        self.runbzr('missing ../missing/new-branch')
 
802
 
 
803
    def test_external_command(self):
 
804
        """test that external commands can be run by setting the path"""
 
805
        cmd_name = 'test-command'
 
806
        output = 'Hello from test-command'
 
807
        if sys.platform == 'win32':
 
808
            cmd_name += '.bat'
 
809
            output += '\r\n'
 
810
        else:
 
811
            output += '\n'
 
812
 
 
813
        oldpath = os.environ.get('BZRPATH', None)
 
814
 
 
815
        bzr = self.capture
 
816
 
 
817
        try:
 
818
            if os.environ.has_key('BZRPATH'):
 
819
                del os.environ['BZRPATH']
 
820
 
 
821
            f = file(cmd_name, 'wb')
 
822
            if sys.platform == 'win32':
 
823
                f.write('@echo off\n')
 
824
            else:
 
825
                f.write('#!/bin/sh\n')
 
826
            f.write('echo Hello from test-command')
 
827
            f.close()
 
828
            os.chmod(cmd_name, 0755)
 
829
 
 
830
            # It should not find the command in the local 
 
831
            # directory by default, since it is not in my path
 
832
            bzr(cmd_name, retcode=1)
 
833
 
 
834
            # Now put it into my path
 
835
            os.environ['BZRPATH'] = '.'
 
836
 
 
837
            bzr(cmd_name)
 
838
            # The test suite does not capture stdout for external commands
 
839
            # this is because you have to have a real file object
 
840
            # to pass to Popen(stdout=FOO), and StringIO is not one of those.
 
841
            # (just replacing sys.stdout does not change a spawned objects stdout)
 
842
            #self.assertEquals(bzr(cmd_name), output)
 
843
 
 
844
            # Make sure empty path elements are ignored
 
845
            os.environ['BZRPATH'] = os.pathsep
 
846
 
 
847
            bzr(cmd_name, retcode=1)
 
848
 
 
849
        finally:
 
850
            if oldpath:
 
851
                os.environ['BZRPATH'] = oldpath
 
852
 
 
853
 
 
854
 
 
855
 
 
856
 
 
857
def listdir_sorted(dir):
 
858
    L = os.listdir(dir)
 
859
    L.sort()
 
860
    return L
 
861
 
246
862
 
247
863
class OldTests(ExternalBase):
248
864
    """old tests moved from ./testbzr."""
250
866
    def test_bzr(self):
251
867
        from os import chdir, mkdir
252
868
        from os.path import exists
253
 
        import os
254
869
 
255
870
        runbzr = self.runbzr
256
 
        backtick = self.backtick
 
871
        capture = self.capture
257
872
        progress = self.log
258
873
 
259
874
        progress("basic branch creation")
261
876
        chdir('branch1')
262
877
        runbzr('init')
263
878
 
264
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
879
        self.assertEquals(capture('root').rstrip(),
265
880
                          os.path.join(self.test_dir, 'branch1'))
266
881
 
267
882
        progress("status of new file")
270
885
        f.write('hello world!\n')
271
886
        f.close()
272
887
 
273
 
        out = backtick("bzr unknowns")
274
 
        self.assertEquals(out, 'test.txt\n')
275
 
 
276
 
        out = backtick("bzr status")
277
 
        assert out == 'unknown:\n  test.txt\n'
278
 
 
279
 
        out = backtick("bzr status --all")
280
 
        assert out == "unknown:\n  test.txt\n"
281
 
 
282
 
        out = backtick("bzr status test.txt --all")
283
 
        assert out == "unknown:\n  test.txt\n"
 
888
        self.assertEquals(capture('unknowns'), 'test.txt\n')
 
889
 
 
890
        out = capture("status")
 
891
        self.assertEquals(out, 'unknown:\n  test.txt\n')
 
892
 
 
893
        out = capture("status --all")
 
894
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
895
 
 
896
        out = capture("status test.txt --all")
 
897
        self.assertEquals(out, "unknown:\n  test.txt\n")
284
898
 
285
899
        f = file('test2.txt', 'wt')
286
900
        f.write('goodbye cruel world...\n')
287
901
        f.close()
288
902
 
289
 
        out = backtick("bzr status test.txt")
290
 
        assert out == "unknown:\n  test.txt\n"
 
903
        out = capture("status test.txt")
 
904
        self.assertEquals(out, "unknown:\n  test.txt\n")
291
905
 
292
 
        out = backtick("bzr status")
293
 
        assert out == ("unknown:\n"
294
 
                       "  test.txt\n"
295
 
                       "  test2.txt\n")
 
906
        out = capture("status")
 
907
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
296
908
 
297
909
        os.unlink('test2.txt')
298
910
 
299
911
        progress("command aliases")
300
 
        out = backtick("bzr st --all")
301
 
        assert out == ("unknown:\n"
302
 
                       "  test.txt\n")
 
912
        out = capture("st --all")
 
913
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
303
914
 
304
 
        out = backtick("bzr stat")
305
 
        assert out == ("unknown:\n"
306
 
                       "  test.txt\n")
 
915
        out = capture("stat")
 
916
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
307
917
 
308
918
        progress("command help")
309
919
        runbzr("help st")
311
921
        runbzr("help commands")
312
922
        runbzr("help slartibartfast", 1)
313
923
 
314
 
        out = backtick("bzr help ci")
 
924
        out = capture("help ci")
315
925
        out.index('aliases: ')
316
926
 
317
927
        progress("can't rename unversioned file")
320
930
        progress("adding a file")
321
931
 
322
932
        runbzr("add test.txt")
323
 
        assert backtick("bzr unknowns") == ''
324
 
        assert backtick("bzr status --all") == ("added:\n"
325
 
                                                "  test.txt\n")
 
933
        self.assertEquals(capture("unknowns"), '')
 
934
        self.assertEquals(capture("status --all"), ("added:\n" "  test.txt\n"))
326
935
 
327
936
        progress("rename newly-added file")
328
937
        runbzr("rename test.txt hello.txt")
329
 
        assert os.path.exists("hello.txt")
330
 
        assert not os.path.exists("test.txt")
 
938
        self.assert_(os.path.exists("hello.txt"))
 
939
        self.assert_(not os.path.exists("test.txt"))
331
940
 
332
 
        assert backtick("bzr revno") == '0\n'
 
941
        self.assertEquals(capture("revno"), '0\n')
333
942
 
334
943
        progress("add first revision")
335
944
        runbzr(['commit', '-m', 'add first revision'])
343
952
        runbzr("add sub1")
344
953
        runbzr("rename sub1 sub2")
345
954
        runbzr("move hello.txt sub2")
346
 
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
955
        self.assertEqual(capture("relpath sub2/hello.txt"),
 
956
                         os.path.join("sub2", "hello.txt\n"))
347
957
 
348
 
        assert exists("sub2")
349
 
        assert exists("sub2/hello.txt")
350
 
        assert not exists("sub1")
351
 
        assert not exists("hello.txt")
 
958
        self.assert_(exists("sub2"))
 
959
        self.assert_(exists("sub2/hello.txt"))
 
960
        self.assert_(not exists("sub1"))
 
961
        self.assert_(not exists("hello.txt"))
352
962
 
353
963
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
354
964
 
355
965
        mkdir("sub1")
356
966
        runbzr('add sub1')
357
967
        runbzr('move sub2/hello.txt sub1')
358
 
        assert not exists('sub2/hello.txt')
359
 
        assert exists('sub1/hello.txt')
 
968
        self.assert_(not exists('sub2/hello.txt'))
 
969
        self.assert_(exists('sub1/hello.txt'))
360
970
        runbzr('move sub2 sub1')
361
 
        assert not exists('sub2')
362
 
        assert exists('sub1/sub2')
 
971
        self.assert_(not exists('sub2'))
 
972
        self.assert_(exists('sub1/sub2'))
363
973
 
364
974
        runbzr(['commit', '-m', 'rename nested subdirectories'])
365
975
 
366
976
        chdir('sub1/sub2')
367
 
        self.assertEquals(backtick('bzr root')[:-1],
 
977
        self.assertEquals(capture('root')[:-1],
368
978
                          os.path.join(self.test_dir, 'branch1'))
369
979
        runbzr('move ../hello.txt .')
370
 
        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')
 
980
        self.assert_(exists('./hello.txt'))
 
981
        self.assertEquals(capture('relpath hello.txt'),
 
982
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
983
        self.assertEquals(capture('relpath ../../sub1/sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
373
984
        runbzr(['commit', '-m', 'move to parent directory'])
374
985
        chdir('..')
375
 
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
986
        self.assertEquals(capture('relpath sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
376
987
 
377
988
        runbzr('move sub2/hello.txt .')
378
 
        assert exists('hello.txt')
 
989
        self.assert_(exists('hello.txt'))
379
990
 
380
991
        f = file('hello.txt', 'wt')
381
992
        f.write('some nice new content\n')
382
993
        f.close()
383
994
 
384
995
        f = file('msg.tmp', 'wt')
385
 
        f.write('this is my new commit\n')
 
996
        f.write('this is my new commit\nand it has multiple lines, for fun')
386
997
        f.close()
387
998
 
388
999
        runbzr('commit -F msg.tmp')
389
1000
 
390
 
        assert backtick('bzr revno') == '5\n'
 
1001
        self.assertEquals(capture('revno'), '5\n')
391
1002
        runbzr('export -r 5 export-5.tmp')
392
1003
        runbzr('export export.tmp')
393
1004
 
395
1006
        runbzr('log -v')
396
1007
        runbzr('log -v --forward')
397
1008
        runbzr('log -m', retcode=1)
398
 
        log_out = backtick('bzr log -m commit')
399
 
        assert "this is my new commit" in log_out
400
 
        assert "rename nested" not in log_out
401
 
        assert 'revision-id' not in log_out
402
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
1009
        log_out = capture('log -m commit')
 
1010
        self.assert_("this is my new commit\n  and" in log_out)
 
1011
        self.assert_("rename nested" not in log_out)
 
1012
        self.assert_('revision-id' not in log_out)
 
1013
        self.assert_('revision-id' in capture('log --show-ids -m commit'))
 
1014
 
 
1015
        log_out = capture('log --line')
 
1016
        for line in log_out.splitlines():
 
1017
            self.assert_(len(line) <= 79, len(line))
 
1018
        self.assert_("this is my new commit and" in log_out)
403
1019
 
404
1020
 
405
1021
        progress("file with spaces in name")
406
1022
        mkdir('sub directory')
407
1023
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
408
1024
        runbzr('add .')
409
 
        runbzr('diff')
 
1025
        runbzr('diff', retcode=1)
410
1026
        runbzr('commit -m add-spaces')
411
1027
        runbzr('check')
412
1028
 
415
1031
 
416
1032
        runbzr('info')
417
1033
 
 
1034
        if has_symlinks():
 
1035
            progress("symlinks")
 
1036
            mkdir('symlinks')
 
1037
            chdir('symlinks')
 
1038
            runbzr('init')
 
1039
            os.symlink("NOWHERE1", "link1")
 
1040
            runbzr('add link1')
 
1041
            self.assertEquals(self.capture('unknowns'), '')
 
1042
            runbzr(['commit', '-m', '1: added symlink link1'])
 
1043
    
 
1044
            mkdir('d1')
 
1045
            runbzr('add d1')
 
1046
            self.assertEquals(self.capture('unknowns'), '')
 
1047
            os.symlink("NOWHERE2", "d1/link2")
 
1048
            self.assertEquals(self.capture('unknowns'), 'd1/link2\n')
 
1049
            # is d1/link2 found when adding d1
 
1050
            runbzr('add d1')
 
1051
            self.assertEquals(self.capture('unknowns'), '')
 
1052
            os.symlink("NOWHERE3", "d1/link3")
 
1053
            self.assertEquals(self.capture('unknowns'), 'd1/link3\n')
 
1054
            runbzr(['commit', '-m', '2: added dir, symlink'])
 
1055
    
 
1056
            runbzr('rename d1 d2')
 
1057
            runbzr('move d2/link2 .')
 
1058
            runbzr('move link1 d2')
 
1059
            self.assertEquals(os.readlink("./link2"), "NOWHERE2")
 
1060
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
 
1061
            runbzr('add d2/link3')
 
1062
            runbzr('diff', retcode=1)
 
1063
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
 
1064
    
 
1065
            os.unlink("link2")
 
1066
            os.symlink("TARGET 2", "link2")
 
1067
            os.unlink("d2/link1")
 
1068
            os.symlink("TARGET 1", "d2/link1")
 
1069
            runbzr('diff', retcode=1)
 
1070
            self.assertEquals(self.capture("relpath d2/link1"), "d2/link1\n")
 
1071
            runbzr(['commit', '-m', '4: retarget of two links'])
 
1072
    
 
1073
            runbzr('remove d2/link1')
 
1074
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
 
1075
            runbzr(['commit', '-m', '5: remove d2/link1'])
 
1076
            # try with the rm alias
 
1077
            runbzr('add d2/link1')
 
1078
            runbzr(['commit', '-m', '6: add d2/link1'])
 
1079
            runbzr('rm d2/link1')
 
1080
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
 
1081
            runbzr(['commit', '-m', '7: remove d2/link1'])
 
1082
    
 
1083
            os.mkdir("d1")
 
1084
            runbzr('add d1')
 
1085
            runbzr('rename d2/link3 d1/link3new')
 
1086
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
 
1087
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
 
1088
            
 
1089
            runbzr(['check'])
 
1090
            
 
1091
            runbzr(['export', '-r', '1', 'exp1.tmp'])
 
1092
            chdir("exp1.tmp")
 
1093
            self.assertEquals(listdir_sorted("."), [ "link1" ])
 
1094
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
 
1095
            chdir("..")
 
1096
            
 
1097
            runbzr(['export', '-r', '2', 'exp2.tmp'])
 
1098
            chdir("exp2.tmp")
 
1099
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
 
1100
            chdir("..")
 
1101
            
 
1102
            runbzr(['export', '-r', '3', 'exp3.tmp'])
 
1103
            chdir("exp3.tmp")
 
1104
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1105
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
 
1106
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
 
1107
            self.assertEquals(os.readlink("link2")   , "NOWHERE2")
 
1108
            chdir("..")
 
1109
            
 
1110
            runbzr(['export', '-r', '4', 'exp4.tmp'])
 
1111
            chdir("exp4.tmp")
 
1112
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1113
            self.assertEquals(os.readlink("d2/link1"), "TARGET 1")
 
1114
            self.assertEquals(os.readlink("link2")   , "TARGET 2")
 
1115
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
 
1116
            chdir("..")
 
1117
            
 
1118
            runbzr(['export', '-r', '5', 'exp5.tmp'])
 
1119
            chdir("exp5.tmp")
 
1120
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1121
            self.assert_(os.path.islink("link2"))
 
1122
            self.assert_(listdir_sorted("d2")== [ "link3" ])
 
1123
            chdir("..")
 
1124
            
 
1125
            runbzr(['export', '-r', '8', 'exp6.tmp'])
 
1126
            chdir("exp6.tmp")
 
1127
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
 
1128
            self.assertEquals(listdir_sorted("d1"), [ "link3new" ])
 
1129
            self.assertEquals(listdir_sorted("d2"), [])
 
1130
            self.assertEquals(os.readlink("d1/link3new"), "NOWHERE3")
 
1131
            chdir("..")
 
1132
        else:
 
1133
            progress("skipping symlink tests")
 
1134
 
 
1135
 
 
1136
class HttpTests(TestCaseWithWebserver):
 
1137
    """Test bzr ui commands against remote branches."""
 
1138
 
 
1139
    def test_branch(self):
 
1140
        os.mkdir('from')
 
1141
        branch = Branch.initialize('from')
 
1142
        branch.working_tree().commit('empty commit for nonsense', allow_pointless=True)
 
1143
        url = self.get_remote_url('from')
 
1144
        self.run_bzr('branch', url, 'to')
 
1145
        branch = Branch.open('to')
 
1146
        self.assertEqual(1, len(branch.revision_history()))
 
1147
 
 
1148
    def test_log(self):
 
1149
        self.build_tree(['branch/', 'branch/file'])
 
1150
        branch = Branch.initialize('branch')
 
1151
        branch.add(['file'])
 
1152
        branch.working_tree().commit('add file', rev_id='A')
 
1153
        url = self.get_remote_url('branch/file')
 
1154
        output = self.capture('log %s' % url)
 
1155
        self.assertEqual(7, len(output.split('\n')))
 
1156
        
 
1157
 
 
1158
 
 
1159