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