« back to all changes in this revision
Viewing changes to bzrlib/selftest/blackbox.py
- browse files at revision 1181
- compare with another revision
- download diff
- download tarball
- view history from revision 1181
- Committer: Martin Pool
- Date: 2005-09-05 09:11:03 UTC
- Revision ID: mbp@sourcefrog.net-20050905091103-1e51e146be0f08b4
- add test for deserialization from a canned XML inventory
- 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_fetch.py => bzrlib/selftest/testfetch.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/test_store.py => bzrlib/selftest/teststore.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
30
31
from bzrlib.selftest import TestCaseInTempDir, BzrTestBase
43
32
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
33
from bzrlib.commands import run_bzr
34
35
36
class ExternalBase(TestCaseInTempDir):
37
def runbzr(self, args, retcode=0,backtick=False):
38
if isinstance(args, basestring):
39
args = args.split()
40
41
if backtick:
42
return self.backtick(['python', self.BZRPATH,] + args,
43
retcode=retcode)
44
else:
45
return self.runcmd(['python', self.BZRPATH,] + args,
46
retcode=retcode)
47
49
48
50
49
class TestCommands(ExternalBase):
51
50
59
58
def test_init_branch(self):
60
59
self.runbzr(['init'])
61
60
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
61
def test_whoami(self):
77
62
# this should always identify something, if only "john@localhost"
78
63
self.runbzr("whoami")
87
72
f = file('.bzr/email', 'wt')
88
73
f.write('Branch Identity <branch@identi.ty>')
89
74
f.close()
90
bzr_email = os.environ.get('BZREMAIL')
91
if bzr_email is not None:
92
del os.environ['BZREMAIL']
93
75
whoami = self.runbzr("whoami",backtick=True)
94
76
whoami_email = self.runbzr("whoami --email",backtick=True)
95
77
self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
96
78
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
79
119
80
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)
81
self.runbzr("pants", retcode=1)
82
self.runbzr("--pants off", retcode=1)
83
self.runbzr("diff --message foo", retcode=1)
123
84
124
85
def test_empty_commit(self):
125
86
self.runbzr("init")
126
87
self.build_tree(['hello.txt'])
127
self.runbzr("commit -m empty", retcode=3)
88
self.runbzr("commit -m empty", retcode=1)
128
89
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)
90
self.runbzr("commit -m added")
164
91
165
92
def test_ignore_patterns(self):
166
93
from bzrlib.branch import Branch
167
Branch.initialize('.')
168
self.assertEquals(self.capture('unknowns'), '')
94
95
b = Branch('.', init=True)
96
self.assertEquals(list(b.unknowns()), [])
169
97
170
98
file('foo.tmp', 'wt').write('tmp files are ignored')
171
self.assertEquals(self.capture('unknowns'), '')
99
self.assertEquals(list(b.unknowns()), [])
100
assert self.backtick('bzr unknowns') == ''
172
101
173
102
file('foo.c', 'wt').write('int main() {}')
174
self.assertEquals(self.capture('unknowns'), 'foo.c\n')
103
self.assertEquals(list(b.unknowns()), ['foo.c'])
104
assert self.backtick('bzr unknowns') == 'foo.c\n'
175
105
176
106
self.runbzr(['add', 'foo.c'])
177
self.assertEquals(self.capture('unknowns'), '')
107
assert self.backtick('bzr unknowns') == ''
178
108
179
109
# 'ignore' works when creating the .bzignore file
180
110
file('foo.blah', 'wt').write('blah')
181
self.assertEquals(self.capture('unknowns'), 'foo.blah\n')
111
self.assertEquals(list(b.unknowns()), ['foo.blah'])
182
112
self.runbzr('ignore *.blah')
183
self.assertEquals(self.capture('unknowns'), '')
184
self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')
113
self.assertEquals(list(b.unknowns()), [])
114
assert file('.bzrignore', 'rb').read() == '*.blah\n'
185
115
186
116
# 'ignore' works when then .bzrignore file already exists
187
117
file('garh', 'wt').write('garh')
188
self.assertEquals(self.capture('unknowns'), 'garh\n')
118
self.assertEquals(list(b.unknowns()), ['garh'])
119
assert self.backtick('bzr unknowns') == 'garh\n'
189
120
self.runbzr('ignore garh')
190
self.assertEquals(self.capture('unknowns'), '')
191
self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')
121
self.assertEquals(list(b.unknowns()), [])
122
assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
192
123
193
124
def test_revert(self):
125
import os
194
126
self.runbzr('init')
195
127
196
128
file('hello', 'wt').write('foo')
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
def test_mv_modes(self):
150
def skipped_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('mv', 'a', 'b')
156
self.run_bzr('mv', 'b', 'subdir')
157
self.run_bzr('mv', 'subdir/b', 'a')
158
self.run_bzr('mv', 'a', 'b', 'subdir')
159
self.run_bzr('mv', 'subdir/a', 'subdir/newa')
267
160
268
161
def test_main_version(self):
269
162
"""Check output from version command and master option is reasonable"""
289
182
test.runbzr('add goodbye')
290
183
test.runbzr('commit -m setup goodbye')
291
184
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')
185
def test_revert(self):
186
self.example_branch()
187
file('hello', 'wt').write('bar')
188
file('goodbye', 'wt').write('qux')
189
self.runbzr('revert hello')
190
self.check_file_contents('hello', 'foo')
191
self.check_file_contents('goodbye', 'qux')
192
self.runbzr('revert')
193
self.check_file_contents('goodbye', 'baz')
407
194
408
195
def test_merge(self):
409
196
from bzrlib.branch import Branch
197
import os
410
198
411
199
os.mkdir('a')
412
200
os.chdir('a')
201
413
202
self.example_branch()
414
203
os.chdir('..')
415
204
self.runbzr('branch a b')
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
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
217
a = Branch('.')
218
b = Branch('../b')
219
a.get_revision_xml(b.last_patch())
220
221
self.log('pending merges: %s', a.pending_merges())
222
# assert a.pending_merges() == [b.last_patch()], "Assertion %s %s" \
223
# % (a.pending_merges(), b.last_patch())
224
225
667
226
def test_add_reports(self):
668
227
"""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('.')
228
b = Branch('.', init=True)
691
229
self.build_tree(['top.txt', 'dir/', 'dir/sub.txt'])
692
out = self.run_bzr_captured(['add', '-q'], retcode=0)[0]
230
231
from cStringIO import StringIO
232
out = StringIO()
233
234
ret = self.apply_redirected(None, out, None,
235
run_bzr,
236
['add'])
237
self.assertEquals(ret, 0)
238
693
239
# 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
240
results = sorted(out.getvalue().rstrip('\n').split('\n'))
241
self.assertEquals(['added dir',
242
'added dir/sub.txt',
243
'added top.txt',],
244
results)
991
245
992
246
993
247
class OldTests(ExternalBase):
996
250
def test_bzr(self):
997
251
from os import chdir, mkdir
998
252
from os.path import exists
253
import os
999
254
1000
255
runbzr = self.runbzr
1001
capture = self.capture
256
backtick = self.backtick
1002
257
progress = self.log
1003
258
1004
259
progress("basic branch creation")
1006
261
chdir('branch1')
1007
262
runbzr('init')
1008
263
1009
self.assertEquals(capture('root').rstrip(),
264
self.assertEquals(backtick('bzr root').rstrip(),
1010
265
os.path.join(self.test_dir, 'branch1'))
1011
266
1012
267
progress("status of new file")
1015
270
f.write('hello world!\n')
1016
271
f.close()
1017
272
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")
273
out = backtick("bzr unknowns")
274
self.assertEquals(out, 'test.txt\n')
275
276
out = backtick("bzr status")
277
assert out == 'unknown:\n test.txt\n'
278
279
out = backtick("bzr status --all")
280
assert out == "unknown:\n test.txt\n"
281
282
out = backtick("bzr status test.txt --all")
283
assert out == "unknown:\n test.txt\n"
1028
284
1029
285
f = file('test2.txt', 'wt')
1030
286
f.write('goodbye cruel world...\n')
1031
287
f.close()
1032
288
1033
out = capture("status test.txt")
1034
self.assertEquals(out, "unknown:\n test.txt\n")
289
out = backtick("bzr status test.txt")
290
assert out == "unknown:\n test.txt\n"
1035
291
1036
out = capture("status")
1037
self.assertEquals(out, ("unknown:\n" " test.txt\n" " test2.txt\n"))
292
out = backtick("bzr status")
293
assert out == ("unknown:\n"
294
" test.txt\n"
295
" test2.txt\n")
1038
296
1039
297
os.unlink('test2.txt')
1040
298
1041
299
progress("command aliases")
1042
out = capture("st --all")
1043
self.assertEquals(out, ("unknown:\n" " test.txt\n"))
300
out = backtick("bzr st --all")
301
assert out == ("unknown:\n"
302
" test.txt\n")
1044
303
1045
out = capture("stat")
1046
self.assertEquals(out, ("unknown:\n" " test.txt\n"))
304
out = backtick("bzr stat")
305
assert out == ("unknown:\n"
306
" test.txt\n")
1047
307
1048
308
progress("command help")
1049
309
runbzr("help st")
1050
310
runbzr("help")
1051
311
runbzr("help commands")
1052
runbzr("help slartibartfast", 3)
312
runbzr("help slartibartfast", 1)
1053
313
1054
out = capture("help ci")
314
out = backtick("bzr help ci")
1055
315
out.index('aliases: ')
1056
316
1057
317
progress("can't rename unversioned file")
1058
runbzr("rename test.txt new-test.txt", 3)
318
runbzr("rename test.txt new-test.txt", 1)
1059
319
1060
320
progress("adding a file")
1061
321
1062
322
runbzr("add test.txt")
1063
self.assertEquals(capture("unknowns"), '')
1064
self.assertEquals(capture("status --all"), ("added:\n" " test.txt\n"))
323
assert backtick("bzr unknowns") == ''
324
assert backtick("bzr status --all") == ("added:\n"
325
" test.txt\n")
1065
326
1066
327
progress("rename newly-added file")
1067
328
runbzr("rename test.txt hello.txt")
1068
self.assert_(os.path.exists("hello.txt"))
1069
self.assert_(not os.path.exists("test.txt"))
329
assert os.path.exists("hello.txt")
330
assert not os.path.exists("test.txt")
1070
331
1071
self.assertEquals(capture("revno"), '0\n')
332
assert backtick("bzr revno") == '0\n'
1072
333
1073
334
progress("add first revision")
1074
335
runbzr(['commit', '-m', 'add first revision'])
1075
336
1076
337
progress("more complex renames")
1077
338
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)
339
runbzr("rename hello.txt sub1", 1)
340
runbzr("rename hello.txt sub1/hello.txt", 1)
341
runbzr("move hello.txt sub1", 1)
1081
342
1082
343
runbzr("add sub1")
1083
344
runbzr("rename sub1 sub2")
1084
345
runbzr("move hello.txt sub2")
1085
self.assertEqual(capture("relpath sub2/hello.txt"),
1086
os.path.join("sub2", "hello.txt\n"))
346
assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
1087
347
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"))
348
assert exists("sub2")
349
assert exists("sub2/hello.txt")
350
assert not exists("sub1")
351
assert not exists("hello.txt")
1092
352
1093
353
runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
1094
354
1095
355
mkdir("sub1")
1096
356
runbzr('add sub1')
1097
357
runbzr('move sub2/hello.txt sub1')
1098
self.assert_(not exists('sub2/hello.txt'))
1099
self.assert_(exists('sub1/hello.txt'))
358
assert not exists('sub2/hello.txt')
359
assert exists('sub1/hello.txt')
1100
360
runbzr('move sub2 sub1')
1101
self.assert_(not exists('sub2'))
1102
self.assert_(exists('sub1/sub2'))
361
assert not exists('sub2')
362
assert exists('sub1/sub2')
1103
363
1104
364
runbzr(['commit', '-m', 'rename nested subdirectories'])
1105
365
1106
366
chdir('sub1/sub2')
1107
self.assertEquals(capture('root')[:-1],
367
self.assertEquals(backtick('bzr root')[:-1],
1108
368
os.path.join(self.test_dir, 'branch1'))
1109
369
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'))
370
assert exists('./hello.txt')
371
assert backtick('bzr relpath hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
372
assert backtick('bzr relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
1114
373
runbzr(['commit', '-m', 'move to parent directory'])
1115
374
chdir('..')
1116
self.assertEquals(capture('relpath sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
375
assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
1117
376
1118
377
runbzr('move sub2/hello.txt .')
1119
self.assert_(exists('hello.txt'))
378
assert exists('hello.txt')
1120
379
1121
380
f = file('hello.txt', 'wt')
1122
381
f.write('some nice new content\n')
1123
382
f.close()
1124
383
1125
384
f = file('msg.tmp', 'wt')
1126
f.write('this is my new commit\nand it has multiple lines, for fun')
385
f.write('this is my new commit\n')
1127
386
f.close()
1128
387
1129
388
runbzr('commit -F msg.tmp')
1130
389
1131
self.assertEquals(capture('revno'), '5\n')
390
assert backtick('bzr revno') == '5\n'
1132
391
runbzr('export -r 5 export-5.tmp')
1133
392
runbzr('export export.tmp')
1134
393
1135
394
runbzr('log')
1136
395
runbzr('log -v')
1137
396
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)
397
runbzr('log -m', retcode=1)
398
log_out = backtick('bzr log -m commit')
399
assert "this is my new commit" in log_out
400
assert "rename nested" not in log_out
401
assert 'revision-id' not in log_out
402
assert 'revision-id' in backtick('bzr log --show-ids -m commit')
1149
403
1150
404
1151
405
progress("file with spaces in name")
1152
406
mkdir('sub directory')
1153
407
file('sub directory/file with spaces ', 'wt').write('see how this works\n')
1154
408
runbzr('add .')
1155
runbzr('diff', retcode=1)
409
runbzr('diff')
1156
410
runbzr('commit -m add-spaces')
1157
411
runbzr('check')
1158
412
1161
415
1162
416
runbzr('info')
1163
417
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)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1