← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_selftest.py

(mbp) gc fragmentation fix and content filtering path_content_summary

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_selftest.py
18
18
 
19
19
from cStringIO import StringIO
20
20
import os
 
21
import signal
21
22
import sys
22
23
import time
23
24
import unittest
50
51
    deprecated_method,
51
52
    )
52
53
from bzrlib.tests import (
 
54
    SubUnitFeature,
53
55
    test_lsprof,
54
56
    test_sftp_transport,
55
57
    TestUtil,
1745
1747
 
1746
1748
    def test_make_tree_for_sftp_branch(self):
1747
1749
        """Transports backed by local directories create local trees."""
1748
 
 
 
1750
        # NB: This is arguably a bug in the definition of make_branch_and_tree.
1749
1751
        tree = self.make_branch_and_tree('t1')
1750
1752
        base = tree.bzrdir.root_transport.base
1751
1753
        self.failIf(base.startswith('sftp'),
1756
1758
                tree.branch.repository.bzrdir.root_transport)
1757
1759
 
1758
1760
 
1759
 
class TestSelftest(tests.TestCase):
 
1761
class SelfTestHelper:
 
1762
 
 
1763
    def run_selftest(self, **kwargs):
 
1764
        """Run selftest returning its output."""
 
1765
        output = StringIO()
 
1766
        old_transport = bzrlib.tests.default_transport
 
1767
        old_root = tests.TestCaseWithMemoryTransport.TEST_ROOT
 
1768
        tests.TestCaseWithMemoryTransport.TEST_ROOT = None
 
1769
        try:
 
1770
            self.assertEqual(True, tests.selftest(stream=output, **kwargs))
 
1771
        finally:
 
1772
            bzrlib.tests.default_transport = old_transport
 
1773
            tests.TestCaseWithMemoryTransport.TEST_ROOT = old_root
 
1774
        output.seek(0)
 
1775
        return output
 
1776
 
 
1777
 
 
1778
class TestSelftest(tests.TestCase, SelfTestHelper):
1760
1779
    """Tests of bzrlib.tests.selftest."""
1761
1780
 
1762
1781
    def test_selftest_benchmark_parameter_invokes_test_suite__benchmark__(self):
1770
1789
            test_suite_factory=factory)
1771
1790
        self.assertEqual([True], factory_called)
1772
1791
 
 
1792
    def factory(self):
 
1793
        """A test suite factory."""
 
1794
        class Test(tests.TestCase):
 
1795
            def a(self):
 
1796
                pass
 
1797
            def b(self):
 
1798
                pass
 
1799
            def c(self):
 
1800
                pass
 
1801
        return TestUtil.TestSuite([Test("a"), Test("b"), Test("c")])
 
1802
 
 
1803
    def test_list_only(self):
 
1804
        output = self.run_selftest(test_suite_factory=self.factory,
 
1805
            list_only=True)
 
1806
        self.assertEqual(3, len(output.readlines()))
 
1807
 
 
1808
    def test_list_only_filtered(self):
 
1809
        output = self.run_selftest(test_suite_factory=self.factory,
 
1810
            list_only=True, pattern="Test.b")
 
1811
        self.assertEndsWith(output.getvalue(), "Test.b\n")
 
1812
        self.assertLength(1, output.readlines())
 
1813
 
 
1814
    def test_list_only_excludes(self):
 
1815
        output = self.run_selftest(test_suite_factory=self.factory,
 
1816
            list_only=True, exclude_pattern="Test.b")
 
1817
        self.assertNotContainsRe("Test.b", output.getvalue())
 
1818
        self.assertLength(2, output.readlines())
 
1819
 
 
1820
    def test_random(self):
 
1821
        # test randomising by listing a number of tests.
 
1822
        output_123 = self.run_selftest(test_suite_factory=self.factory,
 
1823
            list_only=True, random_seed="123")
 
1824
        output_234 = self.run_selftest(test_suite_factory=self.factory,
 
1825
            list_only=True, random_seed="234")
 
1826
        self.assertNotEqual(output_123, output_234)
 
1827
        # "Randominzing test order..\n\n
 
1828
        self.assertLength(5, output_123.readlines())
 
1829
        self.assertLength(5, output_234.readlines())
 
1830
 
 
1831
    def test_random_reuse_is_same_order(self):
 
1832
        # test randomising by listing a number of tests.
 
1833
        expected = self.run_selftest(test_suite_factory=self.factory,
 
1834
            list_only=True, random_seed="123")
 
1835
        repeated = self.run_selftest(test_suite_factory=self.factory,
 
1836
            list_only=True, random_seed="123")
 
1837
        self.assertEqual(expected.getvalue(), repeated.getvalue())
 
1838
 
 
1839
    def test_runner_class(self):
 
1840
        self.requireFeature(SubUnitFeature)
 
1841
        from subunit import ProtocolTestCase
 
1842
        stream = self.run_selftest(runner_class=tests.SubUnitBzrRunner,
 
1843
            test_suite_factory=self.factory)
 
1844
        test = ProtocolTestCase(stream)
 
1845
        result = unittest.TestResult()
 
1846
        test.run(result)
 
1847
        self.assertEqual(3, result.testsRun)
 
1848
 
 
1849
    def test_starting_with_single_argument(self):
 
1850
        output = self.run_selftest(test_suite_factory=self.factory,
 
1851
            starting_with=['bzrlib.tests.test_selftest.Test.a'],
 
1852
            list_only=True)
 
1853
        self.assertEqual('bzrlib.tests.test_selftest.Test.a\n',
 
1854
            output.getvalue())
 
1855
 
 
1856
    def test_starting_with_multiple_argument(self):
 
1857
        output = self.run_selftest(test_suite_factory=self.factory,
 
1858
            starting_with=['bzrlib.tests.test_selftest.Test.a',
 
1859
                'bzrlib.tests.test_selftest.Test.b'],
 
1860
            list_only=True)
 
1861
        self.assertEqual('bzrlib.tests.test_selftest.Test.a\n'
 
1862
            'bzrlib.tests.test_selftest.Test.b\n',
 
1863
            output.getvalue())
 
1864
 
 
1865
    def check_transport_set(self, transport_server):
 
1866
        captured_transport = []
 
1867
        def seen_transport(a_transport):
 
1868
            captured_transport.append(a_transport)
 
1869
        class Capture(tests.TestCase):
 
1870
            def a(self):
 
1871
                seen_transport(bzrlib.tests.default_transport)
 
1872
        def factory():
 
1873
            return TestUtil.TestSuite([Capture("a")])
 
1874
        self.run_selftest(transport=transport_server, test_suite_factory=factory)
 
1875
        self.assertEqual(transport_server, captured_transport[0])
 
1876
 
 
1877
    def test_transport_sftp(self):
 
1878
        try:
 
1879
            import bzrlib.transport.sftp
 
1880
        except ParamikoNotPresent:
 
1881
            raise TestSkipped("Paramiko not present")
 
1882
        self.check_transport_set(bzrlib.transport.sftp.SFTPAbsoluteServer)
 
1883
 
 
1884
    def test_transport_memory(self):
 
1885
        self.check_transport_set(bzrlib.transport.memory.MemoryServer)
 
1886
 
 
1887
 
 
1888
class TestSelftestWithIdList(tests.TestCaseInTempDir, SelfTestHelper):
 
1889
    # Does IO: reads test.list
 
1890
 
 
1891
    def test_load_list(self):
 
1892
        # Provide a list with one test - this test.
 
1893
        test_id_line = '%s\n' % self.id()
 
1894
        self.build_tree_contents([('test.list', test_id_line)])
 
1895
        # And generate a list of the tests in  the suite.
 
1896
        stream = self.run_selftest(load_list='test.list', list_only=True)
 
1897
        self.assertEqual(test_id_line, stream.getvalue())
 
1898
 
 
1899
    def test_load_unknown(self):
 
1900
        # Provide a list with one test - this test.
 
1901
        # And generate a list of the tests in  the suite.
 
1902
        err = self.assertRaises(errors.NoSuchFile, self.run_selftest,
 
1903
            load_list='missing file name', list_only=True)
 
1904
 
 
1905
 
 
1906
class TestRunBzr(tests.TestCase):
 
1907
 
 
1908
    out = ''
 
1909
    err = ''
 
1910
 
 
1911
    def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
 
1912
                         working_dir=None):
 
1913
        """Override _run_bzr_core to test how it is invoked by run_bzr.
 
1914
 
 
1915
        Attempts to run bzr from inside this class don't actually run it.
 
1916
 
 
1917
        We test how run_bzr actually invokes bzr in another location.
 
1918
        Here we only need to test that it is run_bzr passes the right
 
1919
        parameters to run_bzr.
 
1920
        """
 
1921
        self.argv = list(argv)
 
1922
        self.retcode = retcode
 
1923
        self.encoding = encoding
 
1924
        self.stdin = stdin
 
1925
        self.working_dir = working_dir
 
1926
        return self.out, self.err
 
1927
 
 
1928
    def test_run_bzr_error(self):
 
1929
        self.out = "It sure does!\n"
 
1930
        out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=34)
 
1931
        self.assertEqual(['rocks'], self.argv)
 
1932
        self.assertEqual(34, self.retcode)
 
1933
        self.assertEqual(out, 'It sure does!\n')
 
1934
 
 
1935
    def test_run_bzr_error_regexes(self):
 
1936
        self.out = ''
 
1937
        self.err = "bzr: ERROR: foobarbaz is not versioned"
 
1938
        out, err = self.run_bzr_error(
 
1939
                ["bzr: ERROR: foobarbaz is not versioned"],
 
1940
                ['file-id', 'foobarbaz'])
 
1941
 
 
1942
    def test_encoding(self):
 
1943
        """Test that run_bzr passes encoding to _run_bzr_core"""
 
1944
        self.run_bzr('foo bar')
 
1945
        self.assertEqual(None, self.encoding)
 
1946
        self.assertEqual(['foo', 'bar'], self.argv)
 
1947
 
 
1948
        self.run_bzr('foo bar', encoding='baz')
 
1949
        self.assertEqual('baz', self.encoding)
 
1950
        self.assertEqual(['foo', 'bar'], self.argv)
 
1951
 
 
1952
    def test_retcode(self):
 
1953
        """Test that run_bzr passes retcode to _run_bzr_core"""
 
1954
        # Default is retcode == 0
 
1955
        self.run_bzr('foo bar')
 
1956
        self.assertEqual(0, self.retcode)
 
1957
        self.assertEqual(['foo', 'bar'], self.argv)
 
1958
 
 
1959
        self.run_bzr('foo bar', retcode=1)
 
1960
        self.assertEqual(1, self.retcode)
 
1961
        self.assertEqual(['foo', 'bar'], self.argv)
 
1962
 
 
1963
        self.run_bzr('foo bar', retcode=None)
 
1964
        self.assertEqual(None, self.retcode)
 
1965
        self.assertEqual(['foo', 'bar'], self.argv)
 
1966
 
 
1967
        self.run_bzr(['foo', 'bar'], retcode=3)
 
1968
        self.assertEqual(3, self.retcode)
 
1969
        self.assertEqual(['foo', 'bar'], self.argv)
 
1970
 
 
1971
    def test_stdin(self):
 
1972
        # test that the stdin keyword to run_bzr is passed through to
 
1973
        # _run_bzr_core as-is. We do this by overriding
 
1974
        # _run_bzr_core in this class, and then calling run_bzr,
 
1975
        # which is a convenience function for _run_bzr_core, so
 
1976
        # should invoke it.
 
1977
        self.run_bzr('foo bar', stdin='gam')
 
1978
        self.assertEqual('gam', self.stdin)
 
1979
        self.assertEqual(['foo', 'bar'], self.argv)
 
1980
 
 
1981
        self.run_bzr('foo bar', stdin='zippy')
 
1982
        self.assertEqual('zippy', self.stdin)
 
1983
        self.assertEqual(['foo', 'bar'], self.argv)
 
1984
 
 
1985
    def test_working_dir(self):
 
1986
        """Test that run_bzr passes working_dir to _run_bzr_core"""
 
1987
        self.run_bzr('foo bar')
 
1988
        self.assertEqual(None, self.working_dir)
 
1989
        self.assertEqual(['foo', 'bar'], self.argv)
 
1990
 
 
1991
        self.run_bzr('foo bar', working_dir='baz')
 
1992
        self.assertEqual('baz', self.working_dir)
 
1993
        self.assertEqual(['foo', 'bar'], self.argv)
 
1994
 
 
1995
    def test_reject_extra_keyword_arguments(self):
 
1996
        self.assertRaises(TypeError, self.run_bzr, "foo bar",
 
1997
                          error_regex=['error message'])
 
1998
 
 
1999
 
 
2000
class TestRunBzrCaptured(tests.TestCaseWithTransport):
 
2001
    # Does IO when testing the working_dir parameter.
 
2002
 
 
2003
    def apply_redirected(self, stdin=None, stdout=None, stderr=None,
 
2004
                         a_callable=None, *args, **kwargs):
 
2005
        self.stdin = stdin
 
2006
        self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
 
2007
        self.factory = bzrlib.ui.ui_factory
 
2008
        self.working_dir = osutils.getcwd()
 
2009
        stdout.write('foo\n')
 
2010
        stderr.write('bar\n')
 
2011
        return 0
 
2012
 
 
2013
    def test_stdin(self):
 
2014
        # test that the stdin keyword to _run_bzr_core is passed through to
 
2015
        # apply_redirected as a StringIO. We do this by overriding
 
2016
        # apply_redirected in this class, and then calling _run_bzr_core,
 
2017
        # which calls apply_redirected.
 
2018
        self.run_bzr(['foo', 'bar'], stdin='gam')
 
2019
        self.assertEqual('gam', self.stdin.read())
 
2020
        self.assertTrue(self.stdin is self.factory_stdin)
 
2021
        self.run_bzr(['foo', 'bar'], stdin='zippy')
 
2022
        self.assertEqual('zippy', self.stdin.read())
 
2023
        self.assertTrue(self.stdin is self.factory_stdin)
 
2024
 
 
2025
    def test_ui_factory(self):
 
2026
        # each invocation of self.run_bzr should get its
 
2027
        # own UI factory, which is an instance of TestUIFactory,
 
2028
        # with stdin, stdout and stderr attached to the stdin,
 
2029
        # stdout and stderr of the invoked run_bzr
 
2030
        current_factory = bzrlib.ui.ui_factory
 
2031
        self.run_bzr(['foo'])
 
2032
        self.failIf(current_factory is self.factory)
 
2033
        self.assertNotEqual(sys.stdout, self.factory.stdout)
 
2034
        self.assertNotEqual(sys.stderr, self.factory.stderr)
 
2035
        self.assertEqual('foo\n', self.factory.stdout.getvalue())
 
2036
        self.assertEqual('bar\n', self.factory.stderr.getvalue())
 
2037
        self.assertIsInstance(self.factory, tests.TestUIFactory)
 
2038
 
 
2039
    def test_working_dir(self):
 
2040
        self.build_tree(['one/', 'two/'])
 
2041
        cwd = osutils.getcwd()
 
2042
 
 
2043
        # Default is to work in the current directory
 
2044
        self.run_bzr(['foo', 'bar'])
 
2045
        self.assertEqual(cwd, self.working_dir)
 
2046
 
 
2047
        self.run_bzr(['foo', 'bar'], working_dir=None)
 
2048
        self.assertEqual(cwd, self.working_dir)
 
2049
 
 
2050
        # The function should be run in the alternative directory
 
2051
        # but afterwards the current working dir shouldn't be changed
 
2052
        self.run_bzr(['foo', 'bar'], working_dir='one')
 
2053
        self.assertNotEqual(cwd, self.working_dir)
 
2054
        self.assertEndsWith(self.working_dir, 'one')
 
2055
        self.assertEqual(cwd, osutils.getcwd())
 
2056
 
 
2057
        self.run_bzr(['foo', 'bar'], working_dir='two')
 
2058
        self.assertNotEqual(cwd, self.working_dir)
 
2059
        self.assertEndsWith(self.working_dir, 'two')
 
2060
        self.assertEqual(cwd, osutils.getcwd())
 
2061
 
 
2062
 
 
2063
class StubProcess(object):
 
2064
    """A stub process for testing run_bzr_subprocess."""
 
2065
    
 
2066
    def __init__(self, out="", err="", retcode=0):
 
2067
        self.out = out
 
2068
        self.err = err
 
2069
        self.returncode = retcode
 
2070
 
 
2071
    def communicate(self):
 
2072
        return self.out, self.err
 
2073
 
 
2074
 
 
2075
class TestRunBzrSubprocess(tests.TestCaseWithTransport):
 
2076
 
 
2077
    def setUp(self):
 
2078
        tests.TestCaseWithTransport.setUp(self)
 
2079
        self.subprocess_calls = []
 
2080
 
 
2081
    def start_bzr_subprocess(self, process_args, env_changes=None,
 
2082
                             skip_if_plan_to_signal=False,
 
2083
                             working_dir=None,
 
2084
                             allow_plugins=False):
 
2085
        """capture what run_bzr_subprocess tries to do."""
 
2086
        self.subprocess_calls.append({'process_args':process_args,
 
2087
            'env_changes':env_changes,
 
2088
            'skip_if_plan_to_signal':skip_if_plan_to_signal,
 
2089
            'working_dir':working_dir, 'allow_plugins':allow_plugins})
 
2090
        return self.next_subprocess
 
2091
 
 
2092
    def assertRunBzrSubprocess(self, expected_args, process, *args, **kwargs):
 
2093
        """Run run_bzr_subprocess with args and kwargs using a stubbed process.
 
2094
 
 
2095
        Inside TestRunBzrSubprocessCommands we use a stub start_bzr_subprocess
 
2096
        that will return static results. This assertion method populates those
 
2097
        results and also checks the arguments run_bzr_subprocess generates.
 
2098
        """
 
2099
        self.next_subprocess = process
 
2100
        try:
 
2101
            result = self.run_bzr_subprocess(*args, **kwargs)
 
2102
        except:
 
2103
            self.next_subprocess = None
 
2104
            for key, expected in expected_args.iteritems():
 
2105
                self.assertEqual(expected, self.subprocess_calls[-1][key])
 
2106
            raise
 
2107
        else:
 
2108
            self.next_subprocess = None
 
2109
            for key, expected in expected_args.iteritems():
 
2110
                self.assertEqual(expected, self.subprocess_calls[-1][key])
 
2111
            return result
 
2112
 
 
2113
    def test_run_bzr_subprocess(self):
 
2114
        """The run_bzr_helper_external command behaves nicely."""
 
2115
        self.assertRunBzrSubprocess({'process_args':['--version']},
 
2116
            StubProcess(), '--version')
 
2117
        self.assertRunBzrSubprocess({'process_args':['--version']},
 
2118
            StubProcess(), ['--version'])
 
2119
        # retcode=None disables retcode checking
 
2120
        result = self.assertRunBzrSubprocess({},
 
2121
            StubProcess(retcode=3), '--version', retcode=None)
 
2122
        result = self.assertRunBzrSubprocess({},
 
2123
            StubProcess(out="is free software"), '--version')
 
2124
        self.assertContainsRe(result[0], 'is free software')
 
2125
        # Running a subcommand that is missing errors
 
2126
        self.assertRaises(AssertionError, self.assertRunBzrSubprocess,
 
2127
            {'process_args':['--versionn']}, StubProcess(retcode=3),
 
2128
            '--versionn')
 
2129
        # Unless it is told to expect the error from the subprocess
 
2130
        result = self.assertRunBzrSubprocess({},
 
2131
            StubProcess(retcode=3), '--versionn', retcode=3)
 
2132
        # Or to ignore retcode checking
 
2133
        result = self.assertRunBzrSubprocess({},
 
2134
            StubProcess(err="unknown command", retcode=3), '--versionn',
 
2135
            retcode=None)
 
2136
        self.assertContainsRe(result[1], 'unknown command')
 
2137
 
 
2138
    def test_env_change_passes_through(self):
 
2139
        self.assertRunBzrSubprocess(
 
2140
            {'env_changes':{'new':'value', 'changed':'newvalue', 'deleted':None}},
 
2141
            StubProcess(), '',
 
2142
            env_changes={'new':'value', 'changed':'newvalue', 'deleted':None})
 
2143
 
 
2144
    def test_no_working_dir_passed_as_None(self):
 
2145
        self.assertRunBzrSubprocess({'working_dir': None}, StubProcess(), '')
 
2146
 
 
2147
    def test_no_working_dir_passed_through(self):
 
2148
        self.assertRunBzrSubprocess({'working_dir': 'dir'}, StubProcess(), '',
 
2149
            working_dir='dir')
 
2150
 
 
2151
    def test_run_bzr_subprocess_no_plugins(self):
 
2152
        self.assertRunBzrSubprocess({'allow_plugins': False},
 
2153
            StubProcess(), '')
 
2154
 
 
2155
    def test_allow_plugins(self):
 
2156
        self.assertRunBzrSubprocess({'allow_plugins': True},
 
2157
            StubProcess(), '', allow_plugins=True)
 
2158
 
 
2159
 
 
2160
class _DontSpawnProcess(Exception):
 
2161
    """A simple exception which just allows us to skip unnecessary steps"""
 
2162
 
 
2163
 
 
2164
class TestStartBzrSubProcess(tests.TestCase):
 
2165
 
 
2166
    def check_popen_state(self):
 
2167
        """Replace to make assertions when popen is called."""
 
2168
 
 
2169
    def _popen(self, *args, **kwargs):
 
2170
        """Record the command that is run, so that we can ensure it is correct"""
 
2171
        self.check_popen_state()
 
2172
        self._popen_args = args
 
2173
        self._popen_kwargs = kwargs
 
2174
        raise _DontSpawnProcess()
 
2175
 
 
2176
    def test_run_bzr_subprocess_no_plugins(self):
 
2177
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [])
 
2178
        command = self._popen_args[0]
 
2179
        self.assertEqual(sys.executable, command[0])
 
2180
        self.assertEqual(self.get_bzr_path(), command[1])
 
2181
        self.assertEqual(['--no-plugins'], command[2:])
 
2182
 
 
2183
    def test_allow_plugins(self):
 
2184
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2185
            allow_plugins=True)
 
2186
        command = self._popen_args[0]
 
2187
        self.assertEqual([], command[2:])
 
2188
 
 
2189
    def test_set_env(self):
 
2190
        self.failIf('EXISTANT_ENV_VAR' in os.environ)
 
2191
        # set in the child
 
2192
        def check_environment():
 
2193
            self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
 
2194
        self.check_popen_state = check_environment
 
2195
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2196
            env_changes={'EXISTANT_ENV_VAR':'set variable'})
 
2197
        # not set in theparent
 
2198
        self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
 
2199
 
 
2200
    def test_run_bzr_subprocess_env_del(self):
 
2201
        """run_bzr_subprocess can remove environment variables too."""
 
2202
        self.failIf('EXISTANT_ENV_VAR' in os.environ)
 
2203
        def check_environment():
 
2204
            self.assertFalse('EXISTANT_ENV_VAR' in os.environ)
 
2205
        os.environ['EXISTANT_ENV_VAR'] = 'set variable'
 
2206
        self.check_popen_state = check_environment
 
2207
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2208
            env_changes={'EXISTANT_ENV_VAR':None})
 
2209
        # Still set in parent
 
2210
        self.assertEqual('set variable', os.environ['EXISTANT_ENV_VAR'])
 
2211
        del os.environ['EXISTANT_ENV_VAR']
 
2212
 
 
2213
    def test_env_del_missing(self):
 
2214
        self.failIf('NON_EXISTANT_ENV_VAR' in os.environ)
 
2215
        def check_environment():
 
2216
            self.assertFalse('NON_EXISTANT_ENV_VAR' in os.environ)
 
2217
        self.check_popen_state = check_environment
 
2218
        self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2219
            env_changes={'NON_EXISTANT_ENV_VAR':None})
 
2220
 
 
2221
    def test_working_dir(self):
 
2222
        """Test that we can specify the working dir for the child"""
 
2223
        orig_getcwd = osutils.getcwd
 
2224
        orig_chdir = os.chdir
 
2225
        chdirs = []
 
2226
        def chdir(path):
 
2227
            chdirs.append(path)
 
2228
        os.chdir = chdir
 
2229
        try:
 
2230
            def getcwd():
 
2231
                return 'current'
 
2232
            osutils.getcwd = getcwd
 
2233
            try:
 
2234
                self.assertRaises(_DontSpawnProcess, self.start_bzr_subprocess, [],
 
2235
                    working_dir='foo')
 
2236
            finally:
 
2237
                osutils.getcwd = orig_getcwd
 
2238
        finally:
 
2239
            os.chdir = orig_chdir
 
2240
        self.assertEqual(['foo', 'current'], chdirs)
 
2241
 
 
2242
 
 
2243
class TestBzrSubprocess(tests.TestCaseWithTransport):
 
2244
 
 
2245
    def test_start_and_stop_bzr_subprocess(self):
 
2246
        """We can start and perform other test actions while that process is
 
2247
        still alive.
 
2248
        """
 
2249
        process = self.start_bzr_subprocess(['--version'])
 
2250
        result = self.finish_bzr_subprocess(process)
 
2251
        self.assertContainsRe(result[0], 'is free software')
 
2252
        self.assertEqual('', result[1])
 
2253
 
 
2254
    def test_start_and_stop_bzr_subprocess_with_error(self):
 
2255
        """finish_bzr_subprocess allows specification of the desired exit code.
 
2256
        """
 
2257
        process = self.start_bzr_subprocess(['--versionn'])
 
2258
        result = self.finish_bzr_subprocess(process, retcode=3)
 
2259
        self.assertEqual('', result[0])
 
2260
        self.assertContainsRe(result[1], 'unknown command')
 
2261
 
 
2262
    def test_start_and_stop_bzr_subprocess_ignoring_retcode(self):
 
2263
        """finish_bzr_subprocess allows the exit code to be ignored."""
 
2264
        process = self.start_bzr_subprocess(['--versionn'])
 
2265
        result = self.finish_bzr_subprocess(process, retcode=None)
 
2266
        self.assertEqual('', result[0])
 
2267
        self.assertContainsRe(result[1], 'unknown command')
 
2268
 
 
2269
    def test_start_and_stop_bzr_subprocess_with_unexpected_retcode(self):
 
2270
        """finish_bzr_subprocess raises self.failureException if the retcode is
 
2271
        not the expected one.
 
2272
        """
 
2273
        process = self.start_bzr_subprocess(['--versionn'])
 
2274
        self.assertRaises(self.failureException, self.finish_bzr_subprocess,
 
2275
                          process)
 
2276
 
 
2277
    def test_start_and_stop_bzr_subprocess_send_signal(self):
 
2278
        """finish_bzr_subprocess raises self.failureException if the retcode is
 
2279
        not the expected one.
 
2280
        """
 
2281
        process = self.start_bzr_subprocess(['wait-until-signalled'],
 
2282
                                            skip_if_plan_to_signal=True)
 
2283
        self.assertEqual('running\n', process.stdout.readline())
 
2284
        result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
 
2285
                                            retcode=3)
 
2286
        self.assertEqual('', result[0])
 
2287
        self.assertEqual('bzr: interrupted\n', result[1])
 
2288
 
 
2289
    def test_start_and_stop_working_dir(self):
 
2290
        cwd = osutils.getcwd()
 
2291
        self.make_branch_and_tree('one')
 
2292
        process = self.start_bzr_subprocess(['root'], working_dir='one')
 
2293
        result = self.finish_bzr_subprocess(process, universal_newlines=True)
 
2294
        self.assertEndsWith(result[0], 'one\n')
 
2295
        self.assertEqual('', result[1])
 
2296
 
1773
2297
 
1774
2298
class TestKnownFailure(tests.TestCase):
1775
2299
 
1840
2364
        tests.TestCase.setUp(self)
1841
2365
        self.suite = TestUtil.TestSuite()
1842
2366
        self.loader = TestUtil.TestLoader()
1843
 
        self.suite.addTest(self.loader.loadTestsFromModuleNames([
1844
 
            'bzrlib.tests.test_selftest']))
 
2367
        self.suite.addTest(self.loader.loadTestsFromModule(
 
2368
            sys.modules['bzrlib.tests.test_selftest']))
1845
2369
        self.all_names = _test_ids(self.suite)
1846
2370
 
1847
2371
    def test_condition_id_re(self):
2158
2682
class TestTestSuite(tests.TestCase):
2159
2683
 
2160
2684
    def test_test_suite(self):
2161
 
        # This test is slow, so we do a single test with one test in each
2162
 
        # category
 
2685
        # This test is slow - it loads the entire test suite to operate, so we
 
2686
        # do a single test with one test in each category
2163
2687
        test_list = [
2164
2688
            # testmod_names
2165
2689
            'bzrlib.tests.blackbox.test_branch.TestBranch.test_branch',
2175
2699
        self.assertEquals(test_list, _test_ids(suite))
2176
2700
 
2177
2701
    def test_test_suite_list_and_start(self):
 
2702
        # We cannot test this at the same time as the main load, because we want
 
2703
        # to know that starting_with == None works. So a second full load is
 
2704
        # incurred.
2178
2705
        test_list = ['bzrlib.tests.test_selftest.TestTestSuite.test_test_suite']
2179
2706
        suite = tests.test_suite(test_list,
2180
2707
                                 ['bzrlib.tests.test_selftest.TestTestSuite'])