def setup(self):
self.server1 = self.servers.get_server(0)
data_file = os.path.normpath("./std_data/fkeys.sql")
self.drop_all()
self.server1.disable_foreign_key_checks(True)
try:
res = self.server1.read_and_exec_SQL(data_file, self.debug)
except UtilError, e:
raise MUTLibError("Failed to read commands from file %s: %s" % \
(data_file, e.errmsg))
def check_prerequisites(self):
if self.servers.get_server(0).check_version_compat(5, 6, 5):
raise MUTLibError("Test requires server version prior to 5.6.5")
# Need at least one server.
self.server1 = None
self.server2 = None
self.need_server = False
if not self.check_num_servers(3):
self.need_server = True
return self.check_num_servers(1)
def setup(self):
num_server = self.servers.num_servers()
if self.need_servers:
try:
self.servers.spawn_new_servers(2)
except MUTLibError as err:
raise MUTLibError("Cannot spawn needed servers: {0}".format(
err.errmsg))
else:
num_server -= 1 # Get last server in list
self.server1 = self.servers.get_server(num_server)
data_file = os.path.normpath("./std_data/basic_data.sql")
self.drop_all()
try:
self.server1.read_and_exec_SQL(data_file, self.debug)
except UtilError as err:
raise MUTLibError("Failed to read commands from file {0}: "
"{1}".format(data_file, err.errmsg))
return True
def setup(self):
self.server1 = self.servers.get_server(0)
data_file = os.path.normpath("./std_data/basic_data.sql")
self.drop_all()
try:
self.server1.read_and_exec_SQL(data_file, self.debug)
except MUTLibError, err:
raise MUTLibError(
"Failed to read commands from file {0}{1}: ".format(
data_file, err.errmsg))
def setup(self):
self.res_fname = "result.txt"
# Spawn servers
self.server0 = self.servers.get_server(0)
mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port())
self.server1 = self.servers.spawn_server("rep_master_gtid", mysqld,
True)
mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port())
self.server2 = self.servers.spawn_server("rep_slave1_gtid", mysqld,
True)
mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port())
self.server3 = self.servers.spawn_server("rep_slave2_gtid", mysqld,
True)
mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port())
self.server4 = self.servers.spawn_server("rep_slave3_gtid", mysqld,
True)
mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port())
self.server5 = self.servers.spawn_server("rep_slave4_gtid", mysqld,
True)
# Reset spawned servers (clear binary log and GTID_EXECUTED set)
self.reset_master([self.server1, self.server2, self.server3,
self.server4, self.server5])
self.m_port = self.server1.port
self.s1_port = self.server2.port
self.s2_port = self.server3.port
self.s3_port = self.server4.port
self.s4_port = self.server5.port
rpl_admin.test.reset_topology(self)
build_str = self.build_connection_string
self.master_conn = build_str(self.server1).strip(' ')
self.slave1_conn = build_str(self.server2).strip(' ')
self.slave2_conn = build_str(self.server3).strip(' ')
self.slave3_conn = build_str(self.server4).strip(' ')
self.slave4_conn = build_str(self.server5).strip(' ')
try:
self.server5.exec_query("STOP SLAVE")
self.server5.exec_query("RESET SLAVE")
except UtilError:
raise MUTLibError("Unable to reset slave")
cmd = " ".join(["mysqlreplicate.py --rpl-user=rpl:rpl ",
" --slave={0}".format(self.slave4_conn),
" --master={0}".format(self.master_conn)])
self.exec_util(cmd, self.res_fname)
self.servers_list = [self.server1, self.server2, self.server3,
self.server4, self.server5]
return True
def run(self):
cmd_base = 'mysqlgrants.py --server={0}'.format(
self.build_connection_string(self.server1))
test_num = 1
comment = ("Test case {0} - Privileges are inherited from global "
"level to db level and from db level to tables and "
"routines".format(test_num))
cmd = ("{0} util_test util_test.t3 util_test.t2 util_test.p1 "
"util_test.f1".format(cmd_base))
res = self.run_test_case(0, cmd, comment)
if not res:
raise MUTLibError("{0}: failed".format(comment))
test_num += 1
comment = ("Test case {0} - show grantees, using all types of objects:"
" tables, databases and stored routines".format(test_num))
if os.name == 'posix':
cmd_arg = ("'`db``:db`' '`db``:db`.```t``.``export_2`' "
"'`db``:db`.`fu``nc`' '`db``:db`.`pr````oc`' ")
else:
cmd_arg = ('"`db``:db`" "`db``:db`.```t``.``export_2`" '
'"`db``:db`.`fu``nc`" "`db``:db`.`pr````oc`" ')
cmd = ("{0} util_test util_test.t1 util_test.t2 "
"util_test.does_not_exist util_test.v1 db_does_not_exist "
"util_test.t3 {1}".format(cmd_base, cmd_arg))
res = self.run_test_case(0, cmd, comment)
if not res:
raise MUTLibError("{0}: failed".format(comment))
test_num += 1
comment = ("Test case {0} - show grants for all objects of a "
"database using wildcard".format(test_num))
cmd = "{0} util_test.* ".format(cmd_base,)
res = self.run_test_case(0, cmd, comment)
if not res:
raise MUTLibError("{0}: failed".format(comment))
# mask non deterministic output
self.do_masks()
return True
def setup(self):
super(test, self).setup()
rows = self.server2.exec_query("SHOW VARIABLES LIKE 'datadir'")
if not rows:
raise MUTLibError("Unable to determine datadir of cloned server "
"at {0}:{1}".format(self.server2.host,
self.server2.port))
self.server2_datadir = rows[0][1]
return True
def check_prerequisites(self):
# Check MySQL server version - Must be 5.1.0 or higher
if not self.servers.get_server(0).check_version_compat(5, 1, 0):
raise MUTLibError("Test requires server version 5.1.0 or higher")
self.check_gtid_unsafe()
# Need at least one server.
self.server1 = None
self.need_servers = False
if not self.check_num_servers(3):
self.need_servers = True
return self.check_num_servers(1)
def setup(self):
self.server1 = self.servers.get_server(0)
data_file = os.path.normpath("./std_data/basic_data.sql")
self.drop_all()
try:
res = self.server1.read_and_exec_SQL(data_file, self.debug)
except UtilError as err:
raise MUTLibError("Failed to read commands from file %s: %s" %
(data_file, err.errmsg))
# Create backtick database (with weird names)
data_file_backticks = os.path.normpath("./std_data/backtick_data.sql")
try:
res = self.server1.read_and_exec_SQL(data_file_backticks,
self.debug)
except UtilError as err:
raise MUTLibError("Failed to read commands from file %s: %s" %
(data_file_backticks, err.errmsg))
return True
def setup(self):
mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port(), "")
self.server1 = self.servers.spawn_server("compare_db_srv1_aq_mix",
mysqld, True)
if self.server1.select_variable("SQL_MODE") == "ANSI_QUOTES":
raise MUTLibError("This Test needs a server with SQL_MODE != "
"ANSI_QUOTES {0}:{1}".format(
self.server2.host, self.server2.port))
mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port(),
"--sql-mode=ANSI_QUOTES")
self.server2 = self.servers.spawn_server("compare_db_srv2_aq_mix",
mysqld, True)
if self.server2.select_variable("SQL_MODE") != "ANSI_QUOTES":
raise MUTLibError("Failed to set SQL_MODE!=ANSI_QUOTES to server"
" {0}:{1}".format(self.server2.host,
self.server2.port))
self.drop_all()
return True
def do_test(self, test_num, comment, command):
"""Do test.
test_num[in] Test number.
comment[in] Comment.
command[in] Command.
"""
res = self.run_test_case(0, command,
_BASE_COMMENT.format(test_num, comment))
if not res:
raise MUTLibError("{0}: failed".format(comment))
def _load_data(self, server, data_file):
"""Reads and executes SQL from data file.
server[in] Server instance.
data_file[in] File name containing SQL statements.
"""
try:
server.read_and_exec_SQL(data_file, self.debug)
except UtilError as err:
raise MUTLibError("Failed to read commands from file {0}: "
"{1}".format(data_file, err.errmsg))
def check_prerequisites(self):
""" Check prerequisites to execute test.
Return True if all prerequisites are met, otherwise a MUTLibError is
issued.
"""
# Check required server version.
# Reason: GTID requires servers > 5.6.9.
if not self.servers.get_server(0).check_version_compat(5, 6, 9):
raise MUTLibError("Test requires server version >= 5.6.9")
return self.check_num_servers(1)
def check_prerequisites(self):
# Need non-Windows platform
if os.name == "nt":
raise MUTLibError("Test requires a non-Windows platform.")
# Need at least one server.
self.server1 = self.servers.get_server(0)
self.server2 = None
self.need_server = False
if not self.check_num_servers(2):
self.need_server = True
res = self.check_num_servers(1)
rows = []
try:
rows = self.server1.exec_query("SHOW DATABASES LIKE 'employees'")
except:
pass
if len(rows) == 0:
raise MUTLibError("Need employees database loaded on "
"{0}".format(self.server1.role))
return res
def setup(self):
res = check_rpl.test.setup(self)
index = self.servers.find_server_by_name("rep_slave_ignore")
if index >= 0:
self.server3 = self.servers.get_server(index)
try:
res = self.server3.show_server_variable("server_id")
except MUTLibError, e:
raise MUTLibError("Cannot get replication slave " +
"server_id: %s" % e.errmsg)
self.s3_serverid = int(res[0][1])
def check_prerequisites(self):
if self.servers.get_server(0).supports_gtid() != "ON" or \
not self.servers.get_server(0).check_version_compat(5,6,9):
raise MUTLibError("Test requires server version 5.6.9 with "
"GTID_MODE=ON.")
if os.name == "nt":
raise MUTLibError("Test does not run correctly on Windows. "
"See BUG#16005010.")
if os.name == "posix":
self.failover_dir = "./fail_event"
else:
self.failover_dir = ".\\fail_event"
if self.debug:
print
for log in ["1", "2", "3", "4"]:
try:
os.unlink(log + _FAILOVER_LOG)
except:
pass
return rpl_admin_gtid.test.check_prerequisites(self)
def check_prerequisites(self):
self.check_gtid_unsafe()
if self.servers.get_server(0).check_version_compat(5, 6, 2):
raise MUTLibError("Test requires server version prior to 5.6.2")
# Need at least one server.
self.server1 = None
self.server2 = None
self.gen_log = None
self.slow_log = None
self.error_log = None
return self.check_num_servers(1)
def get_table_rows(self, comment):
"""Get list of rows from the slave.
comment[in] Comment.
"""
try:
res = self.server1.exec_query("SELECT * FROM log_test.t1")
self.results.append(res)
except UtilError as err:
raise MUTLibError("{0}: Query failed. {1}".format(
comment, err.errmsg))
def setup(self):
self.server1 = self.servers.get_server(0)
if self.need_server:
try:
self.servers.spawn_new_servers(2)
except MUTLibError as err:
raise MUTLibError("Cannot spawn needed servers: {0}".format(
err.errmsg))
self.server2 = self.servers.get_server(1)
self.drop_all()
return True
def setup(self):
self.server0 = self.servers.get_server(0)
mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port())
self.server1 = self.servers.spawn_server("compare_db_srv1_ansi_quotes",
mysqld, True)
mysqld = _DEFAULT_MYSQL_OPTS.format(self.servers.view_next_port())
self.server2 = self.servers.spawn_server("compare_db_srv2_ansi_quotes",
mysqld, True)
if self.server1.select_variable("SQL_MODE") != "ANSI_QUOTES":
raise MUTLibError("Failed to set SQL_MODE=ANSI_QUOTES to server"
" {0}:{1}".format(self.server1.host,
self.server1.port))
if self.server2.select_variable("SQL_MODE") != "ANSI_QUOTES":
raise MUTLibError("Failed to set SQL_MODE=ANSI_QUOTES to server"
" {0}:{1}".format(self.server2.host,
self.server2.port))
self.drop_all()
return True
def setup(self):
res = import_basic.test.setup(self)
if not res:
return False
data_file = os.path.normpath("./std_data/basic_data.sql")
try:
res = self.server2.read_and_exec_SQL(data_file, self.debug)
except MUTLibError, e:
raise MUTLibError("Failed to read commands from file %s: " % \
data_file + e.errmsg)
def run(self):
self.mask_global = False # Turn off global masks
self.res_fname = "result.txt"
from_conn = self.build_connection_string(self.server1)
conn_val = self.get_connection_values(self.server1)
cmd = ("mysqlprocgrep.py --server={0} "
"--match-user={1} ".format(from_conn, conn_val[0]))
test_case_num = 1
_FORMATS = ("CSV", "TAB", "VERTICAL", "GRID")
for format_ in _FORMATS:
comment = ("Test case {0} - find processes for current "
"user format={1}".format(test_case_num, format_))
test_case_num += 1
cmd = "{0} --format={1} ".format(cmd, format_)
res = self.run_test_case(0, cmd, comment)
if not res:
raise MUTLibError("{0}: failed".format(comment))
self.results.append("\n")
# CSV masks
self.mask_column_result("root:*@localhost", ",", 1, "root[...]")
self.mask_column_result("root[...]", ",", 2, "XXXXX")
self.mask_column_result("root[...]", ",", 4, "localhost")
self.mask_column_result("root[...]", ",", 7, "XXXXX")
# TAB masks
self.mask_column_result("root:*@localhost", "\t", 1, "root[...]")
self.mask_column_result("root[...]", "\t", 2, "XXXXX")
self.mask_column_result("root[...]", "\t", 4, "localhost")
self.mask_column_result("root[...]", "\t", 7, "XXXXX")
# Vertical masks
self.replace_result(" Connection: ", " Connection: XXXXX\n")
self.replace_result(" Id: ", " Id: XXXXX\n")
self.replace_result(" Host: ", " Host: localhost\n")
self.replace_result(" Time: ", " Time: XXXXX\n")
# Grid masks
# Here, we truncate all horizontal bars for deterministic results
self.replace_result("+---", "+---+\n")
self.mask_column_result("| root", "|", 2, " root[...] ")
self.mask_column_result("| root[...] ", "|", 3, " XXXXX ")
self.mask_column_result("| root[...] ", "|", 5, " localhost ")
self.mask_column_result("| root[...] ", "|", 8, " XXXXX ")
self.replace_result(
"| Connection", "| Connection | Id | User | Host "
"| Db | Command | Time | State "
"| Info [...] |\n")
return True
def exec_export_import(self, server1, server2, exp_cmd, imp_cmd,
test_num, test_case, ret_val=True, reset=True,
load_data=True):
conn1 = "--server=" + self.build_connection_string(server1)
conn2 = "--server=" + self.build_connection_string(server2)
if load_data:
try:
res = server1.read_and_exec_SQL(self.data_file, self.debug)
except UtilError, e:
raise MUTLibError("Failed to read commands from file %s: %s" %
(self.data_file, e.errmsg))
def setup(self):
# Check available cloned servers and spawn one if needed.
if self.servers.num_servers() < 2:
try:
self.servers.spawn_new_servers(2)
except MUTLibError as err:
raise MUTLibError("Cannot spawn needed servers: "
"{0}".format(err.errmsg))
# Get first cloned server (only one needed).
self.server1 = self.servers.get_server(1)
# Load users data for test.
data_file = "./std_data/basic_users.sql"
try:
self.server1.read_and_exec_SQL(data_file, self.debug)
except (MUTLibError, UtilError) as err:
raise MUTLibError(
"Failed to read commands from file {0}: {1}".format(
data_file, err.errmsg))
return True
def setup(self, spawn_servers=True):
if spawn_servers:
self.server1 = self.servers.get_server(0)
if self.need_server:
try:
self.servers.spawn_new_servers(2)
except MUTLibError as err:
raise MUTLibError("Cannot spawn needed servers: {0}"
"".format(err.errmsg))
if self.server2 is None:
self.server2 = self.servers.get_server(1)
self.drop_all()
data_file = os.path.normpath("./std_data/basic_data.sql")
try:
self.server1.read_and_exec_SQL(data_file, self.debug)
except UtilError as err:
raise MUTLibError("Failed to read commands from file {0}: {1}"
"".format(data_file, err.errmsg))
# Create backtick database (with weird names)
data_file_backticks = os.path.normpath("./std_data/backtick_data.sql")
try:
self.server1.read_and_exec_SQL(data_file_backticks, self.debug)
except UtilError as err:
raise MUTLibError("Failed to read commands from file {0}: {1}"
"".format(data_file_backticks, err.errmsg))
# Create database with test VIEWS.
data_file_views = os.path.normpath("./std_data/db_copy_views.sql")
try:
self.server1.read_and_exec_SQL(data_file_views, self.debug)
except UtilError as err:
raise MUTLibError("Failed to read commands from file "
"{0}: {1}".format(data_file_views, err.errmsg))
# Load database with with blobs and insert data.
data_file_blobs = os.path.normpath("./std_data/blob_data.sql")
try:
self.server1.read_and_exec_SQL(data_file_blobs, self.debug)
except UtilError as err:
raise MUTLibError("Failed to read commands from file {0}: {1}"
"".format(data_file_blobs, err.errmsg))
# Create user 'joe'@'localhost' in source server
try:
self.server1.exec_query("CREATE USER 'joe'@'localhost'")
except UtilError as err:
raise MUTLibError("Failed to create user: {0}".format(err.errmsg))
# Create user 'joe'@'localhost' in destination server
try:
self.server2.exec_query("CREATE USER 'joe'@'localhost'")
except UtilError as err:
raise MUTLibError("Failed to create user: {0}".format(err.errmsg))
return True
def setup(self):
self.server0 = self.servers.get_server(0)
self.frm_output = "frm_output.txt"
self.s1_serverid = None
index = self.servers.find_server_by_name("frm_test")
if index >= 0:
self.server1 = self.servers.get_server(index)
try:
res = self.server1.show_server_variable("server_id")
except MUTLibError as err:
raise MUTLibError("Cannot get frm test server "
"server_id: {0}".format(err.errmsg))
self.s1_serverid = int(res[0][1])
else:
self.s1_serverid = self.servers.get_next_id()
res = self.servers.spawn_new_server(
self.server0, self.s1_serverid, "frm_test",
' --mysqld="--log-bin=mysql-bin "')
if not res:
raise MUTLibError("Cannot spawn frm_test server.")
self.server1 = res[0]
self.servers.add_new_server(self.server1, True)
self.drop_all()
self.server1.exec_query("CREATE DATABASE frm_test")
# Load a known CREATE TABLE|VIEW statement from file
data_file = os.path.normpath("./std_data/frm_test.sql")
try:
with open(data_file, 'r') as f:
queries = " ".join([a.strip("\n") for a in f])
sql_statements = queries.split(";")
for table_sql in sql_statements:
self.server1.exec_query(table_sql)
except MUTLibError as err:
raise MUTLibError("Failed to read commands from file "
"{0}: {1}".format(data_file, err.errmsg))
return True
def exec_copy(self,
server1,
server2,
copy_cmd,
test_num,
test_case,
reset=True,
load_data=True,
ret_val=True):
"""Execute copy.
server1[in] Server instance.
server2[in] Server instance.
copy_cmd[in] Copy command.
test_num[in] Test number.
test_case[in] Test case.
reset[in] True for reset.
load_data[in] True for load data.
ret_val[in] Return value.
"""
conn1 = " --source={0}".format(self.build_connection_string(server1))
conn2 = " --destination={0}".format(
self.build_connection_string(server2))
if load_data:
try:
server1.read_and_exec_SQL(self.data_file, self.debug)
except UtilError as err:
raise MUTLibError("Failed to read commands from file {0}: "
"{1}".format(self.data_file, err.errmsg))
comment = "Test case {0} {1}".format(test_num, test_case)
cmd_str = copy_cmd + conn1 + conn2
if reset:
server2.exec_query("RESET MASTER") # reset GTID_EXECUTED
res = mutlib.System_test.run_test_case(self, 0, cmd_str, comment)
if not res == ret_val:
for row in self.results:
print row,
raise MUTLibError("{0}: failed".format(comment))
self.drop_all()
def run(self):
self.res_fname = "result.txt"
from_conn = self.build_connection_string(self.server1)
cmd_base = "mysqlmetagrep.py --server={0}".format(from_conn)
test_num = 1
comment = "Test case {0} - invalid --character-set".format(test_num)
cmd = ("{0} --pattern=%t1% --character-set=unsupported_charset"
"".format(cmd_base))
res = self.run_test_case(1, cmd, comment)
if not res:
raise MUTLibError("{0}: failed".format(comment))
test_num += 1
comment = "Test case {0} - invalid --object-type.".format(test_num)
cmd = ("{0} --body --pattern=%t1% --object-types=function"
"".format(cmd_base))
res = self.run_test_case(1, cmd, comment)
if not res:
raise MUTLibError("{0}: failed".format(comment))
test_num += 1
comment = "Test case {0} - invalid --search-objects.".format(test_num)
cmd = ("{0} --pattern=%t1% --object-types=routine,foo"
"".format(cmd_base))
res = self.run_test_case(1, cmd, comment)
if not res:
raise MUTLibError("{0}: failed".format(comment))
test_num += 1
comment = "Test case {0} - invalid user.".format(test_num)
cmd_base = "mysqlmetagrep.py --server=nope@nada"
cmd = ("{0} --pattern=%t1% --object-types=routine" "".format(cmd_base))
res = self.run_test_case(1, cmd, comment)
if not res:
raise MUTLibError("{0}: failed".format(comment))
self.replace_result("ERROR: 2003: Can't connect to MySQL server",
"ERROR: 2003: Can't connect to XXXX\n")
return True
def run(self):
self.res_fname = "result.txt"
master_str = "--master=%s" % self.build_connection_string(self.server2)
slave_str = " --slave=%s" % self.build_connection_string(self.server1)
conn_str = master_str + slave_str
cmd = "mysqlreplicate.py --rpl-user=rpl:rpl %s" % conn_str
try:
res = self.exec_util(cmd, self.res_fname)
except MUTLibError, e:
raise MUTLibError(e.errmsg)
def stop_slave(comment, slave):
"""Stop and flush the slave to disconnect are reset.
comment[in] Comment.
slave[in] Slave instance.
"""
try:
slave.exec_query("STOP SLAVE")
slave.exec_query("RESET SLAVE")
except UtilError:
raise MUTLibError(
"{0}: Cannot stop and reset slave.".format(comment))
