← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

and the tutorial patch came back, the very next day

Show diffs side-by-side

added added

removed removed

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