13
13
# You should have received a copy of the GNU General Public License
14
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17
17
"""UI tests for the test framework."""
19
24
from bzrlib import (
27
from bzrlib.errors import ParamikoNotPresent
23
28
from bzrlib.tests import (
26
from bzrlib.transport import memory
30
def get_params_passed_to_core(self, cmdline):
32
def selftest(*args, **kwargs):
33
"""Capture the arguments selftest was run with."""
34
params.append((args, kwargs))
36
# Yes this prevents using threads to run the test suite in parallel,
37
# however we don't have a clean dependency injector for commands,
38
# and even if we did - we'd still be testing that the glue is wired
39
# up correctly. XXX: TODO: Solve this testing problem.
40
original_selftest = tests.selftest
41
tests.selftest = selftest
31
TestCaseWithMemoryTransport,
32
TestCaseWithTransport,
35
from bzrlib.tests.blackbox import ExternalBase
38
class TestOptions(TestCase):
42
def test_transport_set_to_sftp(self):
43
# test the --transport option has taken effect from within the
46
import bzrlib.transport.sftp
47
except ParamikoNotPresent:
48
raise TestSkipped("Paramiko not present")
49
if TestOptions.current_test != "test_transport_set_to_sftp":
51
self.assertEqual(bzrlib.transport.sftp.SFTPAbsoluteServer,
52
bzrlib.tests.default_transport)
54
def test_transport_set_to_memory(self):
55
# test the --transport option has taken effect from within the
57
import bzrlib.transport.memory
58
if TestOptions.current_test != "test_transport_set_to_memory":
60
self.assertEqual(bzrlib.transport.memory.MemoryServer,
61
bzrlib.tests.default_transport)
63
def test_transport(self):
64
# test that --transport=sftp works
66
import bzrlib.transport.sftp
67
except ParamikoNotPresent:
68
raise TestSkipped("Paramiko not present")
69
old_transport = bzrlib.tests.default_transport
70
old_root = TestCaseWithMemoryTransport.TEST_ROOT
71
TestCaseWithMemoryTransport.TEST_ROOT = None
73
TestOptions.current_test = "test_transport_set_to_sftp"
74
stdout = self.capture('selftest --transport=sftp test_transport_set_to_sftp')
76
self.assertContainsRe(stdout, 'Ran 1 test')
77
self.assertEqual(old_transport, bzrlib.tests.default_transport)
79
TestOptions.current_test = "test_transport_set_to_memory"
80
stdout = self.capture('selftest --transport=memory test_transport_set_to_memory')
81
self.assertContainsRe(stdout, 'Ran 1 test')
82
self.assertEqual(old_transport, bzrlib.tests.default_transport)
46
tests.selftest = original_selftest
49
class TestOptionsWritingToDisk(tests.TestCaseInTempDir, SelfTestPatch):
84
bzrlib.tests.default_transport = old_transport
85
TestOptions.current_test = None
86
TestCaseWithMemoryTransport.TEST_ROOT = old_root
89
class TestRunBzr(ExternalBase):
91
def run_bzr_captured(self, argv, retcode=0, encoding=None, stdin=None,
93
"""Override run_bzr_captured to test how it is invoked by run_bzr.
95
We test how run_bzr_captured actually invokes bzr in another location.
96
Here we only need to test that it is run_bzr passes the right
97
parameters to run_bzr_captured.
100
self.retcode = retcode
101
self.encoding = encoding
103
self.working_dir = working_dir
106
"""Test that run_bzr passes args correctly to run_bzr_captured"""
107
self.run_bzr('arg1', 'arg2', 'arg3', retcode=1)
108
self.assertEqual(('arg1', 'arg2', 'arg3'), self.argv)
110
def test_encoding(self):
111
"""Test that run_bzr passes encoding to run_bzr_captured"""
112
self.run_bzr('foo', 'bar')
113
self.assertEqual(None, self.encoding)
114
self.assertEqual(('foo', 'bar'), self.argv)
116
self.run_bzr('foo', 'bar', encoding='baz')
117
self.assertEqual('baz', self.encoding)
118
self.assertEqual(('foo', 'bar'), self.argv)
120
def test_retcode(self):
121
"""Test that run_bzr passes retcode to run_bzr_captured"""
122
# Default is retcode == 0
123
self.run_bzr('foo', 'bar')
124
self.assertEqual(0, self.retcode)
125
self.assertEqual(('foo', 'bar'), self.argv)
127
self.run_bzr('foo', 'bar', retcode=1)
128
self.assertEqual(1, self.retcode)
129
self.assertEqual(('foo', 'bar'), self.argv)
131
self.run_bzr('foo', 'bar', retcode=None)
132
self.assertEqual(None, self.retcode)
133
self.assertEqual(('foo', 'bar'), self.argv)
135
self.run_bzr('foo', 'bar', retcode=3)
136
self.assertEqual(3, self.retcode)
137
self.assertEqual(('foo', 'bar'), self.argv)
139
def test_stdin(self):
140
# test that the stdin keyword to run_bzr is passed through to
141
# run_bzr_captured as-is. We do this by overriding
142
# run_bzr_captured in this class, and then calling run_bzr,
143
# which is a convenience function for run_bzr_captured, so
145
self.run_bzr('foo', 'bar', stdin='gam')
146
self.assertEqual('gam', self.stdin)
147
self.assertEqual(('foo', 'bar'), self.argv)
149
self.run_bzr('foo', 'bar', stdin='zippy')
150
self.assertEqual('zippy', self.stdin)
151
self.assertEqual(('foo', 'bar'), self.argv)
153
def test_working_dir(self):
154
"""Test that run_bzr passes working_dir to run_bzr_captured"""
155
self.run_bzr('foo', 'bar')
156
self.assertEqual(None, self.working_dir)
157
self.assertEqual(('foo', 'bar'), self.argv)
159
self.run_bzr('foo', 'bar', working_dir='baz')
160
self.assertEqual('baz', self.working_dir)
161
self.assertEqual(('foo', 'bar'), self.argv)
164
class TestBenchmarkTests(TestCaseWithTransport):
51
166
def test_benchmark_runs_benchmark_tests(self):
52
"""selftest --benchmark should change the suite factory."""
53
params = self.get_params_passed_to_core('selftest --benchmark')
54
self.assertEqual(benchmarks.test_suite,
55
params[1]['test_suite_factory'])
56
self.assertNotEqual(None, params[1]['bench_history'])
167
"""bzr selftest --benchmark should not run the default test suite."""
168
# We test this by passing a regression test name to --benchmark, which
169
# should result in 0 rests run.
170
old_root = TestCaseWithMemoryTransport.TEST_ROOT
172
TestCaseWithMemoryTransport.TEST_ROOT = None
173
out, err = self.run_bzr('selftest', '--benchmark', 'workingtree_implementations')
175
TestCaseWithMemoryTransport.TEST_ROOT = old_root
176
self.assertContainsRe(out, 'Ran 0 tests.*\n\nOK')
57
180
benchfile = open(".perf_history", "rt")
59
182
lines = benchfile.readlines()
62
# Because we don't run the actual test code no output is made to the
64
self.assertEqual(0, len(lines))
67
class TestOptions(tests.TestCase, SelfTestPatch):
69
def test_load_list(self):
70
params = self.get_params_passed_to_core('selftest --load-list foo')
71
self.assertEqual('foo', params[1]['load_list'])
73
def test_transport_set_to_sftp(self):
74
# Test that we can pass a transport to the selftest core - sftp
76
self.requireFeature(features.paramiko)
77
from bzrlib.tests import stub_sftp
78
params = self.get_params_passed_to_core('selftest --transport=sftp')
79
self.assertEqual(stub_sftp.SFTPAbsoluteServer,
80
params[1]["transport"])
82
def test_transport_set_to_memory(self):
83
# Test that we can pass a transport to the selftest core - memory
85
params = self.get_params_passed_to_core('selftest --transport=memory')
86
self.assertEqual(memory.MemoryServer, params[1]["transport"])
88
def test_parameters_passed_to_core(self):
89
params = self.get_params_passed_to_core('selftest --list-only')
90
self.assertTrue("list_only" in params[1])
91
params = self.get_params_passed_to_core('selftest --list-only selftest')
92
self.assertTrue("list_only" in params[1])
93
params = self.get_params_passed_to_core(['selftest', '--list-only',
94
'--exclude', 'selftest'])
95
self.assertTrue("list_only" in params[1])
96
params = self.get_params_passed_to_core(['selftest', '--list-only',
97
'selftest', '--randomize', 'now'])
98
self.assertSubset(["list_only", "random_seed"], params[1])
100
def test_starting_with(self):
101
params = self.get_params_passed_to_core('selftest --starting-with foo')
102
self.assertEqual(['foo'], params[1]['starting_with'])
104
def test_starting_with_multiple_argument(self):
105
params = self.get_params_passed_to_core(
106
'selftest --starting-with foo --starting-with bar')
107
self.assertEqual(['foo', 'bar'], params[1]['starting_with'])
109
def test_subunit(self):
110
self.requireFeature(features.subunit)
111
params = self.get_params_passed_to_core('selftest --subunit')
112
self.assertEqual(tests.SubUnitBzrRunner, params[1]['runner_class'])
114
def _parse_test_list(self, lines, newlines_in_header=0):
115
"Parse a list of lines into a tuple of 3 lists (header,body,footer)."
116
in_header = newlines_in_header != 0
121
header_newlines_found = 0
125
header_newlines_found += 1
126
if header_newlines_found >= newlines_in_header:
131
if line.startswith('-------'):
137
# If the last body line is blank, drop it off the list
138
if len(body) > 0 and body[-1] == '':
140
return (header,body,footer)
142
def test_list_only(self):
143
# check that bzr selftest --list-only outputs no ui noise
144
def selftest(*args, **kwargs):
145
"""Capture the arguments selftest was run with."""
147
def outputs_nothing(cmdline):
148
out,err = self.run_bzr(cmdline)
149
(header,body,footer) = self._parse_test_list(out.splitlines())
150
num_tests = len(body)
151
self.assertLength(0, header)
152
self.assertLength(0, footer)
153
self.assertEqual('', err)
154
# Yes this prevents using threads to run the test suite in parallel,
155
# however we don't have a clean dependency injector for commands,
156
# and even if we did - we'd still be testing that the glue is wired
157
# up correctly. XXX: TODO: Solve this testing problem.
158
original_selftest = tests.selftest
159
tests.selftest = selftest
185
self.assertEqual(1, len(lines))
186
self.assertContainsRe(lines[0], "--date [0-9.]+")
189
class TestRunBzrCaptured(ExternalBase):
191
def apply_redirected(self, stdin=None, stdout=None, stderr=None,
192
a_callable=None, *args, **kwargs):
194
self.factory_stdin = getattr(bzrlib.ui.ui_factory, "stdin", None)
195
self.factory = bzrlib.ui.ui_factory
196
self.working_dir = osutils.getcwd()
197
stdout.write('foo\n')
198
stderr.write('bar\n')
201
def test_stdin(self):
202
# test that the stdin keyword to run_bzr_captured is passed through to
203
# apply_redirected as a StringIO. We do this by overriding
204
# apply_redirected in this class, and then calling run_bzr_captured,
205
# which calls apply_redirected.
206
self.run_bzr_captured(['foo', 'bar'], stdin='gam')
207
self.assertEqual('gam', self.stdin.read())
208
self.assertTrue(self.stdin is self.factory_stdin)
209
self.run_bzr_captured(['foo', 'bar'], stdin='zippy')
210
self.assertEqual('zippy', self.stdin.read())
211
self.assertTrue(self.stdin is self.factory_stdin)
213
def test_ui_factory(self):
214
# each invocation of self.run_bzr_captured should get its own UI
215
# factory, which is an instance of TestUIFactory, with stdout and
216
# stderr attached to the stdout and stderr of the invoked
218
current_factory = bzrlib.ui.ui_factory
219
self.run_bzr_captured(['foo'])
220
self.failIf(current_factory is self.factory)
221
self.assertNotEqual(sys.stdout, self.factory.stdout)
222
self.assertNotEqual(sys.stderr, self.factory.stderr)
223
self.assertEqual('foo\n', self.factory.stdout.getvalue())
224
self.assertEqual('bar\n', self.factory.stderr.getvalue())
225
self.assertIsInstance(self.factory, bzrlib.tests.blackbox.TestUIFactory)
227
def test_working_dir(self):
228
self.build_tree(['one/', 'two/'])
229
cwd = osutils.getcwd()
231
# Default is to work in the current directory
232
self.run_bzr_captured(['foo', 'bar'])
233
self.assertEqual(cwd, self.working_dir)
235
self.run_bzr_captured(['foo', 'bar'], working_dir=None)
236
self.assertEqual(cwd, self.working_dir)
238
# The function should be run in the alternative directory
239
# but afterwards the current working dir shouldn't be changed
240
self.run_bzr_captured(['foo', 'bar'], working_dir='one')
241
self.assertNotEqual(cwd, self.working_dir)
242
self.assertEndsWith(self.working_dir, 'one')
243
self.assertEqual(cwd, osutils.getcwd())
245
self.run_bzr_captured(['foo', 'bar'], working_dir='two')
246
self.assertNotEqual(cwd, self.working_dir)
247
self.assertEndsWith(self.working_dir, 'two')
248
self.assertEqual(cwd, osutils.getcwd())
251
class TestRunBzrSubprocess(TestCaseWithTransport):
253
def test_run_bzr_subprocess(self):
254
"""The run_bzr_helper_external comand behaves nicely."""
255
result = self.run_bzr_subprocess('--version')
256
result = self.run_bzr_subprocess('--version', retcode=None)
257
self.assertContainsRe(result[0], 'is free software')
258
self.assertRaises(AssertionError, self.run_bzr_subprocess,
260
result = self.run_bzr_subprocess('--versionn', retcode=3)
261
result = self.run_bzr_subprocess('--versionn', retcode=None)
262
self.assertContainsRe(result[1], 'unknown command')
263
err = self.run_bzr_subprocess('merge', '--merge-type', 'magic merge',
265
self.assertContainsRe(err, 'No known merge type magic merge')
267
def test_run_bzr_subprocess_env(self):
268
"""run_bzr_subprocess can set environment variables in the child only.
270
These changes should not change the running process, only the child.
272
# The test suite should unset this variable
273
self.assertEqual(None, os.environ.get('BZR_EMAIL'))
274
out, err = self.run_bzr_subprocess('whoami', env_changes={
275
'BZR_EMAIL':'Joe Foo <joe@foo.com>'
276
}, universal_newlines=True)
277
self.assertEqual('', err)
278
self.assertEqual('Joe Foo <joe@foo.com>\n', out)
279
# And it should not be modified
280
self.assertEqual(None, os.environ.get('BZR_EMAIL'))
282
# Do it again with a different address, just to make sure
283
# it is actually changing
284
out, err = self.run_bzr_subprocess('whoami', env_changes={
285
'BZR_EMAIL':'Barry <bar@foo.com>'
286
}, universal_newlines=True)
287
self.assertEqual('', err)
288
self.assertEqual('Barry <bar@foo.com>\n', out)
289
self.assertEqual(None, os.environ.get('BZR_EMAIL'))
291
def test_run_bzr_subprocess_env_del(self):
292
"""run_bzr_subprocess can remove environment variables too."""
293
# Create a random email, so we are sure this won't collide
294
rand_bzr_email = 'John Doe <jdoe@%s.com>' % (osutils.rand_chars(20),)
295
rand_email = 'Jane Doe <jdoe@%s.com>' % (osutils.rand_chars(20),)
296
os.environ['BZR_EMAIL'] = rand_bzr_email
297
os.environ['EMAIL'] = rand_email
161
outputs_nothing('selftest --list-only')
162
outputs_nothing('selftest --list-only selftest')
163
outputs_nothing(['selftest', '--list-only', '--exclude', 'selftest'])
299
# By default, the child will inherit the current env setting
300
out, err = self.run_bzr_subprocess('whoami', universal_newlines=True)
301
self.assertEqual('', err)
302
self.assertEqual(rand_bzr_email + '\n', out)
304
# Now that BZR_EMAIL is not set, it should fall back to EMAIL
305
out, err = self.run_bzr_subprocess('whoami',
306
env_changes={'BZR_EMAIL':None},
307
universal_newlines=True)
308
self.assertEqual('', err)
309
self.assertEqual(rand_email + '\n', out)
311
# This switches back to the default email guessing logic
312
# Which shouldn't match either of the above addresses
313
out, err = self.run_bzr_subprocess('whoami',
314
env_changes={'BZR_EMAIL':None, 'EMAIL':None},
315
universal_newlines=True)
317
self.assertEqual('', err)
318
self.assertNotEqual(rand_bzr_email + '\n', out)
319
self.assertNotEqual(rand_email + '\n', out)
165
tests.selftest = original_selftest
167
def test_lsprof_tests(self):
168
params = self.get_params_passed_to_core('selftest --lsprof-tests')
169
self.assertEqual(True, params[1]["lsprof_tests"])
321
# TestCase cleans up BZR_EMAIL, and EMAIL at startup
322
del os.environ['BZR_EMAIL']
323
del os.environ['EMAIL']
325
def test_run_bzr_subprocess_env_del_missing(self):
326
"""run_bzr_subprocess won't fail if deleting a nonexistant env var"""
327
self.failIf('NON_EXISTANT_ENV_VAR' in os.environ)
328
out, err = self.run_bzr_subprocess('rocks',
329
env_changes={'NON_EXISTANT_ENV_VAR':None},
330
universal_newlines=True)
331
self.assertEqual('it sure does!\n', out)
332
self.assertEqual('', err)
334
def test_run_bzr_subprocess_working_dir(self):
335
"""Test that we can specify the working dir for the child"""
336
cwd = osutils.getcwd()
338
self.make_branch_and_tree('.')
339
self.make_branch_and_tree('one')
340
self.make_branch_and_tree('two')
342
def get_root(**kwargs):
343
"""Spawn a process to get the 'root' of the tree.
345
You can pass in arbitrary new arguments. This just makes
346
sure that the returned path doesn't have trailing whitespace.
348
return self.run_bzr_subprocess('root', **kwargs)[0].rstrip()
350
self.assertEqual(cwd, get_root())
351
self.assertEqual(cwd, get_root(working_dir=None))
352
# Has our path changed?
353
self.assertEqual(cwd, osutils.getcwd())
355
dir1 = get_root(working_dir='one')
356
self.assertEndsWith(dir1, 'one')
357
self.assertEqual(cwd, osutils.getcwd())
359
dir2 = get_root(working_dir='two')
360
self.assertEndsWith(dir2, 'two')
361
self.assertEqual(cwd, osutils.getcwd())
364
class _DontSpawnProcess(Exception):
365
"""A simple exception which just allows us to skip unnecessary steps"""
368
class TestRunBzrSubprocessCommands(TestCaseWithTransport):
370
def _popen(self, *args, **kwargs):
371
"""Record the command that is run, so that we can ensure it is correct"""
372
self._popen_args = args
373
self._popen_kwargs = kwargs
374
raise _DontSpawnProcess()
376
def test_run_bzr_subprocess_no_plugins(self):
377
self.assertRaises(_DontSpawnProcess, self.run_bzr_subprocess)
378
command = self._popen_args[0]
379
self.assertEqual(sys.executable, command[0])
380
self.assertEqual(self.get_bzr_path(), command[1])
381
self.assertEqual(['--no-plugins'], command[2:])
383
def test_allow_plugins(self):
384
self.assertRaises(_DontSpawnProcess,
385
self.run_bzr_subprocess, allow_plugins=True)
386
command = self._popen_args[0]
387
self.assertEqual([], command[2:])
390
class TestBzrSubprocess(TestCaseWithTransport):
392
def test_start_and_stop_bzr_subprocess(self):
393
"""We can start and perform other test actions while that process is
396
process = self.start_bzr_subprocess(['--version'])
397
result = self.finish_bzr_subprocess(process)
398
self.assertContainsRe(result[0], 'is free software')
399
self.assertEqual('', result[1])
401
def test_start_and_stop_bzr_subprocess_with_error(self):
402
"""finish_bzr_subprocess allows specification of the desired exit code.
404
process = self.start_bzr_subprocess(['--versionn'])
405
result = self.finish_bzr_subprocess(process, retcode=3)
406
self.assertEqual('', result[0])
407
self.assertContainsRe(result[1], 'unknown command')
409
def test_start_and_stop_bzr_subprocess_ignoring_retcode(self):
410
"""finish_bzr_subprocess allows the exit code to be ignored."""
411
process = self.start_bzr_subprocess(['--versionn'])
412
result = self.finish_bzr_subprocess(process, retcode=None)
413
self.assertEqual('', result[0])
414
self.assertContainsRe(result[1], 'unknown command')
416
def test_start_and_stop_bzr_subprocess_with_unexpected_retcode(self):
417
"""finish_bzr_subprocess raises self.failureException if the retcode is
418
not the expected one.
420
process = self.start_bzr_subprocess(['--versionn'])
421
self.assertRaises(self.failureException, self.finish_bzr_subprocess,
424
def test_start_and_stop_bzr_subprocess_send_signal(self):
425
"""finish_bzr_subprocess raises self.failureException if the retcode is
426
not the expected one.
428
process = self.start_bzr_subprocess(['wait-until-signalled'],
429
skip_if_plan_to_signal=True)
430
self.assertEqual('running\n', process.stdout.readline())
431
result = self.finish_bzr_subprocess(process, send_signal=signal.SIGINT,
433
self.assertEqual('', result[0])
434
self.assertEqual('bzr: interrupted\n', result[1])
436
def test_start_and_stop_working_dir(self):
437
cwd = osutils.getcwd()
439
self.make_branch_and_tree('one')
441
process = self.start_bzr_subprocess(['root'], working_dir='one')
442
result = self.finish_bzr_subprocess(process, universal_newlines=True)
443
self.assertEndsWith(result[0], 'one\n')
444
self.assertEqual('', result[1])
447
class TestRunBzrError(ExternalBase):
449
def test_run_bzr_error(self):
450
out, err = self.run_bzr_error(['^$'], 'rocks', retcode=0)
451
self.assertEqual(out, 'it sure does!\n')
453
out, err = self.run_bzr_error(["bzr: ERROR: foobarbaz is not versioned"],
454
'file-id', 'foobarbaz')
457
class TestSelftestCleanOutput(TestCaseInTempDir):
459
def test_clean_output(self):
460
# check that 'bzr selftest --clean-output' works correct
461
dirs = ('test0000.tmp', 'test0001.tmp', 'bzrlib', 'tests')
462
files = ('bzr', 'setup.py', 'test9999.tmp')
467
f.write('content of ')
472
before = os.listdir(root)
474
self.assertEquals(['bzr','bzrlib','setup.py',
475
'test0000.tmp','test0001.tmp',
476
'test9999.tmp','tests'],
479
out,err = self.run_bzr_captured(['selftest','--clean-output'],
482
self.assertEquals(['delete directory: test0000.tmp',
483
'delete directory: test0001.tmp'],
484
sorted(out.splitlines()))
485
self.assertEquals('', err)
487
after = os.listdir(root)
489
self.assertEquals(['bzr','bzrlib','setup.py',
490
'test9999.tmp','tests'],
added
removed
bzrlib/tests/blackbox/test_selftest.py
