← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/selftest/blackbox.py

  • Committer: Martin Pool
  • Date: 2005-11-11 23:22:03 UTC
  • mto: (1185.33.43 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 1512.
  • Revision ID: mbp@sourcefrog.net-20051111232203-e1c6e4437f6fe9a7
Don't enable default logging twice

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/selftest/blackbox.py
62
62
    def test_init_branch(self):
63
63
        self.runbzr(['init'])
64
64
 
 
65
        # Can it handle subdirectories as well?
 
66
        self.runbzr('init subdir1')
 
67
        self.assert_(os.path.exists('subdir1'))
 
68
        self.assert_(os.path.exists('subdir1/.bzr'))
 
69
 
 
70
        self.runbzr('init subdir2/nothere', retcode=2)
 
71
        
 
72
        os.mkdir('subdir2')
 
73
        self.runbzr('init subdir2')
 
74
        self.runbzr('init subdir2', retcode=1)
 
75
 
 
76
        self.runbzr('init subdir2/subsubdir1')
 
77
        self.assert_(os.path.exists('subdir2/subsubdir1/.bzr'))
 
78
 
65
79
    def test_whoami(self):
66
80
        # this should always identify something, if only "john@localhost"
67
81
        self.runbzr("whoami")
103
117
        self.build_tree(['hello.txt'])
104
118
        self.runbzr("commit -m empty", retcode=1)
105
119
        self.runbzr("add hello.txt")
106
 
        self.runbzr("commit -m added")
 
120
        self.runbzr("commit -m added")       
107
121
 
108
122
    def test_empty_commit_message(self):
109
123
        self.runbzr("init")
111
125
        self.runbzr(['add', 'foo.c'])
112
126
        self.runbzr(["commit", "-m", ""] , retcode=1) 
113
127
 
 
128
    def test_other_branch_commit(self):
 
129
        # this branch is to ensure consistent behaviour, whether we're run
 
130
        # inside a branch, or not.
 
131
        os.mkdir('empty_branch')
 
132
        os.chdir('empty_branch')
 
133
        self.runbzr('init')
 
134
        os.mkdir('branch')
 
135
        os.chdir('branch')
 
136
        self.runbzr('init')
 
137
        file('foo.c', 'wt').write('int main() {}')
 
138
        file('bar.c', 'wt').write('int main() {}')
 
139
        os.chdir('..')
 
140
        self.runbzr(['add', 'branch/foo.c'])
 
141
        self.runbzr(['add', 'branch'])
 
142
        # can't commit files in different trees; sane error
 
143
        self.runbzr('commit -m newstuff branch/foo.c .', retcode=1)
 
144
        self.runbzr('commit -m newstuff branch/foo.c')
 
145
        self.runbzr('commit -m newstuff branch')
 
146
        self.runbzr('commit -m newstuff branch', retcode=1)
 
147
 
 
148
 
114
149
    def test_ignore_patterns(self):
115
150
        from bzrlib.branch import Branch
116
151
        
119
154
 
120
155
        file('foo.tmp', 'wt').write('tmp files are ignored')
121
156
        self.assertEquals(list(b.unknowns()), [])
122
 
        assert self.capture('unknowns') == ''
 
157
        self.assertEquals(self.capture('unknowns'), '')
123
158
 
124
159
        file('foo.c', 'wt').write('int main() {}')
125
160
        self.assertEquals(list(b.unknowns()), ['foo.c'])
126
 
        assert self.capture('unknowns') == 'foo.c\n'
 
161
        self.assertEquals(self.capture('unknowns'), 'foo.c\n')
127
162
 
128
163
        self.runbzr(['add', 'foo.c'])
129
 
        assert self.capture('unknowns') == ''
 
164
        self.assertEquals(self.capture('unknowns'), '')
130
165
 
131
166
        # 'ignore' works when creating the .bzignore file
132
167
        file('foo.blah', 'wt').write('blah')
133
168
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
134
169
        self.runbzr('ignore *.blah')
135
170
        self.assertEquals(list(b.unknowns()), [])
136
 
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
 
171
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')
137
172
 
138
173
        # 'ignore' works when then .bzrignore file already exists
139
174
        file('garh', 'wt').write('garh')
140
175
        self.assertEquals(list(b.unknowns()), ['garh'])
141
 
        assert self.capture('unknowns') == 'garh\n'
 
176
        self.assertEquals(self.capture('unknowns'), 'garh\n')
142
177
        self.runbzr('ignore garh')
143
178
        self.assertEquals(list(b.unknowns()), [])
144
 
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
 
179
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')
145
180
 
146
181
    def test_revert(self):
147
182
        self.runbzr('init')
190
225
        self.runbzr('revert')
191
226
        os.chdir('..')
192
227
 
 
228
    def test_status(self):
 
229
        self.runbzr("init")
 
230
        self.build_tree(['hello.txt'])
 
231
        result = self.runbzr("status")
 
232
        self.assert_("unknown:\n  hello.txt\n" in result, result)
 
233
        self.runbzr("add hello.txt")
 
234
        result = self.runbzr("status")
 
235
        self.assert_("added:\n  hello.txt\n" in result, result)
 
236
        self.runbzr("commit -m added")
 
237
        result = self.runbzr("status -r 0..1")
 
238
        self.assert_("added:\n  hello.txt\n" in result, result)
 
239
        self.build_tree(['world.txt'])
 
240
        result = self.runbzr("status -r 0")
 
241
        self.assert_("added:\n  hello.txt\n" \
 
242
                     "unknown:\n  world.txt\n" in result, result)
193
243
 
194
244
    def test_mv_modes(self):
195
245
        """Test two modes of operation for mv"""
234
284
        self.runbzr('export ../latest')
235
285
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
236
286
        self.runbzr('export ../first -r 1')
237
 
        assert not os.path.exists('../first/goodbye')
 
287
        self.assert_(not os.path.exists('../first/goodbye'))
238
288
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
239
289
        self.runbzr('export ../first.gz -r 1')
240
290
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
241
291
        self.runbzr('export ../first.bz2 -r 1')
242
292
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
243
293
        self.runbzr('export ../first.tar -r 1')
244
 
        assert os.path.isfile('../first.tar')
 
294
        self.assert_(os.path.isfile('../first.tar'))
245
295
        from tarfile import TarFile
246
296
        tf = TarFile('../first.tar')
247
 
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
297
        self.assert_('first/hello' in tf.getnames(), tf.getnames())
248
298
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
249
299
        self.runbzr('export ../first.tar.gz -r 1')
250
 
        assert os.path.isfile('../first.tar.gz')
 
300
        self.assert_(os.path.isfile('../first.tar.gz'))
251
301
        self.runbzr('export ../first.tbz2 -r 1')
252
 
        assert os.path.isfile('../first.tbz2')
 
302
        self.assert_(os.path.isfile('../first.tbz2'))
253
303
        self.runbzr('export ../first.tar.bz2 -r 1')
254
 
        assert os.path.isfile('../first.tar.bz2')
 
304
        self.assert_(os.path.isfile('../first.tar.bz2'))
255
305
        self.runbzr('export ../first.tar.tbz2 -r 1')
256
 
        assert os.path.isfile('../first.tar.tbz2')
 
306
        self.assert_(os.path.isfile('../first.tar.tbz2'))
257
307
        from bz2 import BZ2File
258
308
        tf = TarFile('../first.tar.tbz2', 
259
309
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
260
 
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
310
        self.assert_('first.tar/hello' in tf.getnames(), tf.getnames())
261
311
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
262
312
        self.runbzr('export ../first2.tar -r 1 --root pizza')
263
313
        tf = TarFile('../first2.tar')
264
 
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
314
        self.assert_('pizza/hello' in tf.getnames(), tf.getnames())
265
315
 
266
316
    def test_diff(self):
267
317
        self.example_branch()
268
318
        file('hello', 'wt').write('hello world!')
269
319
        self.runbzr('commit -m fixing hello')
270
 
        output = self.runbzr('diff -r 2..3', backtick=1)
 
320
        output = self.runbzr('diff -r 2..3', backtick=1, retcode=1)
271
321
        self.assert_('\n+hello world!' in output)
272
 
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
322
        output = self.runbzr('diff -r last:3..last:1', backtick=1, retcode=1)
273
323
        self.assert_('\n+baz' in output)
274
324
 
275
325
    def test_diff_branches(self):
282
332
        branch2 = Branch.open('branch2')
283
333
        branch2.commit('update file')
284
334
        # should open branch1 and diff against branch2, 
285
 
        output = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 'branch1'])
 
335
        output = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 
 
336
                                        'branch1'],
 
337
                                       retcode=1)
286
338
        self.assertEquals(("=== modified file 'file'\n"
287
339
                           "--- file\n"
288
340
                           "+++ file\n"
298
350
        self.example_branch()
299
351
        os.chdir('..')
300
352
        self.runbzr('branch a b')
 
353
        self.assertFileEqual('b\n', 'b/.bzr/branch-name')
301
354
        self.runbzr('branch a c -r 1')
302
355
        os.chdir('b')
303
356
        self.runbzr('commit -m foo --unchanged')
326
379
        # We can't merge when there are in-tree changes
327
380
        self.runbzr('merge ../b', retcode=1)
328
381
        self.runbzr(['commit', '-m', "Like an epidemic of u's"])
329
 
        self.runbzr('merge ../b')
 
382
        self.runbzr('merge ../b -r last:1..last:1 --merge-type blooof',
 
383
                    retcode=1)
 
384
        self.runbzr('merge ../b -r last:1..last:1 --merge-type merge3')
 
385
        self.runbzr('revert --no-backup')
 
386
        self.runbzr('merge ../b -r last:1..last:1 --merge-type weave')
 
387
        self.runbzr('revert --no-backup')
 
388
        self.runbzr('merge ../b -r last:1..last:1 --reprocess')
 
389
        self.runbzr('revert --no-backup')
 
390
        self.runbzr('merge ../b -r last:1')
330
391
        self.check_file_contents('goodbye', 'quux')
331
392
        # Merging a branch pulls its revision into the tree
332
393
        a = Branch.open('.')
333
394
        b = Branch.open('../b')
334
395
        a.get_revision_xml(b.last_revision())
335
396
        self.log('pending merges: %s', a.pending_merges())
336
 
        #        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
337
 
        #        % (a.pending_merges(), b.last_patch())
 
397
        self.assertEquals(a.pending_merges(), [b.last_revision()])
 
398
        self.runbzr('commit -m merged')
 
399
        self.runbzr('merge ../b -r last:1')
 
400
        self.assertEqual(Branch.open('.').pending_merges(), [])
 
401
 
338
402
 
339
403
    def test_merge_with_missing_file(self):
340
404
        """Merge handles missing file conflicts"""
362
426
        print >> file('b.txt', 'ab'), "something"
363
427
        print >> file('sub/c.txt', 'ab'), "something"
364
428
        self.runbzr(('commit', '-m', 'Modified a.txt'))
365
 
        self.runbzr('merge ../a/')
366
 
        assert os.path.exists('sub/a.txt.THIS')
367
 
        assert os.path.exists('sub/a.txt.BASE')
 
429
        self.runbzr('merge ../a/', retcode=1)
 
430
        self.assert_(os.path.exists('sub/a.txt.THIS'))
 
431
        self.assert_(os.path.exists('sub/a.txt.BASE'))
368
432
        os.chdir('../a')
369
 
        self.runbzr('merge ../b/')
370
 
        assert os.path.exists('sub/a.txt.OTHER')
371
 
        assert os.path.exists('sub/a.txt.BASE')
 
433
        self.runbzr('merge ../b/', retcode=1)
 
434
        self.assert_(os.path.exists('sub/a.txt.OTHER'))
 
435
        self.assert_(os.path.exists('sub/a.txt.BASE'))
372
436
 
373
437
    def test_pull(self):
374
438
        """Pull changes from one branch to another."""
394
458
        os.chdir('../a')
395
459
        a = Branch.open('.')
396
460
        b = Branch.open('../b')
397
 
        assert a.revision_history() == b.revision_history()[:-1]
 
461
        self.assertEquals(a.revision_history(), b.revision_history()[:-1])
398
462
        self.runbzr('pull ../b')
399
 
        assert a.revision_history() == b.revision_history()
 
463
        self.assertEquals(a.revision_history(), b.revision_history())
400
464
        self.runbzr('commit -m blah2 --unchanged')
401
465
        os.chdir('../b')
402
466
        self.runbzr('commit -m blah3 --unchanged')
403
 
        # no clobber
 
467
        # no overwrite
404
468
        self.runbzr('pull ../a', retcode=1)
405
469
        os.chdir('..')
406
 
        self.runbzr('branch b clobberme')
407
 
        os.chdir('clobberme')
408
 
        self.runbzr('pull --clobber ../a')
409
 
        clobbered = Branch.open('.')
410
 
        self.assertEqual(clobbered.revision_history(),
 
470
        self.runbzr('branch b overwriteme')
 
471
        os.chdir('overwriteme')
 
472
        self.runbzr('pull --overwrite ../a')
 
473
        overwritten = Branch.open('.')
 
474
        self.assertEqual(overwritten.revision_history(),
411
475
                         a.revision_history())
412
476
        os.chdir('../a')
413
477
        self.runbzr('merge ../b')
414
478
        self.runbzr('commit -m blah4 --unchanged')
415
479
        os.chdir('../b/subdir')
416
480
        self.runbzr('pull ../../a')
417
 
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
481
        self.assertEquals(a.revision_history()[-1], b.revision_history()[-1])
418
482
        self.runbzr('commit -m blah5 --unchanged')
419
483
        self.runbzr('commit -m blah6 --unchanged')
420
484
        os.chdir('..')
426
490
        self.runbzr('pull ../b')
427
491
        self.runbzr('pull ../b')
428
492
 
 
493
    def test_ls(self):
 
494
        """Test the abilities of 'bzr ls'"""
 
495
        bzr = self.runbzr
 
496
        def bzrout(*args, **kwargs):
 
497
            kwargs['backtick'] = True
 
498
            return self.runbzr(*args, **kwargs)
 
499
 
 
500
        def ls_equals(value, *args):
 
501
            out = self.runbzr(['ls'] + list(args), backtick=True)
 
502
            self.assertEquals(out, value)
 
503
 
 
504
        bzr('init')
 
505
        open('a', 'wb').write('hello\n')
 
506
 
 
507
        # Can't supply both
 
508
        bzr('ls --verbose --null', retcode=1)
 
509
 
 
510
        ls_equals('a\n')
 
511
        ls_equals('?        a\n', '--verbose')
 
512
        ls_equals('a\n', '--unknown')
 
513
        ls_equals('', '--ignored')
 
514
        ls_equals('', '--versioned')
 
515
        ls_equals('a\n', '--unknown', '--ignored', '--versioned')
 
516
        ls_equals('', '--ignored', '--versioned')
 
517
        ls_equals('a\0', '--null')
 
518
 
 
519
        bzr('add a')
 
520
        ls_equals('V        a\n', '--verbose')
 
521
        bzr('commit -m add')
 
522
        
 
523
        os.mkdir('subdir')
 
524
        ls_equals('V        a\n'
 
525
                  '?        subdir/\n'
 
526
                  , '--verbose')
 
527
        open('subdir/b', 'wb').write('b\n')
 
528
        bzr('add')
 
529
        ls_equals('V        a\n'
 
530
                  'V        subdir/\n'
 
531
                  'V        subdir/b\n'
 
532
                  , '--verbose')
 
533
        bzr('commit -m subdir')
 
534
 
 
535
        ls_equals('a\n'
 
536
                  'subdir\n'
 
537
                  , '--non-recursive')
 
538
 
 
539
        ls_equals('V        a\n'
 
540
                  'V        subdir/\n'
 
541
                  , '--verbose', '--non-recursive')
 
542
 
 
543
        # Check what happens in a sub-directory
 
544
        os.chdir('subdir')
 
545
        ls_equals('b\n')
 
546
        ls_equals('b\0'
 
547
                  , '--null')
 
548
        ls_equals('a\n'
 
549
                  'subdir\n'
 
550
                  'subdir/b\n'
 
551
                  , '--from-root')
 
552
        ls_equals('a\0'
 
553
                  'subdir\0'
 
554
                  'subdir/b\0'
 
555
                  , '--from-root', '--null')
 
556
        ls_equals('a\n'
 
557
                  'subdir\n'
 
558
                  , '--from-root', '--non-recursive')
 
559
 
 
560
        os.chdir('..')
 
561
 
 
562
        # Check what happens when we supply a specific revision
 
563
        ls_equals('a\n', '--revision', '1')
 
564
        ls_equals('V        a\n'
 
565
                  , '--verbose', '--revision', '1')
 
566
 
 
567
        os.chdir('subdir')
 
568
        ls_equals('', '--revision', '1')
 
569
 
 
570
        # Now try to do ignored files.
 
571
        os.chdir('..')
 
572
        open('blah.py', 'wb').write('unknown\n')
 
573
        open('blah.pyo', 'wb').write('ignored\n')
 
574
        ls_equals('a\n'
 
575
                  'blah.py\n'
 
576
                  'blah.pyo\n'
 
577
                  'subdir\n'
 
578
                  'subdir/b\n')
 
579
        ls_equals('V        a\n'
 
580
                  '?        blah.py\n'
 
581
                  'I        blah.pyo\n'
 
582
                  'V        subdir/\n'
 
583
                  'V        subdir/b\n'
 
584
                  , '--verbose')
 
585
        ls_equals('blah.pyo\n'
 
586
                  , '--ignored')
 
587
        ls_equals('blah.py\n'
 
588
                  , '--unknown')
 
589
        ls_equals('a\n'
 
590
                  'subdir\n'
 
591
                  'subdir/b\n'
 
592
                  , '--versioned')
 
593
 
 
594
 
429
595
    def test_locations(self):
430
596
        """Using and remembering different locations"""
431
597
        os.mkdir('a')
503
669
        file('question', 'wb').write("What do you get when you multiply six"
504
670
                                   "times nine?")
505
671
        self.runbzr('commit -m this')
506
 
        self.runbzr('merge ../other')
 
672
        self.runbzr('merge ../other --show-base', retcode=1)
 
673
        conflict_text = file('hello').read()
 
674
        self.assert_('<<<<<<<' in conflict_text)
 
675
        self.assert_('>>>>>>>' in conflict_text)
 
676
        self.assert_('=======' in conflict_text)
 
677
        self.assert_('|||||||' in conflict_text)
 
678
        self.assert_('hi world' in conflict_text)
 
679
        self.runbzr('revert')
 
680
        self.runbzr('resolve --all')
 
681
        self.runbzr('merge ../other', retcode=1)
 
682
        conflict_text = file('hello').read()
 
683
        self.assert_('|||||||' not in conflict_text)
 
684
        self.assert_('hi world' not in conflict_text)
507
685
        result = self.runbzr('conflicts', backtick=1)
508
686
        self.assertEquals(result, "hello\nquestion\n")
509
687
        result = self.runbzr('status', backtick=1)
510
 
        assert "conflicts:\n  hello\n  question\n" in result, result
 
688
        self.assert_("conflicts:\n  hello\n  question\n" in result, result)
511
689
        self.runbzr('resolve hello')
512
690
        result = self.runbzr('conflicts', backtick=1)
513
691
        self.assertEquals(result, "question\n")
532
710
                             branch.revision_store.get('A', 'sig').read())
533
711
        finally:
534
712
            bzrlib.gpg.GPGStrategy = oldstrategy
 
713
            
 
714
    def test_resign_range(self):
 
715
        import bzrlib.gpg
 
716
        oldstrategy = bzrlib.gpg.GPGStrategy
 
717
        branch = Branch.initialize('.')
 
718
        branch.commit("base", allow_pointless=True, rev_id='A')
 
719
        branch.commit("base", allow_pointless=True, rev_id='B')
 
720
        branch.commit("base", allow_pointless=True, rev_id='C')
 
721
        try:
 
722
            # monkey patch gpg signing mechanism
 
723
            from bzrlib.testament import Testament
 
724
            bzrlib.gpg.GPGStrategy = bzrlib.gpg.LoopbackGPGStrategy
 
725
            self.runbzr('re-sign -r 1..')
 
726
            self.assertEqual(Testament.from_revision(branch,'A').as_short_text(),
 
727
                             branch.revision_store.get('A', 'sig').read())
 
728
            self.assertEqual(Testament.from_revision(branch,'B').as_short_text(),
 
729
                             branch.revision_store.get('B', 'sig').read())
 
730
            self.assertEqual(Testament.from_revision(branch,'C').as_short_text(),
 
731
                             branch.revision_store.get('C', 'sig').read())
 
732
        finally:
 
733
            bzrlib.gpg.GPGStrategy = oldstrategy
 
734
 
 
735
    def test_push(self):
 
736
        # create a source branch
 
737
        os.mkdir('my-branch')
 
738
        os.chdir('my-branch')
 
739
        self.example_branch()
 
740
 
 
741
        # with no push target, fail
 
742
        self.runbzr('push', retcode=1)
 
743
        # with an explicit target work
 
744
        self.runbzr('push ../output-branch')
 
745
        # with an implicit target work
 
746
        self.runbzr('push')
 
747
        # nothing missing
 
748
        self.runbzr('missing ../output-branch')
 
749
        # advance this branch
 
750
        self.runbzr('commit --unchanged -m unchanged')
 
751
 
 
752
        os.chdir('../output-branch')
 
753
        # should be a diff as we have not pushed the tree
 
754
        self.runbzr('diff', retcode=1)
 
755
        self.runbzr('revert')
 
756
        # but not now.
 
757
        self.runbzr('diff')
 
758
        # diverge the branches
 
759
        self.runbzr('commit --unchanged -m unchanged')
 
760
        os.chdir('../my-branch')
 
761
        # cannot push now
 
762
        self.runbzr('push', retcode=1)
 
763
        # and there are difference
 
764
        self.runbzr('missing ../output-branch', retcode=1)
 
765
        # but we can force a push
 
766
        self.runbzr('push --overwrite')
 
767
        # nothing missing
 
768
        self.runbzr('missing ../output-branch')
 
769
        
 
770
        # pushing to a new dir with no parent should fail
 
771
        self.runbzr('push ../missing/new-branch', retcode=1)
 
772
        # unless we provide --create-prefix
 
773
        self.runbzr('push --create-prefix ../missing/new-branch')
 
774
        # nothing missing
 
775
        self.runbzr('missing ../missing/new-branch')
 
776
 
535
777
 
536
778
def listdir_sorted(dir):
537
779
    L = os.listdir(dir)
567
809
        self.assertEquals(capture('unknowns'), 'test.txt\n')
568
810
 
569
811
        out = capture("status")
570
 
        assert out == 'unknown:\n  test.txt\n'
 
812
        self.assertEquals(out, 'unknown:\n  test.txt\n')
571
813
 
572
814
        out = capture("status --all")
573
 
        assert out == "unknown:\n  test.txt\n"
 
815
        self.assertEquals(out, "unknown:\n  test.txt\n")
574
816
 
575
817
        out = capture("status test.txt --all")
576
 
        assert out == "unknown:\n  test.txt\n"
 
818
        self.assertEquals(out, "unknown:\n  test.txt\n")
577
819
 
578
820
        f = file('test2.txt', 'wt')
579
821
        f.write('goodbye cruel world...\n')
580
822
        f.close()
581
823
 
582
824
        out = capture("status test.txt")
583
 
        assert out == "unknown:\n  test.txt\n"
 
825
        self.assertEquals(out, "unknown:\n  test.txt\n")
584
826
 
585
827
        out = capture("status")
586
 
        assert out == ("unknown:\n"
587
 
                       "  test.txt\n"
588
 
                       "  test2.txt\n")
 
828
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
589
829
 
590
830
        os.unlink('test2.txt')
591
831
 
592
832
        progress("command aliases")
593
833
        out = capture("st --all")
594
 
        assert out == ("unknown:\n"
595
 
                       "  test.txt\n")
 
834
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
596
835
 
597
836
        out = capture("stat")
598
 
        assert out == ("unknown:\n"
599
 
                       "  test.txt\n")
 
837
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
600
838
 
601
839
        progress("command help")
602
840
        runbzr("help st")
613
851
        progress("adding a file")
614
852
 
615
853
        runbzr("add test.txt")
616
 
        assert capture("unknowns") == ''
617
 
        assert capture("status --all") == ("added:\n"
618
 
                                                "  test.txt\n")
 
854
        self.assertEquals(capture("unknowns"), '')
 
855
        self.assertEquals(capture("status --all"), ("added:\n" "  test.txt\n"))
619
856
 
620
857
        progress("rename newly-added file")
621
858
        runbzr("rename test.txt hello.txt")
622
 
        assert os.path.exists("hello.txt")
623
 
        assert not os.path.exists("test.txt")
 
859
        self.assert_(os.path.exists("hello.txt"))
 
860
        self.assert_(not os.path.exists("test.txt"))
624
861
 
625
 
        assert capture("revno") == '0\n'
 
862
        self.assertEquals(capture("revno"), '0\n')
626
863
 
627
864
        progress("add first revision")
628
865
        runbzr(['commit', '-m', 'add first revision'])
639
876
        self.assertEqual(capture("relpath sub2/hello.txt"),
640
877
                         os.path.join("sub2", "hello.txt\n"))
641
878
 
642
 
        assert exists("sub2")
643
 
        assert exists("sub2/hello.txt")
644
 
        assert not exists("sub1")
645
 
        assert not exists("hello.txt")
 
879
        self.assert_(exists("sub2"))
 
880
        self.assert_(exists("sub2/hello.txt"))
 
881
        self.assert_(not exists("sub1"))
 
882
        self.assert_(not exists("hello.txt"))
646
883
 
647
884
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
648
885
 
649
886
        mkdir("sub1")
650
887
        runbzr('add sub1')
651
888
        runbzr('move sub2/hello.txt sub1')
652
 
        assert not exists('sub2/hello.txt')
653
 
        assert exists('sub1/hello.txt')
 
889
        self.assert_(not exists('sub2/hello.txt'))
 
890
        self.assert_(exists('sub1/hello.txt'))
654
891
        runbzr('move sub2 sub1')
655
 
        assert not exists('sub2')
656
 
        assert exists('sub1/sub2')
 
892
        self.assert_(not exists('sub2'))
 
893
        self.assert_(exists('sub1/sub2'))
657
894
 
658
895
        runbzr(['commit', '-m', 'rename nested subdirectories'])
659
896
 
661
898
        self.assertEquals(capture('root')[:-1],
662
899
                          os.path.join(self.test_dir, 'branch1'))
663
900
        runbzr('move ../hello.txt .')
664
 
        assert exists('./hello.txt')
 
901
        self.assert_(exists('./hello.txt'))
665
902
        self.assertEquals(capture('relpath hello.txt'),
666
903
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
667
 
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
904
        self.assertEquals(capture('relpath ../../sub1/sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
668
905
        runbzr(['commit', '-m', 'move to parent directory'])
669
906
        chdir('..')
670
 
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
907
        self.assertEquals(capture('relpath sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
671
908
 
672
909
        runbzr('move sub2/hello.txt .')
673
 
        assert exists('hello.txt')
 
910
        self.assert_(exists('hello.txt'))
674
911
 
675
912
        f = file('hello.txt', 'wt')
676
913
        f.write('some nice new content\n')
682
919
 
683
920
        runbzr('commit -F msg.tmp')
684
921
 
685
 
        assert capture('revno') == '5\n'
 
922
        self.assertEquals(capture('revno'), '5\n')
686
923
        runbzr('export -r 5 export-5.tmp')
687
924
        runbzr('export export.tmp')
688
925
 
691
928
        runbzr('log -v --forward')
692
929
        runbzr('log -m', retcode=1)
693
930
        log_out = capture('log -m commit')
694
 
        assert "this is my new commit\n  and" in log_out
695
 
        assert "rename nested" not in log_out
696
 
        assert 'revision-id' not in log_out
697
 
        assert 'revision-id' in capture('log --show-ids -m commit')
 
931
        self.assert_("this is my new commit\n  and" in log_out)
 
932
        self.assert_("rename nested" not in log_out)
 
933
        self.assert_('revision-id' not in log_out)
 
934
        self.assert_('revision-id' in capture('log --show-ids -m commit'))
698
935
 
699
936
        log_out = capture('log --line')
700
937
        for line in log_out.splitlines():
701
 
            assert len(line) <= 79, len(line)
702
 
        assert "this is my new commit and" in log_out
 
938
            self.assert_(len(line) <= 79, len(line))
 
939
        self.assert_("this is my new commit and" in log_out)
703
940
 
704
941
 
705
942
        progress("file with spaces in name")
706
943
        mkdir('sub directory')
707
944
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
708
945
        runbzr('add .')
709
 
        runbzr('diff')
 
946
        runbzr('diff', retcode=1)
710
947
        runbzr('commit -m add-spaces')
711
948
        runbzr('check')
712
949
 
722
959
            runbzr('init')
723
960
            os.symlink("NOWHERE1", "link1")
724
961
            runbzr('add link1')
725
 
            assert self.capture('unknowns') == ''
 
962
            self.assertEquals(self.capture('unknowns'), '')
726
963
            runbzr(['commit', '-m', '1: added symlink link1'])
727
964
    
728
965
            mkdir('d1')
729
966
            runbzr('add d1')
730
 
            assert self.capture('unknowns') == ''
 
967
            self.assertEquals(self.capture('unknowns'), '')
731
968
            os.symlink("NOWHERE2", "d1/link2")
732
 
            assert self.capture('unknowns') == 'd1/link2\n'
 
969
            self.assertEquals(self.capture('unknowns'), 'd1/link2\n')
733
970
            # is d1/link2 found when adding d1
734
971
            runbzr('add d1')
735
 
            assert self.capture('unknowns') == ''
 
972
            self.assertEquals(self.capture('unknowns'), '')
736
973
            os.symlink("NOWHERE3", "d1/link3")
737
 
            assert self.capture('unknowns') == 'd1/link3\n'
 
974
            self.assertEquals(self.capture('unknowns'), 'd1/link3\n')
738
975
            runbzr(['commit', '-m', '2: added dir, symlink'])
739
976
    
740
977
            runbzr('rename d1 d2')
741
978
            runbzr('move d2/link2 .')
742
979
            runbzr('move link1 d2')
743
 
            assert os.readlink("./link2") == "NOWHERE2"
744
 
            assert os.readlink("d2/link1") == "NOWHERE1"
 
980
            self.assertEquals(os.readlink("./link2"), "NOWHERE2")
 
981
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
745
982
            runbzr('add d2/link3')
746
 
            runbzr('diff')
 
983
            runbzr('diff', retcode=1)
747
984
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
748
985
    
749
986
            os.unlink("link2")
750
987
            os.symlink("TARGET 2", "link2")
751
988
            os.unlink("d2/link1")
752
989
            os.symlink("TARGET 1", "d2/link1")
753
 
            runbzr('diff')
754
 
            assert self.capture("relpath d2/link1") == "d2/link1\n"
 
990
            runbzr('diff', retcode=1)
 
991
            self.assertEquals(self.capture("relpath d2/link1"), "d2/link1\n")
755
992
            runbzr(['commit', '-m', '4: retarget of two links'])
756
993
    
757
994
            runbzr('remove d2/link1')
758
 
            assert self.capture('unknowns') == 'd2/link1\n'
 
995
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
759
996
            runbzr(['commit', '-m', '5: remove d2/link1'])
760
997
            # try with the rm alias
761
998
            runbzr('add d2/link1')
762
999
            runbzr(['commit', '-m', '6: add d2/link1'])
763
1000
            runbzr('rm d2/link1')
764
 
            assert self.capture('unknowns') == 'd2/link1\n'
 
1001
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
765
1002
            runbzr(['commit', '-m', '7: remove d2/link1'])
766
1003
    
767
1004
            os.mkdir("d1")
768
1005
            runbzr('add d1')
769
1006
            runbzr('rename d2/link3 d1/link3new')
770
 
            assert self.capture('unknowns') == 'd2/link1\n'
 
1007
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
771
1008
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
772
1009
            
773
1010
            runbzr(['check'])
774
1011
            
775
1012
            runbzr(['export', '-r', '1', 'exp1.tmp'])
776
1013
            chdir("exp1.tmp")
777
 
            assert listdir_sorted(".") == [ "link1" ]
778
 
            assert os.readlink("link1") == "NOWHERE1"
 
1014
            self.assertEquals(listdir_sorted("."), [ "link1" ])
 
1015
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
779
1016
            chdir("..")
780
1017
            
781
1018
            runbzr(['export', '-r', '2', 'exp2.tmp'])
782
1019
            chdir("exp2.tmp")
783
 
            assert listdir_sorted(".") == [ "d1", "link1" ]
 
1020
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
784
1021
            chdir("..")
785
1022
            
786
1023
            runbzr(['export', '-r', '3', 'exp3.tmp'])
787
1024
            chdir("exp3.tmp")
788
 
            assert listdir_sorted(".") == [ "d2", "link2" ]
789
 
            assert listdir_sorted("d2") == [ "link1", "link3" ]
790
 
            assert os.readlink("d2/link1") == "NOWHERE1"
791
 
            assert os.readlink("link2")    == "NOWHERE2"
 
1025
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1026
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
 
1027
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
 
1028
            self.assertEquals(os.readlink("link2")   , "NOWHERE2")
792
1029
            chdir("..")
793
1030
            
794
1031
            runbzr(['export', '-r', '4', 'exp4.tmp'])
795
1032
            chdir("exp4.tmp")
796
 
            assert listdir_sorted(".") == [ "d2", "link2" ]
797
 
            assert os.readlink("d2/link1") == "TARGET 1"
798
 
            assert os.readlink("link2")    == "TARGET 2"
799
 
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
1033
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1034
            self.assertEquals(os.readlink("d2/link1"), "TARGET 1")
 
1035
            self.assertEquals(os.readlink("link2")   , "TARGET 2")
 
1036
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
800
1037
            chdir("..")
801
1038
            
802
1039
            runbzr(['export', '-r', '5', 'exp5.tmp'])
803
1040
            chdir("exp5.tmp")
804
 
            assert listdir_sorted(".") == [ "d2", "link2" ]
805
 
            assert os.path.islink("link2")
806
 
            assert listdir_sorted("d2")== [ "link3" ]
 
1041
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1042
            self.assert_(os.path.islink("link2"))
 
1043
            self.assert_(listdir_sorted("d2")== [ "link3" ])
807
1044
            chdir("..")
808
1045
            
809
1046
            runbzr(['export', '-r', '8', 'exp6.tmp'])
810
1047
            chdir("exp6.tmp")
811
1048
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
812
 
            assert listdir_sorted("d1") == [ "link3new" ]
813
 
            assert listdir_sorted("d2") == []
814
 
            assert os.readlink("d1/link3new") == "NOWHERE3"
 
1049
            self.assertEquals(listdir_sorted("d1"), [ "link3new" ])
 
1050
            self.assertEquals(listdir_sorted("d2"), [])
 
1051
            self.assertEquals(os.readlink("d1/link3new"), "NOWHERE3")
815
1052
            chdir("..")
816
1053
        else:
817
1054
            progress("skipping symlink tests")