← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: John Arbash Meinel
  • Date: 2005-11-08 18:36:26 UTC
  • mto: This revision was merged to the branch mainline in revision 1727.
  • Revision ID: john@arbash-meinel.com-20051108183626-71f8414338043265
Updating unified_diff to take a factory, using the new diff algorithm in the code.

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
 
import os
31
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
32
37
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
33
 
from bzrlib.branch import Branch
34
 
from bzrlib.commands import run_bzr
 
38
from bzrlib.selftest.HTTPTestUtil import TestCaseWithWebserver
35
39
 
36
40
 
37
41
class ExternalBase(TestCaseInTempDir):
38
 
    def runbzr(self, args, retcode=0,backtick=False):
 
42
 
 
43
    def runbzr(self, args, retcode=0, backtick=False):
39
44
        if isinstance(args, basestring):
40
45
            args = args.split()
41
46
 
42
47
        if backtick:
43
 
            return self.backtick(['python', self.BZRPATH,] + args,
44
 
                           retcode=retcode)
 
48
            return self.run_bzr_captured(args, retcode=retcode)[0]
45
49
        else:
46
 
            return self.runcmd(['python', self.BZRPATH,] + args,
47
 
                           retcode=retcode)
 
50
            return self.run_bzr_captured(args, retcode=retcode)
48
51
 
49
52
 
50
53
class TestCommands(ExternalBase):
59
62
    def test_init_branch(self):
60
63
        self.runbzr(['init'])
61
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
 
62
79
    def test_whoami(self):
63
80
        # this should always identify something, if only "john@localhost"
64
81
        self.runbzr("whoami")
73
90
        f = file('.bzr/email', 'wt')
74
91
        f.write('Branch Identity <branch@identi.ty>')
75
92
        f.close()
 
93
        bzr_email = os.environ.get('BZREMAIL')
 
94
        if bzr_email is not None:
 
95
            del os.environ['BZREMAIL']
76
96
        whoami = self.runbzr("whoami",backtick=True)
77
97
        whoami_email = self.runbzr("whoami --email",backtick=True)
78
98
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
79
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
80
109
 
81
110
    def test_invalid_commands(self):
82
111
        self.runbzr("pants", retcode=1)
90
119
        self.runbzr("add hello.txt")
91
120
        self.runbzr("commit -m added")
92
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
 
93
149
    def test_ignore_patterns(self):
94
150
        from bzrlib.branch import Branch
95
151
        
96
 
        b = Branch('.', init=True)
 
152
        b = Branch.initialize('.')
97
153
        self.assertEquals(list(b.unknowns()), [])
98
154
 
99
155
        file('foo.tmp', 'wt').write('tmp files are ignored')
100
156
        self.assertEquals(list(b.unknowns()), [])
101
 
        assert self.backtick('bzr unknowns') == ''
 
157
        self.assertEquals(self.capture('unknowns'), '')
102
158
 
103
159
        file('foo.c', 'wt').write('int main() {}')
104
160
        self.assertEquals(list(b.unknowns()), ['foo.c'])
105
 
        assert self.backtick('bzr unknowns') == 'foo.c\n'
 
161
        self.assertEquals(self.capture('unknowns'), 'foo.c\n')
106
162
 
107
163
        self.runbzr(['add', 'foo.c'])
108
 
        assert self.backtick('bzr unknowns') == ''
 
164
        self.assertEquals(self.capture('unknowns'), '')
109
165
 
110
166
        # 'ignore' works when creating the .bzignore file
111
167
        file('foo.blah', 'wt').write('blah')
112
168
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
113
169
        self.runbzr('ignore *.blah')
114
170
        self.assertEquals(list(b.unknowns()), [])
115
 
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
 
171
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')
116
172
 
117
173
        # 'ignore' works when then .bzrignore file already exists
118
174
        file('garh', 'wt').write('garh')
119
175
        self.assertEquals(list(b.unknowns()), ['garh'])
120
 
        assert self.backtick('bzr unknowns') == 'garh\n'
 
176
        self.assertEquals(self.capture('unknowns'), 'garh\n')
121
177
        self.runbzr('ignore garh')
122
178
        self.assertEquals(list(b.unknowns()), [])
123
 
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
 
179
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')
124
180
 
125
181
    def test_revert(self):
126
182
        self.runbzr('init')
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
 
 
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
 
150
229
    def test_mv_modes(self):
151
230
        """Test two modes of operation for mv"""
152
231
        from bzrlib.branch import Branch
153
 
        b = Branch('.', init=True)
 
232
        b = Branch.initialize('.')
154
233
        self.build_tree(['a', 'c', 'subdir/'])
155
 
        self.run_bzr('add', self.test_dir)
156
 
        self.run_bzr('mv', 'a', 'b')
157
 
        self.run_bzr('mv', 'b', 'subdir')
158
 
        self.run_bzr('mv', 'subdir/b', 'a')
159
 
        self.run_bzr('mv', 'a', 'c', 'subdir')
160
 
        self.run_bzr('mv', 'subdir/a', 'subdir/newa')
161
 
 
 
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'])
162
240
 
163
241
    def test_main_version(self):
164
242
        """Check output from version command and master option is reasonable"""
184
262
        test.runbzr('add goodbye')
185
263
        test.runbzr('commit -m setup goodbye')
186
264
 
187
 
    def test_revert(self):
188
 
        self.example_branch()
189
 
        file('hello', 'wt').write('bar')
190
 
        file('goodbye', 'wt').write('qux')
191
 
        self.runbzr('revert hello')
192
 
        self.check_file_contents('hello', 'foo')
193
 
        self.check_file_contents('goodbye', 'qux')
194
 
        self.runbzr('revert')
195
 
        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.commit('add file')
 
315
        copy_branch(branch, 'branch2')
 
316
        print >> open('branch2/file', 'w'), 'new content'
 
317
        branch2 = Branch.open('branch2')
 
318
        branch2.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')
196
349
 
197
350
    def test_merge(self):
198
351
        from bzrlib.branch import Branch
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
 
        a = Branch('.')
218
 
        b = Branch('../b')
219
 
        a.get_revision_xml(b.last_patch())
 
378
        a = Branch.open('.')
 
379
        b = Branch.open('../b')
 
380
        a.get_revision_xml(b.last_revision())
220
381
        self.log('pending merges: %s', a.pending_merges())
221
 
        #        assert a.pending_merges() == [b.last_patch()], "Assertion %s %s" \
222
 
        #        % (a.pending_merges(), b.last_patch())
 
382
        self.assertEquals(a.pending_merges(), [b.last_revision()])
 
383
        self.runbzr('commit -m merged')
 
384
        self.runbzr('merge ../b -r last:1')
 
385
        self.assertEqual(Branch.open('.').pending_merges(), [])
 
386
 
 
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'))
223
421
 
224
422
    def test_pull(self):
225
423
        """Pull changes from one branch to another."""
239
437
        self.runbzr('branch a b')
240
438
        os.chdir('b')
241
439
        self.runbzr('pull')
 
440
        os.mkdir('subdir')
 
441
        self.runbzr('add subdir')
242
442
        self.runbzr('commit -m blah --unchanged')
243
443
        os.chdir('../a')
244
 
        a = Branch('.')
245
 
        b = Branch('../b')
246
 
        assert a.revision_history() == b.revision_history()[:-1]
 
444
        a = Branch.open('.')
 
445
        b = Branch.open('../b')
 
446
        self.assertEquals(a.revision_history(), b.revision_history()[:-1])
247
447
        self.runbzr('pull ../b')
248
 
        assert a.revision_history() == b.revision_history()
 
448
        self.assertEquals(a.revision_history(), b.revision_history())
249
449
        self.runbzr('commit -m blah2 --unchanged')
250
450
        os.chdir('../b')
251
451
        self.runbzr('commit -m blah3 --unchanged')
 
452
        # no overwrite
252
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())
253
461
        os.chdir('../a')
254
462
        self.runbzr('merge ../b')
255
463
        self.runbzr('commit -m blah4 --unchanged')
256
 
        os.chdir('../b')
 
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('..')
257
470
        self.runbzr('pull ../a')
258
 
        assert a.revision_history()[-1] == b.revision_history()[-1]
259
 
        
260
 
 
 
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
 
 
580
    def test_locations(self):
 
581
        """Using and remembering different locations"""
 
582
        os.mkdir('a')
 
583
        os.chdir('a')
 
584
        self.runbzr('init')
 
585
        self.runbzr('commit -m unchanged --unchanged')
 
586
        self.runbzr('pull', retcode=1)
 
587
        self.runbzr('merge', retcode=1)
 
588
        self.runbzr('branch . ../b')
 
589
        os.chdir('../b')
 
590
        self.runbzr('pull')
 
591
        self.runbzr('branch . ../c')
 
592
        self.runbzr('pull ../c')
 
593
        self.runbzr('merge')
 
594
        os.chdir('../a')
 
595
        self.runbzr('pull ../b')
 
596
        self.runbzr('pull')
 
597
        self.runbzr('pull ../c')
 
598
        self.runbzr('branch ../c ../d')
 
599
        shutil.rmtree('../c')
 
600
        self.runbzr('pull')
 
601
        os.chdir('../b')
 
602
        self.runbzr('pull')
 
603
        os.chdir('../d')
 
604
        self.runbzr('pull', retcode=1)
 
605
        self.runbzr('pull ../a --remember')
 
606
        self.runbzr('pull')
 
607
        
261
608
    def test_add_reports(self):
262
609
        """add command prints the names of added files."""
263
 
        b = Branch('.', init=True)
 
610
        b = Branch.initialize('.')
264
611
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
265
 
 
266
 
        from cStringIO import StringIO
267
 
        out = StringIO()
268
 
 
269
 
        ret = self.apply_redirected(None, out, None,
270
 
                                    run_bzr,
271
 
                                    ['add'])
272
 
        self.assertEquals(ret, 0)
273
 
 
 
612
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
274
613
        # the ordering is not defined at the moment
275
 
        results = sorted(out.getvalue().rstrip('\n').split('\n'))
 
614
        results = sorted(out.rstrip('\n').split('\n'))
276
615
        self.assertEquals(['added dir',
277
 
                           'added dir/sub.txt',
 
616
                           'added dir'+os.sep+'sub.txt',
278
617
                           'added top.txt',],
279
618
                          results)
280
619
 
 
620
    def test_add_quiet_is(self):
 
621
        """add -q does not print the names of added files."""
 
622
        b = Branch.initialize('.')
 
623
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
624
        out = self.run_bzr_captured(['add', '-q'], retcode = 0)[0]
 
625
        # the ordering is not defined at the moment
 
626
        results = sorted(out.rstrip('\n').split('\n'))
 
627
        self.assertEquals([''], results)
 
628
 
 
629
    def test_unknown_command(self):
 
630
        """Handling of unknown command."""
 
631
        out, err = self.run_bzr_captured(['fluffy-badger'],
 
632
                                         retcode=1)
 
633
        self.assertEquals(out, '')
 
634
        err.index('unknown command')
 
635
 
 
636
    def test_conflicts(self):
 
637
        """Handling of merge conflicts"""
 
638
        os.mkdir('base')
 
639
        os.chdir('base')
 
640
        file('hello', 'wb').write("hi world")
 
641
        file('answer', 'wb').write("42")
 
642
        self.runbzr('init')
 
643
        self.runbzr('add')
 
644
        self.runbzr('commit -m base')
 
645
        self.runbzr('branch . ../other')
 
646
        self.runbzr('branch . ../this')
 
647
        os.chdir('../other')
 
648
        file('hello', 'wb').write("Hello.")
 
649
        file('answer', 'wb').write("Is anyone there?")
 
650
        self.runbzr('commit -m other')
 
651
        os.chdir('../this')
 
652
        file('hello', 'wb').write("Hello, world")
 
653
        self.runbzr('mv answer question')
 
654
        file('question', 'wb').write("What do you get when you multiply six"
 
655
                                   "times nine?")
 
656
        self.runbzr('commit -m this')
 
657
        self.runbzr('merge ../other --show-base', retcode=1)
 
658
        conflict_text = file('hello').read()
 
659
        self.assert_('<<<<<<<' in conflict_text)
 
660
        self.assert_('>>>>>>>' in conflict_text)
 
661
        self.assert_('=======' in conflict_text)
 
662
        self.assert_('|||||||' in conflict_text)
 
663
        self.assert_('hi world' in conflict_text)
 
664
        self.runbzr('revert')
 
665
        self.runbzr('resolve --all')
 
666
        self.runbzr('merge ../other', retcode=1)
 
667
        conflict_text = file('hello').read()
 
668
        self.assert_('|||||||' not in conflict_text)
 
669
        self.assert_('hi world' not in conflict_text)
 
670
        result = self.runbzr('conflicts', backtick=1)
 
671
        self.assertEquals(result, "hello\nquestion\n")
 
672
        result = self.runbzr('status', backtick=1)
 
673
        self.assert_("conflicts:\n  hello\n  question\n" in result, result)
 
674
        self.runbzr('resolve hello')
 
675
        result = self.runbzr('conflicts', backtick=1)
 
676
        self.assertEquals(result, "question\n")
 
677
        self.runbzr('commit -m conflicts', retcode=1)
 
678
        self.runbzr('resolve --all')
 
679
        result = self.runbzr('conflicts', backtick=1)
 
680
        self.runbzr('commit -m conflicts')
 
681
        self.assertEquals(result, "")
 
682
 
 
683
    def test_resign(self):
 
684
        """Test re signing of data."""
 
685
        import bzrlib.gpg
 
686
        oldstrategy = bzrlib.gpg.GPGStrategy
 
687
        branch = Branch.initialize('.')
 
688
        branch.commit("base", allow_pointless=True, rev_id='A')
 
689
        try:
 
690
            # monkey patch gpg signing mechanism
 
691
            from bzrlib.testament import Testament
 
692
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
 
693
            self.runbzr('re-sign -r revid:A')
 
694
            self.assertEqual(Testament.from_revision(branch,'A').as_short_text(),
 
695
                             branch.revision_store.get('A', 'sig').read())
 
696
        finally:
 
697
            bzrlib.gpg.GPGStrategy = oldstrategy
 
698
            
 
699
    def test_resign_range(self):
 
700
        import bzrlib.gpg
 
701
        oldstrategy = bzrlib.gpg.GPGStrategy
 
702
        branch = Branch.initialize('.')
 
703
        branch.commit("base", allow_pointless=True, rev_id='A')
 
704
        branch.commit("base", allow_pointless=True, rev_id='B')
 
705
        branch.commit("base", allow_pointless=True, rev_id='C')
 
706
        try:
 
707
            # monkey patch gpg signing mechanism
 
708
            from bzrlib.testament import Testament
 
709
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
 
710
            self.runbzr('re-sign -r 1..')
 
711
            self.assertEqual(Testament.from_revision(branch,'A').as_short_text(),
 
712
                             branch.revision_store.get('A', 'sig').read())
 
713
            self.assertEqual(Testament.from_revision(branch,'B').as_short_text(),
 
714
                             branch.revision_store.get('B', 'sig').read())
 
715
            self.assertEqual(Testament.from_revision(branch,'C').as_short_text(),
 
716
                             branch.revision_store.get('C', 'sig').read())
 
717
        finally:
 
718
            bzrlib.gpg.GPGStrategy = oldstrategy
 
719
 
 
720
    def test_push(self):
 
721
        # create a source branch
 
722
        os.mkdir('my-branch')
 
723
        os.chdir('my-branch')
 
724
        self.example_branch()
 
725
 
 
726
        # with no push target, fail
 
727
        self.runbzr('push', retcode=1)
 
728
        # with an explicit target work
 
729
        self.runbzr('push ../output-branch')
 
730
        # with an implicit target work
 
731
        self.runbzr('push')
 
732
        # nothing missing
 
733
        self.runbzr('missing ../output-branch')
 
734
        # advance this branch
 
735
        self.runbzr('commit --unchanged -m unchanged')
 
736
 
 
737
        os.chdir('../output-branch')
 
738
        # should be a diff as we have not pushed the tree
 
739
        self.runbzr('diff', retcode=1)
 
740
        self.runbzr('revert')
 
741
        # but not now.
 
742
        self.runbzr('diff')
 
743
        # diverge the branches
 
744
        self.runbzr('commit --unchanged -m unchanged')
 
745
        os.chdir('../my-branch')
 
746
        # cannot push now
 
747
        self.runbzr('push', retcode=1)
 
748
        # and there are difference
 
749
        self.runbzr('missing ../output-branch', retcode=1)
 
750
        # but we can force a push
 
751
        self.runbzr('push --overwrite')
 
752
        # nothing missing
 
753
        self.runbzr('missing ../output-branch')
 
754
        
 
755
        # pushing to a new dir with no parent should fail
 
756
        self.runbzr('push ../missing/new-branch', retcode=1)
 
757
        # unless we provide --create-prefix
 
758
        self.runbzr('push --create-prefix ../missing/new-branch')
 
759
        # nothing missing
 
760
        self.runbzr('missing ../missing/new-branch')
 
761
 
 
762
 
 
763
def listdir_sorted(dir):
 
764
    L = os.listdir(dir)
 
765
    L.sort()
 
766
    return L
 
767
 
281
768
 
282
769
class OldTests(ExternalBase):
283
770
    """old tests moved from ./testbzr."""
287
774
        from os.path import exists
288
775
 
289
776
        runbzr = self.runbzr
290
 
        backtick = self.backtick
 
777
        capture = self.capture
291
778
        progress = self.log
292
779
 
293
780
        progress("basic branch creation")
295
782
        chdir('branch1')
296
783
        runbzr('init')
297
784
 
298
 
        self.assertEquals(backtick('bzr root').rstrip(),
 
785
        self.assertEquals(capture('root').rstrip(),
299
786
                          os.path.join(self.test_dir, 'branch1'))
300
787
 
301
788
        progress("status of new file")
304
791
        f.write('hello world!\n')
305
792
        f.close()
306
793
 
307
 
        out = backtick("bzr unknowns")
308
 
        self.assertEquals(out, 'test.txt\n')
309
 
 
310
 
        out = backtick("bzr status")
311
 
        assert out == 'unknown:\n  test.txt\n'
312
 
 
313
 
        out = backtick("bzr status --all")
314
 
        assert out == "unknown:\n  test.txt\n"
315
 
 
316
 
        out = backtick("bzr status test.txt --all")
317
 
        assert out == "unknown:\n  test.txt\n"
 
794
        self.assertEquals(capture('unknowns'), 'test.txt\n')
 
795
 
 
796
        out = capture("status")
 
797
        self.assertEquals(out, 'unknown:\n  test.txt\n')
 
798
 
 
799
        out = capture("status --all")
 
800
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
801
 
 
802
        out = capture("status test.txt --all")
 
803
        self.assertEquals(out, "unknown:\n  test.txt\n")
318
804
 
319
805
        f = file('test2.txt', 'wt')
320
806
        f.write('goodbye cruel world...\n')
321
807
        f.close()
322
808
 
323
 
        out = backtick("bzr status test.txt")
324
 
        assert out == "unknown:\n  test.txt\n"
 
809
        out = capture("status test.txt")
 
810
        self.assertEquals(out, "unknown:\n  test.txt\n")
325
811
 
326
 
        out = backtick("bzr status")
327
 
        assert out == ("unknown:\n"
328
 
                       "  test.txt\n"
329
 
                       "  test2.txt\n")
 
812
        out = capture("status")
 
813
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
330
814
 
331
815
        os.unlink('test2.txt')
332
816
 
333
817
        progress("command aliases")
334
 
        out = backtick("bzr st --all")
335
 
        assert out == ("unknown:\n"
336
 
                       "  test.txt\n")
 
818
        out = capture("st --all")
 
819
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
337
820
 
338
 
        out = backtick("bzr stat")
339
 
        assert out == ("unknown:\n"
340
 
                       "  test.txt\n")
 
821
        out = capture("stat")
 
822
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
341
823
 
342
824
        progress("command help")
343
825
        runbzr("help st")
345
827
        runbzr("help commands")
346
828
        runbzr("help slartibartfast", 1)
347
829
 
348
 
        out = backtick("bzr help ci")
 
830
        out = capture("help ci")
349
831
        out.index('aliases: ')
350
832
 
351
833
        progress("can't rename unversioned file")
354
836
        progress("adding a file")
355
837
 
356
838
        runbzr("add test.txt")
357
 
        assert backtick("bzr unknowns") == ''
358
 
        assert backtick("bzr status --all") == ("added:\n"
359
 
                                                "  test.txt\n")
 
839
        self.assertEquals(capture("unknowns"), '')
 
840
        self.assertEquals(capture("status --all"), ("added:\n" "  test.txt\n"))
360
841
 
361
842
        progress("rename newly-added file")
362
843
        runbzr("rename test.txt hello.txt")
363
 
        assert os.path.exists("hello.txt")
364
 
        assert not os.path.exists("test.txt")
 
844
        self.assert_(os.path.exists("hello.txt"))
 
845
        self.assert_(not os.path.exists("test.txt"))
365
846
 
366
 
        assert backtick("bzr revno") == '0\n'
 
847
        self.assertEquals(capture("revno"), '0\n')
367
848
 
368
849
        progress("add first revision")
369
850
        runbzr(['commit', '-m', 'add first revision'])
377
858
        runbzr("add sub1")
378
859
        runbzr("rename sub1 sub2")
379
860
        runbzr("move hello.txt sub2")
380
 
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
 
861
        self.assertEqual(capture("relpath sub2/hello.txt"),
 
862
                         os.path.join("sub2", "hello.txt\n"))
381
863
 
382
 
        assert exists("sub2")
383
 
        assert exists("sub2/hello.txt")
384
 
        assert not exists("sub1")
385
 
        assert not exists("hello.txt")
 
864
        self.assert_(exists("sub2"))
 
865
        self.assert_(exists("sub2/hello.txt"))
 
866
        self.assert_(not exists("sub1"))
 
867
        self.assert_(not exists("hello.txt"))
386
868
 
387
869
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
388
870
 
389
871
        mkdir("sub1")
390
872
        runbzr('add sub1')
391
873
        runbzr('move sub2/hello.txt sub1')
392
 
        assert not exists('sub2/hello.txt')
393
 
        assert exists('sub1/hello.txt')
 
874
        self.assert_(not exists('sub2/hello.txt'))
 
875
        self.assert_(exists('sub1/hello.txt'))
394
876
        runbzr('move sub2 sub1')
395
 
        assert not exists('sub2')
396
 
        assert exists('sub1/sub2')
 
877
        self.assert_(not exists('sub2'))
 
878
        self.assert_(exists('sub1/sub2'))
397
879
 
398
880
        runbzr(['commit', '-m', 'rename nested subdirectories'])
399
881
 
400
882
        chdir('sub1/sub2')
401
 
        self.assertEquals(backtick('bzr root')[:-1],
 
883
        self.assertEquals(capture('root')[:-1],
402
884
                          os.path.join(self.test_dir, 'branch1'))
403
885
        runbzr('move ../hello.txt .')
404
 
        assert exists('./hello.txt')
405
 
        assert backtick('bzr relpath hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
406
 
        assert backtick('bzr relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
886
        self.assert_(exists('./hello.txt'))
 
887
        self.assertEquals(capture('relpath hello.txt'),
 
888
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
889
        self.assertEquals(capture('relpath ../../sub1/sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
407
890
        runbzr(['commit', '-m', 'move to parent directory'])
408
891
        chdir('..')
409
 
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
892
        self.assertEquals(capture('relpath sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
410
893
 
411
894
        runbzr('move sub2/hello.txt .')
412
 
        assert exists('hello.txt')
 
895
        self.assert_(exists('hello.txt'))
413
896
 
414
897
        f = file('hello.txt', 'wt')
415
898
        f.write('some nice new content\n')
416
899
        f.close()
417
900
 
418
901
        f = file('msg.tmp', 'wt')
419
 
        f.write('this is my new commit\n')
 
902
        f.write('this is my new commit\nand it has multiple lines, for fun')
420
903
        f.close()
421
904
 
422
905
        runbzr('commit -F msg.tmp')
423
906
 
424
 
        assert backtick('bzr revno') == '5\n'
 
907
        self.assertEquals(capture('revno'), '5\n')
425
908
        runbzr('export -r 5 export-5.tmp')
426
909
        runbzr('export export.tmp')
427
910
 
429
912
        runbzr('log -v')
430
913
        runbzr('log -v --forward')
431
914
        runbzr('log -m', retcode=1)
432
 
        log_out = backtick('bzr log -m commit')
433
 
        assert "this is my new commit" in log_out
434
 
        assert "rename nested" not in log_out
435
 
        assert 'revision-id' not in log_out
436
 
        assert 'revision-id' in backtick('bzr log --show-ids -m commit')
 
915
        log_out = capture('log -m commit')
 
916
        self.assert_("this is my new commit\n  and" in log_out)
 
917
        self.assert_("rename nested" not in log_out)
 
918
        self.assert_('revision-id' not in log_out)
 
919
        self.assert_('revision-id' in capture('log --show-ids -m commit'))
 
920
 
 
921
        log_out = capture('log --line')
 
922
        for line in log_out.splitlines():
 
923
            self.assert_(len(line) <= 79, len(line))
 
924
        self.assert_("this is my new commit and" in log_out)
437
925
 
438
926
 
439
927
        progress("file with spaces in name")
440
928
        mkdir('sub directory')
441
929
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
442
930
        runbzr('add .')
443
 
        runbzr('diff')
 
931
        runbzr('diff', retcode=1)
444
932
        runbzr('commit -m add-spaces')
445
933
        runbzr('check')
446
934
 
449
937
 
450
938
        runbzr('info')
451
939
 
 
940
        if has_symlinks():
 
941
            progress("symlinks")
 
942
            mkdir('symlinks')
 
943
            chdir('symlinks')
 
944
            runbzr('init')
 
945
            os.symlink("NOWHERE1", "link1")
 
946
            runbzr('add link1')
 
947
            self.assertEquals(self.capture('unknowns'), '')
 
948
            runbzr(['commit', '-m', '1: added symlink link1'])
 
949
    
 
950
            mkdir('d1')
 
951
            runbzr('add d1')
 
952
            self.assertEquals(self.capture('unknowns'), '')
 
953
            os.symlink("NOWHERE2", "d1/link2")
 
954
            self.assertEquals(self.capture('unknowns'), 'd1/link2\n')
 
955
            # is d1/link2 found when adding d1
 
956
            runbzr('add d1')
 
957
            self.assertEquals(self.capture('unknowns'), '')
 
958
            os.symlink("NOWHERE3", "d1/link3")
 
959
            self.assertEquals(self.capture('unknowns'), 'd1/link3\n')
 
960
            runbzr(['commit', '-m', '2: added dir, symlink'])
 
961
    
 
962
            runbzr('rename d1 d2')
 
963
            runbzr('move d2/link2 .')
 
964
            runbzr('move link1 d2')
 
965
            self.assertEquals(os.readlink("./link2"), "NOWHERE2")
 
966
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
 
967
            runbzr('add d2/link3')
 
968
            runbzr('diff', retcode=1)
 
969
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
 
970
    
 
971
            os.unlink("link2")
 
972
            os.symlink("TARGET 2", "link2")
 
973
            os.unlink("d2/link1")
 
974
            os.symlink("TARGET 1", "d2/link1")
 
975
            runbzr('diff', retcode=1)
 
976
            self.assertEquals(self.capture("relpath d2/link1"), "d2/link1\n")
 
977
            runbzr(['commit', '-m', '4: retarget of two links'])
 
978
    
 
979
            runbzr('remove d2/link1')
 
980
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
 
981
            runbzr(['commit', '-m', '5: remove d2/link1'])
 
982
            # try with the rm alias
 
983
            runbzr('add d2/link1')
 
984
            runbzr(['commit', '-m', '6: add d2/link1'])
 
985
            runbzr('rm d2/link1')
 
986
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
 
987
            runbzr(['commit', '-m', '7: remove d2/link1'])
 
988
    
 
989
            os.mkdir("d1")
 
990
            runbzr('add d1')
 
991
            runbzr('rename d2/link3 d1/link3new')
 
992
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
 
993
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
 
994
            
 
995
            runbzr(['check'])
 
996
            
 
997
            runbzr(['export', '-r', '1', 'exp1.tmp'])
 
998
            chdir("exp1.tmp")
 
999
            self.assertEquals(listdir_sorted("."), [ "link1" ])
 
1000
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
 
1001
            chdir("..")
 
1002
            
 
1003
            runbzr(['export', '-r', '2', 'exp2.tmp'])
 
1004
            chdir("exp2.tmp")
 
1005
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
 
1006
            chdir("..")
 
1007
            
 
1008
            runbzr(['export', '-r', '3', 'exp3.tmp'])
 
1009
            chdir("exp3.tmp")
 
1010
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1011
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
 
1012
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
 
1013
            self.assertEquals(os.readlink("link2")   , "NOWHERE2")
 
1014
            chdir("..")
 
1015
            
 
1016
            runbzr(['export', '-r', '4', 'exp4.tmp'])
 
1017
            chdir("exp4.tmp")
 
1018
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1019
            self.assertEquals(os.readlink("d2/link1"), "TARGET 1")
 
1020
            self.assertEquals(os.readlink("link2")   , "TARGET 2")
 
1021
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
 
1022
            chdir("..")
 
1023
            
 
1024
            runbzr(['export', '-r', '5', 'exp5.tmp'])
 
1025
            chdir("exp5.tmp")
 
1026
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1027
            self.assert_(os.path.islink("link2"))
 
1028
            self.assert_(listdir_sorted("d2")== [ "link3" ])
 
1029
            chdir("..")
 
1030
            
 
1031
            runbzr(['export', '-r', '8', 'exp6.tmp'])
 
1032
            chdir("exp6.tmp")
 
1033
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
 
1034
            self.assertEquals(listdir_sorted("d1"), [ "link3new" ])
 
1035
            self.assertEquals(listdir_sorted("d2"), [])
 
1036
            self.assertEquals(os.readlink("d1/link3new"), "NOWHERE3")
 
1037
            chdir("..")
 
1038
        else:
 
1039
            progress("skipping symlink tests")
 
1040
 
 
1041
 
 
1042
class HttpTests(TestCaseWithWebserver):
 
1043
    """Test bzr ui commands against remote branches."""
 
1044
 
 
1045
    def test_branch(self):
 
1046
        os.mkdir('from')
 
1047
        branch = Branch.initialize('from')
 
1048
        branch.commit('empty commit for nonsense', allow_pointless=True)
 
1049
        url = self.get_remote_url('from')
 
1050
        self.run_bzr('branch', url, 'to')
 
1051
        branch = Branch.open('to')
 
1052
        self.assertEqual(1, len(branch.revision_history()))
 
1053
 
 
1054
    def test_log(self):
 
1055
        self.build_tree(['branch/', 'branch/file'])
 
1056
        branch = Branch.initialize('branch')
 
1057
        branch.add(['file'])
 
1058
        branch.commit('add file', rev_id='A')
 
1059
        url = self.get_remote_url('branch/file')
 
1060
        output = self.capture('log %s' % url)
 
1061
        self.assertEqual(7, len(output.split('\n')))
 
1062
        
 
1063
 
 
1064
 
 
1065