~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Martin Pool
  • Date: 2005-10-06 03:48:08 UTC
  • mto: (1185.13.3)
  • mto: This revision was merged to the branch mainline in revision 1417.
  • Revision ID: mbp@sourcefrog.net-20051006034808-7984f1371c3fa26a
- more hacking notes on evolving interfaces

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 
 
22
command-line interface.  This doesn't actually run a new interpreter but 
27
23
rather starts again from the run_bzr function.
28
24
"""
29
25
 
30
26
 
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
27
from cStringIO import StringIO
38
28
import os
39
 
import re
 
29
import shutil
40
30
import sys
 
31
import os
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.osutils import has_symlinks
 
36
 
 
37
 
 
38
class ExternalBase(TestCaseInTempDir):
 
39
 
 
40
    def runbzr(self, args, retcode=0, backtick=False):
 
41
        if isinstance(args, basestring):
 
42
            args = args.split()
 
43
 
 
44
        if backtick:
 
45
            return self.run_bzr_captured(args, retcode=retcode)[0]
 
46
        else:
 
47
            return self.run_bzr_captured(args, 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
        f = file('.bzr/email', 'wt')
 
74
        f.write('Branch Identity <branch@identi.ty>')
 
75
        f.close()
73
76
        bzr_email = os.environ.get('BZREMAIL')
74
77
        if bzr_email is not None:
75
78
            del os.environ['BZREMAIL']
87
90
        if bzr_email is not None:
88
91
            os.environ['BZREMAIL'] = bzr_email
89
92
 
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
93
    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)
 
94
        self.runbzr("pants", retcode=1)
 
95
        self.runbzr("--pants off", retcode=1)
 
96
        self.runbzr("diff --message foo", retcode=1)
 
97
 
 
98
    def test_empty_commit(self):
 
99
        self.runbzr("init")
 
100
        self.build_tree(['hello.txt'])
 
101
        self.runbzr("commit -m empty", retcode=1)
 
102
        self.runbzr("add hello.txt")
 
103
        self.runbzr("commit -m added")
105
104
 
106
105
    def test_ignore_patterns(self):
107
 
        self.runbzr('init')
108
 
        self.assertEquals(self.capture('unknowns'), '')
 
106
        from bzrlib.branch import Branch
 
107
        
 
108
        b = Branch.initialize('.')
 
109
        self.assertEquals(list(b.unknowns()), [])
109
110
 
110
111
        file('foo.tmp', 'wt').write('tmp files are ignored')
111
 
        self.assertEquals(self.capture('unknowns'), '')
 
112
        self.assertEquals(list(b.unknowns()), [])
 
113
        assert self.capture('unknowns') == ''
112
114
 
113
115
        file('foo.c', 'wt').write('int main() {}')
114
 
        self.assertEquals(self.capture('unknowns'), 'foo.c\n')
 
116
        self.assertEquals(list(b.unknowns()), ['foo.c'])
 
117
        assert self.capture('unknowns') == 'foo.c\n'
115
118
 
116
119
        self.runbzr(['add', 'foo.c'])
117
 
        self.assertEquals(self.capture('unknowns'), '')
 
120
        assert self.capture('unknowns') == ''
118
121
 
119
122
        # 'ignore' works when creating the .bzignore file
120
123
        file('foo.blah', 'wt').write('blah')
121
 
        self.assertEquals(self.capture('unknowns'), 'foo.blah\n')
 
124
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
122
125
        self.runbzr('ignore *.blah')
123
 
        self.assertEquals(self.capture('unknowns'), '')
124
 
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')
 
126
        self.assertEquals(list(b.unknowns()), [])
 
127
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
125
128
 
126
129
        # 'ignore' works when then .bzrignore file already exists
127
130
        file('garh', 'wt').write('garh')
128
 
        self.assertEquals(self.capture('unknowns'), 'garh\n')
 
131
        self.assertEquals(list(b.unknowns()), ['garh'])
 
132
        assert self.capture('unknowns') == 'garh\n'
129
133
        self.runbzr('ignore garh')
130
 
        self.assertEquals(self.capture('unknowns'), '')
131
 
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')
 
134
        self.assertEquals(list(b.unknowns()), [])
 
135
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
132
136
 
133
137
    def test_revert(self):
134
138
        self.runbzr('init')
155
159
        os.rmdir('revertdir')
156
160
        self.runbzr('revert')
157
161
 
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")
 
162
        os.symlink('/unlikely/to/exist', 'symlink')
 
163
        self.runbzr('add symlink')
 
164
        self.runbzr('commit -m f')
 
165
        os.unlink('symlink')
 
166
        self.runbzr('revert')
172
167
        
173
168
        file('hello', 'wt').write('xyz')
174
169
        self.runbzr('commit -m xyz hello')
180
175
        self.runbzr('revert')
181
176
        os.chdir('..')
182
177
 
 
178
 
183
179
    def test_mv_modes(self):
184
180
        """Test two modes of operation for mv"""
185
 
        self.runbzr('init')
 
181
        from bzrlib.branch import Branch
 
182
        b = Branch.initialize('.')
186
183
        self.build_tree(['a', 'c', 'subdir/'])
187
184
        self.run_bzr_captured(['add', self.test_dir])
188
185
        self.run_bzr_captured(['mv', 'a', 'b'])
222
219
        self.runbzr('export ../latest')
223
220
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
224
221
        self.runbzr('export ../first -r 1')
225
 
        self.assert_(not os.path.exists('../first/goodbye'))
 
222
        assert not os.path.exists('../first/goodbye')
226
223
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
227
224
        self.runbzr('export ../first.gz -r 1')
228
225
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
229
226
        self.runbzr('export ../first.bz2 -r 1')
230
227
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
231
 
 
 
228
        self.runbzr('export ../first.tar -r 1')
 
229
        assert os.path.isfile('../first.tar')
232
230
        from tarfile import TarFile
233
 
        self.runbzr('export ../first.tar -r 1')
234
 
        self.assert_(os.path.isfile('../first.tar'))
235
231
        tf = TarFile('../first.tar')
236
 
        self.assert_('first/hello' in tf.getnames(), tf.getnames())
 
232
        assert 'first/hello' in tf.getnames(), tf.getnames()
237
233
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
238
234
        self.runbzr('export ../first.tar.gz -r 1')
239
 
        self.assert_(os.path.isfile('../first.tar.gz'))
 
235
        assert os.path.isfile('../first.tar.gz')
240
236
        self.runbzr('export ../first.tbz2 -r 1')
241
 
        self.assert_(os.path.isfile('../first.tbz2'))
 
237
        assert os.path.isfile('../first.tbz2')
242
238
        self.runbzr('export ../first.tar.bz2 -r 1')
243
 
        self.assert_(os.path.isfile('../first.tar.bz2'))
 
239
        assert os.path.isfile('../first.tar.bz2')
244
240
        self.runbzr('export ../first.tar.tbz2 -r 1')
245
 
        self.assert_(os.path.isfile('../first.tar.tbz2'))
246
 
 
 
241
        assert os.path.isfile('../first.tar.tbz2')
247
242
        from bz2 import BZ2File
248
243
        tf = TarFile('../first.tar.tbz2', 
249
244
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
250
 
        self.assert_('first.tar/hello' in tf.getnames(), tf.getnames())
 
245
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
251
246
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
252
247
        self.runbzr('export ../first2.tar -r 1 --root pizza')
253
248
        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
 
        
 
249
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
250
 
 
251
    def test_diff(self):
 
252
        self.example_branch()
 
253
        file('hello', 'wt').write('hello world!')
 
254
        self.runbzr('commit -m fixing hello')
 
255
        output = self.runbzr('diff -r 2..3', backtick=1)
 
256
        self.assert_('\n+hello world!' in output)
 
257
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
258
        self.assert_('\n+baz' in output)
 
259
 
 
260
    def test_branch(self):
 
261
        """Branch from one branch to another."""
 
262
        os.mkdir('a')
 
263
        os.chdir('a')
 
264
        self.example_branch()
 
265
        os.chdir('..')
 
266
        self.runbzr('branch a b')
 
267
        self.runbzr('branch a c -r 1')
 
268
        os.chdir('b')
 
269
        self.runbzr('commit -m foo --unchanged')
 
270
        os.chdir('..')
 
271
        # naughty - abstraction violations RBC 20050928  
 
272
        print "test_branch used to delete the stores, how is this meant to work ?"
 
273
        #shutil.rmtree('a/.bzr/revision-store')
 
274
        #shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
 
275
        #shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
 
276
        self.runbzr('branch a d --basis b')
 
277
 
 
278
    def test_merge(self):
 
279
        from bzrlib.branch import Branch
 
280
        
 
281
        os.mkdir('a')
 
282
        os.chdir('a')
 
283
        self.example_branch()
 
284
        os.chdir('..')
 
285
        self.runbzr('branch a b')
 
286
        os.chdir('b')
 
287
        file('goodbye', 'wt').write('quux')
 
288
        self.runbzr(['commit',  '-m',  "more u's are always good"])
 
289
 
 
290
        os.chdir('../a')
 
291
        file('hello', 'wt').write('quuux')
 
292
        # We can't merge when there are in-tree changes
 
293
        self.runbzr('merge ../b', retcode=1)
 
294
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
 
295
        self.runbzr('merge ../b')
 
296
        self.check_file_contents('goodbye', 'quux')
 
297
        # Merging a branch pulls its revision into the tree
 
298
        a = Branch.open('.')
 
299
        b = Branch.open('../b')
 
300
        a.get_revision_xml(b.last_revision())
 
301
        self.log('pending merges: %s', a.pending_merges())
 
302
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
 
303
        #        % (a.pending_merges(), b.last_revision())
 
304
 
 
305
    def test_merge_with_missing_file(self):
 
306
        """Merge handles missing file conflicts"""
 
307
        os.mkdir('a')
 
308
        os.chdir('a')
 
309
        os.mkdir('sub')
 
310
        print >> file('sub/a.txt', 'wb'), "hello"
 
311
        print >> file('b.txt', 'wb'), "hello"
 
312
        print >> file('sub/c.txt', 'wb'), "hello"
 
313
        self.runbzr('init')
 
314
        self.runbzr('add')
 
315
        self.runbzr(('commit', '-m', 'added a'))
 
316
        self.runbzr('branch . ../b')
 
317
        print >> file('sub/a.txt', 'ab'), "there"
 
318
        print >> file('b.txt', 'ab'), "there"
 
319
        print >> file('sub/c.txt', 'ab'), "there"
 
320
        self.runbzr(('commit', '-m', 'Added there'))
 
321
        os.unlink('sub/a.txt')
 
322
        os.unlink('sub/c.txt')
 
323
        os.rmdir('sub')
 
324
        os.unlink('b.txt')
 
325
        self.runbzr(('commit', '-m', 'Removed a.txt'))
 
326
        os.chdir('../b')
 
327
        print >> file('sub/a.txt', 'ab'), "something"
 
328
        print >> file('b.txt', 'ab'), "something"
 
329
        print >> file('sub/c.txt', 'ab'), "something"
 
330
        self.runbzr(('commit', '-m', 'Modified a.txt'))
 
331
        self.runbzr('merge ../a/')
 
332
        assert os.path.exists('sub/a.txt.THIS')
 
333
        assert os.path.exists('sub/a.txt.BASE')
 
334
        os.chdir('../a')
 
335
        self.runbzr('merge ../b/')
 
336
        assert os.path.exists('sub/a.txt.OTHER')
 
337
        assert os.path.exists('sub/a.txt.BASE')
 
338
 
 
339
    def test_pull(self):
 
340
        """Pull changes from one branch to another."""
 
341
        os.mkdir('a')
 
342
        os.chdir('a')
 
343
 
 
344
        self.example_branch()
 
345
        self.runbzr('pull', retcode=1)
 
346
        self.runbzr('missing', retcode=1)
 
347
        self.runbzr('missing .')
 
348
        self.runbzr('missing')
 
349
        self.runbzr('pull')
 
350
        self.runbzr('pull /', retcode=1)
 
351
        self.runbzr('pull')
 
352
 
 
353
        os.chdir('..')
 
354
        self.runbzr('branch a b')
 
355
        os.chdir('b')
 
356
        self.runbzr('pull')
317
357
        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')
452
 
        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
 
        
 
358
        self.runbzr('add subdir')
 
359
        self.runbzr('commit -m blah --unchanged')
 
360
        os.chdir('../a')
 
361
        a = Branch.open('.')
 
362
        b = Branch.open('../b')
 
363
        assert a.revision_history() == b.revision_history()[:-1]
 
364
        self.runbzr('pull ../b')
 
365
        assert a.revision_history() == b.revision_history()
 
366
        self.runbzr('commit -m blah2 --unchanged')
 
367
        os.chdir('../b')
 
368
        self.runbzr('commit -m blah3 --unchanged')
 
369
        self.runbzr('pull ../a', retcode=1)
 
370
        print "DECIDE IF PULL CAN CONVERGE, blackbox.py"
 
371
        return
 
372
        os.chdir('../a')
 
373
        self.runbzr('merge ../b')
 
374
        self.runbzr('commit -m blah4 --unchanged')
 
375
        os.chdir('../b/subdir')
 
376
        self.runbzr('pull ../../a')
 
377
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
378
        self.runbzr('commit -m blah5 --unchanged')
 
379
        self.runbzr('commit -m blah6 --unchanged')
 
380
        os.chdir('..')
 
381
        self.runbzr('pull ../a')
 
382
        os.chdir('../a')
 
383
        self.runbzr('commit -m blah7 --unchanged')
 
384
        self.runbzr('merge ../b')
 
385
        self.runbzr('commit -m blah8 --unchanged')
 
386
        self.runbzr('pull ../b')
 
387
        self.runbzr('pull ../b')
 
388
        
 
389
    def test_add_reports(self):
 
390
        """add command prints the names of added files."""
 
391
        b = Branch.initialize('.')
 
392
        self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
 
393
        out = self.run_bzr_captured(['add'], retcode = 0)[0]
 
394
        # the ordering is not defined at the moment
 
395
        results = sorted(out.rstrip('\n').split('\n'))
 
396
        self.assertEquals(['added dir',
 
397
                           'added dir'+os.sep+'sub.txt',
 
398
                           'added top.txt',],
 
399
                          results)
 
400
 
465
401
    def test_unknown_command(self):
466
402
        """Handling of unknown command."""
467
403
        out, err = self.run_bzr_captured(['fluffy-badger'],
468
 
                                         retcode=3)
 
404
                                         retcode=1)
469
405
        self.assertEquals(out, '')
470
406
        err.index('unknown command')
471
407
 
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
408
 
663
409
def listdir_sorted(dir):
664
410
    L = os.listdir(dir)
683
429
        runbzr('init')
684
430
 
685
431
        self.assertEquals(capture('root').rstrip(),
686
 
                          pathjoin(self.test_dir, 'branch1'))
 
432
                          os.path.join(self.test_dir, 'branch1'))
687
433
 
688
434
        progress("status of new file")
689
435
 
694
440
        self.assertEquals(capture('unknowns'), 'test.txt\n')
695
441
 
696
442
        out = capture("status")
697
 
        self.assertEquals(out, 'unknown:\n  test.txt\n')
 
443
        assert out == 'unknown:\n  test.txt\n'
698
444
 
699
445
        out = capture("status --all")
700
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
446
        assert out == "unknown:\n  test.txt\n"
701
447
 
702
448
        out = capture("status test.txt --all")
703
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
449
        assert out == "unknown:\n  test.txt\n"
704
450
 
705
451
        f = file('test2.txt', 'wt')
706
452
        f.write('goodbye cruel world...\n')
707
453
        f.close()
708
454
 
709
455
        out = capture("status test.txt")
710
 
        self.assertEquals(out, "unknown:\n  test.txt\n")
 
456
        assert out == "unknown:\n  test.txt\n"
711
457
 
712
458
        out = capture("status")
713
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
 
459
        assert out == ("unknown:\n"
 
460
                       "  test.txt\n"
 
461
                       "  test2.txt\n")
714
462
 
715
463
        os.unlink('test2.txt')
716
464
 
717
465
        progress("command aliases")
718
466
        out = capture("st --all")
719
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
467
        assert out == ("unknown:\n"
 
468
                       "  test.txt\n")
720
469
 
721
470
        out = capture("stat")
722
 
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
 
471
        assert out == ("unknown:\n"
 
472
                       "  test.txt\n")
723
473
 
724
474
        progress("command help")
725
475
        runbzr("help st")
726
476
        runbzr("help")
727
477
        runbzr("help commands")
728
 
        runbzr("help slartibartfast", 3)
 
478
        runbzr("help slartibartfast", 1)
729
479
 
730
480
        out = capture("help ci")
731
481
        out.index('aliases: ')
732
482
 
733
483
        progress("can't rename unversioned file")
734
 
        runbzr("rename test.txt new-test.txt", 3)
 
484
        runbzr("rename test.txt new-test.txt", 1)
735
485
 
736
486
        progress("adding a file")
737
487
 
738
488
        runbzr("add test.txt")
739
 
        self.assertEquals(capture("unknowns"), '')
740
 
        self.assertEquals(capture("status --all"), ("added:\n" "  test.txt\n"))
 
489
        assert capture("unknowns") == ''
 
490
        assert capture("status --all") == ("added:\n"
 
491
                                                "  test.txt\n")
741
492
 
742
493
        progress("rename newly-added file")
743
494
        runbzr("rename test.txt hello.txt")
744
 
        self.assert_(os.path.exists("hello.txt"))
745
 
        self.assert_(not os.path.exists("test.txt"))
 
495
        assert os.path.exists("hello.txt")
 
496
        assert not os.path.exists("test.txt")
746
497
 
747
 
        self.assertEquals(capture("revno"), '0\n')
 
498
        assert capture("revno") == '0\n'
748
499
 
749
500
        progress("add first revision")
750
501
        runbzr(['commit', '-m', 'add first revision'])
751
502
 
752
503
        progress("more complex renames")
753
504
        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)
 
505
        runbzr("rename hello.txt sub1", 1)
 
506
        runbzr("rename hello.txt sub1/hello.txt", 1)
 
507
        runbzr("move hello.txt sub1", 1)
757
508
 
758
509
        runbzr("add sub1")
759
510
        runbzr("rename sub1 sub2")
760
511
        runbzr("move hello.txt sub2")
761
 
        self.assertEqual(capture("relpath sub2/hello.txt"),
762
 
                         pathjoin("sub2", "hello.txt\n"))
 
512
        assert capture("relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
763
513
 
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"))
 
514
        assert exists("sub2")
 
515
        assert exists("sub2/hello.txt")
 
516
        assert not exists("sub1")
 
517
        assert not exists("hello.txt")
768
518
 
769
519
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
770
520
 
771
521
        mkdir("sub1")
772
522
        runbzr('add sub1')
773
523
        runbzr('move sub2/hello.txt sub1')
774
 
        self.assert_(not exists('sub2/hello.txt'))
775
 
        self.assert_(exists('sub1/hello.txt'))
 
524
        assert not exists('sub2/hello.txt')
 
525
        assert exists('sub1/hello.txt')
776
526
        runbzr('move sub2 sub1')
777
 
        self.assert_(not exists('sub2'))
778
 
        self.assert_(exists('sub1/sub2'))
 
527
        assert not exists('sub2')
 
528
        assert exists('sub1/sub2')
779
529
 
780
530
        runbzr(['commit', '-m', 'rename nested subdirectories'])
781
531
 
782
532
        chdir('sub1/sub2')
783
533
        self.assertEquals(capture('root')[:-1],
784
 
                          pathjoin(self.test_dir, 'branch1'))
 
534
                          os.path.join(self.test_dir, 'branch1'))
785
535
        runbzr('move ../hello.txt .')
786
 
        self.assert_(exists('./hello.txt'))
 
536
        assert exists('./hello.txt')
787
537
        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'))
 
538
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
 
539
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
790
540
        runbzr(['commit', '-m', 'move to parent directory'])
791
541
        chdir('..')
792
 
        self.assertEquals(capture('relpath sub2/hello.txt'), pathjoin('sub1', 'sub2', 'hello.txt\n'))
 
542
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
793
543
 
794
544
        runbzr('move sub2/hello.txt .')
795
 
        self.assert_(exists('hello.txt'))
 
545
        assert exists('hello.txt')
796
546
 
797
547
        f = file('hello.txt', 'wt')
798
548
        f.write('some nice new content\n')
799
549
        f.close()
800
550
 
801
551
        f = file('msg.tmp', 'wt')
802
 
        f.write('this is my new commit\nand it has multiple lines, for fun')
 
552
        f.write('this is my new commit\n')
803
553
        f.close()
804
554
 
805
555
        runbzr('commit -F msg.tmp')
806
556
 
807
 
        self.assertEquals(capture('revno'), '5\n')
 
557
        assert capture('revno') == '5\n'
808
558
        runbzr('export -r 5 export-5.tmp')
809
559
        runbzr('export export.tmp')
810
560
 
811
561
        runbzr('log')
812
562
        runbzr('log -v')
813
563
        runbzr('log -v --forward')
814
 
        runbzr('log -m', retcode=3)
 
564
        runbzr('log -m', retcode=1)
815
565
        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'))
 
566
        assert "this is my new commit" in log_out
 
567
        assert "rename nested" not in log_out
 
568
        assert 'revision-id' not in log_out
 
569
        assert 'revision-id' in capture('log --show-ids -m commit')
820
570
 
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
571
 
829
572
        progress("file with spaces in name")
830
573
        mkdir('sub directory')
831
574
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
832
575
        runbzr('add .')
833
 
        runbzr('diff', retcode=1)
 
576
        runbzr('diff')
834
577
        runbzr('commit -m add-spaces')
835
578
        runbzr('check')
836
579
 
846
589
            runbzr('init')
847
590
            os.symlink("NOWHERE1", "link1")
848
591
            runbzr('add link1')
849
 
            self.assertEquals(self.capture('unknowns'), '')
 
592
            assert self.capture('unknowns') == ''
850
593
            runbzr(['commit', '-m', '1: added symlink link1'])
851
594
    
852
595
            mkdir('d1')
853
596
            runbzr('add d1')
854
 
            self.assertEquals(self.capture('unknowns'), '')
 
597
            assert self.capture('unknowns') == ''
855
598
            os.symlink("NOWHERE2", "d1/link2")
856
 
            self.assertEquals(self.capture('unknowns'), 'd1/link2\n')
 
599
            assert self.capture('unknowns') == 'd1/link2\n'
857
600
            # is d1/link2 found when adding d1
858
601
            runbzr('add d1')
859
 
            self.assertEquals(self.capture('unknowns'), '')
 
602
            assert self.capture('unknowns') == ''
860
603
            os.symlink("NOWHERE3", "d1/link3")
861
 
            self.assertEquals(self.capture('unknowns'), 'd1/link3\n')
 
604
            assert self.capture('unknowns') == 'd1/link3\n'
862
605
            runbzr(['commit', '-m', '2: added dir, symlink'])
863
606
    
864
607
            runbzr('rename d1 d2')
865
608
            runbzr('move d2/link2 .')
866
609
            runbzr('move link1 d2')
867
 
            self.assertEquals(os.readlink("./link2"), "NOWHERE2")
868
 
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
 
610
            assert os.readlink("./link2") == "NOWHERE2"
 
611
            assert os.readlink("d2/link1") == "NOWHERE1"
869
612
            runbzr('add d2/link3')
870
 
            runbzr('diff', retcode=1)
 
613
            runbzr('diff')
871
614
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
872
615
    
873
616
            os.unlink("link2")
874
617
            os.symlink("TARGET 2", "link2")
875
618
            os.unlink("d2/link1")
876
619
            os.symlink("TARGET 1", "d2/link1")
877
 
            runbzr('diff', retcode=1)
878
 
            self.assertEquals(self.capture("relpath d2/link1"), "d2/link1\n")
 
620
            runbzr('diff')
 
621
            assert self.capture("relpath d2/link1") == "d2/link1\n"
879
622
            runbzr(['commit', '-m', '4: retarget of two links'])
880
623
    
881
624
            runbzr('remove d2/link1')
882
 
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
 
625
            assert self.capture('unknowns') == 'd2/link1\n'
883
626
            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
627
    
891
628
            os.mkdir("d1")
892
629
            runbzr('add d1')
893
630
            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'])
 
631
            assert self.capture('unknowns') == 'd2/link1\n'
 
632
            runbzr(['commit', '-m', '6: remove d2/link1, move/rename link3'])
896
633
            
897
634
            runbzr(['check'])
898
635
            
899
636
            runbzr(['export', '-r', '1', 'exp1.tmp'])
900
637
            chdir("exp1.tmp")
901
 
            self.assertEquals(listdir_sorted("."), [ "link1" ])
902
 
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
 
638
            assert listdir_sorted(".") == [ "link1" ]
 
639
            assert os.readlink("link1") == "NOWHERE1"
903
640
            chdir("..")
904
641
            
905
642
            runbzr(['export', '-r', '2', 'exp2.tmp'])
906
643
            chdir("exp2.tmp")
907
 
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
 
644
            assert listdir_sorted(".") == [ "d1", "link1" ]
908
645
            chdir("..")
909
646
            
910
647
            runbzr(['export', '-r', '3', 'exp3.tmp'])
911
648
            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")
 
649
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
650
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
651
            assert os.readlink("d2/link1") == "NOWHERE1"
 
652
            assert os.readlink("link2")    == "NOWHERE2"
916
653
            chdir("..")
917
654
            
918
655
            runbzr(['export', '-r', '4', 'exp4.tmp'])
919
656
            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" ])
 
657
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
658
            assert os.readlink("d2/link1") == "TARGET 1"
 
659
            assert os.readlink("link2")    == "TARGET 2"
 
660
            assert listdir_sorted("d2") == [ "link1", "link3" ]
924
661
            chdir("..")
925
662
            
926
663
            runbzr(['export', '-r', '5', 'exp5.tmp'])
927
664
            chdir("exp5.tmp")
928
 
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
929
 
            self.assert_(os.path.islink("link2"))
930
 
            self.assert_(listdir_sorted("d2")== [ "link3" ])
 
665
            assert listdir_sorted(".") == [ "d2", "link2" ]
 
666
            assert os.path.islink("link2")
 
667
            assert listdir_sorted("d2")== [ "link3" ]
931
668
            chdir("..")
932
669
            
933
 
            runbzr(['export', '-r', '8', 'exp6.tmp'])
 
670
            runbzr(['export', '-r', '6', 'exp6.tmp'])
934
671
            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")
 
672
            assert listdir_sorted(".") == [ "d1", "d2", "link2" ]
 
673
            assert listdir_sorted("d1") == [ "link3new" ]
 
674
            assert listdir_sorted("d2") == []
 
675
            assert os.readlink("d1/link3new") == "NOWHERE3"
939
676
            chdir("..")
940
677
        else:
941
678
            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
 
679