~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

add a clean target

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
 
from cStringIO import StringIO
 
29
import sys
38
30
import os
39
 
import re
40
 
import sys
41
31
 
42
 
import bzrlib
 
32
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
43
33
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
 
34
from bzrlib.commands import run_bzr
 
35
 
 
36
 
 
37
class ExternalBase(TestCaseInTempDir):
 
38
    def runbzr(self, args, retcode=0,backtick=False):
 
39
        if isinstance(args, basestring):
 
40
            args = args.split()
 
41
 
 
42
        if backtick:
 
43
            return self.backtick(['python', self.BZRPATH,] + args,
 
44
                           retcode=retcode)
 
45
        else:
 
46
            return self.runcmd(['python', self.BZRPATH,] + args,
 
47
                           retcode=retcode)
56
48
 
57
49
 
58
50
class TestCommands(ExternalBase):
59
51
 
 
52
    def test_help_commands(self):
 
53
        self.runbzr('--help')
 
54
        self.runbzr('help')
 
55
        self.runbzr('help commands')
 
56
        self.runbzr('help help')
 
57
        self.runbzr('commit -h')
 
58
 
 
59
    def test_init_branch(self):
 
60
        self.runbzr(['init'])
 
61
 
60
62
    def test_whoami(self):
61
63
        # this should always identify something, if only "john@localhost"
62
64
        self.runbzr("whoami")
68
70
    def test_whoami_branch(self):
69
71
        """branch specific user identity works."""
70
72
        self.runbzr('init')
71
 
        b = bzrlib.branch.Branch.open('.')
72
 
        b.control_files.put_utf8('email', 'Branch Identity <branch@identi.ty>')
73
 
        bzr_email = os.environ.get('BZREMAIL')
74
 
        if bzr_email is not None:
75
 
            del os.environ['BZREMAIL']
 
73
        f = file('.bzr/email', 'wt')
 
74
        f.write('Branch Identity <branch@identi.ty>')
 
75
        f.close()
76
76
        whoami = self.runbzr("whoami",backtick=True)
77
77
        whoami_email = self.runbzr("whoami --email",backtick=True)
78
78
        self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
79
79
        self.assertTrue(whoami_email.startswith('branch@identi.ty'))
80
 
        # Verify that the environment variable overrides the value 
81
 
        # in the file
82
 
        os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
83
 
        whoami = self.runbzr("whoami",backtick=True)
84
 
        whoami_email = self.runbzr("whoami --email",backtick=True)
85
 
        self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
86
 
        self.assertTrue(whoami_email.startswith('other@environ.ment'))
87
 
        if bzr_email is not None:
88
 
            os.environ['BZREMAIL'] = bzr_email
89
 
 
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
80
 
101
81
    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)
 
82
        self.runbzr("pants", retcode=1)
 
83
        self.runbzr("--pants off", retcode=1)
 
84
        self.runbzr("diff --message foo", retcode=1)
 
85
 
 
86
    def test_empty_commit(self):
 
87
        self.runbzr("init")
 
88
        self.build_tree(['hello.txt'])
 
89
        self.runbzr("commit -m empty", retcode=1)
 
90
        self.runbzr("add hello.txt")
 
91
        self.runbzr("commit -m added")
105
92
 
106
93
    def test_ignore_patterns(self):
107
 
        self.runbzr('init')
108
 
        self.assertEquals(self.capture('unknowns'), '')
 
94
        from bzrlib.branch import Branch
 
95
        
 
96
        b = Branch('.', init=True)
 
97
        self.assertEquals(list(b.unknowns()), [])
109
98
 
110
99
        file('foo.tmp', 'wt').write('tmp files are ignored')
111
 
        self.assertEquals(self.capture('unknowns'), '')
 
100
        self.assertEquals(list(b.unknowns()), [])
 
101
        assert self.backtick('bzr unknowns') == ''
112
102
 
113
103
        file('foo.c', 'wt').write('int main() {}')
114
 
        self.assertEquals(self.capture('unknowns'), 'foo.c\n')
 
104
        self.assertEquals(list(b.unknowns()), ['foo.c'])
 
105
        assert self.backtick('bzr unknowns') == 'foo.c\n'
115
106
 
116
107
        self.runbzr(['add', 'foo.c'])
117
 
        self.assertEquals(self.capture('unknowns'), '')
 
108
        assert self.backtick('bzr unknowns') == ''
118
109
 
119
110
        # 'ignore' works when creating the .bzignore file
120
111
        file('foo.blah', 'wt').write('blah')
121
 
        self.assertEquals(self.capture('unknowns'), 'foo.blah\n')
 
112
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
122
113
        self.runbzr('ignore *.blah')
123
 
        self.assertEquals(self.capture('unknowns'), '')
124
 
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')
 
114
        self.assertEquals(list(b.unknowns()), [])
 
115
        assert file('.bzrignore', 'rb').read() == '*.blah\n'
125
116
 
126
117
        # 'ignore' works when then .bzrignore file already exists
127
118
        file('garh', 'wt').write('garh')
128
 
        self.assertEquals(self.capture('unknowns'), 'garh\n')
 
119
        self.assertEquals(list(b.unknowns()), ['garh'])
 
120
        assert self.backtick('bzr unknowns') == 'garh\n'
129
121
        self.runbzr('ignore garh')
130
 
        self.assertEquals(self.capture('unknowns'), '')
131
 
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')
 
122
        self.assertEquals(list(b.unknowns()), [])
 
123
        assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
132
124
 
133
125
    def test_revert(self):
134
126
        self.runbzr('init')
140
132
        file('goodbye', 'wt').write('baz')
141
133
        self.runbzr('add goodbye')
142
134
        self.runbzr('commit -m setup goodbye')
143
 
 
 
135
        
144
136
        file('hello', 'wt').write('bar')
145
137
        file('goodbye', 'wt').write('qux')
146
138
        self.runbzr('revert hello')
155
147
        os.rmdir('revertdir')
156
148
        self.runbzr('revert')
157
149
 
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
 
        file('hello', 'wt').write('xyz')
174
 
        self.runbzr('commit -m xyz hello')
175
 
        self.runbzr('revert -r 1 hello')
176
 
        self.check_file_contents('hello', 'foo')
177
 
        self.runbzr('revert hello')
178
 
        self.check_file_contents('hello', 'xyz')
179
 
        os.chdir('revertdir')
180
 
        self.runbzr('revert')
181
 
        os.chdir('..')
182
 
 
183
150
    def test_mv_modes(self):
184
151
        """Test two modes of operation for mv"""
185
 
        self.runbzr('init')
 
152
        from bzrlib.branch import Branch
 
153
        b = Branch('.', init=True)
186
154
        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'])
 
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
 
193
162
 
194
163
    def test_main_version(self):
195
164
        """Check output from version command and master option is reasonable"""
215
184
        test.runbzr('add goodbye')
216
185
        test.runbzr('commit -m setup goodbye')
217
186
 
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')
 
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')
 
196
 
 
197
    def test_merge(self):
 
198
        from bzrlib.branch import Branch
 
199
        
 
200
        os.mkdir('a')
 
201
        os.chdir('a')
 
202
        self.example_branch()
 
203
        os.chdir('..')
 
204
        self.runbzr('branch a b')
 
205
        os.chdir('b')
 
206
        file('goodbye', 'wt').write('quux')
 
207
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
208
 
 
209
        os.chdir('../a')
 
210
        file('hello', 'wt').write('quuux')
 
211
        # We can't merge when there are in-tree changes
 
212
        self.runbzr('merge ../b', retcode=1)
 
213
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
214
        self.runbzr('merge ../b')
 
215
        self.check_file_contents('goodbye', 'quux')
 
216
        # Merging a branch pulls its revision into the tree
 
217
        a = Branch('.')
 
218
        b = Branch('../b')
 
219
        a.get_revision_xml(b.last_patch())
 
220
        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())
 
223
 
 
224
    def test_pull(self):
 
225
        """Pull changes from one branch to another."""
 
226
        os.mkdir('a')
 
227
        os.chdir('a')
 
228
 
 
229
        self.example_branch()
 
230
        self.runbzr('pull', retcode=1)
 
231
        self.runbzr('missing', retcode=1)
 
232
        self.runbzr('missing .')
 
233
        self.runbzr('missing')
 
234
        self.runbzr('pull')
 
235
        self.runbzr('pull /', retcode=1)
 
236
        self.runbzr('pull')
 
237
 
 
238
        os.chdir('..')
 
239
        self.runbzr('branch a b')
 
240
        os.chdir('b')
 
241
        self.runbzr('pull')
 
242
        self.runbzr('commit -m blah --unchanged')
 
243
        os.chdir('../a')
 
244
        a = Branch('.')
 
245
        b = Branch('../b')
 
246
        assert a.revision_history() == b.revision_history()[:-1]
452
247
        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')
464
 
        
465
 
    def test_unknown_command(self):
466
 
        """Handling of unknown command."""
467
 
        out, err = self.run_bzr_captured(['fluffy-badger'],
468
 
                                         retcode=3)
469
 
        self.assertEquals(out, '')
470
 
        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
 
        
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
 
248
        assert a.revision_history() == b.revision_history()
 
249
        self.runbzr('commit -m blah2 --unchanged')
 
250
        os.chdir('../b')
 
251
        self.runbzr('commit -m blah3 --unchanged')
 
252
        self.runbzr('pull ../a', retcode=1)
 
253
        os.chdir('../a')
 
254
        self.runbzr('merge ../b')
 
255
        self.runbzr('commit -m blah4 --unchanged')
 
256
        os.chdir('../b')
 
257
        self.runbzr('pull ../a')
 
258
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
259
        
 
260
 
 
261
    def test_add_reports(self):
 
262
        """add command prints the names of added files."""
 
263
        b = Branch('.', init=True)
 
264
        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
 
 
274
        # the ordering is not defined at the moment
 
275
        results = sorted(out.getvalue().rstrip('\n').split('\n'))
 
276
        self.assertEquals(['added dir',
 
277
                           'added dir/sub.txt',
 
278
                           'added top.txt',],
 
279
                          results)
667
280
 
668
281
 
669
282
class OldTests(ExternalBase):
674
287
        from os.path import exists
675
288
 
676
289
        runbzr = self.runbzr
677
 
        capture = self.capture
 
290
        backtick = self.backtick
678
291
        progress = self.log
679
292
 
680
293
        progress("basic branch creation")
682
295
        chdir('branch1')
683
296
        runbzr('init')
684
297
 
685
 
        self.assertEquals(capture('root').rstrip(),
686
 
                          pathjoin(self.test_dir, 'branch1'))
 
298
        self.assertEquals(backtick('bzr root').rstrip(),
 
299
                          os.path.join(self.test_dir, 'branch1'))
687
300
 
688
301
        progress("status of new file")
689
302
 
691
304
        f.write('hello world!\n')
692
305
        f.close()
693
306
 
694
 
        self.assertEquals(capture('unknowns'), 'test.txt\n')
695
 
 
696
 
        out = capture("status")
697
 
        self.assertEquals(out, 'unknown:\n  test.txt\n')
698
 
 
699
 
        out = capture("status --all")
700
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
701
 
 
702
 
        out = capture("status test.txt --all")
703
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
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"
704
318
 
705
319
        f = file('test2.txt', 'wt')
706
320
        f.write('goodbye cruel world...\n')
707
321
        f.close()
708
322
 
709
 
        out = capture("status test.txt")
710
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
323
        out = backtick("bzr status test.txt")
 
324
        assert out == "unknown:\n  test.txt\n"
711
325
 
712
 
        out = capture("status")
713
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
 
326
        out = backtick("bzr status")
 
327
        assert out == ("unknown:\n"
 
328
                       "  test.txt\n"
 
329
                       "  test2.txt\n")
714
330
 
715
331
        os.unlink('test2.txt')
716
332
 
717
333
        progress("command aliases")
718
 
        out = capture("st --all")
719
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
334
        out = backtick("bzr st --all")
 
335
        assert out == ("unknown:\n"
 
336
                       "  test.txt\n")
720
337
 
721
 
        out = capture("stat")
722
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
338
        out = backtick("bzr stat")
 
339
        assert out == ("unknown:\n"
 
340
                       "  test.txt\n")
723
341
 
724
342
        progress("command help")
725
343
        runbzr("help st")
726
344
        runbzr("help")
727
345
        runbzr("help commands")
728
 
        runbzr("help slartibartfast", 3)
 
346
        runbzr("help slartibartfast", 1)
729
347
 
730
 
        out = capture("help ci")
 
348
        out = backtick("bzr help ci")
731
349
        out.index('aliases: ')
732
350
 
733
351
        progress("can't rename unversioned file")
734
 
        runbzr("rename test.txt new-test.txt", 3)
 
352
        runbzr("rename test.txt new-test.txt", 1)
735
353
 
736
354
        progress("adding a file")
737
355
 
738
356
        runbzr("add test.txt")
739
 
        self.assertEquals(capture("unknowns"), '')
740
 
        self.assertEquals(capture("status --all"), ("added:\n" "  test.txt\n"))
 
357
        assert backtick("bzr unknowns") == ''
 
358
        assert backtick("bzr status --all") == ("added:\n"
 
359
                                                "  test.txt\n")
741
360
 
742
361
        progress("rename newly-added file")
743
362
        runbzr("rename test.txt hello.txt")
744
 
        self.assert_(os.path.exists("hello.txt"))
745
 
        self.assert_(not os.path.exists("test.txt"))
 
363
        assert os.path.exists("hello.txt")
 
364
        assert not os.path.exists("test.txt")
746
365
 
747
 
        self.assertEquals(capture("revno"), '0\n')
 
366
        assert backtick("bzr revno") == '0\n'
748
367
 
749
368
        progress("add first revision")
750
369
        runbzr(['commit', '-m', 'add first revision'])
751
370
 
752
371
        progress("more complex renames")
753
372
        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)
 
373
        runbzr("rename hello.txt sub1", 1)
 
374
        runbzr("rename hello.txt sub1/hello.txt", 1)
 
375
        runbzr("move hello.txt sub1", 1)
757
376
 
758
377
        runbzr("add sub1")
759
378
        runbzr("rename sub1 sub2")
760
379
        runbzr("move hello.txt sub2")
761
 
        self.assertEqual(capture("relpath sub2/hello.txt"),
762
 
                         pathjoin("sub2", "hello.txt\n"))
 
380
        assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
763
381
 
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"))
 
382
        assert exists("sub2")
 
383
        assert exists("sub2/hello.txt")
 
384
        assert not exists("sub1")
 
385
        assert not exists("hello.txt")
768
386
 
769
387
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
770
388
 
771
389
        mkdir("sub1")
772
390
        runbzr('add sub1')
773
391
        runbzr('move sub2/hello.txt sub1')
774
 
        self.assert_(not exists('sub2/hello.txt'))
775
 
        self.assert_(exists('sub1/hello.txt'))
 
392
        assert not exists('sub2/hello.txt')
 
393
        assert exists('sub1/hello.txt')
776
394
        runbzr('move sub2 sub1')
777
 
        self.assert_(not exists('sub2'))
778
 
        self.assert_(exists('sub1/sub2'))
 
395
        assert not exists('sub2')
 
396
        assert exists('sub1/sub2')
779
397
 
780
398
        runbzr(['commit', '-m', 'rename nested subdirectories'])
781
399
 
782
400
        chdir('sub1/sub2')
783
 
        self.assertEquals(capture('root')[:-1],
784
 
                          pathjoin(self.test_dir, 'branch1'))
 
401
        self.assertEquals(backtick('bzr root')[:-1],
 
402
                          os.path.join(self.test_dir, 'branch1'))
785
403
        runbzr('move ../hello.txt .')
786
 
        self.assert_(exists('./hello.txt'))
787
 
        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'))
 
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')
790
407
        runbzr(['commit', '-m', 'move to parent directory'])
791
408
        chdir('..')
792
 
        self.assertEquals(capture('relpath sub2/hello.txt'), pathjoin('sub1', 'sub2', 'hello.txt\n'))
 
409
        assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
793
410
 
794
411
        runbzr('move sub2/hello.txt .')
795
 
        self.assert_(exists('hello.txt'))
 
412
        assert exists('hello.txt')
796
413
 
797
414
        f = file('hello.txt', 'wt')
798
415
        f.write('some nice new content\n')
799
416
        f.close()
800
417
 
801
418
        f = file('msg.tmp', 'wt')
802
 
        f.write('this is my new commit\nand it has multiple lines, for fun')
 
419
        f.write('this is my new commit\n')
803
420
        f.close()
804
421
 
805
422
        runbzr('commit -F msg.tmp')
806
423
 
807
 
        self.assertEquals(capture('revno'), '5\n')
 
424
        assert backtick('bzr revno') == '5\n'
808
425
        runbzr('export -r 5 export-5.tmp')
809
426
        runbzr('export export.tmp')
810
427
 
811
428
        runbzr('log')
812
429
        runbzr('log -v')
813
430
        runbzr('log -v --forward')
814
 
        runbzr('log -m', retcode=3)
815
 
        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'))
 
431
        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')
820
437
 
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
438
 
829
439
        progress("file with spaces in name")
830
440
        mkdir('sub directory')
831
441
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
832
442
        runbzr('add .')
833
 
        runbzr('diff', retcode=1)
 
443
        runbzr('diff')
834
444
        runbzr('commit -m add-spaces')
835
445
        runbzr('check')
836
446
 
839
449
 
840
450
        runbzr('info')
841
451
 
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