singlestoredb 0.4.0__py3-none-any.whl → 1.0.4__py3-none-any.whl

singlestoredb/{clients/pymysqlsv → mysql}/tests/test_connection.py

@@ -1,18 +1,18 @@
 # type: ignore
 import datetime
 import ssl
-import sys
 import time
 from unittest import mock
 
 import pytest
 
-import singlestoredb.clients.pymysqlsv as sv
-from singlestoredb.clients.pymysqlsv.constants import CLIENT
-from singlestoredb.clients.pymysqlsv.tests import base
+import singlestoredb.mysql as sv
+from singlestoredb.mysql.constants import CLIENT
+from singlestoredb.mysql.tests import base
 
 
 class TempUser:
+
     def __init__(self, c, user, db, auth=None, authdata=None, password=None):
         self._c = c
         self._user = user
@@ -61,49 +61,51 @@ class TestAuthentication(base.PyMySQLTestCase):
 
     osuser = os.environ.get('USER')
 
-    # socket auth requires the current user and for the connection to be a socket
-    # rest do grants @localhost due to incomplete logic - TODO change to @% then
-    db = base.PyMySQLTestCase.databases[0].copy()
-
-    socket_auth = db.get('unix_socket') is not None and db.get('host') in (
-        'localhost',
-        '127.0.0.1',
-    )
-
-    cur = sv.connect(**db).cursor()
-    db.pop('user', None)
-    cur.execute('SHOW PLUGINS')
-    for r in cur:
-        if (r[1], r[2]) != ('ACTIVE', 'AUTHENTICATION'):
-            continue
-        if r[3] == 'auth_socket.so' or r[0] == 'unix_socket':
-            socket_plugin_name = r[0]
-            socket_found = True
-        elif r[3] == 'dialog_examples.so':
-            if r[0] == 'two_questions':
-                two_questions_found = True
-            elif r[0] == 'three_attempts':
-                three_attempts_found = True
-        elif r[0] == 'pam':
-            pam_found = True
-            pam_plugin_name = r[3].split('.')[0]
-            if pam_plugin_name == 'auth_pam':
-                pam_plugin_name = 'pam'
-            # MySQL: authentication_pam
-            # https://dev.mysql.com/doc/refman/5.5/en/pam-authentication-plugin.html
-
-            # MariaDB: pam
-            # https://mariadb.com/kb/en/mariadb/pam-authentication-plugin/
-
-            # Names differ but functionality is close
-        elif r[0] == 'mysql_old_password':
-            mysql_old_password_found = True
-        elif r[0] == 'sha256_password':
-            sha256_password_found = True
-        elif r[0] == 'ed25519':
-            ed25519_found = True
-        # else:
-        #    print("plugin: %r" % r[0])
+#   # socket auth requires the current user and for the connection to be a socket
+#   # rest do grants @localhost due to incomplete logic - TODO change to @% then
+#   db = base.PyMySQLTestCase.databases[0].copy()
+
+#   socket_auth = db.get('unix_socket') is not None and db.get('host') in (
+#       'localhost',
+#       '127.0.0.1',
+#   )
+
+#   dbname = db['database']
+
+#   cur = sv.connect(**db).cursor()
+#   db.pop('user', None)
+#   cur.execute('SHOW PLUGINS')
+#   for r in cur:
+#       if (r[1], r[2]) != ('ACTIVE', 'AUTHENTICATION'):
+#           continue
+#       if r[3] == 'auth_socket.so' or r[0] == 'unix_socket':
+#           socket_plugin_name = r[0]
+#           socket_found = True
+#       elif r[3] == 'dialog_examples.so':
+#           if r[0] == 'two_questions':
+#               two_questions_found = True
+#           elif r[0] == 'three_attempts':
+#               three_attempts_found = True
+#       elif r[0] == 'pam':
+#           pam_found = True
+#           pam_plugin_name = r[3].split('.')[0]
+#           if pam_plugin_name == 'auth_pam':
+#               pam_plugin_name = 'pam'
+#           # MySQL: authentication_pam
+#           # https://dev.mysql.com/doc/refman/5.5/en/pam-authentication-plugin.html
+
+#           # MariaDB: pam
+#           # https://mariadb.com/kb/en/mariadb/pam-authentication-plugin/
+
+#           # Names differ but functionality is close
+#       elif r[0] == 'mysql_old_password':
+#           mysql_old_password_found = True
+#       elif r[0] == 'sha256_password':
+#           sha256_password_found = True
+#       elif r[0] == 'ed25519':
+#           ed25519_found = True
+#       # else:
+#       #    print("plugin: %r" % r[0])
 
     @pytest.mark.skip(reason='not currently supported in SingleStoreDB')
     def test_plugin(self):
@@ -151,8 +153,8 @@ class TestAuthentication(base.PyMySQLTestCase):
             TestAuthentication.osuser + '@localhost',
             self.databases[0]['database'],
             self.socket_plugin_name,
-        ) as u:
-            c = sv.connect(user=TestAuthentication.osuser, **self.db)
+        ) as _:
+            sv.connect(user=TestAuthentication.osuser, **self.db)
 
     class Dialog:
         fail = False
@@ -174,7 +176,7 @@ class TestAuthentication(base.PyMySQLTestCase):
         def authenticate(self, pkt):
             while True:
                 flag = pkt.read_uint8()
-                echo = (flag & 0x06) == 0x02
+                echo = (flag & 0x06) == 0x02  # noqa: F841
                 last = (flag & 0x01) == 0x01
                 prompt = pkt.read_all()
 
@@ -224,15 +226,15 @@ class TestAuthentication(base.PyMySQLTestCase):
         }
         with TempUser(
             self.connect().cursor(),
-            'pymysqlsv_2q@localhost',
+            'singlestoredb_2q@localhost',
             self.databases[0]['database'],
             'two_questions',
             'notverysecret',
-        ) as u:
+        ) as _:
             with self.assertRaises(sv.err.OperationalError):
-                sv.connect(user='pymysqlsv_2q', **self.db)
+                sv.connect(user='singlestoredb_2q', **self.db)
             sv.connect(
-                user='pymysqlsv_2q',
+                user='singlestoredb_2q',
                 auth_plugin_map={b'dialog': TestAuthentication.Dialog},
                 **self.db,
             )
@@ -268,49 +270,51 @@ class TestAuthentication(base.PyMySQLTestCase):
         )
         with TempUser(
             self.connect().cursor(),
-            'pymysqlsv_3a@localhost',
+            'singlestoredb_3a@localhost',
             self.databases[0]['database'],
             'three_attempts',
             'stillnotverysecret',
-        ) as u:
+        ) as _:
             sv.connect(
-                user='pymysqlsv_3a',
+                user='singlestoredb_3a',
                 auth_plugin_map={b'dialog': TestAuthentication.Dialog},
                 **self.db,
             )
             sv.connect(
-                user='pymysqlsv_3a',
+                user='singlestoredb_3a',
                 auth_plugin_map={b'dialog': TestAuthentication.DialogHandler},
                 **self.db,
             )
             with self.assertRaises(sv.err.OperationalError):
                 sv.connect(
-                    user='pymysqlsv_3a', auth_plugin_map={b'dialog': object}, **self.db,
+                    user='singlestoredb_3a',
+                    auth_plugin_map={b'dialog': object},
+                    **self.db,
                 )
 
             with self.assertRaises(sv.err.OperationalError):
                 sv.connect(
-                    user='pymysqlsv_3a',
+                    user='singlestoredb_3a',
                     auth_plugin_map={b'dialog': TestAuthentication.DefectiveHandler},
                     **self.db,
                 )
             with self.assertRaises(sv.err.OperationalError):
                 sv.connect(
-                    user='pymysqlsv_3a',
+                    user='singlestoredb_3a',
                     auth_plugin_map={b'notdialogplugin': TestAuthentication.Dialog},
                     **self.db,
                 )
             TestAuthentication.Dialog.m = {b'Password, please:': b'I do not know'}
             with self.assertRaises(sv.err.OperationalError):
                 sv.connect(
-                    user='pymysqlsv_3a',
+                    user='singlestoredb_3a',
                     auth_plugin_map={b'dialog': TestAuthentication.Dialog},
                     **self.db,
                 )
             TestAuthentication.Dialog.m = {b'Password, please:': None}
             with self.assertRaises(sv.err.OperationalError):
                 sv.connect(
-                    user='pymysqlsv_3a',
+                    user='singlestoredb_3a',
                     auth_plugin_map={b'dialog': TestAuthentication.Dialog},
                     **self.db,
                 )
@@ -368,26 +372,29 @@ class TestAuthentication(base.PyMySQLTestCase):
             self.databases[0]['database'],
             'pam',
             os.environ.get('PAMSERVICE'),
-        ) as u:
+        ) as _:
             try:
-                c = sv.connect(user=TestAuthentication.osuser, **db)
+                c = sv.connect(user=TestAuthentication.osuser, **db)  # noqa: F841
                 db['password'] = 'very bad guess at password'
                 with self.assertRaises(sv.err.OperationalError):
                     sv.connect(
                         user=TestAuthentication.osuser,
                         auth_plugin_map={
-                            b'mysql_cleartext_password': TestAuthentication.DefectiveHandler,
+                            b'mysql_cleartext_password':
+                                TestAuthentication.DefectiveHandler,
                         },
                         **self.db,
                     )
             except sv.OperationalError as e:
                 self.assertEqual(1045, e.args[0])
-                # we had 'bad guess at password' work with pam. Well at least we get a permission denied here
+                # we had 'bad guess at password' work with pam. Well at least
+                # we get a permission denied here
                 with self.assertRaises(sv.err.OperationalError):
                     sv.connect(
                         user=TestAuthentication.osuser,
                         auth_plugin_map={
-                            b'mysql_cleartext_password': TestAuthentication.DefectiveHandler,
+                            b'mysql_cleartext_password':
+                                TestAuthentication.DefectiveHandler,
                         },
                         **self.db,
                     )
@@ -406,17 +413,18 @@ class TestAuthentication(base.PyMySQLTestCase):
         c = conn.cursor()
         with TempUser(
             c,
-            'pymysqlsv_sha256@localhost',
+            'singlestoredb_sha256@localhost',
             self.databases[0]['database'],
             'sha256_password',
-        ) as u:
-            c.execute("SET PASSWORD FOR 'pymysqlsv_sha256'@'localhost' ='Sh@256Pa33'")
+        ) as _:
+            c.execute("SET PASSWORD FOR 'singlestoredb_sha256'@'localhost' ='Sh@256Pa33'")
             c.execute('FLUSH PRIVILEGES')
             db = self.db.copy()
             db['password'] = 'Sh@256Pa33'
-            # Although SHA256 is supported, need the configuration of public key of the mysql server. Currently will get error by this test.
+            # Although SHA256 is supported, need the configuration of public
+            # key of the mysql server. Currently will get error by this test.
             with self.assertRaises(sv.err.OperationalError):
-                sv.connect(user='pymysqlsv_sha256', **db)
+                sv.connect(user='singlestoredb_sha256', **db)
 
     @pytest.mark.skipif(not ed25519_found, reason='no ed25519 authention plugin')
     def testAuthEd25519(self):
@@ -431,32 +439,33 @@ class TestAuthentication(base.PyMySQLTestCase):
 
         with TempUser(
             c,
-            'pymysqlsv_ed25519',
+            'singlestoredb_ed25519',
             self.databases[0]['database'],
             'ed25519',
             empty_pass,
-        ) as u:
-            sv.connect(user='pymysqlsv_ed25519', password='', **db)
+        ) as _:
+            sv.connect(user='singlestoredb_ed25519', password='', **db)
 
         with TempUser(
             c,
-            'pymysqlsv_ed25519',
+            'singlestoredb_ed25519',
             self.databases[0]['database'],
             'ed25519',
             non_empty_pass,
-        ) as u:
-            sv.connect(user='pymysqlsv_ed25519', password='ed25519_password', **db)
+        ) as _:
+            sv.connect(user='singlestoredb_ed25519', password='ed25519_password', **db)
 
 
 class TestConnection(base.PyMySQLTestCase):
+
     def test_utf8mb4(self):
-        """This test requires MySQL >= 5.5"""
+        """This test requires MySQL >= 5.5."""
         arg = self.databases[0].copy()
         arg['charset'] = 'utf8mb4'
-        conn = sv.connect(**arg)
+        conn = sv.connect(**arg)  # noqa: F841
 
     def test_largedata(self):
-        """Large query and response (>=16MB)"""
+        """Large query and response (>=16MB)."""
         cur = self.connect().cursor()
         cur.execute('SELECT @@max_allowed_packet')
         if cur.fetchone()[0] < 16 * 1024 * 1024 + 10:
@@ -497,6 +506,7 @@ class TestConnection(base.PyMySQLTestCase):
         """
         http://dev.mysql.com/doc/refman/5.0/en/gone-away.html
         http://dev.mysql.com/doc/refman/5.0/en/error-messages-client.html#error_cr_server_gone_error
+
         """
         con = self.connect()
         cur = con.cursor()
@@ -559,9 +569,9 @@ class TestConnection(base.PyMySQLTestCase):
     def test_ssl_connect(self):
         dummy_ssl_context = mock.Mock(options=0)
         with mock.patch(
-            'pymysqlsv.connections.Connection.connect',
-        ) as connect, mock.patch(
-            'pymysqlsv.connections.ssl.create_default_context',
+            'singlestoredb.connections.Connection.connect',
+        ) as _, mock.patch(
+            'singlestoredb.connections.ssl.create_default_context',
             new=mock.Mock(return_value=dummy_ssl_context),
         ) as create_default_context:
             sv.connect(
@@ -580,9 +590,9 @@ class TestConnection(base.PyMySQLTestCase):
 
         dummy_ssl_context = mock.Mock(options=0)
         with mock.patch(
-            'pymysqlsv.connections.Connection.connect',
-        ) as connect, mock.patch(
-            'pymysqlsv.connections.ssl.create_default_context',
+            'singlestoredb.connections.Connection.connect',
+        ) as _, mock.patch(
+            'singelstoredb.connections.ssl.create_default_context',
             new=mock.Mock(return_value=dummy_ssl_context),
         ) as create_default_context:
             sv.connect(
@@ -600,9 +610,9 @@ class TestConnection(base.PyMySQLTestCase):
 
         dummy_ssl_context = mock.Mock(options=0)
         with mock.patch(
-            'pymysqlsv.connections.Connection.connect',
-        ) as connect, mock.patch(
-            'pymysqlsv.connections.ssl.create_default_context',
+            'singelstoredb.connections.Connection.connect',
+        ) as _, mock.patch(
+            'singlestoredb.connections.ssl.create_default_context',
             new=mock.Mock(return_value=dummy_ssl_context),
         ) as create_default_context:
             sv.connect(
@@ -616,9 +626,9 @@ class TestConnection(base.PyMySQLTestCase):
 
         dummy_ssl_context = mock.Mock(options=0)
         with mock.patch(
-            'pymysqlsv.connections.Connection.connect',
-        ) as connect, mock.patch(
-            'pymysqlsv.connections.ssl.create_default_context',
+            'singlestoredb.connections.Connection.connect',
+        ) as _, mock.patch(
+            'singlestoredb.connections.ssl.create_default_context',
             new=mock.Mock(return_value=dummy_ssl_context),
         ) as create_default_context:
             sv.connect(
@@ -635,9 +645,9 @@ class TestConnection(base.PyMySQLTestCase):
         for ssl_verify_cert in (True, '1', 'yes', 'true'):
             dummy_ssl_context = mock.Mock(options=0)
             with mock.patch(
-                'pymysqlsv.connections.Connection.connect',
-            ) as connect, mock.patch(
-                'pymysqlsv.connections.ssl.create_default_context',
+                'singlestoredb.connections.Connection.connect',
+            ) as _, mock.patch(
+                'singlestoredb.connections.ssl.create_default_context',
                 new=mock.Mock(return_value=dummy_ssl_context),
             ) as create_default_context:
                 sv.connect(
@@ -656,9 +666,9 @@ class TestConnection(base.PyMySQLTestCase):
         for ssl_verify_cert in (None, False, '0', 'no', 'false'):
             dummy_ssl_context = mock.Mock(options=0)
             with mock.patch(
-                'pymysqlsv.connections.Connection.connect',
-            ) as connect, mock.patch(
-                'pymysqlsv.connections.ssl.create_default_context',
+                'singlestoredb.connections.Connection.connect',
+            ) as _, mock.patch(
+                'singlestoredb.connections.ssl.create_default_context',
                 new=mock.Mock(return_value=dummy_ssl_context),
             ) as create_default_context:
                 sv.connect(
@@ -678,9 +688,9 @@ class TestConnection(base.PyMySQLTestCase):
             for ssl_verify_cert in ('foo', 'bar', ''):
                 dummy_ssl_context = mock.Mock(options=0)
                 with mock.patch(
-                    'pymysqlsv.connections.Connection.connect',
-                ) as connect, mock.patch(
-                    'pymysqlsv.connections.ssl.create_default_context',
+                    'singlestoredb.connections.Connection.connect',
+                ) as _, mock.patch(
+                    'singlestoredb.connections.ssl.create_default_context',
                     new=mock.Mock(return_value=dummy_ssl_context),
                 ) as create_default_context:
                     sv.connect(
@@ -701,9 +711,9 @@ class TestConnection(base.PyMySQLTestCase):
 
         dummy_ssl_context = mock.Mock(options=0)
         with mock.patch(
-            'pymysqlsv.connections.Connection.connect',
-        ) as connect, mock.patch(
-            'pymysqlsv.connections.ssl.create_default_context',
+            'singlestoredb.connections.Connection.connect',
+        ) as _, mock.patch(
+            'singlestoredb.connections.ssl.create_default_context',
             new=mock.Mock(return_value=dummy_ssl_context),
         ) as create_default_context:
             sv.connect(
@@ -720,9 +730,9 @@ class TestConnection(base.PyMySQLTestCase):
 
         dummy_ssl_context = mock.Mock(options=0)
         with mock.patch(
-            'pymysqlsv.connections.Connection.connect',
-        ) as connect, mock.patch(
-            'pymysqlsv.connections.ssl.create_default_context',
+            'singlestoredb.connections.Connection.connect',
+        ) as _, mock.patch(
+            'singlestoredb.connections.ssl.create_default_context',
             new=mock.Mock(return_value=dummy_ssl_context),
         ) as create_default_context:
             sv.connect(
@@ -737,9 +747,9 @@ class TestConnection(base.PyMySQLTestCase):
 
         dummy_ssl_context = mock.Mock(options=0)
         with mock.patch(
-            'pymysqlsv.connections.Connection.connect',
-        ) as connect, mock.patch(
-            'pymysqlsv.connections.ssl.create_default_context',
+            'singlestoredb.connections.Connection.connect',
+        ) as _, mock.patch(
+            'singlestoredb.connections.ssl.create_default_context',
             new=mock.Mock(return_value=dummy_ssl_context),
         ) as create_default_context:
             sv.connect(
@@ -761,9 +771,10 @@ def escape_foo(x, d):
 
 
 class TestEscape(base.PyMySQLTestCase):
+
     def test_escape_string(self):
         con = self.connect()
-        cur = con.cursor()
+        cur = con.cursor()  # noqa: F841
 
         self.assertEqual(con.escape("foo'bar"), "'foo\\'bar'")
 #       # added NO_AUTO_CREATE_USER as not including it in 5.7 generates warnings
@@ -776,21 +787,21 @@ class TestEscape(base.PyMySQLTestCase):
 
     def test_escape_builtin_encoders(self):
         con = self.connect()
-        cur = con.cursor()
+        cur = con.cursor()  # noqa: F841
 
         val = datetime.datetime(2012, 3, 4, 5, 6)
         self.assertEqual(con.escape(val, con.encoders), "'2012-03-04 05:06:00'")
 
     def test_escape_custom_object(self):
         con = self.connect()
-        cur = con.cursor()
+        cur = con.cursor()  # noqa: F841
 
         mapping = {Foo: escape_foo}
         self.assertEqual(con.escape(Foo(), mapping), 'bar')
 
     def test_escape_fallback_encoder(self):
         con = self.connect()
-        cur = con.cursor()
+        cur = con.cursor()  # noqa: F841
 
         class Custom(str):
             pass
@@ -800,13 +811,13 @@ class TestEscape(base.PyMySQLTestCase):
 
     def test_escape_no_default(self):
         con = self.connect()
-        cur = con.cursor()
+        cur = con.cursor()  # noqa: F841
 
         self.assertRaises(TypeError, con.escape, 42, {})
 
     def test_escape_dict_value(self):
         con = self.connect()
-        cur = con.cursor()
+        cur = con.cursor()  # noqa: F841
 
         mapping = con.encoders.copy()
         mapping[Foo] = escape_foo
@@ -814,7 +825,7 @@ class TestEscape(base.PyMySQLTestCase):
 
     def test_escape_list_item(self):
         con = self.connect()
-        cur = con.cursor()
+        cur = con.cursor()  # noqa: F841
 
         mapping = con.encoders.copy()
         mapping[Foo] = escape_foo

singlestoredb/{clients/pymysqlsv → mysql}/tests/test_converters.py

@@ -2,24 +2,26 @@
 import datetime
 from unittest import TestCase
 
-from singlestoredb.clients.pymysqlsv import converters
+from singlestoredb import converters
+from singlestoredb.mysql.converters import escape_string
 
 
 __all__ = ['TestConverter']
 
 
 class TestConverter(TestCase):
+
     def test_escape_string(self):
-        self.assertEqual(converters.escape_string('foo\nbar'), 'foo\\nbar')
+        self.assertEqual(escape_string('foo\nbar'), 'foo\\nbar')
 
     def test_convert_datetime(self):
         expected = datetime.datetime(2007, 2, 24, 23, 6, 20)
-        dt = converters.convert_datetime('2007-02-24 23:06:20')
+        dt = converters.datetime_or_none('2007-02-24 23:06:20')
         self.assertEqual(dt, expected)
 
     def test_convert_datetime_with_fsp(self):
         expected = datetime.datetime(2007, 2, 24, 23, 6, 20, 511581)
-        dt = converters.convert_datetime('2007-02-24 23:06:20.511581')
+        dt = converters.datetime_or_none('2007-02-24 23:06:20.511581')
         self.assertEqual(dt, expected)
 
     def _test_convert_timedelta(self, with_negate=False, with_fsp=False):
@@ -34,7 +36,7 @@ class TestConverter(TestCase):
             expected = -expected
             s = '-' + s
 
-        tdelta = converters.convert_timedelta(s)
+        tdelta = converters.timedelta_or_none(s)
         self.assertEqual(tdelta, expected)
 
     def test_convert_timedelta(self):
@@ -47,10 +49,10 @@ class TestConverter(TestCase):
 
     def test_convert_time(self):
         expected = datetime.time(23, 6, 20)
-        time_obj = converters.convert_time('23:06:20')
+        time_obj = converters.time_or_none('23:06:20')
         self.assertEqual(time_obj, expected)
 
     def test_convert_time_with_fsp(self):
         expected = datetime.time(23, 6, 20, 511581)
-        time_obj = converters.convert_time('23:06:20.511581')
+        time_obj = converters.time_or_none('23:06:20.511581')
         self.assertEqual(time_obj, expected)