andpp/mopidy
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

ext: Refactor tests based on review comments

Browse Source
This commit is contained in:
Thomas Adamcik 2015-05-12 22:00:31 +02:00
parent dbc3100e9c
commit d630a97bc1
1 changed files with 136 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

293
tests/test_ext.py
View File

@ -23,222 +23,201 @@ class TestExtension(ext.Extension):
any_testextension = IsA(TestExtension) any_testextension = IsA(TestExtension)
# ext.Extension class ExtensionTest(object):
@pytest.fixture @pytest.fixture
def extension(): def extension(self):
return ext.Extension() return ext.Extension()
def test_dist_name_is_none(self, extension):
assert extension.dist_name is None
def test_dist_name_is_none(extension): def test_ext_name_is_none(self, extension):
assert extension.dist_name is None 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): def test_get_default_config_raises_not_implemented(self, extension):
assert extension.ext_name is None 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): def test_validate_environment_does_nothing_by_default(self, extension):
assert extension.version is None 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): @pytest.yield_fixture
schema = extension.get_config_schema() def iter_entry_points_mock(self, request):
assert isinstance(schema['enabled'], config.Boolean) 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): def test_load_extensions(self, iter_entry_points_mock):
assert extension.validate_environment() is None 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): expected = ext.ExtensionData(
with pytest.raises(NotImplementedError): any_testextension, mock_entry_point, IsA(config.ConfigSchema),
extension.setup(None) any_unicode, None)
assert ext.load_extensions() == [expected]
# ext.load_extensions def test_gets_wrong_class(self, iter_entry_points_mock):
@pytest.fixture class WrongClass(object):
def iter_entry_points_mock(request): pass
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
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 = [mock_entry_point]
iter_entry_points_mock.return_value = []
assert [] == ext.load_extensions()
assert ext.load_extensions() == []
def test_load_extensions(iter_entry_points_mock): def test_gets_instance(self, iter_entry_points_mock):
mock_entry_point = mock.Mock() mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = TestExtension 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( assert ext.load_extensions() == []
any_testextension, mock_entry_point, IsA(config.ConfigSchema),
any_unicode, None)
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): assert ext.load_extensions() == []
pass
mock_entry_point = mock.Mock() def test_get_config_schema_fails(self, iter_entry_points_mock):
mock_entry_point.load.return_value = WrongClass 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): def test_get_default_config_fails(self, iter_entry_points_mock):
mock_entry_point = mock.Mock() mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = TestExtension() 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): def test_get_command_fails(self, iter_entry_points_mock):
mock_extension = mock.Mock(spec=ext.Extension) mock_entry_point = mock.Mock()
mock_extension.side_effect = Exception mock_entry_point.load.return_value = TestExtension
mock_entry_point = mock.Mock() iter_entry_points_mock.return_value = [mock_entry_point]
mock_entry_point.load.return_value = mock_extension
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): class ValidateExtensionDataTest(object):
mock_entry_point = mock.Mock()
mock_entry_point.load.return_value = TestExtension
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: entry_point = mock.Mock()
get_schema.side_effect = Exception entry_point.name = extension.ext_name
assert [] == ext.load_extensions()
get_schema.assert_called_once_with()
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): return ext.ExtensionData(
mock_entry_point = mock.Mock() extension, entry_point, schema, defaults, command)
mock_entry_point.load.return_value = TestExtension
iter_entry_points_mock.return_value = [mock_entry_point] def test_name_mismatch(self, ext_data):
ext_data.entry_point.name = 'barfoo'
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):
assert not ext.validate_extension_data(ext_data) assert not ext.validate_extension_data(ext_data)
def test_distribution_not_found(self, ext_data):
def test_validate_extension_instance_validate_env_ext_error(ext_data): error = pkg_resources.DistributionNotFound
extension = ext_data.extension ext_data.entry_point.require.side_effect = error
with mock.patch.object(extension, 'validate_environment') as validate:
validate.side_effect = exceptions.ExtensionError('error')
assert not ext.validate_extension_data(ext_data) 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) 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): # Hope that entry points are well behaved, so exception will bubble.
ext_data = ext_data._replace(config_schema=None) with pytest.raises(Exception):
assert not ext.validate_extension_data(ext_data) 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): assert not ext.validate_extension_data(ext_data)
del ext_data.config_schema['enabled'] validate.assert_called_once_with()
ext_data.config_schema['baz'] = config.String()
assert not ext.validate_extension_data(ext_data)
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): assert not ext.validate_extension_data(ext_data)
ext_data.config_schema['enabled'] = 123 validate.assert_called_once_with()
assert not ext.validate_extension_data(ext_data)
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): def test_schema_that_is_missing_enabled(self, ext_data):
ext_data.config_schema['baz'] = 123 del ext_data.config_schema['enabled']
assert not ext.validate_extension_data(ext_data) 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): def test_schema_with_invalid_type(self, ext_data):
ext_data = ext_data._replace(config_defaults=None) ext_data.config_schema['baz'] = 123
assert not ext.validate_extension_data(ext_data) 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)