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