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

singlestoredb/tests/test_fusion.py

@@ -0,0 +1,465 @@
+#!/usr/bin/env python
+# type: ignore
+"""SingleStoreDB Fusion testing."""
+import os
+import random
+import secrets
+import time
+import unittest
+from typing import Any
+from typing import List
+
+import pytest
+
+import singlestoredb as s2
+from singlestoredb.tests import utils
+
+
+class TestFusion(unittest.TestCase):
+
+    dbname: str = ''
+    dbexisted: bool = False
+
+    @classmethod
+    def setUpClass(cls):
+        sql_file = os.path.join(os.path.dirname(__file__), 'test.sql')
+        cls.dbname, cls.dbexisted = utils.load_sql(sql_file)
+
+    @classmethod
+    def tearDownClass(cls):
+        if not cls.dbexisted:
+            utils.drop_database(cls.dbname)
+
+    def setUp(self):
+        self.enabled = os.environ.get('SINGLESTOREDB_FUSION_ENABLED')
+        os.environ['SINGLESTOREDB_FUSION_ENABLED'] = '1'
+        self.conn = s2.connect(database=type(self).dbname, local_infile=True)
+        self.cur = self.conn.cursor()
+
+    def tearDown(self):
+        if self.enabled:
+            os.environ['SINGLESTOREDB_FUSION_ENABLED'] = self.enabled
+        else:
+            del os.environ['SINGLESTOREDB_FUSION_ENABLED']
+
+        try:
+            if self.cur is not None:
+                self.cur.close()
+        except Exception:
+            # traceback.print_exc()
+            pass
+
+        try:
+            if self.conn is not None:
+                self.conn.close()
+        except Exception:
+            # traceback.print_exc()
+            pass
+
+    def test_env_var(self):
+        os.environ['SINGLESTOREDB_FUSION_ENABLED'] = '0'
+
+        with self.assertRaises(s2.ProgrammingError):
+            self.cur.execute('show fusion commands')
+
+        del os.environ['SINGLESTOREDB_FUSION_ENABLED']
+
+        with self.assertRaises(s2.ProgrammingError):
+            self.cur.execute('show fusion commands')
+
+        os.environ['SINGLESTOREDB_FUSION_ENABLED'] = 'yes'
+
+        self.cur.execute('show fusion commands')
+        assert list(self.cur)
+
+    def test_show_commands(self):
+        self.cur.execute('show fusion commands')
+        cmds = [x[0] for x in self.cur.fetchall()]
+        assert cmds
+        assert [x for x in cmds if x.strip().startswith('SHOW FUSION GRAMMAR')], cmds
+
+        self.cur.execute('show fusion commands like "create%"')
+        cmds = [x[0] for x in self.cur.fetchall()]
+        assert cmds
+        assert [x for x in cmds if x.strip().startswith('CREATE')] == cmds, cmds
+
+    def test_show_grammar(self):
+        self.cur.execute('show fusion grammar for "create workspace"')
+        cmds = [x[0] for x in self.cur.fetchall()]
+        assert cmds
+        assert [x for x in cmds if x.strip().startswith('CREATE WORKSPACE')], cmds
+
+
+@pytest.mark.management
+class TestManagementAPIFusion(unittest.TestCase):
+
+    id: str = secrets.token_hex(8)
+    dbname: str = ''
+    dbexisted: bool = False
+    workspace_groups: List[Any] = []
+
+    @classmethod
+    def setUpClass(cls):
+        sql_file = os.path.join(os.path.dirname(__file__), 'test.sql')
+        cls.dbname, cls.dbexisted = utils.load_sql(sql_file)
+        mgr = s2.manage_workspaces()
+        us_regions = [x for x in mgr.regions if x.name.startswith('US')]
+        non_us_regions = [x for x in mgr.regions if not x.name.startswith('US')]
+        wg = mgr.create_workspace_group(
+            f'A Fusion Testing {cls.id}',
+            region=random.choice(us_regions),
+            firewall_ranges=[],
+        )
+        cls.workspace_groups.append(wg)
+        wg = mgr.create_workspace_group(
+            f'B Fusion Testing {cls.id}',
+            region=random.choice(us_regions),
+            firewall_ranges=[],
+        )
+        cls.workspace_groups.append(wg)
+        wg = mgr.create_workspace_group(
+            f'C Fusion Testing {cls.id}',
+            region=random.choice(non_us_regions),
+            firewall_ranges=[],
+        )
+        cls.workspace_groups.append(wg)
+
+    @classmethod
+    def tearDownClass(cls):
+        if not cls.dbexisted:
+            utils.drop_database(cls.dbname)
+        while cls.workspace_groups:
+            cls.workspace_groups.pop().terminate(force=True)
+
+    def setUp(self):
+        self.enabled = os.environ.get('SINGLESTOREDB_FUSION_ENABLED')
+        os.environ['SINGLESTOREDB_FUSION_ENABLED'] = '1'
+        self.conn = s2.connect(database=type(self).dbname, local_infile=True)
+        self.cur = self.conn.cursor()
+
+    def tearDown(self):
+        if self.enabled:
+            os.environ['SINGLESTOREDB_FUSION_ENABLED'] = self.enabled
+        else:
+            del os.environ['SINGLESTOREDB_FUSION_ENABLED']
+
+        try:
+            if self.cur is not None:
+                self.cur.close()
+        except Exception:
+            # traceback.print_exc()
+            pass
+
+        try:
+            if self.conn is not None:
+                self.conn.close()
+        except Exception:
+            # traceback.print_exc()
+            pass
+
+    def test_show_regions(self):
+        self.cur.execute('show regions')
+        regs = list(self.cur)
+        desc = self.cur.description
+
+        us_regs = [x for x in regs if x[0].startswith('US')]
+
+        assert len(desc) == 3
+        assert len(regs) > 5
+        assert len(us_regs) > 5
+
+        # LIKE
+        self.cur.execute('show regions like "US%"')
+        regs = list(self.cur)
+        assert regs == us_regs
+
+        # LIMIT
+        self.cur.execute('show regions like "US%" limit 3')
+        regs = list(self.cur)
+        assert len(regs) == 3
+
+        # ORDER BY
+        self.cur.execute('show regions like "US%" limit 3 order by name')
+        regs = list(self.cur)
+        assert len(regs) == 3
+        assert regs == list(sorted(regs, key=lambda x: x[0]))
+
+        # Wrong column
+        with self.assertRaises(KeyError):
+            self.cur.execute('show regions like "US%" limit 3 order by foo')
+
+    def test_show_workspace_groups(self):
+        self.cur.execute('show workspace groups')
+        wgs = list(self.cur)
+        desc = self.cur.description
+
+        assert len(desc) == 4
+        assert desc[0].name == 'Name'
+        assert desc[1].name == 'ID'
+        assert desc[2].name == 'Region'
+        assert desc[3].name == 'FirewallRanges'
+        assert len(wgs) >= 3
+
+        names = [x[0] for x in wgs]
+        assert f'A Fusion Testing {self.id}' in names
+        assert f'B Fusion Testing {self.id}' in names
+        assert f'C Fusion Testing {self.id}' in names
+
+        # LIKE clause
+        self.cur.execute(f'show workspace groups like "A%sion Testing {self.id}"')
+        wgs = list(self.cur)
+
+        names = [x[0] for x in wgs]
+        assert f'A Fusion Testing {self.id}' in names
+        assert f'B Fusion Testing {self.id}' not in names
+        assert f'C Fusion Testing {self.id}' not in names
+
+        # LIMIT clause
+        self.cur.execute('show workspace groups limit 2')
+        wgs = list(self.cur)
+        assert len(wgs) == 2
+
+        # EXTENDED attributes
+        self.cur.execute('show workspace groups extended')
+        wgs = list(self.cur)
+        desc = self.cur.description
+
+        assert len(desc) == 6
+        assert desc[4].name == 'CreatedAt'
+        assert desc[5].name == 'TerminatedAt'
+
+        # ORDER BY
+        self.cur.execute(
+            f'show workspace groups like "% Fusion Testing {self.id}" order by name desc',
+        )
+        wgs = list(self.cur)
+
+        names = [x[0] for x in wgs]
+        assert names == [
+            f'C Fusion Testing {self.id}',
+            f'B Fusion Testing {self.id}',
+            f'A Fusion Testing {self.id}',
+        ]
+
+        # All options
+        self.cur.execute(
+            f'show workspace groups like "% Fusion Testing {self.id}" '
+            'extended order by name desc limit 2',
+        )
+        wgs = list(self.cur)
+        desc = self.cur.description
+        names = [x[0] for x in wgs]
+
+        assert len(desc) == 6
+        assert names == [f'C Fusion Testing {self.id}', f'B Fusion Testing {self.id}']
+
+    def test_show_workspaces(self):
+        mgr = s2.manage_workspaces()
+        wg = mgr.workspace_groups[f'B Fusion Testing {self.id}']
+
+        self.cur.execute(
+            'create workspace show-ws-1 in group '
+            f'"B Fusion Testing {self.id}" with size S-00',
+        )
+        self.cur.execute(
+            'create workspace show-ws-2 in group '
+            f'"B Fusion Testing {self.id}" with size S-00',
+        )
+        self.cur.execute(
+            'create workspace show-ws-3 in group '
+            f'"B Fusion Testing {self.id}" with size S-00',
+        )
+
+        time.sleep(30)
+        iterations = 20
+        while True:
+            wgs = wg.workspaces
+            states = [
+                x.state for x in wgs
+                if x.name in ('show-ws-1', 'show-ws-2', 'show-ws-3')
+            ]
+            if len(states) == 3 and states.count('ACTIVE') == 3:
+                break
+            iterations -= 1
+            if not iterations:
+                raise RuntimeError('timed out waiting for workspaces to start')
+            time.sleep(30)
+
+        # SHOW
+        self.cur.execute(f'show workspaces in group "B Fusion Testing {self.id}"')
+        desc = self.cur.description
+        out = list(self.cur)
+        names = [x[0] for x in out]
+        assert len(desc) == 4
+        assert [x[0] for x in desc] == ['Name', 'ID', 'Size', 'State']
+        assert len(out) >= 3
+        assert 'show-ws-1' in names
+        assert 'show-ws-2' in names
+        assert 'show-ws-3' in names
+
+        # SHOW ID
+        self.cur.execute(f'show workspaces in group id {wg.id}')
+        desc = self.cur.description
+        out = list(self.cur)
+        names = [x[0] for x in out]
+        assert len(desc) == 4
+        assert [x[0] for x in desc] == ['Name', 'ID', 'Size', 'State']
+        assert len(out) >= 3
+        assert 'show-ws-1' in names
+        assert 'show-ws-2' in names
+        assert 'show-ws-3' in names
+
+        # LIKE clause
+        self.cur.execute(
+            'show workspaces in group '
+            f'"B Fusion Testing {self.id}" like "%2"',
+        )
+        out = list(self.cur)
+        names = [x[0] for x in out]
+        assert len(out) >= 1
+        assert [x for x in names if x.endswith('2')]
+        assert 'show-ws-1' not in names
+        assert 'show-ws-2' in names
+        assert 'show-ws-3' not in names
+
+        # Extended attributes
+        self.cur.execute(
+            'show workspaces in group '
+            f'"B Fusion Testing {self.id}" extended',
+        )
+        desc = self.cur.description
+        out = list(self.cur)
+        assert len(desc) == 7
+        assert [x[0] for x in desc] == [
+            'Name', 'ID', 'Size', 'State',
+            'Endpoint', 'CreatedAt', 'TerminatedAt',
+        ]
+
+        # ORDER BY
+        self.cur.execute(
+            'show workspaces in group '
+            f'"B Fusion Testing {self.id}" order by name desc',
+        )
+        out = list(self.cur)
+        desc = self.cur.description
+        assert len(desc) == 4
+        names = [x[0] for x in out]
+        assert names == ['show-ws-3', 'show-ws-2', 'show-ws-1']
+
+        # LIMIT clause
+        self.cur.execute(
+            'show workspaces in group '
+            f'"B Fusion Testing {self.id}" order by name desc limit 2',
+        )
+        out = list(self.cur)
+        desc = self.cur.description
+        assert len(desc) == 4
+        names = [x[0] for x in out]
+        assert names == ['show-ws-3', 'show-ws-2']
+
+        # All options
+        self.cur.execute(
+            f'show workspaces in group "B Fusion Testing {self.id}" '
+            'like "show-ws%" extended order by name desc limit 2',
+        )
+        out = list(self.cur)
+        desc = self.cur.description
+        assert len(desc) == 7
+        names = [x[0] for x in out]
+        assert names == ['show-ws-3', 'show-ws-2']
+
+    def test_create_drop_workspace(self):
+        mgr = s2.manage_workspaces()
+        wg = mgr.workspace_groups[f'A Fusion Testing {self.id}']
+
+        self.cur.execute(
+            f'create workspace foobar-1 in group "A Fusion Testing {self.id}" '
+            'with size S-00 wait on active',
+        )
+        foobar_1 = [x for x in wg.workspaces if x.name == 'foobar-1']
+        assert len(foobar_1) == 1
+
+        self.cur.execute(
+            f'create workspace foobar-2 in group "A Fusion Testing {self.id}" '
+            'with size S-00 wait on active',
+        )
+        foobar_2 = [x for x in wg.workspaces if x.name == 'foobar-2']
+        assert len(foobar_2) == 1
+
+        # Drop by name
+        self.cur.execute(
+            f'drop workspace "foobar-1" in group "A Fusion Testing {self.id}" '
+            'wait on terminated',
+        )
+        foobar_1 = [x for x in wg.workspaces if x.name == 'foobar-1']
+        assert len(foobar_1) == 0
+
+        # Drop by ID
+        foobar_2_id = foobar_2[0].id
+        self.cur.execute(
+            f'drop workspace id {foobar_2_id} in group '
+            f'"A Fusion Testing {self.id}" wait on terminated',
+        )
+        foobar_2 = [x for x in wg.workspaces if x.name == 'foobar-2']
+        assert len(foobar_2) == 0
+
+        # Drop non-existent by ID
+        with self.assertRaises(KeyError):
+            self.cur.execute(
+                f'drop workspace id {foobar_2_id} '
+                f'in group "A Fusion Testing {self.id}"',
+            )
+
+        # Drop non-existent by ID with IF EXISTS
+        self.cur.execute(
+            f'drop workspace IF EXISTS id {foobar_2_id} '
+            f'in group "A Fusion Testing {self.id}"',
+        )
+
+    def test_create_drop_workspace_group(self):
+        mgr = s2.manage_workspaces()
+
+        reg = [x for x in mgr.regions if x.name.startswith('US')][0]
+        wg_name = f'Create WG Test {id(self)}'
+
+        try:
+            self.cur.execute(
+                f'create workspace group "{wg_name}" '
+                f'in region "{reg.name}"',
+            )
+            wg = [x for x in mgr.workspace_groups if x.name == wg_name]
+            assert len(wg) == 1
+
+            # Drop it by name
+            self.cur.execute(
+                f'drop workspace group "{wg_name}" '
+                'wait on terminated',
+            )
+            wg = [x for x in mgr.workspace_groups if x.name == wg_name]
+            assert len(wg) == 0
+
+            # Create it again
+            self.cur.execute(
+                f'create workspace group "{wg_name}" in region "{reg.name}"',
+            )
+            wg = [x for x in mgr.workspace_groups if x.name == wg_name]
+            assert len(wg) == 1
+
+            # Drop it by ID
+            wg_id = wg[0].id
+            self.cur.execute(f'drop workspace group id {wg_id} wait on terminated')
+            wg = [x for x in mgr.workspace_groups if x.name == wg_name]
+            assert len(wg) == 0
+
+            # Drop non-existent
+            with self.assertRaises(KeyError):
+                self.cur.execute(f'drop workspace group id {wg_id}')
+
+            # Drop non-existent with IF EXISTS
+            self.cur.execute(f'drop workspace group if exists id {wg_id}')
+
+        finally:
+            try:
+                mgr.workspace_groups[wg_name].terminate(force=True)
+            except Exception:
+                pass

singlestoredb/tests/test_http.py

@@ -30,9 +30,9 @@ class TestHTTP(unittest.TestCase):
     def setUp(self):
         self.conn = self._connect()
         self.cur = self.conn.cursor()
-        if self.params['protocol'] not in ['http', 'https']:
+        if self.params['driver'] not in ['http', 'https']:
             self.skipTest('Tests must be run using HTTP connection')
-        self.driver = self.params['protocol'] or 'http'
+        self.driver = self.params['driver'] or 'http'
 
     def _connect(self):
         params = sc.build_params(host=config.get_option('host'))
@@ -42,7 +42,7 @@ class TestHTTP(unittest.TestCase):
                 port=params.get('port'),
                 user=params.get('user'),
                 password=params.get('password'),
-                protocol=params.get('driver'),
+                driver=params.get('driver'),
             ).items() if v is not None
         }
         return http.connect(database=type(self).dbname, **self.params)
@@ -63,56 +63,62 @@ class TestHTTP(unittest.TestCase):
             pass
 
     def test_get_exc_type(self):
-        exc = http.get_exc_type(0)
+        exc = http.connection.get_exc_type(0)
         assert exc is http.InterfaceError, exc
 
-        exc = http.get_exc_type(2012)
+        exc = http.connection.get_exc_type(2012)
         assert exc is http.InterfaceError, exc
 
-        exc = http.get_exc_type(1230)
+        exc = http.connection.get_exc_type(1230)
         assert exc is http.DataError, exc
 
-        exc = http.get_exc_type(1110)
+        exc = http.connection.get_exc_type(1110)
         assert exc is http.ProgrammingError, exc
 
-        exc = http.get_exc_type(1452)
+        exc = http.connection.get_exc_type(1452)
         assert exc is http.IntegrityError, exc
 
-        exc = http.get_exc_type(9999)
+        exc = http.connection.get_exc_type(9999)
         assert exc is http.OperationalError, exc
 
-        exc = http.get_exc_type(222)
+        exc = http.connection.get_exc_type(222)
         assert exc is http.InternalError, exc
 
     def test_identity(self):
-        out = http.identity(1)
+        out = http.connection.identity(1)
         assert out == 1, out
 
-        out = http.identity('hi')
+        out = http.connection.identity('hi')
         assert out == 'hi', out
 
     def test_b64decode_converter(self):
         data = base64.b64encode(b'hi there')
         assert type(data) is bytes, type(data)
 
-        out = http.b64decode_converter(http.identity, None)
+        out = http.connection.b64decode_converter(http.connection.identity, None)
         assert out is None, out
 
-        out = http.b64decode_converter(http.identity, data)
+        out = http.connection.b64decode_converter(http.connection.identity, data)
         assert out == b'hi there', out
 
-        out = http.b64decode_converter(http.identity, str(data, 'utf8'))
+        out = http.connection.b64decode_converter(
+            http.connection.identity,
+            str(data, 'utf8'),
+        )
         assert out == b'hi there', out
 
     def test_executemany(self):
-        self.cur.executemany('select * from data where id < ?', [['d'], ['e']])
+        self.cur.executemany(
+            'select * from data where id < %(id)s',
+            [dict(id='d'), dict(id='e')],
+        )
 
         assert self.cur.rownumber == 0, self.cur.rownumber
 
         # First set
         out = self.cur.fetchall()
 
-        assert self.cur.rownumber is None, self.cur.rownumber
+        assert self.cur.rownumber == 3, self.cur.rownumber
 
         desc = self.cur.description
         rowcount = self.cur.rowcount
@@ -124,7 +130,7 @@ class TestHTTP(unittest.TestCase):
             ('c', 'cats', 5),
         ]), out
 
-        assert rowcount == 3, rowcount
+        assert rowcount == 7, rowcount
         assert lastrowid is None, lastrowid
         assert len(desc) == 3, desc
         assert desc[0][0] == 'id', desc[0][0]
@@ -161,7 +167,7 @@ class TestHTTP(unittest.TestCase):
         assert desc[2][1] == 8, desc[2][1]
 
         out = self.cur.nextset()
-        assert out is False, out
+        assert out is None, out
 
     def test_executemany_no_args(self):
         self.cur.executemany('select * from data where id < "d"')
@@ -190,7 +196,7 @@ class TestHTTP(unittest.TestCase):
         assert desc[2][1] == 8, desc[2][1]
 
         out = self.cur.nextset()
-        assert out is False, out
+        assert out is None, out
 
     def test_is_connected(self):
         assert self.cur.is_connected() is True
@@ -201,18 +207,18 @@ class TestHTTP(unittest.TestCase):
         self.cur.close()
         assert self.cur.is_connected() is False
 
-        with self.assertRaises(http.InterfaceError):
+        with self.assertRaises(http.ProgrammingError):
             self.cur.execute('select 1')
 
-        with self.assertRaises(http.InterfaceError):
+        with self.assertRaises(http.ProgrammingError):
             self.cur.executemany('select 1')
 
-        with self.assertRaises(http.InterfaceError):
+        with self.assertRaises(http.ProgrammingError):
             self.cur.callproc('get_animal', ['cats'])
 
-    def test_callproc(self):
-        with self.assertRaises(NotImplementedError):
-            self.cur.callproc('get_animal', ['cats'])
+#   def test_callproc(self):
+#       with self.assertRaises(NotImplementedError):
+#           self.cur.callproc('get_animal', ['cats'])
 
     def test_iter(self):
         self.cur.execute('select * from data')