13
12
# You should have received a copy of the GNU General Public License
14
13
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
14
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
16
"""UI tests for the test framework."""
19
import bzrlib.transport
24
21
from bzrlib.errors import ParamikoNotPresent
25
22
from bzrlib.tests import (
35
def get_params_passed_to_core(self, cmdline):
37
def selftest(*args, **kwargs):
38
"""Capture the arguments selftest was run with."""
39
params.append((args, kwargs))
41
# Yes this prevents using threads to run the test suite in parallel,
42
# however we don't have a clean dependency injector for commands,
43
# and even if we did - we'd still be testing that the glue is wired
44
# up correctly. XXX: TODO: Solve this testing problem.
45
original_selftest = tests.selftest
46
tests.selftest = selftest
51
tests.selftest = original_selftest
54
class TestOptionsWritingToDisk(TestCaseInTempDir, SelfTestPatch):
56
def test_benchmark_runs_benchmark_tests(self):
57
"""selftest --benchmark should change the suite factory."""
58
params = self.get_params_passed_to_core('selftest --benchmark')
59
self.assertEqual(benchmarks.test_suite,
60
params[1]['test_suite_factory'])
61
self.assertNotEqual(None, params[1]['bench_history'])
62
benchfile = open(".perf_history", "rt")
64
lines = benchfile.readlines()
67
# Because we don't run the actual test code no output is made to the
69
self.assertEqual(0, len(lines))
72
class TestOptions(TestCase, SelfTestPatch):
74
def test_load_list(self):
75
params = self.get_params_passed_to_core('selftest --load-list foo')
76
self.assertEqual('foo', params[1]['load_list'])
27
from bzrlib.tests.blackbox import ExternalBase
30
class TestOptions(TestCase):
78
34
def test_transport_set_to_sftp(self):
79
# Test that we can pass a transport to the selftest core - sftp
81
self.requireFeature(features.paramiko)
82
params = self.get_params_passed_to_core('selftest --transport=sftp')
35
# test the --transport option has taken effect from within the
38
import bzrlib.transport.sftp
39
except ParamikoNotPresent:
40
raise TestSkipped("Paramiko not present")
41
if TestOptions.current_test != "test_transport_set_to_sftp":
83
43
self.assertEqual(bzrlib.transport.sftp.SFTPAbsoluteServer,
84
params[1]["transport"])
44
bzrlib.tests.default_transport)
86
46
def test_transport_set_to_memory(self):
87
# Test that we can pass a transport to the selftest core - memory
47
# test the --transport option has taken effect from within the
89
49
import bzrlib.transport.memory
90
params = self.get_params_passed_to_core('selftest --transport=memory')
50
if TestOptions.current_test != "test_transport_set_to_memory":
91
52
self.assertEqual(bzrlib.transport.memory.MemoryServer,
92
params[1]["transport"])
94
def test_parameters_passed_to_core(self):
95
params = self.get_params_passed_to_core('selftest --list-only')
96
self.assertTrue("list_only" in params[1])
97
params = self.get_params_passed_to_core('selftest --list-only selftest')
98
self.assertTrue("list_only" in params[1])
99
params = self.get_params_passed_to_core(['selftest', '--list-only',
100
'--exclude', 'selftest'])
101
self.assertTrue("list_only" in params[1])
102
params = self.get_params_passed_to_core(['selftest', '--list-only',
103
'selftest', '--randomize', 'now'])
104
self.assertSubset(["list_only", "random_seed"], params[1])
106
def test_starting_with(self):
107
params = self.get_params_passed_to_core('selftest --starting-with foo')
108
self.assertEqual(['foo'], params[1]['starting_with'])
110
def test_starting_with_multiple_argument(self):
111
params = self.get_params_passed_to_core(
112
'selftest --starting-with foo --starting-with bar')
113
self.assertEqual(['foo', 'bar'], params[1]['starting_with'])
115
def test_subunit(self):
116
self.requireFeature(features.subunit)
117
params = self.get_params_passed_to_core('selftest --subunit')
118
self.assertEqual(tests.SubUnitBzrRunner, params[1]['runner_class'])
120
def _parse_test_list(self, lines, newlines_in_header=0):
121
"Parse a list of lines into a tuple of 3 lists (header,body,footer)."
122
in_header = newlines_in_header != 0
127
header_newlines_found = 0
131
header_newlines_found += 1
132
if header_newlines_found >= newlines_in_header:
137
if line.startswith('-------'):
143
# If the last body line is blank, drop it off the list
144
if len(body) > 0 and body[-1] == '':
146
return (header,body,footer)
148
def test_list_only(self):
149
# check that bzr selftest --list-only outputs no ui noise
150
def selftest(*args, **kwargs):
151
"""Capture the arguments selftest was run with."""
153
def outputs_nothing(cmdline):
154
out,err = self.run_bzr(cmdline)
155
(header,body,footer) = self._parse_test_list(out.splitlines())
156
num_tests = len(body)
157
self.assertLength(0, header)
158
self.assertLength(0, footer)
159
self.assertEqual('', err)
160
# Yes this prevents using threads to run the test suite in parallel,
161
# however we don't have a clean dependency injector for commands,
162
# and even if we did - we'd still be testing that the glue is wired
163
# up correctly. XXX: TODO: Solve this testing problem.
164
original_selftest = tests.selftest
165
tests.selftest = selftest
167
outputs_nothing('selftest --list-only')
168
outputs_nothing('selftest --list-only selftest')
169
outputs_nothing(['selftest', '--list-only', '--exclude', 'selftest'])
53
bzrlib.tests.default_transport)
55
def test_transport(self):
56
# test that --transport=sftp works
58
import bzrlib.transport.sftp
59
except ParamikoNotPresent:
60
raise TestSkipped("Paramiko not present")
61
old_transport = bzrlib.tests.default_transport
62
old_root = TestCaseInTempDir.TEST_ROOT
63
TestCaseInTempDir.TEST_ROOT = None
65
TestOptions.current_test = "test_transport_set_to_sftp"
66
stdout = self.capture('selftest --transport=sftp test_transport_set_to_sftp')
68
self.assertContainsRe(stdout, 'Ran 1 test')
69
self.assertEqual(old_transport, bzrlib.tests.default_transport)
71
TestOptions.current_test = "test_transport_set_to_memory"
72
stdout = self.capture('selftest --transport=memory test_transport_set_to_memory')
73
self.assertContainsRe(stdout, 'Ran 1 test')
74
self.assertEqual(old_transport, bzrlib.tests.default_transport)
171
tests.selftest = original_selftest
173
def test_lsprof_tests(self):
174
params = self.get_params_passed_to_core('selftest --lsprof-tests')
175
self.assertEqual(True, params[1]["lsprof_tests"])
76
bzrlib.tests.default_transport = old_transport
77
TestOptions.current_test = None
78
TestCaseInTempDir.TEST_ROOT = old_root
80
def test_benchmark_runs_benchmark_tests(self):
81
"""bzr selftest --benchmark should not run the default test suite."""
82
# We test this by passing a regression test name to --benchmark, which
83
# should result in 0 rests run.
84
out, err = self.run_bzr('selftest', '--benchmark', 'workingtree_implementations')
85
self.assertContainsRe(out, 'Ran 0 tests.*\n\nOK')
87
'running tests...\ntests passed\n',
91
class TestRunBzr(ExternalBase):
93
def run_bzr_captured(self, argv, retcode=0, encoding=None, stdin=None):
97
# test that the stdin keyword to run_bzr is passed through to
98
# run_bzr_captured as-is. We do this by overriding
99
# run_bzr_captured in this class, and then calling run_bzr,
100
# which is a convenience function for run_bzr_captured, so
102
self.run_bzr('foo', 'bar', stdin='gam')
103
self.assertEqual('gam', self.stdin)
104
self.run_bzr('foo', 'bar', stdin='zippy')
105
self.assertEqual('zippy', self.stdin)
108
class TestRunBzrCaptured(ExternalBase):
110
def apply_redirected(self, stdin=None, stdout=None, stderr=None,
111
a_callable=None, *args, **kwargs):
113
self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
114
self.factory = bzrlib.ui.ui_factory
115
stdout.write('foo\n')
116
stderr.write('bar\n')
119
def test_stdin(self):
120
# test that the stdin keyword to run_bzr_captured is passed through to
121
# apply_redirected as a StringIO. We do this by overriding
122
# apply_redirected in this class, and then calling run_bzr_captured,
123
# which calls apply_redirected.
124
self.run_bzr_captured(['foo', 'bar'], stdin='gam')
125
self.assertEqual('gam', self.stdin.read())
126
self.assertTrue(self.stdin is self.factory_stdin)
127
self.run_bzr_captured(['foo', 'bar'], stdin='zippy')
128
self.assertEqual('zippy', self.stdin.read())
129
self.assertTrue(self.stdin is self.factory_stdin)
131
def test_ui_factory(self):
132
# each invocation of self.run_bzr_captured should get its own UI
133
# factory, which is an instance of TestUIFactory, with stdout and
134
# stderr attached to the stdout and stderr of the invoked
136
current_factory = bzrlib.ui.ui_factory
137
self.run_bzr_captured(['foo'])
138
self.failIf(current_factory is self.factory)
139
self.assertNotEqual(sys.stdout, self.factory.stdout)
140
self.assertNotEqual(sys.stderr, self.factory.stderr)
141
self.assertEqual('foo\n', self.factory.stdout.getvalue())
142
self.assertEqual('bar\n', self.factory.stderr.getvalue())
143
self.assertIsInstance(self.factory, bzrlib.tests.blackbox.TestUIFactory)
added
removed
bzrlib/tests/blackbox/test_selftest.py
