update itest

diff --git a/itest/test_create_database.py b/itest/test_create_database.py
new file mode 100644 (file)
index 0000000..6a72685
--- /dev/null
+++ b/itest/test_create_database.py
@@ -0,0 +1,108 @@
+import asyncio
+import functools
+import os
+import subprocess
+import random
+import time
+from testing import Client
+from testing import default_test_setup
+from testing import gen_data
+from testing import gen_points
+from testing import gen_series
+from testing import InsertError
+from testing import PoolError
+from testing import QueryError
+from testing import run_test
+from testing import Series
+from testing import Server
+from testing import ServerError
+from testing import SiriDB
+from testing import TestBase
+from testing import UserAuthError
+from testing import parse_args
+
+
+LENPOINTS = 12
+DATA = {
+    'series-001': [
+        [1471254705000000005, 1.5],
+        [1471254705000000007, -3.5],
+        [1471254705000000010, -7.3]],
+    'series-002': [
+        [1471254705000000005, 5],
+        [1471254705000000008, -3],
+        [1471254705000000010, -7]],
+    'series-003': [
+        [1471254705000000005, 10.5],
+        [1471254705000000007, -8.5],
+        [1471254705000000010, -2.7]],
+    'series-004': [
+        [1471254705000000005, 6],
+        [1471254705000000008, -8],
+        [1471254705000000010, -9]],
+}
+
+TIME_PRECISION = 'ns'
+
+
+class TestCreateDatabase(TestBase):
+    title = 'Test create database'
+
+    @default_test_setup(1, time_precision=TIME_PRECISION)
+    async def run(self):
+        await self.client0.connect()
+
+        tasks = [
+            asyncio.ensure_future(
+                SiriDB(
+                    dbname="db_{}".format(i),
+                    time_precision=TIME_PRECISION).create_on(
+                        server=self.server0
+                        ))
+            for i in range(30)]
+
+        await asyncio.gather(*tasks)
+
+        self.assertEqual(
+            await self.client0.insert(DATA),
+            {'success_msg': 'Successfully inserted {} point(s).'.format(
+                LENPOINTS)})
+
+        self.assertEqual(
+            await self.client0.query('create group `b` for /series.*/'),
+            {'success_msg': "Successfully created group 'b'."})
+
+        time.sleep(3)
+
+        self.client0.close()
+
+        for i in range(30):
+            client = Client(
+                db=SiriDB(dbname="db_{}".format(i)),
+                servers=self.servers)
+            await client.connect()
+            self.assertEqual(
+                await client.insert(DATA),
+                {'success_msg': 'Successfully inserted {} point(s).'.format(
+                    LENPOINTS)})
+            client.close()
+
+        await self.client0.connect()
+
+        self.assertEqual(
+            await self.client0.query(
+                'select max(1) from /series.*/ '
+                'merge as "max" using max(1)'),
+            {'max': [
+                [1471254705000000005, 10.5],
+                [1471254705000000007, -3.5],
+                [1471254705000000008, -3.0],
+                [1471254705000000010, -2.7]
+            ]})
+
+        self.client0.close()
+
+
+if __name__ == '__main__':
+    parse_args()
+    run_test(TestCreateDatabase())

diff --git a/itest/test_parentheses.py b/itest/test_parentheses.py
index f1eed8257420b4648c52aec35d2fa05ab28df5d2..c31be3636ad76e718c415f006e467c669f2759f1 100644 (file)
--- a/itest/test_parentheses.py
+++ b/itest/test_parentheses.py
@@ -79,9 +79,6 @@ TIME_PRECISION = 'ns'
 class TestParenth(TestBase):
     title = 'Test parentheses'
 
-    GEN_POINTS = functools.partial(
-        gen_points, n=1, time_precision=TIME_PRECISION)
-
     @default_test_setup(1, time_precision=TIME_PRECISION)
     async def run(self):
         await self.client0.connect()

diff --git a/itest/testing/siridb.py b/itest/testing/siridb.py
index 71e7b8f21612e3847a6bf8cb58bce62ecc94dda3..5fa3300c19c74f7fd142ff5849d8b35152b63e8b 100644 (file)
--- a/itest/testing/siridb.py
+++ b/itest/testing/siridb.py
@@ -57,6 +57,48 @@ class SiriDB:
         if sleep:
             await asyncio.sleep(sleep)
 
+    async def add_database(
+                self,
+                server,
+                dbname='dbtest',
+                time_precision='s',
+                buffer_path='',
+                duration_log='1d',
+                duration_num='1w',
+                buffer_size=1024,
+                sleep=None):
+
+        logging.info('Create database {} on {}'.format(
+            dbname,
+            server.name))
+
+        rc = os.system(
+            '{service} '
+            '-u sa -p siri -s {addr} '
+            'new-database '
+            '--db-name {dbname} '
+            '--time-precision {time_precision} '
+            '--duration-log {duration_log} '
+            '--duration-num {duration_num} '
+            '--buffer-size {buffer_size}'
+            '{verbose}'.format(
+                service=SERVICE,
+                addr=server.addr,
+                dbname=dbname,
+                time_precision=time_precision,
+                duration_log=duration_log,
+                duration_num=duration_num,
+                buffer_size=buffer_size,
+                verbose=VERBOSE if self.LOG_LEVEL == 'DEBUG'
+                else ' >/dev/null'))
+
+        assert rc == 0, 'Expected rc = 0 but got rc = {}'.format(rc)
+
+        self.servers.append(server)
+
+        if sleep:
+            await asyncio.sleep(sleep)
+
     async def add_replica(
                 self,
                 server,

diff --git a/itest/testing/testbase.py b/itest/testing/testbase.py
index 8c1fe7ce98b8be09fdb94f0067fcd4bd77df780e..3fed61498073d46b1b98ab2fe9ff176ce48277f5 100644 (file)
--- a/itest/testing/testbase.py
+++ b/itest/testing/testbase.py
@@ -53,7 +53,7 @@ class TestBase(unittest.TestCase):
             result = result['servers']
             try:
                 assert len(result) == len(self.db.servers), \
-                    'Server(s) are missing: {} (expexting: {})'.format(
+                    'Server(s) are missing: {} (expecting: {})'.format(
                         result, self.db.servers)
             except AssertionError as e:
                 if not timeout: