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