~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

merge merge tweaks from aaron, which includes latest .dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
15
15
# along with this program; if not, write to the Free Software
16
16
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
17
17
 
18
 
# Mr. Smoketoomuch: I'm sorry?
19
 
# Mr. Bounder: You'd better cut down a little then.
20
 
# Mr. Smoketoomuch: Oh, I see! Smoke too much so I'd better cut down a little
21
 
#                   then!
22
18
 
23
19
"""Black-box tests for bzr.
24
20
 
25
21
These check that it behaves properly when it's invoked through the regular
26
 
command-line interface. This doesn't actually run a new interpreter but 
27
 
rather starts again from the run_bzr function.
 
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.
28
27
"""
29
28
 
30
 
 
31
 
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
32
 
# Note: Please don't add new tests here, it's too big and bulky.  Instead add
33
 
# them into small suites in bzrlib.tests.blackbox.test_FOO for the particular
34
 
# UI command/aspect that is being tested.
35
 
 
36
 
 
37
29
from cStringIO import StringIO
 
30
import sys
38
31
import os
39
 
import re
40
 
import sys
41
32
 
42
 
import bzrlib
 
33
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
43
34
from bzrlib.branch import Branch
44
 
import bzrlib.bzrdir as bzrdir
45
 
from bzrlib.errors import BzrCommandError
46
 
from bzrlib.osutils import (
47
 
    has_symlinks,
48
 
    pathjoin,
49
 
    rmtree,
50
 
    terminal_width,
51
 
    )
52
 
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
53
 
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
54
 
from bzrlib.tests.blackbox import ExternalBase
55
 
from bzrlib.workingtree import WorkingTree
 
35
from bzrlib.commands import run_bzr
 
36
 
 
37
 
 
38
class ExternalBase(TestCaseInTempDir):
 
39
    def runbzr(self, args, retcode=0, backtick=False):
 
40
        if isinstance(args, basestring):
 
41
            args = args.split()
 
42
 
 
43
        if backtick:
 
44
            return self.run_bzr_captured(args, retcode=retcode)[0]
 
45
        else:
 
46
            return self.run_bzr_captured(args, retcode=retcode)
56
47
 
57
48
 
58
49
class TestCommands(ExternalBase):
59
50
 
 
51
    def test_help_commands(self):
 
52
        self.runbzr('--help')
 
53
        self.runbzr('help')
 
54
        self.runbzr('help commands')
 
55
        self.runbzr('help help')
 
56
        self.runbzr('commit -h')
 
57
 
 
58
    def test_init_branch(self):
 
59
        self.runbzr(['init'])
 
60
 
60
61
    def test_whoami(self):
61
62
        # this should always identify something, if only "john@localhost"
62
63
        self.runbzr("whoami")
68
69
    def test_whoami_branch(self):
69
70
        """branch specific user identity works."""
70
71
        self.runbzr('init')
71
 
        b = bzrlib.branch.Branch.open('.')
72
 
        b.control_files.put_utf8('email', 'Branch Identity <branch@identi.ty>')
 
72
        f = file('.bzr/email', 'wt')
 
73
        f.write('Branch Identity <branch@identi.ty>')
 
74
        f.close()
73
75
        bzr_email = os.environ.get('BZREMAIL')
74
76
        if bzr_email is not None:
75
77
            del os.environ['BZREMAIL']
87
89
        if bzr_email is not None:
88
90
            os.environ['BZREMAIL'] = bzr_email
89
91
 
90
 
    def test_nick_command(self):
91
 
        """bzr nick for viewing, setting nicknames"""
92
 
        os.mkdir('me.dev')
93
 
        os.chdir('me.dev')
94
 
        self.runbzr('init')
95
 
        nick = self.runbzr("nick",backtick=True)
96
 
        self.assertEqual(nick, 'me.dev\n')
97
 
        nick = self.runbzr("nick moo")
98
 
        nick = self.runbzr("nick",backtick=True)
99
 
        self.assertEqual(nick, 'moo\n')
100
 
 
101
92
    def test_invalid_commands(self):
102
 
        self.runbzr("pants", retcode=3)
103
 
        self.runbzr("--pants off", retcode=3)
104
 
        self.runbzr("diff --message foo", retcode=3)
 
93
        self.runbzr("pants", retcode=1)
 
94
        self.runbzr("--pants off", retcode=1)
 
95
        self.runbzr("diff --message foo", retcode=1)
 
96
 
 
97
    def test_empty_commit(self):
 
98
        self.runbzr("init")
 
99
        self.build_tree(['hello.txt'])
 
100
        self.runbzr("commit -m empty", retcode=1)
 
101
        self.runbzr("add hello.txt")
 
102
        self.runbzr("commit -m added")
105
103
 
106
104
    def test_ignore_patterns(self):
107
 
        self.runbzr('init')
108
 
        self.assertEquals(self.capture('unknowns'), '')
 
105
        from bzrlib.branch import Branch
 
106
        
 
107
        b = Branch.initialize('.')
 
108
        self.assertEquals(list(b.unknowns()), [])
109
109
 
110
110
        file('foo.tmp', 'wt').write('tmp files are ignored')
111
 
        self.assertEquals(self.capture('unknowns'), '')
 
111
        self.assertEquals(list(b.unknowns()), [])
 
112
        assert self.capture('unknowns') == ''
112
113
 
113
114
        file('foo.c', 'wt').write('int main() {}')
114
 
        self.assertEquals(self.capture('unknowns'), 'foo.c\n')
 
115
        self.assertEquals(list(b.unknowns()), ['foo.c'])
 
116
        assert self.capture('unknowns') == 'foo.c\n'
115
117
 
116
118
        self.runbzr(['add', 'foo.c'])
117
 
        self.assertEquals(self.capture('unknowns'), '')
 
119
        assert self.capture('unknowns') == ''
118
120
 
119
121
        # 'ignore' works when creating the .bzignore file
120
122
        file('foo.blah', 'wt').write('blah')
121
 
        self.assertEquals(self.capture('unknowns'), 'foo.blah\n')
 
123
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
122
124
        self.runbzr('ignore *.blah')
123
 
        self.assertEquals(self.capture('unknowns'), '')
124
 
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')
 
125
        self.assertEquals(list(b.unknowns()), [])
 
126
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
125
127
 
126
128
        # 'ignore' works when then .bzrignore file already exists
127
129
        file('garh', 'wt').write('garh')
128
 
        self.assertEquals(self.capture('unknowns'), 'garh\n')
 
130
        self.assertEquals(list(b.unknowns()), ['garh'])
 
131
        assert self.capture('unknowns') == 'garh\n'
129
132
        self.runbzr('ignore garh')
130
 
        self.assertEquals(self.capture('unknowns'), '')
131
 
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')
 
133
        self.assertEquals(list(b.unknowns()), [])
 
134
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
132
135
 
133
136
    def test_revert(self):
134
137
        self.runbzr('init')
140
143
        file('goodbye', 'wt').write('baz')
141
144
        self.runbzr('add goodbye')
142
145
        self.runbzr('commit -m setup goodbye')
143
 
 
 
146
        
144
147
        file('hello', 'wt').write('bar')
145
148
        file('goodbye', 'wt').write('qux')
146
149
        self.runbzr('revert hello')
155
158
        os.rmdir('revertdir')
156
159
        self.runbzr('revert')
157
160
 
158
 
        if has_symlinks():
159
 
            os.symlink('/unlikely/to/exist', 'symlink')
160
 
            self.runbzr('add symlink')
161
 
            self.runbzr('commit -m f')
162
 
            os.unlink('symlink')
163
 
            self.runbzr('revert')
164
 
            self.failUnlessExists('symlink')
165
 
            os.unlink('symlink')
166
 
            os.symlink('a-different-path', 'symlink')
167
 
            self.runbzr('revert')
168
 
            self.assertEqual('/unlikely/to/exist',
169
 
                             os.readlink('symlink'))
170
 
        else:
171
 
            self.log("skipping revert symlink tests")
172
 
        
173
161
        file('hello', 'wt').write('xyz')
174
162
        self.runbzr('commit -m xyz hello')
175
163
        self.runbzr('revert -r 1 hello')
176
164
        self.check_file_contents('hello', 'foo')
177
165
        self.runbzr('revert hello')
178
166
        self.check_file_contents('hello', 'xyz')
179
 
        os.chdir('revertdir')
180
 
        self.runbzr('revert')
181
 
        os.chdir('..')
182
167
 
183
168
    def test_mv_modes(self):
184
169
        """Test two modes of operation for mv"""
185
 
        self.runbzr('init')
 
170
        from bzrlib.branch import Branch
 
171
        b = Branch.initialize('.')
186
172
        self.build_tree(['a', 'c', 'subdir/'])
187
 
        self.run_bzr_captured(['add', self.test_dir])
188
 
        self.run_bzr_captured(['mv', 'a', 'b'])
189
 
        self.run_bzr_captured(['mv', 'b', 'subdir'])
190
 
        self.run_bzr_captured(['mv', 'subdir/b', 'a'])
191
 
        self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
192
 
        self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
 
173
        self.run_bzr('add', self.test_dir)
 
174
        self.run_bzr('mv', 'a', 'b')
 
175
        self.run_bzr('mv', 'b', 'subdir')
 
176
        self.run_bzr('mv', 'subdir/b', 'a')
 
177
        self.run_bzr('mv', 'a', 'c', 'subdir')
 
178
        self.run_bzr('mv', 'subdir/a', 'subdir/newa')
 
179
 
193
180
 
194
181
    def test_main_version(self):
195
182
        """Check output from version command and master option is reasonable"""
215
202
        test.runbzr('add goodbye')
216
203
        test.runbzr('commit -m setup goodbye')
217
204
 
218
 
    def test_export(self):
219
 
        os.mkdir('branch')
220
 
        os.chdir('branch')
221
 
        self.example_branch()
222
 
        self.runbzr('export ../latest')
223
 
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
224
 
        self.runbzr('export ../first -r 1')
225
 
        self.assert_(not os.path.exists('../first/goodbye'))
226
 
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
227
 
        self.runbzr('export ../first.gz -r 1')
228
 
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
229
 
        self.runbzr('export ../first.bz2 -r 1')
230
 
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
231
 
 
232
 
        from tarfile import TarFile
233
 
        self.runbzr('export ../first.tar -r 1')
234
 
        self.assert_(os.path.isfile('../first.tar'))
235
 
        tf = TarFile('../first.tar')
236
 
        self.assert_('first/hello' in tf.getnames(), tf.getnames())
237
 
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
238
 
        self.runbzr('export ../first.tar.gz -r 1')
239
 
        self.assert_(os.path.isfile('../first.tar.gz'))
240
 
        self.runbzr('export ../first.tbz2 -r 1')
241
 
        self.assert_(os.path.isfile('../first.tbz2'))
242
 
        self.runbzr('export ../first.tar.bz2 -r 1')
243
 
        self.assert_(os.path.isfile('../first.tar.bz2'))
244
 
        self.runbzr('export ../first.tar.tbz2 -r 1')
245
 
        self.assert_(os.path.isfile('../first.tar.tbz2'))
246
 
 
247
 
        from bz2 import BZ2File
248
 
        tf = TarFile('../first.tar.tbz2', 
249
 
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
250
 
        self.assert_('first.tar/hello' in tf.getnames(), tf.getnames())
251
 
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
252
 
        self.runbzr('export ../first2.tar -r 1 --root pizza')
253
 
        tf = TarFile('../first2.tar')
254
 
        self.assert_('pizza/hello' in tf.getnames(), tf.getnames())
255
 
 
256
 
        from zipfile import ZipFile
257
 
        self.runbzr('export ../first.zip -r 1')
258
 
        self.failUnlessExists('../first.zip')
259
 
        zf = ZipFile('../first.zip')
260
 
        self.assert_('first/hello' in zf.namelist(), zf.namelist())
261
 
        self.assertEqual(zf.read('first/hello'), 'foo')
262
 
 
263
 
        self.runbzr('export ../first2.zip -r 1 --root pizza')
264
 
        zf = ZipFile('../first2.zip')
265
 
        self.assert_('pizza/hello' in zf.namelist(), zf.namelist())
266
 
        
267
 
        self.runbzr('export ../first-zip --format=zip -r 1')
268
 
        zf = ZipFile('../first-zip')
269
 
        self.assert_('first-zip/hello' in zf.namelist(), zf.namelist())
270
 
 
271
 
    def test_inventory(self):
272
 
        bzr = self.runbzr
273
 
        def output_equals(value, *args):
274
 
            out = self.runbzr(['inventory'] + list(args), backtick=True)
275
 
            self.assertEquals(out, value)
276
 
 
277
 
        bzr('init')
278
 
        open('a', 'wb').write('hello\n')
279
 
        os.mkdir('b')
280
 
 
281
 
        bzr('add a b')
282
 
        bzr('commit -m add')
283
 
 
284
 
        output_equals('a\n', '--kind', 'file')
285
 
        output_equals('b\n', '--kind', 'directory')        
286
 
 
287
 
    def test_ls(self):
288
 
        """Test the abilities of 'bzr ls'"""
289
 
        bzr = self.runbzr
290
 
        def bzrout(*args, **kwargs):
291
 
            kwargs['backtick'] = True
292
 
            return self.runbzr(*args, **kwargs)
293
 
 
294
 
        def ls_equals(value, *args):
295
 
            out = self.runbzr(['ls'] + list(args), backtick=True)
296
 
            self.assertEquals(out, value)
297
 
 
298
 
        bzr('init')
299
 
        open('a', 'wb').write('hello\n')
300
 
 
301
 
        # Can't supply both
302
 
        bzr('ls --verbose --null', retcode=3)
303
 
 
304
 
        ls_equals('a\n')
305
 
        ls_equals('?        a\n', '--verbose')
306
 
        ls_equals('a\n', '--unknown')
307
 
        ls_equals('', '--ignored')
308
 
        ls_equals('', '--versioned')
309
 
        ls_equals('a\n', '--unknown', '--ignored', '--versioned')
310
 
        ls_equals('', '--ignored', '--versioned')
311
 
        ls_equals('a\0', '--null')
312
 
 
313
 
        bzr('add a')
314
 
        ls_equals('V        a\n', '--verbose')
315
 
        bzr('commit -m add')
316
 
        
317
 
        os.mkdir('subdir')
318
 
        ls_equals('V        a\n'
319
 
                  '?        subdir/\n'
320
 
                  , '--verbose')
321
 
        open('subdir/b', 'wb').write('b\n')
322
 
        bzr('add')
323
 
        ls_equals('V        a\n'
324
 
                  'V        subdir/\n'
325
 
                  'V        subdir/b\n'
326
 
                  , '--verbose')
327
 
        bzr('commit -m subdir')
328
 
 
329
 
        ls_equals('a\n'
330
 
                  'subdir\n'
331
 
                  , '--non-recursive')
332
 
 
333
 
        ls_equals('V        a\n'
334
 
                  'V        subdir/\n'
335
 
                  , '--verbose', '--non-recursive')
336
 
 
337
 
        # Check what happens in a sub-directory
338
 
        os.chdir('subdir')
339
 
        ls_equals('b\n')
340
 
        ls_equals('b\0'
341
 
                  , '--null')
342
 
        ls_equals('a\n'
343
 
                  'subdir\n'
344
 
                  'subdir/b\n'
345
 
                  , '--from-root')
346
 
        ls_equals('a\0'
347
 
                  'subdir\0'
348
 
                  'subdir/b\0'
349
 
                  , '--from-root', '--null')
350
 
        ls_equals('a\n'
351
 
                  'subdir\n'
352
 
                  , '--from-root', '--non-recursive')
353
 
 
354
 
        os.chdir('..')
355
 
 
356
 
        # Check what happens when we supply a specific revision
357
 
        ls_equals('a\n', '--revision', '1')
358
 
        ls_equals('V        a\n'
359
 
                  , '--verbose', '--revision', '1')
360
 
 
361
 
        os.chdir('subdir')
362
 
        ls_equals('', '--revision', '1')
363
 
 
364
 
        # Now try to do ignored files.
365
 
        os.chdir('..')
366
 
        open('blah.py', 'wb').write('unknown\n')
367
 
        open('blah.pyo', 'wb').write('ignored\n')
368
 
        ls_equals('a\n'
369
 
                  'blah.py\n'
370
 
                  'blah.pyo\n'
371
 
                  'subdir\n'
372
 
                  'subdir/b\n')
373
 
        ls_equals('V        a\n'
374
 
                  '?        blah.py\n'
375
 
                  'I        blah.pyo\n'
376
 
                  'V        subdir/\n'
377
 
                  'V        subdir/b\n'
378
 
                  , '--verbose')
379
 
        ls_equals('blah.pyo\n'
380
 
                  , '--ignored')
381
 
        ls_equals('blah.py\n'
382
 
                  , '--unknown')
383
 
        ls_equals('a\n'
384
 
                  'subdir\n'
385
 
                  'subdir/b\n'
386
 
                  , '--versioned')
387
 
 
388
 
    def test_cat(self):
389
 
        self.runbzr('init')
390
 
        file("myfile", "wb").write("My contents\n")
391
 
        self.runbzr('add')
392
 
        self.runbzr('commit -m myfile')
393
 
        self.run_bzr_captured('cat -r 1 myfile'.split(' '))
394
 
 
395
 
    def test_pull_verbose(self):
396
 
        """Pull changes from one branch to another and watch the output."""
397
 
 
398
 
        os.mkdir('a')
399
 
        os.chdir('a')
400
 
 
401
 
        bzr = self.runbzr
402
 
        self.example_branch()
403
 
 
404
 
        os.chdir('..')
405
 
        bzr('branch a b')
406
 
        os.chdir('b')
407
 
        open('b', 'wb').write('else\n')
408
 
        bzr('add b')
409
 
        bzr(['commit', '-m', 'added b'])
410
 
 
411
 
        os.chdir('../a')
412
 
        out = bzr('pull --verbose ../b', backtick=True)
413
 
        self.failIfEqual(out.find('Added Revisions:'), -1)
414
 
        self.failIfEqual(out.find('message:\n  added b'), -1)
415
 
        self.failIfEqual(out.find('added b'), -1)
416
 
 
417
 
        # Check that --overwrite --verbose prints out the removed entries
418
 
        bzr('commit -m foo --unchanged')
419
 
        os.chdir('../b')
420
 
        bzr('commit -m baz --unchanged')
421
 
        bzr('pull ../a', retcode=3)
422
 
        out = bzr('pull --overwrite --verbose ../a', backtick=1)
423
 
 
424
 
        remove_loc = out.find('Removed Revisions:')
425
 
        self.failIfEqual(remove_loc, -1)
426
 
        added_loc = out.find('Added Revisions:')
427
 
        self.failIfEqual(added_loc, -1)
428
 
 
429
 
        removed_message = out.find('message:\n  baz')
430
 
        self.failIfEqual(removed_message, -1)
431
 
        self.failUnless(remove_loc < removed_message < added_loc)
432
 
 
433
 
        added_message = out.find('message:\n  foo')
434
 
        self.failIfEqual(added_message, -1)
435
 
        self.failUnless(added_loc < added_message)
436
 
        
437
 
    def test_locations(self):
438
 
        """Using and remembering different locations"""
439
 
        os.mkdir('a')
440
 
        os.chdir('a')
441
 
        self.runbzr('init')
442
 
        self.runbzr('commit -m unchanged --unchanged')
443
 
        self.runbzr('pull', retcode=3)
444
 
        self.runbzr('merge', retcode=3)
445
 
        self.runbzr('branch . ../b')
446
 
        os.chdir('../b')
447
 
        self.runbzr('pull')
448
 
        self.runbzr('branch . ../c')
449
 
        self.runbzr('pull ../c')
450
 
        self.runbzr('merge')
451
 
        os.chdir('../a')
 
205
    def test_diff(self):
 
206
        self.example_branch()
 
207
        file('hello', 'wt').write('hello world!')
 
208
        self.runbzr('commit -m fixing hello')
 
209
        output = self.runbzr('diff -r 2..3', backtick=1)
 
210
        self.assert_('\n+hello world!' in output)
 
211
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
212
        self.assert_('\n+baz' in output)
 
213
 
 
214
    def test_diff(self):
 
215
        self.example_branch()
 
216
        file('hello', 'wt').write('hello world!')
 
217
        self.runbzr('commit -m fixing hello')
 
218
        output = self.runbzr('diff -r 2..3', backtick=1)
 
219
        self.assert_('\n+hello world!' in output)
 
220
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
221
        self.assert_('\n+baz' in output)
 
222
 
 
223
    def test_merge(self):
 
224
        from bzrlib.branch import Branch
 
225
        
 
226
        os.mkdir('a')
 
227
        os.chdir('a')
 
228
        self.example_branch()
 
229
        os.chdir('..')
 
230
        self.runbzr('branch a b')
 
231
        os.chdir('b')
 
232
        file('goodbye', 'wt').write('quux')
 
233
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
234
 
 
235
        os.chdir('../a')
 
236
        file('hello', 'wt').write('quuux')
 
237
        # We can't merge when there are in-tree changes
 
238
        self.runbzr('merge ../b', retcode=1)
 
239
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
240
        self.runbzr('merge ../b')
 
241
        self.check_file_contents('goodbye', 'quux')
 
242
        # Merging a branch pulls its revision into the tree
 
243
        a = Branch.open('.')
 
244
        b = Branch.open('../b')
 
245
        a.get_revision_xml(b.last_patch())
 
246
        self.log('pending merges: %s', a.pending_merges())
 
247
        #        assert a.pending_merges() == [b.last_patch()], "Assertion %s %s" \
 
248
        #        % (a.pending_merges(), b.last_patch())
 
249
 
 
250
    def test_pull(self):
 
251
        """Pull changes from one branch to another."""
 
252
        os.mkdir('a')
 
253
        os.chdir('a')
 
254
 
 
255
        self.example_branch()
 
256
        self.runbzr('pull', retcode=1)
 
257
        self.runbzr('missing', retcode=1)
 
258
        self.runbzr('missing .')
 
259
        self.runbzr('missing')
 
260
        self.runbzr('pull')
 
261
        self.runbzr('pull /', retcode=1)
 
262
        self.runbzr('pull')
 
263
 
 
264
        os.chdir('..')
 
265
        self.runbzr('branch a b')
 
266
        os.chdir('b')
 
267
        self.runbzr('pull')
 
268
        self.runbzr('commit -m blah --unchanged')
 
269
        os.chdir('../a')
 
270
        a = Branch.open('.')
 
271
        b = Branch.open('../b')
 
272
        assert a.revision_history() == b.revision_history()[:-1]
452
273
        self.runbzr('pull ../b')
453
 
        self.runbzr('pull')
454
 
        self.runbzr('pull ../c')
455
 
        self.runbzr('branch ../c ../d')
456
 
        rmtree('../c')
457
 
        self.runbzr('pull')
458
 
        os.chdir('../b')
459
 
        self.runbzr('pull')
460
 
        os.chdir('../d')
461
 
        self.runbzr('pull', retcode=3)
462
 
        self.runbzr('pull ../a --remember')
463
 
        self.runbzr('pull')
 
274
        assert a.revision_history() == b.revision_history()
 
275
        self.runbzr('commit -m blah2 --unchanged')
 
276
        os.chdir('../b')
 
277
        self.runbzr('commit -m blah3 --unchanged')
 
278
        self.runbzr('pull ../a', retcode=1)
 
279
        os.chdir('../a')
 
280
        self.runbzr('merge ../b')
 
281
        self.runbzr('commit -m blah4 --unchanged')
 
282
        os.chdir('../b')
 
283
        self.runbzr('pull ../a')
 
284
        assert a.revision_history()[-1] == b.revision_history()[-1]
464
285
        
 
286
    def test_add_reports(self):
 
287
        """add command prints the names of added files."""
 
288
        b = Branch.initialize('.')
 
289
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
290
        out = StringIO()
 
291
        ret = self.apply_redirected(None, out, None,
 
292
                                    run_bzr,
 
293
                                    ['add'])
 
294
        self.assertEquals(ret, 0)
 
295
        # the ordering is not defined at the moment
 
296
        results = sorted(out.getvalue().rstrip('\n').split('\n'))
 
297
        self.assertEquals(['added dir',
 
298
                           'added dir/sub.txt',
 
299
                           'added top.txt',],
 
300
                          results)
 
301
 
465
302
    def test_unknown_command(self):
466
303
        """Handling of unknown command."""
467
304
        out, err = self.run_bzr_captured(['fluffy-badger'],
468
 
                                         retcode=3)
 
305
                                         retcode=1)
469
306
        self.assertEquals(out, '')
470
307
        err.index('unknown command')
471
 
 
472
 
    def create_conflicts(self):
473
 
        """Create a conflicted tree"""
474
 
        os.mkdir('base')
475
 
        os.chdir('base')
476
 
        file('hello', 'wb').write("hi world")
477
 
        file('answer', 'wb').write("42")
478
 
        self.runbzr('init')
479
 
        self.runbzr('add')
480
 
        self.runbzr('commit -m base')
481
 
        self.runbzr('branch . ../other')
482
 
        self.runbzr('branch . ../this')
483
 
        os.chdir('../other')
484
 
        file('hello', 'wb').write("Hello.")
485
 
        file('answer', 'wb').write("Is anyone there?")
486
 
        self.runbzr('commit -m other')
487
 
        os.chdir('../this')
488
 
        file('hello', 'wb').write("Hello, world")
489
 
        self.runbzr('mv answer question')
490
 
        file('question', 'wb').write("What do you get when you multiply six"
491
 
                                   "times nine?")
492
 
        self.runbzr('commit -m this')
493
 
 
494
 
    def test_remerge(self):
495
 
        """Remerge command works as expected"""
496
 
        self.create_conflicts()
497
 
        self.runbzr('merge ../other --show-base', retcode=1)
498
 
        conflict_text = file('hello').read()
499
 
        assert '|||||||' in conflict_text
500
 
        assert 'hi world' in conflict_text
501
 
        self.runbzr('remerge', retcode=1)
502
 
        conflict_text = file('hello').read()
503
 
        assert '|||||||' not in conflict_text
504
 
        assert 'hi world' not in conflict_text
505
 
        os.unlink('hello.OTHER')
506
 
        os.unlink('question.OTHER')
507
 
        self.runbzr('remerge jello --merge-type weave', retcode=3)
508
 
        self.runbzr('remerge hello --merge-type weave', retcode=1)
509
 
        assert os.path.exists('hello.OTHER')
510
 
        self.assertIs(False, os.path.exists('question.OTHER'))
511
 
        file_id = self.runbzr('file-id hello')
512
 
        file_id = self.runbzr('file-id hello.THIS', retcode=3)
513
 
        self.runbzr('remerge --merge-type weave', retcode=1)
514
 
        assert os.path.exists('hello.OTHER')
515
 
        assert not os.path.exists('hello.BASE')
516
 
        assert '|||||||' not in conflict_text
517
 
        assert 'hi world' not in conflict_text
518
 
        self.runbzr('remerge . --merge-type weave --show-base', retcode=3)
519
 
        self.runbzr('remerge . --show-base --reprocess', retcode=3)
520
 
        self.runbzr('remerge . --merge-type weave --reprocess', retcode=1)
521
 
        self.runbzr('remerge hello --show-base', retcode=1)
522
 
        self.runbzr('remerge hello --reprocess', retcode=1)
523
 
        self.runbzr('resolve --all')
524
 
        self.runbzr('commit -m done',)
525
 
        self.runbzr('remerge', retcode=3)
526
 
 
527
 
    def test_status(self):
528
 
        os.mkdir('branch1')
529
 
        os.chdir('branch1')
530
 
        self.runbzr('init')
531
 
        self.runbzr('commit --unchanged --message f')
532
 
        self.runbzr('branch . ../branch2')
533
 
        self.runbzr('branch . ../branch3')
534
 
        self.runbzr('commit --unchanged --message peter')
535
 
        os.chdir('../branch2')
536
 
        self.runbzr('merge ../branch1')
537
 
        self.runbzr('commit --unchanged --message pumpkin')
538
 
        os.chdir('../branch3')
539
 
        self.runbzr('merge ../branch2')
540
 
        message = self.capture('status')
541
 
 
542
 
 
543
 
    def test_conflicts(self):
544
 
        """Handling of merge conflicts"""
545
 
        self.create_conflicts()
546
 
        self.runbzr('merge ../other --show-base', retcode=1)
547
 
        conflict_text = file('hello').read()
548
 
        self.assert_('<<<<<<<' in conflict_text)
549
 
        self.assert_('>>>>>>>' in conflict_text)
550
 
        self.assert_('=======' in conflict_text)
551
 
        self.assert_('|||||||' in conflict_text)
552
 
        self.assert_('hi world' in conflict_text)
553
 
        self.runbzr('revert')
554
 
        self.runbzr('resolve --all')
555
 
        self.runbzr('merge ../other', retcode=1)
556
 
        conflict_text = file('hello').read()
557
 
        self.assert_('|||||||' not in conflict_text)
558
 
        self.assert_('hi world' not in conflict_text)
559
 
        result = self.runbzr('conflicts', backtick=1)
560
 
        self.assertEquals(result, "Text conflict in hello\nText conflict in"
561
 
                                  " question\n")
562
 
        result = self.runbzr('status', backtick=1)
563
 
        self.assert_("conflicts:\n  Text conflict in hello\n"
564
 
                     "  Text conflict in question\n" in result, result)
565
 
        self.runbzr('resolve hello')
566
 
        result = self.runbzr('conflicts', backtick=1)
567
 
        self.assertEquals(result, "Text conflict in question\n")
568
 
        self.runbzr('commit -m conflicts', retcode=3)
569
 
        self.runbzr('resolve --all')
570
 
        result = self.runbzr('conflicts', backtick=1)
571
 
        self.runbzr('commit -m conflicts')
572
 
        self.assertEquals(result, "")
573
 
 
574
 
    def test_push(self):
575
 
        # create a source branch
576
 
        os.mkdir('my-branch')
577
 
        os.chdir('my-branch')
578
 
        self.example_branch()
579
 
 
580
 
        # with no push target, fail
581
 
        self.runbzr('push', retcode=3)
582
 
        # with an explicit target work
583
 
        self.runbzr('push ../output-branch')
584
 
        # with an implicit target work
585
 
        self.runbzr('push')
586
 
        # nothing missing
587
 
        self.runbzr('missing ../output-branch')
588
 
        # advance this branch
589
 
        self.runbzr('commit --unchanged -m unchanged')
590
 
 
591
 
        os.chdir('../output-branch')
592
 
        # There is no longer a difference as long as we have
593
 
        # access to the working tree
594
 
        self.runbzr('diff')
595
 
 
596
 
        # But we should be missing a revision
597
 
        self.runbzr('missing ../my-branch', retcode=1)
598
 
 
599
 
        # diverge the branches
600
 
        self.runbzr('commit --unchanged -m unchanged')
601
 
        os.chdir('../my-branch')
602
 
        # cannot push now
603
 
        self.runbzr('push', retcode=3)
604
 
        # and there are difference
605
 
        self.runbzr('missing ../output-branch', retcode=1)
606
 
        self.runbzr('missing --verbose ../output-branch', retcode=1)
607
 
        # but we can force a push
608
 
        self.runbzr('push --overwrite')
609
 
        # nothing missing
610
 
        self.runbzr('missing ../output-branch')
611
308
        
612
 
        # pushing to a new dir with no parent should fail
613
 
        self.runbzr('push ../missing/new-branch', retcode=3)
614
 
        # unless we provide --create-prefix
615
 
        self.runbzr('push --create-prefix ../missing/new-branch')
616
 
        # nothing missing
617
 
        self.runbzr('missing ../missing/new-branch')
618
 
 
619
 
    def test_external_command(self):
620
 
        """Test that external commands can be run by setting the path
621
 
        """
622
 
        # We don't at present run bzr in a subprocess for blackbox tests, and so 
623
 
        # don't really capture stdout, only the internal python stream.
624
 
        # Therefore we don't use a subcommand that produces any output or does
625
 
        # anything -- we just check that it can be run successfully.  
626
 
        cmd_name = 'test-command'
627
 
        if sys.platform == 'win32':
628
 
            cmd_name += '.bat'
629
 
        oldpath = os.environ.get('BZRPATH', None)
630
 
        bzr = self.capture
631
 
        try:
632
 
            if os.environ.has_key('BZRPATH'):
633
 
                del os.environ['BZRPATH']
634
 
 
635
 
            f = file(cmd_name, 'wb')
636
 
            if sys.platform == 'win32':
637
 
                f.write('@echo off\n')
638
 
            else:
639
 
                f.write('#!/bin/sh\n')
640
 
            # f.write('echo Hello from test-command')
641
 
            f.close()
642
 
            os.chmod(cmd_name, 0755)
643
 
 
644
 
            # It should not find the command in the local 
645
 
            # directory by default, since it is not in my path
646
 
            bzr(cmd_name, retcode=3)
647
 
 
648
 
            # Now put it into my path
649
 
            os.environ['BZRPATH'] = '.'
650
 
 
651
 
            bzr(cmd_name)
652
 
 
653
 
            # Make sure empty path elements are ignored
654
 
            os.environ['BZRPATH'] = os.pathsep
655
 
 
656
 
            bzr(cmd_name, retcode=3)
657
 
 
658
 
        finally:
659
 
            if oldpath:
660
 
                os.environ['BZRPATH'] = oldpath
661
 
 
662
 
 
663
 
def listdir_sorted(dir):
664
 
    L = os.listdir(dir)
665
 
    L.sort()
666
 
    return L
667
309
 
668
310
 
669
311
class OldTests(ExternalBase):
683
325
        runbzr('init')
684
326
 
685
327
        self.assertEquals(capture('root').rstrip(),
686
 
                          pathjoin(self.test_dir, 'branch1'))
 
328
                          os.path.join(self.test_dir, 'branch1'))
687
329
 
688
330
        progress("status of new file")
689
331
 
694
336
        self.assertEquals(capture('unknowns'), 'test.txt\n')
695
337
 
696
338
        out = capture("status")
697
 
        self.assertEquals(out, 'unknown:\n  test.txt\n')
 
339
        assert out == 'unknown:\n  test.txt\n'
698
340
 
699
341
        out = capture("status --all")
700
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
342
        assert out == "unknown:\n  test.txt\n"
701
343
 
702
344
        out = capture("status test.txt --all")
703
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
345
        assert out == "unknown:\n  test.txt\n"
704
346
 
705
347
        f = file('test2.txt', 'wt')
706
348
        f.write('goodbye cruel world...\n')
707
349
        f.close()
708
350
 
709
351
        out = capture("status test.txt")
710
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
352
        assert out == "unknown:\n  test.txt\n"
711
353
 
712
354
        out = capture("status")
713
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
 
355
        assert out == ("unknown:\n"
 
356
                       "  test.txt\n"
 
357
                       "  test2.txt\n")
714
358
 
715
359
        os.unlink('test2.txt')
716
360
 
717
361
        progress("command aliases")
718
362
        out = capture("st --all")
719
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
363
        assert out == ("unknown:\n"
 
364
                       "  test.txt\n")
720
365
 
721
366
        out = capture("stat")
722
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
367
        assert out == ("unknown:\n"
 
368
                       "  test.txt\n")
723
369
 
724
370
        progress("command help")
725
371
        runbzr("help st")
726
372
        runbzr("help")
727
373
        runbzr("help commands")
728
 
        runbzr("help slartibartfast", 3)
 
374
        runbzr("help slartibartfast", 1)
729
375
 
730
376
        out = capture("help ci")
731
377
        out.index('aliases: ')
732
378
 
733
379
        progress("can't rename unversioned file")
734
 
        runbzr("rename test.txt new-test.txt", 3)
 
380
        runbzr("rename test.txt new-test.txt", 1)
735
381
 
736
382
        progress("adding a file")
737
383
 
738
384
        runbzr("add test.txt")
739
 
        self.assertEquals(capture("unknowns"), '')
740
 
        self.assertEquals(capture("status --all"), ("added:\n" "  test.txt\n"))
 
385
        assert capture("unknowns") == ''
 
386
        assert capture("status --all") == ("added:\n"
 
387
                                                "  test.txt\n")
741
388
 
742
389
        progress("rename newly-added file")
743
390
        runbzr("rename test.txt hello.txt")
744
 
        self.assert_(os.path.exists("hello.txt"))
745
 
        self.assert_(not os.path.exists("test.txt"))
 
391
        assert os.path.exists("hello.txt")
 
392
        assert not os.path.exists("test.txt")
746
393
 
747
 
        self.assertEquals(capture("revno"), '0\n')
 
394
        assert capture("revno") == '0\n'
748
395
 
749
396
        progress("add first revision")
750
397
        runbzr(['commit', '-m', 'add first revision'])
751
398
 
752
399
        progress("more complex renames")
753
400
        os.mkdir("sub1")
754
 
        runbzr("rename hello.txt sub1", 3)
755
 
        runbzr("rename hello.txt sub1/hello.txt", 3)
756
 
        runbzr("move hello.txt sub1", 3)
 
401
        runbzr("rename hello.txt sub1", 1)
 
402
        runbzr("rename hello.txt sub1/hello.txt", 1)
 
403
        runbzr("move hello.txt sub1", 1)
757
404
 
758
405
        runbzr("add sub1")
759
406
        runbzr("rename sub1 sub2")
760
407
        runbzr("move hello.txt sub2")
761
 
        self.assertEqual(capture("relpath sub2/hello.txt"),
762
 
                         pathjoin("sub2", "hello.txt\n"))
 
408
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
763
409
 
764
 
        self.assert_(exists("sub2"))
765
 
        self.assert_(exists("sub2/hello.txt"))
766
 
        self.assert_(not exists("sub1"))
767
 
        self.assert_(not exists("hello.txt"))
 
410
        assert exists("sub2")
 
411
        assert exists("sub2/hello.txt")
 
412
        assert not exists("sub1")
 
413
        assert not exists("hello.txt")
768
414
 
769
415
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
770
416
 
771
417
        mkdir("sub1")
772
418
        runbzr('add sub1')
773
419
        runbzr('move sub2/hello.txt sub1')
774
 
        self.assert_(not exists('sub2/hello.txt'))
775
 
        self.assert_(exists('sub1/hello.txt'))
 
420
        assert not exists('sub2/hello.txt')
 
421
        assert exists('sub1/hello.txt')
776
422
        runbzr('move sub2 sub1')
777
 
        self.assert_(not exists('sub2'))
778
 
        self.assert_(exists('sub1/sub2'))
 
423
        assert not exists('sub2')
 
424
        assert exists('sub1/sub2')
779
425
 
780
426
        runbzr(['commit', '-m', 'rename nested subdirectories'])
781
427
 
782
428
        chdir('sub1/sub2')
783
429
        self.assertEquals(capture('root')[:-1],
784
 
                          pathjoin(self.test_dir, 'branch1'))
 
430
                          os.path.join(self.test_dir, 'branch1'))
785
431
        runbzr('move ../hello.txt .')
786
 
        self.assert_(exists('./hello.txt'))
 
432
        assert exists('./hello.txt')
787
433
        self.assertEquals(capture('relpath hello.txt'),
788
 
                          pathjoin('sub1', 'sub2', 'hello.txt') + '\n')
789
 
        self.assertEquals(capture('relpath ../../sub1/sub2/hello.txt'), pathjoin('sub1', 'sub2', 'hello.txt\n'))
 
434
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
435
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
790
436
        runbzr(['commit', '-m', 'move to parent directory'])
791
437
        chdir('..')
792
 
        self.assertEquals(capture('relpath sub2/hello.txt'), pathjoin('sub1', 'sub2', 'hello.txt\n'))
 
438
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
793
439
 
794
440
        runbzr('move sub2/hello.txt .')
795
 
        self.assert_(exists('hello.txt'))
 
441
        assert exists('hello.txt')
796
442
 
797
443
        f = file('hello.txt', 'wt')
798
444
        f.write('some nice new content\n')
799
445
        f.close()
800
446
 
801
447
        f = file('msg.tmp', 'wt')
802
 
        f.write('this is my new commit\nand it has multiple lines, for fun')
 
448
        f.write('this is my new commit\n')
803
449
        f.close()
804
450
 
805
451
        runbzr('commit -F msg.tmp')
806
452
 
807
 
        self.assertEquals(capture('revno'), '5\n')
 
453
        assert capture('revno') == '5\n'
808
454
        runbzr('export -r 5 export-5.tmp')
809
455
        runbzr('export export.tmp')
810
456
 
811
457
        runbzr('log')
812
458
        runbzr('log -v')
813
459
        runbzr('log -v --forward')
814
 
        runbzr('log -m', retcode=3)
 
460
        runbzr('log -m', retcode=1)
815
461
        log_out = capture('log -m commit')
816
 
        self.assert_("this is my new commit\n  and" in log_out)
817
 
        self.assert_("rename nested" not in log_out)
818
 
        self.assert_('revision-id' not in log_out)
819
 
        self.assert_('revision-id' in capture('log --show-ids -m commit'))
 
462
        assert "this is my new commit" in log_out
 
463
        assert "rename nested" not in log_out
 
464
        assert 'revision-id' not in log_out
 
465
        assert 'revision-id' in capture('log --show-ids -m commit')
820
466
 
821
 
        log_out = capture('log --line')
822
 
        # determine the widest line we want
823
 
        max_width = terminal_width() - 1
824
 
        for line in log_out.splitlines():
825
 
            self.assert_(len(line) <= max_width, len(line))
826
 
        self.assert_("this is my new commit and" not in log_out)
827
 
        self.assert_("this is my new commit" in log_out)
828
467
 
829
468
        progress("file with spaces in name")
830
469
        mkdir('sub directory')
831
470
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
832
471
        runbzr('add .')
833
 
        runbzr('diff', retcode=1)
 
472
        runbzr('diff')
834
473
        runbzr('commit -m add-spaces')
835
474
        runbzr('check')
836
475
 
839
478
 
840
479
        runbzr('info')
841
480
 
842
 
        if has_symlinks():
843
 
            progress("symlinks")
844
 
            mkdir('symlinks')
845
 
            chdir('symlinks')
846
 
            runbzr('init')
847
 
            os.symlink("NOWHERE1", "link1")
848
 
            runbzr('add link1')
849
 
            self.assertEquals(self.capture('unknowns'), '')
850
 
            runbzr(['commit', '-m', '1: added symlink link1'])
851
 
    
852
 
            mkdir('d1')
853
 
            runbzr('add d1')
854
 
            self.assertEquals(self.capture('unknowns'), '')
855
 
            os.symlink("NOWHERE2", "d1/link2")
856
 
            self.assertEquals(self.capture('unknowns'), 'd1/link2\n')
857
 
            # is d1/link2 found when adding d1
858
 
            runbzr('add d1')
859
 
            self.assertEquals(self.capture('unknowns'), '')
860
 
            os.symlink("NOWHERE3", "d1/link3")
861
 
            self.assertEquals(self.capture('unknowns'), 'd1/link3\n')
862
 
            runbzr(['commit', '-m', '2: added dir, symlink'])
863
 
    
864
 
            runbzr('rename d1 d2')
865
 
            runbzr('move d2/link2 .')
866
 
            runbzr('move link1 d2')
867
 
            self.assertEquals(os.readlink("./link2"), "NOWHERE2")
868
 
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
869
 
            runbzr('add d2/link3')
870
 
            runbzr('diff', retcode=1)
871
 
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
872
 
    
873
 
            os.unlink("link2")
874
 
            os.symlink("TARGET 2", "link2")
875
 
            os.unlink("d2/link1")
876
 
            os.symlink("TARGET 1", "d2/link1")
877
 
            runbzr('diff', retcode=1)
878
 
            self.assertEquals(self.capture("relpath d2/link1"), "d2/link1\n")
879
 
            runbzr(['commit', '-m', '4: retarget of two links'])
880
 
    
881
 
            runbzr('remove d2/link1')
882
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
883
 
            runbzr(['commit', '-m', '5: remove d2/link1'])
884
 
            # try with the rm alias
885
 
            runbzr('add d2/link1')
886
 
            runbzr(['commit', '-m', '6: add d2/link1'])
887
 
            runbzr('rm d2/link1')
888
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
889
 
            runbzr(['commit', '-m', '7: remove d2/link1'])
890
 
    
891
 
            os.mkdir("d1")
892
 
            runbzr('add d1')
893
 
            runbzr('rename d2/link3 d1/link3new')
894
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
895
 
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
896
 
            
897
 
            runbzr(['check'])
898
 
            
899
 
            runbzr(['export', '-r', '1', 'exp1.tmp'])
900
 
            chdir("exp1.tmp")
901
 
            self.assertEquals(listdir_sorted("."), [ "link1" ])
902
 
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
903
 
            chdir("..")
904
 
            
905
 
            runbzr(['export', '-r', '2', 'exp2.tmp'])
906
 
            chdir("exp2.tmp")
907
 
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
908
 
            chdir("..")
909
 
            
910
 
            runbzr(['export', '-r', '3', 'exp3.tmp'])
911
 
            chdir("exp3.tmp")
912
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
913
 
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
914
 
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
915
 
            self.assertEquals(os.readlink("link2")   , "NOWHERE2")
916
 
            chdir("..")
917
 
            
918
 
            runbzr(['export', '-r', '4', 'exp4.tmp'])
919
 
            chdir("exp4.tmp")
920
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
921
 
            self.assertEquals(os.readlink("d2/link1"), "TARGET 1")
922
 
            self.assertEquals(os.readlink("link2")   , "TARGET 2")
923
 
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
924
 
            chdir("..")
925
 
            
926
 
            runbzr(['export', '-r', '5', 'exp5.tmp'])
927
 
            chdir("exp5.tmp")
928
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
929
 
            self.assert_(os.path.islink("link2"))
930
 
            self.assert_(listdir_sorted("d2")== [ "link3" ])
931
 
            chdir("..")
932
 
            
933
 
            runbzr(['export', '-r', '8', 'exp6.tmp'])
934
 
            chdir("exp6.tmp")
935
 
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
936
 
            self.assertEquals(listdir_sorted("d1"), [ "link3new" ])
937
 
            self.assertEquals(listdir_sorted("d2"), [])
938
 
            self.assertEquals(os.readlink("d1/link3new"), "NOWHERE3")
939
 
            chdir("..")
940
 
        else:
941
 
            progress("skipping symlink tests")
942
 
 
943
 
 
944
 
class RemoteTests(object):
945
 
    """Test bzr ui commands against remote branches."""
946
 
 
947
 
    def test_branch(self):
948
 
        os.mkdir('from')
949
 
        wt = self.make_branch_and_tree('from')
950
 
        branch = wt.branch
951
 
        wt.commit('empty commit for nonsense', allow_pointless=True)
952
 
        url = self.get_readonly_url('from')
953
 
        self.run_bzr('branch', url, 'to')
954
 
        branch = Branch.open('to')
955
 
        self.assertEqual(1, len(branch.revision_history()))
956
 
        # the branch should be set in to to from
957
 
        self.assertEqual(url + '/', branch.get_parent())
958
 
 
959
 
    def test_log(self):
960
 
        self.build_tree(['branch/', 'branch/file'])
961
 
        self.capture('init branch')
962
 
        self.capture('add branch/file')
963
 
        self.capture('commit -m foo branch')
964
 
        url = self.get_readonly_url('branch/file')
965
 
        output = self.capture('log %s' % url)
966
 
        self.assertEqual(8, len(output.split('\n')))
967
 
        
968
 
    def test_check(self):
969
 
        self.build_tree(['branch/', 'branch/file'])
970
 
        self.capture('init branch')
971
 
        self.capture('add branch/file')
972
 
        self.capture('commit -m foo branch')
973
 
        url = self.get_readonly_url('branch/')
974
 
        self.run_bzr('check', url)
975
 
    
976
 
    def test_push(self):
977
 
        # create a source branch
978
 
        os.mkdir('my-branch')
979
 
        os.chdir('my-branch')
980
 
        self.run_bzr('init')
981
 
        file('hello', 'wt').write('foo')
982
 
        self.run_bzr('add', 'hello')
983
 
        self.run_bzr('commit', '-m', 'setup')
984
 
 
985
 
        # with an explicit target work
986
 
        self.run_bzr('push', self.get_url('output-branch'))
987
 
 
988
 
    
989
 
class HTTPTests(TestCaseWithWebserver, RemoteTests):
990
 
    """Test various commands against a HTTP server."""
991
 
    
992
 
    
993
 
class SFTPTestsAbsolute(TestCaseWithSFTPServer, RemoteTests):
994
 
    """Test various commands against a SFTP server using abs paths."""
995
 
 
996
 
    
997
 
class SFTPTestsAbsoluteSibling(TestCaseWithSFTPServer, RemoteTests):
998
 
    """Test various commands against a SFTP server using abs paths."""
999
 
 
1000
 
    def setUp(self):
1001
 
        super(SFTPTestsAbsoluteSibling, self).setUp()
1002
 
        self._override_home = '/dev/noone/runs/tests/here'
1003
 
 
1004
 
    
1005
 
class SFTPTestsRelative(TestCaseWithSFTPServer, RemoteTests):
1006
 
    """Test various commands against a SFTP server using homedir rel paths."""
1007
 
 
1008
 
    def setUp(self):
1009
 
        super(SFTPTestsRelative, self).setUp()
1010
 
        self._get_remote_is_absolute = False