~bzr-pqm/bzr/bzr.dev
» Revision
1094
(compared to revision 1185.33.74)
: bzrlib/selftest/blackbox.py
« back to all changes in this revision
Viewing changes to bzrlib/selftest/blackbox.py
- browse files at revision 1094
- compare with another revision
- download diff
- download tarball
- view history from revision 1094
- Committer: Martin Pool
- Date: 2005-08-23 00:27:12 UTC
- Revision ID: mbp@sourcefrog.net-20050823002712-2b0f5e12243a6116
- merge aaron's merge improvements 999..1008
abentley@panoramicfeedback.com-20050822154931-a0da28d30681e2c6
abentley@panoramicfeedback.com-20050822154931-a0da28d30681e2c6
- files added:
- bzrlib/mdiff.py
- files removed:
- INSTALL
- bzrlib/export
- bzrlib/store
- bzrlib/tests/blackbox
- bzrlib/transport
- bzrlib/ui
- bzrlib/util/configobj
- bzrlib/util/configobj/docs
- files renamed:
- bzr_man.py => bzr-man.py
- contrib/newinventory.py => bzrlib/newinventory.py
- bzrlib/tests/ => bzrlib/selftest/
- bzrlib/tests/blackbox/test_too_much.py => bzrlib/selftest/blackbox.py
- bzrlib/tests/test_plugins.py => bzrlib/selftest/plugins.py
- bzrlib/tests/test_branch.py => bzrlib/selftest/testbranch.py
- bzrlib/tests/test_diff.py => bzrlib/selftest/testdiff.py
- bzrlib/tests/test_hashcache.py => bzrlib/selftest/testhashcache.py
- bzrlib/tests/test_inv.py => bzrlib/selftest/testinv.py
- bzrlib/tests/test_log.py => bzrlib/selftest/testlog.py
- bzrlib/tests/test_merge3.py => bzrlib/selftest/testmerge3.py
- bzrlib/tests/test_revision.py => bzrlib/selftest/testrevision.py
- bzrlib/tests/test_revisionnamespaces.py => bzrlib/selftest/testrevisionnamespaces.py
- bzrlib/tests/test_status.py => bzrlib/selftest/teststatus.py
- bzrlib/tests/blackbox/test_versioning.py => bzrlib/selftest/versioning.py
- bzrlib/tests/test_whitebox.py => bzrlib/selftest/whitebox.py
- bzrlib/store/__init__.py => bzrlib/store.py
- bzrlib/upgrade.py => tools/history2weaves.py
- bzrlib/tests/test_weave.py => tools/testweave.py
- files modified:
- .bzrignore
- bzr *
- setup.py *
added
removed
bzrlib/selftest/blackbox.py
19
19
"""Black-box tests for bzr.
20
20
21
21
These check that it behaves properly when it's invoked through the regular
22
command-line interface. This doesn't actually run a new interpreter but
23
rather starts again from the run_bzr function.
22
command-line interface.
23
24
This always reinvokes bzr through a new Python interpreter, which is a
25
bit inefficient but arguably tests in a way more representative of how
26
it's normally invoked.
24
27
"""
25
28
26
27
# XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
28
# Note: Please don't add new tests here, it's too big and bulky. Instead add
29
# them into small suites in bzrlib.tests.blackbox.test_FOO for the particular
30
# UI command/aspect that is being tested.
31
32
33
from cStringIO import StringIO
34
import os
35
import re
36
import shutil
37
29
import sys
38
30
39
from bzrlib.branch import Branch
40
from bzrlib.clone import copy_branch
41
from bzrlib.errors import BzrCommandError
42
from bzrlib.osutils import has_symlinks
43
from bzrlib.tests.HTTPTestUtil import TestCaseWithWebserver
44
from bzrlib.tests.blackbox import ExternalBase
45
46
class TestCommands(ExternalBase):
47
48
def test_help_commands(self):
31
from bzrlib.selftest import TestBase, InTempDir, BzrTestBase
32
33
34
35
class ExternalBase(InTempDir):
36
def runbzr(self, args, retcode=0,backtick=False):
37
try:
38
import shutil
39
from subprocess import call
40
except ImportError, e:
41
_need_subprocess()
42
raise
43
44
if isinstance(args, basestring):
45
args = args.split()
46
47
if backtick:
48
return self.backtick(['python', self.BZRPATH,] + args,
49
retcode=retcode)
50
else:
51
return self.runcmd(['python', self.BZRPATH,] + args,
52
retcode=retcode)
53
54
55
56
class MvCommand(BzrTestBase):
57
def runbzr(self):
58
"""Test two modes of operation for mv"""
59
b = Branch('.', init=True)
60
self.build_tree(['a', 'c', 'subdir/'])
61
self.run_bzr('mv', 'a', 'b')
62
self.run_bzr('mv', 'b', 'subdir')
63
self.run_bzr('mv', 'subdir/b', 'a')
64
self.run_bzr('mv', 'a', 'b', 'subdir')
65
self.run_bzr('mv', 'subdir/a', 'subdir/newa')
66
67
68
69
class TestVersion(BzrTestBase):
70
"""Check output from version command and master option is reasonable"""
71
def runTest(self):
72
# output is intentionally passed through to stdout so that we
73
# can see the version being tested
74
from cStringIO import StringIO
75
save_out = sys.stdout
76
try:
77
sys.stdout = tmp_out = StringIO()
78
79
self.run_bzr('version')
80
finally:
81
sys.stdout = save_out
82
83
output = tmp_out.getvalue()
84
self.log('bzr version output:')
85
self.log(output)
86
87
self.assert_(output.startswith('bzr (bazaar-ng) '))
88
self.assertNotEqual(output.index('Canonical'), -1)
89
90
# make sure --version is consistent
91
try:
92
sys.stdout = tmp_out = StringIO()
93
94
self.run_bzr('--version')
95
finally:
96
sys.stdout = save_out
97
98
self.log('bzr --version output:')
99
self.log(tmp_out.getvalue())
100
101
self.assertEquals(output, tmp_out.getvalue())
102
103
104
105
106
107
class HelpCommands(ExternalBase):
108
def runTest(self):
49
109
self.runbzr('--help')
50
110
self.runbzr('help')
51
111
self.runbzr('help commands')
52
112
self.runbzr('help help')
53
113
self.runbzr('commit -h')
54
114
55
def test_init_branch(self):
115
116
class InitBranch(ExternalBase):
117
def runTest(self):
118
import os
56
119
self.runbzr(['init'])
57
120
58
# Can it handle subdirectories as well?
59
self.runbzr('init subdir1')
60
self.assert_(os.path.exists('subdir1'))
61
self.assert_(os.path.exists('subdir1/.bzr'))
62
63
self.runbzr('init subdir2/nothere', retcode=3)
64
65
os.mkdir('subdir2')
66
self.runbzr('init subdir2')
67
self.runbzr('init subdir2', retcode=3)
68
69
self.runbzr('init subdir2/subsubdir1')
70
self.assert_(os.path.exists('subdir2/subsubdir1/.bzr'))
71
72
def test_whoami(self):
121
122
123
class UserIdentity(ExternalBase):
124
def runTest(self):
73
125
# this should always identify something, if only "john@localhost"
74
126
self.runbzr("whoami")
75
127
self.runbzr("whoami --email")
77
129
self.assertEquals(self.runbzr("whoami --email",
78
130
backtick=True).count('@'), 1)
79
131
80
def test_whoami_branch(self):
81
"""branch specific user identity works."""
132
class UserIdentityBranch(ExternalBase):
133
def runTest(self):
134
# tests branch specific user identity
82
135
self.runbzr('init')
83
136
f = file('.bzr/email', 'wt')
84
137
f.write('Branch Identity <branch@identi.ty>')
85
138
f.close()
86
bzr_email = os.environ.get('BZREMAIL')
87
if bzr_email is not None:
88
del os.environ['BZREMAIL']
89
139
whoami = self.runbzr("whoami",backtick=True)
90
140
whoami_email = self.runbzr("whoami --email",backtick=True)
91
141
self.assertTrue(whoami.startswith('Branch Identity <branch@identi.ty>'))
92
142
self.assertTrue(whoami_email.startswith('branch@identi.ty'))
93
# Verify that the environment variable overrides the value
94
# in the file
95
os.environ['BZREMAIL'] = 'Different ID <other@environ.ment>'
96
whoami = self.runbzr("whoami",backtick=True)
97
whoami_email = self.runbzr("whoami --email",backtick=True)
98
self.assertTrue(whoami.startswith('Different ID <other@environ.ment>'))
99
self.assertTrue(whoami_email.startswith('other@environ.ment'))
100
if bzr_email is not None:
101
os.environ['BZREMAIL'] = bzr_email
102
103
def test_nick_command(self):
104
"""bzr nick for viewing, setting nicknames"""
105
os.mkdir('me.dev')
106
os.chdir('me.dev')
107
self.runbzr('init')
108
nick = self.runbzr("nick",backtick=True)
109
self.assertEqual(nick, 'me.dev\n')
110
nick = self.runbzr("nick moo")
111
nick = self.runbzr("nick",backtick=True)
112
self.assertEqual(nick, 'moo\n')
113
114
115
def test_invalid_commands(self):
116
self.runbzr("pants", retcode=3)
117
self.runbzr("--pants off", retcode=3)
118
self.runbzr("diff --message foo", retcode=3)
119
120
def test_empty_commit(self):
143
144
145
class InvalidCommands(ExternalBase):
146
def runTest(self):
147
self.runbzr("pants", retcode=1)
148
self.runbzr("--pants off", retcode=1)
149
self.runbzr("diff --message foo", retcode=1)
150
151
152
153
class EmptyCommit(ExternalBase):
154
def runTest(self):
121
155
self.runbzr("init")
122
156
self.build_tree(['hello.txt'])
123
self.runbzr("commit -m empty", retcode=3)
157
self.runbzr("commit -m empty", retcode=1)
124
158
self.runbzr("add hello.txt")
125
self.runbzr("commit -m added")
126
127
def test_empty_commit_message(self):
128
self.runbzr("init")
129
file('foo.c', 'wt').write('int main() {}')
130
self.runbzr(['add', 'foo.c'])
131
self.runbzr(["commit", "-m", ""] , retcode=3)
132
133
def test_remove_deleted(self):
134
self.runbzr("init")
135
self.build_tree(['a'])
136
self.runbzr(['add', 'a'])
137
self.runbzr(['commit', '-m', 'added a'])
138
os.unlink('a')
139
self.runbzr(['remove', 'a'])
140
141
def test_other_branch_commit(self):
142
# this branch is to ensure consistent behaviour, whether we're run
143
# inside a branch, or not.
144
os.mkdir('empty_branch')
145
os.chdir('empty_branch')
146
self.runbzr('init')
147
os.mkdir('branch')
148
os.chdir('branch')
149
self.runbzr('init')
150
file('foo.c', 'wt').write('int main() {}')
151
file('bar.c', 'wt').write('int main() {}')
152
os.chdir('..')
153
self.runbzr(['add', 'branch/foo.c'])
154
self.runbzr(['add', 'branch'])
155
# can't commit files in different trees; sane error
156
self.runbzr('commit -m newstuff branch/foo.c .', retcode=3)
157
self.runbzr('commit -m newstuff branch/foo.c')
158
self.runbzr('commit -m newstuff branch')
159
self.runbzr('commit -m newstuff branch', retcode=3)
160
161
def test_ignore_patterns(self):
159
self.runbzr("commit -m added")
160
161
162
163
class IgnorePatterns(ExternalBase):
164
def runTest(self):
162
165
from bzrlib.branch import Branch
163
Branch.initialize('.')
164
self.assertEquals(self.capture('unknowns'), '')
166
167
b = Branch('.', init=True)
168
self.assertEquals(list(b.unknowns()), [])
165
169
166
170
file('foo.tmp', 'wt').write('tmp files are ignored')
167
self.assertEquals(self.capture('unknowns'), '')
171
self.assertEquals(list(b.unknowns()), [])
172
assert self.backtick('bzr unknowns') == ''
168
173
169
174
file('foo.c', 'wt').write('int main() {}')
170
self.assertEquals(self.capture('unknowns'), 'foo.c\n')
175
self.assertEquals(list(b.unknowns()), ['foo.c'])
176
assert self.backtick('bzr unknowns') == 'foo.c\n'
171
177
172
178
self.runbzr(['add', 'foo.c'])
173
self.assertEquals(self.capture('unknowns'), '')
179
assert self.backtick('bzr unknowns') == ''
174
180
175
181
# 'ignore' works when creating the .bzignore file
176
182
file('foo.blah', 'wt').write('blah')
177
self.assertEquals(self.capture('unknowns'), 'foo.blah\n')
183
self.assertEquals(list(b.unknowns()), ['foo.blah'])
178
184
self.runbzr('ignore *.blah')
179
self.assertEquals(self.capture('unknowns'), '')
180
self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')
185
self.assertEquals(list(b.unknowns()), [])
186
assert file('.bzrignore', 'rb').read() == '*.blah\n'
181
187
182
188
# 'ignore' works when then .bzrignore file already exists
183
189
file('garh', 'wt').write('garh')
184
self.assertEquals(self.capture('unknowns'), 'garh\n')
190
self.assertEquals(list(b.unknowns()), ['garh'])
191
assert self.backtick('bzr unknowns') == 'garh\n'
185
192
self.runbzr('ignore garh')
186
self.assertEquals(self.capture('unknowns'), '')
187
self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')
188
189
def test_revert(self):
190
self.runbzr('init')
191
192
file('hello', 'wt').write('foo')
193
self.runbzr('add hello')
194
self.runbzr('commit -m setup hello')
195
196
file('goodbye', 'wt').write('baz')
197
self.runbzr('add goodbye')
198
self.runbzr('commit -m setup goodbye')
199
200
file('hello', 'wt').write('bar')
201
file('goodbye', 'wt').write('qux')
202
self.runbzr('revert hello')
203
self.check_file_contents('hello', 'foo')
204
self.check_file_contents('goodbye', 'qux')
205
self.runbzr('revert')
206
self.check_file_contents('goodbye', 'baz')
207
208
os.mkdir('revertdir')
209
self.runbzr('add revertdir')
210
self.runbzr('commit -m f')
211
os.rmdir('revertdir')
212
self.runbzr('revert')
213
214
os.symlink('/unlikely/to/exist', 'symlink')
215
self.runbzr('add symlink')
216
self.runbzr('commit -m f')
217
os.unlink('symlink')
218
self.runbzr('revert')
219
self.failUnlessExists('symlink')
220
os.unlink('symlink')
221
os.symlink('a-different-path', 'symlink')
222
self.runbzr('revert')
223
self.assertEqual('/unlikely/to/exist',
224
os.readlink('symlink'))
225
226
file('hello', 'wt').write('xyz')
227
self.runbzr('commit -m xyz hello')
228
self.runbzr('revert -r 1 hello')
229
self.check_file_contents('hello', 'foo')
230
self.runbzr('revert hello')
231
self.check_file_contents('hello', 'xyz')
232
os.chdir('revertdir')
233
self.runbzr('revert')
234
os.chdir('..')
235
236
def test_status(self):
237
self.runbzr("init")
238
self.build_tree(['hello.txt'])
239
result = self.runbzr("status")
240
self.assert_("unknown:\n hello.txt\n" in result, result)
241
self.runbzr("add hello.txt")
242
result = self.runbzr("status")
243
self.assert_("added:\n hello.txt\n" in result, result)
244
self.runbzr("commit -m added")
245
result = self.runbzr("status -r 0..1")
246
self.assert_("added:\n hello.txt\n" in result, result)
247
self.build_tree(['world.txt'])
248
result = self.runbzr("status -r 0")
249
self.assert_("added:\n hello.txt\n" \
250
"unknown:\n world.txt\n" in result, result)
251
252
def test_mv_modes(self):
253
"""Test two modes of operation for mv"""
254
from bzrlib.branch import Branch
255
b = Branch.initialize('.')
256
self.build_tree(['a', 'c', 'subdir/'])
257
self.run_bzr_captured(['add', self.test_dir])
258
self.run_bzr_captured(['mv', 'a', 'b'])
259
self.run_bzr_captured(['mv', 'b', 'subdir'])
260
self.run_bzr_captured(['mv', 'subdir/b', 'a'])
261
self.run_bzr_captured(['mv', 'a', 'c', 'subdir'])
262
self.run_bzr_captured(['mv', 'subdir/a', 'subdir/newa'])
263
264
def test_main_version(self):
265
"""Check output from version command and master option is reasonable"""
266
# output is intentionally passed through to stdout so that we
267
# can see the version being tested
268
output = self.runbzr('version', backtick=1)
269
self.log('bzr version output:')
270
self.log(output)
271
self.assert_(output.startswith('bzr (bazaar-ng) '))
272
self.assertNotEqual(output.index('Canonical'), -1)
273
# make sure --version is consistent
274
tmp_output = self.runbzr('--version', backtick=1)
275
self.log('bzr --version output:')
276
self.log(tmp_output)
277
self.assertEquals(output, tmp_output)
278
279
def example_branch(test):
280
test.runbzr('init')
281
file('hello', 'wt').write('foo')
282
test.runbzr('add hello')
283
test.runbzr('commit -m setup hello')
284
file('goodbye', 'wt').write('baz')
285
test.runbzr('add goodbye')
286
test.runbzr('commit -m setup goodbye')
287
288
def test_export(self):
289
os.mkdir('branch')
290
os.chdir('branch')
291
self.example_branch()
292
self.runbzr('export ../latest')
293
self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
294
self.runbzr('export ../first -r 1')
295
self.assert_(not os.path.exists('../first/goodbye'))
296
self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
297
self.runbzr('export ../first.gz -r 1')
298
self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
299
self.runbzr('export ../first.bz2 -r 1')
300
self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
301
302
from tarfile import TarFile
303
self.runbzr('export ../first.tar -r 1')
304
self.assert_(os.path.isfile('../first.tar'))
305
tf = TarFile('../first.tar')
306
self.assert_('first/hello' in tf.getnames(), tf.getnames())
307
self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
308
self.runbzr('export ../first.tar.gz -r 1')
309
self.assert_(os.path.isfile('../first.tar.gz'))
310
self.runbzr('export ../first.tbz2 -r 1')
311
self.assert_(os.path.isfile('../first.tbz2'))
312
self.runbzr('export ../first.tar.bz2 -r 1')
313
self.assert_(os.path.isfile('../first.tar.bz2'))
314
self.runbzr('export ../first.tar.tbz2 -r 1')
315
self.assert_(os.path.isfile('../first.tar.tbz2'))
316
317
from bz2 import BZ2File
318
tf = TarFile('../first.tar.tbz2',
319
fileobj=BZ2File('../first.tar.tbz2', 'r'))
320
self.assert_('first.tar/hello' in tf.getnames(), tf.getnames())
321
self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
322
self.runbzr('export ../first2.tar -r 1 --root pizza')
323
tf = TarFile('../first2.tar')
324
self.assert_('pizza/hello' in tf.getnames(), tf.getnames())
325
326
from zipfile import ZipFile
327
self.runbzr('export ../first.zip -r 1')
328
self.failUnlessExists('../first.zip')
329
zf = ZipFile('../first.zip')
330
self.assert_('first/hello' in zf.namelist(), zf.namelist())
331
self.assertEqual(zf.read('first/hello'), 'foo')
332
333
self.runbzr('export ../first2.zip -r 1 --root pizza')
334
zf = ZipFile('../first2.zip')
335
self.assert_('pizza/hello' in zf.namelist(), zf.namelist())
336
337
self.runbzr('export ../first-zip --format=zip -r 1')
338
zf = ZipFile('../first-zip')
339
self.assert_('first-zip/hello' in zf.namelist(), zf.namelist())
340
341
def test_diff(self):
342
self.example_branch()
343
file('hello', 'wt').write('hello world!')
344
self.runbzr('commit -m fixing hello')
345
output = self.runbzr('diff -r 2..3', backtick=1, retcode=1)
346
self.assert_('\n+hello world!' in output)
347
output = self.runbzr('diff -r last:3..last:1', backtick=1, retcode=1)
348
self.assert_('\n+baz' in output)
349
file('moo', 'wb').write('moo')
350
self.runbzr('add moo')
351
os.unlink('moo')
352
self.runbzr('diff')
353
354
def test_diff_branches(self):
355
self.build_tree(['branch1/', 'branch1/file', 'branch2/'], line_endings='binary')
356
branch = Branch.initialize('branch1')
357
branch.working_tree().add(['file'])
358
branch.working_tree().commit('add file')
359
copy_branch(branch, 'branch2')
360
print >> open('branch2/file', 'wb'), 'new content'
361
branch2 = Branch.open('branch2')
362
branch2.working_tree().commit('update file')
363
# should open branch1 and diff against branch2,
364
output = self.run_bzr_captured(['diff', '-r', 'branch:branch2',
365
'branch1'],
366
retcode=1)
367
self.assertEquals(("=== modified file 'file'\n"
368
"--- file\t\n"
369
"+++ file\t\n"
370
"@@ -1,1 +1,1 @@\n"
371
"-new content\n"
372
"+contents of branch1/file\n"
373
"\n", ''), output)
374
output = self.run_bzr_captured(['diff', 'branch2', 'branch1'],
375
retcode=1)
376
self.assertEqualDiff(("=== modified file 'file'\n"
377
"--- file\t\n"
378
"+++ file\t\n"
379
"@@ -1,1 +1,1 @@\n"
380
"-new content\n"
381
"+contents of branch1/file\n"
382
"\n", ''), output)
383
384
385
def test_branch(self):
386
"""Branch from one branch to another."""
387
os.mkdir('a')
388
os.chdir('a')
389
self.example_branch()
390
os.chdir('..')
391
self.runbzr('branch a b')
392
self.assertFileEqual('b\n', 'b/.bzr/branch-name')
393
self.runbzr('branch a c -r 1')
394
os.chdir('b')
395
self.runbzr('commit -m foo --unchanged')
396
os.chdir('..')
397
# naughty - abstraction violations RBC 20050928
398
print "test_branch used to delete the stores, how is this meant to work ?"
399
#shutil.rmtree('a/.bzr/revision-store')
400
#shutil.rmtree('a/.bzr/inventory-store', ignore_errors=True)
401
#shutil.rmtree('a/.bzr/text-store', ignore_errors=True)
402
self.runbzr('branch a d --basis b')
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_add_in_unversioned(self):
741
"""Try to add a file in an unversioned directory.
742
743
"bzr add" should add the parent(s) as necessary.
744
"""
745
from bzrlib.branch import Branch
746
Branch.initialize('.')
747
self.build_tree(['inertiatic/', 'inertiatic/esp'])
748
self.assertEquals(self.capture('unknowns'), 'inertiatic\n')
749
self.run_bzr('add', 'inertiatic/esp')
750
self.assertEquals(self.capture('unknowns'), '')
751
752
# Multiple unversioned parents
753
self.build_tree(['veil/', 'veil/cerpin/', 'veil/cerpin/taxt'])
754
self.assertEquals(self.capture('unknowns'), 'veil\n')
755
self.run_bzr('add', 'veil/cerpin/taxt')
756
self.assertEquals(self.capture('unknowns'), '')
757
758
# Check whacky paths work
759
self.build_tree(['cicatriz/', 'cicatriz/esp'])
760
self.assertEquals(self.capture('unknowns'), 'cicatriz\n')
761
self.run_bzr('add', 'inertiatic/../cicatriz/esp')
762
self.assertEquals(self.capture('unknowns'), '')
763
764
def test_add_in_versioned(self):
765
"""Try to add a file in a versioned directory.
766
767
"bzr add" should do this happily.
768
"""
769
from bzrlib.branch import Branch
770
Branch.initialize('.')
771
self.build_tree(['inertiatic/', 'inertiatic/esp'])
772
self.assertEquals(self.capture('unknowns'), 'inertiatic\n')
773
self.run_bzr('add', '--no-recurse', 'inertiatic')
774
self.assertEquals(self.capture('unknowns'), 'inertiatic'+os.sep+'esp\n')
775
self.run_bzr('add', 'inertiatic/esp')
776
self.assertEquals(self.capture('unknowns'), '')
777
778
def test_subdir_add(self):
779
"""Add in subdirectory should add only things from there down"""
780
from bzrlib.branch import Branch
781
782
eq = self.assertEqual
783
ass = self.assert_
784
chdir = os.chdir
785
786
b = Branch.initialize('.')
787
t = b.working_tree()
788
self.build_tree(['src/', 'README'])
789
790
eq(sorted(t.unknowns()),
791
['README', 'src'])
792
793
self.run_bzr('add', 'src')
794
795
self.build_tree(['src/foo.c'])
796
797
chdir('src')
798
self.run_bzr('add')
799
800
self.assertEquals(self.capture('unknowns'), 'README\n')
801
eq(len(t.read_working_inventory()), 3)
802
803
chdir('..')
804
self.run_bzr('add')
805
self.assertEquals(self.capture('unknowns'), '')
806
self.run_bzr('check')
807
808
def test_unknown_command(self):
809
"""Handling of unknown command."""
810
out, err = self.run_bzr_captured(['fluffy-badger'],
811
retcode=3)
812
self.assertEquals(out, '')
813
err.index('unknown command')
814
815
def create_conflicts(self):
816
"""Create a conflicted tree"""
817
os.mkdir('base')
818
os.chdir('base')
819
file('hello', 'wb').write("hi world")
820
file('answer', 'wb').write("42")
821
self.runbzr('init')
822
self.runbzr('add')
823
self.runbzr('commit -m base')
824
self.runbzr('branch . ../other')
825
self.runbzr('branch . ../this')
826
os.chdir('../other')
827
file('hello', 'wb').write("Hello.")
828
file('answer', 'wb').write("Is anyone there?")
829
self.runbzr('commit -m other')
830
os.chdir('../this')
831
file('hello', 'wb').write("Hello, world")
832
self.runbzr('mv answer question')
833
file('question', 'wb').write("What do you get when you multiply six"
834
"times nine?")
835
self.runbzr('commit -m this')
836
837
def test_remerge(self):
838
"""Remerge command works as expected"""
839
self.create_conflicts()
840
self.runbzr('merge ../other --show-base', retcode=1)
841
conflict_text = file('hello').read()
842
assert '|||||||' in conflict_text
843
assert 'hi world' in conflict_text
844
self.runbzr('remerge', retcode=1)
845
conflict_text = file('hello').read()
846
assert '|||||||' not in conflict_text
847
assert 'hi world' not in conflict_text
848
os.unlink('hello.OTHER')
849
self.runbzr('remerge hello --merge-type weave', retcode=1)
850
assert os.path.exists('hello.OTHER')
851
file_id = self.runbzr('file-id hello')
852
file_id = self.runbzr('file-id hello.THIS', retcode=3)
853
self.runbzr('remerge --merge-type weave', retcode=1)
854
assert os.path.exists('hello.OTHER')
855
assert not os.path.exists('hello.BASE')
856
assert '|||||||' not in conflict_text
857
assert 'hi world' not in conflict_text
858
self.runbzr('remerge . --merge-type weave --show-base', retcode=3)
859
self.runbzr('remerge . --merge-type weave --reprocess', retcode=3)
860
self.runbzr('remerge . --show-base --reprocess', retcode=3)
861
self.runbzr('remerge hello --show-base', retcode=1)
862
self.runbzr('remerge hello --reprocess', retcode=1)
863
self.runbzr('resolve --all')
864
self.runbzr('commit -m done',)
865
self.runbzr('remerge', retcode=3)
866
867
868
def test_conflicts(self):
869
"""Handling of merge conflicts"""
870
self.create_conflicts()
871
self.runbzr('merge ../other --show-base', retcode=1)
872
conflict_text = file('hello').read()
873
self.assert_('<<<<<<<' in conflict_text)
874
self.assert_('>>>>>>>' in conflict_text)
875
self.assert_('=======' in conflict_text)
876
self.assert_('|||||||' in conflict_text)
877
self.assert_('hi world' in conflict_text)
878
self.runbzr('revert')
879
self.runbzr('resolve --all')
880
self.runbzr('merge ../other', retcode=1)
881
conflict_text = file('hello').read()
882
self.assert_('|||||||' not in conflict_text)
883
self.assert_('hi world' not in conflict_text)
884
result = self.runbzr('conflicts', backtick=1)
885
self.assertEquals(result, "hello\nquestion\n")
886
result = self.runbzr('status', backtick=1)
887
self.assert_("conflicts:\n hello\n question\n" in result, result)
888
self.runbzr('resolve hello')
889
result = self.runbzr('conflicts', backtick=1)
890
self.assertEquals(result, "question\n")
891
self.runbzr('commit -m conflicts', retcode=3)
892
self.runbzr('resolve --all')
893
result = self.runbzr('conflicts', backtick=1)
894
self.runbzr('commit -m conflicts')
895
self.assertEquals(result, "")
896
897
def test_resign(self):
898
"""Test re signing of data."""
899
import bzrlib.gpg
900
oldstrategy = bzrlib.gpg.GPGStrategy
901
branch = Branch.initialize('.')
902
branch.working_tree().commit("base", allow_pointless=True, rev_id='A')
903
try:
904
# monkey patch gpg signing mechanism
905
from bzrlib.testament import Testament
906
bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
907
self.runbzr('re-sign -r revid:A')
908
self.assertEqual(Testament.from_revision(branch,'A').as_short_text(),
909
branch.revision_store.get('A', 'sig').read())
910
finally:
911
bzrlib.gpg.GPGStrategy = oldstrategy
912
913
def test_resign_range(self):
914
import bzrlib.gpg
915
oldstrategy = bzrlib.gpg.GPGStrategy
916
branch = Branch.initialize('.')
917
branch.working_tree().commit("base", allow_pointless=True, rev_id='A')
918
branch.working_tree().commit("base", allow_pointless=True, rev_id='B')
919
branch.working_tree().commit("base", allow_pointless=True, rev_id='C')
920
try:
921
# monkey patch gpg signing mechanism
922
from bzrlib.testament import Testament
923
bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
924
self.runbzr('re-sign -r 1..')
925
self.assertEqual(Testament.from_revision(branch,'A').as_short_text(),
926
branch.revision_store.get('A', 'sig').read())
927
self.assertEqual(Testament.from_revision(branch,'B').as_short_text(),
928
branch.revision_store.get('B', 'sig').read())
929
self.assertEqual(Testament.from_revision(branch,'C').as_short_text(),
930
branch.revision_store.get('C', 'sig').read())
931
finally:
932
bzrlib.gpg.GPGStrategy = oldstrategy
933
934
def test_push(self):
935
# create a source branch
936
os.mkdir('my-branch')
937
os.chdir('my-branch')
938
self.example_branch()
939
940
# with no push target, fail
941
self.runbzr('push', retcode=3)
942
# with an explicit target work
943
self.runbzr('push ../output-branch')
944
# with an implicit target work
945
self.runbzr('push')
946
# nothing missing
947
self.runbzr('missing ../output-branch')
948
# advance this branch
949
self.runbzr('commit --unchanged -m unchanged')
950
951
os.chdir('../output-branch')
952
# should be a diff as we have not pushed the tree
953
self.runbzr('diff', retcode=1)
954
self.runbzr('revert')
955
# but not now.
956
self.runbzr('diff')
957
# diverge the branches
958
self.runbzr('commit --unchanged -m unchanged')
959
os.chdir('../my-branch')
960
# cannot push now
961
self.runbzr('push', retcode=3)
962
# and there are difference
963
self.runbzr('missing ../output-branch', retcode=1)
964
self.runbzr('missing --verbose ../output-branch', retcode=1)
965
# but we can force a push
966
self.runbzr('push --overwrite')
967
# nothing missing
968
self.runbzr('missing ../output-branch')
969
970
# pushing to a new dir with no parent should fail
971
self.runbzr('push ../missing/new-branch', retcode=3)
972
# unless we provide --create-prefix
973
self.runbzr('push --create-prefix ../missing/new-branch')
974
# nothing missing
975
self.runbzr('missing ../missing/new-branch')
976
977
def test_external_command(self):
978
"""test that external commands can be run by setting the path"""
979
cmd_name = 'test-command'
980
output = 'Hello from test-command'
981
if sys.platform == 'win32':
982
cmd_name += '.bat'
983
output += '\r\n'
984
else:
985
output += '\n'
986
987
oldpath = os.environ.get('BZRPATH', None)
988
989
bzr = self.capture
990
991
try:
992
if os.environ.has_key('BZRPATH'):
993
del os.environ['BZRPATH']
994
995
f = file(cmd_name, 'wb')
996
if sys.platform == 'win32':
997
f.write('@echo off\n')
998
else:
999
f.write('#!/bin/sh\n')
1000
f.write('echo Hello from test-command')
1001
f.close()
1002
os.chmod(cmd_name, 0755)
1003
1004
# It should not find the command in the local
1005
# directory by default, since it is not in my path
1006
bzr(cmd_name, retcode=3)
1007
1008
# Now put it into my path
1009
os.environ['BZRPATH'] = '.'
1010
1011
bzr(cmd_name)
1012
# The test suite does not capture stdout for external commands
1013
# this is because you have to have a real file object
1014
# to pass to Popen(stdout=FOO), and StringIO is not one of those.
1015
# (just replacing sys.stdout does not change a spawned objects stdout)
1016
#self.assertEquals(bzr(cmd_name), output)
1017
1018
# Make sure empty path elements are ignored
1019
os.environ['BZRPATH'] = os.pathsep
1020
1021
bzr(cmd_name, retcode=3)
1022
1023
finally:
1024
if oldpath:
1025
os.environ['BZRPATH'] = oldpath
1026
1027
1028
def listdir_sorted(dir):
1029
L = os.listdir(dir)
1030
L.sort()
1031
return L
193
self.assertEquals(list(b.unknowns()), [])
194
assert file('.bzrignore', 'rb').read() == '*.blah\ngarh\n'
195
196
1032
197
1033
198
1034
199
class OldTests(ExternalBase):
1035
"""old tests moved from ./testbzr."""
1036
1037
def test_bzr(self):
200
# old tests moved from ./testbzr
201
def runTest(self):
1038
202
from os import chdir, mkdir
1039
203
from os.path import exists
204
import os
1040
205
1041
206
runbzr = self.runbzr
1042
capture = self.capture
207
backtick = self.backtick
1043
208
progress = self.log
1044
209
1045
210
progress("basic branch creation")
1047
212
chdir('branch1')
1048
213
runbzr('init')
1049
214
1050
self.assertEquals(capture('root').rstrip(),
215
self.assertEquals(backtick('bzr root').rstrip(),
1051
216
os.path.join(self.test_dir, 'branch1'))
1052
217
1053
218
progress("status of new file")
1056
221
f.write('hello world!\n')
1057
222
f.close()
1058
223
1059
self.assertEquals(capture('unknowns'), 'test.txt\n')
1060
1061
out = capture("status")
1062
self.assertEquals(out, 'unknown:\n test.txt\n')
1063
1064
out = capture("status --all")
1065
self.assertEquals(out, "unknown:\n test.txt\n")
1066
1067
out = capture("status test.txt --all")
1068
self.assertEquals(out, "unknown:\n test.txt\n")
224
out = backtick("bzr unknowns")
225
self.assertEquals(out, 'test.txt\n')
226
227
out = backtick("bzr status")
228
assert out == 'unknown:\n test.txt\n'
229
230
out = backtick("bzr status --all")
231
assert out == "unknown:\n test.txt\n"
232
233
out = backtick("bzr status test.txt --all")
234
assert out == "unknown:\n test.txt\n"
1069
235
1070
236
f = file('test2.txt', 'wt')
1071
237
f.write('goodbye cruel world...\n')
1072
238
f.close()
1073
239
1074
out = capture("status test.txt")
1075
self.assertEquals(out, "unknown:\n test.txt\n")
240
out = backtick("bzr status test.txt")
241
assert out == "unknown:\n test.txt\n"
1076
242
1077
out = capture("status")
1078
self.assertEquals(out, ("unknown:\n" " test.txt\n" " test2.txt\n"))
243
out = backtick("bzr status")
244
assert out == ("unknown:\n"
245
" test.txt\n"
246
" test2.txt\n")
1079
247
1080
248
os.unlink('test2.txt')
1081
249
1082
250
progress("command aliases")
1083
out = capture("st --all")
1084
self.assertEquals(out, ("unknown:\n" " test.txt\n"))
251
out = backtick("bzr st --all")
252
assert out == ("unknown:\n"
253
" test.txt\n")
1085
254
1086
out = capture("stat")
1087
self.assertEquals(out, ("unknown:\n" " test.txt\n"))
255
out = backtick("bzr stat")
256
assert out == ("unknown:\n"
257
" test.txt\n")
1088
258
1089
259
progress("command help")
1090
260
runbzr("help st")
1091
261
runbzr("help")
1092
262
runbzr("help commands")
1093
runbzr("help slartibartfast", 3)
263
runbzr("help slartibartfast", 1)
1094
264
1095
out = capture("help ci")
265
out = backtick("bzr help ci")
1096
266
out.index('aliases: ')
1097
267
1098
268
progress("can't rename unversioned file")
1099
runbzr("rename test.txt new-test.txt", 3)
269
runbzr("rename test.txt new-test.txt", 1)
1100
270
1101
271
progress("adding a file")
1102
272
1103
273
runbzr("add test.txt")
1104
self.assertEquals(capture("unknowns"), '')
1105
self.assertEquals(capture("status --all"), ("added:\n" " test.txt\n"))
274
assert backtick("bzr unknowns") == ''
275
assert backtick("bzr status --all") == ("added:\n"
276
" test.txt\n")
1106
277
1107
278
progress("rename newly-added file")
1108
279
runbzr("rename test.txt hello.txt")
1109
self.assert_(os.path.exists("hello.txt"))
1110
self.assert_(not os.path.exists("test.txt"))
280
assert os.path.exists("hello.txt")
281
assert not os.path.exists("test.txt")
1111
282
1112
self.assertEquals(capture("revno"), '0\n')
283
assert backtick("bzr revno") == '0\n'
1113
284
1114
285
progress("add first revision")
1115
286
runbzr(['commit', '-m', 'add first revision'])
1116
287
1117
288
progress("more complex renames")
1118
289
os.mkdir("sub1")
1119
runbzr("rename hello.txt sub1", 3)
1120
runbzr("rename hello.txt sub1/hello.txt", 3)
1121
runbzr("move hello.txt sub1", 3)
290
runbzr("rename hello.txt sub1", 1)
291
runbzr("rename hello.txt sub1/hello.txt", 1)
292
runbzr("move hello.txt sub1", 1)
1122
293
1123
294
runbzr("add sub1")
1124
295
runbzr("rename sub1 sub2")
1125
296
runbzr("move hello.txt sub2")
1126
self.assertEqual(capture("relpath sub2/hello.txt"),
1127
os.path.join("sub2", "hello.txt\n"))
297
assert backtick("bzr relpath sub2/hello.txt") == os.path.join("sub2", "hello.txt\n")
1128
298
1129
self.assert_(exists("sub2"))
1130
self.assert_(exists("sub2/hello.txt"))
1131
self.assert_(not exists("sub1"))
1132
self.assert_(not exists("hello.txt"))
299
assert exists("sub2")
300
assert exists("sub2/hello.txt")
301
assert not exists("sub1")
302
assert not exists("hello.txt")
1133
303
1134
304
runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
1135
305
1136
306
mkdir("sub1")
1137
307
runbzr('add sub1')
1138
308
runbzr('move sub2/hello.txt sub1')
1139
self.assert_(not exists('sub2/hello.txt'))
1140
self.assert_(exists('sub1/hello.txt'))
309
assert not exists('sub2/hello.txt')
310
assert exists('sub1/hello.txt')
1141
311
runbzr('move sub2 sub1')
1142
self.assert_(not exists('sub2'))
1143
self.assert_(exists('sub1/sub2'))
312
assert not exists('sub2')
313
assert exists('sub1/sub2')
1144
314
1145
315
runbzr(['commit', '-m', 'rename nested subdirectories'])
1146
316
1147
317
chdir('sub1/sub2')
1148
self.assertEquals(capture('root')[:-1],
318
self.assertEquals(backtick('bzr root')[:-1],
1149
319
os.path.join(self.test_dir, 'branch1'))
1150
320
runbzr('move ../hello.txt .')
1151
self.assert_(exists('./hello.txt'))
1152
self.assertEquals(capture('relpath hello.txt'),
1153
os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
1154
self.assertEquals(capture('relpath ../../sub1/sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
321
assert exists('./hello.txt')
322
assert backtick('bzr relpath hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
323
assert backtick('bzr relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
1155
324
runbzr(['commit', '-m', 'move to parent directory'])
1156
325
chdir('..')
1157
self.assertEquals(capture('relpath sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
326
assert backtick('bzr relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
1158
327
1159
328
runbzr('move sub2/hello.txt .')
1160
self.assert_(exists('hello.txt'))
329
assert exists('hello.txt')
1161
330
1162
331
f = file('hello.txt', 'wt')
1163
332
f.write('some nice new content\n')
1164
333
f.close()
1165
334
1166
335
f = file('msg.tmp', 'wt')
1167
f.write('this is my new commit\nand it has multiple lines, for fun')
336
f.write('this is my new commit\n')
1168
337
f.close()
1169
338
1170
339
runbzr('commit -F msg.tmp')
1171
340
1172
self.assertEquals(capture('revno'), '5\n')
341
assert backtick('bzr revno') == '5\n'
1173
342
runbzr('export -r 5 export-5.tmp')
1174
343
runbzr('export export.tmp')
1175
344
1176
345
runbzr('log')
1177
346
runbzr('log -v')
1178
347
runbzr('log -v --forward')
1179
runbzr('log -m', retcode=3)
1180
log_out = capture('log -m commit')
1181
self.assert_("this is my new commit\n and" in log_out)
1182
self.assert_("rename nested" not in log_out)
1183
self.assert_('revision-id' not in log_out)
1184
self.assert_('revision-id' in capture('log --show-ids -m commit'))
1185
1186
log_out = capture('log --line')
1187
for line in log_out.splitlines():
1188
self.assert_(len(line) <= 79, len(line))
1189
self.assert_("this is my new commit and" in log_out)
348
runbzr('log -m', retcode=1)
349
log_out = backtick('bzr log -m commit')
350
assert "this is my new commit" in log_out
351
assert "rename nested" not in log_out
352
assert 'revision-id' not in log_out
353
assert 'revision-id' in backtick('bzr log --show-ids -m commit')
1190
354
1191
355
1192
356
progress("file with spaces in name")
1193
357
mkdir('sub directory')
1194
358
file('sub directory/file with spaces ', 'wt').write('see how this works\n')
1195
359
runbzr('add .')
1196
runbzr('diff', retcode=1)
360
runbzr('diff')
1197
361
runbzr('commit -m add-spaces')
1198
362
runbzr('check')
1199
363
1202
366
1203
367
runbzr('info')
1204
368
1205
if has_symlinks():
1206
progress("symlinks")
1207
mkdir('symlinks')
1208
chdir('symlinks')
1209
runbzr('init')
1210
os.symlink("NOWHERE1", "link1")
1211
runbzr('add link1')
1212
self.assertEquals(self.capture('unknowns'), '')
1213
runbzr(['commit', '-m', '1: added symlink link1'])
1214
1215
mkdir('d1')
1216
runbzr('add d1')
1217
self.assertEquals(self.capture('unknowns'), '')
1218
os.symlink("NOWHERE2", "d1/link2")
1219
self.assertEquals(self.capture('unknowns'), 'd1/link2\n')
1220
# is d1/link2 found when adding d1
1221
runbzr('add d1')
1222
self.assertEquals(self.capture('unknowns'), '')
1223
os.symlink("NOWHERE3", "d1/link3")
1224
self.assertEquals(self.capture('unknowns'), 'd1/link3\n')
1225
runbzr(['commit', '-m', '2: added dir, symlink'])
1226
1227
runbzr('rename d1 d2')
1228
runbzr('move d2/link2 .')
1229
runbzr('move link1 d2')
1230
self.assertEquals(os.readlink("./link2"), "NOWHERE2")
1231
self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
1232
runbzr('add d2/link3')
1233
runbzr('diff', retcode=1)
1234
runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
1235
1236
os.unlink("link2")
1237
os.symlink("TARGET 2", "link2")
1238
os.unlink("d2/link1")
1239
os.symlink("TARGET 1", "d2/link1")
1240
runbzr('diff', retcode=1)
1241
self.assertEquals(self.capture("relpath d2/link1"), "d2/link1\n")
1242
runbzr(['commit', '-m', '4: retarget of two links'])
1243
1244
runbzr('remove d2/link1')
1245
self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
1246
runbzr(['commit', '-m', '5: remove d2/link1'])
1247
# try with the rm alias
1248
runbzr('add d2/link1')
1249
runbzr(['commit', '-m', '6: add d2/link1'])
1250
runbzr('rm d2/link1')
1251
self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
1252
runbzr(['commit', '-m', '7: remove d2/link1'])
1253
1254
os.mkdir("d1")
1255
runbzr('add d1')
1256
runbzr('rename d2/link3 d1/link3new')
1257
self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
1258
runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
1259
1260
runbzr(['check'])
1261
1262
runbzr(['export', '-r', '1', 'exp1.tmp'])
1263
chdir("exp1.tmp")
1264
self.assertEquals(listdir_sorted("."), [ "link1" ])
1265
self.assertEquals(os.readlink("link1"), "NOWHERE1")
1266
chdir("..")
1267
1268
runbzr(['export', '-r', '2', 'exp2.tmp'])
1269
chdir("exp2.tmp")
1270
self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
1271
chdir("..")
1272
1273
runbzr(['export', '-r', '3', 'exp3.tmp'])
1274
chdir("exp3.tmp")
1275
self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
1276
self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
1277
self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
1278
self.assertEquals(os.readlink("link2") , "NOWHERE2")
1279
chdir("..")
1280
1281
runbzr(['export', '-r', '4', 'exp4.tmp'])
1282
chdir("exp4.tmp")
1283
self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
1284
self.assertEquals(os.readlink("d2/link1"), "TARGET 1")
1285
self.assertEquals(os.readlink("link2") , "TARGET 2")
1286
self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
1287
chdir("..")
1288
1289
runbzr(['export', '-r', '5', 'exp5.tmp'])
1290
chdir("exp5.tmp")
1291
self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
1292
self.assert_(os.path.islink("link2"))
1293
self.assert_(listdir_sorted("d2")== [ "link3" ])
1294
chdir("..")
1295
1296
runbzr(['export', '-r', '8', 'exp6.tmp'])
1297
chdir("exp6.tmp")
1298
self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
1299
self.assertEquals(listdir_sorted("d1"), [ "link3new" ])
1300
self.assertEquals(listdir_sorted("d2"), [])
1301
self.assertEquals(os.readlink("d1/link3new"), "NOWHERE3")
1302
chdir("..")
1303
else:
1304
progress("skipping symlink tests")
1305
1306
1307
class HttpTests(TestCaseWithWebserver):
1308
"""Test bzr ui commands against remote branches."""
1309
1310
def test_branch(self):
1311
os.mkdir('from')
1312
branch = Branch.initialize('from')
1313
branch.working_tree().commit('empty commit for nonsense', allow_pointless=True)
1314
url = self.get_remote_url('from')
1315
self.run_bzr('branch', url, 'to')
1316
branch = Branch.open('to')
1317
self.assertEqual(1, len(branch.revision_history()))
1318
1319
def test_log(self):
1320
self.build_tree(['branch/', 'branch/file'])
1321
branch = Branch.initialize('branch')
1322
branch.working_tree().add(['file'])
1323
branch.working_tree().commit('add file', rev_id='A')
1324
url = self.get_remote_url('branch/file')
1325
output = self.capture('log %s' % url)
1326
self.assertEqual(8, len(output.split('\n')))
369
370
371
372
373
374
class RevertCommand(ExternalBase):
375
def runTest(self):
376
import os
377
self.runbzr('init')
378
379
file('hello', 'wt').write('foo')
380
self.runbzr('add hello')
381
self.runbzr('commit -m setup hello')
382
383
file('goodbye', 'wt').write('baz')
384
self.runbzr('add goodbye')
385
self.runbzr('commit -m setup goodbye')
1327
386
1328
def test_check(self):
1329
self.build_tree(['branch/', 'branch/file'])
1330
branch = Branch.initialize('branch')
1331
branch.working_tree().add(['file'])
1332
branch.working_tree().commit('add file', rev_id='A')
1333
url = self.get_remote_url('branch/')
1334
self.run_bzr('check', url)
387
file('hello', 'wt').write('bar')
388
file('goodbye', 'wt').write('qux')
389
self.runbzr('revert hello')
390
self.check_file_contents('hello', 'foo')
391
self.check_file_contents('goodbye', 'qux')
392
self.runbzr('revert')
393
self.check_file_contents('goodbye', 'baz')
394
os.mkdir('revertdir')
395
self.runbzr('add revertdir')
396
self.runbzr('commit -m f')
397
os.rmdir('revertdir')
398
self.runbzr('revert')
399
400
Loggerhead is a web-based interface for Breezy
Version: 2.0.1