12
13
# You should have received a copy of the GNU General Public License
13
14
# along with this program; if not, write to the Free Software
14
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
16
17
"""UI tests for the test framework."""
22
21
from bzrlib import (
25
from bzrlib.errors import ParamikoNotPresent
26
24
from bzrlib.tests import (
29
TestCaseWithTransport,
32
from bzrlib.tests.blackbox import ExternalBase
35
class TestOptions(TestCase):
27
from bzrlib.transport import memory
31
def get_params_passed_to_core(self, cmdline):
33
def selftest(*args, **kwargs):
34
"""Capture the arguments selftest was run with."""
35
params.append((args, kwargs))
37
# Yes this prevents using threads to run the test suite in parallel,
38
# however we don't have a clean dependency injector for commands,
39
# and even if we did - we'd still be testing that the glue is wired
40
# up correctly. XXX: TODO: Solve this testing problem.
41
original_selftest = tests.selftest
42
tests.selftest = selftest
47
tests.selftest = original_selftest
50
class TestOptions(tests.TestCase, SelfTestPatch):
52
def test_load_list(self):
53
params = self.get_params_passed_to_core('selftest --load-list foo')
54
self.assertEqual('foo', params[1]['load_list'])
39
56
def test_transport_set_to_sftp(self):
40
# test the --transport option has taken effect from within the
43
import bzrlib.transport.sftp
44
except ParamikoNotPresent:
45
raise TestSkipped("Paramiko not present")
46
if TestOptions.current_test != "test_transport_set_to_sftp":
48
self.assertEqual(bzrlib.transport.sftp.SFTPAbsoluteServer,
49
bzrlib.tests.default_transport)
57
# Test that we can pass a transport to the selftest core - sftp
59
self.requireFeature(features.paramiko)
60
from bzrlib.tests import stub_sftp
61
params = self.get_params_passed_to_core('selftest --transport=sftp')
62
self.assertEqual(stub_sftp.SFTPAbsoluteServer,
63
params[1]["transport"])
51
65
def test_transport_set_to_memory(self):
52
# test the --transport option has taken effect from within the
54
import bzrlib.transport.memory
55
if TestOptions.current_test != "test_transport_set_to_memory":
57
self.assertEqual(bzrlib.transport.memory.MemoryServer,
58
bzrlib.tests.default_transport)
60
def test_transport(self):
61
# test that --transport=sftp works
63
import bzrlib.transport.sftp
64
except ParamikoNotPresent:
65
raise TestSkipped("Paramiko not present")
66
old_transport = bzrlib.tests.default_transport
67
old_root = TestCaseInTempDir.TEST_ROOT
68
TestCaseInTempDir.TEST_ROOT = None
70
TestOptions.current_test = "test_transport_set_to_sftp"
71
stdout = self.capture('selftest --transport=sftp test_transport_set_to_sftp')
73
self.assertContainsRe(stdout, 'Ran 1 test')
74
self.assertEqual(old_transport, bzrlib.tests.default_transport)
76
TestOptions.current_test = "test_transport_set_to_memory"
77
stdout = self.capture('selftest --transport=memory test_transport_set_to_memory')
78
self.assertContainsRe(stdout, 'Ran 1 test')
79
self.assertEqual(old_transport, bzrlib.tests.default_transport)
81
bzrlib.tests.default_transport = old_transport
82
TestOptions.current_test = None
83
TestCaseInTempDir.TEST_ROOT = old_root
86
class TestRunBzr(ExternalBase):
88
def run_bzr_captured(self, argv, retcode=0, encoding=None, stdin=None):
92
# test that the stdin keyword to run_bzr is passed through to
93
# run_bzr_captured as-is. We do this by overriding
94
# run_bzr_captured in this class, and then calling run_bzr,
95
# which is a convenience function for run_bzr_captured, so
97
self.run_bzr('foo', 'bar', stdin='gam')
98
self.assertEqual('gam', self.stdin)
99
self.run_bzr('foo', 'bar', stdin='zippy')
100
self.assertEqual('zippy', self.stdin)
103
class TestBenchmarkTests(TestCaseWithTransport):
105
def test_benchmark_runs_benchmark_tests(self):
106
"""bzr selftest --benchmark should not run the default test suite."""
107
# We test this by passing a regression test name to --benchmark, which
108
# should result in 0 rests run.
109
old_root = TestCaseInTempDir.TEST_ROOT
111
TestCaseInTempDir.TEST_ROOT = None
112
out, err = self.run_bzr('selftest', '--benchmark', 'workingtree_implementations')
114
TestCaseInTempDir.TEST_ROOT = old_root
115
self.assertContainsRe(out, 'Ran 0 tests.*\n\nOK')
117
'running tests...\ntests passed\n',
119
benchfile = open(".perf_history", "rt")
121
lines = benchfile.readlines()
124
self.assertEqual(1, len(lines))
125
self.assertContainsRe(lines[0], "--date [0-9.]+")
128
class TestRunBzrCaptured(ExternalBase):
130
def apply_redirected(self, stdin=None, stdout=None, stderr=None,
131
a_callable=None, *args, **kwargs):
133
self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
134
self.factory = bzrlib.ui.ui_factory
135
stdout.write('foo\n')
136
stderr.write('bar\n')
139
def test_stdin(self):
140
# test that the stdin keyword to run_bzr_captured is passed through to
141
# apply_redirected as a StringIO. We do this by overriding
142
# apply_redirected in this class, and then calling run_bzr_captured,
143
# which calls apply_redirected.
144
self.run_bzr_captured(['foo', 'bar'], stdin='gam')
145
self.assertEqual('gam', self.stdin.read())
146
self.assertTrue(self.stdin is self.factory_stdin)
147
self.run_bzr_captured(['foo', 'bar'], stdin='zippy')
148
self.assertEqual('zippy', self.stdin.read())
149
self.assertTrue(self.stdin is self.factory_stdin)
151
def test_ui_factory(self):
152
# each invocation of self.run_bzr_captured should get its own UI
153
# factory, which is an instance of TestUIFactory, with stdout and
154
# stderr attached to the stdout and stderr of the invoked
156
current_factory = bzrlib.ui.ui_factory
157
self.run_bzr_captured(['foo'])
158
self.failIf(current_factory is self.factory)
159
self.assertNotEqual(sys.stdout, self.factory.stdout)
160
self.assertNotEqual(sys.stderr, self.factory.stderr)
161
self.assertEqual('foo\n', self.factory.stdout.getvalue())
162
self.assertEqual('bar\n', self.factory.stderr.getvalue())
163
self.assertIsInstance(self.factory, bzrlib.tests.blackbox.TestUIFactory)
165
def test_run_bzr_subprocess(self):
166
"""The run_bzr_helper_external comand behaves nicely."""
167
result = self.run_bzr_subprocess('--version')
168
result = self.run_bzr_subprocess('--version', retcode=None)
169
self.assertContainsRe(result[0], 'is free software')
170
self.assertRaises(AssertionError, self.run_bzr_subprocess,
172
result = self.run_bzr_subprocess('--versionn', retcode=3)
173
result = self.run_bzr_subprocess('--versionn', retcode=None)
174
self.assertContainsRe(result[1], 'unknown command')
175
err = self.run_bzr_subprocess('merge', '--merge-type', 'magic merge',
177
self.assertContainsRe(err, 'No known merge type magic merge')
179
def test_run_bzr_subprocess_env(self):
180
"""run_bzr_subprocess can set environment variables in the child only.
182
These changes should not change the running process, only the child.
184
# The test suite should unset this variable
185
self.assertEqual(None, os.environ.get('BZR_EMAIL'))
186
out, err = self.run_bzr_subprocess('whoami', env_changes={
187
'BZR_EMAIL':'Joe Foo <joe@foo.com>'
189
self.assertEqual('', err)
190
self.assertEqual('Joe Foo <joe@foo.com>\n', out)
191
# And it should not be modified
192
self.assertEqual(None, os.environ.get('BZR_EMAIL'))
194
# Do it again with a different address, just to make sure
195
# it is actually changing
196
out, err = self.run_bzr_subprocess('whoami', env_changes={
197
'BZR_EMAIL':'Barry <bar@foo.com>'
199
self.assertEqual('', err)
200
self.assertEqual('Barry <bar@foo.com>\n', out)
201
self.assertEqual(None, os.environ.get('BZR_EMAIL'))
203
def test_run_bzr_subprocess_env_del(self):
204
"""run_bzr_subprocess can remove environment variables too."""
205
# Create a random email, so we are sure this won't collide
206
rand_bzr_email = 'John Doe <jdoe@%s.com>' % (osutils.rand_chars(20),)
207
rand_email = 'Jane Doe <jdoe@%s.com>' % (osutils.rand_chars(20),)
208
os.environ['BZR_EMAIL'] = rand_bzr_email
209
os.environ['EMAIL'] = rand_email
211
# By default, the child will inherit the current env setting
212
out, err = self.run_bzr_subprocess('whoami')
213
self.assertEqual('', err)
214
self.assertEqual(rand_bzr_email + '\n', out)
216
# Now that BZR_EMAIL is not set, it should fall back to EMAIL
217
out, err = self.run_bzr_subprocess('whoami',
218
env_changes={'BZR_EMAIL':None})
219
self.assertEqual('', err)
220
self.assertEqual(rand_email + '\n', out)
222
# This switches back to the default email guessing logic
223
# Which shouldn't match either of the above addresses
224
out, err = self.run_bzr_subprocess('whoami',
225
env_changes={'BZR_EMAIL':None, 'EMAIL':None})
227
self.assertEqual('', err)
228
self.assertNotEqual(rand_bzr_email + '\n', out)
229
self.assertNotEqual(rand_email + '\n', out)
231
# TestCase cleans up BZR_EMAIL, and EMAIL at startup
232
del os.environ['BZR_EMAIL']
233
del os.environ['EMAIL']
235
class TestRunBzrError(ExternalBase):
237
def test_run_bzr_error(self):
238
out, err = self.run_bzr_error(['^$'], 'rocks', retcode=0)
239
self.assertEqual(out, 'it sure does!\n')
241
out, err = self.run_bzr_error(["'foobarbaz' is not a versioned file"],
242
'file-id', 'foobarbaz')
66
# Test that we can pass a transport to the selftest core - memory
68
params = self.get_params_passed_to_core('selftest --transport=memory')
69
self.assertEqual(memory.MemoryServer, params[1]["transport"])
71
def test_parameters_passed_to_core(self):
72
params = self.get_params_passed_to_core('selftest --list-only')
73
self.assertTrue("list_only" in params[1])
74
params = self.get_params_passed_to_core('selftest --list-only selftest')
75
self.assertTrue("list_only" in params[1])
76
params = self.get_params_passed_to_core(['selftest', '--list-only',
77
'--exclude', 'selftest'])
78
self.assertTrue("list_only" in params[1])
79
params = self.get_params_passed_to_core(['selftest', '--list-only',
80
'selftest', '--randomize', 'now'])
81
self.assertSubset(["list_only", "random_seed"], params[1])
83
def test_starting_with(self):
84
params = self.get_params_passed_to_core('selftest --starting-with foo')
85
self.assertEqual(['foo'], params[1]['starting_with'])
87
def test_starting_with_multiple_argument(self):
88
params = self.get_params_passed_to_core(
89
'selftest --starting-with foo --starting-with bar')
90
self.assertEqual(['foo', 'bar'], params[1]['starting_with'])
92
def test_subunit(self):
93
self.requireFeature(features.subunit)
94
params = self.get_params_passed_to_core('selftest --subunit')
95
self.assertEqual(tests.SubUnitBzrRunner, params[1]['runner_class'])
97
def _parse_test_list(self, lines, newlines_in_header=0):
98
"Parse a list of lines into a tuple of 3 lists (header,body,footer)."
99
in_header = newlines_in_header != 0
104
header_newlines_found = 0
108
header_newlines_found += 1
109
if header_newlines_found >= newlines_in_header:
114
if line.startswith('-------'):
120
# If the last body line is blank, drop it off the list
121
if len(body) > 0 and body[-1] == '':
123
return (header,body,footer)
125
def test_list_only(self):
126
# check that bzr selftest --list-only outputs no ui noise
127
def selftest(*args, **kwargs):
128
"""Capture the arguments selftest was run with."""
130
def outputs_nothing(cmdline):
131
out,err = self.run_bzr(cmdline)
132
(header,body,footer) = self._parse_test_list(out.splitlines())
133
num_tests = len(body)
134
self.assertLength(0, header)
135
self.assertLength(0, footer)
136
self.assertEqual('', err)
137
# Yes this prevents using threads to run the test suite in parallel,
138
# however we don't have a clean dependency injector for commands,
139
# and even if we did - we'd still be testing that the glue is wired
140
# up correctly. XXX: TODO: Solve this testing problem.
141
original_selftest = tests.selftest
142
tests.selftest = selftest
144
outputs_nothing('selftest --list-only')
145
outputs_nothing('selftest --list-only selftest')
146
outputs_nothing(['selftest', '--list-only', '--exclude', 'selftest'])
148
tests.selftest = original_selftest
150
def test_lsprof_tests(self):
151
params = self.get_params_passed_to_core('selftest --lsprof-tests')
152
self.assertEqual(True, params[1]["lsprof_tests"])
154
def test_parallel_fork_unsupported(self):
155
if getattr(os, "fork", None) is not None:
156
self.addCleanup(setattr, os, "fork", os.fork)
158
out, err = self.run_bzr(["selftest", "--parallel=fork", "-s", "bt.x"],
160
self.assertIn("platform does not support fork", err)
161
self.assertFalse(out)
added
removed
bzrlib/tests/blackbox/test_selftest.py
