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