py3: extract cls_method_fn()

Steve Canny · Steve Canny · commit 31f88dafa845 · 2014-01-07T02:51:57.000-08:00
diff --git a/docx/opc/compat.py b/docx/opc/compat.py
@@ -16,6 +16,13 @@
 
 if sys.version_info >= (3, 0):
 
+    def cls_method_fn(cls, method_name):
+        """
+        Return the function object associated with the method of *cls* having
+        *method_name*.
+        """
+        return getattr(cls, method_name)
+
     def is_string(obj):
         """
         Return True if *obj* is a string, False otherwise.
@@ -28,6 +35,14 @@ def is_string(obj):
 
 else:
 
+    def cls_method_fn(cls, method_name):
+        """
+        Return the function object associated with the method of *cls* having
+        *method_name*.
+        """
+        unbound_method = getattr(cls, method_name)
+        return unbound_method.__func__
+
     def is_string(obj):
         """
         Return True if *obj* is a string, False otherwise.
diff --git a/docx/opc/package.py b/docx/opc/package.py
@@ -7,6 +7,7 @@
 
 from __future__ import absolute_import, print_function, unicode_literals
 
+from .compat import cls_method_fn
 from .constants import RELATIONSHIP_TYPE as RT
 from .oxml import CT_Relationships, nsmap, serialize_part_xml
 from .packuri import PACKAGE_URI, PackURI
@@ -333,7 +334,7 @@ class PartFactory(object):
     def __new__(cls, partname, content_type, reltype, blob, package):
         PartClass = None
         if cls.part_class_selector is not None:
-            part_class_selector = cls.part_class_selector.__func__
+            part_class_selector = cls_method_fn(cls, 'part_class_selector')
             PartClass = part_class_selector(content_type, reltype)
         if PartClass is None:
             PartClass = cls._part_cls_for(content_type)
diff --git a/tests/opc/test_package.py b/tests/opc/test_package.py
@@ -19,7 +19,8 @@
 from docx.opc.pkgreader import PackageReader
 
 from ..unitutil import (
-    cls_attr_mock, class_mock, instance_mock, loose_mock, method_mock
+    cls_attr_mock, class_mock, function_mock, instance_mock, loose_mock,
+    method_mock
 )
 
 
@@ -384,15 +385,14 @@ class DescribePartFactory(object):
     def it_constructs_part_from_selector_if_defined(
             self, cls_selector_fixture):
         # fixture ----------------------
-        (cls_selector_fn_, partname, content_type, reltype, blob, package,
-         CustomPartClass_, part_of_custom_type_) = cls_selector_fixture
+        (cls_selector_fn_, part_load_params, CustomPartClass_,
+         part_of_custom_type_) = cls_selector_fixture
+        partname, content_type, reltype, blob, package = part_load_params
         # exercise ---------------------
         PartFactory.part_class_selector = cls_selector_fn_
         part = PartFactory(partname, content_type, reltype, blob, package)
         # verify -----------------------
-        cls_selector_fn_.__func__.assert_called_once_with(
-            content_type, reltype
-        )
+        cls_selector_fn_.assert_called_once_with(content_type, reltype)
         CustomPartClass_.load.assert_called_once_with(
             partname, content_type, blob, package
         )
@@ -430,25 +430,34 @@ def blob_(self, request):
     def blob_2_(self, request):
         return instance_mock(request, str)
 
+    @pytest.fixture
+    def cls_method_fn_(self, request, cls_selector_fn_):
+        return function_mock(
+            request, 'docx.opc.package.cls_method_fn',
+            return_value=cls_selector_fn_
+        )
+
     @pytest.fixture
     def cls_selector_fixture(
-            self, request, cls_selector_fn_, partname_, content_type_,
-            reltype_, blob_, package_, CustomPartClass_,
-            part_of_custom_type_):
+            self, request, cls_selector_fn_, cls_method_fn_, part_load_params,
+            CustomPartClass_, part_of_custom_type_):
         def reset_part_class_selector():
             PartFactory.part_class_selector = original_part_class_selector
         original_part_class_selector = PartFactory.part_class_selector
         request.addfinalizer(reset_part_class_selector)
         return (
-            cls_selector_fn_, partname_, content_type_, reltype_,
-            blob_, package_, CustomPartClass_, part_of_custom_type_
+            cls_selector_fn_, part_load_params, CustomPartClass_,
+            part_of_custom_type_
         )
 
     @pytest.fixture
     def cls_selector_fn_(self, request, CustomPartClass_):
         cls_selector_fn_ = loose_mock(request)
+        # Python 3 version
+        cls_selector_fn_.return_value = CustomPartClass_
+        # Python 2 version
         cls_selector_fn_.__func__ = loose_mock(
-            request, name='__func__', return_value=CustomPartClass_
+            request, name='__func__', return_value=cls_selector_fn_
         )
         return cls_selector_fn_
 
@@ -482,6 +491,11 @@ def package_(self, request):
     def package_2_(self, request):
         return instance_mock(request, OpcPackage)
 
+    @pytest.fixture
+    def part_load_params(
+            self, partname_, content_type_, reltype_, blob_, package_):
+        return partname_, content_type_, reltype_, blob_, package_
+
     @pytest.fixture
     def part_of_custom_type_(self, request):
         return instance_mock(request, Part)
diff --git a/tests/unitutil.py b/tests/unitutil.py
@@ -70,12 +70,12 @@ def cls_attr_mock(request, cls, attr_name, name=None, **kwargs):
     return _patch.start()
 
 
-def function_mock(request, q_function_name):
+def function_mock(request, q_function_name, **kwargs):
     """
     Return a mock patching the function with qualified name
     *q_function_name*. Patch is reversed after calling test returns.
     """
-    _patch = patch(q_function_name)
+    _patch = patch(q_function_name, **kwargs)
     request.addfinalizer(_patch.stop)
     return _patch.start()
 
