test: fix test connection resource warnings

Close all connection opened in tests even in case of failed asserts.

Part of #250

Author: DifferentialOrange

test/suites/test_dml.py

@@ -167,29 +167,32 @@ def test_06_update(self):
 
     def test_07_call_16(self):
         con = tarantool.Connection(self.srv.host, self.srv.args['primary'], call_16 = True)
-        con.authenticate('test', 'test')
-        self.assertSequenceEqual(con.call('json.decode', '[123, 234, 345]'), [[123, 234, 345]])
-        self.assertSequenceEqual(con.call('json.decode', ['[123, 234, 345]']), [[123, 234, 345]])
-        self.assertSequenceEqual(con.call('json.decode', ('[123, 234, 345]',)), [[123, 234, 345]])
-        with self.assertRaisesRegex(tarantool.DatabaseError, '(32, .*)'):
-            con.call('json.decode')
-        with self.assertRaisesRegex(tarantool.DatabaseError, '(32, .*)'):
-            con.call('json.decode', '{[1, 2]: "world"}')
-        ans = con.call('fiber.time')
-        self.assertEqual(len(ans), 1)
-        self.assertEqual(len(ans[0]), 1)
-        self.assertIsInstance(ans[0][0], float)
-        ans = con.call('fiber.time64')
-        self.assertEqual(len(ans), 1)
-        self.assertEqual(len(ans[0]), 1)
-        self.assertIsInstance(ans[0][0], int)
-        ans = con.call('uuid.str')
-        self.assertEqual(len(ans), 1)
-        self.assertEqual(len(ans[0]), 1)
-        self.assertIsInstance(ans[0][0], str)
+        try:
+            con.authenticate('test', 'test')
+            self.assertSequenceEqual(con.call('json.decode', '[123, 234, 345]'), [[123, 234, 345]])
+            self.assertSequenceEqual(con.call('json.decode', ['[123, 234, 345]']), [[123, 234, 345]])
+            self.assertSequenceEqual(con.call('json.decode', ('[123, 234, 345]',)), [[123, 234, 345]])
+            with self.assertRaisesRegex(tarantool.DatabaseError, '(32, .*)'):
+                con.call('json.decode')
+            with self.assertRaisesRegex(tarantool.DatabaseError, '(32, .*)'):
+                con.call('json.decode', '{[1, 2]: "world"}')
+            ans = con.call('fiber.time')
+            self.assertEqual(len(ans), 1)
+            self.assertEqual(len(ans[0]), 1)
+            self.assertIsInstance(ans[0][0], float)
+            ans = con.call('fiber.time64')
+            self.assertEqual(len(ans), 1)
+            self.assertEqual(len(ans[0]), 1)
+            self.assertIsInstance(ans[0][0], int)
+            ans = con.call('uuid.str')
+            self.assertEqual(len(ans), 1)
+            self.assertEqual(len(ans[0]), 1)
+            self.assertIsInstance(ans[0][0], str)
 
-        self.assertSequenceEqual(con.call('box.tuple.new', [1, 2, 3, 'fld_1']), [[1, 2, 3, 'fld_1']])
-        self.assertSequenceEqual(con.call('box.tuple.new', 'fld_1'), [['fld_1']])
+            self.assertSequenceEqual(con.call('box.tuple.new', [1, 2, 3, 'fld_1']), [[1, 2, 3, 'fld_1']])
+            self.assertSequenceEqual(con.call('box.tuple.new', 'fld_1'), [['fld_1']])
+        finally:
+            con.close()
 
     def test_07_call_17(self):
         con = tarantool.Connection(self.srv.host, self.srv.args['primary'])

test/suites/test_mesh.py

@@ -80,27 +80,30 @@ def assert_srv_id(con, srv_id):
             {'host': self.host_2, 'port': self.port_2},
         ], user='test', password='test')
 
-        # Response from instance#1.
-        assert_srv_id(con, 1)
-
-        # Stop instance#1 -- response from instance#2.
-        self.srv.stop()
-        assert_srv_id(con, 2)
-
-        # Start instance#1, stop instance#2 -- response from
-        # instance#1 again.
-        self.srv.start()
-        self.srv.admin('function srv_id() return 1 end')
-        self.srv2.stop()
-        assert_srv_id(con, 1)
-
-        # Stop instance #2 -- NetworkError (because we have no
-        # alive servers anymore).
-        self.srv.stop()
-        with self.assertRaises(NetworkError):
-            with warnings.catch_warnings():
-                warnings.simplefilter('ignore', category=NetworkWarning)
-                con.ping()
+        try:
+            # Response from instance#1.
+            assert_srv_id(con, 1)
+
+            # Stop instance#1 -- response from instance#2.
+            self.srv.stop()
+            assert_srv_id(con, 2)
+
+            # Start instance#1, stop instance#2 -- response from
+            # instance#1 again.
+            self.srv.start()
+            self.srv.admin('function srv_id() return 1 end')
+            self.srv2.stop()
+            assert_srv_id(con, 1)
+
+            # Stop instance #2 -- NetworkError (because we have no
+            # alive servers anymore).
+            self.srv.stop()
+            with self.assertRaises(NetworkError):
+                with warnings.catch_warnings():
+                    warnings.simplefilter('ignore', category=NetworkWarning)
+                    con.ping()
+        finally:
+            con.close()
 
     def test_01_contructor(self):
         # Verify that an error is risen when no addresses are
@@ -126,7 +129,10 @@ def test_01_contructor(self):
         addrs = [{"host": "localhost", "port": 1234}]
         con = tarantool.MeshConnection("localhost", 1234, addrs=addrs,
                                        connect_now=False)
-        self.assertEqual(len(con.strategy.addrs), 1)
+        try:
+            self.assertEqual(len(con.strategy.addrs), 1)
+        finally:
+            con.close()
 
     def test_02_discovery_bad_address(self):
         retvals = [
@@ -147,44 +153,46 @@ def test_02_discovery_bad_address(self):
             self.define_custom_cluster_function(func_name, retval)
             con = tarantool.MeshConnection(self.host_1, self.port_1,
                                            user='test', password='test')
-            con.cluster_discovery_function = func_name
-
-            # Verify that a cluster discovery (that is triggered
-            # by ping) give one or two warnings.
-            with warnings.catch_warnings(record=True) as ws:
-                con.ping()
-                self.assertTrue(len(ws) in (1, 2))
-                for w in ws:
-                    self.assertIs(w.category, ClusterDiscoveryWarning)
-
-            # Verify that incorrect or empty result was discarded.
-            self.assertEqual(len(con.strategy.addrs), 1)
-            self.assertEqual(con.strategy.addrs[0]['host'], self.host_1)
-            self.assertEqual(con.strategy.addrs[0]['port'], self.port_1)
-
-            con.close()
+            try:
+                con.cluster_discovery_function = func_name
+
+                # Verify that a cluster discovery (that is triggered
+                # by ping) give one or two warnings.
+                with warnings.catch_warnings(record=True) as ws:
+                    con.ping()
+                    self.assertTrue(len(ws) in (1, 2))
+                    for w in ws:
+                        self.assertIs(w.category, ClusterDiscoveryWarning)
+
+                # Verify that incorrect or empty result was discarded.
+                self.assertEqual(len(con.strategy.addrs), 1)
+                self.assertEqual(con.strategy.addrs[0]['host'], self.host_1)
+                self.assertEqual(con.strategy.addrs[0]['port'], self.port_1)
+            finally:
+                con.close()
 
     def test_03_discovery_bad_good_addresses(self):
         func_name = 'bad_and_good_addresses'
         retval = "{'localhost:', '%s:%d'}" % (self.host_2, self.port_2)
         self.define_custom_cluster_function(func_name, retval)
         con = tarantool.MeshConnection(self.host_1, self.port_1,
                                        user='test', password='test')
-        con.cluster_discovery_function = func_name
-
-        # Verify that a cluster discovery (that is triggered
-        # by ping) give one warning.
-        with warnings.catch_warnings(record=True) as ws:
-            con.ping()
-            self.assertEqual(len(ws), 1)
-            self.assertIs(ws[0].category, ClusterDiscoveryWarning)
+        try:
+            con.cluster_discovery_function = func_name
 
-        # Verify that only second address was accepted.
-        self.assertEqual(len(con.strategy.addrs), 1)
-        self.assertEqual(con.strategy.addrs[0]['host'], self.host_2)
-        self.assertEqual(con.strategy.addrs[0]['port'], self.port_2)
+            # Verify that a cluster discovery (that is triggered
+            # by ping) give one warning.
+            with warnings.catch_warnings(record=True) as ws:
+                con.ping()
+                self.assertEqual(len(ws), 1)
+                self.assertIs(ws[0].category, ClusterDiscoveryWarning)
 
-        con.close()
+            # Verify that only second address was accepted.
+            self.assertEqual(len(con.strategy.addrs), 1)
+            self.assertEqual(con.strategy.addrs[0]['host'], self.host_2)
+            self.assertEqual(con.strategy.addrs[0]['port'], self.port_2)
+        finally:
+            con.close()
 
     def test_04_discovery_add_address(self):
         # Create a mesh connection; pass only the first server
@@ -194,20 +202,21 @@ def test_04_discovery_add_address(self):
             cluster_discovery_function=self.get_all_nodes_func_name,
             connect_now=False)
 
-        # Verify that the strategy has one address that comes from
-        # the constructor arguments.
-        self.assertEqual(len(con.strategy.addrs), 1)
-        con.connect()
-
-        # Verify that we work with the first server.
-        resp = con.call('srv_id')
-        self.assertEqual(resp.data and resp.data[0], 1)
+        try:
+            # Verify that the strategy has one address that comes from
+            # the constructor arguments.
+            self.assertEqual(len(con.strategy.addrs), 1)
+            con.connect()
 
-        # Verify that the refresh was successful and the strategy
-        # has 2 addresses.
-        self.assertEqual(len(con.strategy.addrs), 2)
+            # Verify that we work with the first server.
+            resp = con.call('srv_id')
+            self.assertEqual(resp.data and resp.data[0], 1)
 
-        con.close()
+            # Verify that the refresh was successful and the strategy
+            # has 2 addresses.
+            self.assertEqual(len(con.strategy.addrs), 2)
+        finally:
+            con.close()
 
     def test_05_discovery_delay(self):
         # Create a mesh connection, pass only the first server address.
@@ -216,25 +225,26 @@ def test_05_discovery_delay(self):
             cluster_discovery_function=self.get_all_nodes_func_name,
             cluster_discovery_delay=1)
 
-        # Verify that the strategy has two addresses come from
-        # the function right after connecting.
-        self.assertEqual(len(con.strategy.addrs), 2)
-
-        # Drop addresses list to the initial state.
-        con.strategy.update([con.strategy.addrs[0], ])
+        try:
+            # Verify that the strategy has two addresses come from
+            # the function right after connecting.
+            self.assertEqual(len(con.strategy.addrs), 2)
 
-        # Verify that the discovery will not be performed until
-        # 'cluster_discovery_delay' seconds will be passed.
-        con.ping()
-        self.assertEqual(len(con.strategy.addrs), 1)
+            # Drop addresses list to the initial state.
+            con.strategy.update([con.strategy.addrs[0], ])
 
-        sleep(1.1)
+            # Verify that the discovery will not be performed until
+            # 'cluster_discovery_delay' seconds will be passed.
+            con.ping()
+            self.assertEqual(len(con.strategy.addrs), 1)
 
-        # Refresh after cluster_discovery_delay.
-        con.ping()
-        self.assertEqual(len(con.strategy.addrs), 2)
+            sleep(1.1)
 
-        con.close()
+            # Refresh after cluster_discovery_delay.
+            con.ping()
+            self.assertEqual(len(con.strategy.addrs), 2)
+        finally:
+            con.close()
 
     def test_06_reconnection(self):
         # Create a mesh connection; pass only the first server
@@ -243,24 +253,25 @@ def test_06_reconnection(self):
             self.host_1, self.port_1, user='test', password='test',
             cluster_discovery_function=self.get_all_nodes_func_name)
 
-        con.last_nodes_refresh = 0
-        resp = con.call('srv_id')
-        self.assertEqual(resp.data and resp.data[0], 1)
-
-        # Verify that the last discovery was successful and the
-        # strategy has 2 addresses.
-        self.assertEqual(len(con.strategy.addrs), 2)
+        try:
+            con.last_nodes_refresh = 0
+            resp = con.call('srv_id')
+            self.assertEqual(resp.data and resp.data[0], 1)
 
-        self.srv.stop()
+            # Verify that the last discovery was successful and the
+            # strategy has 2 addresses.
+            self.assertEqual(len(con.strategy.addrs), 2)
 
-        # Verify that we switched to the second server.
-        with warnings.catch_warnings():
-            # Suppress reconnection warnings.
-            warnings.simplefilter("ignore")
-            resp = con.call('srv_id')
-        self.assertEqual(resp.data and resp.data[0], 2)
+            self.srv.stop()
 
-        con.close()
+            # Verify that we switched to the second server.
+            with warnings.catch_warnings():
+                # Suppress reconnection warnings.
+                warnings.simplefilter("ignore")
+                resp = con.call('srv_id')
+            self.assertEqual(resp.data and resp.data[0], 2)
+        finally:
+            con.close()
 
     def test_07_discovery_exclude_address(self):
         # Define function to get back only second server.
@@ -272,15 +283,16 @@ def test_07_discovery_exclude_address(self):
             self.host_1, self.port_1, user='test', password='test',
             cluster_discovery_function=func_name)
 
-        # Verify that discovery was successful and the strategy
-        # has 1 address.
-        self.assertEqual(len(con.strategy.addrs), 1)
-
-        # Verify that the current server is second one.
-        resp = con.call('srv_id')
-        self.assertEqual(resp.data and resp.data[0], 2)
+        try:
+            # Verify that discovery was successful and the strategy
+            # has 1 address.
+            self.assertEqual(len(con.strategy.addrs), 1)
 
-        con.close()
+            # Verify that the current server is second one.
+            resp = con.call('srv_id')
+            self.assertEqual(resp.data and resp.data[0], 2)
+        finally:
+            con.close()
 
     def tearDown(self):
         self.srv.stop()