def setUp(self):
super(TestProcessorFixture, self).setUp()
variable_regex = '\$(IDOPTION|IDFILE|IDLIST|LISTOPT)'
variables = {}
list_variables = {'LISTOPT': self.listopt}
cmd = self.template
default_idstr = None
def list_subst(match):
return list_variables.get(match.groups(1)[0], '')
self.list_cmd = re.sub(variable_regex, list_subst, cmd)
nonparallel = not self.parallel
selection_logic = (self.test_filters or self.blacklist_file
or self.whitelist_file or self.black_regex)
if nonparallel:
self.concurrency = 1
else:
self.concurrency = None
if self.concurrency_value:
self.concurrency = int(self.concurrency_value)
if not self.concurrency:
self.concurrency = scheduler.local_concurrency()
if not self.concurrency:
self.concurrency = 1
if self.test_ids is None:
if self.concurrency == 1:
if default_idstr:
self.test_ids = default_idstr.split()
if self.concurrency != 1 or selection_logic or self.worker_path:
# Have to be able to tell each worker what to run / filter
# tests.
self.test_ids = self.list_tests()
if self.test_ids is None:
# No test ids to supply to the program.
self.list_file_name = None
name = ''
idlist = ''
else:
self.test_ids = selection.construct_list(
self.test_ids,
blacklist_file=self.blacklist_file,
whitelist_file=self.whitelist_file,
regexes=self.test_filters,
black_regex=self.black_regex)
name = self.make_listfile()
variables['IDFILE'] = name
idlist = ' '.join(self.test_ids)
variables['IDLIST'] = idlist
def subst(match):
return variables.get(match.groups(1)[0], '')
if self.test_ids is None:
# No test ids, no id option.
idoption = ''
else:
idoption = re.sub(variable_regex, subst, self.idoption)
variables['IDOPTION'] = idoption
self.cmd = re.sub(variable_regex, subst, cmd)
def test_inclusion_list(self):
include_list = [re.compile('fake_test1'), re.compile('fake_test2')]
test_lists = ['fake_test1[tg]', 'fake_test2[tg]', 'fake_test3[tg]']
include_getter = 'stestr.selection._get_regex_from_include_list'
with mock.patch(include_getter, return_value=include_list):
result = selection.construct_list(test_lists, include_list='file')
self.assertEqual(set(result), {'fake_test1[tg]', 'fake_test2[tg]'})
def test_whitelist(self):
white_list = [re.compile('fake_test1'), re.compile('fake_test2')]
test_lists = ['fake_test1[tg]', 'fake_test2[tg]', 'fake_test3[tg]']
white_getter = 'stestr.selection._get_regex_from_whitelist_file'
with mock.patch(white_getter, return_value=white_list):
result = selection.construct_list(test_lists,
whitelist_file='file')
self.assertEqual(set(result), {'fake_test1[tg]', 'fake_test2[tg]'})
def test_precedence_black_re_vs_exclude_re(self):
test_lists = ['fake_test(scen)[tag,bar])', 'fake_test(scen)[egg,foo])']
result = selection.construct_list(test_lists,
exclude_regex='foo',
black_regex='bar')
# When both options are used together, 'exclude_regex'
# is respected while 'black_regex' is ignored!
self.assertEqual(list(result), ['fake_test(scen)[tag,bar])'])
def test_exclusion_list(self):
exclude_list = [(re.compile('foo'), 'foo not liked', [])]
test_lists = ['fake_test(scen)[tag,bar])', 'fake_test(scen)[egg,foo])']
with mock.patch('stestr.selection.exclusion_reader',
return_value=exclude_list):
result = selection.construct_list(test_lists,
exclude_list='file',
regexes=['fake_test'])
self.assertEqual(list(result), ['fake_test(scen)[tag,bar])'])
def test_whitelist_blacklist_re(self):
white_list = [re.compile('fake_test1'), re.compile('fake_test2')]
test_lists = [
'fake_test1[tg]', 'fake_test2[spam]', 'fake_test3[tg,foo]',
'fake_test4[spam]'
]
black_list = [(re.compile('spam'), 'spam not liked', [])]
white_getter = 'stestr.selection._get_regex_from_whitelist_file'
with mock.patch(white_getter, return_value=white_list):
with mock.patch('stestr.selection.black_reader',
return_value=black_list):
result = selection.construct_list(test_lists, 'black_file',
'white_file', ['foo'])
self.assertEqual(set(result), {'fake_test1[tg]', 'fake_test3[tg,foo]'})
def test_inclusion_exclusion_list_re(self):
include_list = [re.compile('fake_test1'), re.compile('fake_test2')]
test_lists = ['fake_test1[tg]', 'fake_test2[spam]',
'fake_test3[tg,foo]', 'fake_test4[spam]']
exclude_list = [(re.compile('spam'), 'spam not liked', [])]
include_getter = 'stestr.selection._get_regex_from_include_list'
with mock.patch(include_getter,
return_value=include_list):
with mock.patch('stestr.selection.exclusion_reader',
return_value=exclude_list):
result = selection.construct_list(
test_lists, exclude_list='exclude_file',
include_list='include_file', regexes=['foo'])
self.assertEqual(set(result),
{'fake_test1[tg]', 'fake_test3[tg,foo]'})
def test_overlapping_exclude_regex(self):
exclude_list = [(re.compile('compute.test_keypairs.KeypairsTestV210'),
'', []),
(re.compile('compute.test_keypairs.KeypairsTestV21'),
'', [])]
test_lists = [
'compute.test_keypairs.KeypairsTestV210.test_create_keypair',
'compute.test_keypairs.KeypairsTestV21.test_create_keypair',
'compute.test_fake.FakeTest.test_fake_test']
with mock.patch('stestr.selection.exclusion_reader',
return_value=exclude_list):
result = selection.construct_list(test_lists,
exclude_list='file',
regexes=['fake_test'])
self.assertEqual(
list(result), ['compute.test_fake.FakeTest.test_fake_test'])
def test_precedence_whitelist_vs_include_list(self):
test_lists = ['fake_test1[tg]', 'fake_test2[tg]', 'fake_test3[tg]']
# New option --include-list to be passed -> should be used
include_file = open('include_file.txt', 'w')
include_file.write('fake_test1\nfake_test2')
include_file.close()
# Old option --whitelist-file to be passed -> should be ignored
whitelist_file = open('whitelist_file.txt', 'w')
whitelist_file.write('fake_test3')
whitelist_file.close()
result = selection.construct_list(test_lists,
include_list='include_file.txt',
whitelist_file='whitelist_file.txt')
self.assertEqual({'fake_test1[tg]', 'fake_test2[tg]'}, set(result))
# Cleanup
os.remove('include_file.txt')
os.remove('whitelist_file.txt')
def test_precedence_blacklist_vs_exclude_list(self):
test_lists = ['fake_test(scen)[tag,bar])', 'fake_test(scen)[egg,foo])']
# New option --exclude-list to be passed -> should be used
exclude_file = open('exclude_file.txt', 'w')
exclude_file.write("foo\nfoo not liked")
exclude_file.close()
# Old option --blacklist-file to be passed -> should be ignored
black_file = open('black_file.txt', 'w')
black_file.write("bar\nbar not liked")
black_file.close()
result = selection.construct_list(test_lists,
exclude_list='exclude_file.txt',
blacklist_file='black_file.txt',
regexes=['fake_test'])
self.assertEqual(list(result), ['fake_test(scen)[tag,bar])'])
# Cleanup
os.remove('exclude_file.txt')
os.remove('black_file.txt')
def test_simple_exclusion_re(self):
test_lists = ['fake_test(scen)[tag,bar])', 'fake_test(scen)[egg,foo])']
result = selection.construct_list(test_lists, exclude_regex='foo')
self.assertEqual(list(result), ['fake_test(scen)[tag,bar])'])
