fix test cases

tests/system-test/6-cluster/vnode/4dnode1mnode_basic_createDb_replica1.py

@@ -3,7 +3,7 @@ from ssl import ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE
 import taos
 import sys
 import time
-import os 
+import os
 
 from util.log import *
 from util.sql import *
@@ -95,7 +95,7 @@ class TDTestCase:
             (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
             '''
         )
-        
+
         for i in range(5):
             tdSql.execute("create table sub_tb_{} using stb1 tags({})".format(i,i))
         tdSql.query("show stables")
@@ -126,7 +126,7 @@ class TDTestCase:
         return taos.connect(host=host, port=int(port), config=config_dir)
 
 
-    def run(self): 
+    def run(self):
         self.check_setup_cluster_status()
         self.create_db_check_vgroups()
 
@@ -135,4 +135,4 @@ class TDTestCase:
         tdLog.success(f"{__file__} successfully executed")
 
 tdCases.addLinux(__file__, TDTestCase())
-tdCases.addWindows(__file__, TDTestCase())
\ No newline at end of file
+tdCases.addWindows(__file__, TDTestCase())

tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_insertdatas_stop_follower_unsync_force_stop.py

@@ -3,7 +3,7 @@ from ssl import ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE
 import taos
 import sys
 import time
-import os 
+import os
 
 from util.log import *
 from util.sql import *
@@ -30,9 +30,9 @@ class TDTestCase:
         self.ts = 1483200000000
         self.ts_step =1000
         self.db_name ='testdb'
-        self.replica = 3 
+        self.replica = 3
         self.vgroups = 1
-        self.tb_nums = 10 
+        self.tb_nums = 10
         self.row_nums = 100
         self.stop_dnode_id = None
         self.loop_restart_times = 5
@@ -110,7 +110,7 @@ class TDTestCase:
             (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
             '''
         )
-        
+
         for i in range(5):
             tdSql.execute("create table sub_tb_{} using stb1 tags({})".format(i,i))
         tdSql.query("show stables")
@@ -142,7 +142,7 @@ class TDTestCase:
         tdSql.execute(drop_db_sql)
         tdSql.execute(create_db_sql)
         tdSql.execute("use {}".format(dbname))
-       
+
     def create_stable_insert_datas(self,dbname ,stablename , tb_nums , row_nums):
         tdSql.execute("use {}".format(dbname))
         tdSql.execute(
@@ -151,7 +151,7 @@ class TDTestCase:
         tags (t1 int)
         '''.format(stablename)
         )
-    
+
         for i in range(tb_nums):
             sub_tbname = "sub_{}_{}".format(stablename,i)
             tdSql.execute("create table {} using {} tags({})".format(sub_tbname, stablename ,i))
@@ -162,11 +162,11 @@ class TDTestCase:
                 tdSql.execute(f"insert into {sub_tbname} values ({ts}, {row_num} ,{row_num}, 10 ,1 ,{row_num} ,{row_num},true,'bin_{row_num}','nchar_{row_num}',now) ")
 
         tdLog.notice(" ==== stable {} insert rows execute end =====".format(stablename))
-    
+
     def append_rows_of_exists_tables(self,dbname ,stablename , tbname , append_nums ):
-        
+
         tdSql.execute("use {}".format(dbname))
-     
+
         for row_num in range(append_nums):
             tdSql.execute(f"insert into {tbname} values (now, {row_num} ,{row_num}, 10 ,1 ,{row_num} ,{row_num},true,'bin_{row_num}','nchar_{row_num}',now) ")
             # print(f"insert into {tbname} values (now, {row_num} ,{row_num}, 10 ,1 ,{row_num} ,{row_num},true,'bin_{row_num}','nchar_{row_num}',now) ")
@@ -176,7 +176,7 @@ class TDTestCase:
     def check_insert_rows(self, dbname, stablename , tb_nums , row_nums, append_rows):
 
         tdSql.execute("use {}".format(dbname))
-        
+
         tdSql.query("select count(*) from {}.{}".format(dbname,stablename))
 
         while not tdSql.queryResult:
@@ -184,8 +184,8 @@ class TDTestCase:
             tdSql.query("select count(*) from {}.{}".format(dbname,stablename))
 
         status_OK = self.mycheckData("select count(*) from {}.{}".format(dbname,stablename) ,0 , 0 , tb_nums*row_nums+append_rows)
-        
-        count = 0 
+
+        count = 0
         while not status_OK :
             if count > self.try_check_times:
                 os.system("taos -s ' show {}.vgroups; '".format(dbname))
@@ -199,14 +199,14 @@ class TDTestCase:
             status_OK = self.mycheckData("select count(*) from {}.{}".format(dbname,stablename) ,0 , 0 , tb_nums*row_nums+append_rows)
             tdLog.notice(" ==== check insert rows first failed , this is {}_th retry check rows of database {}".format(count , dbname))
             count += 1
-        
+
 
         tdSql.query("select distinct tbname from {}.{}".format(dbname,stablename))
         while not tdSql.queryResult:
             time.sleep(0.1)
             tdSql.query("select distinct tbname from {}.{}".format(dbname,stablename))
         status_OK = self.mycheckRows("select distinct tbname from {}.{}".format(dbname,stablename) ,tb_nums)
-        count = 0 
+        count = 0
         while not status_OK :
             if count > self.try_check_times:
                 os.system("taos -s ' show {}.vgroups;'".format(dbname))
@@ -225,7 +225,7 @@ class TDTestCase:
         tdSql.query("show {}.vgroups".format(dbname))
         vgroup_infos = tdSql.queryResult
         for vgroup_info in vgroup_infos:
-            leader_infos = vgroup_info[3:-4] 
+            leader_infos = vgroup_info[3:-4]
             # print(vgroup_info)
             for ind ,role in enumerate(leader_infos):
                 if role =='follower':
@@ -237,7 +237,7 @@ class TDTestCase:
         return self.stop_dnode_id
 
     def wait_stop_dnode_OK(self):
-    
+
         def _get_status():
             newTdSql=tdCom.newTdSql()
 
@@ -250,7 +250,7 @@ class TDTestCase:
                 if id == self.stop_dnode_id:
                     status = dnode_status
                     break
-            return status 
+            return status
 
         status = _get_status()
         while status !="offline":
@@ -260,7 +260,7 @@ class TDTestCase:
         tdLog.notice("==== stop_dnode has stopped , id is {}".format(self.stop_dnode_id))
 
     def wait_start_dnode_OK(self):
-    
+
         def _get_status():
             newTdSql=tdCom.newTdSql()
             status =  ""
@@ -272,7 +272,7 @@ class TDTestCase:
                 if id == self.stop_dnode_id:
                     status = dnode_status
                     break
-            return status 
+            return status
 
         status = _get_status()
         while status !="ready":
@@ -366,7 +366,7 @@ class TDTestCase:
             tdLog.info("%s(%d) failed: sql:%s, queryRows:%d != expect:%d" % args)
             check_status = False
         return check_status
-        
+
     def sync_run_case(self):
         # stop follower and insert datas , update tables and create new stables
         tdDnodes=cluster.dnodes
@@ -376,19 +376,19 @@ class TDTestCase:
             self.create_database(dbname = db_name ,replica_num= self.replica  , vgroup_nums= 1)
             self.create_stable_insert_datas(dbname = db_name , stablename = stablename , tb_nums= 10 ,row_nums= 10 )
             self.stop_dnode_id = self._get_stop_dnode_id(db_name)
-            
+
             # check rows of datas
-            
+
             self.check_insert_rows(db_name ,stablename ,tb_nums=10 , row_nums= 10 ,append_rows=0)
-        
-            # begin stop dnode 
+
+            # begin stop dnode
             start = time.time()
             tdDnodes[self.stop_dnode_id-1].forcestop()
-        
+
             self.wait_stop_dnode_OK()
 
-            # append rows of stablename when dnode stop 
-            
+            # append rows of stablename when dnode stop
+
             tbname = "sub_{}_{}".format(stablename , 0)
             tdLog.notice(" ==== begin  append rows of exists table {} when dnode {} offline ====".format(tbname , self.stop_dnode_id))
             self.append_rows_of_exists_tables(db_name ,stablename , tbname , 100 )
@@ -401,20 +401,20 @@ class TDTestCase:
             tdLog.notice(" ==== check new stable {} when  dnode {} offline ====".format('new_stb1' , self.stop_dnode_id))
             self.check_insert_rows(db_name ,'new_stb1' ,tb_nums=10 , row_nums= 10 ,append_rows=0)
 
-            # begin start dnode 
+            # begin start dnode
             tdDnodes[self.stop_dnode_id-1].starttaosd()
             self.wait_start_dnode_OK()
             end = time.time()
             time_cost = int(end -start)
             if time_cost > self.max_restart_time:
                 tdLog.exit(" ==== restart dnode {} cost too much time , please check ====".format(self.stop_dnode_id))
-                
-            # create new stables again 
+
+            # create new stables again
             tdLog.notice(" ==== create new stable {} when  dnode {} restart ====".format('new_stb2' , self.stop_dnode_id))
             self.create_stable_insert_datas(dbname = db_name , stablename = 'new_stb2' , tb_nums= 10 ,row_nums= 10 )
             tdLog.notice(" ==== check new stable {} when  dnode {} restart ====".format('new_stb2' , self.stop_dnode_id))
             self.check_insert_rows(db_name ,'new_stb2' ,tb_nums=10 , row_nums= 10 ,append_rows=0)
-    
+
     def unsync_run_case(self):
 
         def _restart_dnode_of_db_unsync(dbname):
@@ -425,26 +425,26 @@ class TDTestCase:
                 time.sleep(0.5)
                 self.stop_dnode_id = self._get_stop_dnode_id(dbname)
             # begin restart dnode
-            
-            # force stop taosd by kill -9 
+
+            # force stop taosd by kill -9
             self.force_stop_dnode(self.stop_dnode_id)
             self.wait_stop_dnode_OK()
             tdDnodes[self.stop_dnode_id-1].starttaosd()
             self.wait_start_dnode_OK()
             end = time.time()
             time_cost = int(end-start)
-            
+
             if time_cost > self.max_restart_time:
                 tdLog.exit(" ==== restart dnode {} cost too much time , please check ====".format(self.stop_dnode_id))
-            
+
 
         def _create_threading(dbname):
             self.current_thread = threading.Thread(target=_restart_dnode_of_db_unsync, args=(dbname,))
             return self.current_thread
-            
+
 
         '''
-        in this mode  , it will be extra threading control start or stop dnode  , insert will always going with not care follower online or alive 
+        in this mode  , it will be extra threading control start or stop dnode  , insert will always going with not care follower online or alive
         '''
         tdDnodes=cluster.dnodes
         for loop in range(self.loop_restart_times):
@@ -455,7 +455,7 @@ class TDTestCase:
 
             tdLog.notice(" ===== restart dnode of database {}  in an unsync threading  ===== ".format(db_name))
 
-            # create sync threading and start it 
+            # create sync threading and start it
             self.current_thread = _create_threading(db_name)
             self.current_thread.start()
 
@@ -474,7 +474,7 @@ class TDTestCase:
             tdLog.notice(" ==== check new stable {} when  dnode {} offline ====".format('new_stb1' , self.stop_dnode_id))
             self.check_insert_rows(db_name ,'new_stb1' ,tb_nums=10 , row_nums= 10 ,append_rows=0)
 
-            # create new stables again 
+            # create new stables again
             tdLog.notice(" ==== create new stable {} when  dnode {} restart ====".format('new_stb2' , self.stop_dnode_id))
             self.create_stable_insert_datas(dbname = db_name , stablename = 'new_stb2' , tb_nums= 10 ,row_nums= 10 )
             tdLog.notice(" ==== check new stable {} when  dnode {} restart ====".format('new_stb2' , self.stop_dnode_id))
@@ -488,7 +488,7 @@ class TDTestCase:
         port = None
         for dnode_info in tdSql.queryResult:
             if dnode_id == dnode_info[0]:
-                port = dnode_info[1].split(":")[-1] 
+                port = dnode_info[1].split(":")[-1]
                 break
             else:
                 continue
@@ -502,7 +502,7 @@ class TDTestCase:
             os.system(ps_kill_taosd)
 
 
-    def run(self): 
+    def run(self):
 
         # basic insert and check of cluster
         self.check_setup_cluster_status()
@@ -510,7 +510,7 @@ class TDTestCase:
         # self.sync_run_case()
         self.unsync_run_case()
 
-        
+
 
 
     def stop(self):
@@ -518,4 +518,4 @@ class TDTestCase:
         tdLog.success(f"{__file__} successfully executed")
 
 tdCases.addLinux(__file__, TDTestCase())
-tdCases.addWindows(__file__, TDTestCase())
\ No newline at end of file
+tdCases.addWindows(__file__, TDTestCase())

tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_querydatas_stop_follower_force_stop.py

@@ -3,7 +3,7 @@ from ssl import ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE
 import taos
 import sys
 import time
-import os 
+import os
 
 from util.log import *
 from util.sql import *
@@ -30,9 +30,9 @@ class TDTestCase:
         self.ts = 1483200000000
         self.ts_step =1000
         self.db_name ='testdb'
-        self.replica = 3 
+        self.replica = 3
         self.vgroups = 1
-        self.tb_nums = 10 
+        self.tb_nums = 10
         self.row_nums = 100
         self.stop_dnode_id = None
         self.loop_restart_times = 5
@@ -40,7 +40,7 @@ class TDTestCase:
         self.max_restart_time = 10
         self.try_check_times = 10
         self.query_times = 100
-        
+
 
     def getBuildPath(self):
         selfPath = os.path.dirname(os.path.realpath(__file__))
@@ -103,7 +103,7 @@ class TDTestCase:
         tdSql.execute(drop_db_sql)
         tdSql.execute(create_db_sql)
         tdSql.execute("use {}".format(dbname))
-       
+
     def create_stable_insert_datas(self,dbname ,stablename , tb_nums , row_nums):
         tdSql.execute("use {}".format(dbname))
         tdSql.execute(
@@ -112,7 +112,7 @@ class TDTestCase:
         tags (t1 int)
         '''.format(stablename)
         )
-    
+
         for i in range(tb_nums):
             sub_tbname = "sub_{}_{}".format(stablename,i)
             tdSql.execute("create table {} using {} tags({})".format(sub_tbname, stablename ,i))
@@ -123,11 +123,11 @@ class TDTestCase:
                 tdSql.execute(f"insert into {sub_tbname} values ({ts}, {row_num} ,{row_num}, 10 ,1 ,{row_num} ,{row_num},true,'bin_{row_num}','nchar_{row_num}',now) ")
 
         tdLog.notice(" ==== stable {} insert rows execute end =====".format(stablename))
-    
+
     def append_rows_of_exists_tables(self,dbname ,stablename , tbname , append_nums ):
-        
+
         tdSql.execute("use {}".format(dbname))
-     
+
         for row_num in range(append_nums):
             tdSql.execute(f"insert into {tbname} values (now, {row_num} ,{row_num}, 10 ,1 ,{row_num} ,{row_num},true,'bin_{row_num}','nchar_{row_num}',now) ")
             # print(f"insert into {tbname} values (now, {row_num} ,{row_num}, 10 ,1 ,{row_num} ,{row_num},true,'bin_{row_num}','nchar_{row_num}',now) ")
@@ -137,7 +137,7 @@ class TDTestCase:
     def check_insert_rows(self, dbname, stablename , tb_nums , row_nums, append_rows):
 
         tdSql.execute("use {}".format(dbname))
-        
+
         tdSql.query("select count(*) from {}.{}".format(dbname,stablename))
 
         while not tdSql.queryResult:
@@ -145,8 +145,8 @@ class TDTestCase:
             tdSql.query("select count(*) from {}.{}".format(dbname,stablename))
 
         status_OK = self.mycheckData("select count(*) from {}.{}".format(dbname,stablename) ,0 , 0 , tb_nums*row_nums+append_rows)
-        
-        count = 0 
+
+        count = 0
         while not status_OK :
             if count > self.try_check_times:
                 os.system("taos -s ' show {}.vgroups; '".format(dbname))
@@ -160,14 +160,14 @@ class TDTestCase:
             status_OK = self.mycheckData("select count(*) from {}.{}".format(dbname,stablename) ,0 , 0 , tb_nums*row_nums+append_rows)
             tdLog.notice(" ==== check insert rows first failed , this is {}_th retry check rows of database {}".format(count , dbname))
             count += 1
-        
+
 
         tdSql.query("select distinct tbname from {}.{}".format(dbname,stablename))
         while not tdSql.queryResult:
             time.sleep(0.1)
             tdSql.query("select distinct tbname from {}.{}".format(dbname,stablename))
         status_OK = self.mycheckRows("select distinct tbname from {}.{}".format(dbname,stablename) ,tb_nums)
-        count = 0 
+        count = 0
         while not status_OK :
             if count > self.try_check_times:
                 os.system("taos -s ' show {}.vgroups;'".format(dbname))
@@ -186,7 +186,7 @@ class TDTestCase:
         tdSql.query("show {}.vgroups".format(dbname))
         vgroup_infos = tdSql.queryResult
         for vgroup_info in vgroup_infos:
-            leader_infos = vgroup_info[3:-4] 
+            leader_infos = vgroup_info[3:-4]
             # print(vgroup_info)
             for ind ,role in enumerate(leader_infos):
                 if role =='follower':
@@ -198,7 +198,7 @@ class TDTestCase:
         return self.stop_dnode_id
 
     def wait_stop_dnode_OK(self):
-    
+
         def _get_status():
             newTdSql=tdCom.newTdSql()
 
@@ -211,7 +211,7 @@ class TDTestCase:
                 if id == self.stop_dnode_id:
                     status = dnode_status
                     break
-            return status 
+            return status
 
         status = _get_status()
         while status !="offline":
@@ -221,7 +221,7 @@ class TDTestCase:
         tdLog.notice("==== stop_dnode has stopped , id is {}".format(self.stop_dnode_id))
 
     def wait_start_dnode_OK(self):
-    
+
         def _get_status():
             newTdSql=tdCom.newTdSql()
             status =  ""
@@ -233,7 +233,7 @@ class TDTestCase:
                 if id == self.stop_dnode_id:
                     status = dnode_status
                     break
-            return status 
+            return status
 
         status = _get_status()
         while status !="ready":
@@ -327,7 +327,7 @@ class TDTestCase:
             tdLog.info("%s(%d) failed: sql:%s, queryRows:%d != expect:%d" % args)
             check_status = False
         return check_status
-        
+
 
     def force_stop_dnode(self, dnode_id ):
 
@@ -335,7 +335,7 @@ class TDTestCase:
         port = None
         for dnode_info in tdSql.queryResult:
             if dnode_id == dnode_info[0]:
-                port = dnode_info[1].split(":")[-1] 
+                port = dnode_info[1].split(":")[-1]
                 break
             else:
                 continue
@@ -349,9 +349,9 @@ class TDTestCase:
             os.system(ps_kill_taosd)
 
     def basic_query_task(self,dbname ,stablename):
-        
+
         sql = "select * from {}.{} ;".format(dbname , stablename)
-        
+
         count = 0
         while count < self.query_times:
             os.system(''' taos -s '{}' >>/dev/null '''.format(sql))
@@ -364,18 +364,18 @@ class TDTestCase:
             self.thread_list.append(task)
 
         for thread in self.thread_list:
-            
+
             thread.start()
         return self.thread_list
 
 
     def stop_follower_when_query_going(self):
-        
+
         tdDnodes = cluster.dnodes
         self.create_database(dbname = self.db_name ,replica_num= self.replica  , vgroup_nums= 1)
         self.create_stable_insert_datas(dbname = self.db_name , stablename = "stb1" , tb_nums= self.tb_nums ,row_nums= self.row_nums)
 
-        # let query task start 
+        # let query task start
         self.thread_list = self.multi_thread_query_task(10 ,self.db_name ,'stb1' )
 
         # force stop follower
@@ -390,22 +390,22 @@ class TDTestCase:
             self.wait_start_dnode_OK()
             end = time.time()
             time_cost = int(end-start)
-            
+
             if time_cost > self.max_restart_time:
                 tdLog.exit(" ==== restart dnode {} cost too much time , please check ====".format(self.stop_dnode_id))
-        
+
         for thread in self.thread_list:
             thread.join()
 
 
-    def run(self): 
+    def run(self):
 
         # basic check of cluster
         self.check_setup_cluster_status()
         self.stop_follower_when_query_going()
 
 
-        
+
 
 
     def stop(self):
@@ -413,4 +413,4 @@ class TDTestCase:
         tdLog.success(f"{__file__} successfully executed")
 
 tdCases.addLinux(__file__, TDTestCase())
-tdCases.addWindows(__file__, TDTestCase())
\ No newline at end of file
+tdCases.addWindows(__file__, TDTestCase())

tests/system-test/6-cluster/vnode/4dnode1mnode_basic_replica3_vgroups.py

@@ -3,7 +3,7 @@ from ssl import ALERT_DESCRIPTION_CERTIFICATE_UNOBTAINABLE
 import taos
 import sys
 import time
-import os 
+import os
 
 from util.log import *
 from util.sql import *
@@ -25,9 +25,9 @@ class TDTestCase:
         self.dnode_list = {}
         self.ts = 1483200000000
         self.db_name ='testdb'
-        self.replica = 1 
+        self.replica = 1
         self.vgroups = 2
-        self.tb_nums = 10 
+        self.tb_nums = 10
         self.row_nums = 100
         self.max_vote_time_cost = 10  # seconds
 
@@ -101,7 +101,7 @@ class TDTestCase:
             (ts timestamp, c1 int, c2 bigint, c3 smallint, c4 tinyint, c5 float, c6 double, c7 bool, c8 binary(16),c9 nchar(32), c10 timestamp)
             '''
         )
-        
+
         for i in range(5):
             tdSql.execute("create table sub_tb_{} using stb1 tags({})".format(i,i))
         tdSql.query("show stables")
@@ -134,7 +134,7 @@ class TDTestCase:
             vgroup_id = vgroup_info[0]
             vgroup_status = []
             for ind , role in enumerate(vgroup_info[3:-4]):
-                
+
                 if ind%2==0:
                     continue
                 else:
@@ -151,7 +151,7 @@ class TDTestCase:
         while not status:
             time.sleep(0.1)
             status = self.check_vgroups_init_done(dbname)
-            
+
             # tdLog.notice("=== database {} show vgroups vote the leader is in progress ===".format(dbname))
         end = time.time()
         cost_time = end - start
@@ -159,16 +159,16 @@ class TDTestCase:
         # os.system("taos -s 'show {}.vgroups;'".format(dbname))
         if cost_time >= self.max_vote_time_cost:
             tdLog.exit(" ==== database %s vote the leaders cost too large time , cost time is %.3f second ===="%(dbname,cost_time) )
-        
-        
+
+
         return cost_time
-        
+
     def test_init_vgroups_time_costs(self):
 
         tdLog.notice(" ====start check time cost about vgroups vote leaders ==== ")
         tdLog.notice(" ==== current max time cost is set value : {} =======".format(self.max_vote_time_cost))
 
-        # create database replica 3 vgroups 1 
+        # create database replica 3 vgroups 1
 
         db1 = 'db_1'
         create_db_replica_3_vgroups_1 = "create database {} replica 3 vgroups 1".format(db1)
@@ -189,10 +189,10 @@ class TDTestCase:
         tdLog.notice('=======database {} replica 3 vgroups 100 ======'.format(db3))
         tdSql.execute(create_db_replica_3_vgroups_100)
         self.vote_leader_time_costs(db3)
-        
 
-   
-    def run(self): 
+
+
+    def run(self):
         self.check_setup_cluster_status()
         self.test_init_vgroups_time_costs()
 
@@ -203,4 +203,4 @@ class TDTestCase:
         tdLog.success(f"{__file__} successfully executed")
 
 tdCases.addLinux(__file__, TDTestCase())
-tdCases.addWindows(__file__, TDTestCase())
\ No newline at end of file
+tdCases.addWindows(__file__, TDTestCase())