rfctr: upgrade mock helpers to autospec by default

Benjamin Toornstra · scanny · commit d4059d1edf73 · 2021-05-15T15:28:14.000-07:00
diff --git a/tests/image/test_tiff.py b/tests/image/test_tiff.py
@@ -35,7 +35,6 @@
 
 
 class DescribeTiff(object):
-
     def it_can_construct_from_a_tiff_stream(
         self, stream_, _TiffParser_, tiff_parser_, Tiff__init_
     ):
@@ -60,7 +59,7 @@ def it_knows_its_content_type(self):
 
     def it_knows_its_default_ext(self):
         tiff = Tiff(None, None, None, None)
-        assert tiff.default_ext == 'tiff'
+        assert tiff.default_ext == "tiff"
 
     # fixtures -------------------------------------------------------
 
@@ -70,7 +69,7 @@ def Tiff__init_(self, request):
 
     @pytest.fixture
     def _TiffParser_(self, request, tiff_parser_):
-        _TiffParser_ = class_mock(request, 'docx.image.tiff._TiffParser')
+        _TiffParser_ = class_mock(request, "docx.image.tiff._TiffParser")
         _TiffParser_.parse.return_value = tiff_parser_
         return _TiffParser_
 
@@ -84,7 +83,6 @@ def stream_(self, request):
 
 
 class Describe_TiffParser(object):
-
     def it_can_parse_the_properties_from_a_tiff_stream(
         self,
         stream_,
@@ -98,9 +96,7 @@ def it_can_parse_the_properties_from_a_tiff_stream(
         tiff_parser = _TiffParser.parse(stream_)
 
         _make_stream_reader_.assert_called_once_with(stream_)
-        _IfdEntries_.from_stream.assert_called_once_with(
-            stream_rdr_, ifd0_offset_
-        )
+        _IfdEntries_.from_stream.assert_called_once_with(stream_rdr_, ifd0_offset_)
         _TiffParser__init_.assert_called_once_with(ANY, ifd_entries_)
         assert isinstance(tiff_parser, _TiffParser)
 
@@ -112,10 +108,7 @@ def it_makes_a_stream_reader_to_help_parse(self, mk_stream_rdr_fixture):
 
     def it_knows_image_width_and_height_after_parsing(self):
         px_width, px_height = 42, 24
-        entries = {
-            TIFF_TAG.IMAGE_WIDTH:  px_width,
-            TIFF_TAG.IMAGE_LENGTH: px_height,
-        }
+        entries = {TIFF_TAG.IMAGE_WIDTH: px_width, TIFF_TAG.IMAGE_LENGTH: px_height}
         ifd_entries = _IfdEntries(entries)
         tiff_parser = _TiffParser(ifd_entries)
         assert tiff_parser.px_width == px_width
@@ -128,13 +121,15 @@ def it_knows_the_horz_and_vert_dpi_after_parsing(self, dpi_fixture):
 
     # fixtures -------------------------------------------------------
 
-    @pytest.fixture(params=[
-        (1,     150,  240,  72,  72),
-        (2,      42,   24,  42,  24),
-        (3,     100,  200, 254, 508),
-        (2,    None, None,  72,  72),
-        (None,   96,  100,  96, 100),
-    ])
+    @pytest.fixture(
+        params=[
+            (1, 150, 240, 72, 72),
+            (2, 42, 24, 42, 24),
+            (3, 100, 200, 254, 508),
+            (2, None, None, 72, 72),
+            (None, 96, 100, 96, 100),
+        ]
+    )
     def dpi_fixture(self, request):
         resolution_unit, x_resolution, y_resolution = request.param[:3]
         expected_horz_dpi, expected_vert_dpi = request.param[3:]
@@ -152,7 +147,7 @@ def dpi_fixture(self, request):
 
     @pytest.fixture
     def _IfdEntries_(self, request, ifd_entries_):
-        _IfdEntries_ = class_mock(request, 'docx.image.tiff._IfdEntries')
+        _IfdEntries_ = class_mock(request, "docx.image.tiff._IfdEntries")
         _IfdEntries_.from_stream.return_value = ifd_entries_
         return _IfdEntries_
 
@@ -169,15 +164,12 @@ def _make_stream_reader_(self, request, stream_rdr_):
         return method_mock(
             request,
             _TiffParser,
-            '_make_stream_reader',
+            "_make_stream_reader",
             autospec=False,
-            return_value=stream_rdr_
+            return_value=stream_rdr_,
         )
 
-    @pytest.fixture(params=[
-        (b'MM\x00*', BIG_ENDIAN),
-        (b'II*\x00', LITTLE_ENDIAN),
-    ])
+    @pytest.fixture(params=[(b"MM\x00*", BIG_ENDIAN), (b"II*\x00", LITTLE_ENDIAN)])
     def mk_stream_rdr_fixture(self, request, StreamReader_, stream_rdr_):
         bytes_, endian = request.param
         stream = BytesIO(bytes_)
@@ -190,7 +182,7 @@ def stream_(self, request):
     @pytest.fixture
     def StreamReader_(self, request, stream_rdr_):
         return class_mock(
-            request, 'docx.image.tiff.StreamReader', return_value=stream_rdr_
+            request, "docx.image.tiff.StreamReader", return_value=stream_rdr_
         )
 
     @pytest.fixture
@@ -205,7 +197,6 @@ def _TiffParser__init_(self, request):
 
 
 class Describe_IfdEntries(object):
-
     def it_can_construct_from_a_stream_and_offset(
         self,
         stream_,
@@ -226,7 +217,7 @@ def it_can_construct_from_a_stream_and_offset(
         assert isinstance(ifd_entries, _IfdEntries)
 
     def it_has_basic_mapping_semantics(self):
-        key, value = 1, 'foobar'
+        key, value = 1, "foobar"
         entries = {key: value}
         ifd_entries = _IfdEntries(entries)
         assert key in ifd_entries
@@ -249,7 +240,7 @@ def _IfdEntries__init_(self, request):
     @pytest.fixture
     def _IfdParser_(self, request, ifd_parser_):
         return class_mock(
-            request, 'docx.image.tiff._IfdParser', return_value=ifd_parser_
+            request, "docx.image.tiff._IfdParser", return_value=ifd_parser_
         )
 
     @pytest.fixture
@@ -266,11 +257,14 @@ def stream_(self, request):
 
 
 class Describe_IfdParser(object):
-
-    def it_can_iterate_through_the_directory_entries_in_an_IFD(
-            self, iter_fixture):
-        (ifd_parser, _IfdEntryFactory_, stream_rdr, offsets,
-         expected_entries) = iter_fixture
+    def it_can_iterate_through_the_directory_entries_in_an_IFD(self, iter_fixture):
+        (
+            ifd_parser,
+            _IfdEntryFactory_,
+            stream_rdr,
+            offsets,
+            expected_entries,
+        ) = iter_fixture
         entries = [e for e in ifd_parser.iter_entries()]
         assert _IfdEntryFactory_.call_args_list == [
             call(stream_rdr, offsets[0]),
@@ -291,24 +285,21 @@ def ifd_entry_2_(self, request):
     @pytest.fixture
     def _IfdEntryFactory_(self, request, ifd_entry_, ifd_entry_2_):
         return function_mock(
-            request, 'docx.image.tiff._IfdEntryFactory',
-            side_effect=[ifd_entry_, ifd_entry_2_]
+            request,
+            "docx.image.tiff._IfdEntryFactory",
+            side_effect=[ifd_entry_, ifd_entry_2_],
         )
 
     @pytest.fixture
     def iter_fixture(self, _IfdEntryFactory_, ifd_entry_, ifd_entry_2_):
-        stream_rdr = StreamReader(BytesIO(b'\x00\x02'), BIG_ENDIAN)
+        stream_rdr = StreamReader(BytesIO(b"\x00\x02"), BIG_ENDIAN)
         offsets = [2, 14]
         ifd_parser = _IfdParser(stream_rdr, offset=0)
         expected_entries = [ifd_entry_, ifd_entry_2_]
-        return (
-            ifd_parser, _IfdEntryFactory_, stream_rdr, offsets,
-            expected_entries
-        )
+        return (ifd_parser, _IfdEntryFactory_, stream_rdr, offsets, expected_entries)
 
 
 class Describe_IfdEntryFactory(object):
-
     def it_constructs_the_right_class_for_a_given_ifd_entry(self, fixture):
         stream_rdr, offset, entry_cls_, ifd_entry_ = fixture
         ifd_entry = _IfdEntryFactory(stream_rdr, offset)
@@ -317,25 +308,34 @@ def it_constructs_the_right_class_for_a_given_ifd_entry(self, fixture):
 
     # fixtures -------------------------------------------------------
 
-    @pytest.fixture(params=[
-        (b'\x66\x66\x00\x01', 'BYTE'),
-        (b'\x66\x66\x00\x02', 'ASCII'),
-        (b'\x66\x66\x00\x03', 'SHORT'),
-        (b'\x66\x66\x00\x04', 'LONG'),
-        (b'\x66\x66\x00\x05', 'RATIONAL'),
-        (b'\x66\x66\x00\x06', 'CUSTOM'),
-    ])
+    @pytest.fixture(
+        params=[
+            (b"\x66\x66\x00\x01", "BYTE"),
+            (b"\x66\x66\x00\x02", "ASCII"),
+            (b"\x66\x66\x00\x03", "SHORT"),
+            (b"\x66\x66\x00\x04", "LONG"),
+            (b"\x66\x66\x00\x05", "RATIONAL"),
+            (b"\x66\x66\x00\x06", "CUSTOM"),
+        ]
+    )
     def fixture(
-            self, request, ifd_entry_, _IfdEntry_, _AsciiIfdEntry_,
-            _ShortIfdEntry_, _LongIfdEntry_, _RationalIfdEntry_):
+        self,
+        request,
+        ifd_entry_,
+        _IfdEntry_,
+        _AsciiIfdEntry_,
+        _ShortIfdEntry_,
+        _LongIfdEntry_,
+        _RationalIfdEntry_,
+    ):
         bytes_, entry_type = request.param
         entry_cls_ = {
-            'BYTE':     _IfdEntry_,
-            'ASCII':    _AsciiIfdEntry_,
-            'SHORT':    _ShortIfdEntry_,
-            'LONG':     _LongIfdEntry_,
-            'RATIONAL': _RationalIfdEntry_,
-            'CUSTOM':   _IfdEntry_,
+            "BYTE": _IfdEntry_,
+            "ASCII": _AsciiIfdEntry_,
+            "SHORT": _ShortIfdEntry_,
+            "LONG": _LongIfdEntry_,
+            "RATIONAL": _RationalIfdEntry_,
+            "CUSTOM": _IfdEntry_,
         }[entry_type]
         stream_rdr = StreamReader(BytesIO(bytes_), BIG_ENDIAN)
         offset = 0
@@ -347,35 +347,31 @@ def ifd_entry_(self, request):
 
     @pytest.fixture
     def _IfdEntry_(self, request, ifd_entry_):
-        _IfdEntry_ = class_mock(request, 'docx.image.tiff._IfdEntry')
+        _IfdEntry_ = class_mock(request, "docx.image.tiff._IfdEntry")
         _IfdEntry_.from_stream.return_value = ifd_entry_
         return _IfdEntry_
 
     @pytest.fixture
     def _AsciiIfdEntry_(self, request, ifd_entry_):
-        _AsciiIfdEntry_ = class_mock(
-            request, 'docx.image.tiff._AsciiIfdEntry')
+        _AsciiIfdEntry_ = class_mock(request, "docx.image.tiff._AsciiIfdEntry")
         _AsciiIfdEntry_.from_stream.return_value = ifd_entry_
         return _AsciiIfdEntry_
 
     @pytest.fixture
     def _ShortIfdEntry_(self, request, ifd_entry_):
-        _ShortIfdEntry_ = class_mock(
-            request, 'docx.image.tiff._ShortIfdEntry')
+        _ShortIfdEntry_ = class_mock(request, "docx.image.tiff._ShortIfdEntry")
         _ShortIfdEntry_.from_stream.return_value = ifd_entry_
         return _ShortIfdEntry_
 
     @pytest.fixture
     def _LongIfdEntry_(self, request, ifd_entry_):
-        _LongIfdEntry_ = class_mock(
-            request, 'docx.image.tiff._LongIfdEntry')
+        _LongIfdEntry_ = class_mock(request, "docx.image.tiff._LongIfdEntry")
         _LongIfdEntry_.from_stream.return_value = ifd_entry_
         return _LongIfdEntry_
 
     @pytest.fixture
     def _RationalIfdEntry_(self, request, ifd_entry_):
-        _RationalIfdEntry_ = class_mock(
-            request, 'docx.image.tiff._RationalIfdEntry')
+        _RationalIfdEntry_ = class_mock(request, "docx.image.tiff._RationalIfdEntry")
         _RationalIfdEntry_.from_stream.return_value = ifd_entry_
         return _RationalIfdEntry_
 
@@ -385,11 +381,10 @@ def offset_(self, request):
 
 
 class Describe_IfdEntry(object):
-
     def it_can_construct_from_a_stream_and_offset(
         self, _parse_value_, _IfdEntry__init_, value_
     ):
-        bytes_ = b'\x00\x01\x66\x66\x00\x00\x00\x02\x00\x00\x00\x03'
+        bytes_ = b"\x00\x01\x66\x66\x00\x00\x00\x02\x00\x00\x00\x03"
         stream_rdr = StreamReader(BytesIO(bytes_), BIG_ENDIAN)
         offset, tag_code, value_count, value_offset = 0, 1, 2, 3
         _parse_value_.return_value = value_
@@ -415,44 +410,40 @@ def _IfdEntry__init_(self, request):
 
     @pytest.fixture
     def _parse_value_(self, request):
-        return method_mock(request, _IfdEntry, '_parse_value',  autospec=False)
+        return method_mock(request, _IfdEntry, "_parse_value", autospec=False)
 
     @pytest.fixture
     def value_(self, request):
         return loose_mock(request)
 
 
 class Describe_AsciiIfdEntry(object):
-
     def it_can_parse_an_ascii_string_IFD_entry(self):
-        bytes_ = b'foobar\x00'
+        bytes_ = b"foobar\x00"
         stream_rdr = StreamReader(BytesIO(bytes_), BIG_ENDIAN)
         val = _AsciiIfdEntry._parse_value(stream_rdr, None, 7, 0)
-        assert val == 'foobar'
+        assert val == "foobar"
 
 
 class Describe_ShortIfdEntry(object):
-
     def it_can_parse_a_short_int_IFD_entry(self):
-        bytes_ = b'foobaroo\x00\x2A'
+        bytes_ = b"foobaroo\x00\x2A"
         stream_rdr = StreamReader(BytesIO(bytes_), BIG_ENDIAN)
         val = _ShortIfdEntry._parse_value(stream_rdr, 0, 1, None)
         assert val == 42
 
 
 class Describe_LongIfdEntry(object):
-
     def it_can_parse_a_long_int_IFD_entry(self):
-        bytes_ = b'foobaroo\x00\x00\x00\x2A'
+        bytes_ = b"foobaroo\x00\x00\x00\x2A"
         stream_rdr = StreamReader(BytesIO(bytes_), BIG_ENDIAN)
         val = _LongIfdEntry._parse_value(stream_rdr, 0, 1, None)
         assert val == 42
 
 
 class Describe_RationalIfdEntry(object):
-
     def it_can_parse_a_rational_IFD_entry(self):
-        bytes_ = b'\x00\x00\x00\x2A\x00\x00\x00\x54'
+        bytes_ = b"\x00\x00\x00\x2A\x00\x00\x00\x54"
         stream_rdr = StreamReader(BytesIO(bytes_), BIG_ENDIAN)
         val = _RationalIfdEntry._parse_value(stream_rdr, None, 1, 0)
         assert val == 0.5
diff --git a/tests/opc/test_part.py b/tests/opc/test_part.py
@@ -482,6 +482,8 @@ def reltype_2_(self, request):
 
 
 class DescribeXmlPart(object):
+    """Unit-test suite for `docx.opc.part.XmlPart` object."""
+
     def it_can_be_constructed_by_PartFactory(
         self, partname_, content_type_, blob_, package_, element_, parse_xml_, __init_
     ):
diff --git a/tests/unitutil/mock.py b/tests/unitutil/mock.py
@@ -70,9 +70,7 @@ def instance_mock(request, cls, name=None, spec_set=True, **kwargs):
     the Mock() call that creates the mock.
     """
     name = name if name is not None else request.fixturename
-    return create_autospec(
-        cls, _name=name, spec_set=spec_set, instance=True, **kwargs
-    )
+    return create_autospec(cls, _name=name, spec_set=spec_set, instance=True, **kwargs)
 
 
 def loose_mock(request, name=None, **kwargs):
@@ -97,10 +95,8 @@ def method_mock(request, cls, method_name, autospec=True, **kwargs):
 
 
 def open_mock(request, module_name, **kwargs):
-    """
-    Return a mock for the builtin `open()` method in *module_name*.
-    """
-    target = '%s.open' % module_name
+    """Return a mock for the builtin `open()` method in *module_name*."""
+    target = "%s.open" % module_name
     _patch = patch(target, mock_open(), create=True, **kwargs)
     request.addfinalizer(_patch.stop)
     return _patch.start()
