92
89
class TestRunBzr(ExternalBase):
94
def _run_bzr_core(self, argv, retcode=0, encoding=None, stdin=None,
91
def run_bzr_captured(self, argv, retcode=0, encoding=None, stdin=None,
96
"""Override _run_bzr_core to test how it is invoked by run_bzr.
98
Attempts to run bzr from inside this class don't actually run it.
100
We test how run_bzr actually invokes bzr in another location.
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.
101
96
Here we only need to test that it is run_bzr passes the right
102
parameters to run_bzr.
97
parameters to run_bzr_captured.
104
self.argv = list(argv)
105
100
self.retcode = retcode
106
101
self.encoding = encoding
107
102
self.stdin = stdin
108
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)
111
110
def test_encoding(self):
112
"""Test that run_bzr passes encoding to _run_bzr_core"""
113
self.run_bzr('foo bar')
111
"""Test that run_bzr passes encoding to run_bzr_captured"""
112
self.run_bzr('foo', 'bar')
114
113
self.assertEqual(None, self.encoding)
115
self.assertEqual(['foo', 'bar'], self.argv)
114
self.assertEqual(('foo', 'bar'), self.argv)
117
self.run_bzr('foo bar', encoding='baz')
116
self.run_bzr('foo', 'bar', encoding='baz')
118
117
self.assertEqual('baz', self.encoding)
119
self.assertEqual(['foo', 'bar'], self.argv)
118
self.assertEqual(('foo', 'bar'), self.argv)
121
120
def test_retcode(self):
122
"""Test that run_bzr passes retcode to _run_bzr_core"""
121
"""Test that run_bzr passes retcode to run_bzr_captured"""
123
122
# Default is retcode == 0
124
self.run_bzr('foo bar')
123
self.run_bzr('foo', 'bar')
125
124
self.assertEqual(0, self.retcode)
126
self.assertEqual(['foo', 'bar'], self.argv)
125
self.assertEqual(('foo', 'bar'), self.argv)
128
self.run_bzr('foo bar', retcode=1)
127
self.run_bzr('foo', 'bar', retcode=1)
129
128
self.assertEqual(1, self.retcode)
130
self.assertEqual(['foo', 'bar'], self.argv)
129
self.assertEqual(('foo', 'bar'), self.argv)
132
self.run_bzr('foo bar', retcode=None)
131
self.run_bzr('foo', 'bar', retcode=None)
133
132
self.assertEqual(None, self.retcode)
134
self.assertEqual(['foo', 'bar'], self.argv)
133
self.assertEqual(('foo', 'bar'), self.argv)
136
self.run_bzr(['foo', 'bar'], retcode=3)
135
self.run_bzr('foo', 'bar', retcode=3)
137
136
self.assertEqual(3, self.retcode)
138
self.assertEqual(['foo', 'bar'], self.argv)
137
self.assertEqual(('foo', 'bar'), self.argv)
140
139
def test_stdin(self):
141
140
# test that the stdin keyword to run_bzr is passed through to
142
# _run_bzr_core as-is. We do this by overriding
143
# _run_bzr_core in this class, and then calling run_bzr,
144
# which is a convenience function for _run_bzr_core, so
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
144
# should invoke it.
146
self.run_bzr('foo bar', stdin='gam')
145
self.run_bzr('foo', 'bar', stdin='gam')
147
146
self.assertEqual('gam', self.stdin)
148
self.assertEqual(['foo', 'bar'], self.argv)
147
self.assertEqual(('foo', 'bar'), self.argv)
150
self.run_bzr('foo bar', stdin='zippy')
149
self.run_bzr('foo', 'bar', stdin='zippy')
151
150
self.assertEqual('zippy', self.stdin)
152
self.assertEqual(['foo', 'bar'], self.argv)
151
self.assertEqual(('foo', 'bar'), self.argv)
154
153
def test_working_dir(self):
155
"""Test that run_bzr passes working_dir to _run_bzr_core"""
156
self.run_bzr('foo bar')
154
"""Test that run_bzr passes working_dir to run_bzr_captured"""
155
self.run_bzr('foo', 'bar')
157
156
self.assertEqual(None, self.working_dir)
158
self.assertEqual(['foo', 'bar'], self.argv)
157
self.assertEqual(('foo', 'bar'), self.argv)
160
self.run_bzr('foo bar', working_dir='baz')
159
self.run_bzr('foo', 'bar', working_dir='baz')
161
160
self.assertEqual('baz', self.working_dir)
162
self.assertEqual(['foo', 'bar'], self.argv)
164
def test_reject_extra_keyword_arguments(self):
165
self.assertRaises(TypeError, self.run_bzr, "foo bar",
166
error_regex=['error message'])
161
self.assertEqual(('foo', 'bar'), self.argv)
169
164
class TestBenchmarkTests(TestCaseWithTransport):
207
201
def test_stdin(self):
208
# test that the stdin keyword to _run_bzr_core is passed through to
202
# test that the stdin keyword to run_bzr_captured is passed through to
209
203
# apply_redirected as a StringIO. We do this by overriding
210
# apply_redirected in this class, and then calling _run_bzr_core,
204
# apply_redirected in this class, and then calling run_bzr_captured,
211
205
# which calls apply_redirected.
212
self.run_bzr(['foo', 'bar'], stdin='gam')
206
self.run_bzr_captured(['foo', 'bar'], stdin='gam')
213
207
self.assertEqual('gam', self.stdin.read())
214
208
self.assertTrue(self.stdin is self.factory_stdin)
215
self.run_bzr(['foo', 'bar'], stdin='zippy')
209
self.run_bzr_captured(['foo', 'bar'], stdin='zippy')
216
210
self.assertEqual('zippy', self.stdin.read())
217
211
self.assertTrue(self.stdin is self.factory_stdin)
219
213
def test_ui_factory(self):
220
# each invocation of self.run_bzr should get its
221
# own UI factory, which is an instance of TestUIFactory,
222
# with stdin, stdout and stderr attached to the stdin,
223
# stdout and stderr of the invoked run_bzr
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
224
218
current_factory = bzrlib.ui.ui_factory
225
self.run_bzr(['foo'])
219
self.run_bzr_captured(['foo'])
226
220
self.failIf(current_factory is self.factory)
227
221
self.assertNotEqual(sys.stdout, self.factory.stdout)
228
222
self.assertNotEqual(sys.stderr, self.factory.stderr)
229
223
self.assertEqual('foo\n', self.factory.stdout.getvalue())
230
224
self.assertEqual('bar\n', self.factory.stderr.getvalue())
231
self.assertIsInstance(self.factory, TestUIFactory)
225
self.assertIsInstance(self.factory, bzrlib.tests.blackbox.TestUIFactory)
233
227
def test_working_dir(self):
234
228
self.build_tree(['one/', 'two/'])
235
229
cwd = osutils.getcwd()
237
231
# Default is to work in the current directory
238
self.run_bzr(['foo', 'bar'])
232
self.run_bzr_captured(['foo', 'bar'])
239
233
self.assertEqual(cwd, self.working_dir)
241
self.run_bzr(['foo', 'bar'], working_dir=None)
235
self.run_bzr_captured(['foo', 'bar'], working_dir=None)
242
236
self.assertEqual(cwd, self.working_dir)
244
238
# The function should be run in the alternative directory
245
239
# but afterwards the current working dir shouldn't be changed
246
self.run_bzr(['foo', 'bar'], working_dir='one')
240
self.run_bzr_captured(['foo', 'bar'], working_dir='one')
247
241
self.assertNotEqual(cwd, self.working_dir)
248
242
self.assertEndsWith(self.working_dir, 'one')
249
243
self.assertEqual(cwd, osutils.getcwd())
251
self.run_bzr(['foo', 'bar'], working_dir='two')
245
self.run_bzr_captured(['foo', 'bar'], working_dir='two')
252
246
self.assertNotEqual(cwd, self.working_dir)
253
247
self.assertEndsWith(self.working_dir, 'two')
254
248
self.assertEqual(cwd, osutils.getcwd())
455
447
class TestRunBzrError(ExternalBase):
457
449
def test_run_bzr_error(self):
458
# retcode=0 is specially needed here because run_bzr_error expects
459
# an error (oddly enough) but we want to test the case of not
460
# actually getting one
461
out, err = self.run_bzr_error(['^$'], ['rocks'], retcode=0)
462
self.assertEqual(out, 'It sure does!\n')
463
# now test actually getting an error
464
out, err = self.run_bzr_error(
465
["bzr: ERROR: foobarbaz is not versioned"],
466
['file-id', 'foobarbaz'])
469
class TestSelftestListOnly(TestCase):
472
def _parse_test_list(lines, newlines_in_header=1):
473
"Parse a list of lines into a tuple of 3 lists (header,body,footer)."
479
header_newlines_found = 0
483
header_newlines_found += 1
484
if header_newlines_found >= newlines_in_header:
489
if line.startswith('-------'):
495
# If the last body line is blank, drop it off the list
496
if len(body) > 0 and body[-1] == '':
498
return (header,body,footer)
500
def test_list_only(self):
501
# check that bzr selftest --list-only works correctly
502
out,err = self.run_bzr('selftest selftest --list-only')
503
self.assertEndsWith(err, 'tests passed\n')
504
(header,body,footer) = self._parse_test_list(out.splitlines())
505
num_tests = len(body)
506
self.assertContainsRe(footer[0], 'Listed %s tests in' % num_tests)
508
def test_list_only_filtered(self):
509
# check that a filtered --list-only works, both include and exclude
510
out_all,err_all = self.run_bzr('selftest --list-only')
511
tests_all = self._parse_test_list(out_all.splitlines())[1]
512
out_incl,err_incl = self.run_bzr('selftest --list-only selftest')
513
tests_incl = self._parse_test_list(out_incl.splitlines())[1]
514
self.assertSubset(tests_incl, tests_all)
515
out_excl,err_excl = self.run_bzr(['selftest', '--list-only',
516
'--exclude', 'selftest'])
517
tests_excl = self._parse_test_list(out_excl.splitlines())[1]
518
self.assertSubset(tests_excl, tests_all)
519
set_incl = set(tests_incl)
520
set_excl = set(tests_excl)
521
intersection = set_incl.intersection(set_excl)
522
self.assertEquals(0, len(intersection))
523
self.assertEquals(len(tests_all), len(tests_incl) + len(tests_excl))
525
def test_list_only_random(self):
526
# check that --randomize works correctly
527
out_all,err_all = self.run_bzr('selftest --list-only selftest')
528
tests_all = self._parse_test_list(out_all.splitlines())[1]
529
# XXX: It looks like there are some orders for generating tests that
530
# fail as of 20070504 - maybe because of import order dependencies.
531
# So unfortunately this will rarely intermittently fail at the moment.
533
out_rand,err_rand = self.run_bzr(['selftest', '--list-only',
534
'selftest', '--randomize', 'now'])
535
(header_rand,tests_rand,dummy) = self._parse_test_list(
536
out_rand.splitlines(), 2)
537
# XXX: The following line asserts that the randomized order is not the
538
# same as the default order. It is just possible that they'll get
539
# randomized into the same order and this will falsely fail, but
540
# that's very unlikely in practice because there are thousands of
542
self.assertNotEqual(tests_all, tests_rand)
543
self.assertEqual(sorted(tests_all), sorted(tests_rand))
544
# Check that the seed can be reused to get the exact same order
545
seed_re = re.compile('Randomizing test order using seed (\w+)')
546
match_obj = seed_re.search(header_rand[-1])
547
seed = match_obj.group(1)
548
out_rand2,err_rand2 = self.run_bzr(['selftest', '--list-only',
549
'selftest', '--randomize', seed])
550
(header_rand2,tests_rand2,dummy) = self._parse_test_list(
551
out_rand2.splitlines(), 2)
552
self.assertEqual(tests_rand, tests_rand2)
555
class TestSelftestWithIdList(TestCaseInTempDir):
557
def test_load_list(self):
558
# We don't want to call selftest for the whole suite, so we start with
560
test_list_fname = 'test.list'
561
fl = open(test_list_fname, 'wt')
562
fl.write('%s\n' % self.id())
564
out, err = self.run_bzr(
565
['selftest', '--load-list', test_list_fname, '--list'])
566
self.assertContainsRe(out, "Listed 1 test in")
568
def test_load_unknown(self):
569
out, err = self.run_bzr('selftest --load-list I_do_not_exist ',
573
class TestSelftestStartingWith(TestCase):
575
def test_starting_with(self):
576
out, err = self.run_bzr(
577
['selftest', '--starting-with', self.id(), '--list'])
578
self.assertContainsRe(out, "Listed 1 test in")
579
self.assertContainsRe(out, self.id())
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
