def test_proxysql_mysql_user_with_type_conversion():
mu = ProxySQLMySQLUser(username='******',
password='******',
active='0',
use_ssl='0',
default_hostgroup='10',
default_schema='bar',
schema_locked='0',
transaction_persistent='0',
fast_forward='0',
backend='0',
frontend=0,
max_connections='10')
assert mu.username == 'foo'
assert mu.password == 'qwerty'
assert mu.active is False
assert mu.use_ssl is False
assert mu.default_hostgroup == 10
assert mu.default_schema == 'bar'
assert mu.schema_locked is False
assert mu.transaction_persistent is False
assert mu.fast_forward is False
assert mu.backend is False
assert mu.frontend is False
assert mu.max_connections == 10
def test_modify_user(mock_add_user, mock_get_user, mock_parser, config):
mock_get_user.return_value = ProxySQLMySQLUser()
mock_parser.return_value = {'foo': 'bar'}
modify_user(config, 'test', {})
mock_parser.assert_called_once()
mock_add_user.assert_called_once()
mock_get_user.assert_called_once()
def create_user(cfg, kwargs):
"""Create user for MySQL backend"""
args = get_proxysql_options(cfg)
if kwargs['password']:
kwargs['password'] = get_encrypred_password(cfg, kwargs['password'])
user = ProxySQLMySQLUser(**kwargs)
ProxySQL(**args).add_user(user)
def test_get_user_if_user_does_not_exist(mock_execute, proxysql):
user = ProxySQLMySQLUser(username='******', password='******')
mock_execute.return_value = []
with pytest.raises(ProxySQLUserNotFound):
proxysql.get_user('test')
query = "SELECT * FROM mysql_users WHERE username = '******'"
mock_execute.assert_called_once_with(query)
def test__galera_user_create_using_options(proxysql_instance, tmpdir):
config = proxysql_tools_config(proxysql_instance, '127.0.0.1', '3306',
'user', 'pass', 10, 11, 'monitor',
'monitor')
config_file = str(tmpdir.join('proxysql-tool.cfg'))
with open(config_file, 'w') as fh:
config.write(fh)
proxysql_tools.LOG.debug('proxysql-tools config: \n%s', config)
runner = CliRunner()
result = runner.invoke(
main, ['--config', config_file, 'galera', 'user', 'create', 'foo'])
assert result.exit_code == 0
connection = pymysql.connect(host=proxysql_instance.host,
port=proxysql_instance.port,
user=proxysql_instance.user,
passwd=proxysql_instance.password,
connect_timeout=20,
cursorclass=DictCursor)
try:
with connection.cursor() as cursor:
cursor.execute(
"SELECT * FROM mysql_users WHERE username = '******'".
format(username='******'))
row = cursor.fetchall()[0]
assert row
user = ProxySQLMySQLUser(
username=row['username'],
password=row['password'],
active=row['active'],
use_ssl=row['use_ssl'],
default_hostgroup=row['default_hostgroup'],
default_schema=row['default_schema'],
schema_locked=row['schema_locked'],
transaction_persistent=row['transaction_persistent'],
fast_forward=row['fast_forward'],
backend=row['backend'],
frontend=row['frontend'],
max_connections=row['max_connections'])
assert user.active
assert not user.use_ssl
assert user.default_hostgroup == 0
assert user.default_schema == 'information_schema'
assert not user.schema_locked
assert not user.transaction_persistent
assert not user.fast_forward
assert user.backend
assert user.frontend
assert user.max_connections == 10000
finally:
connection.close()
def test_get_user(mock_execute, proxysql):
user = ProxySQLMySQLUser(username='******', password='******')
proxysql.get_user('test')
query = "SELECT * FROM mysql_users WHERE username = '******'"
mock_execute.assert_called_once_with(query)
def test_delete_user(mock_execute, mock_runtime, proxysql):
user = ProxySQLMySQLUser(username='******', password='******')
proxysql.delete_user('test')
query = "DELETE FROM mysql_users WHERE username='******'"
mock_execute.assert_called_once_with(query)
mock_runtime.assert_called_once_with()
def test_add_user(mock_execute, mock_runtime, query, proxysql):
user = ProxySQLMySQLUser(username='******', password='')
proxysql.add_user(user)
mock_execute.assert_called_once_with(query)
mock_runtime.assert_called_once_with()
def test_delete_user(mock_execute, mock_runtime, mock_reload, proxysql):
user = ProxySQLMySQLUser(username='******', password='******')
proxysql.delete_user('test')
mock_runtime.assert_called_once_with()
mock_reload.assert_called_once_with()
def test_get_users(mock_users, config):
mock_users.return_value = [ProxySQLMySQLUser()]
get_users(config)
def test_change_password(mock_add_user, mock_get_user, mock_enc_pwd, config):
mock_get_user.return_value = ProxySQLMySQLUser()
change_password(config, 'root', '1235')
def test__galera_user_set_password_if_user_is_exist(
percona_xtradb_cluster_three_node, proxysql_instance, tmpdir):
wait_for_cluster_nodes_to_become_healthy(percona_xtradb_cluster_three_node)
hostgroup_writer = 10
hostgroup_reader = 11
rw_map = {0: hostgroup_writer, 1: hostgroup_reader, 2: hostgroup_reader}
for i in xrange(3):
backend = ProxySQLMySQLBackend(
hostname=percona_xtradb_cluster_three_node[i]['ip'],
port=percona_xtradb_cluster_three_node[0]['mysql_port'],
hostgroup_id=rw_map[i])
proxysql_instance.register_backend(backend)
blacklist = '{}:3306'.format(percona_xtradb_cluster_three_node[2]['ip'])
nodes = [
percona_xtradb_cluster_three_node[0]['ip'] + ':3306',
percona_xtradb_cluster_three_node[1]['ip'] + ':3306',
percona_xtradb_cluster_three_node[2]['ip'] + ':3306'
]
config = proxysql_tools_config_2(proxysql_instance, nodes, 'root', 'r00t',
hostgroup_writer, hostgroup_reader,
blacklist, 'monitor', 'monitor')
config_file = str(tmpdir.join('proxysql-tool.cfg'))
with open(config_file, 'w') as fh:
config.write(fh)
proxysql_tools.LOG.debug('proxysql-tools config: \n%s', config)
runner = CliRunner()
result = runner.invoke(main,
['--config', config_file, 'galera', 'register'])
assert result.exit_code == 0
result = runner.invoke(
main, ['--config', config_file, 'galera', 'user', 'create', 'foo'])
assert result.exit_code == 0
connection = pymysql.connect(host=proxysql_instance.host,
port=proxysql_instance.port,
user=proxysql_instance.user,
passwd=proxysql_instance.password,
connect_timeout=20,
cursorclass=DictCursor)
try:
with connection.cursor() as cursor:
cursor.execute(
"SELECT * FROM mysql_users WHERE username = '******'".
format(username='******'))
assert cursor.fetchall() != ()
finally:
connection.close()
result = runner.invoke(
main,
['--config', config_file, 'galera', 'user', 'set_password', 'foo'],
input='test\ntest\n')
assert result.exit_code == 0
connection = pymysql.connect(host=proxysql_instance.host,
port=proxysql_instance.port,
user=proxysql_instance.user,
passwd=proxysql_instance.password,
connect_timeout=20,
cursorclass=DictCursor)
try:
with connection.cursor() as cursor:
cursor.execute(
"SELECT * FROM mysql_users WHERE username = '******'".
format(username='******'))
row = cursor.fetchall()[0]
user = ProxySQLMySQLUser(
username=row['username'],
password=row['password'],
active=row['active'],
use_ssl=row['use_ssl'],
default_hostgroup=row['default_hostgroup'],
default_schema=row['default_schema'],
schema_locked=row['schema_locked'],
transaction_persistent=row['transaction_persistent'],
fast_forward=row['fast_forward'],
backend=row['backend'],
frontend=row['frontend'],
max_connections=row['max_connections'])
assert user.password
assert user.active
assert not user.use_ssl
assert user.default_hostgroup == 0
assert user.default_schema == 'information_schema'
assert not user.schema_locked
assert not user.transaction_persistent
assert not user.fast_forward
assert user.backend
assert user.frontend
assert user.max_connections == 10000
finally:
connection.close()
