← 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-01 21:51:17 UTC
  • mfrom: (1185.16.147)
  • mto: (1185.33.49 bzr.dev)
  • mto: This revision was merged to the branch mainline in revision 1512.
  • Revision ID: mbp@sourcefrog.net-20051101215117-e7c33dde397b2350
[merge] main -> bzr.mbp.basic_io

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")
140
154
 
141
155
        file('foo.tmp', 'wt').write('tmp files are ignored')
142
156
        self.assertEquals(list(b.unknowns()), [])
143
 
        assert self.capture('unknowns') == ''
 
157
        self.assertEquals(self.capture('unknowns'), '')
144
158
 
145
159
        file('foo.c', 'wt').write('int main() {}')
146
160
        self.assertEquals(list(b.unknowns()), ['foo.c'])
147
 
        assert self.capture('unknowns') == 'foo.c\n'
 
161
        self.assertEquals(self.capture('unknowns'), 'foo.c\n')
148
162
 
149
163
        self.runbzr(['add', 'foo.c'])
150
 
        assert self.capture('unknowns') == ''
 
164
        self.assertEquals(self.capture('unknowns'), '')
151
165
 
152
166
        # 'ignore' works when creating the .bzignore file
153
167
        file('foo.blah', 'wt').write('blah')
154
168
        self.assertEquals(list(b.unknowns()), ['foo.blah'])
155
169
        self.runbzr('ignore *.blah')
156
170
        self.assertEquals(list(b.unknowns()), [])
157
 
        assert file('.bzrignore', 'rU').read() == '*.blah\n'
 
171
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\n')
158
172
 
159
173
        # 'ignore' works when then .bzrignore file already exists
160
174
        file('garh', 'wt').write('garh')
161
175
        self.assertEquals(list(b.unknowns()), ['garh'])
162
 
        assert self.capture('unknowns') == 'garh\n'
 
176
        self.assertEquals(self.capture('unknowns'), 'garh\n')
163
177
        self.runbzr('ignore garh')
164
178
        self.assertEquals(list(b.unknowns()), [])
165
 
        assert file('.bzrignore', 'rU').read() == '*.blah\ngarh\n'
 
179
        self.assertEquals(file('.bzrignore', 'rU').read(), '*.blah\ngarh\n')
166
180
 
167
181
    def test_revert(self):
168
182
        self.runbzr('init')
255
269
        self.runbzr('export ../latest')
256
270
        self.assertEqual(file('../latest/goodbye', 'rt').read(), 'baz')
257
271
        self.runbzr('export ../first -r 1')
258
 
        assert not os.path.exists('../first/goodbye')
 
272
        self.assert_(not os.path.exists('../first/goodbye'))
259
273
        self.assertEqual(file('../first/hello', 'rt').read(), 'foo')
260
274
        self.runbzr('export ../first.gz -r 1')
261
275
        self.assertEqual(file('../first.gz/hello', 'rt').read(), 'foo')
262
276
        self.runbzr('export ../first.bz2 -r 1')
263
277
        self.assertEqual(file('../first.bz2/hello', 'rt').read(), 'foo')
264
278
        self.runbzr('export ../first.tar -r 1')
265
 
        assert os.path.isfile('../first.tar')
 
279
        self.assert_(os.path.isfile('../first.tar'))
266
280
        from tarfile import TarFile
267
281
        tf = TarFile('../first.tar')
268
 
        assert 'first/hello' in tf.getnames(), tf.getnames()
 
282
        self.assert_('first/hello' in tf.getnames(), tf.getnames())
269
283
        self.assertEqual(tf.extractfile('first/hello').read(), 'foo')
270
284
        self.runbzr('export ../first.tar.gz -r 1')
271
 
        assert os.path.isfile('../first.tar.gz')
 
285
        self.assert_(os.path.isfile('../first.tar.gz'))
272
286
        self.runbzr('export ../first.tbz2 -r 1')
273
 
        assert os.path.isfile('../first.tbz2')
 
287
        self.assert_(os.path.isfile('../first.tbz2'))
274
288
        self.runbzr('export ../first.tar.bz2 -r 1')
275
 
        assert os.path.isfile('../first.tar.bz2')
 
289
        self.assert_(os.path.isfile('../first.tar.bz2'))
276
290
        self.runbzr('export ../first.tar.tbz2 -r 1')
277
 
        assert os.path.isfile('../first.tar.tbz2')
 
291
        self.assert_(os.path.isfile('../first.tar.tbz2'))
278
292
        from bz2 import BZ2File
279
293
        tf = TarFile('../first.tar.tbz2', 
280
294
                     fileobj=BZ2File('../first.tar.tbz2', 'r'))
281
 
        assert 'first.tar/hello' in tf.getnames(), tf.getnames()
 
295
        self.assert_('first.tar/hello' in tf.getnames(), tf.getnames())
282
296
        self.assertEqual(tf.extractfile('first.tar/hello').read(), 'foo')
283
297
        self.runbzr('export ../first2.tar -r 1 --root pizza')
284
298
        tf = TarFile('../first2.tar')
285
 
        assert 'pizza/hello' in tf.getnames(), tf.getnames()
 
299
        self.assert_('pizza/hello' in tf.getnames(), tf.getnames())
286
300
 
287
301
    def test_diff(self):
288
302
        self.example_branch()
289
303
        file('hello', 'wt').write('hello world!')
290
304
        self.runbzr('commit -m fixing hello')
291
 
        output = self.runbzr('diff -r 2..3', backtick=1)
 
305
        output = self.runbzr('diff -r 2..3', backtick=1, retcode=1)
292
306
        self.assert_('\n+hello world!' in output)
293
 
        output = self.runbzr('diff -r last:3..last:1', backtick=1)
 
307
        output = self.runbzr('diff -r last:3..last:1', backtick=1, retcode=1)
294
308
        self.assert_('\n+baz' in output)
295
309
 
296
310
    def test_diff_branches(self):
303
317
        branch2 = Branch.open('branch2')
304
318
        branch2.commit('update file')
305
319
        # should open branch1 and diff against branch2, 
306
 
        output = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 'branch1'])
 
320
        output = self.run_bzr_captured(['diff', '-r', 'branch:branch2', 
 
321
                                        'branch1'],
 
322
                                       retcode=1)
307
323
        self.assertEquals(("=== modified file 'file'\n"
308
324
                           "--- file\n"
309
325
                           "+++ file\n"
363
379
        b = Branch.open('../b')
364
380
        a.get_revision_xml(b.last_revision())
365
381
        self.log('pending merges: %s', a.pending_merges())
366
 
        assert a.pending_merges() == [b.last_revision()], "Assertion %s %s" \
367
 
            % (a.pending_merges(), b.last_patch())
 
382
        self.assertEquals(a.pending_merges(), [b.last_revision()])
368
383
        self.runbzr('commit -m merged')
369
384
        self.runbzr('merge ../b -r last:1')
370
385
        self.assertEqual(Branch.open('.').pending_merges(), [])
397
412
        print >> file('sub/c.txt', 'ab'), "something"
398
413
        self.runbzr(('commit', '-m', 'Modified a.txt'))
399
414
        self.runbzr('merge ../a/', retcode=1)
400
 
        assert os.path.exists('sub/a.txt.THIS')
401
 
        assert os.path.exists('sub/a.txt.BASE')
 
415
        self.assert_(os.path.exists('sub/a.txt.THIS'))
 
416
        self.assert_(os.path.exists('sub/a.txt.BASE'))
402
417
        os.chdir('../a')
403
418
        self.runbzr('merge ../b/', retcode=1)
404
 
        assert os.path.exists('sub/a.txt.OTHER')
405
 
        assert os.path.exists('sub/a.txt.BASE')
 
419
        self.assert_(os.path.exists('sub/a.txt.OTHER'))
 
420
        self.assert_(os.path.exists('sub/a.txt.BASE'))
406
421
 
407
422
    def test_pull(self):
408
423
        """Pull changes from one branch to another."""
428
443
        os.chdir('../a')
429
444
        a = Branch.open('.')
430
445
        b = Branch.open('../b')
431
 
        assert a.revision_history() == b.revision_history()[:-1]
 
446
        self.assertEquals(a.revision_history(), b.revision_history()[:-1])
432
447
        self.runbzr('pull ../b')
433
 
        assert a.revision_history() == b.revision_history()
 
448
        self.assertEquals(a.revision_history(), b.revision_history())
434
449
        self.runbzr('commit -m blah2 --unchanged')
435
450
        os.chdir('../b')
436
451
        self.runbzr('commit -m blah3 --unchanged')
448
463
        self.runbzr('commit -m blah4 --unchanged')
449
464
        os.chdir('../b/subdir')
450
465
        self.runbzr('pull ../../a')
451
 
        assert a.revision_history()[-1] == b.revision_history()[-1]
 
466
        self.assertEquals(a.revision_history()[-1], b.revision_history()[-1])
452
467
        self.runbzr('commit -m blah5 --unchanged')
453
468
        self.runbzr('commit -m blah6 --unchanged')
454
469
        os.chdir('..')
460
475
        self.runbzr('pull ../b')
461
476
        self.runbzr('pull ../b')
462
477
 
 
478
    def test_ls(self):
 
479
        """Test the abilities of 'bzr ls'"""
 
480
        bzr = self.runbzr
 
481
        def bzrout(*args, **kwargs):
 
482
            kwargs['backtick'] = True
 
483
            return self.runbzr(*args, **kwargs)
 
484
 
 
485
        def ls_equals(value, *args):
 
486
            out = self.runbzr(['ls'] + list(args), backtick=True)
 
487
            self.assertEquals(out, value)
 
488
 
 
489
        bzr('init')
 
490
        open('a', 'wb').write('hello\n')
 
491
 
 
492
        # Can't supply both
 
493
        bzr('ls --verbose --null', retcode=1)
 
494
 
 
495
        ls_equals('a\n')
 
496
        ls_equals('?        a\n', '--verbose')
 
497
        ls_equals('a\n', '--unknown')
 
498
        ls_equals('', '--ignored')
 
499
        ls_equals('', '--versioned')
 
500
        ls_equals('a\n', '--unknown', '--ignored', '--versioned')
 
501
        ls_equals('', '--ignored', '--versioned')
 
502
        ls_equals('a\0', '--null')
 
503
 
 
504
        bzr('add a')
 
505
        ls_equals('V        a\n', '--verbose')
 
506
        bzr('commit -m add')
 
507
        
 
508
        os.mkdir('subdir')
 
509
        ls_equals('V        a\n'
 
510
                  '?        subdir/\n'
 
511
                  , '--verbose')
 
512
        open('subdir/b', 'wb').write('b\n')
 
513
        bzr('add')
 
514
        ls_equals('V        a\n'
 
515
                  'V        subdir/\n'
 
516
                  'V        subdir/b\n'
 
517
                  , '--verbose')
 
518
        bzr('commit -m subdir')
 
519
 
 
520
        ls_equals('a\n'
 
521
                  'subdir\n'
 
522
                  , '--non-recursive')
 
523
 
 
524
        ls_equals('V        a\n'
 
525
                  'V        subdir/\n'
 
526
                  , '--verbose', '--non-recursive')
 
527
 
 
528
        # Check what happens in a sub-directory
 
529
        os.chdir('subdir')
 
530
        ls_equals('b\n')
 
531
        ls_equals('b\0'
 
532
                  , '--null')
 
533
        ls_equals('a\n'
 
534
                  'subdir\n'
 
535
                  'subdir/b\n'
 
536
                  , '--from-root')
 
537
        ls_equals('a\0'
 
538
                  'subdir\0'
 
539
                  'subdir/b\0'
 
540
                  , '--from-root', '--null')
 
541
        ls_equals('a\n'
 
542
                  'subdir\n'
 
543
                  , '--from-root', '--non-recursive')
 
544
 
 
545
        os.chdir('..')
 
546
 
 
547
        # Check what happens when we supply a specific revision
 
548
        ls_equals('a\n', '--revision', '1')
 
549
        ls_equals('V        a\n'
 
550
                  , '--verbose', '--revision', '1')
 
551
 
 
552
        os.chdir('subdir')
 
553
        ls_equals('', '--revision', '1')
 
554
 
 
555
        # Now try to do ignored files.
 
556
        os.chdir('..')
 
557
        open('blah.py', 'wb').write('unknown\n')
 
558
        open('blah.pyo', 'wb').write('ignored\n')
 
559
        ls_equals('a\n'
 
560
                  'blah.py\n'
 
561
                  'blah.pyo\n'
 
562
                  'subdir\n'
 
563
                  'subdir/b\n')
 
564
        ls_equals('V        a\n'
 
565
                  '?        blah.py\n'
 
566
                  'I        blah.pyo\n'
 
567
                  'V        subdir/\n'
 
568
                  'V        subdir/b\n'
 
569
                  , '--verbose')
 
570
        ls_equals('blah.pyo\n'
 
571
                  , '--ignored')
 
572
        ls_equals('blah.py\n'
 
573
                  , '--unknown')
 
574
        ls_equals('a\n'
 
575
                  'subdir\n'
 
576
                  'subdir/b\n'
 
577
                  , '--versioned')
 
578
 
 
579
 
463
580
    def test_locations(self):
464
581
        """Using and remembering different locations"""
465
582
        os.mkdir('a')
539
656
        self.runbzr('commit -m this')
540
657
        self.runbzr('merge ../other --show-base', retcode=1)
541
658
        conflict_text = file('hello').read()
542
 
        assert '<<<<<<<' in conflict_text
543
 
        assert '>>>>>>>' in conflict_text
544
 
        assert '=======' in conflict_text
545
 
        assert '|||||||' in conflict_text
546
 
        assert 'hi world' in conflict_text
 
659
        self.assert_('<<<<<<<' in conflict_text)
 
660
        self.assert_('>>>>>>>' in conflict_text)
 
661
        self.assert_('=======' in conflict_text)
 
662
        self.assert_('|||||||' in conflict_text)
 
663
        self.assert_('hi world' in conflict_text)
547
664
        self.runbzr('revert')
548
665
        self.runbzr('resolve --all')
549
666
        self.runbzr('merge ../other', retcode=1)
550
667
        conflict_text = file('hello').read()
551
 
        assert '|||||||' not in conflict_text
552
 
        assert 'hi world' not in conflict_text
 
668
        self.assert_('|||||||' not in conflict_text)
 
669
        self.assert_('hi world' not in conflict_text)
553
670
        result = self.runbzr('conflicts', backtick=1)
554
671
        self.assertEquals(result, "hello\nquestion\n")
555
672
        result = self.runbzr('status', backtick=1)
556
 
        assert "conflicts:\n  hello\n  question\n" in result, result
 
673
        self.assert_("conflicts:\n  hello\n  question\n" in result, result)
557
674
        self.runbzr('resolve hello')
558
675
        result = self.runbzr('conflicts', backtick=1)
559
676
        self.assertEquals(result, "question\n")
600
717
        finally:
601
718
            bzrlib.gpg.GPGStrategy = oldstrategy
602
719
 
 
720
    def test_push(self):
 
721
        # create a source branch
 
722
        os.mkdir('my-branch')
 
723
        os.chdir('my-branch')
 
724
        self.example_branch()
 
725
 
 
726
        # with no push target, fail
 
727
        self.runbzr('push', retcode=1)
 
728
        # with an explicit target work
 
729
        self.runbzr('push ../output-branch')
 
730
        # with an implicit target work
 
731
        self.runbzr('push')
 
732
        # nothing missing
 
733
        self.runbzr('missing ../output-branch')
 
734
        # advance this branch
 
735
        self.runbzr('commit --unchanged -m unchanged')
 
736
 
 
737
        os.chdir('../output-branch')
 
738
        # should be a diff as we have not pushed the tree
 
739
        self.runbzr('diff', retcode=1)
 
740
        self.runbzr('revert')
 
741
        # but not now.
 
742
        self.runbzr('diff')
 
743
        # diverge the branches
 
744
        self.runbzr('commit --unchanged -m unchanged')
 
745
        os.chdir('../my-branch')
 
746
        # cannot push now
 
747
        self.runbzr('push', retcode=1)
 
748
        # and there are difference
 
749
        self.runbzr('missing ../output-branch', retcode=1)
 
750
        # but we can force a push
 
751
        self.runbzr('push --overwrite')
 
752
        # nothing missing
 
753
        self.runbzr('missing ../output-branch')
 
754
        
 
755
        # pushing to a new dir with no parent should fail
 
756
        self.runbzr('push ../missing/new-branch', retcode=1)
 
757
        # unless we provide --create-prefix
 
758
        self.runbzr('push --create-prefix ../missing/new-branch')
 
759
        # nothing missing
 
760
        self.runbzr('missing ../missing/new-branch')
 
761
 
603
762
 
604
763
def listdir_sorted(dir):
605
764
    L = os.listdir(dir)
635
794
        self.assertEquals(capture('unknowns'), 'test.txt\n')
636
795
 
637
796
        out = capture("status")
638
 
        assert out == 'unknown:\n  test.txt\n'
 
797
        self.assertEquals(out, 'unknown:\n  test.txt\n')
639
798
 
640
799
        out = capture("status --all")
641
 
        assert out == "unknown:\n  test.txt\n"
 
800
        self.assertEquals(out, "unknown:\n  test.txt\n")
642
801
 
643
802
        out = capture("status test.txt --all")
644
 
        assert out == "unknown:\n  test.txt\n"
 
803
        self.assertEquals(out, "unknown:\n  test.txt\n")
645
804
 
646
805
        f = file('test2.txt', 'wt')
647
806
        f.write('goodbye cruel world...\n')
648
807
        f.close()
649
808
 
650
809
        out = capture("status test.txt")
651
 
        assert out == "unknown:\n  test.txt\n"
 
810
        self.assertEquals(out, "unknown:\n  test.txt\n")
652
811
 
653
812
        out = capture("status")
654
 
        assert out == ("unknown:\n"
655
 
                       "  test.txt\n"
656
 
                       "  test2.txt\n")
 
813
        self.assertEquals(out, ("unknown:\n" "  test.txt\n" "  test2.txt\n"))
657
814
 
658
815
        os.unlink('test2.txt')
659
816
 
660
817
        progress("command aliases")
661
818
        out = capture("st --all")
662
 
        assert out == ("unknown:\n"
663
 
                       "  test.txt\n")
 
819
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
664
820
 
665
821
        out = capture("stat")
666
 
        assert out == ("unknown:\n"
667
 
                       "  test.txt\n")
 
822
        self.assertEquals(out, ("unknown:\n" "  test.txt\n"))
668
823
 
669
824
        progress("command help")
670
825
        runbzr("help st")
681
836
        progress("adding a file")
682
837
 
683
838
        runbzr("add test.txt")
684
 
        assert capture("unknowns") == ''
685
 
        assert capture("status --all") == ("added:\n"
686
 
                                                "  test.txt\n")
 
839
        self.assertEquals(capture("unknowns"), '')
 
840
        self.assertEquals(capture("status --all"), ("added:\n" "  test.txt\n"))
687
841
 
688
842
        progress("rename newly-added file")
689
843
        runbzr("rename test.txt hello.txt")
690
 
        assert os.path.exists("hello.txt")
691
 
        assert not os.path.exists("test.txt")
 
844
        self.assert_(os.path.exists("hello.txt"))
 
845
        self.assert_(not os.path.exists("test.txt"))
692
846
 
693
 
        assert capture("revno") == '0\n'
 
847
        self.assertEquals(capture("revno"), '0\n')
694
848
 
695
849
        progress("add first revision")
696
850
        runbzr(['commit', '-m', 'add first revision'])
707
861
        self.assertEqual(capture("relpath sub2/hello.txt"),
708
862
                         os.path.join("sub2", "hello.txt\n"))
709
863
 
710
 
        assert exists("sub2")
711
 
        assert exists("sub2/hello.txt")
712
 
        assert not exists("sub1")
713
 
        assert not exists("hello.txt")
 
864
        self.assert_(exists("sub2"))
 
865
        self.assert_(exists("sub2/hello.txt"))
 
866
        self.assert_(not exists("sub1"))
 
867
        self.assert_(not exists("hello.txt"))
714
868
 
715
869
        runbzr(['commit', '-m', 'commit with some things moved to subdirs'])
716
870
 
717
871
        mkdir("sub1")
718
872
        runbzr('add sub1')
719
873
        runbzr('move sub2/hello.txt sub1')
720
 
        assert not exists('sub2/hello.txt')
721
 
        assert exists('sub1/hello.txt')
 
874
        self.assert_(not exists('sub2/hello.txt'))
 
875
        self.assert_(exists('sub1/hello.txt'))
722
876
        runbzr('move sub2 sub1')
723
 
        assert not exists('sub2')
724
 
        assert exists('sub1/sub2')
 
877
        self.assert_(not exists('sub2'))
 
878
        self.assert_(exists('sub1/sub2'))
725
879
 
726
880
        runbzr(['commit', '-m', 'rename nested subdirectories'])
727
881
 
729
883
        self.assertEquals(capture('root')[:-1],
730
884
                          os.path.join(self.test_dir, 'branch1'))
731
885
        runbzr('move ../hello.txt .')
732
 
        assert exists('./hello.txt')
 
886
        self.assert_(exists('./hello.txt'))
733
887
        self.assertEquals(capture('relpath hello.txt'),
734
888
                          os.path.join('sub1', 'sub2', 'hello.txt') + '\n')
735
 
        assert capture('relpath ../../sub1/sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
889
        self.assertEquals(capture('relpath ../../sub1/sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
736
890
        runbzr(['commit', '-m', 'move to parent directory'])
737
891
        chdir('..')
738
 
        assert capture('relpath sub2/hello.txt') == os.path.join('sub1', 'sub2', 'hello.txt\n')
 
892
        self.assertEquals(capture('relpath sub2/hello.txt'), os.path.join('sub1', 'sub2', 'hello.txt\n'))
739
893
 
740
894
        runbzr('move sub2/hello.txt .')
741
 
        assert exists('hello.txt')
 
895
        self.assert_(exists('hello.txt'))
742
896
 
743
897
        f = file('hello.txt', 'wt')
744
898
        f.write('some nice new content\n')
750
904
 
751
905
        runbzr('commit -F msg.tmp')
752
906
 
753
 
        assert capture('revno') == '5\n'
 
907
        self.assertEquals(capture('revno'), '5\n')
754
908
        runbzr('export -r 5 export-5.tmp')
755
909
        runbzr('export export.tmp')
756
910
 
759
913
        runbzr('log -v --forward')
760
914
        runbzr('log -m', retcode=1)
761
915
        log_out = capture('log -m commit')
762
 
        assert "this is my new commit\n  and" in log_out
763
 
        assert "rename nested" not in log_out
764
 
        assert 'revision-id' not in log_out
765
 
        assert 'revision-id' in capture('log --show-ids -m commit')
 
916
        self.assert_("this is my new commit\n  and" in log_out)
 
917
        self.assert_("rename nested" not in log_out)
 
918
        self.assert_('revision-id' not in log_out)
 
919
        self.assert_('revision-id' in capture('log --show-ids -m commit'))
766
920
 
767
921
        log_out = capture('log --line')
768
922
        for line in log_out.splitlines():
769
 
            assert len(line) <= 79, len(line)
770
 
        assert "this is my new commit and" in log_out
 
923
            self.assert_(len(line) <= 79, len(line))
 
924
        self.assert_("this is my new commit and" in log_out)
771
925
 
772
926
 
773
927
        progress("file with spaces in name")
774
928
        mkdir('sub directory')
775
929
        file('sub directory/file with spaces ', 'wt').write('see how this works\n')
776
930
        runbzr('add .')
777
 
        runbzr('diff')
 
931
        runbzr('diff', retcode=1)
778
932
        runbzr('commit -m add-spaces')
779
933
        runbzr('check')
780
934
 
790
944
            runbzr('init')
791
945
            os.symlink("NOWHERE1", "link1")
792
946
            runbzr('add link1')
793
 
            assert self.capture('unknowns') == ''
 
947
            self.assertEquals(self.capture('unknowns'), '')
794
948
            runbzr(['commit', '-m', '1: added symlink link1'])
795
949
    
796
950
            mkdir('d1')
797
951
            runbzr('add d1')
798
 
            assert self.capture('unknowns') == ''
 
952
            self.assertEquals(self.capture('unknowns'), '')
799
953
            os.symlink("NOWHERE2", "d1/link2")
800
 
            assert self.capture('unknowns') == 'd1/link2\n'
 
954
            self.assertEquals(self.capture('unknowns'), 'd1/link2\n')
801
955
            # is d1/link2 found when adding d1
802
956
            runbzr('add d1')
803
 
            assert self.capture('unknowns') == ''
 
957
            self.assertEquals(self.capture('unknowns'), '')
804
958
            os.symlink("NOWHERE3", "d1/link3")
805
 
            assert self.capture('unknowns') == 'd1/link3\n'
 
959
            self.assertEquals(self.capture('unknowns'), 'd1/link3\n')
806
960
            runbzr(['commit', '-m', '2: added dir, symlink'])
807
961
    
808
962
            runbzr('rename d1 d2')
809
963
            runbzr('move d2/link2 .')
810
964
            runbzr('move link1 d2')
811
 
            assert os.readlink("./link2") == "NOWHERE2"
812
 
            assert os.readlink("d2/link1") == "NOWHERE1"
 
965
            self.assertEquals(os.readlink("./link2"), "NOWHERE2")
 
966
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
813
967
            runbzr('add d2/link3')
814
 
            runbzr('diff')
 
968
            runbzr('diff', retcode=1)
815
969
            runbzr(['commit', '-m', '3: rename of dir, move symlinks, add link3'])
816
970
    
817
971
            os.unlink("link2")
818
972
            os.symlink("TARGET 2", "link2")
819
973
            os.unlink("d2/link1")
820
974
            os.symlink("TARGET 1", "d2/link1")
821
 
            runbzr('diff')
822
 
            assert self.capture("relpath d2/link1") == "d2/link1\n"
 
975
            runbzr('diff', retcode=1)
 
976
            self.assertEquals(self.capture("relpath d2/link1"), "d2/link1\n")
823
977
            runbzr(['commit', '-m', '4: retarget of two links'])
824
978
    
825
979
            runbzr('remove d2/link1')
826
 
            assert self.capture('unknowns') == 'd2/link1\n'
 
980
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
827
981
            runbzr(['commit', '-m', '5: remove d2/link1'])
828
982
            # try with the rm alias
829
983
            runbzr('add d2/link1')
830
984
            runbzr(['commit', '-m', '6: add d2/link1'])
831
985
            runbzr('rm d2/link1')
832
 
            assert self.capture('unknowns') == 'd2/link1\n'
 
986
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
833
987
            runbzr(['commit', '-m', '7: remove d2/link1'])
834
988
    
835
989
            os.mkdir("d1")
836
990
            runbzr('add d1')
837
991
            runbzr('rename d2/link3 d1/link3new')
838
 
            assert self.capture('unknowns') == 'd2/link1\n'
 
992
            self.assertEquals(self.capture('unknowns'), 'd2/link1\n')
839
993
            runbzr(['commit', '-m', '8: remove d2/link1, move/rename link3'])
840
994
            
841
995
            runbzr(['check'])
842
996
            
843
997
            runbzr(['export', '-r', '1', 'exp1.tmp'])
844
998
            chdir("exp1.tmp")
845
 
            assert listdir_sorted(".") == [ "link1" ]
846
 
            assert os.readlink("link1") == "NOWHERE1"
 
999
            self.assertEquals(listdir_sorted("."), [ "link1" ])
 
1000
            self.assertEquals(os.readlink("link1"), "NOWHERE1")
847
1001
            chdir("..")
848
1002
            
849
1003
            runbzr(['export', '-r', '2', 'exp2.tmp'])
850
1004
            chdir("exp2.tmp")
851
 
            assert listdir_sorted(".") == [ "d1", "link1" ]
 
1005
            self.assertEquals(listdir_sorted("."), [ "d1", "link1" ])
852
1006
            chdir("..")
853
1007
            
854
1008
            runbzr(['export', '-r', '3', 'exp3.tmp'])
855
1009
            chdir("exp3.tmp")
856
 
            assert listdir_sorted(".") == [ "d2", "link2" ]
857
 
            assert listdir_sorted("d2") == [ "link1", "link3" ]
858
 
            assert os.readlink("d2/link1") == "NOWHERE1"
859
 
            assert os.readlink("link2")    == "NOWHERE2"
 
1010
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1011
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
 
1012
            self.assertEquals(os.readlink("d2/link1"), "NOWHERE1")
 
1013
            self.assertEquals(os.readlink("link2")   , "NOWHERE2")
860
1014
            chdir("..")
861
1015
            
862
1016
            runbzr(['export', '-r', '4', 'exp4.tmp'])
863
1017
            chdir("exp4.tmp")
864
 
            assert listdir_sorted(".") == [ "d2", "link2" ]
865
 
            assert os.readlink("d2/link1") == "TARGET 1"
866
 
            assert os.readlink("link2")    == "TARGET 2"
867
 
            assert listdir_sorted("d2") == [ "link1", "link3" ]
 
1018
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1019
            self.assertEquals(os.readlink("d2/link1"), "TARGET 1")
 
1020
            self.assertEquals(os.readlink("link2")   , "TARGET 2")
 
1021
            self.assertEquals(listdir_sorted("d2"), [ "link1", "link3" ])
868
1022
            chdir("..")
869
1023
            
870
1024
            runbzr(['export', '-r', '5', 'exp5.tmp'])
871
1025
            chdir("exp5.tmp")
872
 
            assert listdir_sorted(".") == [ "d2", "link2" ]
873
 
            assert os.path.islink("link2")
874
 
            assert listdir_sorted("d2")== [ "link3" ]
 
1026
            self.assertEquals(listdir_sorted("."), [ "d2", "link2" ])
 
1027
            self.assert_(os.path.islink("link2"))
 
1028
            self.assert_(listdir_sorted("d2")== [ "link3" ])
875
1029
            chdir("..")
876
1030
            
877
1031
            runbzr(['export', '-r', '8', 'exp6.tmp'])
878
1032
            chdir("exp6.tmp")
879
1033
            self.assertEqual(listdir_sorted("."), [ "d1", "d2", "link2"])
880
 
            assert listdir_sorted("d1") == [ "link3new" ]
881
 
            assert listdir_sorted("d2") == []
882
 
            assert os.readlink("d1/link3new") == "NOWHERE3"
 
1034
            self.assertEquals(listdir_sorted("d1"), [ "link3new" ])
 
1035
            self.assertEquals(listdir_sorted("d2"), [])
 
1036
            self.assertEquals(os.readlink("d1/link3new"), "NOWHERE3")
883
1037
            chdir("..")
884
1038
        else:
885
1039
            progress("skipping symlink tests")