d533445b26
This commit fixes a couple of bugs in the blacklist file regex generator. The first where a comment line was accidently made mandatory. If a comment wasn't specified an IndexError would be raised. The second was related to the variable naming in the function's blacklist file if branch. Variable reuse there was causing the last blacklist regex to take precendence over a regex passed in and would be used instead. Change-Id: Ib80a0c1781db7c8c9e4449b4773258fe3348411a Closes-Bug: #1488700
226 lines
8.7 KiB
Python
226 lines
8.7 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
"""
|
|
test_os_testr
|
|
----------------------------------
|
|
|
|
Tests for `os_testr` module.
|
|
"""
|
|
|
|
import mock
|
|
import six
|
|
|
|
from os_testr import os_testr
|
|
from os_testr.tests import base
|
|
|
|
|
|
class TestPathToRegex(base.TestCase):
|
|
|
|
def test_file_name(self):
|
|
result = os_testr.path_to_regex("tests/network/v2/test_net.py")
|
|
self.assertEqual("tests.network.v2.test_net", result)
|
|
result = os_testr.path_to_regex("openstack/tests/network/v2")
|
|
self.assertEqual("openstack.tests.network.v2", result)
|
|
|
|
|
|
class TestGetParser(base.TestCase):
|
|
def test_pretty(self):
|
|
namespace = os_testr.get_parser(['--pretty'])
|
|
self.assertEqual(True, namespace.pretty)
|
|
namespace = os_testr.get_parser(['--no-pretty'])
|
|
self.assertEqual(False, namespace.pretty)
|
|
self.assertRaises(SystemExit, os_testr.get_parser,
|
|
['--no-pretty', '--pretty'])
|
|
|
|
def test_slowest(self):
|
|
namespace = os_testr.get_parser(['--slowest'])
|
|
self.assertEqual(True, namespace.slowest)
|
|
namespace = os_testr.get_parser(['--no-slowest'])
|
|
self.assertEqual(False, namespace.slowest)
|
|
self.assertRaises(SystemExit, os_testr.get_parser,
|
|
['--no-slowest', '--slowest'])
|
|
|
|
def test_parallel(self):
|
|
namespace = os_testr.get_parser(['--parallel'])
|
|
self.assertEqual(True, namespace.parallel)
|
|
namespace = os_testr.get_parser(['--serial'])
|
|
self.assertEqual(False, namespace.parallel)
|
|
self.assertRaises(SystemExit, os_testr.get_parser,
|
|
['--parallel', '--serial'])
|
|
|
|
|
|
class TestCallers(base.TestCase):
|
|
def test_no_discover(self):
|
|
namespace = os_testr.get_parser(['-n', 'project.tests.foo'])
|
|
|
|
def _fake_exit(arg):
|
|
self.assertTrue(arg)
|
|
|
|
def _fake_run(*args, **kwargs):
|
|
return 'project.tests.foo' in args
|
|
|
|
with mock.patch.object(os_testr, 'exit', side_effect=_fake_exit), \
|
|
mock.patch.object(os_testr, 'get_parser', return_value=namespace), \
|
|
mock.patch.object(os_testr,
|
|
'call_subunit_run',
|
|
side_effect=_fake_run):
|
|
os_testr.main()
|
|
|
|
def test_no_discover_path(self):
|
|
namespace = os_testr.get_parser(['-n', 'project/tests/foo'])
|
|
|
|
def _fake_exit(arg):
|
|
self.assertTrue(arg)
|
|
|
|
def _fake_run(*args, **kwargs):
|
|
return 'project.tests.foo' in args
|
|
|
|
with mock.patch.object(os_testr, 'exit', side_effect=_fake_exit), \
|
|
mock.patch.object(os_testr, 'get_parser', return_value=namespace), \
|
|
mock.patch.object(os_testr,
|
|
'call_subunit_run',
|
|
side_effect=_fake_run):
|
|
os_testr.main()
|
|
|
|
def test_pdb(self):
|
|
namespace = os_testr.get_parser(['--pdb', 'project.tests.foo'])
|
|
|
|
def _fake_exit(arg):
|
|
self.assertTrue(arg)
|
|
|
|
def _fake_run(*args, **kwargs):
|
|
return 'project.tests.foo' in args
|
|
|
|
with mock.patch.object(os_testr, 'exit', side_effect=_fake_exit), \
|
|
mock.patch.object(os_testr, 'get_parser', return_value=namespace), \
|
|
mock.patch.object(os_testr,
|
|
'call_subunit_run',
|
|
side_effect=_fake_run):
|
|
os_testr.main()
|
|
|
|
def test_pdb_path(self):
|
|
namespace = os_testr.get_parser(['--pdb', 'project/tests/foo'])
|
|
|
|
def _fake_exit(arg):
|
|
self.assertTrue(arg)
|
|
|
|
def _fake_run(*args, **kwargs):
|
|
return 'project.tests.foo' in args
|
|
|
|
with mock.patch.object(os_testr, 'exit', side_effect=_fake_exit), \
|
|
mock.patch.object(os_testr, 'get_parser', return_value=namespace), \
|
|
mock.patch.object(os_testr,
|
|
'call_subunit_run',
|
|
side_effect=_fake_run):
|
|
os_testr.main()
|
|
|
|
|
|
class TestConstructRegex(base.TestCase):
|
|
def test_regex_passthrough(self):
|
|
result = os_testr.construct_regex(None, 'fake_regex', False)
|
|
self.assertEqual(result, 'fake_regex')
|
|
|
|
def test_blacklist_regex_with_comments(self):
|
|
blacklist_file = six.StringIO()
|
|
for i in range(4):
|
|
blacklist_file.write('fake_regex_%s # A Comment\n' % i)
|
|
blacklist_file.seek(0)
|
|
with mock.patch('six.moves.builtins.open',
|
|
return_value=blacklist_file):
|
|
result = os_testr.construct_regex('fake_path', None, False)
|
|
self.assertEqual(
|
|
result,
|
|
"(?!.*fake_regex_3|fake_regex_2|fake_regex_1|fake_regex_0|)")
|
|
|
|
def test_blacklist_regex_without_comments(self):
|
|
blacklist_file = six.StringIO()
|
|
for i in range(4):
|
|
blacklist_file.write('fake_regex_%s\n' % i)
|
|
blacklist_file.seek(0)
|
|
with mock.patch('six.moves.builtins.open',
|
|
return_value=blacklist_file):
|
|
result = os_testr.construct_regex('fake_path', None, False)
|
|
self.assertEqual(
|
|
result,
|
|
"(?!.*fake_regex_3|fake_regex_2|fake_regex_1|fake_regex_0|)")
|
|
|
|
def test_blacklist_regex_with_comments_and_regex(self):
|
|
blacklist_file = six.StringIO()
|
|
for i in range(4):
|
|
blacklist_file.write('fake_regex_%s # Comments\n' % i)
|
|
blacklist_file.seek(0)
|
|
with mock.patch('six.moves.builtins.open',
|
|
return_value=blacklist_file):
|
|
result = os_testr.construct_regex('fake_path', 'fake_regex', False)
|
|
|
|
expected_regex = ("(?!.*fake_regex_3|fake_regex_2|fake_regex_1|"
|
|
"fake_regex_0|)fake_regex")
|
|
self.assertEqual(result, expected_regex)
|
|
|
|
def test_blacklist_regex_without_comments_and_regex(self):
|
|
blacklist_file = six.StringIO()
|
|
for i in range(4):
|
|
blacklist_file.write('fake_regex_%s\n' % i)
|
|
blacklist_file.seek(0)
|
|
with mock.patch('six.moves.builtins.open',
|
|
return_value=blacklist_file):
|
|
result = os_testr.construct_regex('fake_path', 'fake_regex', False)
|
|
|
|
expected_regex = ("(?!.*fake_regex_3|fake_regex_2|fake_regex_1|"
|
|
"fake_regex_0|)fake_regex")
|
|
self.assertEqual(result, expected_regex)
|
|
|
|
@mock.patch.object(os_testr, 'print_skips')
|
|
def test_blacklist_regex_with_comment_print_skips(self, print_mock):
|
|
blacklist_file = six.StringIO()
|
|
for i in range(4):
|
|
blacklist_file.write('fake_regex_%s # Comment\n' % i)
|
|
blacklist_file.seek(0)
|
|
with mock.patch('six.moves.builtins.open',
|
|
return_value=blacklist_file):
|
|
result = os_testr.construct_regex('fake_path', None, True)
|
|
|
|
expected_regex = ("(?!.*fake_regex_3|fake_regex_2|fake_regex_1|"
|
|
"fake_regex_0|)")
|
|
self.assertEqual(result, expected_regex)
|
|
calls = print_mock.mock_calls
|
|
self.assertEqual(len(calls), 4)
|
|
args = list(map(lambda x: x[1], calls))
|
|
self.assertIn(('fake_regex_0', 'Comment'), args)
|
|
self.assertIn(('fake_regex_1', 'Comment'), args)
|
|
self.assertIn(('fake_regex_2', 'Comment'), args)
|
|
self.assertIn(('fake_regex_3', 'Comment'), args)
|
|
|
|
@mock.patch.object(os_testr, 'print_skips')
|
|
def test_blacklist_regex_without_comment_print_skips(self, print_mock):
|
|
blacklist_file = six.StringIO()
|
|
for i in range(4):
|
|
blacklist_file.write('fake_regex_%s\n' % i)
|
|
blacklist_file.seek(0)
|
|
with mock.patch('six.moves.builtins.open',
|
|
return_value=blacklist_file):
|
|
result = os_testr.construct_regex('fake_path', None, True)
|
|
|
|
expected_regex = ("(?!.*fake_regex_3|fake_regex_2|fake_regex_1|"
|
|
"fake_regex_0|)")
|
|
self.assertEqual(result, expected_regex)
|
|
calls = print_mock.mock_calls
|
|
self.assertEqual(len(calls), 4)
|
|
args = list(map(lambda x: x[1], calls))
|
|
self.assertIn(('fake_regex_0', ''), args)
|
|
self.assertIn(('fake_regex_1', ''), args)
|
|
self.assertIn(('fake_regex_2', ''), args)
|
|
self.assertIn(('fake_regex_3', ''), args)
|