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