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