def test_get_master_port(self):
std_env = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', dbDirPath=self.test_dir)
assert std_env.getMasterPort() == 6379
env2 = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', dbDirPath=self.test_dir,
port=10000)
assert env2.getMasterPort() == 10000
pass
def test__stop_process(self):
std_env = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', dbDirPath=self.test_dir, useSlaves=True)
assert std_env.isUp() == False
std_env.startEnv()
assert std_env._isAlive(std_env.masterProcess) == True
assert std_env._isAlive(std_env.slaveProcess) == True
std_env.stopEnv()
assert std_env._isAlive(std_env.masterProcess) == False
assert std_env._isAlive(std_env.slaveProcess) == False
std_env = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', dbDirPath=self.test_dir, useSlaves=True)
assert std_env.isUp() == False
std_env.startEnv()
assert std_env._isAlive(std_env.masterProcess) == True
assert std_env._isAlive(std_env.slaveProcess) == True
assert std_env.isUp() == True
assert std_env.isHealthy() == True
std_env.stopEnv(masters=True, slaves=False)
assert std_env._isAlive(std_env.masterProcess) == False
assert std_env._isAlive(std_env.slaveProcess) == True
assert std_env.isUp() == True
assert std_env.isHealthy() == False
std_env.stopEnv(slaves=True)
assert std_env._isAlive(std_env.masterProcess) == False
assert std_env._isAlive(std_env.slaveProcess) == False
assert std_env.isUp() == False
assert std_env.isHealthy() == False
def test_get_password(self):
std_env = StandardEnv(redisBinaryPath=REDIS_BINARY,
outputFilesFormat='%s-test',
dbDirPath=self.test_dir)
assert std_env.getPassword() == None
std_env_pass = StandardEnv(redisBinaryPath=REDIS_BINARY,
outputFilesFormat='%s-test',
dbDirPath=self.test_dir,
password="******")
assert std_env_pass.getPassword() == "passwd"
def test_get_server_id(self):
std_env = StandardEnv(redisBinaryPath=REDIS_BINARY,
outputFilesFormat='%s-test',
dbDirPath=self.test_dir)
assert std_env.getServerId('master') == 1
std_env_id2 = StandardEnv(redisBinaryPath=REDIS_BINARY,
outputFilesFormat='%s-test',
dbDirPath=self.test_dir,
serverId=2)
assert std_env_id2.getServerId('master') == 2
def test_get_port(self):
std_env = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', dbDirPath=self.test_dir)
assert std_env.getPort('master') == 6379
std_env_slave = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', dbDirPath=self.test_dir,
useSlaves=True)
assert std_env_slave.getPort('slave') == 6380
env2 = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', dbDirPath=self.test_dir,
port=10000)
assert env2.getPort('master') == 10000
env2_slave = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', dbDirPath=self.test_dir,
useSlaves=True, port=10000)
assert env2_slave.getPort('slave') == 10001
def test_is_tls(self):
std_env = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', dbDirPath=self.test_dir)
std_env.startEnv()
assert std_env.isTLS() == False
std_env.stopEnv()
if not os.path.isfile(TLS_CERT) or not os.path.isfile(TLS_KEY) or not os.path.isfile(TLS_CACERT):
self.skipTest("missing required tls files")
tls_std_env = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', dbDirPath=self.test_dir,
useTLS=True,
tlsCertFile=TLS_CERT,
tlsKeyFile=TLS_KEY,
tlsCaCertFile=TLS_CACERT)
tls_std_env.startEnv()
assert tls_std_env.isTLS() == True
tls_std_env.stopEnv()
def __init__(self, **kwargs):
self.shards = []
self.envIsUp = False
self.envIsHealthy = False
self.modulePath = kwargs.pop('modulePath')
self.moduleArgs = kwargs['moduleArgs']
self.shardsCount = kwargs.pop('shardsCount')
self.dmcBinaryPath = kwargs.pop('dmcBinaryPath')
useSlaves = kwargs.get('useSlaves', False)
self.preperModule()
startPort = 20000
totalRedises = self.shardsCount * (2 if useSlaves else 1)
for i in range(0, totalRedises, (2 if useSlaves else 1)):
shard = StandardEnv(port=startPort,
serverId=(i + 1),
password=SHARD_PASSWORD,
modulePath=self.moduleSoFilePath,
**kwargs)
self.shards.append(shard)
startPort += 2
self.ccs = CcsMock(redisBinaryPath=kwargs['redisBinaryPath'],
directory=kwargs['dbDirPath'],
useSlaves=kwargs['useSlaves'],
password=SHARD_PASSWORD,
proxyPort=self.DMC_PORT,
libPath=kwargs['libPath'])
self.dmc = Dmc(directory=kwargs['dbDirPath'],
dmcBinaryPath=self.dmcBinaryPath,
libPath=kwargs['libPath'])
self.envIsUp = False
def test_is_up(self):
std_env = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', dbDirPath=self.test_dir)
assert std_env.isUp() == False
std_env.startEnv()
assert std_env.isUp() == True
std_env.stopEnv()
assert std_env.isUp() == False
def test_get_tlscacert_file(self):
if not os.path.isfile(TLS_CERT) or not os.path.isfile(TLS_KEY) or not os.path.isfile(TLS_CACERT):
self.skipTest("missing required tls files")
tls_std_env = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', useTLS=True,
tlsCertFile=os.path.join(self.test_dir, tlsCertFile),
tlsKeyFile=os.path.join(self.test_dir, tlsKeyFile),
tlsCaCertFile=os.path.join(self.test_dir, tlsCaCertFile), port=8000)
assert os.path.join(self.test_dir, tlsCaCertFile) == tls_std_env.getTLSCACertFile()
def test_cluster_node_timeout(self):
std_env = StandardEnv(redisBinaryPath=REDIS_BINARY,
outputFilesFormat='%s-test',
dbDirPath=self.test_dir,
clusterNodeTimeout=60000)
std_env.startEnv()
con = std_env.getConnection()
assert (con.execute_command("CONFIG", "GET",
"cluster-node-timeout"), "60000")
std_env.stopEnv()
def test_create_cmd_args_default(self):
std_env = StandardEnv(redisBinaryPath=REDIS_BINARY,
outputFilesFormat='%s-test')
role = 'master'
cmd_args = std_env.createCmdArgs(role)
assert [
REDIS_BINARY, '--port', '6379', '--logfile',
std_env._getFileName(role, '.log'), '--dbfilename',
std_env._getFileName(role, '.rdb')
] == cmd_args
def test_get_connection_by_key(self):
tagsCount = 3
std_env = StandardEnv(redisBinaryPath=REDIS_BINARY,
outputFilesFormat='%s-test',
dbDirPath=self.test_dir)
std_env.startEnv()
for i in range(tagsCount):
key = 'x{%i}' % i
con = std_env.getConnectionByKey(key, "set")
assert (con.set(key, "1"))
std_env.stopEnv()
def test_create_cmd_args_tls(self):
port = 8000
tls_std_env = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', useTLS=True,
tlsCertFile=os.path.join(self.test_dir, tlsCertFile),
tlsKeyFile=os.path.join(self.test_dir, tlsKeyFile),
tlsCaCertFile=os.path.join(self.test_dir, tlsCaCertFile), port=8000)
role = 'master'
cmd_args = tls_std_env.createCmdArgs(role)
assert [REDIS_BINARY, '--port', '0', '--tls-port', '{}'.format(port), '--logfile',
tls_std_env._getFileName(role, '.log'), '--dbfilename',
tls_std_env._getFileName(role, '.rdb'), '--tls-cert-file', os.path.join(self.test_dir, tlsCertFile),
'--tls-key-file', os.path.join(self.test_dir, tlsKeyFile), '--tls-ca-cert-file',
os.path.join(self.test_dir, tlsCaCertFile)] == cmd_args
def test_create_cmd_args_aof_without_rdb_preamble(self):
port = 8000
aof_std_env = StandardEnv(redisBinaryPath=REDIS_BINARY,
outputFilesFormat='%s-test',
useAof=True,
useRdbPreamble=False,
port=8000)
role = 'master'
cmd_args = aof_std_env.createCmdArgs(role)
assert [
REDIS_BINARY, '--port', '{}'.format(port), '--logfile',
aof_std_env._getFileName(role, '.log'), '--dbfilename',
aof_std_env._getFileName(role, '.rdb'), '--appendonly', 'yes',
'--appendfilename',
aof_std_env._getFileName(role,
'.aof'), '--aof-use-rdb-preamble', 'no'
] == cmd_args
def test_create_cmd_args_modules_one_module_array(self):
port = 8000
temp = tempfile.TemporaryFile()
directory_name = tempfile.mkdtemp()
temp_file = tempfile.NamedTemporaryFile(dir=directory_name)
module_std_env = StandardEnv(redisBinaryPath=REDIS_BINARY,
outputFilesFormat='%s-test',
port=port,
modulePath=[temp_file.name],
moduleArgs=["P1 V1 P2 V2"])
role = 'master'
cmd_args = module_std_env.createCmdArgs(role)
assert [
REDIS_BINARY, '--port', '{}'.format(port), '--loadmodule',
temp_file.name, 'P1', 'V1', 'P2', 'V2', '--logfile',
module_std_env._getFileName(role, '.log'), '--dbfilename',
module_std_env._getFileName(role, '.rdb')
] == cmd_args
shutil.rmtree(directory_name)
def test_has_interactive_debugger(self):
std_env = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test')
assert std_env.has_interactive_debugger == None
def test_is_tcp(self):
std_env = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', dbDirPath=self.test_dir)
assert std_env.isTcp() == True
def test_is_unix_socket(self):
std_env = StandardEnv(redisBinaryPath=REDIS_BINARY, outputFilesFormat='%s-test', dbDirPath=self.test_dir)
assert std_env.isUnixSocket() == False
