Add test coverage for has_attr_safe

rybarczykj · rybarczykj · commit d410c8ce8036 · 2020-08-03T10:35:26.000-05:00
diff --git a/bpython/autocomplete.py b/bpython/autocomplete.py
@@ -340,9 +340,6 @@ def attr_matches(self, text, namespace):
         """Taken from rlcompleter.py and bent to my will.
         """
 
-        # Gna, Py 2.6's rlcompleter searches for __call__ inside the
-        # instance instead of the type, so we monkeypatch to prevent
-        # side-effects (__getattr__/__getattribute__)
         m = self.attr_matches_re.match(text)
         if not m:
             return []
@@ -364,7 +361,7 @@ def attr_lookup(self, obj, expr, attr):
         be wrapped in a safe try/finally block in case anything bad happens to
         restore the original __getattribute__ method."""
         words = self.list_attributes(obj)
-        if inspection.has_attr_safe(obj, "__class__"):
+        if inspection.hasattr_safe(obj, "__class__"):
             words.append("__class__")
             words = words + rlcompleter.get_class_members(obj.__class__)
             if not isinstance(obj.__class__, abc.ABCMeta):
@@ -537,7 +534,7 @@ def matches(self, cursor_offset, line, **kwargs):
         except EvaluationError:
             return set()
 
-        # strips leading dot
+         #        strips leading dot
         matches = [m[1:] for m in self.attr_lookup(obj, "", attr.word)]
         return set(m for m in matches if few_enough_underscores(attr.word, m))
 
@@ -677,7 +674,6 @@ def get_completer_bpython(cursor_offset, line, **kwargs):
 
 def _callable_postfix(value, word):
     """rlcompleter's _callable_postfix done right."""
-    # TODO: do we need this done within an AttrCleaner?
     if inspection.is_callable(value):
         word += "("
     return word
diff --git a/bpython/inspection.py b/bpython/inspection.py
@@ -215,7 +215,7 @@ def getpydocspec(f, func):
     if s is None:
         return None
 
-    if not has_attr_safe(f, "__name__") or s.groups()[0] != f.__name__:
+    if not hasattr_safe(f, "__name__") or s.groups()[0] != f.__name__:
         return None
 
     args = list()
@@ -394,7 +394,7 @@ def get_encoding_file(fname):
 
 if not py3:
 
-    def get_attr_safe(obj, name):
+    def getattr_safe(obj, name):
         """side effect free getattr"""
         if not is_new_style(obj):
             return getattr(obj, name)
@@ -416,18 +416,18 @@ def get_attr_safe(obj, name):
 
 else:
 
-    def get_attr_safe(obj, name):
-        """side effect and AttrCleaner free getattr (calls getattr_static)."""
+    def getattr_safe(obj, name):
+        """side effect free getattr (calls getattr_static)."""
         result = inspect.getattr_static(obj, name)
         # Slots are a MemberDescriptorType
         if isinstance(result, MemberDescriptorType):
             result = getattr(obj, name)
         return result
 
 
-def has_attr_safe(obj, name):
+def hasattr_safe(obj, name):
     try:
-        get_attr_safe(obj, name)
+        getattr_safe(obj, name)
         return True
     except AttributeError:
         return False
diff --git a/bpython/simpleeval.py b/bpython/simpleeval.py
@@ -38,7 +38,7 @@
 
 from . import line as line_properties
 from ._py3compat import py3
-from .inspection import get_attr_safe
+from .inspection import getattr_safe
 
 _string_type_nodes = (ast.Str, ast.Bytes) if py3 else (ast.Str,)
 _numeric_types = (int, float, complex) + (() if py3 else (long,))
@@ -163,7 +163,7 @@ def _convert(node):
         if isinstance(node, ast.Attribute):
             obj = _convert(node.value)
             attr = node.attr
-            return get_attr_safe(obj, attr)
+            return getattr_safe(obj, attr)
 
         raise ValueError("malformed string")
 
diff --git a/bpython/test/test_inspection.py b/bpython/test/test_inspection.py
@@ -159,43 +159,53 @@ class TestSafeGetAttribute(unittest.TestCase):
         def test_lookup_on_object(self):
             a = A()
             a.x = 1
-            self.assertEqual(get_attr_safe(a, "x"), 1)
-            self.assertEqual(get_attr_safe(a, "a"), "a")
+            self.assertEqual(getattr_safe(a, "x"), 1)
+            self.assertEqual(getattr_safe(a, "a"), "a")
             b = B()
             b.y = 2
-            self.assertEqual(get_attr_safe(b, "y"), 2)
-            self.assertEqual(get_attr_safe(b, "a"), "a")
-            self.assertEqual(get_attr_safe(b, "b"), "b")
+            self.assertEqual(getattr_safe(b, "y"), 2)
+            self.assertEqual(getattr_safe(b, "a"), "a")
+            self.assertEqual(getattr_safe(b, "b"), "b")
+
+            self.assertEqual(hasattr_safe(b, "y"), True)
+            self.assertEqual(hasattr_safe(b, "b"), True)
+
 
         def test_avoid_running_properties(self):
             p = Property()
-            self.assertEqual(get_attr_safe(p, "prop"), Property.prop)
+            self.assertEqual(getattr_safe(p, "prop"), Property.prop)
+            self.assertEqual(hasattr_safe(p, "prop"), True)
         
         def test_lookup_with_slots(self):
             s = Slots()
             s.s1 = "s1"
-            self.assertEqual(get_attr_safe(s, "s1"), "s1")
+            self.assertEqual(getattr_safe(s, "s1"), "s1")
             with self.assertRaises(AttributeError):
-                get_attr_safe(s, "s2")
+                getattr_safe(s, "s2")
+
+            self.assertEqual(hasattr_safe(s, "s2"), False)
 
         def test_lookup_on_slots_classes(self):
-            sga = get_attr_safe
+            sga = getattr_safe
             s = SlotsSubclass()
             self.assertIsInstance(sga(Slots, "s1"), member_descriptor)
             self.assertIsInstance(sga(SlotsSubclass, "s1"), member_descriptor)
             self.assertIsInstance(sga(SlotsSubclass, "s4"), property)
             self.assertIsInstance(sga(s, "s4"), property)
 
+            self.assertEqual(hasattr_safe(s, "s1"), True)
+            self.assertEqual(hasattr_safe(s, "s4"), True)
+
         @unittest.skipIf(py3, "Py 3 doesn't allow slots and prop in same class")
         def test_lookup_with_property_and_slots(self):
-            sga = get_attr_safe
+            sga = getattr_safe
             s = SlotsSubclass()
             self.assertIsInstance(sga(Slots, "s3"), property)
-            self.assertEqual(get_attr_safe(s, "s3"), Slots.__dict__["s3"])
+            self.assertEqual(getattr_safe(s, "s3"), Slots.__dict__["s3"])
             self.assertIsInstance(sga(SlotsSubclass, "s3"), property)
 
         def test_lookup_on_overridden_methods(self):
-            sga = get_attr_safe
+            sga = getattr_safe
             self.assertEqual(sga(OverriddenGetattr(), "a"), 1)
             self.assertEqual(sga(OverriddenGetattribute(), "a"), 1)
             self.assertEqual(sga(OverriddenMRO(), "a"), 1)
@@ -206,6 +216,12 @@ def test_lookup_on_overridden_methods(self):
             with self.assertRaises(AttributeError):
                 sga(OverriddenMRO(), "b")
 
+            self.assertEqual(hasattr_safe(OverriddenGetattr(), "b"), False)
+            self.assertEqual(hasattr_safe(OverriddenGetattribute(), "b"), False)
+            self.assertEqual(hasattr_safe(OverriddenMRO(), "b"), False)
+            
+
+
 
 if __name__ == "__main__":
     unittest.main()
