From f1413bcf7d71792920f4271713bc50ead977f144 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E4=B8=AD=E5=A4=A7=E6=B7=98=E6=B2=99?= Date: Wed, 22 Jul 2026 14:19:00 +0800 Subject: [PATCH] add mysql testcases to sysbench --- lib/ts_common.py | 152 ++++++++++++++++- testcase/sysbench/sysbench.py | 30 +++- ...bench_mysql_bulk_insert_lua_threads_128.py | 62 +++++++ ...sbench_mysql_bulk_insert_lua_threads_16.py | 62 +++++++ ...ysbench_mysql_bulk_insert_lua_threads_4.py | 62 +++++++ ...sbench_mysql_bulk_insert_lua_threads_64.py | 62 +++++++ ...elete_threads_128_tables_300_size_20000.py | 63 +++++++ ...elete_threads_128_tables_500_size_50000.py | 63 +++++++ ..._delete_threads_16_tables_100_size_5000.py | 63 +++++++ ...tp_delete_threads_4_tables_10_size_1000.py | 63 +++++++ ...delete_threads_64_tables_200_size_10000.py | 63 +++++++ ...nsert_threads_128_tables_300_size_20000.py | 63 +++++++ ...nsert_threads_128_tables_500_size_50000.py | 63 +++++++ ..._insert_threads_16_tables_100_size_5000.py | 63 +++++++ ...tp_insert_threads_4_tables_10_size_1000.py | 63 +++++++ ...insert_threads_64_tables_200_size_10000.py | 63 +++++++ ...elect_threads_128_tables_300_size_20000.py | 63 +++++++ ...elect_threads_128_tables_500_size_50000.py | 63 +++++++ ..._select_threads_16_tables_100_size_5000.py | 63 +++++++ ...nt_select_threads_4_tables_10_size_1000.py | 63 +++++++ ...select_threads_64_tables_200_size_10000.py | 63 +++++++ ..._only_threads_128_tables_120_size_32000.py | 63 +++++++ ..._only_threads_128_tables_200_size_10000.py | 63 +++++++ ...ad_only_threads_16_tables_100_size_5000.py | 63 +++++++ ...reads_256_tables_250_size_25000_product.py | 63 +++++++ ...hreads_32_tables_250_size_25000_product.py | 63 +++++++ ...read_only_threads_4_tables_10_size_1000.py | 63 +++++++ ...reads_512_tables_250_size_25000_product.py | 63 +++++++ ...d_only_threads_64_tables_200_size_10000.py | 63 +++++++ ...threads_8_tables_250_size_25000_product.py | 63 +++++++ ...write_threads_128_tables_120_size_32000.py | 63 +++++++ ...write_threads_128_tables_200_size_10000.py | 63 +++++++ ...d_write_threads_16_tables_100_size_5000.py | 63 +++++++ ...reads_256_tables_250_size_25000_product.py | 63 +++++++ ...hreads_32_tables_250_size_25000_product.py | 63 +++++++ ...ead_write_threads_4_tables_10_size_1000.py | 63 +++++++ ...reads_512_tables_250_size_25000_product.py | 63 +++++++ ..._write_threads_64_tables_200_size_10000.py | 63 +++++++ ...threads_8_tables_250_size_25000_product.py | 63 +++++++ ...index_threads_128_tables_120_size_32000.py | 63 +++++++ ...index_threads_128_tables_200_size_10000.py | 63 +++++++ ...e_index_threads_16_tables_100_size_5000.py | 63 +++++++ ...reads_256_tables_250_size_25000_product.py | 63 +++++++ ...hreads_32_tables_250_size_25000_product.py | 63 +++++++ ...ate_index_threads_4_tables_10_size_1000.py | 63 +++++++ ...reads_512_tables_250_size_25000_product.py | 63 +++++++ ..._index_threads_64_tables_200_size_10000.py | 63 +++++++ ...threads_8_tables_250_size_25000_product.py | 63 +++++++ ...index_threads_128_tables_120_size_32000.py | 63 +++++++ ...index_threads_128_tables_200_size_10000.py | 63 +++++++ ...n_index_threads_16_tables_100_size_5000.py | 63 +++++++ ...reads_256_tables_250_size_25000_product.py | 63 +++++++ ...hreads_32_tables_250_size_25000_product.py | 63 +++++++ ...non_index_threads_4_tables_10_size_1000.py | 63 +++++++ ...reads_512_tables_250_size_25000_product.py | 63 +++++++ ..._index_threads_64_tables_200_size_10000.py | 63 +++++++ ...threads_8_tables_250_size_25000_product.py | 63 +++++++ ..._only_threads_128_tables_120_size_32000.py | 63 +++++++ ..._only_threads_128_tables_200_size_10000.py | 63 +++++++ ...te_only_threads_16_tables_100_size_5000.py | 63 +++++++ ...reads_256_tables_250_size_25000_product.py | 63 +++++++ ...hreads_32_tables_250_size_25000_product.py | 63 +++++++ ...rite_only_threads_4_tables_10_size_1000.py | 63 +++++++ ...reads_512_tables_250_size_25000_product.py | 63 +++++++ ...e_only_threads_64_tables_200_size_10000.py | 63 +++++++ ...threads_8_tables_250_size_25000_product.py | 63 +++++++ ...points_threads_128_tables_1_size_100000.py | 63 +++++++ ...om_points_threads_16_tables_1_size_5000.py | 63 +++++++ ...points_threads_256_tables_1_size_100000.py | 63 +++++++ ...dom_points_threads_4_tables_1_size_1000.py | 63 +++++++ ...points_threads_512_tables_1_size_200000.py | 63 +++++++ ...m_points_threads_64_tables_1_size_50000.py | 63 +++++++ ...ranges_threads_128_tables_1_size_100000.py | 63 +++++++ ...om_ranges_threads_16_tables_1_size_5000.py | 63 +++++++ ...ranges_threads_256_tables_1_size_100000.py | 63 +++++++ ...dom_ranges_threads_4_tables_1_size_1000.py | 63 +++++++ ...ranges_threads_512_tables_1_size_200000.py | 63 +++++++ ...m_ranges_threads_64_tables_1_size_50000.py | 63 +++++++ tools/sysbench/tst-build.sh | 155 +++++++++++++++++- 79 files changed, 5111 insertions(+), 10 deletions(-) create mode 100755 testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_128.py create mode 100755 testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_16.py create mode 100755 testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_4.py create mode 100755 testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_64.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_delete_threads_128_tables_300_size_20000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_delete_threads_128_tables_500_size_50000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_delete_threads_16_tables_100_size_5000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_delete_threads_4_tables_10_size_1000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_delete_threads_64_tables_200_size_10000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_insert_threads_128_tables_300_size_20000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_insert_threads_128_tables_500_size_50000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_insert_threads_16_tables_100_size_5000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_insert_threads_4_tables_10_size_1000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_insert_threads_64_tables_200_size_10000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_point_select_threads_128_tables_300_size_20000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_point_select_threads_128_tables_500_size_50000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_point_select_threads_16_tables_100_size_5000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_point_select_threads_4_tables_10_size_1000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_point_select_threads_64_tables_200_size_10000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_only_threads_128_tables_120_size_32000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_only_threads_128_tables_200_size_10000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_only_threads_16_tables_100_size_5000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_only_threads_256_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_only_threads_32_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_only_threads_4_tables_10_size_1000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_only_threads_512_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_only_threads_64_tables_200_size_10000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_only_threads_8_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_write_threads_128_tables_120_size_32000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_write_threads_128_tables_200_size_10000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_write_threads_16_tables_100_size_5000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_write_threads_256_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_write_threads_32_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_write_threads_4_tables_10_size_1000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_write_threads_512_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_write_threads_64_tables_200_size_10000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_read_write_threads_8_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_index_threads_128_tables_120_size_32000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_index_threads_128_tables_200_size_10000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_index_threads_16_tables_100_size_5000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_index_threads_256_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_index_threads_32_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_index_threads_4_tables_10_size_1000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_index_threads_512_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_index_threads_64_tables_200_size_10000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_index_threads_8_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_128_tables_120_size_32000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_128_tables_200_size_10000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_16_tables_100_size_5000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_256_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_32_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_4_tables_10_size_1000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_512_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_64_tables_200_size_10000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_8_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_write_only_threads_128_tables_120_size_32000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_write_only_threads_128_tables_200_size_10000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_write_only_threads_16_tables_100_size_5000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_write_only_threads_256_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_write_only_threads_32_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_write_only_threads_4_tables_10_size_1000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_write_only_threads_512_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_write_only_threads_64_tables_200_size_10000.py create mode 100755 testcase/sysbench/sysbench_mysql_oltp_write_only_threads_8_tables_250_size_25000_product.py create mode 100755 testcase/sysbench/sysbench_mysql_select_random_points_threads_128_tables_1_size_100000.py create mode 100755 testcase/sysbench/sysbench_mysql_select_random_points_threads_16_tables_1_size_5000.py create mode 100755 testcase/sysbench/sysbench_mysql_select_random_points_threads_256_tables_1_size_100000.py create mode 100755 testcase/sysbench/sysbench_mysql_select_random_points_threads_4_tables_1_size_1000.py create mode 100755 testcase/sysbench/sysbench_mysql_select_random_points_threads_512_tables_1_size_200000.py create mode 100755 testcase/sysbench/sysbench_mysql_select_random_points_threads_64_tables_1_size_50000.py create mode 100755 testcase/sysbench/sysbench_mysql_select_random_ranges_threads_128_tables_1_size_100000.py create mode 100755 testcase/sysbench/sysbench_mysql_select_random_ranges_threads_16_tables_1_size_5000.py create mode 100755 testcase/sysbench/sysbench_mysql_select_random_ranges_threads_256_tables_1_size_100000.py create mode 100755 testcase/sysbench/sysbench_mysql_select_random_ranges_threads_4_tables_1_size_1000.py create mode 100755 testcase/sysbench/sysbench_mysql_select_random_ranges_threads_512_tables_1_size_200000.py create mode 100755 testcase/sysbench/sysbench_mysql_select_random_ranges_threads_64_tables_1_size_50000.py diff --git a/lib/ts_common.py b/lib/ts_common.py index 44cf22f2..439ffb16 100644 --- a/lib/ts_common.py +++ b/lib/ts_common.py @@ -396,6 +396,18 @@ class PerfSysBench(TSTPerf): label: str = "", general_opt: str = "", test_opt: str = "", + # mysql用例参数：指定lua脚本名(不含.lua)、并发线程数、表数量、单表行数、测试时长 + mysql_lua: str = "", + mysql_threads: str = "", + mysql_tables: str = "", + mysql_table_size: str = "", + mysql_time: str = "60", + # 预热时长：仅部分lua脚本(如bulk_insert)支持--warmup-time， + # 使用oltp_common的脚本不支持，传空则不带该参数以免报"invalid option" + mysql_warmup_time: str = "", + mysql_host: str = "127.0.0.1", + mysql_port: str = "3306", + mysql_user: str = "root", ): super().__init__() self.name = name @@ -406,10 +418,56 @@ class PerfSysBench(TSTPerf): self.sysbench = os.path.join( tperf_top_dir, "tools/sysbench.install/bin/sysbench" ) - self.command = ( - f"{self.sysbench} {self.general_opt if self.general_opt else ''} {self.testname} " - f"{self.test_opt if self.test_opt else ''} run" + # mysql用例相关配置 + self.mysql_lua = mysql_lua + self.mysql_threads = mysql_threads + self.mysql_tables = mysql_tables + self.mysql_table_size = mysql_table_size + self.mysql_time = mysql_time + self.mysql_warmup_time = mysql_warmup_time + self.mysql_conn_opt = ( + f"--mysql-host={mysql_host} " + f"--mysql-port={mysql_port} " + f"--mysql-user={mysql_user}" ) + self.prepare_cmd = "" + self.cleanup_cmd = "" + if self.testname == "mysql": + # mysql用例：run/prepare/cleanup均基于同一lua脚本和表配置，避免用例间相互影响 + lua_path = os.path.join( + tperf_top_dir, + "tools/sysbench.install/share/sysbench", + f"{self.mysql_lua}.lua", + ) + table_opt = "" + if self.mysql_tables: + table_opt += f" --tables={self.mysql_tables}" + if self.mysql_table_size: + table_opt += f" --table_size={self.mysql_table_size}" + # 仅在lua脚本支持时才带--warmup-time，避免"invalid option"报错 + warmup_opt = ( + f" --warmup-time={self.mysql_warmup_time}" + if self.mysql_warmup_time + else "" + ) + self.command = ( + f"{self.sysbench} --threads={self.mysql_threads} " + f"--time={self.mysql_time} --report-interval=10{warmup_opt} " + f"{self.mysql_conn_opt} {lua_path}{table_opt} run" + ) + self.prepare_cmd = ( + f"{self.sysbench} --threads={self.mysql_threads} " + f"{self.mysql_conn_opt} {lua_path}{table_opt} prepare" + ) + self.cleanup_cmd = ( + f"{self.sysbench} --threads={self.mysql_threads} " + f"{self.mysql_conn_opt} {lua_path}{table_opt} cleanup" + ) + else: + self.command = ( + f"{self.sysbench} {self.general_opt if self.general_opt else ''} {self.testname} " + f"{self.test_opt if self.test_opt else ''} run" + ) self.outs = "" self.errs = "" @@ -425,8 +483,30 @@ class PerfSysBench(TSTPerf): if not os.path.isfile(self.sysbench): raise FileNotFoundError(f"sysbench tool compile fail: {self.sysbench}") + def _mysql_prepare_data(self): + """mysql用例每轮测试前先建表并灌入数据""" + self.log(f"mysql prepare: {self.prepare_cmd}") + code = command(cmd=self.prepare_cmd) + if code != 0: + raise Exception(f"mysql prepare fail, code: {code}, cmd: {self.prepare_cmd}") + # 清理page cache，减少上一轮数据缓存对本轮测试的影响 + command(cmd="sync; echo 3 > /proc/sys/vm/drop_caches 2>/dev/null || true") + + def _mysql_cleanup_data(self): + """mysql用例每轮测试后删除测试表，避免影响下一轮测试""" + if self.cleanup_cmd: + self.log(f"mysql cleanup: {self.cleanup_cmd}") + command(cmd=self.cleanup_cmd) + def benchmark(self): - """执行性能测试""" + """执行性能测试 + + mysql用例每一轮都自成闭环：先prepare建表灌数据，再执行run， + 最后cleanup清表并sleep 0.5s，避免各轮测试之间相互影响(如主键冲突)。 + """ + # mysql用例每轮测试前先准备数据 + if self.testname == "mysql": + self._mysql_prepare_data() self.log(f"COMMAND: {self.command}") proc = subprocess.Popen( self.command, @@ -438,6 +518,10 @@ class PerfSysBench(TSTPerf): self.outs, self.errs = proc.communicate() self.log(f"outs: {self.outs}") self.log(f"errs: {self.errs}") + # mysql用例每轮测试后清理数据，并sleep 0.5s后再进行下一轮测试 + if self.testname == "mysql": + self._mysql_cleanup_data() + time.sleep(0.5) def parse_test_data(self): """执行benchmark性能测试后,对测试结果进行解析,返回PerfResult或其list性能测试结果""" @@ -460,12 +544,19 @@ class PerfSysBench(TSTPerf): result.append(self.get_threads_result()) elif self.testname == "mutex": result.append(self.get_mutex_result()) + elif self.testname == "mysql": + # mysql用例采集两个指标：吞吐量eps(越大越好)和时延latency(越小越好) + result.append(self.get_mysql_eps_result()) + result.append(self.get_mysql_latency_result()) else: raise Exception(f"unknown test name {self.testname}") return result def cleanup(self): - """性能测试完成后cleanup""" + """性能测试完成后cleanup + + mysql用例的建表/清表已在每轮benchmark中自成闭环处理，此处无需再清理。 + """ pass def get_cpu_result(self): @@ -543,6 +634,57 @@ class PerfSysBench(TSTPerf): break return result + def get_mysql_eps_result(self): + """解析mysql吞吐量指标eps(每秒处理事务数)，数值越大越好 + + 兼容两种sysbench输出格式： + 1. 新版本存在Throughput段落: events/s (eps): xxx + 2. 部分版本无Throughput段落，取SQL statistics中每秒事务数: + transactions: 58069780 (938628.09 per sec.) + """ + result = PerfData( + name=f"{self.name}-eps", + value_type=ValueType.HIB, + key_item=KeyItem.avg, + unit="eps", + label=self.label, + ) + eps = None + for line in self.outs.splitlines(): + s = line.strip() + if s.startswith("events/s (eps):"): + eps = float(s.split(":")[1].strip()) + break + if eps is None: + for line in self.outs.splitlines(): + s = line.strip() + if s.startswith("transactions:"): + m = re.search(r"\(\s*([\d.]+)\s+per\s+sec", s) + if m: + eps = float(m.group(1)) + break + if eps is not None: + result.set_key_value(value=eps) + return result + + def get_mysql_latency_result(self): + """解析mysql时延指标latency，数值越小越好 + 对应sysbench输出中的: Latency (ms) -> avg: xxx + """ + result = PerfData( + name=f"{self.name}-latency", + value_type=ValueType.LIB, + key_item=KeyItem.avg, + unit="ms", + label=self.label, + ) + for line in self.outs.splitlines(): + if "avg:" in line: + avg = float(line.split(":")[1].strip()) + result.set_key_value(value=avg) + break + return result + class PerfLibMicro(TSTPerf): def __init__( diff --git a/testcase/sysbench/sysbench.py b/testcase/sysbench/sysbench.py index c6c73484..a9aa44fd 100644 --- a/testcase/sysbench/sysbench.py +++ b/testcase/sysbench/sysbench.py @@ -61,7 +61,11 @@ def _build_memory_opt(memory_block_size, memory_total_size, class PerfSysbench(TSTPerf): """sysbench 工具类 — 委托给 PerfSysBench - 支持调度类（threads）和内存类（memory）。 + 支持调度类（threads）、内存类（memory）和数据库类（mysql）。 + + 模式3（数据库类 - mysql）： + mysql_lua, mysql_threads, mysql_tables, mysql_table_size, mysql_time + 指标项包括吞吐量eps和时延latency """ def __init__( @@ -79,10 +83,32 @@ class PerfSysbench(TSTPerf): memory_access_mode: str = "", mm_threads: str = "", mm_time: str = "", + # 数据库类(mysql)参数 + mysql_lua: str = "", + mysql_threads: str = "", + mysql_tables: str = "", + mysql_table_size: str = "", + mysql_time: str = "60", + # 预热时长：仅bulk_insert等未定义options的lua脚本支持--warmup-time， + # 使用oltp_common的脚本不支持，传空则不带该参数 + mysql_warmup_time: str = "", ): super().__init__() - if benchmark_name: + if mysql_lua: + # 数据库类模式：基于lua脚本执行mysql性能测试 + self._impl = PerfSysBench( + name=tc_name, + testname="mysql", + label="L0:数据库", + mysql_lua=mysql_lua, + mysql_threads=mysql_threads, + mysql_tables=mysql_tables, + mysql_table_size=mysql_table_size, + mysql_time=mysql_time, + mysql_warmup_time=mysql_warmup_time, + ) + elif benchmark_name: # 内存类模式：从 CSV 参数动态拼接 general_opt = _build_memory_opt( memory_block_size, memory_total_size, diff --git a/testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_128.py b/testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_128.py new file mode 100755 index 00000000..cc8c4ece --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_128.py @@ -0,0 +1,62 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 035dd1415421906d + @用例名称: sysbench_mysql_bulk_insert_lua_threads_128 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=bulk_insert,threads=128 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="bulk_insert", + mysql_threads="128", + mysql_warmup_time="10", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=bulk_insert,threads=128 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_16.py b/testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_16.py new file mode 100755 index 00000000..af6a4ead --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_16.py @@ -0,0 +1,62 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: e7248bcc7725ac93 + @用例名称: sysbench_mysql_bulk_insert_lua_threads_16 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=bulk_insert,threads=16 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="bulk_insert", + mysql_threads="16", + mysql_warmup_time="10", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=bulk_insert,threads=16 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_4.py b/testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_4.py new file mode 100755 index 00000000..d0aef302 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_4.py @@ -0,0 +1,62 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 6cfefb39915ad426 + @用例名称: sysbench_mysql_bulk_insert_lua_threads_4 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=bulk_insert,threads=4 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="bulk_insert", + mysql_threads="4", + mysql_warmup_time="10", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=bulk_insert,threads=4 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_64.py b/testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_64.py new file mode 100755 index 00000000..70d3fb5b --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_bulk_insert_lua_threads_64.py @@ -0,0 +1,62 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 4441dd61d4981b2c + @用例名称: sysbench_mysql_bulk_insert_lua_threads_64 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=bulk_insert,threads=64 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="bulk_insert", + mysql_threads="64", + mysql_warmup_time="10", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=bulk_insert,threads=64 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_delete_threads_128_tables_300_size_20000.py b/testcase/sysbench/sysbench_mysql_oltp_delete_threads_128_tables_300_size_20000.py new file mode 100755 index 00000000..70abf8a2 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_delete_threads_128_tables_300_size_20000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: e4e2ca9ef826b3b8 + @用例名称: sysbench_mysql_oltp_delete_threads_128_tables_300_size_20000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_delete,threads=128,tables=300,table_size=20000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_delete", + mysql_threads="128", + mysql_tables="300", + mysql_table_size="20000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_delete,threads=128,tables=300,table_size=20000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_delete_threads_128_tables_500_size_50000.py b/testcase/sysbench/sysbench_mysql_oltp_delete_threads_128_tables_500_size_50000.py new file mode 100755 index 00000000..68e45442 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_delete_threads_128_tables_500_size_50000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 3246fc352cee647b + @用例名称: sysbench_mysql_oltp_delete_threads_128_tables_500_size_50000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_delete,threads=128,tables=500,table_size=50000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_delete", + mysql_threads="128", + mysql_tables="500", + mysql_table_size="50000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_delete,threads=128,tables=500,table_size=50000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_delete_threads_16_tables_100_size_5000.py b/testcase/sysbench/sysbench_mysql_oltp_delete_threads_16_tables_100_size_5000.py new file mode 100755 index 00000000..73739d95 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_delete_threads_16_tables_100_size_5000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 119b432ee645515d + @用例名称: sysbench_mysql_oltp_delete_threads_16_tables_100_size_5000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_delete,threads=16,tables=100,table_size=5000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_delete", + mysql_threads="16", + mysql_tables="100", + mysql_table_size="5000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_delete,threads=16,tables=100,table_size=5000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_delete_threads_4_tables_10_size_1000.py b/testcase/sysbench/sysbench_mysql_oltp_delete_threads_4_tables_10_size_1000.py new file mode 100755 index 00000000..3ef566db --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_delete_threads_4_tables_10_size_1000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 020a2c0c10db685b + @用例名称: sysbench_mysql_oltp_delete_threads_4_tables_10_size_1000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_delete,threads=4,tables=10,table_size=1000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_delete", + mysql_threads="4", + mysql_tables="10", + mysql_table_size="1000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_delete,threads=4,tables=10,table_size=1000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_delete_threads_64_tables_200_size_10000.py b/testcase/sysbench/sysbench_mysql_oltp_delete_threads_64_tables_200_size_10000.py new file mode 100755 index 00000000..1b83628a --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_delete_threads_64_tables_200_size_10000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: ac28a69bec9e9ff8 + @用例名称: sysbench_mysql_oltp_delete_threads_64_tables_200_size_10000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_delete,threads=64,tables=200,table_size=10000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_delete", + mysql_threads="64", + mysql_tables="200", + mysql_table_size="10000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_delete,threads=64,tables=200,table_size=10000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_insert_threads_128_tables_300_size_20000.py b/testcase/sysbench/sysbench_mysql_oltp_insert_threads_128_tables_300_size_20000.py new file mode 100755 index 00000000..4fd488dc --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_insert_threads_128_tables_300_size_20000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 4ec343e8fd7d9699 + @用例名称: sysbench_mysql_oltp_insert_threads_128_tables_300_size_20000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_insert,threads=128,tables=300,table_size=20000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_insert", + mysql_threads="128", + mysql_tables="300", + mysql_table_size="20000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_insert,threads=128,tables=300,table_size=20000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_insert_threads_128_tables_500_size_50000.py b/testcase/sysbench/sysbench_mysql_oltp_insert_threads_128_tables_500_size_50000.py new file mode 100755 index 00000000..37f6d8da --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_insert_threads_128_tables_500_size_50000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: b32a94c0bde436f0 + @用例名称: sysbench_mysql_oltp_insert_threads_128_tables_500_size_50000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_insert,threads=128,tables=500,table_size=50000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_insert", + mysql_threads="128", + mysql_tables="500", + mysql_table_size="50000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_insert,threads=128,tables=500,table_size=50000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_insert_threads_16_tables_100_size_5000.py b/testcase/sysbench/sysbench_mysql_oltp_insert_threads_16_tables_100_size_5000.py new file mode 100755 index 00000000..8a3ac929 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_insert_threads_16_tables_100_size_5000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 29e941aaa0ad3b10 + @用例名称: sysbench_mysql_oltp_insert_threads_16_tables_100_size_5000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_insert,threads=16,tables=100,table_size=5000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_insert", + mysql_threads="16", + mysql_tables="100", + mysql_table_size="5000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_insert,threads=16,tables=100,table_size=5000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_insert_threads_4_tables_10_size_1000.py b/testcase/sysbench/sysbench_mysql_oltp_insert_threads_4_tables_10_size_1000.py new file mode 100755 index 00000000..149851f3 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_insert_threads_4_tables_10_size_1000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: d405eaf1a27c5be4 + @用例名称: sysbench_mysql_oltp_insert_threads_4_tables_10_size_1000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_insert,threads=4,tables=10,table_size=1000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_insert", + mysql_threads="4", + mysql_tables="10", + mysql_table_size="1000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_insert,threads=4,tables=10,table_size=1000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_insert_threads_64_tables_200_size_10000.py b/testcase/sysbench/sysbench_mysql_oltp_insert_threads_64_tables_200_size_10000.py new file mode 100755 index 00000000..150fa037 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_insert_threads_64_tables_200_size_10000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 836faff3605d1ec4 + @用例名称: sysbench_mysql_oltp_insert_threads_64_tables_200_size_10000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_insert,threads=64,tables=200,table_size=10000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_insert", + mysql_threads="64", + mysql_tables="200", + mysql_table_size="10000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_insert,threads=64,tables=200,table_size=10000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_128_tables_300_size_20000.py b/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_128_tables_300_size_20000.py new file mode 100755 index 00000000..8e1dd6d1 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_128_tables_300_size_20000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 8989f21bc481a233 + @用例名称: sysbench_mysql_oltp_point_select_threads_128_tables_300_size_20000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_point_select,threads=128,tables=300,table_size=20000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_point_select", + mysql_threads="128", + mysql_tables="300", + mysql_table_size="20000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_point_select,threads=128,tables=300,table_size=20000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_128_tables_500_size_50000.py b/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_128_tables_500_size_50000.py new file mode 100755 index 00000000..405d93c9 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_128_tables_500_size_50000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 28e0fb25df6ef3a9 + @用例名称: sysbench_mysql_oltp_point_select_threads_128_tables_500_size_50000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_point_select,threads=128,tables=500,table_size=50000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_point_select", + mysql_threads="128", + mysql_tables="500", + mysql_table_size="50000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_point_select,threads=128,tables=500,table_size=50000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_16_tables_100_size_5000.py b/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_16_tables_100_size_5000.py new file mode 100755 index 00000000..eecc3215 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_16_tables_100_size_5000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: d908d18422de4432 + @用例名称: sysbench_mysql_oltp_point_select_threads_16_tables_100_size_5000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_point_select,threads=16,tables=100,table_size=5000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_point_select", + mysql_threads="16", + mysql_tables="100", + mysql_table_size="5000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_point_select,threads=16,tables=100,table_size=5000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_4_tables_10_size_1000.py b/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_4_tables_10_size_1000.py new file mode 100755 index 00000000..4afa1f28 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_4_tables_10_size_1000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: dc158b7ecbf6341f + @用例名称: sysbench_mysql_oltp_point_select_threads_4_tables_10_size_1000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_point_select,threads=4,tables=10,table_size=1000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_point_select", + mysql_threads="4", + mysql_tables="10", + mysql_table_size="1000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_point_select,threads=4,tables=10,table_size=1000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_64_tables_200_size_10000.py b/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_64_tables_200_size_10000.py new file mode 100755 index 00000000..3b9e0408 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_point_select_threads_64_tables_200_size_10000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 920328ccc7ad4061 + @用例名称: sysbench_mysql_oltp_point_select_threads_64_tables_200_size_10000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_point_select,threads=64,tables=200,table_size=10000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_point_select", + mysql_threads="64", + mysql_tables="200", + mysql_table_size="10000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_point_select,threads=64,tables=200,table_size=10000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_128_tables_120_size_32000.py b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_128_tables_120_size_32000.py new file mode 100755 index 00000000..bb25c6bf --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_128_tables_120_size_32000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 30d2d776594151f5 + @用例名称: sysbench_mysql_oltp_read_only_threads_128_tables_120_size_32000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_only,threads=128,tables=120,table_size=32000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_only", + mysql_threads="128", + mysql_tables="120", + mysql_table_size="32000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_only,threads=128,tables=120,table_size=32000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_128_tables_200_size_10000.py b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_128_tables_200_size_10000.py new file mode 100755 index 00000000..4d4a5d04 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_128_tables_200_size_10000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: aa7f76c71fd7903b + @用例名称: sysbench_mysql_oltp_read_only_threads_128_tables_200_size_10000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_only,threads=128,tables=200,table_size=10000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_only", + mysql_threads="128", + mysql_tables="200", + mysql_table_size="10000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_only,threads=128,tables=200,table_size=10000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_16_tables_100_size_5000.py b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_16_tables_100_size_5000.py new file mode 100755 index 00000000..2f96fbea --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_16_tables_100_size_5000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 9119da062ac8c557 + @用例名称: sysbench_mysql_oltp_read_only_threads_16_tables_100_size_5000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_only,threads=16,tables=100,table_size=5000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_only", + mysql_threads="16", + mysql_tables="100", + mysql_table_size="5000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_only,threads=16,tables=100,table_size=5000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_256_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_256_tables_250_size_25000_product.py new file mode 100755 index 00000000..299e1686 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_256_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 90535f0076dff6b6 + @用例名称: sysbench_mysql_oltp_read_only_threads_256_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_only,threads=256,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_only", + mysql_threads="256", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_only,threads=256,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_32_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_32_tables_250_size_25000_product.py new file mode 100755 index 00000000..1b6ddc01 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_32_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 8b4fa234d83b3978 + @用例名称: sysbench_mysql_oltp_read_only_threads_32_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_only,threads=32,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_only", + mysql_threads="32", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_only,threads=32,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_4_tables_10_size_1000.py b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_4_tables_10_size_1000.py new file mode 100755 index 00000000..5ef162fa --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_4_tables_10_size_1000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 563e850f34cc569b + @用例名称: sysbench_mysql_oltp_read_only_threads_4_tables_10_size_1000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_only,threads=4,tables=10,table_size=1000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_only", + mysql_threads="4", + mysql_tables="10", + mysql_table_size="1000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_only,threads=4,tables=10,table_size=1000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_512_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_512_tables_250_size_25000_product.py new file mode 100755 index 00000000..6fe33858 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_512_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: d39ae9e825cebaf7 + @用例名称: sysbench_mysql_oltp_read_only_threads_512_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_only,threads=512,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_only", + mysql_threads="512", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_only,threads=512,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_64_tables_200_size_10000.py b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_64_tables_200_size_10000.py new file mode 100755 index 00000000..a2aa76dc --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_64_tables_200_size_10000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: b15e56fb9c2de2bf + @用例名称: sysbench_mysql_oltp_read_only_threads_64_tables_200_size_10000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_only,threads=64,tables=200,table_size=10000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_only", + mysql_threads="64", + mysql_tables="200", + mysql_table_size="10000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_only,threads=64,tables=200,table_size=10000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_8_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_8_tables_250_size_25000_product.py new file mode 100755 index 00000000..e7786360 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_only_threads_8_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 98d11d03a2eeefe2 + @用例名称: sysbench_mysql_oltp_read_only_threads_8_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_only,threads=8,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_only", + mysql_threads="8", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_only,threads=8,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_128_tables_120_size_32000.py b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_128_tables_120_size_32000.py new file mode 100755 index 00000000..36638918 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_128_tables_120_size_32000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 88231fe91fa9a7e6 + @用例名称: sysbench_mysql_oltp_read_write_threads_128_tables_120_size_32000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_write,threads=128,tables=120,table_size=32000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_write", + mysql_threads="128", + mysql_tables="120", + mysql_table_size="32000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_write,threads=128,tables=120,table_size=32000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_128_tables_200_size_10000.py b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_128_tables_200_size_10000.py new file mode 100755 index 00000000..8f058b8d --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_128_tables_200_size_10000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: fd5844ba06309cf0 + @用例名称: sysbench_mysql_oltp_read_write_threads_128_tables_200_size_10000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_write,threads=128,tables=200,table_size=10000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_write", + mysql_threads="128", + mysql_tables="200", + mysql_table_size="10000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_write,threads=128,tables=200,table_size=10000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_16_tables_100_size_5000.py b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_16_tables_100_size_5000.py new file mode 100755 index 00000000..e3dd4bde --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_16_tables_100_size_5000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 81d7540344ed3957 + @用例名称: sysbench_mysql_oltp_read_write_threads_16_tables_100_size_5000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_write,threads=16,tables=100,table_size=5000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_write", + mysql_threads="16", + mysql_tables="100", + mysql_table_size="5000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_write,threads=16,tables=100,table_size=5000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_256_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_256_tables_250_size_25000_product.py new file mode 100755 index 00000000..8d9b1690 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_256_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 420ebbcacdda0e2c + @用例名称: sysbench_mysql_oltp_read_write_threads_256_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_write,threads=256,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_write", + mysql_threads="256", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_write,threads=256,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_32_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_32_tables_250_size_25000_product.py new file mode 100755 index 00000000..825c1ef8 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_32_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: edef0681a692a03d + @用例名称: sysbench_mysql_oltp_read_write_threads_32_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_write,threads=32,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_write", + mysql_threads="32", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_write,threads=32,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_4_tables_10_size_1000.py b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_4_tables_10_size_1000.py new file mode 100755 index 00000000..fd053768 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_4_tables_10_size_1000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: e3845651f56eb287 + @用例名称: sysbench_mysql_oltp_read_write_threads_4_tables_10_size_1000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_write,threads=4,tables=10,table_size=1000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_write", + mysql_threads="4", + mysql_tables="10", + mysql_table_size="1000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_write,threads=4,tables=10,table_size=1000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_512_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_512_tables_250_size_25000_product.py new file mode 100755 index 00000000..0f011c78 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_512_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 6f386275cd7cd6ee + @用例名称: sysbench_mysql_oltp_read_write_threads_512_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_write,threads=512,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_write", + mysql_threads="512", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_write,threads=512,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_64_tables_200_size_10000.py b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_64_tables_200_size_10000.py new file mode 100755 index 00000000..903f91d0 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_64_tables_200_size_10000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 64cf16c8774c2ce9 + @用例名称: sysbench_mysql_oltp_read_write_threads_64_tables_200_size_10000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_write,threads=64,tables=200,table_size=10000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_write", + mysql_threads="64", + mysql_tables="200", + mysql_table_size="10000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_write,threads=64,tables=200,table_size=10000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_8_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_8_tables_250_size_25000_product.py new file mode 100755 index 00000000..50afc8da --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_read_write_threads_8_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: acfeda1a163850c5 + @用例名称: sysbench_mysql_oltp_read_write_threads_8_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_write,threads=8,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_write", + mysql_threads="8", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_write,threads=8,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_128_tables_120_size_32000.py b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_128_tables_120_size_32000.py new file mode 100755 index 00000000..8169a3bd --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_128_tables_120_size_32000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: f441b8c88eaa5f2d + @用例名称: sysbench_mysql_oltp_update_index_threads_128_tables_120_size_32000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_index,threads=128,tables=120,table_size=32000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_index", + mysql_threads="128", + mysql_tables="120", + mysql_table_size="32000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_index,threads=128,tables=120,table_size=32000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_128_tables_200_size_10000.py b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_128_tables_200_size_10000.py new file mode 100755 index 00000000..9e910caa --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_128_tables_200_size_10000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 5d4d807f8bd4b4f8 + @用例名称: sysbench_mysql_oltp_update_index_threads_128_tables_200_size_10000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_index,threads=128,tables=200,table_size=12000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_index", + mysql_threads="128", + mysql_tables="200", + mysql_table_size="12000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_index,threads=128,tables=200,table_size=12000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_16_tables_100_size_5000.py b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_16_tables_100_size_5000.py new file mode 100755 index 00000000..1e39b115 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_16_tables_100_size_5000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 8e17c862083b73dd + @用例名称: sysbench_mysql_oltp_update_index_threads_16_tables_100_size_5000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_index,threads=16,tables=100,table_size=5000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_index", + mysql_threads="16", + mysql_tables="100", + mysql_table_size="5000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_index,threads=16,tables=100,table_size=5000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_256_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_256_tables_250_size_25000_product.py new file mode 100755 index 00000000..5378361c --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_256_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: a07b34baf4c0863c + @用例名称: sysbench_mysql_oltp_update_index_threads_256_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_index,threads=256,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_index", + mysql_threads="256", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_index,threads=256,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_32_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_32_tables_250_size_25000_product.py new file mode 100755 index 00000000..ab7ec966 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_32_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 9210d4a93caf93fb + @用例名称: sysbench_mysql_oltp_update_index_threads_32_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_index,threads=32,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_index", + mysql_threads="32", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_index,threads=32,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_4_tables_10_size_1000.py b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_4_tables_10_size_1000.py new file mode 100755 index 00000000..8b36ebe0 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_4_tables_10_size_1000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 3ab5353ed7da22a4 + @用例名称: sysbench_mysql_oltp_update_index_threads_4_tables_10_size_1000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_index,threads=4,tables=10,table_size=1000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_index", + mysql_threads="4", + mysql_tables="10", + mysql_table_size="1000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_index,threads=4,tables=10,table_size=1000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_512_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_512_tables_250_size_25000_product.py new file mode 100755 index 00000000..17d1b897 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_512_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: bf5c785a6290f3e2 + @用例名称: sysbench_mysql_oltp_update_index_threads_512_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_index,threads=512,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_index", + mysql_threads="512", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_index,threads=512,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_64_tables_200_size_10000.py b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_64_tables_200_size_10000.py new file mode 100755 index 00000000..11b8fdb8 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_64_tables_200_size_10000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: b77bf73a0b22d463 + @用例名称: sysbench_mysql_oltp_update_index_threads_64_tables_200_size_10000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_index,threads=64,tables=200,table_size=10000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_index", + mysql_threads="64", + mysql_tables="200", + mysql_table_size="10000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_index,threads=64,tables=200,table_size=10000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_8_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_8_tables_250_size_25000_product.py new file mode 100755 index 00000000..7d6ae930 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_index_threads_8_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 125476b73f7f5149 + @用例名称: sysbench_mysql_oltp_update_index_threads_8_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_index,threads=8,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_index", + mysql_threads="8", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_index,threads=8,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_128_tables_120_size_32000.py b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_128_tables_120_size_32000.py new file mode 100755 index 00000000..71b38ebc --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_128_tables_120_size_32000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: a836246d831e7550 + @用例名称: sysbench_mysql_oltp_update_non_index_threads_128_tables_120_size_32000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_non_index,threads=128,tables=120,table_size=32000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_non_index", + mysql_threads="128", + mysql_tables="120", + mysql_table_size="32000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_non_index,threads=128,tables=120,table_size=32000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_128_tables_200_size_10000.py b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_128_tables_200_size_10000.py new file mode 100755 index 00000000..7a971c03 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_128_tables_200_size_10000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 8517a217b3cbc0b9 + @用例名称: sysbench_mysql_oltp_update_non_index_threads_128_tables_200_size_10000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_non_index,threads=128,tables=200,table_size=12000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_non_index", + mysql_threads="128", + mysql_tables="200", + mysql_table_size="12000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_non_index,threads=128,tables=200,table_size=12000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_16_tables_100_size_5000.py b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_16_tables_100_size_5000.py new file mode 100755 index 00000000..8e133c74 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_16_tables_100_size_5000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 0a1981703f14399f + @用例名称: sysbench_mysql_oltp_update_non_index_threads_16_tables_100_size_5000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_non_index,threads=16,tables=100,table_size=5000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_non_index", + mysql_threads="16", + mysql_tables="100", + mysql_table_size="5000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_non_index,threads=16,tables=100,table_size=5000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_256_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_256_tables_250_size_25000_product.py new file mode 100755 index 00000000..98a734b4 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_256_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 73b78c19601bdcf5 + @用例名称: sysbench_mysql_oltp_update_non_index_threads_256_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_non_index,threads=256,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_non_index", + mysql_threads="256", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_non_index,threads=256,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_32_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_32_tables_250_size_25000_product.py new file mode 100755 index 00000000..e7250862 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_32_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: a81d47aa967a5783 + @用例名称: sysbench_mysql_oltp_update_non_index_threads_32_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_non_index,threads=32,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_non_index", + mysql_threads="32", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_non_index,threads=32,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_4_tables_10_size_1000.py b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_4_tables_10_size_1000.py new file mode 100755 index 00000000..9aa75289 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_4_tables_10_size_1000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 88a7363de4c8561d + @用例名称: sysbench_mysql_oltp_update_non_index_threads_4_tables_10_size_1000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_non_index,threads=4,tables=10,table_size=1000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_non_index", + mysql_threads="4", + mysql_tables="10", + mysql_table_size="1000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_non_index,threads=4,tables=10,table_size=1000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_512_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_512_tables_250_size_25000_product.py new file mode 100755 index 00000000..318226bc --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_512_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 5e9cbd04370efc8b + @用例名称: sysbench_mysql_oltp_update_non_index_threads_512_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_non_index,threads=512,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_non_index", + mysql_threads="512", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_non_index,threads=512,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_64_tables_200_size_10000.py b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_64_tables_200_size_10000.py new file mode 100755 index 00000000..abe43114 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_64_tables_200_size_10000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 8e202ccf3993f08c + @用例名称: sysbench_mysql_oltp_update_non_index_threads_64_tables_200_size_10000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_non_index,threads=64,tables=200,table_size=10000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_non_index", + mysql_threads="64", + mysql_tables="200", + mysql_table_size="10000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_non_index,threads=64,tables=200,table_size=10000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_8_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_8_tables_250_size_25000_product.py new file mode 100755 index 00000000..e6f6767a --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_update_non_index_threads_8_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: e435f786549f0653 + @用例名称: sysbench_mysql_oltp_update_non_index_threads_8_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_update_non_index,threads=8,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_update_non_index", + mysql_threads="8", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_update_non_index,threads=8,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_128_tables_120_size_32000.py b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_128_tables_120_size_32000.py new file mode 100755 index 00000000..dd899944 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_128_tables_120_size_32000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: c2300376e45fd972 + @用例名称: sysbench_mysql_oltp_write_only_threads_128_tables_120_size_32000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_write_only,threads=128,tables=120,table_size=32000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_write_only", + mysql_threads="128", + mysql_tables="120", + mysql_table_size="32000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_write_only,threads=128,tables=120,table_size=32000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_128_tables_200_size_10000.py b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_128_tables_200_size_10000.py new file mode 100755 index 00000000..1a135af5 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_128_tables_200_size_10000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: eda628d32db9288f + @用例名称: sysbench_mysql_oltp_write_only_threads_128_tables_200_size_10000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_write_only,threads=128,tables=200,table_size=10000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_write_only", + mysql_threads="128", + mysql_tables="200", + mysql_table_size="10000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_write_only,threads=128,tables=200,table_size=10000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_16_tables_100_size_5000.py b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_16_tables_100_size_5000.py new file mode 100755 index 00000000..3cef15c3 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_16_tables_100_size_5000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 30da1009eed4beac + @用例名称: sysbench_mysql_oltp_write_only_threads_16_tables_100_size_5000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_write_only,threads=16,tables=100,table_size=5000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_write_only", + mysql_threads="16", + mysql_tables="100", + mysql_table_size="5000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_write_only,threads=16,tables=100,table_size=5000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_256_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_256_tables_250_size_25000_product.py new file mode 100755 index 00000000..c4d64f6b --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_256_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 6c35328ab21d3d46 + @用例名称: sysbench_mysql_oltp_write_only_threads_256_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_write_only,threads=256,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_write_only", + mysql_threads="256", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_write_only,threads=256,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_32_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_32_tables_250_size_25000_product.py new file mode 100755 index 00000000..9068a462 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_32_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 56d2385129b251b8 + @用例名称: sysbench_mysql_oltp_write_only_threads_32_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_write_only,threads=32,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_write_only", + mysql_threads="32", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_write_only,threads=32,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_4_tables_10_size_1000.py b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_4_tables_10_size_1000.py new file mode 100755 index 00000000..a67f0a75 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_4_tables_10_size_1000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 25f021f2ab886f23 + @用例名称: sysbench_mysql_oltp_write_only_threads_4_tables_10_size_1000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_write_only,threads=4,tables=10,table_size=1000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_write_only", + mysql_threads="4", + mysql_tables="10", + mysql_table_size="1000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_write_only,threads=4,tables=10,table_size=1000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_512_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_512_tables_250_size_25000_product.py new file mode 100755 index 00000000..1d1ded52 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_512_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: a0b4bba78dafbbf0 + @用例名称: sysbench_mysql_oltp_write_only_threads_512_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_read_only,threads=512,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_read_only", + mysql_threads="512", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_read_only,threads=512,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_64_tables_200_size_10000.py b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_64_tables_200_size_10000.py new file mode 100755 index 00000000..cdcdaa1b --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_64_tables_200_size_10000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 15a7e924686b67a2 + @用例名称: sysbench_mysql_oltp_write_only_threads_64_tables_200_size_10000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_write_only,threads=64,tables=200,table_size=10000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_write_only", + mysql_threads="64", + mysql_tables="200", + mysql_table_size="10000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_write_only,threads=64,tables=200,table_size=10000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_8_tables_250_size_25000_product.py b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_8_tables_250_size_25000_product.py new file mode 100755 index 00000000..cf0e25f4 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_oltp_write_only_threads_8_tables_250_size_25000_product.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 33f503dc2bdcddf6 + @用例名称: sysbench_mysql_oltp_write_only_threads_8_tables_250_size_25000_product + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=oltp_write_only,threads=8,tables=250,table_size=25000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="oltp_write_only", + mysql_threads="8", + mysql_tables="250", + mysql_table_size="25000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=oltp_write_only,threads=8,tables=250,table_size=25000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_select_random_points_threads_128_tables_1_size_100000.py b/testcase/sysbench/sysbench_mysql_select_random_points_threads_128_tables_1_size_100000.py new file mode 100755 index 00000000..68e4f993 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_select_random_points_threads_128_tables_1_size_100000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 95526cfc46295c48 + @用例名称: sysbench_mysql_select_random_points_threads_128_tables_1_size_100000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=select_random_points,threads=128,tables=1,table_size=100000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="select_random_points", + mysql_threads="128", + mysql_tables="1", + mysql_table_size="100000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=select_random_points,threads=128,tables=1,table_size=100000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_select_random_points_threads_16_tables_1_size_5000.py b/testcase/sysbench/sysbench_mysql_select_random_points_threads_16_tables_1_size_5000.py new file mode 100755 index 00000000..2df6f752 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_select_random_points_threads_16_tables_1_size_5000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 419e780c9c08f22b + @用例名称: sysbench_mysql_select_random_points_threads_16_tables_1_size_5000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=select_random_points,threads=16,tables=1,table_size=5000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="select_random_points", + mysql_threads="16", + mysql_tables="1", + mysql_table_size="5000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=select_random_points,threads=16,tables=1,table_size=5000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_select_random_points_threads_256_tables_1_size_100000.py b/testcase/sysbench/sysbench_mysql_select_random_points_threads_256_tables_1_size_100000.py new file mode 100755 index 00000000..f4ee2034 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_select_random_points_threads_256_tables_1_size_100000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: b2977cae1fee9e11 + @用例名称: sysbench_mysql_select_random_points_threads_256_tables_1_size_100000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=select_random_points,threads=256,tables=1,table_size=100000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="select_random_points", + mysql_threads="256", + mysql_tables="1", + mysql_table_size="100000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=select_random_points,threads=256,tables=1,table_size=100000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_select_random_points_threads_4_tables_1_size_1000.py b/testcase/sysbench/sysbench_mysql_select_random_points_threads_4_tables_1_size_1000.py new file mode 100755 index 00000000..99161d8f --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_select_random_points_threads_4_tables_1_size_1000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: c7e419164734b3ce + @用例名称: sysbench_mysql_select_random_points_threads_4_tables_1_size_1000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=select_random_points,threads=4,tables=1,table_size=1000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="select_random_points", + mysql_threads="4", + mysql_tables="1", + mysql_table_size="1000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=select_random_points,threads=4,tables=1,table_size=1000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_select_random_points_threads_512_tables_1_size_200000.py b/testcase/sysbench/sysbench_mysql_select_random_points_threads_512_tables_1_size_200000.py new file mode 100755 index 00000000..923bae3d --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_select_random_points_threads_512_tables_1_size_200000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 79ad133a047867cc + @用例名称: sysbench_mysql_select_random_points_threads_512_tables_1_size_200000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=select_random_points,threads=512,tables=1,table_size=200000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="select_random_points", + mysql_threads="512", + mysql_tables="1", + mysql_table_size="200000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=select_random_points,threads=512,tables=1,table_size=200000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_select_random_points_threads_64_tables_1_size_50000.py b/testcase/sysbench/sysbench_mysql_select_random_points_threads_64_tables_1_size_50000.py new file mode 100755 index 00000000..ccf8b0cd --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_select_random_points_threads_64_tables_1_size_50000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: fd1f1b3e19bce729 + @用例名称: sysbench_mysql_select_random_points_threads_64_tables_1_size_50000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=select_random_points,threads=64,tables=1,table_size=52000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="select_random_points", + mysql_threads="64", + mysql_tables="1", + mysql_table_size="52000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=select_random_points,threads=64,tables=1,table_size=52000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_128_tables_1_size_100000.py b/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_128_tables_1_size_100000.py new file mode 100755 index 00000000..9e2c82af --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_128_tables_1_size_100000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: a020f19bdfb85e7e + @用例名称: sysbench_mysql_select_random_ranges_threads_128_tables_1_size_100000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=select_random_ranges,threads=128,tables=1,table_size=100000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="select_random_ranges", + mysql_threads="128", + mysql_tables="1", + mysql_table_size="100000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=select_random_ranges,threads=128,tables=1,table_size=100000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_16_tables_1_size_5000.py b/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_16_tables_1_size_5000.py new file mode 100755 index 00000000..0348ff3f --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_16_tables_1_size_5000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 219594dc9a57bf60 + @用例名称: sysbench_mysql_select_random_ranges_threads_16_tables_1_size_5000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=select_random_ranges,threads=16,tables=1,table_size=5000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="select_random_ranges", + mysql_threads="16", + mysql_tables="1", + mysql_table_size="5000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=select_random_ranges,threads=16,tables=1,table_size=5000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_256_tables_1_size_100000.py b/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_256_tables_1_size_100000.py new file mode 100755 index 00000000..011eb25b --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_256_tables_1_size_100000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: a3ab7fac9f403ad4 + @用例名称: sysbench_mysql_select_random_ranges_threads_256_tables_1_size_100000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=select_random_ranges,threads=256,tables=1,table_size=100000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="select_random_ranges", + mysql_threads="256", + mysql_tables="1", + mysql_table_size="100000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=select_random_ranges,threads=256,tables=1,table_size=100000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_4_tables_1_size_1000.py b/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_4_tables_1_size_1000.py new file mode 100755 index 00000000..6bd0a8b2 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_4_tables_1_size_1000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: db8fe51aa33587bf + @用例名称: sysbench_mysql_select_random_ranges_threads_4_tables_1_size_1000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=select_random_ranges,threads=4,tables=1,table_size=1000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="select_random_ranges", + mysql_threads="4", + mysql_tables="1", + mysql_table_size="1000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=select_random_ranges,threads=4,tables=1,table_size=1000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_512_tables_1_size_200000.py b/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_512_tables_1_size_200000.py new file mode 100755 index 00000000..128f2d40 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_512_tables_1_size_200000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: 9989447c70c11171 + @用例名称: sysbench_mysql_select_random_ranges_threads_512_tables_1_size_200000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=select_random_ranges,threads=512,tables=1,table_size=200000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="select_random_ranges", + mysql_threads="512", + mysql_tables="1", + mysql_table_size="200000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=select_random_ranges,threads=512,tables=1,table_size=200000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_64_tables_1_size_50000.py b/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_64_tables_1_size_50000.py new file mode 100755 index 00000000..f48007f8 --- /dev/null +++ b/testcase/sysbench/sysbench_mysql_select_random_ranges_threads_64_tables_1_size_50000.py @@ -0,0 +1,63 @@ +#!/usr/bin/env python3 +# coding: utf-8 +# 注意：此文件参考parse-csv2case.py自动生成格式编写，由tst_perf移植的mysql用例 + +import os.path +import sys + + +_suite_top_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "..") +while _suite_top_dir != "/": + if os.path.isfile(os.path.join(_suite_top_dir, "tsuite")): + break + _suite_top_dir = os.path.dirname(_suite_top_dir) +sys.path.append(_suite_top_dir) +from lib.ts_common import MyTestCase # noqa: E402 +from testcase.sysbench.sysbench import PerfSysbench # noqa: E402 + + +class PythonTestCase(MyTestCase): + """ + @用例ID: e0af6568d9bafc5d + @用例名称: sysbench_mysql_select_random_ranges_threads_64_tables_1_size_50000 + @用例级别: 3 + @用例标签: + @扩展属性: + @用例类型: 性能测试 + @自动化: 1 + @超时时间: 0 + @用例描述: 使用sysbench测试mysql性能，参数：test=select_random_ranges,threads=64,tables=1,table_size=52000 + """ + + def tc_setup(self, *args): + self.msg("this is tc_setup") + # @预置条件: 系统支持性能测试工具sysbench运行 + # @预置条件: 系统参数配置正确，符合性能测试运行要求 + # @预置条件: mysql服务已启动，可通过127.0.0.1:3306由root用户访问sbtest库 + self.perf_tool = PerfSysbench( + tc_name=self.tc_name, + mysql_lua="select_random_ranges", + mysql_threads="64", + mysql_tables="1", + mysql_table_size="52000", + ) + + def do_test(self, *args): + self.msg("this is do_test") + + # @测试步骤: 使用sysbench工具测试mysql性能，参数：test=select_random_ranges,threads=64,tables=1,table_size=52000 + # @预期结果: 测试正常,性能数据采集正常(吞吐量eps、时延latency) + self.perf_tool.run( + warmup=1, + run_loop=5, + result_select_percent=80, + ) + self.perf_tool.report(testcase=self) + self.assert_true(len(self.perf_tool.results) > 0) + + def tc_teardown(self, *args): + self.msg("this is tc_teardown") + + +if __name__ == "__main__": + PythonTestCase().tst_main(sys.argv) diff --git a/tools/sysbench/tst-build.sh b/tools/sysbench/tst-build.sh index f683ec1d..37ed575e 100755 --- a/tools/sysbench/tst-build.sh +++ b/tools/sysbench/tst-build.sh @@ -8,23 +8,172 @@ # 如果不指定参数g_install_dir，那么默认安装在当前目录.install路径下 # 编译失败则将.install目录重命名为.install.fail # .install目录存在表示工具已经编译过，不再重复编译 +# mysql用例适配参考 tperf-os-benchmark/tools/sysbench/tst-build.sh + +# 设置默认语言环境，避免某些机器中缺少时区/locale设置导致mysql启动失败 +yum install -y glibc-langpack-en nscd 2>/dev/null +localectl set-locale LANG=en_US.UTF-8 2>/dev/null g_tool_dir="$(dirname "$(realpath "$0")")" g_install_dir="$1" +# tperf顶层目录(tools/sysbench的上两级) +g_tperf_top_dir="$(realpath "${g_tool_dir}/../..")" + +# mysql数据目录，挂载独立块设备存放测试数据，避免根目录空间不足 +g_mysql_datadir="/test/mysql.testdir" +# 实际使用的数据库(mysql或mariadb)，由install_db探测后赋值 +g_mysql_db="" # TODO: 编译依赖包列表 build_dep_pkg_list=" libtool +automake +make +pkgconfig +libaio-devel +openssl-devel " +# 安装数据库：优先mysql，其次mariadb +install_db() { + if yum list mysql 2>/dev/null; then + # 使用mysql，先移除可能冲突的mariadb + if rpm -qa | grep -q mariadb; then + rpm -qa | grep mariadb | xargs rpm -e --nodeps + fi + yum -y install mysql-devel mysql-server mysql || return 1 + g_mysql_db="mysql" + elif yum list mariadb 2>/dev/null; then + yum -y install mariadb mariadb-server mariadb-devel || return 1 + g_mysql_db="mariadb" + else + echo "no mysql or mariadb found" + return 1 + fi + echo "g_mysql_db=$g_mysql_db" + return 0 +} + +# 数据库服务名 +db_service() { + if [ "$g_mysql_db" = "mariadb" ]; then + echo "mariadb" + else + echo "mysqld" + fi +} + +# 获取用于存放mysql测试数据的块设备 +# 优先取运行时环境变量TPERF_ARG_BLOCK_FMT(框架从configs/*.ini注入)， +# 若为空则回退解析configs/demo.ini中的TPERF_ARG_BLOCK_FMT +get_mysql_block_dev() { + if [ -n "$TPERF_ARG_BLOCK_FMT" ]; then + echo "$TPERF_ARG_BLOCK_FMT" + return 0 + fi + local conf="${g_tperf_top_dir}/configs/demo.ini" + [ -f "$conf" ] || return 0 + grep -E "^[[:space:]]*TPERF_ARG_BLOCK_FMT[[:space:]]*[:=]" "$conf" \ + | head -1 \ + | sed -E 's/^[^:=]*[:=][[:space:]]*//' \ + | tr -d '[:space:]' +} + +# 准备mysql数据盘：格式化TPERF_ARG_BLOCK_FMT指定的块设备并挂载到mysql数据目录， +# 使所有mysql测试数据落在该独立设备上，避免根目录空间不足导致prepare大表时 +# 报错"The table 'xxx' is full" +setup_mysql_datadir() { + local dev + dev="$(get_mysql_block_dev)" + if [ -z "$dev" ]; then + echo "WARNING: TPERF_ARG_BLOCK_FMT未配置，mysql数据目录$g_mysql_datadir使用当前文件系统" + umount "$g_mysql_datadir" 2>/dev/null + rm -rf "$g_mysql_datadir" + mkdir -p "$g_mysql_datadir" + return 0 + fi + if [ ! -b "$dev" ]; then + echo "ERROR: 块设备 $dev 不存在或不是块设备" + return 1 + fi + echo "使用块设备 $dev 作为mysql数据目录 $g_mysql_datadir" + # 先卸载设备及挂载点(可能被上一次测试占用) + umount "$dev" 2>/dev/null + umount "$g_mysql_datadir" 2>/dev/null + # 格式化为ext4 + mkfs.ext4 -F "$dev" || return 1 + # 挂载到mysql数据目录 + mkdir -p "$g_mysql_datadir" + mount "$dev" "$g_mysql_datadir" || return 1 + # 清理lost+found，避免mysql初始化时认为datadir非空而跳过初始化 + rm -rf "${g_mysql_datadir:?}"/* 2>/dev/null + return 0 +} + +# 初始化mysql服务，供sysbench mysql用例使用 +# 用例统一使用 127.0.0.1:3306 root用户(空密码) 访问sbtest库 +setup_mysql() { + echo "setup mysql for sysbench mysql testcase" + local svc + svc="$(db_service)" + + # 停止服务后，准备干净的数据目录(挂载到独立块设备) + systemctl stop "$svc" 2>/dev/null + setup_mysql_datadir || return 1 + chown -R mysql:mysql "$g_mysql_datadir" + # SELinux enforcing环境下，自定义datadir需要正确的安全上下文，否则mysqld无法启动 + chcon -R -t mysqld_db_t "$g_mysql_datadir" 2>/dev/null || true + + # 备份原有配置文件，写入基准测试所需配置 + local conf_file=/etc/my.cnf + if [ -f "$conf_file" ]; then + mv -v "$conf_file" "${conf_file}.$$.tperf.save" + fi + cat >"$conf_file" </dev/null 2>&1; then + break + fi + sleep 1 + done + + # 创建sysbench默认测试库sbtest + mysqladmin -h 127.0.0.1 -P 3306 -u root create sbtest 2>/dev/null || true + + # 校验mysql是否可用，不可用则视为环境准备失败 + if ! mysqladmin -h 127.0.0.1 -P 3306 -u root ping >/dev/null 2>&1; then + echo "mysql service is not ready, mysql testcase can not run" + return 1 + fi + echo "mysql setup done" + return 0 +} + # TODO: 实际编译动作 build_tool() { - # 不编译数据库相关的测试项 + # 安装数据库及其开发库(mysql-devel提供mysql_config，编译mysql驱动所需) + install_db || return 1 + # 默认即以数据库支持编译，确保可以跑mysql用例 cd "$g_tool_dir" \ && ./autogen.sh \ - && ./configure --disable-db --without-mysql --prefix="$g_install_dir" \ + && ./configure --prefix="$g_install_dir" \ && make -j \ - && make install + && make install \ + && setup_mysql } # 下面代码建议保持不变 -- Gitee