Fixes after rebase

Author: dagwieers

.pylintrc

@@ -4,3 +4,4 @@ disable=
     import-outside-toplevel,  # Done on purpose to reduce overhead at startup
     invalid-name,  # Module name or methods do not follow snake_case convention
     line-too-long,  # Flake8 is used for testing line-length
+max-line-length=160

lib/AddonSignals.py

@@ -6,11 +6,12 @@
 
 
 class WaitTimeoutError(Exception):
-    pass
+    """ Exception used when waiting times out"""
 
 
 def _perf_clock():
     """Provides high resolution timing in seconds"""
+    import time
     if hasattr(time, 'perf_counter'):
         return time.perf_counter()  # pylint: disable=no-member
     if hasattr(time, 'clock'):
@@ -27,6 +28,20 @@ def _addon_id():
     return getattr(_addon_id, 'cached')
 
 
+def _to_unicode(text, encoding='utf-8', errors='strict'):
+    """Force text to unicode"""
+    if isinstance(text, bytes):
+        return text.decode(encoding, errors=errors)
+    return text
+
+
+def _receiver():
+    """Return a SignalReceiver instance and cache it as a static variable"""
+    if not hasattr(_receiver, 'cached'):
+        _receiver.cached = SignalReceiver()
+    return getattr(_receiver, 'cached')
+
+
 def _decode_data(data):
     """Decode base64-encoded JSON data and return Python data structure"""
     import json
@@ -50,13 +65,6 @@ def _encode_data(data):
     return encoded_data.decode('ascii')
 
 
-def _receiver():
-    """Return a SignalReceiver instance and cache it as a static variable"""
-    if not hasattr(_receiver, 'cached'):
-        _receiver.cached = SignalReceiver()
-    return getattr(_receiver, 'cached')
-
-
 def _jsonrpc(**kwargs):
     """Perform JSONRPC calls"""
     import json
@@ -67,20 +75,11 @@ def _jsonrpc(**kwargs):
     return json.loads(executeJSONRPC(json.dumps(kwargs)))
 
 
-def _to_unicode(text, encoding='utf-8', errors='strict'):
-    """Force text to unicode"""
-    if isinstance(text, bytes):
-        return text.decode(encoding, errors=errors)
-    return text
-
-
 class SignalReceiver(Monitor, object):  # pylint: disable=bad-option-value,useless-object-inheritance
     """The AddonSignals receiver class"""
-
     def __init__(self):  # pylint: disable=super-init-not-called
-        """The SignalReceiver constructor"""
         self._slots = {}
-        super(SignalReceiver, self).__init__()
+        super(SignalReceiver, self).__init__()  # pylint: disable=super-with-arguments
 
     def registerSlot(self, signaler_id, signal, callback):
         """Register a slot in the AddonSignals receiver"""
@@ -111,16 +110,16 @@ def onNotification(self, sender, method, data):
 
 class CallHandler(object):  # pylint: disable=bad-option-value,useless-object-inheritance
     """The AddonSignals event handler class"""
-
-    def __init__(self, signal, data, source_id, timeout=1000, use_timeout_exception=False):
-        ''' The CallHandler constructor '''
+    def __init__(self, signal, data, source_id, timeout=1000, use_timeout_exception=False):  # pylint: disable=too-many-arguments
+        """The CallHandler constructor"""
         self.signal = signal
+        self.data = data
         self.timeout = timeout
         self.source_id = source_id
         self._return = None
         self.is_callback_received = False
         self.use_timeout_exception = use_timeout_exception
-        registerSlot(self.source_id, '_return.{0}'.format(self.signal), self.callback)
+        registerSlot(self.source_id, '_return_{0}'.format(self.signal), self.callback)
         sendSignal(signal, data, self.source_id)
 
     def callback(self, data):
@@ -130,17 +129,17 @@ def callback(self, data):
 
     def waitForReturn(self):
         """Wait for callback to trigger"""
-        monitor = xbmc.Monitor()
+        monitor = Monitor()
         end_time = _perf_clock() + (self.timeout / 1000)
         while not self.is_callback_received:
             if _perf_clock() > end_time:
                 if self.use_timeout_exception:
                     unRegisterSlot(self.source_id, self.signal)
                     raise WaitTimeoutError
                 break
-            elif monitor.abortRequested():
+            if monitor.abortRequested():
                 raise OSError
-            xbmc.sleep(10)
+            sleep(10)
         unRegisterSlot(self.source_id, self.signal)
         return self._return
 
@@ -183,7 +182,7 @@ def returnCall(signal, data=None, source_id=None):
     :param data: data to send
     :param source_id: the name used for call/answer (e.g. add-on id)
     """
-    sendSignal('_return.{0}'.format(signal), data, source_id)
+    sendSignal('_return_{0}'.format(signal), data, source_id)
 
 
 def makeCall(signal, data=None, source_id=None, timeout_ms=1000, use_timeout_exception=False):

tests/test_calls.py

@@ -58,9 +58,10 @@ def test_unicode(self):
         self.assertEqual(ret, dict(value='return_unicode', data=data))
 
     def test_bogus_sender(self):
-        ret = makeCall(signal='test_bogus_sender', data=dict(bogus='data'), source_id='bogus.sender.id')
+        with self.assertRaises(OSError) as ctxt:
+            makeCall(signal='test_bogus_sender', data=dict(bogus='data'), source_id='bogus.sender.id')
+        self.assertTrue(isinstance(ctxt.exception, OSError))
 #        self.assertNotEqual(data, callback_bogus_sender.data)
-        self.assertEqual(ret, None)
 
     def test_send_multiple(self):
         for idx in range(3):

tests/xbmc.py

@@ -26,13 +26,30 @@ class Monitor(object):
 
     def __init__(self, line='', heading=''):  # pylint: disable=unused-argument
         """A stub constructor for the xbmc Monitor class"""
+        self.iteration = 0
         self._instances.add(weakref.ref(self))
 
+    def abortRequested(self):
+        """A stub implementation for the xbmc Keyboard class abortRequested() method"""
+        self.iteration += 1
+        print('Iteration: %s' % self.iteration)
+        return self.iteration % 5 == 0
+
+    def waitForAbort(self, timeout=None):  # pylint: disable=no-self-use
+        """A stub implementation for the xbmc Monitor class waitForAbort() method"""
+        try:
+            time.sleep(timeout)
+        except KeyboardInterrupt:
+            return True
+        except Exception:  # pylint: disable=broad-except
+            return True
+        return False
+
     @classmethod
     def getinstances(cls):
         """Return the instances for this class"""
         dead = set()
-        for ref in cls._instances:
+        for ref in cls._instances.copy():
             obj = ref()
             if obj is not None:
                 yield obj