← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

[merge] fix \t in commit messages

Show diffs side-by-side

added added

removed removed

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