[FIX]

- problems with tests
 - pre-commit

[UPD] Update base_external_dbsource.pot

[UPD] README.rst

base_external_dbsource/tests/test_base_external_dbsource.py

@@ -43,7 +43,7 @@ class TestBaseExternalDbsource(common.TransactionCase):
         if kwargs is None:
             kwargs = {}
         adapter = "%s_postgresql" % method_name
-        with mock.patch.object(self.dbsource, adapter, create=create) as adapter:
+        with mock.patch.object(type(self.dbsource), adapter, create=create) as adapter:
             if side_effect is not None:
                 adapter.side_effect = side_effect
             elif return_value is not None:
@@ -52,7 +52,7 @@ class TestBaseExternalDbsource(common.TransactionCase):
             return res, adapter
 
     def test_conn_string_full(self):
-        """ It should add password if string interpolation not detected """
+        """It should add password if string interpolation not detected"""
         self.dbsource.conn_string = "User=Derp;"
         self.dbsource.password = "password"
         expect = self.dbsource.conn_string + "PWD=%s;" % self.dbsource.password
@@ -61,37 +61,37 @@ class TestBaseExternalDbsource(common.TransactionCase):
     # Interface
 
     def test_connection_success(self):
-        """ It should raise for successful connection """
+        """It should raise for successful connection"""
         with self.assertRaises(ValidationError):
             self.dbsource.connection_test()
 
     def test_connection_fail(self):
-        """ It should raise for failed/invalid connection """
-        with mock.patch.object(self.dbsource, "connection_open") as conn:
+        """It should raise for failed/invalid connection"""
+        with mock.patch.object(type(self.dbsource), "connection_open") as conn:
             conn.side_effect = Exception
             with self.assertRaises(ValidationError):
                 self.dbsource.connection_test()
 
     def test_connection_open_calls_close(self):
-        """ It should close connection after context ends """
-        with mock.patch.object(self.dbsource, "connection_close") as close:
+        """It should close connection after context ends"""
+        with mock.patch.object(type(self.dbsource), "connection_close") as close:
             with self.dbsource.connection_open():
                 pass
             close.assert_called_once()
 
     def test_connection_close(self):
-        """ It should call adapter's close method """
+        """It should call adapter's close method"""
         args = [mock.MagicMock()]
         res, adapter = self._test_adapter_method("connection_close", args=args)
         adapter.assert_called_once_with(args[0])
 
     def test_execute_asserts_query_arg(self):
-        """ It should raise a TypeError if query and sqlquery not in args """
+        """It should raise a TypeError if query and sqlquery not in args"""
         with self.assertRaises(TypeError):
             self.dbsource.execute()
 
     def test_execute_calls_adapter(self):
-        """ It should call the adapter methods with proper args """
+        """It should call the adapter methods with proper args"""
         expect = ("query", "execute", "metadata")
         return_value = "rows", "cols"
         res, adapter = self._test_adapter_method(
@@ -100,7 +100,7 @@ class TestBaseExternalDbsource(common.TransactionCase):
         adapter.assert_called_once_with(*expect)
 
     def test_execute_return(self):
-        """ It should return rows if not metadata """
+        """It should return rows if not metadata"""
         expect = (True, True, False)
         return_value = "rows", "cols"
         res, adapter = self._test_adapter_method(
@@ -109,7 +109,7 @@ class TestBaseExternalDbsource(common.TransactionCase):
         self.assertEqual(res, return_value[0])
 
     def test_execute_return_metadata(self):
-        """ It should return rows and cols if metadata """
+        """It should return rows and cols if metadata"""
         expect = (True, True, True)
         return_value = "rows", "cols"
         res, adapter = self._test_adapter_method(
@@ -118,10 +118,10 @@ class TestBaseExternalDbsource(common.TransactionCase):
         self.assertEqual(res, {"rows": return_value[0], "cols": return_value[1]})
 
     def test_remote_browse(self):
-        """ It should call the adapter method with proper args """
+        """It should call the adapter method with proper args"""
         args = [1], "args"
         kwargs = {"kwargs": True}
-        self.dbsource.current_table = "table"
+        type(self.dbsource).current_table = "table"
         res, adapter = self._test_adapter_method(
             "remote_browse", create=True, args=args, kwargs=kwargs
         )
@@ -129,19 +129,20 @@ class TestBaseExternalDbsource(common.TransactionCase):
         self.assertEqual(res, adapter())
 
     def test_remote_browse_asserts_current_table(self):
-        """ It should raise AssertionError if a table not selected """
+        """It should raise AssertionError if a table not selected"""
         args = [1], "args"
         kwargs = {"kwargs": True}
+        type(self.dbsource).current_table = False
         with self.assertRaises(AssertionError):
             res, adapter = self._test_adapter_method(
                 "remote_browse", create=True, args=args, kwargs=kwargs
             )
 
     def test_remote_create(self):
-        """ It should call the adapter method with proper args """
+        """It should call the adapter method with proper args"""
         args = {"val": "Value"}, "args"
         kwargs = {"kwargs": True}
-        self.dbsource.current_table = "table"
+        type(self.dbsource).current_table = "table"
         res, adapter = self._test_adapter_method(
             "remote_create", create=True, args=args, kwargs=kwargs
         )
@@ -149,19 +150,20 @@ class TestBaseExternalDbsource(common.TransactionCase):
         self.assertEqual(res, adapter())
 
     def test_remote_create_asserts_current_table(self):
-        """ It should raise AssertionError if a table not selected """
+        """It should raise AssertionError if a table not selected"""
         args = [1], "args"
         kwargs = {"kwargs": True}
+        type(self.dbsource).current_table = False
         with self.assertRaises(AssertionError):
             res, adapter = self._test_adapter_method(
                 "remote_create", create=True, args=args, kwargs=kwargs
             )
 
     def test_remote_delete(self):
-        """ It should call the adapter method with proper args """
+        """It should call the adapter method with proper args"""
         args = [1], "args"
         kwargs = {"kwargs": True}
-        self.dbsource.current_table = "table"
+        type(self.dbsource).current_table = "table"
         res, adapter = self._test_adapter_method(
             "remote_delete", create=True, args=args, kwargs=kwargs
         )
@@ -169,19 +171,20 @@ class TestBaseExternalDbsource(common.TransactionCase):
         self.assertEqual(res, adapter())
 
     def test_remote_delete_asserts_current_table(self):
-        """ It should raise AssertionError if a table not selected """
+        """It should raise AssertionError if a table not selected"""
         args = [1], "args"
         kwargs = {"kwargs": True}
+        type(self.dbsource).current_table = False
         with self.assertRaises(AssertionError):
             res, adapter = self._test_adapter_method(
                 "remote_delete", create=True, args=args, kwargs=kwargs
             )
 
     def test_remote_search(self):
-        """ It should call the adapter method with proper args """
+        """It should call the adapter method with proper args"""
         args = {"search": "query"}, "args"
         kwargs = {"kwargs": True}
-        self.dbsource.current_table = "table"
+        type(self.dbsource).current_table = "table"
         res, adapter = self._test_adapter_method(
             "remote_search", create=True, args=args, kwargs=kwargs
         )
@@ -189,19 +192,20 @@ class TestBaseExternalDbsource(common.TransactionCase):
         self.assertEqual(res, adapter())
 
     def test_remote_search_asserts_current_table(self):
-        """ It should raise AssertionError if a table not selected """
+        """It should raise AssertionError if a table not selected"""
         args = [1], "args"
         kwargs = {"kwargs": True}
+        type(self.dbsource).current_table = False
         with self.assertRaises(AssertionError):
             res, adapter = self._test_adapter_method(
                 "remote_search", create=True, args=args, kwargs=kwargs
             )
 
     def test_remote_update(self):
-        """ It should call the adapter method with proper args """
+        """It should call the adapter method with proper args"""
         args = [1], {"vals": "Value"}, "args"
         kwargs = {"kwargs": True}
-        self.dbsource.current_table = "table"
+        type(self.dbsource).current_table = "table"
         res, adapter = self._test_adapter_method(
             "remote_update", create=True, args=args, kwargs=kwargs
         )
@@ -209,9 +213,10 @@ class TestBaseExternalDbsource(common.TransactionCase):
         self.assertEqual(res, adapter())
 
     def test_remote_update_asserts_current_table(self):
-        """ It should raise AssertionError if a table not selected """
+        """It should raise AssertionError if a table not selected"""
         args = [1], "args"
         kwargs = {"kwargs": True}
+        type(self.dbsource).current_table = False
         with self.assertRaises(AssertionError):
             res, adapter = self._test_adapter_method(
                 "remote_update", create=True, args=args, kwargs=kwargs
@@ -220,10 +225,11 @@ class TestBaseExternalDbsource(common.TransactionCase):
     # Postgres
 
     def test_execute_postgresql(self):
-        """ It should call generic executor with proper args """
+        """It should call generic executor with proper args"""
         expect = ("query", "execute", "metadata")
         with mock.patch.object(
-            self.dbsource, "_execute_generic", autospec=True
+            type(self.dbsource),
+            "_execute_generic",
         ) as execute:
             execute.return_value = "rows", "cols"
             self.dbsource.execute(*expect)
@@ -232,10 +238,11 @@ class TestBaseExternalDbsource(common.TransactionCase):
     # Old API Compat
 
     def test_execute_calls_adapter_old_api(self):
-        """ It should call the adapter correctly if old kwargs provided """
+        """It should call the adapter correctly if old kwargs provided"""
         expect = [None, None, "metadata"]
         with mock.patch.object(
-            self.dbsource, "execute_postgresql", autospec=True
+            type(self.dbsource),
+            "execute_postgresql",
         ) as psql:
             psql.return_value = "rows", "cols"
             self.dbsource.execute(*expect, sqlparams="params", sqlquery="query")
@@ -243,9 +250,7 @@ class TestBaseExternalDbsource(common.TransactionCase):
             psql.assert_called_once_with(*expect)
 
     def test_conn_open(self):
-        """ It should return open connection for use """
-        with mock.patch.object(
-            self.dbsource, "connection_open", autospec=True
-        ) as connection:
+        """It should return open connection for use"""
+        with mock.patch.object(type(self.dbsource), "connection_open") as connection:
             res = self.dbsource.conn_open()
             self.assertEqual(res, connection().__enter__())