Separated the concerns of unit testing descriptor stack trace behavio…

…r; expanded rpyc.service support to decorators

rpyc/utils/__init__.py

@@ -8,6 +8,9 @@
 
 def service(cls):
     """find and rename exposed decorated attributes"""
+    # NOTE: inspect.getmembers invokes getattr for each attribute-name. Descriptors may raise AttributeError.
+    # Only the AttributeError exception is caught when raised. This decorator will if a descriptor raises
+    # any exception other than AttributeError when getattr is called.
     for attr_name, attr_obj in inspect.getmembers(cls):  # rebind exposed decorated attributes
         exposed_prefix = getattr(attr_obj, '__exposed__', False)
         if exposed_prefix and not inspect.iscode(attr_obj):  # exclude the implementation
@@ -26,11 +29,11 @@ def exposed(arg):
         # When the arg is a string (i.e. `@rpyc.exposed("customPrefix_")`) the prefix
         # is partially evaluated into the wrapper. The function returned is "frozen" and used as a decorator.
         return functools.partial(_wrapper, arg)
-    elif hasattr(arg, '__call__'):
+    elif hasattr(arg, '__call__') or hasattr(arg, '__get__'):
         # When the arg is callable (i.e. `@rpyc.exposed`) then use default prefix and invoke
         return _wrapper(exposed_prefix, arg)
     else:
-        raise TypeError('rpyc.exposed expects a callable object or a string')
+        raise TypeError('rpyc.exposed expects a callable object, descriptor, or string')
 
 
 def _wrapper(exposed_prefix, exposed_obj):

tests/test_attr_access.py

@@ -74,16 +74,6 @@ def _rpyc_getattr(_, name):
 SVC_RESTRICTED = ["exposed_foobar", "__add__", "_privy", "foo", "bar"]
 
 
-class MyDescriptor1(object):
-    def __get__(self, instance, owner=None):
-        raise AttributeError("abcd")
-
-
-class MyDescriptor2(object):
-    def __get__(self, instance, owner=None):
-        raise RuntimeError("efgh")
-
-
 class MyService(rpyc.Service):
     exposed_MyClass = MyClass
 
@@ -96,10 +86,6 @@ def exposed_get_two(self):
         protector.register(YourClass, ["lala", "baba"])
         return protector.wrap(YourClass())
 
-    exposed_desc_1 = MyDescriptor1()
-
-    exposed_desc_2 = MyDescriptor2()
-
 
 class TestRestricted(unittest.TestCase):
     def setUp(self):
@@ -166,11 +152,6 @@ def test_default_config(self):
         self.assertRaises(AttributeError, lambda: obj.foo)
         self.assertRaises(AttributeError, lambda: obj.bar)
         self.assertRaises(AttributeError, lambda: obj.spam)
-        root = self.conn.root
-        self.assertRaisesRegex(AttributeError, "abcd", lambda: root.exposed_desc_1)
-        self.assertRaisesRegex(AttributeError, "abcd", lambda: root.desc_1)
-        self.assertRaisesRegex(RuntimeError, "efgh", lambda: root.exposed_desc_2)
-        self.assertRaisesRegex(RuntimeError, "efgh", lambda: root.desc_2)
 
     def test_allow_all(self):
         self._reset_cfg()
@@ -181,11 +162,6 @@ def test_allow_all(self):
         self.assertEqual(obj._privy(), "privy")
         self.assertEqual(obj.foobar(), "Fee Fie Foe Foo")
         self.assertEqual(obj.exposed_foobar(), "Fee Fie Foe Foo")
-        root = self.conn.root
-        self.assertRaisesRegex(AttributeError, "abcd", lambda: root.exposed_desc_1)
-        self.assertRaisesRegex(AttributeError, "abcd", lambda: root.desc_1)
-        self.assertRaisesRegex(RuntimeError, "efgh", lambda: root.exposed_desc_2)
-        self.assertRaisesRegex(RuntimeError, "efgh", lambda: root.desc_2)
 
     def test_allow_exposed(self):
         self._reset_cfg()
@@ -196,11 +172,6 @@ def test_allow_exposed(self):
         except Exception:
             passed = True
         self.assertEqual(passed, True)
-        root = self.conn.root
-        self.assertRaises(AttributeError, lambda: root.exposed_desc_1)
-        self.assertRaises(AttributeError, lambda: root.desc_1)
-        self.assertRaises(AttributeError, lambda: root.exposed_desc_2)
-        self.assertRaises(AttributeError, lambda: root.desc_2)
 
     def test_allow_safe_attrs(self):
         self._reset_cfg()
@@ -213,11 +184,6 @@ def test_allow_safe_attrs(self):
         self.assertRaises(AttributeError, lambda: obj.foo)
         self.assertRaises(AttributeError, lambda: obj.bar)
         self.assertRaises(AttributeError, lambda: obj.spam)
-        root = self.conn.root
-        self.assertRaisesRegex(AttributeError, "abcd", lambda: root.exposed_desc_1)
-        self.assertRaisesRegex(AttributeError, "abcd", lambda: root.desc_1)
-        self.assertRaisesRegex(RuntimeError, "efgh", lambda: root.exposed_desc_2)
-        self.assertRaisesRegex(RuntimeError, "efgh", lambda: root.desc_2)
 
     def test_allow_public_attrs(self):
         self._reset_cfg()
@@ -229,31 +195,58 @@ def test_allow_public_attrs(self):
         self.assertEqual(obj.foobar(), "Fee Fie Foe Foo")
         self.assertEqual(obj.exposed_foobar(), "Fee Fie Foe Foo")
         self.assertRaises(AttributeError, lambda: obj._privy)
+
+
+class MyDescriptor1(object):
+    def __get__(self, instance, owner=None):
+        raise AttributeError("abcd")
+
+
+class MyDescriptor2(object):
+    def __get__(self, instance, owner=None):
+        if instance is None:
+            return self
+        else:
+            raise RuntimeError("efgh")
+
+
+@rpyc.service
+class MyDecoratedService(rpyc.Service):
+    desc_1 = rpyc.exposed(MyDescriptor1())
+    exposed_desc_2 = MyDescriptor2()
+
+
+class TestDescriptorErrors(unittest.TestCase):
+    def setUp(self):
+        self.cfg = copy.copy(rpyc.core.protocol.DEFAULT_CONFIG)
+        self.server = ThreadedServer(MyDecoratedService(), port=0)
+        self.thd = self.server._start_in_thread()
+        self.conn = rpyc.connect("localhost", self.server.port)
+
+    def tearDown(self):
+        self.conn.close()
+        while self.server.clients:
+            pass
+        self.server.close()
+        self.thd.join()
+
+    def test_default_config(self):
         root = self.conn.root
         self.assertRaisesRegex(AttributeError, "abcd", lambda: root.exposed_desc_1)
         self.assertRaisesRegex(AttributeError, "abcd", lambda: root.desc_1)
         self.assertRaisesRegex(RuntimeError, "efgh", lambda: root.exposed_desc_2)
         self.assertRaisesRegex(RuntimeError, "efgh", lambda: root.desc_2)
 
-#    def test_type_protector(self):
-#        obj = self.conn.root.get_two()
-#        assert obj.baba() == "baba"
-#        try:
-#            obj.gaga()
-#        except AttributeError:
-#            pass
-#        else:
-#            assert False, "expected an attribute error!"
-#        obj2 = obj.lala()
-#        assert obj2.foo() == "foo"
-#        assert obj2.spam() == "spam"
-#        try:
-#            obj.bar()
-#        except AttributeError:
-#            pass
-#        else:
-#            assert False, "expected an attribute error!"
-#
+    def test_allow_all(self):
+        self.cfg['allow_all_attrs'] = True
+        self.conn.close()
+        self.server.protocol_config.update(self.cfg)
+        self.conn = rpyc.connect("localhost", self.server.port)
+        root = self.conn.root
+        self.assertRaisesRegex(AttributeError, "abcd", lambda: root.exposed_desc_1)
+        self.assertRaisesRegex(AttributeError, "abcd", lambda: root.desc_1)
+        self.assertRaisesRegex(RuntimeError, "efgh", lambda: root.exposed_desc_2)
+        self.assertRaisesRegex(RuntimeError, "efgh", lambda: root.desc_2)
 
 
 if __name__ == "__main__":