« back to all changes in this revision
Viewing changes to bzrlib/selftest/blackbox.py
- browse files at revision 1111
- compare with another revision
- download diff
- download tarball
- view history from revision 1111
- Committer: Martin Pool
- Date: 2005-08-25 07:46:11 UTC
- Revision ID: mbp@sourcefrog.net-20050825074611-98130ea6d05d9d2a
- add functions to enable and disable default logging, so that we can
turn it off while running the tests
- default logging gets turned on from the bzr main function so that
other applications using the library can make their own decisions
turn it off while running the tests
- default logging gets turned on from the bzr main function so that
other applications using the library can make their own decisions
- files added:
- bzrlib/mdiff.py
- files removed:
- INSTALL
- bzrlib/doc
- bzrlib/doc/api
- bzrlib/export
- bzrlib/store
- bzrlib/tests/blackbox
- bzrlib/transport
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- files renamed:
- bzr_man.py => bzr-man.py
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/tests/ => bzrlib/selftest/
- bzrlib/tests/blackbox/test_too_much.py => bzrlib/selftest/blackbox.py
- bzrlib/tests/test_plugins.py => bzrlib/selftest/plugins.py
- bzrlib/tests/test_branch.py => bzrlib/selftest/testbranch.py
- bzrlib/tests/test_diff.py => bzrlib/selftest/testdiff.py
- bzrlib/tests/test_hashcache.py => bzrlib/selftest/testhashcache.py
- bzrlib/tests/test_inv.py => bzrlib/selftest/testinv.py
- bzrlib/tests/test_log.py => bzrlib/selftest/testlog.py
- bzrlib/tests/test_merge3.py => bzrlib/selftest/testmerge3.py
- bzrlib/tests/test_revision.py => bzrlib/selftest/testrevision.py
- bzrlib/tests/test_revisionnamespaces.py => bzrlib/selftest/testrevisionnamespaces.py
- bzrlib/tests/test_status.py => bzrlib/selftest/teststatus.py
- bzrlib/tests/blackbox/test_versioning.py => bzrlib/selftest/versioning.py
- bzrlib/tests/test_whitebox.py => bzrlib/selftest/whitebox.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/ui/__init__.py => bzrlib/ui.py
- bzrlib/upgrade.py => tools/history2weaves.py
- bzrlib/tests/test_weave.py => tools/testweave.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
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
38
import os
39
import re
40
import shutil
41
29
import sys
42
43
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
30
from bzrlib.selftest import InTempDir, BzrTestBase
31
32
33
class ExternalBase(InTempDir):
34
35
def runbzr(self, args, retcode=0,backtick=False):
36
try:
37
import shutil
38
from subprocess import call
39
except ImportError, e:
40
_need_subprocess()
41
raise
42
43
if isinstance(args, basestring):
44
args = args.split()
45
46
if backtick:
47
return self.backtick(['python', self.BZRPATH,] + args,
48
retcode=retcode)
49
else:
50
return self.runcmd(['python', self.BZRPATH,] + args,
51
retcode=retcode)
49
52
50
53
class TestCommands(ExternalBase):
51
54
57
60
self.runbzr('commit -h')
58
61
59
62
def test_init_branch(self):
63
import os
60
64
self.runbzr(['init'])
61
65
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
66
def test_whoami(self):
77
67
# this should always identify something, if only "john@localhost"
78
68
self.runbzr("whoami")
87
77
f = file('.bzr/email', 'wt')
88
78
f.write('Branch Identity <branch@identi.ty>')
89
79
f.close()
90
bzr_email = os.environ.get('BZREMAIL')
91
if bzr_email is not None:
92
del os.environ['BZREMAIL']
93
80
whoami = self.runbzr("whoami",backtick=True)
94
81
whoami_email = self.runbzr("whoami --email",backtick=True)
95
82
self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
96
83
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
84
119
85
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)
86
self.runbzr("pants", retcode=1)
87
self.runbzr("--pants off", retcode=1)
88
self.runbzr("diff --message foo", retcode=1)
123
89
124
90
def test_empty_commit(self):
125
91
self.runbzr("init")
126
92
self.build_tree(['hello.txt'])
127
self.runbzr("commit -m empty", retcode=3)
93
self.runbzr("commit -m empty", retcode=1)
128
94
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)
95
self.runbzr("commit -m added")
164
96
165
97
def test_ignore_patterns(self):
166
98
from bzrlib.branch import Branch
167
Branch.initialize('.')
168
self.assertEquals(self.capture('unknowns'), '')
99
100
b = Branch('.', init=True)
101
self.assertEquals(list(b.unknowns()), [])
169
102
170
103
file('foo.tmp', 'wt').write('tmp files are ignored')
171
self.assertEquals(self.capture('unknowns'), '')
104
self.assertEquals(list(b.unknowns()), [])
105
assert self.backtick('bzr unknowns') == ''
172
106
173
107
file('foo.c', 'wt').write('int main() {}')
174
self.assertEquals(self.capture('unknowns'), 'foo.c\n')
108
self.assertEquals(list(b.unknowns()), ['foo.c'])
109
assert self.backtick('bzr unknowns') == 'foo.c\n'
175
110
176
111
self.runbzr(['add', 'foo.c'])
177
self.assertEquals(self.capture('unknowns'), '')
112
assert self.backtick('bzr unknowns') == ''
178
113
179
114
# 'ignore' works when creating the .bzignore file
180
115
file('foo.blah', 'wt').write('blah')
181
self.assertEquals(self.capture('unknowns'), 'foo.blah\n')
116
self.assertEquals(list(b.unknowns()), ['foo.blah'])
182
117
self.runbzr('ignore *.blah')
183
self.assertEquals(self.capture('unknowns'), '')
184
self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')
118
self.assertEquals(list(b.unknowns()), [])
119
assert file('.bzrignore', 'rb').read() == '*.blah\n'
185
120
186
121
# 'ignore' works when then .bzrignore file already exists
187
122
file('garh', 'wt').write('garh')
188
self.assertEquals(self.capture('unknowns'), 'garh\n')
123
self.assertEquals(list(b.unknowns()), ['garh'])
124
assert self.backtick('bzr unknowns') == 'garh\n'
189
125
self.runbzr('ignore garh')
190
self.assertEquals(self.capture('unknowns'), '')
191
self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')
126
self.assertEquals(list(b.unknowns()), [])
127
assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
192
128
193
129
def test_revert(self):
130
import os
131
194
132
self.runbzr('init')
195
133
196
134
file('hello', 'wt').write('foo')
200
138
file('goodbye', 'wt').write('baz')
201
139
self.runbzr('add goodbye')
202
140
self.runbzr('commit -m setup goodbye')
203
141
204
142
file('hello', 'wt').write('bar')
205
143
file('goodbye', 'wt').write('qux')
206
144
self.runbzr('revert hello')
215
153
os.rmdir('revertdir')
216
154
self.runbzr('revert')
217
155
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
def test_mv_modes(self):
156
157
def skipped_test_mv_modes(self):
257
158
"""Test two modes of operation for mv"""
258
159
from bzrlib.branch import Branch
259
b = Branch.initialize('.')
160
b = Branch('.', init=True)
260
161
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'])
162
self.run_bzr('mv', 'a', 'b')
163
self.run_bzr('mv', 'b', 'subdir')
164
self.run_bzr('mv', 'subdir/b', 'a')
165
self.run_bzr('mv', 'a', 'b', 'subdir')
166
self.run_bzr('mv', 'subdir/a', 'subdir/newa')
267
167
268
168
def test_main_version(self):
269
169
"""Check output from version command and master option is reasonable"""
280
180
self.log(tmp_output)
281
181
self.assertEquals(output, tmp_output)
282
182
283
def example_branch(test):
284
test.runbzr('init')
285
file('hello', 'wt').write('foo')
286
test.runbzr('add hello')
287
test.runbzr('commit -m setup hello')
288
file('goodbye', 'wt').write('baz')
289
test.runbzr('add goodbye')
290
test.runbzr('commit -m setup goodbye')
291
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')
407
408
def test_merge(self):
409
from bzrlib.branch import Branch
410
411
os.mkdir('a')
412
os.chdir('a')
413
self.example_branch()
414
os.chdir('..')
415
self.runbzr('branch a b')
416
os.chdir('b')
417
file('goodbye', 'wt').write('quux')
418
self.runbzr(['commit', '-m', "more u's are always good"])
419
420
os.chdir('../a')
421
file('hello', 'wt').write('quuux')
422
# We can't merge when there are in-tree changes
423
self.runbzr('merge ../b', retcode=3)
424
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')
434
self.check_file_contents('goodbye', 'quux')
435
# 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
604
self.example_branch()
605
606
os.chdir('..')
607
bzr('branch a b')
608
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')
654
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')
666
667
def test_add_reports(self):
668
"""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('.')
691
self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
692
out = self.run_bzr_captured(['add', '-q'], retcode=0)[0]
693
# 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
991
992
993
183
class OldTests(ExternalBase):
994
"""old tests moved from ./testbzr."""
995
184
# old tests moved from ./testbzr
996
185
def test_bzr(self):
997
186
from os import chdir, mkdir
998
187
from os.path import exists
188
import os
999
189
1000
190
runbzr = self.runbzr
1001
capture = self.capture
191
backtick = self.backtick
1002
192
progress = self.log
1003
193
1004
194
progress("basic branch creation")
1006
196
chdir('branch1')
1007
197
runbzr('init')
1008
198
1009
self.assertEquals(capture('root').rstrip(),
199
self.assertEquals(backtick('bzr root').rstrip(),
1010
200
os.path.join(self.test_dir, 'branch1'))
1011
201
1012
202
progress("status of new file")
1015
205
f.write('hello world!\n')
1016
206
f.close()
1017
207
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")
208
out = backtick("bzr unknowns")
209
self.assertEquals(out, 'test.txt\n')
210
211
out = backtick("bzr status")
212
assert out == 'unknown:\n test.txt\n'
213
214
out = backtick("bzr status --all")
215
assert out == "unknown:\n test.txt\n"
216
217
out = backtick("bzr status test.txt --all")
218
assert out == "unknown:\n test.txt\n"
1028
219
1029
220
f = file('test2.txt', 'wt')
1030
221
f.write('goodbye cruel world...\n')
1031
222
f.close()
1032
223
1033
out = capture("status test.txt")
1034
self.assertEquals(out, "unknown:\n test.txt\n")
224
out = backtick("bzr status test.txt")
225
assert out == "unknown:\n test.txt\n"
1035
226
1036
out = capture("status")
1037
self.assertEquals(out, ("unknown:\n" " test.txt\n" " test2.txt\n"))
227
out = backtick("bzr status")
228
assert out == ("unknown:\n"
229
" test.txt\n"
230
" test2.txt\n")
1038
231
1039
232
os.unlink('test2.txt')
1040
233
1041
234
progress("command aliases")
1042
out = capture("st --all")
1043
self.assertEquals(out, ("unknown:\n" " test.txt\n"))
235
out = backtick("bzr st --all")
236
assert out == ("unknown:\n"
237
" test.txt\n")
1044
238
1045
out = capture("stat")
1046
self.assertEquals(out, ("unknown:\n" " test.txt\n"))
239
out = backtick("bzr stat")
240
assert out == ("unknown:\n"
241
" test.txt\n")
1047
242
1048
243
progress("command help")
1049
244
runbzr("help st")
1050
245
runbzr("help")
1051
246
runbzr("help commands")
1052
runbzr("help slartibartfast", 3)
247
runbzr("help slartibartfast", 1)
1053
248
1054
out = capture("help ci")
249
out = backtick("bzr help ci")
1055
250
out.index('aliases: ')
1056
251
1057
252
progress("can't rename unversioned file")
1058
runbzr("rename test.txt new-test.txt", 3)
253
runbzr("rename test.txt new-test.txt", 1)
1059
254
1060
255
progress("adding a file")
1061
256
1062
257
runbzr("add test.txt")
1063
self.assertEquals(capture("unknowns"), '')
1064
self.assertEquals(capture("status --all"), ("added:\n" " test.txt\n"))
258
assert backtick("bzr unknowns") == ''
259
assert backtick("bzr status --all") == ("added:\n"
260
" test.txt\n")
1065
261
1066
262
progress("rename newly-added file")
1067
263
runbzr("rename test.txt hello.txt")
1068
self.assert_(os.path.exists("hello.txt"))
1069
self.assert_(not os.path.exists("test.txt"))
264
assert os.path.exists("hello.txt")
265
assert not os.path.exists("test.txt")
1070
266
1071
self.assertEquals(capture("revno"), '0\n')
267
assert backtick("bzr revno") == '0\n'
1072
268
1073
269
progress("add first revision")
1074
270
runbzr(['commit', '-m', 'add first revision'])
1075
271
1076
272
progress("more complex renames")
1077
273
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)
274
runbzr("rename hello.txt sub1", 1)
275
runbzr("rename hello.txt sub1/hello.txt", 1)
276
runbzr("move hello.txt sub1", 1)
1081
277
1082
278
runbzr("add sub1")
1083
279
runbzr("rename sub1 sub2")
1084
280
runbzr("move hello.txt sub2")
1085
self.assertEqual(capture("relpath sub2/hello.txt"),
1086
os.path.join("sub2", "hello.txt\n"))
281
assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
1087
282
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"))
283
assert exists("sub2")
284
assert exists("sub2/hello.txt")
285
assert not exists("sub1")
286
assert not exists("hello.txt")
1092
287
1093
288
runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
1094
289
1095
290
mkdir("sub1")
1096
291
runbzr('add sub1')
1097
292
runbzr('move sub2/hello.txt sub1')
1098
self.assert_(not exists('sub2/hello.txt'))
1099
self.assert_(exists('sub1/hello.txt'))
293
assert not exists('sub2/hello.txt')
294
assert exists('sub1/hello.txt')
1100
295
runbzr('move sub2 sub1')
1101
self.assert_(not exists('sub2'))
1102
self.assert_(exists('sub1/sub2'))
296
assert not exists('sub2')
297
assert exists('sub1/sub2')
1103
298
1104
299
runbzr(['commit', '-m', 'rename nested subdirectories'])
1105
300
1106
301
chdir('sub1/sub2')
1107
self.assertEquals(capture('root')[:-1],
302
self.assertEquals(backtick('bzr root')[:-1],
1108
303
os.path.join(self.test_dir, 'branch1'))
1109
304
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'))
305
assert exists('./hello.txt')
306
assert backtick('bzr relpath hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
307
assert backtick('bzr relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
1114
308
runbzr(['commit', '-m', 'move to parent directory'])
1115
309
chdir('..')
1116
self.assertEquals(capture('relpath sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
310
assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
1117
311
1118
312
runbzr('move sub2/hello.txt .')
1119
self.assert_(exists('hello.txt'))
313
assert exists('hello.txt')
1120
314
1121
315
f = file('hello.txt', 'wt')
1122
316
f.write('some nice new content\n')
1123
317
f.close()
1124
318
1125
319
f = file('msg.tmp', 'wt')
1126
f.write('this is my new commit\nand it has multiple lines, for fun')
320
f.write('this is my new commit\n')
1127
321
f.close()
1128
322
1129
323
runbzr('commit -F msg.tmp')
1130
324
1131
self.assertEquals(capture('revno'), '5\n')
325
assert backtick('bzr revno') == '5\n'
1132
326
runbzr('export -r 5 export-5.tmp')
1133
327
runbzr('export export.tmp')
1134
328
1135
329
runbzr('log')
1136
330
runbzr('log -v')
1137
331
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)
332
runbzr('log -m', retcode=1)
333
log_out = backtick('bzr log -m commit')
334
assert "this is my new commit" in log_out
335
assert "rename nested" not in log_out
336
assert 'revision-id' not in log_out
337
assert 'revision-id' in backtick('bzr log --show-ids -m commit')
1149
338
1150
339
1151
340
progress("file with spaces in name")
1152
341
mkdir('sub directory')
1153
342
file('sub directory/file with spaces ', 'wt').write('see how this works\n')
1154
343
runbzr('add .')
1155
runbzr('diff', retcode=1)
344
runbzr('diff')
1156
345
runbzr('commit -m add-spaces')
1157
346
runbzr('check')
1158
347
1161
350
1162
351
runbzr('info')
1163
352
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)
353
354
355
def example_branch(test):
356
test.runbzr('init')
357
358
file('hello', 'wt').write('foo')
359
test.runbzr('add hello')
360
test.runbzr('commit -m setup hello')
361
362
file('goodbye', 'wt').write('baz')
363
test.runbzr('add goodbye')
364
test.runbzr('commit -m setup goodbye')
365
366
367
class RevertCommand(ExternalBase):
368
def runTest(self):
369
example_branch(self)
370
file('hello', 'wt').write('bar')
371
file('goodbye', 'wt').write('qux')
372
self.runbzr('revert hello')
373
self.check_file_contents('hello', 'foo')
374
self.check_file_contents('goodbye', 'qux')
375
self.runbzr('revert')
376
self.check_file_contents('goodbye', 'baz')
377
378
379
class MergeCommand(ExternalBase):
380
def runTest(self):
381
from bzrlib.branch import Branch
382
import os
383
os.mkdir('a')
384
os.chdir('a')
385
example_branch(self)
386
os.chdir('..')
387
self.runbzr('branch a b')
388
os.chdir('b')
389
file('goodbye', 'wt').write('quux')
390
self.runbzr(['commit', '-m', "more u's are always good"])
391
392
os.chdir('../a')
393
file('hello', 'wt').write('quuux')
394
# We can't merge when there are in-tree changes
395
self.runbzr('merge ../b', retcode=1)
396
self.runbzr(['commit', '-m', "Like an epidemic of u's"])
397
self.runbzr('merge ../b')
398
self.check_file_contents('goodbye', 'quux')
399
# Merging a branch pulls its revision into the tree
400
a = Branch('.')
401
b = Branch('../b')
402
a.get_revision_xml(b.last_patch())
403
print "Pending: %s" % a.pending_merges()
404
# assert a.pending_merges() == [b.last_patch()], "Assertion %s %s" \
405
# % (a.pending_merges(), b.last_patch())
406
Loggerhead is a web-based interface for Breezy
Version: 2.0.1