diff options
Diffstat (limited to 'external_libs/python/python-daemon-2.0.5/test_version.py')
| -rw-r--r-- | external_libs/python/python-daemon-2.0.5/test_version.py | 1373 |
1 files changed, 0 insertions, 1373 deletions
diff --git a/external_libs/python/python-daemon-2.0.5/test_version.py b/external_libs/python/python-daemon-2.0.5/test_version.py deleted file mode 100644 index b52f521d..00000000 --- a/external_libs/python/python-daemon-2.0.5/test_version.py +++ /dev/null @@ -1,1373 +0,0 @@ -# -*- coding: utf-8 -*- -# -# test_version.py -# Part of ‘python-daemon’, an implementation of PEP 3143. -# -# Copyright © 2008–2015 Ben Finney <ben+python@benfinney.id.au> -# -# This is free software: you may copy, modify, and/or distribute this work -# under the terms of the GNU General Public License as published by the -# Free Software Foundation; version 3 of that license or any later version. -# No warranty expressed or implied. See the file ‘LICENSE.GPL-3’ for details. - -""" Unit test for ‘version’ packaging module. """ - -from __future__ import (absolute_import, unicode_literals) - -import os -import os.path -import io -import errno -import functools -import collections -import textwrap -import json -import tempfile -import distutils.dist -import distutils.cmd -import distutils.errors -import distutils.fancy_getopt -try: - # Standard library of Python 2.7 and later. - from io import StringIO -except ImportError: - # Standard library of Python 2.6 and earlier. - from StringIO import StringIO - -import mock -import testtools -import testscenarios -import docutils -import docutils.writers -import docutils.nodes -import setuptools -import setuptools.command - -import version - -version.ensure_class_bases_begin_with( - version.__dict__, str('VersionInfoWriter'), docutils.writers.Writer) -version.ensure_class_bases_begin_with( - version.__dict__, str('VersionInfoTranslator'), - docutils.nodes.SparseNodeVisitor) - - -def make_test_classes_for_ensure_class_bases_begin_with(): - """ Make test classes for use with ‘ensure_class_bases_begin_with’. - - :return: Mapping {`name`: `type`} of the custom types created. - - """ - - class quux_metaclass(type): - def __new__(metaclass, name, bases, namespace): - return super(quux_metaclass, metaclass).__new__( - metaclass, name, bases, namespace) - - class Foo(object): - __metaclass__ = type - - class Bar(object): - pass - - class FooInheritingBar(Bar): - __metaclass__ = type - - class FooWithCustomMetaclass(object): - __metaclass__ = quux_metaclass - - result = dict( - (name, value) for (name, value) in locals().items() - if isinstance(value, type)) - - return result - -class ensure_class_bases_begin_with_TestCase( - testscenarios.WithScenarios, testtools.TestCase): - """ Test cases for ‘ensure_class_bases_begin_with’ function. """ - - test_classes = make_test_classes_for_ensure_class_bases_begin_with() - - scenarios = [ - ('simple', { - 'test_class': test_classes['Foo'], - 'base_class': test_classes['Bar'], - }), - ('custom metaclass', { - 'test_class': test_classes['FooWithCustomMetaclass'], - 'base_class': test_classes['Bar'], - 'expected_metaclass': test_classes['quux_metaclass'], - }), - ] - - def setUp(self): - """ Set up test fixtures. """ - super(ensure_class_bases_begin_with_TestCase, self).setUp() - - self.class_name = self.test_class.__name__ - self.test_module_namespace = {self.class_name: self.test_class} - - if not hasattr(self, 'expected_metaclass'): - self.expected_metaclass = type - - patcher_metaclass = mock.patch.object( - self.test_class, '__metaclass__') - patcher_metaclass.start() - self.addCleanup(patcher_metaclass.stop) - - self.fake_new_class = type(object) - self.test_class.__metaclass__.return_value = ( - self.fake_new_class) - - def test_module_namespace_contains_new_class(self): - """ Specified module namespace should have new class. """ - version.ensure_class_bases_begin_with( - self.test_module_namespace, self.class_name, self.base_class) - self.assertIn(self.fake_new_class, self.test_module_namespace.values()) - - def test_calls_metaclass_with_expected_class_name(self): - """ Should call the metaclass with the expected class name. """ - version.ensure_class_bases_begin_with( - self.test_module_namespace, self.class_name, self.base_class) - expected_class_name = self.class_name - self.test_class.__metaclass__.assert_called_with( - expected_class_name, mock.ANY, mock.ANY) - - def test_calls_metaclass_with_expected_bases(self): - """ Should call the metaclass with the expected bases. """ - version.ensure_class_bases_begin_with( - self.test_module_namespace, self.class_name, self.base_class) - expected_bases = tuple( - [self.base_class] - + list(self.test_class.__bases__)) - self.test_class.__metaclass__.assert_called_with( - mock.ANY, expected_bases, mock.ANY) - - def test_calls_metaclass_with_expected_namespace(self): - """ Should call the metaclass with the expected class namespace. """ - version.ensure_class_bases_begin_with( - self.test_module_namespace, self.class_name, self.base_class) - expected_namespace = self.test_class.__dict__.copy() - del expected_namespace['__dict__'] - self.test_class.__metaclass__.assert_called_with( - mock.ANY, mock.ANY, expected_namespace) - - -class ensure_class_bases_begin_with_AlreadyHasBase_TestCase( - testscenarios.WithScenarios, testtools.TestCase): - """ Test cases for ‘ensure_class_bases_begin_with’ function. - - These test cases test the conditions where the class's base is - already the specified base class. - - """ - - test_classes = make_test_classes_for_ensure_class_bases_begin_with() - - scenarios = [ - ('already Bar subclass', { - 'test_class': test_classes['FooInheritingBar'], - 'base_class': test_classes['Bar'], - }), - ] - - def setUp(self): - """ Set up test fixtures. """ - super( - ensure_class_bases_begin_with_AlreadyHasBase_TestCase, - self).setUp() - - self.class_name = self.test_class.__name__ - self.test_module_namespace = {self.class_name: self.test_class} - - patcher_metaclass = mock.patch.object( - self.test_class, '__metaclass__') - patcher_metaclass.start() - self.addCleanup(patcher_metaclass.stop) - - def test_metaclass_not_called(self): - """ Should not call metaclass to create a new type. """ - version.ensure_class_bases_begin_with( - self.test_module_namespace, self.class_name, self.base_class) - self.assertFalse(self.test_class.__metaclass__.called) - - -class VersionInfoWriter_TestCase(testtools.TestCase): - """ Test cases for ‘VersionInfoWriter’ class. """ - - def setUp(self): - """ Set up test fixtures. """ - super(VersionInfoWriter_TestCase, self).setUp() - - self.test_instance = version.VersionInfoWriter() - - def test_declares_version_info_support(self): - """ Should declare support for ‘version_info’. """ - instance = self.test_instance - expected_support = "version_info" - result = instance.supports(expected_support) - self.assertTrue(result) - - -class VersionInfoWriter_translate_TestCase(testtools.TestCase): - """ Test cases for ‘VersionInfoWriter.translate’ method. """ - - def setUp(self): - """ Set up test fixtures. """ - super(VersionInfoWriter_translate_TestCase, self).setUp() - - patcher_translator = mock.patch.object( - version, 'VersionInfoTranslator') - self.mock_class_translator = patcher_translator.start() - self.addCleanup(patcher_translator.stop) - self.mock_translator = self.mock_class_translator.return_value - - self.test_instance = version.VersionInfoWriter() - patcher_document = mock.patch.object( - self.test_instance, 'document') - patcher_document.start() - self.addCleanup(patcher_document.stop) - - def test_creates_translator_with_document(self): - """ Should create a translator with the writer's document. """ - instance = self.test_instance - expected_document = self.test_instance.document - instance.translate() - self.mock_class_translator.assert_called_with(expected_document) - - def test_calls_document_walkabout_with_translator(self): - """ Should call document.walkabout with the translator. """ - instance = self.test_instance - instance.translate() - instance.document.walkabout.assert_called_with(self.mock_translator) - - def test_output_from_translator_astext(self): - """ Should have output from translator.astext(). """ - instance = self.test_instance - instance.translate() - expected_output = self.mock_translator.astext.return_value - self.assertEqual(expected_output, instance.output) - - -class ChangeLogEntry_TestCase(testtools.TestCase): - """ Test cases for ‘ChangeLogEntry’ class. """ - - def setUp(self): - """ Set up test fixtures. """ - super(ChangeLogEntry_TestCase, self).setUp() - - self.test_instance = version.ChangeLogEntry() - - def test_instantiate(self): - """ New instance of ‘ChangeLogEntry’ should be created. """ - self.assertIsInstance( - self.test_instance, version.ChangeLogEntry) - - def test_minimum_zero_arguments(self): - """ Initialiser should not require any arguments. """ - instance = version.ChangeLogEntry() - self.assertIsNot(instance, None) - - -class ChangeLogEntry_release_date_TestCase( - testscenarios.WithScenarios, testtools.TestCase): - """ Test cases for ‘ChangeLogEntry.release_date’ attribute. """ - - scenarios = [ - ('default', { - 'test_args': {}, - 'expected_release_date': - version.ChangeLogEntry.default_release_date, - }), - ('unknown token', { - 'test_args': {'release_date': "UNKNOWN"}, - 'expected_release_date': "UNKNOWN", - }), - ('future token', { - 'test_args': {'release_date': "FUTURE"}, - 'expected_release_date': "FUTURE", - }), - ('2001-01-01', { - 'test_args': {'release_date': "2001-01-01"}, - 'expected_release_date': "2001-01-01", - }), - ('bogus', { - 'test_args': {'release_date': "b0gUs"}, - 'expected_error': ValueError, - }), - ] - - def test_has_expected_release_date(self): - """ Should have default `release_date` attribute. """ - if hasattr(self, 'expected_error'): - self.assertRaises( - self.expected_error, - version.ChangeLogEntry, **self.test_args) - else: - instance = version.ChangeLogEntry(**self.test_args) - self.assertEqual(self.expected_release_date, instance.release_date) - - -class ChangeLogEntry_version_TestCase( - testscenarios.WithScenarios, testtools.TestCase): - """ Test cases for ‘ChangeLogEntry.version’ attribute. """ - - scenarios = [ - ('default', { - 'test_args': {}, - 'expected_version': - version.ChangeLogEntry.default_version, - }), - ('unknown token', { - 'test_args': {'version': "UNKNOWN"}, - 'expected_version': "UNKNOWN", - }), - ('0.0', { - 'test_args': {'version': "0.0"}, - 'expected_version': "0.0", - }), - ] - - def test_has_expected_version(self): - """ Should have default `version` attribute. """ - instance = version.ChangeLogEntry(**self.test_args) - self.assertEqual(self.expected_version, instance.version) - - -class ChangeLogEntry_maintainer_TestCase( - testscenarios.WithScenarios, testtools.TestCase): - """ Test cases for ‘ChangeLogEntry.maintainer’ attribute. """ - - scenarios = [ - ('default', { - 'test_args': {}, - 'expected_maintainer': None, - }), - ('person', { - 'test_args': {'maintainer': "Foo Bar <foo.bar@example.org>"}, - 'expected_maintainer': "Foo Bar <foo.bar@example.org>", - }), - ('bogus', { - 'test_args': {'maintainer': "b0gUs"}, - 'expected_error': ValueError, - }), - ] - - def test_has_expected_maintainer(self): - """ Should have default `maintainer` attribute. """ - if hasattr(self, 'expected_error'): - self.assertRaises( - self.expected_error, - version.ChangeLogEntry, **self.test_args) - else: - instance = version.ChangeLogEntry(**self.test_args) - self.assertEqual(self.expected_maintainer, instance.maintainer) - - -class ChangeLogEntry_body_TestCase( - testscenarios.WithScenarios, testtools.TestCase): - """ Test cases for ‘ChangeLogEntry.body’ attribute. """ - - scenarios = [ - ('default', { - 'test_args': {}, - 'expected_body': None, - }), - ('simple', { - 'test_args': {'body': "Foo bar baz."}, - 'expected_body': "Foo bar baz.", - }), - ] - - def test_has_expected_body(self): - """ Should have default `body` attribute. """ - instance = version.ChangeLogEntry(**self.test_args) - self.assertEqual(self.expected_body, instance.body) - - -class ChangeLogEntry_as_version_info_entry_TestCase( - testscenarios.WithScenarios, testtools.TestCase): - """ Test cases for ‘ChangeLogEntry.as_version_info_entry’ attribute. """ - - scenarios = [ - ('default', { - 'test_args': {}, - 'expected_result': collections.OrderedDict([ - ('release_date', version.ChangeLogEntry.default_release_date), - ('version', version.ChangeLogEntry.default_version), - ('maintainer', None), - ('body', None), - ]), - }), - ] - - def setUp(self): - """ Set up test fixtures. """ - super(ChangeLogEntry_as_version_info_entry_TestCase, self).setUp() - - self.test_instance = version.ChangeLogEntry(**self.test_args) - - def test_returns_result(self): - """ Should return expected result. """ - result = self.test_instance.as_version_info_entry() - self.assertEqual(self.expected_result, result) - - -def make_mock_field_node(field_name, field_body): - """ Make a mock Docutils field node for tests. """ - - mock_field_node = mock.MagicMock( - name='field', spec=docutils.nodes.field) - - mock_field_name_node = mock.MagicMock( - name='field_name', spec=docutils.nodes.field_name) - mock_field_name_node.parent = mock_field_node - mock_field_name_node.children = [field_name] - - mock_field_body_node = mock.MagicMock( - name='field_body', spec=docutils.nodes.field_body) - mock_field_body_node.parent = mock_field_node - mock_field_body_node.children = [field_body] - - mock_field_node.children = [mock_field_name_node, mock_field_body_node] - - def fake_func_first_child_matching_class(node_class): - result = None - node_class_name = node_class.__name__ - for (index, node) in enumerate(mock_field_node.children): - if node._mock_name == node_class_name: - result = index - break - return result - - mock_field_node.first_child_matching_class.side_effect = ( - fake_func_first_child_matching_class) - - return mock_field_node - - -class JsonEqual(testtools.matchers.Matcher): - """ A matcher to compare the value of JSON streams. """ - - def __init__(self, expected): - self.expected_value = expected - - def match(self, content): - """ Assert the JSON `content` matches the `expected_content`. """ - result = None - actual_value = json.loads(content.decode('utf-8')) - if actual_value != self.expected_value: - result = JsonValueMismatch(self.expected_value, actual_value) - return result - - -class JsonValueMismatch(testtools.matchers.Mismatch): - """ The specified JSON stream does not evaluate to the expected value. """ - - def __init__(self, expected, actual): - self.expected_value = expected - self.actual_value = actual - - def describe(self): - """ Emit a text description of this mismatch. """ - expected_json_text = json.dumps(self.expected_value, indent=4) - actual_json_text = json.dumps(self.actual_value, indent=4) - text = ( - "\n" - "reference: {expected}\n" - "actual: {actual}\n").format( - expected=expected_json_text, actual=actual_json_text) - return text - - -class changelog_to_version_info_collection_TestCase( - testscenarios.WithScenarios, testtools.TestCase): - """ Test cases for ‘changelog_to_version_info_collection’ function. """ - - scenarios = [ - ('single entry', { - 'test_input': textwrap.dedent("""\ - Version 1.0 - =========== - - :Released: 2009-01-01 - :Maintainer: Foo Bar <foo.bar@example.org> - - * Lorem ipsum dolor sit amet. - """), - 'expected_version_info': [ - { - 'release_date': "2009-01-01", - 'version': "1.0", - 'maintainer': "Foo Bar <foo.bar@example.org>", - 'body': "* Lorem ipsum dolor sit amet.\n", - }, - ], - }), - ('multiple entries', { - 'test_input': textwrap.dedent("""\ - Version 1.0 - =========== - - :Released: 2009-01-01 - :Maintainer: Foo Bar <foo.bar@example.org> - - * Lorem ipsum dolor sit amet. - - - Version 0.8 - =========== - - :Released: 2004-01-01 - :Maintainer: Foo Bar <foo.bar@example.org> - - * Donec venenatis nisl aliquam ipsum. - - - Version 0.7.2 - ============= - - :Released: 2001-01-01 - :Maintainer: Foo Bar <foo.bar@example.org> - - * Pellentesque elementum mollis finibus. - """), - 'expected_version_info': [ - { - 'release_date': "2009-01-01", - 'version': "1.0", - 'maintainer': "Foo Bar <foo.bar@example.org>", - 'body': "* Lorem ipsum dolor sit amet.\n", - }, - { - 'release_date': "2004-01-01", - 'version': "0.8", - 'maintainer': "Foo Bar <foo.bar@example.org>", - 'body': "* Donec venenatis nisl aliquam ipsum.\n", - }, - { - 'release_date': "2001-01-01", - 'version': "0.7.2", - 'maintainer': "Foo Bar <foo.bar@example.org>", - 'body': "* Pellentesque elementum mollis finibus.\n", - }, - ], - }), - ('trailing comment', { - 'test_input': textwrap.dedent("""\ - Version NEXT - ============ - - :Released: FUTURE - :Maintainer: - - * Lorem ipsum dolor sit amet. - - .. - Vivamus aliquam felis rutrum rutrum dictum. - """), - 'expected_version_info': [ - { - 'release_date': "FUTURE", - 'version': "NEXT", - 'maintainer': "", - 'body': "* Lorem ipsum dolor sit amet.\n", - }, - ], - }), - ('inline comment', { - 'test_input': textwrap.dedent("""\ - Version NEXT - ============ - - :Released: FUTURE - :Maintainer: - - .. - Vivamus aliquam felis rutrum rutrum dictum. - - * Lorem ipsum dolor sit amet. - """), - 'expected_version_info': [ - { - 'release_date': "FUTURE", - 'version': "NEXT", - 'maintainer': "", - 'body': "* Lorem ipsum dolor sit amet.\n", - }, - ], - }), - ('unreleased entry', { - 'test_input': textwrap.dedent("""\ - Version NEXT - ============ - - :Released: FUTURE - :Maintainer: - - * Lorem ipsum dolor sit amet. - - - Version 0.8 - =========== - - :Released: 2001-01-01 - :Maintainer: Foo Bar <foo.bar@example.org> - - * Donec venenatis nisl aliquam ipsum. - """), - 'expected_version_info': [ - { - 'release_date': "FUTURE", - 'version': "NEXT", - 'maintainer': "", - 'body': "* Lorem ipsum dolor sit amet.\n", - }, - { - 'release_date': "2001-01-01", - 'version': "0.8", - 'maintainer': "Foo Bar <foo.bar@example.org>", - 'body': "* Donec venenatis nisl aliquam ipsum.\n", - }, - ], - }), - ('no section', { - 'test_input': textwrap.dedent("""\ - :Released: 2009-01-01 - :Maintainer: Foo Bar <foo.bar@example.org> - - * Lorem ipsum dolor sit amet. - """), - 'expected_error': version.InvalidFormatError, - }), - ('subsection', { - 'test_input': textwrap.dedent("""\ - Version 1.0 - =========== - - :Released: 2009-01-01 - :Maintainer: Foo Bar <foo.bar@example.org> - - * Lorem ipsum dolor sit amet. - - Ut ultricies fermentum quam - --------------------------- - - * In commodo magna facilisis in. - """), - 'expected_error': version.InvalidFormatError, - 'subsection': True, - }), - ('unknown field', { - 'test_input': textwrap.dedent("""\ - Version 1.0 - =========== - - :Released: 2009-01-01 - :Maintainer: Foo Bar <foo.bar@example.org> - :Favourite: Spam - - * Lorem ipsum dolor sit amet. - """), - 'expected_error': version.InvalidFormatError, - }), - ('invalid version word', { - 'test_input': textwrap.dedent("""\ - BoGuS 1.0 - ========= - - :Released: 2009-01-01 - :Maintainer: Foo Bar <foo.bar@example.org> - - * Lorem ipsum dolor sit amet. - """), - 'expected_error': version.InvalidFormatError, - }), - ('invalid section title', { - 'test_input': textwrap.dedent("""\ - Lorem Ipsum 1.0 - =============== - - :Released: 2009-01-01 - :Maintainer: Foo Bar <foo.bar@example.org> - - * Lorem ipsum dolor sit amet. - """), - 'expected_error': version.InvalidFormatError, - }), - ] - - def test_returns_expected_version_info(self): - """ Should return expected version info mapping. """ - infile = StringIO(self.test_input) - if hasattr(self, 'expected_error'): - self.assertRaises( - self.expected_error, - version.changelog_to_version_info_collection, infile) - else: - result = version.changelog_to_version_info_collection(infile) - self.assertThat(result, JsonEqual(self.expected_version_info)) - - -try: - FileNotFoundError - PermissionError -except NameError: - # Python 2 uses OSError. - FileNotFoundError = functools.partial(IOError, errno.ENOENT) - PermissionError = functools.partial(IOError, errno.EPERM) - -fake_version_info = { - 'release_date': "2001-01-01", 'version': "2.0", - 'maintainer': None, 'body': None, - } - -@mock.patch.object( - version, "get_latest_version", return_value=fake_version_info) -class generate_version_info_from_changelog_TestCase( - testscenarios.WithScenarios, testtools.TestCase): - """ Test cases for ‘generate_version_info_from_changelog’ function. """ - - fake_open_side_effects = { - 'success': ( - lambda *args, **kwargs: StringIO()), - 'file not found': FileNotFoundError(), - 'permission denied': PermissionError(), - } - - scenarios = [ - ('simple', { - 'open_scenario': 'success', - 'fake_versions_json': json.dumps([fake_version_info]), - 'expected_result': fake_version_info, - }), - ('file not found', { - 'open_scenario': 'file not found', - 'expected_result': {}, - }), - ('permission denied', { - 'open_scenario': 'permission denied', - 'expected_result': {}, - }), - ] - - def setUp(self): - """ Set up test fixtures. """ - super(generate_version_info_from_changelog_TestCase, self).setUp() - - self.fake_changelog_file_path = tempfile.mktemp() - - def fake_open(filespec, *args, **kwargs): - if filespec == self.fake_changelog_file_path: - side_effect = self.fake_open_side_effects[self.open_scenario] - if callable(side_effect): - result = side_effect() - else: - raise side_effect - else: - result = StringIO() - return result - - func_patcher_io_open = mock.patch.object( - io, "open") - func_patcher_io_open.start() - self.addCleanup(func_patcher_io_open.stop) - io.open.side_effect = fake_open - - self.file_encoding = "utf-8" - - func_patcher_changelog_to_version_info_collection = mock.patch.object( - version, "changelog_to_version_info_collection") - func_patcher_changelog_to_version_info_collection.start() - self.addCleanup(func_patcher_changelog_to_version_info_collection.stop) - if hasattr(self, 'fake_versions_json'): - version.changelog_to_version_info_collection.return_value = ( - self.fake_versions_json.encode(self.file_encoding)) - - def test_returns_empty_collection_on_read_error( - self, - mock_func_get_latest_version): - """ Should return empty collection on error reading changelog. """ - test_error = PermissionError("Not for you") - version.changelog_to_version_info_collection.side_effect = test_error - result = version.generate_version_info_from_changelog( - self.fake_changelog_file_path) - expected_result = {} - self.assertDictEqual(expected_result, result) - - def test_opens_file_with_expected_encoding( - self, - mock_func_get_latest_version): - """ Should open changelog file in text mode with expected encoding. """ - result = version.generate_version_info_from_changelog( - self.fake_changelog_file_path) - expected_file_path = self.fake_changelog_file_path - expected_open_mode = 'rt' - expected_encoding = self.file_encoding - (open_args_positional, open_args_kwargs) = io.open.call_args - (open_args_filespec, open_args_mode) = open_args_positional[:2] - open_args_encoding = open_args_kwargs['encoding'] - self.assertEqual(expected_file_path, open_args_filespec) - self.assertEqual(expected_open_mode, open_args_mode) - self.assertEqual(expected_encoding, open_args_encoding) - - def test_returns_expected_result( - self, - mock_func_get_latest_version): - """ Should return expected result. """ - result = version.generate_version_info_from_changelog( - self.fake_changelog_file_path) - self.assertEqual(self.expected_result, result) - - -DefaultNoneDict = functools.partial(collections.defaultdict, lambda: None) - -class get_latest_version_TestCase( - testscenarios.WithScenarios, testtools.TestCase): - """ Test cases for ‘get_latest_version’ function. """ - - scenarios = [ - ('simple', { - 'test_versions': [ - DefaultNoneDict({'release_date': "LATEST"}), - ], - 'expected_result': version.ChangeLogEntry.make_ordered_dict( - DefaultNoneDict({'release_date': "LATEST"})), - }), - ('no versions', { - 'test_versions': [], - 'expected_result': collections.OrderedDict(), - }), - ('ordered versions', { - 'test_versions': [ - DefaultNoneDict({'release_date': "1"}), - DefaultNoneDict({'release_date': "2"}), - DefaultNoneDict({'release_date': "LATEST"}), - ], - 'expected_result': version.ChangeLogEntry.make_ordered_dict( - DefaultNoneDict({'release_date': "LATEST"})), - }), - ('un-ordered versions', { - 'test_versions': [ - DefaultNoneDict({'release_date': "2"}), - DefaultNoneDict({'release_date': "LATEST"}), - DefaultNoneDict({'release_date': "1"}), - ], - 'expected_result': version.ChangeLogEntry.make_ordered_dict( - DefaultNoneDict({'release_date': "LATEST"})), - }), - ] - - def test_returns_expected_result(self): - """ Should return expected result. """ - result = version.get_latest_version(self.test_versions) - self.assertDictEqual(self.expected_result, result) - - -@mock.patch.object(json, "dumps", side_effect=json.dumps) -class serialise_version_info_from_mapping_TestCase( - testscenarios.WithScenarios, testtools.TestCase): - """ Test cases for ‘get_latest_version’ function. """ - - scenarios = [ - ('simple', { - 'test_version_info': {'foo': "spam"}, - }), - ] - - for (name, scenario) in scenarios: - scenario['fake_json_dump'] = json.dumps(scenario['test_version_info']) - scenario['expected_value'] = scenario['test_version_info'] - - def test_passes_specified_object(self, mock_func_json_dumps): - """ Should pass the specified object to `json.dumps`. """ - result = version.serialise_version_info_from_mapping( - self.test_version_info) - mock_func_json_dumps.assert_called_with( - self.test_version_info, indent=mock.ANY) - - def test_returns_expected_result(self, mock_func_json_dumps): - """ Should return expected result. """ - mock_func_json_dumps.return_value = self.fake_json_dump - result = version.serialise_version_info_from_mapping( - self.test_version_info) - value = json.loads(result) - self.assertEqual(self.expected_value, value) - - -DistributionMetadata_defaults = { - name: None - for name in list(collections.OrderedDict.fromkeys( - distutils.dist.DistributionMetadata._METHOD_BASENAMES))} -FakeDistributionMetadata = collections.namedtuple( - 'FakeDistributionMetadata', DistributionMetadata_defaults.keys()) - -Distribution_defaults = { - 'metadata': None, - 'version': None, - 'release_date': None, - 'maintainer': None, - 'maintainer_email': None, - } -FakeDistribution = collections.namedtuple( - 'FakeDistribution', Distribution_defaults.keys()) - -def make_fake_distribution( - fields_override=None, metadata_fields_override=None): - metadata_fields = DistributionMetadata_defaults.copy() - if metadata_fields_override is not None: - metadata_fields.update(metadata_fields_override) - metadata = FakeDistributionMetadata(**metadata_fields) - - fields = Distribution_defaults.copy() - fields['metadata'] = metadata - if fields_override is not None: - fields.update(fields_override) - distribution = FakeDistribution(**fields) - - return distribution - - -class get_changelog_path_TestCase( - testscenarios.WithScenarios, testtools.TestCase): - """ Test cases for ‘get_changelog_path’ function. """ - - default_path = "." - default_script_filename = "setup.py" - - scenarios = [ - ('simple', {}), - ('unusual script name', { - 'script_filename': "lorem_ipsum", - }), - ('relative script path', { - 'script_directory': "dolor/sit/amet", - }), - ('absolute script path', { - 'script_directory': "/dolor/sit/amet", - }), - ('specify filename', { - 'changelog_filename': "adipiscing", - }), - ] - - def setUp(self): - """ Set up test fixtures. """ - super(get_changelog_path_TestCase, self).setUp() - - self.test_distribution = mock.MagicMock(distutils.dist.Distribution) - - if not hasattr(self, 'script_directory'): - self.script_directory = self.default_path - if not hasattr(self, 'script_filename'): - self.script_filename = self.default_script_filename - self.test_distribution.script_name = os.path.join( - self.script_directory, self.script_filename) - - changelog_filename = version.changelog_filename - if hasattr(self, 'changelog_filename'): - changelog_filename = self.changelog_filename - - self.expected_result = os.path.join( - self.script_directory, changelog_filename) - - def test_returns_expected_result(self): - """ Should return expected result. """ - args = { - 'distribution': self.test_distribution, - } - if hasattr(self, 'changelog_filename'): - args.update({'filename': self.changelog_filename}) - result = version.get_changelog_path(**args) - self.assertEqual(self.expected_result, result) - - -class WriteVersionInfoCommand_BaseTestCase( - testscenarios.WithScenarios, testtools.TestCase): - """ Base class for ‘WriteVersionInfoCommand’ test case classes. """ - - def setUp(self): - """ Set up test fixtures. """ - super(WriteVersionInfoCommand_BaseTestCase, self).setUp() - - fake_distribution_name = self.getUniqueString() - - self.test_distribution = distutils.dist.Distribution() - self.test_distribution.metadata.name = fake_distribution_name - - -class WriteVersionInfoCommand_TestCase(WriteVersionInfoCommand_BaseTestCase): - """ Test cases for ‘WriteVersionInfoCommand’ class. """ - - def test_subclass_of_distutils_command(self): - """ Should be a subclass of ‘distutils.cmd.Command’. """ - instance = version.WriteVersionInfoCommand(self.test_distribution) - self.assertIsInstance(instance, distutils.cmd.Command) - - -class WriteVersionInfoCommand_user_options_TestCase( - WriteVersionInfoCommand_BaseTestCase): - """ Test cases for ‘WriteVersionInfoCommand.user_options’ attribute. """ - - def setUp(self): - """ Set up test fixtures. """ - super(WriteVersionInfoCommand_user_options_TestCase, self).setUp() - - self.test_instance = version.WriteVersionInfoCommand( - self.test_distribution) - self.commandline_parser = distutils.fancy_getopt.FancyGetopt( - self.test_instance.user_options) - - def test_parses_correctly_as_fancy_getopt(self): - """ Should parse correctly in ‘FancyGetopt’. """ - self.assertIsInstance( - self.commandline_parser, distutils.fancy_getopt.FancyGetopt) - - def test_includes_base_class_user_options(self): - """ Should include base class's user_options. """ - base_command = setuptools.command.egg_info.egg_info - expected_user_options = base_command.user_options - self.assertThat( - set(expected_user_options), - IsSubset(set(self.test_instance.user_options))) - - def test_has_option_changelog_path(self): - """ Should have a ‘changelog-path’ option. """ - expected_option_name = "changelog-path=" - result = self.commandline_parser.has_option(expected_option_name) - self.assertTrue(result) - - def test_has_option_outfile_path(self): - """ Should have a ‘outfile-path’ option. """ - expected_option_name = "outfile-path=" - result = self.commandline_parser.has_option(expected_option_name) - self.assertTrue(result) - - -class WriteVersionInfoCommand_initialize_options_TestCase( - WriteVersionInfoCommand_BaseTestCase): - """ Test cases for ‘WriteVersionInfoCommand.initialize_options’ method. """ - - def setUp(self): - """ Set up test fixtures. """ - super( - WriteVersionInfoCommand_initialize_options_TestCase, self - ).setUp() - - patcher_func_egg_info_initialize_options = mock.patch.object( - setuptools.command.egg_info.egg_info, "initialize_options") - patcher_func_egg_info_initialize_options.start() - self.addCleanup(patcher_func_egg_info_initialize_options.stop) - - def test_calls_base_class_method(self): - """ Should call base class's ‘initialize_options’ method. """ - instance = version.WriteVersionInfoCommand(self.test_distribution) - base_command_class = setuptools.command.egg_info.egg_info - base_command_class.initialize_options.assert_called_with() - - def test_sets_changelog_path_to_none(self): - """ Should set ‘changelog_path’ attribute to ``None``. """ - instance = version.WriteVersionInfoCommand(self.test_distribution) - self.assertIs(instance.changelog_path, None) - - def test_sets_outfile_path_to_none(self): - """ Should set ‘outfile_path’ attribute to ``None``. """ - instance = version.WriteVersionInfoCommand(self.test_distribution) - self.assertIs(instance.outfile_path, None) - - -class WriteVersionInfoCommand_finalize_options_TestCase( - WriteVersionInfoCommand_BaseTestCase): - """ Test cases for ‘WriteVersionInfoCommand.finalize_options’ method. """ - - def setUp(self): - """ Set up test fixtures. """ - super(WriteVersionInfoCommand_finalize_options_TestCase, self).setUp() - - self.test_instance = version.WriteVersionInfoCommand(self.test_distribution) - - patcher_func_egg_info_finalize_options = mock.patch.object( - setuptools.command.egg_info.egg_info, "finalize_options") - patcher_func_egg_info_finalize_options.start() - self.addCleanup(patcher_func_egg_info_finalize_options.stop) - - self.fake_script_dir = self.getUniqueString() - self.test_distribution.script_name = os.path.join( - self.fake_script_dir, self.getUniqueString()) - - self.fake_egg_dir = self.getUniqueString() - self.test_instance.egg_info = self.fake_egg_dir - - patcher_func_get_changelog_path = mock.patch.object( - version, "get_changelog_path") - patcher_func_get_changelog_path.start() - self.addCleanup(patcher_func_get_changelog_path.stop) - - self.fake_changelog_path = self.getUniqueString() - version.get_changelog_path.return_value = self.fake_changelog_path - - def test_calls_base_class_method(self): - """ Should call base class's ‘finalize_options’ method. """ - base_command_class = setuptools.command.egg_info.egg_info - self.test_instance.finalize_options() - base_command_class.finalize_options.assert_called_with() - - def test_sets_force_to_none(self): - """ Should set ‘force’ attribute to ``None``. """ - self.test_instance.finalize_options() - self.assertIs(self.test_instance.force, None) - - def test_sets_changelog_path_using_get_changelog_path(self): - """ Should set ‘changelog_path’ attribute if it was ``None``. """ - self.test_instance.changelog_path = None - self.test_instance.finalize_options() - expected_changelog_path = self.fake_changelog_path - self.assertEqual(expected_changelog_path, self.test_instance.changelog_path) - - def test_leaves_changelog_path_if_already_set(self): - """ Should leave ‘changelog_path’ attribute set. """ - prior_changelog_path = self.getUniqueString() - self.test_instance.changelog_path = prior_changelog_path - self.test_instance.finalize_options() - expected_changelog_path = prior_changelog_path - self.assertEqual(expected_changelog_path, self.test_instance.changelog_path) - - def test_sets_outfile_path_to_default(self): - """ Should set ‘outfile_path’ attribute to default value. """ - fake_version_info_filename = self.getUniqueString() - with mock.patch.object( - version, "version_info_filename", - new=fake_version_info_filename): - self.test_instance.finalize_options() - expected_outfile_path = os.path.join( - self.fake_egg_dir, fake_version_info_filename) - self.assertEqual(expected_outfile_path, self.test_instance.outfile_path) - - def test_leaves_outfile_path_if_already_set(self): - """ Should leave ‘outfile_path’ attribute set. """ - prior_outfile_path = self.getUniqueString() - self.test_instance.outfile_path = prior_outfile_path - self.test_instance.finalize_options() - expected_outfile_path = prior_outfile_path - self.assertEqual(expected_outfile_path, self.test_instance.outfile_path) - - -class has_changelog_TestCase( - testscenarios.WithScenarios, testtools.TestCase): - """ Test cases for ‘has_changelog’ function. """ - - fake_os_path_exists_side_effects = { - 'true': (lambda path: True), - 'false': (lambda path: False), - } - - scenarios = [ - ('no changelog path', { - 'changelog_path': None, - 'expected_result': False, - }), - ('changelog exists', { - 'os_path_exists_scenario': 'true', - 'expected_result': True, - }), - ('changelog not found', { - 'os_path_exists_scenario': 'false', - 'expected_result': False, - }), - ] - - def setUp(self): - """ Set up test fixtures. """ - super(has_changelog_TestCase, self).setUp() - - self.test_distribution = distutils.dist.Distribution() - self.test_command = version.EggInfoCommand( - self.test_distribution) - - patcher_func_get_changelog_path = mock.patch.object( - version, "get_changelog_path") - patcher_func_get_changelog_path.start() - self.addCleanup(patcher_func_get_changelog_path.stop) - - self.fake_changelog_file_path = self.getUniqueString() - if hasattr(self, 'changelog_path'): - self.fake_changelog_file_path = self.changelog_path - version.get_changelog_path.return_value = self.fake_changelog_file_path - self.fake_changelog_file = StringIO() - - def fake_os_path_exists(path): - if path == self.fake_changelog_file_path: - side_effect = self.fake_os_path_exists_side_effects[ - self.os_path_exists_scenario] - if callable(side_effect): - result = side_effect(path) - else: - raise side_effect - else: - result = False - return result - - func_patcher_os_path_exists = mock.patch.object( - os.path, "exists") - func_patcher_os_path_exists.start() - self.addCleanup(func_patcher_os_path_exists.stop) - os.path.exists.side_effect = fake_os_path_exists - - def test_gets_changelog_path_from_distribution(self): - """ Should call ‘get_changelog_path’ with distribution. """ - result = version.has_changelog(self.test_command) - version.get_changelog_path.assert_called_with( - self.test_distribution) - - def test_returns_expected_result(self): - """ Should be a subclass of ‘distutils.cmd.Command’. """ - result = version.has_changelog(self.test_command) - self.assertEqual(self.expected_result, result) - - -@mock.patch.object(version, 'generate_version_info_from_changelog') -@mock.patch.object(version, 'serialise_version_info_from_mapping') -@mock.patch.object(version.EggInfoCommand, "write_file") -class WriteVersionInfoCommand_run_TestCase( - WriteVersionInfoCommand_BaseTestCase): - """ Test cases for ‘WriteVersionInfoCommand.run’ method. """ - - def setUp(self): - """ Set up test fixtures. """ - super(WriteVersionInfoCommand_run_TestCase, self).setUp() - - self.test_instance = version.WriteVersionInfoCommand( - self.test_distribution) - - self.fake_changelog_path = self.getUniqueString() - self.test_instance.changelog_path = self.fake_changelog_path - - self.fake_outfile_path = self.getUniqueString() - self.test_instance.outfile_path = self.fake_outfile_path - - def test_returns_none( - self, - mock_func_egg_info_write_file, - mock_func_serialise_version_info, - mock_func_generate_version_info): - """ Should return ``None``. """ - result = self.test_instance.run() - self.assertIs(result, None) - - def test_generates_version_info_from_changelog( - self, - mock_func_egg_info_write_file, - mock_func_serialise_version_info, - mock_func_generate_version_info): - """ Should generate version info from specified changelog. """ - self.test_instance.run() - expected_changelog_path = self.test_instance.changelog_path - mock_func_generate_version_info.assert_called_with( - expected_changelog_path) - - def test_serialises_version_info_from_mapping( - self, - mock_func_egg_info_write_file, - mock_func_serialise_version_info, - mock_func_generate_version_info): - """ Should serialise version info from specified mapping. """ - self.test_instance.run() - expected_version_info = mock_func_generate_version_info.return_value - mock_func_serialise_version_info.assert_called_with( - expected_version_info) - - def test_writes_file_using_command_context( - self, - mock_func_egg_info_write_file, - mock_func_serialise_version_info, - mock_func_generate_version_info): - """ Should write the metadata file using the command context. """ - self.test_instance.run() - expected_content = mock_func_serialise_version_info.return_value - mock_func_egg_info_write_file.assert_called_with( - "version info", self.fake_outfile_path, expected_content) - - -IsSubset = testtools.matchers.MatchesPredicateWithParams( - set.issubset, "{0} should be a subset of {1}") - -class EggInfoCommand_TestCase(testtools.TestCase): - """ Test cases for ‘EggInfoCommand’ class. """ - - def setUp(self): - """ Set up test fixtures. """ - super(EggInfoCommand_TestCase, self).setUp() - - self.test_distribution = distutils.dist.Distribution() - self.test_instance = version.EggInfoCommand(self.test_distribution) - - def test_subclass_of_setuptools_egg_info(self): - """ Should be a subclass of Setuptools ‘egg_info’. """ - self.assertIsInstance( - self.test_instance, setuptools.command.egg_info.egg_info) - - def test_sub_commands_include_base_class_sub_commands(self): - """ Should include base class's sub-commands in this sub_commands. """ - base_command = setuptools.command.egg_info.egg_info - expected_sub_commands = base_command.sub_commands - self.assertThat( - set(expected_sub_commands), - IsSubset(set(self.test_instance.sub_commands))) - - def test_sub_commands_includes_write_version_info_command(self): - """ Should include sub-command named ‘write_version_info’. """ - commands_by_name = dict(self.test_instance.sub_commands) - expected_predicate = version.has_changelog - expected_item = ('write_version_info', expected_predicate) - self.assertIn(expected_item, commands_by_name.items()) - - -@mock.patch.object(setuptools.command.egg_info.egg_info, "run") -class EggInfoCommand_run_TestCase(testtools.TestCase): - """ Test cases for ‘EggInfoCommand.run’ method. """ - - def setUp(self): - """ Set up test fixtures. """ - super(EggInfoCommand_run_TestCase, self).setUp() - - self.test_distribution = distutils.dist.Distribution() - self.test_instance = version.EggInfoCommand(self.test_distribution) - - base_command = setuptools.command.egg_info.egg_info - patcher_func_egg_info_get_sub_commands = mock.patch.object( - base_command, "get_sub_commands") - patcher_func_egg_info_get_sub_commands.start() - self.addCleanup(patcher_func_egg_info_get_sub_commands.stop) - - patcher_func_egg_info_run_command = mock.patch.object( - base_command, "run_command") - patcher_func_egg_info_run_command.start() - self.addCleanup(patcher_func_egg_info_run_command.stop) - - self.fake_sub_commands = ["spam", "eggs", "beans"] - base_command.get_sub_commands.return_value = self.fake_sub_commands - - def test_returns_none(self, mock_func_egg_info_run): - """ Should return ``None``. """ - result = self.test_instance.run() - self.assertIs(result, None) - - def test_runs_each_command_in_sub_commands( - self, mock_func_egg_info_run): - """ Should run each command in ‘self.get_sub_commands()’. """ - base_command = setuptools.command.egg_info.egg_info - self.test_instance.run() - expected_calls = [mock.call(name) for name in self.fake_sub_commands] - base_command.run_command.assert_has_calls(expected_calls) - - def test_calls_base_class_run(self, mock_func_egg_info_run): - """ Should call base class's ‘run’ method. """ - result = self.test_instance.run() - mock_func_egg_info_run.assert_called_with() - - -# Local variables: -# coding: utf-8 -# mode: python -# End: -# vim: fileencoding=utf-8 filetype=python : |