← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

  • Committer: John Arbash Meinel
  • Date: 2006-10-11 00:23:23 UTC
  • mfrom: (2070 +trunk)
  • mto: This revision was merged to the branch mainline in revision 2071.
  • Revision ID: john@arbash-meinel.com-20061011002323-82ba88c293d7caff
[merge] bzr.dev 2070

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
15
15
 
16
16
"""Tests for the test framework."""
17
17
 
 
18
import cStringIO
18
19
import os
19
20
from StringIO import StringIO
20
21
import sys
22
23
import unittest
23
24
import warnings
24
25
 
 
26
from bzrlib import osutils, memorytree
25
27
import bzrlib
26
28
from bzrlib.progress import _BaseProgressBar
27
29
from bzrlib.tests import (
28
30
                          ChrootedTestCase,
29
31
                          TestCase,
30
32
                          TestCaseInTempDir,
 
33
                          TestCaseWithMemoryTransport,
31
34
                          TestCaseWithTransport,
32
35
                          TestSkipped,
33
36
                          TestSuite,
34
37
                          TextTestRunner,
35
38
                          )
 
39
from bzrlib.tests.test_sftp_transport import TestCaseWithSFTPServer
36
40
from bzrlib.tests.TestUtil import _load_module_by_name
37
41
import bzrlib.errors as errors
 
42
from bzrlib import symbol_versioning
 
43
from bzrlib.symbol_versioning import zero_ten, zero_eleven
38
44
from bzrlib.trace import note
 
45
from bzrlib.transport.memory import MemoryServer, MemoryTransport
 
46
from bzrlib.version import _get_bzr_source_tree
39
47
 
40
48
 
41
49
class SelftestTests(TestCase):
56
64
        """Test logs are captured when a test fails."""
57
65
        self.log('a test message')
58
66
        self._log_file.flush()
59
 
        self.assertContainsRe(self._get_log(), 'a test message\n')
 
67
        self.assertContainsRe(self._get_log(keep_log_file=True),
 
68
                              'a test message\n')
60
69
 
61
70
 
62
71
class TestTreeShape(TestCaseInTempDir):
323
332
        self.assertEqual(tests[1].transport_readonly_server, server2)
324
333
 
325
334
 
 
335
class TestTreeProviderAdapter(TestCase):
 
336
    """Test the setup of tree_implementation tests."""
 
337
 
 
338
    def test_adapted_tests(self):
 
339
        # the tree implementation adapter is meant to setup one instance for
 
340
        # each working tree format, and one additional instance that will
 
341
        # use the default wt format, but create a revision tree for the tests.
 
342
        # this means that the wt ones should have the workingtree_to_test_tree
 
343
        # attribute set to 'return_parameter' and the revision one set to
 
344
        # revision_tree_from_workingtree.
 
345
 
 
346
        from bzrlib.tests.tree_implementations import (
 
347
            TreeTestProviderAdapter,
 
348
            return_parameter,
 
349
            revision_tree_from_workingtree
 
350
            )
 
351
        from bzrlib.workingtree import WorkingTreeFormat
 
352
        input_test = TestTreeProviderAdapter(
 
353
            "test_adapted_tests")
 
354
        server1 = "a"
 
355
        server2 = "b"
 
356
        formats = [("c", "C"), ("d", "D")]
 
357
        adapter = TreeTestProviderAdapter(server1, server2, formats)
 
358
        suite = adapter.adapt(input_test)
 
359
        tests = list(iter(suite))
 
360
        self.assertEqual(3, len(tests))
 
361
        default_format = WorkingTreeFormat.get_default_format()
 
362
        self.assertEqual(tests[0].workingtree_format, formats[0][0])
 
363
        self.assertEqual(tests[0].bzrdir_format, formats[0][1])
 
364
        self.assertEqual(tests[0].transport_server, server1)
 
365
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
366
        self.assertEqual(tests[0].workingtree_to_test_tree, return_parameter)
 
367
        self.assertEqual(tests[1].workingtree_format, formats[1][0])
 
368
        self.assertEqual(tests[1].bzrdir_format, formats[1][1])
 
369
        self.assertEqual(tests[1].transport_server, server1)
 
370
        self.assertEqual(tests[1].transport_readonly_server, server2)
 
371
        self.assertEqual(tests[1].workingtree_to_test_tree, return_parameter)
 
372
        self.assertEqual(tests[2].workingtree_format, default_format)
 
373
        self.assertEqual(tests[2].bzrdir_format, default_format._matchingbzrdir)
 
374
        self.assertEqual(tests[2].transport_server, server1)
 
375
        self.assertEqual(tests[2].transport_readonly_server, server2)
 
376
        self.assertEqual(tests[2].workingtree_to_test_tree,
 
377
            revision_tree_from_workingtree)
 
378
 
 
379
 
 
380
class TestInterTreeProviderAdapter(TestCase):
 
381
    """A group of tests that test the InterTreeTestAdapter."""
 
382
 
 
383
    def test_adapted_tests(self):
 
384
        # check that constructor parameters are passed through to the adapted
 
385
        # test.
 
386
        # for InterTree tests we want the machinery to bring up two trees in
 
387
        # each instance: the base one, and the one we are interacting with.
 
388
        # because each optimiser can be direction specific, we need to test
 
389
        # each optimiser in its chosen direction.
 
390
        # unlike the TestProviderAdapter we dont want to automatically add a
 
391
        # parameterised one for WorkingTree - the optimisers will tell us what
 
392
        # ones to add.
 
393
        from bzrlib.tests.tree_implementations import (
 
394
            return_parameter,
 
395
            revision_tree_from_workingtree
 
396
            )
 
397
        from bzrlib.tests.intertree_implementations import (
 
398
            InterTreeTestProviderAdapter,
 
399
            )
 
400
        from bzrlib.workingtree import WorkingTreeFormat2, WorkingTreeFormat3
 
401
        input_test = TestInterTreeProviderAdapter(
 
402
            "test_adapted_tests")
 
403
        server1 = "a"
 
404
        server2 = "b"
 
405
        format1 = WorkingTreeFormat2()
 
406
        format2 = WorkingTreeFormat3()
 
407
        formats = [(str, format1, format2, False, True),
 
408
            (int, format2, format1, False, True)]
 
409
        adapter = InterTreeTestProviderAdapter(server1, server2, formats)
 
410
        suite = adapter.adapt(input_test)
 
411
        tests = list(iter(suite))
 
412
        self.assertEqual(2, len(tests))
 
413
        self.assertEqual(tests[0].intertree_class, formats[0][0])
 
414
        self.assertEqual(tests[0].workingtree_format, formats[0][1])
 
415
        self.assertEqual(tests[0].workingtree_to_test_tree, formats[0][2])
 
416
        self.assertEqual(tests[0].workingtree_format_to, formats[0][3])
 
417
        self.assertEqual(tests[0].workingtree_to_test_tree_to, formats[0][4])
 
418
        self.assertEqual(tests[0].transport_server, server1)
 
419
        self.assertEqual(tests[0].transport_readonly_server, server2)
 
420
        self.assertEqual(tests[1].intertree_class, formats[1][0])
 
421
        self.assertEqual(tests[1].workingtree_format, formats[1][1])
 
422
        self.assertEqual(tests[1].workingtree_to_test_tree, formats[1][2])
 
423
        self.assertEqual(tests[1].workingtree_format_to, formats[1][3])
 
424
        self.assertEqual(tests[1].workingtree_to_test_tree_to, formats[1][4])
 
425
        self.assertEqual(tests[1].transport_server, server1)
 
426
        self.assertEqual(tests[1].transport_readonly_server, server2)
 
427
 
 
428
 
 
429
class TestTestCaseInTempDir(TestCaseInTempDir):
 
430
 
 
431
    def test_home_is_not_working(self):
 
432
        self.assertNotEqual(self.test_dir, self.test_home_dir)
 
433
        cwd = osutils.getcwd()
 
434
        self.assertEqual(self.test_dir, cwd)
 
435
        self.assertEqual(self.test_home_dir, os.environ['HOME'])
 
436
 
 
437
 
 
438
class TestTestCaseWithMemoryTransport(TestCaseWithMemoryTransport):
 
439
 
 
440
    def test_home_is_non_existant_dir_under_root(self):
 
441
        """The test_home_dir for TestCaseWithMemoryTransport is missing.
 
442
 
 
443
        This is because TestCaseWithMemoryTransport is for tests that do not
 
444
        need any disk resources: they should be hooked into bzrlib in such a 
 
445
        way that no global settings are being changed by the test (only a 
 
446
        few tests should need to do that), and having a missing dir as home is
 
447
        an effective way to ensure that this is the case.
 
448
        """
 
449
        self.assertEqual(self.TEST_ROOT + "/MemoryTransportMissingHomeDir",
 
450
            self.test_home_dir)
 
451
        self.assertEqual(self.test_home_dir, os.environ['HOME'])
 
452
        
 
453
    def test_cwd_is_TEST_ROOT(self):
 
454
        self.assertEqual(self.test_dir, self.TEST_ROOT)
 
455
        cwd = osutils.getcwd()
 
456
        self.assertEqual(self.test_dir, cwd)
 
457
 
 
458
    def test_make_branch_and_memory_tree(self):
 
459
        """In TestCaseWithMemoryTransport we should not make the branch on disk.
 
460
 
 
461
        This is hard to comprehensively robustly test, so we settle for making
 
462
        a branch and checking no directory was created at its relpath.
 
463
        """
 
464
        tree = self.make_branch_and_memory_tree('dir')
 
465
        self.failIfExists('dir')
 
466
        self.assertIsInstance(tree, memorytree.MemoryTree)
 
467
 
 
468
 
326
469
class TestTestCaseWithTransport(TestCaseWithTransport):
327
470
    """Tests for the convenience functions TestCaseWithTransport introduces."""
328
471
 
367
510
        self.assertRaises(AssertionError, self.assertIsDirectory, 'not_here', t)
368
511
 
369
512
 
 
513
class TestTestCaseTransports(TestCaseWithTransport):
 
514
 
 
515
    def setUp(self):
 
516
        super(TestTestCaseTransports, self).setUp()
 
517
        self.transport_server = MemoryServer
 
518
 
 
519
    def test_make_bzrdir_preserves_transport(self):
 
520
        t = self.get_transport()
 
521
        result_bzrdir = self.make_bzrdir('subdir')
 
522
        self.assertIsInstance(result_bzrdir.transport, 
 
523
                              MemoryTransport)
 
524
        # should not be on disk, should only be in memory
 
525
        self.failIfExists('subdir')
 
526
 
 
527
 
370
528
class TestChrootedTest(ChrootedTestCase):
371
529
 
372
530
    def test_root_is_root(self):
395
553
    def clear(self):
396
554
        self.calls.append(('clear',))
397
555
 
 
556
    def note(self, msg, *args):
 
557
        self.calls.append(('note', msg, args))
 
558
 
398
559
 
399
560
class TestTestResult(TestCase):
400
561
 
405
566
        mypb = MockProgress()
406
567
        mypb.update('Running tests', 0, 4)
407
568
        last_calls = mypb.calls[:]
 
569
 
408
570
        result = bzrlib.tests._MyResult(self._log_file,
409
571
                                        descriptions=0,
410
572
                                        verbosity=1,
411
573
                                        pb=mypb)
412
574
        self.assertEqual(last_calls, mypb.calls)
413
575
 
 
576
        def shorten(s):
 
577
            """Shorten a string based on the terminal width"""
 
578
            return result._ellipsise_unimportant_words(s,
 
579
                                 osutils.terminal_width())
 
580
 
414
581
        # an error 
415
582
        result.startTest(dummy_test)
416
583
        # starting a test prints the test name
417
 
        self.assertEqual(last_calls + [('update', '...tyle_quiet', 0, None)], mypb.calls)
418
 
        last_calls = mypb.calls[:]
 
584
        last_calls += [('update', '...tyle_quiet', 0, None)]
 
585
        self.assertEqual(last_calls, mypb.calls)
419
586
        result.addError(dummy_test, dummy_error)
420
 
        self.assertEqual(last_calls + [('update', 'ERROR        ', 1, None)], mypb.calls)
421
 
        last_calls = mypb.calls[:]
 
587
        last_calls += [('update', 'ERROR        ', 1, None),
 
588
                       ('note', shorten(dummy_test.id() + ': ERROR'), ())
 
589
                      ]
 
590
        self.assertEqual(last_calls, mypb.calls)
422
591
 
423
592
        # a failure
424
593
        result.startTest(dummy_test)
425
 
        self.assertEqual(last_calls + [('update', '...tyle_quiet', 1, None)], mypb.calls)
426
 
        last_calls = mypb.calls[:]
 
594
        last_calls += [('update', '...tyle_quiet', 1, None)]
 
595
        self.assertEqual(last_calls, mypb.calls)
 
596
        last_calls += [('update', 'FAIL         ', 2, None),
 
597
                       ('note', shorten(dummy_test.id() + ': FAIL'), ())
 
598
                      ]
427
599
        result.addFailure(dummy_test, dummy_error)
428
 
        self.assertEqual(last_calls + [('update', 'FAIL         ', 2, None)], mypb.calls)
429
 
        last_calls = mypb.calls[:]
 
600
        self.assertEqual(last_calls, mypb.calls)
430
601
 
431
602
        # a success
432
603
        result.startTest(dummy_test)
433
 
        self.assertEqual(last_calls + [('update', '...tyle_quiet', 2, None)], mypb.calls)
434
 
        last_calls = mypb.calls[:]
 
604
        last_calls += [('update', '...tyle_quiet', 2, None)]
 
605
        self.assertEqual(last_calls, mypb.calls)
435
606
        result.addSuccess(dummy_test)
436
 
        self.assertEqual(last_calls + [('update', 'OK           ', 3, None)], mypb.calls)
437
 
        last_calls = mypb.calls[:]
 
607
        last_calls += [('update', 'OK           ', 3, None)]
 
608
        self.assertEqual(last_calls, mypb.calls)
438
609
 
439
610
        # a skip
440
611
        result.startTest(dummy_test)
441
 
        self.assertEqual(last_calls + [('update', '...tyle_quiet', 3, None)], mypb.calls)
442
 
        last_calls = mypb.calls[:]
 
612
        last_calls += [('update', '...tyle_quiet', 3, None)]
 
613
        self.assertEqual(last_calls, mypb.calls)
443
614
        result.addSkipped(dummy_test, dummy_error)
444
 
        self.assertEqual(last_calls + [('update', 'SKIP         ', 4, None)], mypb.calls)
445
 
        last_calls = mypb.calls[:]
 
615
        last_calls += [('update', 'SKIP         ', 4, None)]
 
616
        self.assertEqual(last_calls, mypb.calls)
446
617
 
447
618
    def test_elapsed_time_with_benchmarking(self):
448
619
        result = bzrlib.tests._MyResult(self._log_file,
469
640
        # cheat. Yes, wash thy mouth out with soap.
470
641
        self._benchtime = None
471
642
 
 
643
    def test_assigned_benchmark_file_stores_date(self):
 
644
        output = StringIO()
 
645
        result = bzrlib.tests._MyResult(self._log_file,
 
646
                                        descriptions=0,
 
647
                                        verbosity=1,
 
648
                                        bench_history=output
 
649
                                        )
 
650
        output_string = output.getvalue()
 
651
        # if you are wondering about the regexp please read the comment in
 
652
        # test_bench_history (bzrlib.tests.test_selftest.TestRunner)
 
653
        # XXX: what comment?  -- Andrew Bennetts
 
654
        self.assertContainsRe(output_string, "--date [0-9.]+")
 
655
 
 
656
    def test_benchhistory_records_test_times(self):
 
657
        result_stream = StringIO()
 
658
        result = bzrlib.tests._MyResult(
 
659
            self._log_file,
 
660
            descriptions=0,
 
661
            verbosity=1,
 
662
            bench_history=result_stream
 
663
            )
 
664
 
 
665
        # we want profile a call and check that its test duration is recorded
 
666
        # make a new test instance that when run will generate a benchmark
 
667
        example_test_case = TestTestResult("_time_hello_world_encoding")
 
668
        # execute the test, which should succeed and record times
 
669
        example_test_case.run(result)
 
670
        lines = result_stream.getvalue().splitlines()
 
671
        self.assertEqual(2, len(lines))
 
672
        self.assertContainsRe(lines[1],
 
673
            " *[0-9]+ms bzrlib.tests.test_selftest.TestTestResult"
 
674
            "._time_hello_world_encoding")
 
675
 
472
676
    def _time_hello_world_encoding(self):
473
677
        """Profile two sleep calls
474
678
        
564
768
        result = self.run_test_runner(runner, test)
565
769
        self.assertTrue(result.wasSuccessful())
566
770
 
 
771
    def test_bench_history(self):
 
772
        # tests that the running the benchmark produces a history file
 
773
        # containing a timestamp and the revision id of the bzrlib source which
 
774
        # was tested.
 
775
        workingtree = _get_bzr_source_tree()
 
776
        test = TestRunner('dummy_test')
 
777
        output = StringIO()
 
778
        runner = TextTestRunner(stream=self._log_file, bench_history=output)
 
779
        result = self.run_test_runner(runner, test)
 
780
        output_string = output.getvalue()
 
781
        self.assertContainsRe(output_string, "--date [0-9.]+")
 
782
        if workingtree is not None:
 
783
            revision_id = workingtree.get_parent_ids()[0]
 
784
            self.assertEndsWith(output_string.rstrip(), revision_id)
 
785
 
 
786
    def test_success_log_deleted(self):
 
787
        """Successful tests have their log deleted"""
 
788
 
 
789
        class LogTester(TestCase):
 
790
 
 
791
            def test_success(self):
 
792
                self.log('this will be removed\n')
 
793
 
 
794
        sio = cStringIO.StringIO()
 
795
        runner = TextTestRunner(stream=sio)
 
796
        test = LogTester('test_success')
 
797
        result = self.run_test_runner(runner, test)
 
798
 
 
799
        log = test._get_log()
 
800
        self.assertEqual("DELETED log file to reduce memory footprint", log)
 
801
        self.assertEqual('', test._log_contents)
 
802
        self.assertIs(None, test._log_file_name)
 
803
 
 
804
    def test_fail_log_kept(self):
 
805
        """Failed tests have their log kept"""
 
806
 
 
807
        class LogTester(TestCase):
 
808
 
 
809
            def test_fail(self):
 
810
                self.log('this will be kept\n')
 
811
                self.fail('this test fails')
 
812
 
 
813
        sio = cStringIO.StringIO()
 
814
        runner = TextTestRunner(stream=sio)
 
815
        test = LogTester('test_fail')
 
816
        result = self.run_test_runner(runner, test)
 
817
 
 
818
        text = sio.getvalue()
 
819
        self.assertContainsRe(text, 'this will be kept')
 
820
        self.assertContainsRe(text, 'this test fails')
 
821
 
 
822
        log = test._get_log()
 
823
        self.assertContainsRe(log, 'this will be kept')
 
824
        self.assertEqual(log, test._log_contents)
 
825
 
 
826
    def test_error_log_kept(self):
 
827
        """Tests with errors have their log kept"""
 
828
 
 
829
        class LogTester(TestCase):
 
830
 
 
831
            def test_error(self):
 
832
                self.log('this will be kept\n')
 
833
                raise ValueError('random exception raised')
 
834
 
 
835
        sio = cStringIO.StringIO()
 
836
        runner = TextTestRunner(stream=sio)
 
837
        test = LogTester('test_error')
 
838
        result = self.run_test_runner(runner, test)
 
839
 
 
840
        text = sio.getvalue()
 
841
        self.assertContainsRe(text, 'this will be kept')
 
842
        self.assertContainsRe(text, 'random exception raised')
 
843
 
 
844
        log = test._get_log()
 
845
        self.assertContainsRe(log, 'this will be kept')
 
846
        self.assertEqual(log, test._log_contents)
 
847
 
567
848
 
568
849
class TestTestCase(TestCase):
569
850
    """Tests that test the core bzrlib TestCase."""
641
922
        self.assertIsInstance(self._benchcalls[1][1], bzrlib.lsprof.Stats)
642
923
 
643
924
 
 
925
@symbol_versioning.deprecated_function(zero_eleven)
 
926
def sample_deprecated_function():
 
927
    """A deprecated function to test applyDeprecated with."""
 
928
    return 2
 
929
 
 
930
 
 
931
def sample_undeprecated_function(a_param):
 
932
    """A undeprecated function to test applyDeprecated with."""
 
933
 
 
934
 
 
935
class ApplyDeprecatedHelper(object):
 
936
    """A helper class for ApplyDeprecated tests."""
 
937
 
 
938
    @symbol_versioning.deprecated_method(zero_eleven)
 
939
    def sample_deprecated_method(self, param_one):
 
940
        """A deprecated method for testing with."""
 
941
        return param_one
 
942
 
 
943
    def sample_normal_method(self):
 
944
        """A undeprecated method."""
 
945
 
 
946
    @symbol_versioning.deprecated_method(zero_ten)
 
947
    def sample_nested_deprecation(self):
 
948
        return sample_deprecated_function()
 
949
 
 
950
 
644
951
class TestExtraAssertions(TestCase):
645
952
    """Tests for new test assertions in bzrlib test suite"""
646
953
 
654
961
        self.assertEndsWith('foo', 'oo')
655
962
        self.assertRaises(AssertionError, self.assertEndsWith, 'o', 'oo')
656
963
 
 
964
    def test_applyDeprecated_not_deprecated(self):
 
965
        sample_object = ApplyDeprecatedHelper()
 
966
        # calling an undeprecated callable raises an assertion
 
967
        self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
 
968
            sample_object.sample_normal_method)
 
969
        self.assertRaises(AssertionError, self.applyDeprecated, zero_eleven,
 
970
            sample_undeprecated_function, "a param value")
 
971
        # calling a deprecated callable (function or method) with the wrong
 
972
        # expected deprecation fails.
 
973
        self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
 
974
            sample_object.sample_deprecated_method, "a param value")
 
975
        self.assertRaises(AssertionError, self.applyDeprecated, zero_ten,
 
976
            sample_deprecated_function)
 
977
        # calling a deprecated callable (function or method) with the right
 
978
        # expected deprecation returns the functions result.
 
979
        self.assertEqual("a param value", self.applyDeprecated(zero_eleven,
 
980
            sample_object.sample_deprecated_method, "a param value"))
 
981
        self.assertEqual(2, self.applyDeprecated(zero_eleven,
 
982
            sample_deprecated_function))
 
983
        # calling a nested deprecation with the wrong deprecation version
 
984
        # fails even if a deeper nested function was deprecated with the 
 
985
        # supplied version.
 
986
        self.assertRaises(AssertionError, self.applyDeprecated,
 
987
            zero_eleven, sample_object.sample_nested_deprecation)
 
988
        # calling a nested deprecation with the right deprecation value
 
989
        # returns the calls result.
 
990
        self.assertEqual(2, self.applyDeprecated(zero_ten,
 
991
            sample_object.sample_nested_deprecation))
 
992
 
 
993
    def test_callDeprecated(self):
 
994
        def testfunc(be_deprecated, result=None):
 
995
            if be_deprecated is True:
 
996
                symbol_versioning.warn('i am deprecated', DeprecationWarning, 
 
997
                                       stacklevel=1)
 
998
            return result
 
999
        result = self.callDeprecated(['i am deprecated'], testfunc, True)
 
1000
        self.assertIs(None, result)
 
1001
        result = self.callDeprecated([], testfunc, False, 'result')
 
1002
        self.assertEqual('result', result)
 
1003
        self.callDeprecated(['i am deprecated'], testfunc, be_deprecated=True)
 
1004
        self.callDeprecated([], testfunc, be_deprecated=False)
 
1005
 
657
1006
 
658
1007
class TestConvenienceMakers(TestCaseWithTransport):
659
1008
    """Test for the make_* convenience functions."""
667
1016
        self.assertIsInstance(bzrlib.bzrdir.BzrDir.open('b')._format,
668
1017
                              bzrlib.bzrdir.BzrDirFormat6)
669
1018
 
 
1019
    def test_make_branch_and_memory_tree(self):
 
1020
        # we should be able to get a new branch and a mutable tree from
 
1021
        # TestCaseWithTransport
 
1022
        tree = self.make_branch_and_memory_tree('a')
 
1023
        self.assertIsInstance(tree, bzrlib.memorytree.MemoryTree)
 
1024
 
 
1025
 
 
1026
class TestSFTPMakeBranchAndTree(TestCaseWithSFTPServer):
 
1027
 
 
1028
    def test_make_tree_for_sftp_branch(self):
 
1029
        """Transports backed by local directories create local trees."""
 
1030
 
 
1031
        tree = self.make_branch_and_tree('t1')
 
1032
        base = tree.bzrdir.root_transport.base
 
1033
        self.failIf(base.startswith('sftp'),
 
1034
                'base %r is on sftp but should be local' % base)
 
1035
        self.assertEquals(tree.bzrdir.root_transport,
 
1036
                tree.branch.bzrdir.root_transport)
 
1037
        self.assertEquals(tree.bzrdir.root_transport,
 
1038
                tree.branch.repository.bzrdir.root_transport)
 
1039
 
670
1040
 
671
1041
class TestSelftest(TestCase):
672
1042
    """Tests of bzrlib.tests.selftest."""
681
1051
        self.apply_redirected(out, err, None, bzrlib.tests.selftest, 
682
1052
            test_suite_factory=factory)
683
1053
        self.assertEqual([True], factory_called)
684
 
 
685
 
    def test_run_bzr_subprocess(self):
686
 
        """The run_bzr_helper_external comand behaves nicely."""
687
 
        result = self.run_bzr_subprocess('--version')
688
 
        result = self.run_bzr_subprocess('--version', retcode=None)
689
 
        self.assertContainsRe(result[0], 'is free software')
690
 
        self.assertRaises(AssertionError, self.run_bzr_subprocess, 
691
 
                          '--versionn')
692
 
        result = self.run_bzr_subprocess('--versionn', retcode=3)
693
 
        result = self.run_bzr_subprocess('--versionn', retcode=None)
694
 
        self.assertContainsRe(result[1], 'unknown command')
695
 
        err = self.run_bzr_subprocess('merge', '--merge-type', 'magic merge', 
696
 
                                      retcode=3)[1]
697
 
        self.assertContainsRe(err, 'No known merge type magic merge')
698
 
 
699
 
    def test_run_bzr_error(self):
700
 
        out, err = self.run_bzr_error(['^$'], 'rocks', retcode=0)
701
 
        self.assertEqual(out, 'it sure does!\n')
702
 
 
703
 
        out, err = self.run_bzr_error(["'foobarbaz' is not a versioned file"],
704
 
                                      'file-id', 'foobarbaz')