Added handling for pytest-mocker>=1.11.2 context manager restriction

Author: amorozenko

README.md

@@ -64,6 +64,8 @@ You can run unit tests for cPython version of library (blynklib.py) using the co
 
     python setup.py test
 
+**NOTE** Blynklib version <0.2.6 should use pytest-mock<1.11.2. In version 1.11.2 were added restrictions for context manager usage
+
 **NOTE:** Unit tests for Micropython ENV are not available yet.
 
 #### Micropython installation

blynklib.py

@@ -202,7 +202,7 @@ def _get_socket(self):
             self._socket.connect(socket.getaddrinfo(self.server, self.port)[0][4])
             self._socket.settimeout(self.SOCK_TIMEOUT)
             if self.ssl_cert:
-                # system’s default CA certificates case
+                # system default CA certificates case
                 if self.ssl_cert == "default":
                     self.ssl_cert = None
                 self.log('Using SSL socket...')

setup.py

@@ -14,7 +14,7 @@
     author='Anton Morozenko',
     author_email='antoha.ua@gmail.com',
     setup_requires=['pytest-runner', ],
-    tests_require=['pytest', 'pytest-mock', ],
+    tests_require=['pytest', 'pytest-mock>=1.11.2', ],
     py_modules=['blynklib', 'blynktimer'],
     classifiers=[
         "Programming Language :: Python :: 2.7",

test/test_blynk_connection.py

@@ -86,9 +86,9 @@ def test_is_server_alive_negative(self, cb):
 
     def test_is_server_alive_positive_ping(self, cb, mocker):
         cb._last_rcv_time = int(time.time() * 1000)
-        with mocker.patch.object(cb, 'send', return_value=None):
-            result = cb.is_server_alive()
-            assert result is True
+        mocker.patch.object(cb, 'send', return_value=None)
+        result = cb.is_server_alive()
+        assert result is True
 
     def test_is_server_alive_positive_no_ping_1(self, cb):
         cb._last_rcv_time = int(time.time() * 1000)
@@ -116,59 +116,59 @@ def test_get_socket_exception(self, cb, mocker):
                 assert 'Connection with the Blynk server failed: BE' in str(b_err.value)
 
     def test_authenticate(self, cb, mocker):
-        with mocker.patch.object(cb, 'send', return_value=None):
-            with mocker.patch.object(cb, 'receive', return_value=b'\x00\x00\x02\x00\xc8'):
-                cb._authenticate()
-                assert cb._state == cb.AUTHENTICATED
+        mocker.patch.object(cb, 'send', return_value=None)
+        mocker.patch.object(cb, 'receive', return_value=b'\x00\x00\x02\x00\xc8')
+        cb._authenticate()
+        assert cb._state == cb.AUTHENTICATED
 
     def test_authenticate_invalid_auth_token(self, cb, mocker):
-        with mocker.patch.object(cb, 'send', return_value=None):
-            with mocker.patch.object(cb, 'receive', return_value=b'\x00\x00\x02\x00\x09'):
-                with pytest.raises(BlynkError) as b_err:
-                    cb._authenticate()
-                assert 'Invalid Auth Token' in str(b_err.value)
+        mocker.patch.object(cb, 'send', return_value=None)
+        mocker.patch.object(cb, 'receive', return_value=b'\x00\x00\x02\x00\x09')
+        with pytest.raises(BlynkError) as b_err:
+            cb._authenticate()
+            assert 'Invalid Auth Token' in str(b_err.value)
 
     def test_authenticate_redirect_message(self, cb, mocker):
-        with mocker.patch.object(cb, 'send', return_value=None):
-            with mocker.patch.object(cb, 'receive', return_value=b'\x29\x00\x02\x00\x11127.0.0.1\x004444'):
-                with pytest.raises(RedirectError) as r_err:
-                    cb._authenticate()
-                # pytest exception wraps real exception - so we need access value field first
-                assert '127.0.0.1' in r_err.value.server
-                assert '4444' in r_err.value.port
+        mocker.patch.object(cb, 'send', return_value=None)
+        mocker.patch.object(cb, 'receive', return_value=b'\x29\x00\x02\x00\x11127.0.0.1\x004444')
+        with pytest.raises(RedirectError) as r_err:
+            cb._authenticate()
+            # pytest exception wraps real exception - so we need access value field first
+            assert '127.0.0.1' in r_err.value.server
+            assert '4444' in r_err.value.port
 
     def test_authenticate_not_ok_status(self, cb, mocker):
-        with mocker.patch.object(cb, 'send', return_value=None):
-            with mocker.patch.object(cb, 'receive', return_value=b'\x00\x00\x02\x00\x19'):
-                with pytest.raises(BlynkError) as b_err:
-                    cb._authenticate()
-                assert 'Auth stage failed. Status=25' in str(b_err.value)
+        mocker.patch.object(cb, 'send', return_value=None)
+        mocker.patch.object(cb, 'receive', return_value=b'\x00\x00\x02\x00\x19')
+        with pytest.raises(BlynkError) as b_err:
+            cb._authenticate()
+            assert 'Auth stage failed. Status=25' in str(b_err.value)
 
     def test_authenticate_timeout(self, cb, mocker):
-        with mocker.patch.object(cb, 'send', return_value=None):
-            with mocker.patch.object(cb, 'receive', return_value=None):
-                with pytest.raises(BlynkError) as b_err:
-                    cb._authenticate()
-                assert 'Auth stage timeout' in str(b_err.value)
+        mocker.patch.object(cb, 'send', return_value=None)
+        mocker.patch.object(cb, 'receive', return_value=None)
+        with pytest.raises(BlynkError) as b_err:
+            cb._authenticate()
+            assert 'Auth stage timeout' in str(b_err.value)
 
     def test_set_heartbeat_timeout(self, cb, mocker):
-        with mocker.patch.object(cb, 'send', return_value=None):
-            with mocker.patch.object(cb, 'receive', return_value=None):
-                with pytest.raises(BlynkError) as b_err:
-                    cb._set_heartbeat()
-                assert 'Heartbeat stage timeout' in str(b_err.value)
+        mocker.patch.object(cb, 'send', return_value=None)
+        mocker.patch.object(cb, 'receive', return_value=None)
+        with pytest.raises(BlynkError) as b_err:
+            cb._set_heartbeat()
+            assert 'Heartbeat stage timeout' in str(b_err.value)
 
     def test_set_heartbeat_error_status(self, cb, mocker):
-        with mocker.patch.object(cb, 'send', return_value=None):
-            with mocker.patch.object(cb, 'receive', return_value=b'\x00\x00\x02\x00\x0e'):
-                with pytest.raises(BlynkError) as b_err:
-                    cb._set_heartbeat()
-                assert 'Set heartbeat returned code=14' in str(b_err.value)
+        mocker.patch.object(cb, 'send', return_value=None)
+        mocker.patch.object(cb, 'receive', return_value=b'\x00\x00\x02\x00\x0e')
+        with pytest.raises(BlynkError) as b_err:
+            cb._set_heartbeat()
+            assert 'Set heartbeat returned code=14' in str(b_err.value)
 
     def test_set_heartbeat_positive(self, cb, mocker):
-        with mocker.patch.object(cb, 'send', return_value=None):
-            with mocker.patch.object(cb, 'receive', return_value=b'\x00\x00\x02\x00\xc8'):
-                cb._set_heartbeat()
+        mocker.patch.object(cb, 'send', return_value=None)
+        mocker.patch.object(cb, 'receive', return_value=b'\x00\x00\x02\x00\xc8')
+        cb._set_heartbeat()
 
     def test_connected_false(self, cb):
         result = cb.connected()

test/test_blynk_main.py

@@ -12,95 +12,95 @@ def bl(self):
         yield blynk
 
     def test_connect(self, bl, mocker):
-        with mocker.patch.object(bl, 'connected', return_value=False):
-            with mocker.patch.object(bl, '_get_socket', return_value=None):
-                with mocker.patch.object(bl, '_authenticate', return_value=None):
-                    with mocker.patch.object(bl, '_set_heartbeat', return_value=None):
-                        with mocker.patch.object(bl, 'call_handler', return_value=None):
-                            with mocker.patch.object(blynklib, 'ticks_ms', return_value=42):
-                                result = bl.connect()
-                                assert result is True
-                                assert bl._last_rcv_time == 42
+        mocker.patch.object(bl, 'connected', return_value=False)
+        mocker.patch.object(bl, '_get_socket', return_value=None)
+        mocker.patch.object(bl, '_authenticate', return_value=None)
+        mocker.patch.object(bl, '_set_heartbeat', return_value=None)
+        mocker.patch.object(bl, 'call_handler', return_value=None)
+        mocker.patch.object(blynklib, 'ticks_ms', return_value=42)
+        result = bl.connect()
+        assert result is True
+        assert bl._last_rcv_time == 42
 
     def test_connect_exception(self, bl, mocker):
-        with mocker.patch.object(bl, 'connected', return_value=False):
-            with mocker.patch.object(bl, '_get_socket', return_value=None):
-                with mocker.patch.object(bl, '_authenticate', side_effect=blynklib.BlynkError()):
-                    with mocker.patch.object(bl, 'disconnect', return_value=None):
-                        with mocker.patch('time.sleep', return_value=None):
-                            mocker.spy(bl, 'disconnect')
-                            result = bl.connect(0.001)
-                            assert result is False
-                            assert bl.disconnect.call_count > 1
+        mocker.patch.object(bl, 'connected', return_value=False)
+        mocker.patch.object(bl, '_get_socket', return_value=None)
+        mocker.patch.object(bl, '_authenticate', side_effect=blynklib.BlynkError())
+        mocker.patch.object(bl, 'disconnect', return_value=None)
+        mocker.patch('time.sleep', return_value=None)
+        mocker.spy(bl, 'disconnect')
+        result = bl.connect(0.001)
+        assert result is False
+        assert bl.disconnect.call_count > 1
 
     def test_connect_redirect_exception(self, bl, mocker):
-        with mocker.patch.object(bl, 'connected', return_value=False):
-            with mocker.patch.object(bl, '_get_socket', return_value=None):
-                with mocker.patch.object(bl, '_authenticate', side_effect=blynklib.RedirectError('127.0.0.1', 4444)):
-                    with mocker.patch.object(bl, 'disconnect', return_value=None):
-                        with mocker.patch('time.sleep', return_value=None):
-                            mocker.spy(bl, 'disconnect')
-                            result = bl.connect(0.001)
-                            assert result is False
-                            assert bl.disconnect.call_count > 1
-                            assert bl.server == '127.0.0.1'
-                            assert bl.port == 4444
+        mocker.patch.object(bl, 'connected', return_value=False)
+        mocker.patch.object(bl, '_get_socket', return_value=None)
+        mocker.patch.object(bl, '_authenticate', side_effect=blynklib.RedirectError('127.0.0.1', 4444))
+        mocker.patch.object(bl, 'disconnect', return_value=None)
+        mocker.patch('time.sleep', return_value=None)
+        mocker.spy(bl, 'disconnect')
+        result = bl.connect(0.001)
+        assert result is False
+        assert bl.disconnect.call_count > 1
+        assert bl.server == '127.0.0.1'
+        assert bl.port == 4444
 
     def test_connect_timeout(self, bl, mocker):
         bl._state = bl.CONNECTING
-        with mocker.patch.object(bl, 'connected', return_value=False):
-            result = bl.connect(0.001)
-            assert result is False
+        mocker.patch.object(bl, 'connected', return_value=False)
+        result = bl.connect(0.001)
+        assert result is False
 
     def test_disconnect(self, bl, mocker):
         bl._socket = socket.socket()
-        with mocker.patch('time.sleep', return_value=None):
-            bl.disconnect('123')
+        mocker.patch('time.sleep', return_value=None)
+        bl.disconnect('123')
 
     def test_virtual_write(self, bl, mocker):
-        with mocker.patch.object(bl, 'send', return_value=10):
-            result = bl.virtual_write(20, 'va1', 'val2')
-            assert result == 10
+        mocker.patch.object(bl, 'send', return_value=10)
+        result = bl.virtual_write(20, 'va1', 'val2')
+        assert result == 10
 
     def test_virtual_sync(self, bl, mocker):
-        with mocker.patch.object(bl, 'send', return_value=20):
-            result = bl.virtual_sync(20, 22)
-            assert result == 20
+        mocker.patch.object(bl, 'send', return_value=20)
+        result = bl.virtual_sync(20, 22)
+        assert result == 20
 
     def test_email(self, bl, mocker):
-        with mocker.patch.object(bl, 'send', return_value=30):
-            result = bl.email('1', '2', '3')
-            assert result == 30
+        mocker.patch.object(bl, 'send', return_value=30)
+        result = bl.email('1', '2', '3')
+        assert result == 30
 
     def test_tweet(self, bl, mocker):
-        with mocker.patch.object(bl, 'send', return_value=40):
-            result = bl.tweet('123')
-            assert result == 40
+        mocker.patch.object(bl, 'send', return_value=40)
+        result = bl.tweet('123')
+        assert result == 40
 
     def test_notify(self, bl, mocker):
-        with mocker.patch.object(bl, 'send', return_value=50):
-            result = bl.notify('123')
-            assert result == 50
+        mocker.patch.object(bl, 'send', return_value=50)
+        result = bl.notify('123')
+        assert result == 50
 
     def test_set_property(self, bl, mocker):
-        with mocker.patch.object(bl, 'send', return_value=60):
-            result = bl.set_property(1, '2', '3')
-            assert result == 60
+        mocker.patch.object(bl, 'send', return_value=60)
+        result = bl.set_property(1, '2', '3')
+        assert result == 60
 
     def test_internal(self, bl, mocker):
-        with mocker.patch.object(bl, 'send', return_value=70):
-            result = bl.internal('rtc', 'sync')
-            assert result == 70
+        mocker.patch.object(bl, 'send', return_value=70)
+        result = bl.internal('rtc', 'sync')
+        assert result == 70
 
     def test_hadle_event(self, bl):
         bl._events = {}
 
-        @bl.handle_event("connect")
+        @bl.handle_event('connect')
         def connect_handler():
             pass
 
-        @bl.handle_event("disconnect")
-        def connect_handler():
+        @bl.handle_event('disconnect')
+        def disconnect_handler():
             pass
 
         assert 'connect' in bl._events.keys()
@@ -142,10 +142,10 @@ def test_process_rsp(self, bl, mocker):
         assert bl.log.call_count == 1
 
     def test_process_ping(self, bl, mocker):
-        with mocker.patch.object(bl, 'send', return_value=None):
-            mocker.spy(bl, 'send')
-            bl.process(bl.MSG_PING, 100, 200, [])
-            assert bl.send.call_count == 1
+        mocker.patch.object(bl, 'send', return_value=None)
+        mocker.spy(bl, 'send')
+        bl.process(bl.MSG_PING, 100, 200, [])
+        assert bl.send.call_count == 1
 
     def test_process_internal(self, bl, mocker):
         bl._events = {}
@@ -154,9 +154,9 @@ def test_process_internal(self, bl, mocker):
         def internal_handler(*args):
             bl._status = 'INTERNAL TEST {}'.format(*args)
 
-        with mocker.patch.object(bl, 'send', return_value=None):
-            bl.process(bl.MSG_INTERNAL, 100, 20, ["xyz", "add", 2])
-            assert bl._status == "INTERNAL TEST ['add', 2]"
+        mocker.patch.object(bl, 'send', return_value=None)
+        bl.process(bl.MSG_INTERNAL, 100, 20, ['xyz', 'add', 2])
+        assert bl._status == "INTERNAL TEST ['add', 2]"
 
     def test_process_write(self, bl, mocker):
         bl._events = {}
@@ -165,9 +165,9 @@ def test_process_write(self, bl, mocker):
         def write_handler(pin, *values):
             bl._status = 'WRITE TEST{}'.format(*values)
 
-        with mocker.patch.object(bl, 'send', return_value=None):
-            bl.process(bl.MSG_HW, 100, 200, ['vw', 4, 1, 2])
-            assert bl._status == 'WRITE TEST[1, 2]'
+        mocker.patch.object(bl, 'send', return_value=None)
+        bl.process(bl.MSG_HW, 100, 200, ['vw', 4, 1, 2])
+        assert bl._status == 'WRITE TEST[1, 2]'
 
     def test_process_read(self, bl, mocker):
         bl._events = {}
@@ -176,6 +176,6 @@ def test_process_read(self, bl, mocker):
         def read_handler(pin):
             bl._status = 'READ TEST{}'.format(pin)
 
-        with mocker.patch.object(bl, 'send', return_value=None):
-            bl.process(bl.MSG_HW, 100, 200, ['vr', 7])
-            assert bl._status == 'READ TEST7'
+        mocker.patch.object(bl, 'send', return_value=None)
+        bl.process(bl.MSG_HW, 100, 200, ['vr', 7])
+        assert bl._status == 'READ TEST7'

test/test_blynk_protocol.py

@@ -32,7 +32,7 @@ def test_get_msg_id_defined(self, pb):
 
     def test_pack_msg(self, pb):
         msg_type = 20
-        args = ["test", 1234, 745, 'abcde']
+        args = ['test', 1234, 745, 'abcde']
         result = pb._pack_msg(msg_type, *args)
         assert result == b'\x14\x00\x01\x00\x13test\x001234\x00745\x00abcde'
 
@@ -47,7 +47,7 @@ def test_pack_msg_unicode(self, pb):
             pytest.skip('Python2 unicode compatibility issue')
 
         msg_type = 20
-        args = ["ёж"]
+        args = ['ёж']
         result = pb._pack_msg(msg_type, *args)
         assert result == b'\x14\x00\x01\x00\x04\xd1\x91\xd0\xb6'