add connection tests

conftest.py

@@ -4,13 +4,6 @@ from mishards import settings, db, create_app
 
 logger = logging.getLogger(__name__)
 
-def clear_data(session):
-    meta = db.metadata
-    for table in reversed(meta.sorted_tables):
-        session.execute(table.delete())
-    session.commit()
-
-# @pytest.fixture(scope="module")
 @pytest.fixture
 def app(request):
     app = create_app(settings.TestingConfig)

mishards/connections.py

@@ -35,7 +35,7 @@ class Connection:
 
     @property
     def can_retry(self):
-        return self.retried <= self.max_retry
+        return self.retried < self.max_retry
 
     @property
     def connected(self):
@@ -45,7 +45,7 @@ class Connection:
         if self.on_retry_func:
             self.on_retry_func(self)
         else:
-            logger.warn('{} is retrying {}'.format(self, self.retried))
+            logger.warning('{} is retrying {}'.format(self, self.retried))
 
     def on_connect(self, metadata=None):
         while not self.connected and self.can_retry:
@@ -123,11 +123,11 @@ class ConnectionMgr:
         return self.on_diff_meta(name, url)
 
     def on_same_meta(self, name, url):
-        # logger.warn('Register same meta: {}:{}'.format(name, url))
+        # logger.warning('Register same meta: {}:{}'.format(name, url))
         pass
 
     def on_diff_meta(self, name, url):
-        logger.warn('Received {} with diff url={}'.format(name, url))
+        logger.warning('Received {} with diff url={}'.format(name, url))
         self.metas[name] = url
         self.conns[name] = {}
 
@@ -136,7 +136,7 @@ class ConnectionMgr:
         self.conns.pop(name, None)
 
     def on_nonexisted_meta(self, name):
-        logger.warn('Non-existed meta: {}'.format(name))
+        logger.warning('Non-existed meta: {}'.format(name))
 
     def register(self, name, url):
         logger.info('Register Connection: name={};url={}'.format(name, url))

mishards/test_connections.py

@@ -0,0 +1,73 @@
+import logging
+import pytest
+
+from mishards.connections import (ConnectionMgr, Connection)
+from mishards import exceptions
+
+logger = logging.getLogger(__name__)
+
+@pytest.mark.usefixtures('app')
+class TestConnection:
+    def test_manager(self):
+        mgr = ConnectionMgr()
+
+        mgr.register('pod1', '111')
+        mgr.register('pod2', '222')
+        mgr.register('pod2', '222')
+        mgr.register('pod2', '2222')
+        assert len(mgr.conn_names) == 2
+
+        mgr.unregister('pod1')
+        assert len(mgr.conn_names) == 1
+
+        mgr.unregister('pod2')
+        assert len(mgr.conn_names) == 0
+
+        mgr.register('WOSERVER', 'xxxx')
+        assert len(mgr.conn_names) == 0
+
+    def test_connection(self):
+        class Conn:
+            def __init__(self, state):
+                self.state = state
+            def connect(self, uri):
+                return self.state
+            def connected(self):
+                return self.state
+        FAIL_CONN = Conn(False)
+        PASS_CONN = Conn(True)
+
+        class Retry:
+            def __init__(self):
+                self.times = 0
+
+            def __call__(self, conn):
+                self.times += 1
+                logger.info('Retrying {}'.format(self.times))
+
+        class Func():
+            def __init__(self):
+                self.executed = False
+            def __call__(self):
+                self.executed = True
+
+        max_retry = 3
+
+        RetryObj = Retry()
+        c = Connection('client', uri='',
+                max_retry=max_retry,
+                on_retry_func=RetryObj)
+        c.conn = FAIL_CONN
+        ff = Func()
+        this_connect = c.connect(func=ff)
+        with pytest.raises(exceptions.ConnectionConnectError):
+            this_connect()
+        assert RetryObj.times == max_retry
+        assert not ff.executed
+        RetryObj = Retry()
+
+        c.conn = PASS_CONN
+        this_connect = c.connect(func=ff)
+        this_connect()
+        assert ff.executed
+        assert RetryObj.times == 0