ext: Refactor tests based on review comments

This commit is contained in:
Thomas Adamcik 2015-05-12 22:00:31 +02:00
parent dbc3100e9c
commit d630a97bc1

View File

@ -23,222 +23,201 @@ class TestExtension(ext.Extension):
any_testextension = IsA(TestExtension)
# ext.Extension
class ExtensionTest(object):
@pytest.fixture
def extension():
return ext.Extension()
@pytest.fixture
def extension(self):
return ext.Extension()
def test_dist_name_is_none(self, extension):
assert extension.dist_name is None
def test_dist_name_is_none(extension):
assert extension.dist_name is None
def test_ext_name_is_none(self, extension):
assert extension.ext_name is None
def test_version_is_none(self, extension):
assert extension.version is None
def test_ext_name_is_none(extension):
assert extension.ext_name is None
def test_get_default_config_raises_not_implemented(self, extension):
with pytest.raises(NotImplementedError):
extension.get_default_config()
def test_get_config_schema_returns_extension_schema(self, extension):
schema = extension.get_config_schema()
assert isinstance(schema['enabled'], config.Boolean)
def test_version_is_none(extension):
assert extension.version is None
def test_validate_environment_does_nothing_by_default(self, extension):
assert extension.validate_environment() is None
def test_setup_raises_not_implemented(self, extension):
with pytest.raises(NotImplementedError):
extension.setup(None)
def test_get_default_config_raises_not_implemented(extension):
with pytest.raises(NotImplementedError):
extension.get_default_config()
class LoadExtensionsTest(object):
def test_get_config_schema_returns_extension_schema(extension):
schema = extension.get_config_schema()
assert isinstance(schema['enabled'], config.Boolean)
@pytest.yield_fixture
def iter_entry_points_mock(self, request):
patcher = mock.patch('pkg_resources.iter_entry_points')
iter_entry_points = patcher.start()
iter_entry_points.return_value = []
yield iter_entry_points
patcher.stop()
def test_no_extensions(self, iter_entry_points_mock):
iter_entry_points_mock.return_value = []
assert ext.load_extensions() == []
def test_validate_environment_does_nothing_by_default(extension):
assert extension.validate_environment() is None
def test_load_extensions(self, iter_entry_points_mock):
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = TestExtension
iter_entry_points_mock.return_value = [mock_entry_point]
def test_setup_raises_not_implemented(extension):
with pytest.raises(NotImplementedError):
extension.setup(None)
expected = ext.ExtensionData(
any_testextension, mock_entry_point, IsA(config.ConfigSchema),
any_unicode, None)
assert ext.load_extensions() == [expected]
# ext.load_extensions
def test_gets_wrong_class(self, iter_entry_points_mock):
@pytest.fixture
def iter_entry_points_mock(request):
patcher = mock.patch('pkg_resources.iter_entry_points')
iter_entry_points = patcher.start()
iter_entry_points.return_value = []
request.addfinalizer(patcher.stop)
return iter_entry_points
class WrongClass(object):
pass
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = WrongClass
def test_load_extensions_no_extenions(iter_entry_points_mock):
iter_entry_points_mock.return_value = []
assert [] == ext.load_extensions()
iter_entry_points_mock.return_value = [mock_entry_point]
assert ext.load_extensions() == []
def test_load_extensions(iter_entry_points_mock):
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = TestExtension
def test_gets_instance(self, iter_entry_points_mock):
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = TestExtension()
iter_entry_points_mock.return_value = [mock_entry_point]
iter_entry_points_mock.return_value = [mock_entry_point]
expected = ext.ExtensionData(
any_testextension, mock_entry_point, IsA(config.ConfigSchema),
any_unicode, None)
assert ext.load_extensions() == []
assert ext.load_extensions() == [expected]
def test_creating_instance_fails(self, iter_entry_points_mock):
mock_extension = mock.Mock(spec=ext.Extension)
mock_extension.side_effect = Exception
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = mock_extension
def test_load_extensions_gets_wrong_class(iter_entry_points_mock):
iter_entry_points_mock.return_value = [mock_entry_point]
class WrongClass(object):
pass
assert ext.load_extensions() == []
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = WrongClass
def test_get_config_schema_fails(self, iter_entry_points_mock):
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = TestExtension
iter_entry_points_mock.return_value = [mock_entry_point]
iter_entry_points_mock.return_value = [mock_entry_point]
assert [] == ext.load_extensions()
with mock.patch.object(TestExtension, 'get_config_schema') as get:
get.side_effect = Exception
assert ext.load_extensions() == []
get.assert_called_once_with()
def test_load_extensions_gets_instance(iter_entry_points_mock):
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = TestExtension()
def test_get_default_config_fails(self, iter_entry_points_mock):
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = TestExtension
iter_entry_points_mock.return_value = [mock_entry_point]
iter_entry_points_mock.return_value = [mock_entry_point]
assert [] == ext.load_extensions()
with mock.patch.object(TestExtension, 'get_default_config') as get:
get.side_effect = Exception
assert ext.load_extensions() == []
get.assert_called_once_with()
def test_load_extensions_creating_instance_fails(iter_entry_points_mock):
mock_extension = mock.Mock(spec=ext.Extension)
mock_extension.side_effect = Exception
def test_get_command_fails(self, iter_entry_points_mock):
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = TestExtension
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = mock_extension
iter_entry_points_mock.return_value = [mock_entry_point]
iter_entry_points_mock.return_value = [mock_entry_point]
with mock.patch.object(TestExtension, 'get_command') as get:
get.side_effect = Exception
assert [] == ext.load_extensions()
assert ext.load_extensions() == []
get.assert_called_once_with()
def test_load_extensions_get_config_schema_fails(iter_entry_points_mock):
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = TestExtension
class ValidateExtensionDataTest(object):
iter_entry_points_mock.return_value = [mock_entry_point]
@pytest.fixture
def ext_data(self):
extension = TestExtension()
with mock.patch.object(TestExtension, 'get_config_schema') as get_schema:
get_schema.side_effect = Exception
assert [] == ext.load_extensions()
get_schema.assert_called_once_with()
entry_point = mock.Mock()
entry_point.name = extension.ext_name
schema = extension.get_config_schema()
defaults = extension.get_default_config()
command = extension.get_command()
def test_load_extensions_get_default_config_fails(iter_entry_points_mock):
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = TestExtension
return ext.ExtensionData(
extension, entry_point, schema, defaults, command)
iter_entry_points_mock.return_value = [mock_entry_point]
with mock.patch.object(TestExtension, 'get_default_config') as get_default:
get_default.side_effect = Exception
assert [] == ext.load_extensions()
get_default.assert_called_once_with()
def test_load_extensions_get_command_fails(iter_entry_points_mock):
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = TestExtension
iter_entry_points_mock.return_value = [mock_entry_point]
with mock.patch.object(TestExtension, 'get_command') as get_command:
get_command.side_effect = Exception
assert [] == ext.load_extensions()
get_command.assert_called_once_with()
# ext.validate_extension_data
@pytest.fixture
def ext_data():
extension = TestExtension()
entry_point = mock.Mock()
entry_point.name = extension.ext_name
schema = extension.get_config_schema()
defaults = extension.get_default_config()
command = extension.get_command()
return ext.ExtensionData(extension, entry_point, schema, defaults, command)
def test_validate_extension_name_mismatch(ext_data):
ext_data.entry_point.name = 'barfoo'
assert not ext.validate_extension_data(ext_data)
def test_validate_extension_distribution_not_found(ext_data):
error = pkg_resources.DistributionNotFound
ext_data.entry_point.require.side_effect = error
assert not ext.validate_extension_data(ext_data)
def test_validate_extension_version_conflict(ext_data):
ext_data.entry_point.require.side_effect = pkg_resources.VersionConflict
assert not ext.validate_extension_data(ext_data)
def test_validate_extension_exception(ext_data):
ext_data.entry_point.require.side_effect = Exception
# We trust that entry points are well behaved, so exception will bubble.
with pytest.raises(Exception):
def test_name_mismatch(self, ext_data):
ext_data.entry_point.name = 'barfoo'
assert not ext.validate_extension_data(ext_data)
def test_validate_extension_instance_validate_env_ext_error(ext_data):
extension = ext_data.extension
with mock.patch.object(extension, 'validate_environment') as validate:
validate.side_effect = exceptions.ExtensionError('error')
def test_distribution_not_found(self, ext_data):
error = pkg_resources.DistributionNotFound
ext_data.entry_point.require.side_effect = error
assert not ext.validate_extension_data(ext_data)
validate.assert_called_once_with()
def test_validate_extension_instance_validate_env_exception(ext_data):
extension = ext_data.extension
with mock.patch.object(extension, 'validate_environment') as validate:
validate.side_effect = Exception
def test_version_conflict(self, ext_data):
error = pkg_resources.VersionConflict
ext_data.entry_point.require.side_effect = error
assert not ext.validate_extension_data(ext_data)
validate.assert_called_once_with()
def test_entry_point_require_exception(self, ext_data):
ext_data.entry_point.require.side_effect = Exception
def test_validate_extension_with_missing_schema(ext_data):
ext_data = ext_data._replace(config_schema=None)
assert not ext.validate_extension_data(ext_data)
# Hope that entry points are well behaved, so exception will bubble.
with pytest.raises(Exception):
assert not ext.validate_extension_data(ext_data)
def test_extenions_validate_environment_error(self, ext_data):
extension = ext_data.extension
with mock.patch.object(extension, 'validate_environment') as validate:
validate.side_effect = exceptions.ExtensionError('error')
def test_validate_extension_with_schema_that_is_missing_enabled(ext_data):
del ext_data.config_schema['enabled']
ext_data.config_schema['baz'] = config.String()
assert not ext.validate_extension_data(ext_data)
assert not ext.validate_extension_data(ext_data)
validate.assert_called_once_with()
def test_extenions_validate_environment_exception(self, ext_data):
extension = ext_data.extension
with mock.patch.object(extension, 'validate_environment') as validate:
validate.side_effect = Exception
def test_validate_extension_with_schema_with_wrong_types(ext_data):
ext_data.config_schema['enabled'] = 123
assert not ext.validate_extension_data(ext_data)
assert not ext.validate_extension_data(ext_data)
validate.assert_called_once_with()
def test_missing_schema(self, ext_data):
ext_data = ext_data._replace(config_schema=None)
assert not ext.validate_extension_data(ext_data)
def test_validate_extension_with_schema_with_invalid_type(ext_data):
ext_data.config_schema['baz'] = 123
assert not ext.validate_extension_data(ext_data)
def test_schema_that_is_missing_enabled(self, ext_data):
del ext_data.config_schema['enabled']
ext_data.config_schema['baz'] = config.String()
assert not ext.validate_extension_data(ext_data)
def test_schema_with_wrong_types(self, ext_data):
ext_data.config_schema['enabled'] = 123
assert not ext.validate_extension_data(ext_data)
def test_validate_extension_with_no_defaults(ext_data):
ext_data = ext_data._replace(config_defaults=None)
assert not ext.validate_extension_data(ext_data)
def test_schema_with_invalid_type(self, ext_data):
ext_data.config_schema['baz'] = 123
assert not ext.validate_extension_data(ext_data)
def test_no_default_config(self, ext_data):
ext_data = ext_data._replace(config_defaults=None)
assert not ext.validate_extension_data(ext_data)