def params_from_base_suite_setup(request):
log_info("Setting up 'params_from_base_suite_setup' ...")
server_version = request.config.getoption("--server-version")
sync_gateway_version = request.config.getoption("--sync-gateway-version")
mode = request.config.getoption("--mode")
skip_provisioning = request.config.getoption("--skip-provisioning")
log_info("server_version: {}".format(server_version))
log_info("sync_gateway_version: {}".format(sync_gateway_version))
log_info("mode: {}".format(mode))
log_info("skip_provisioning: {}".format(skip_provisioning))
# Make sure mode for sync_gateway is supported ('cc' or 'di')
validate_sync_gateway_mode(mode)
# use base_cc cluster config if mode is "cc" or base_di cluster config if more is "di"
cluster_config = "{}/multiple_sync_gateways_{}".format(constants.CLUSTER_CONFIGS_DIR, mode)
sg_config = sync_gateway_config_path_for_mode("sync_gateway_default_functional_tests", mode)
# Skip provisioning if user specifies '--skip-provisoning'
if not skip_provisioning:
cluster_helper = ClusterKeywords()
cluster_helper.provision_cluster(
cluster_config=cluster_config,
server_version=server_version,
sync_gateway_version=sync_gateway_version,
sync_gateway_config=sg_config
)
yield {"cluster_config": cluster_config, "mode": mode}
log_info("Tearing down 'params_from_base_suite_setup' ...")
def params_from_base_suite_setup(request):
log_info("Setting up 'params_from_base_suite_setup' ...")
server_version = request.config.getoption("--server-version")
sync_gateway_version = request.config.getoption("--sync-gateway-version")
mode = request.config.getoption("--mode")
skip_provisioning = request.config.getoption("--skip-provisioning")
log_info("server_version: {}".format(server_version))
log_info("sync_gateway_version: {}".format(sync_gateway_version))
log_info("mode: {}".format(mode))
log_info("skip_provisioning: {}".format(skip_provisioning))
# Make sure mode for sync_gateway is supported ('cc' or 'di')
validate_sync_gateway_mode(mode)
# Skip these tests unless you are running in 'di' mode
if mode != "di":
pytest.skip("These tests should only run in with sg_accels")
# use multiple_sg_accels_di
cluster_config = "{}/multiple_sg_accels_di".format(keywords.constants.CLUSTER_CONFIGS_DIR)
sg_config = "{}/sync_gateway_default_functional_tests_di.json".format(SYNC_GATEWAY_CONFIGS)
# Skip provisioning if user specifies '--skip-provisoning'
if not skip_provisioning:
cluster_helper = ClusterKeywords()
cluster_helper.provision_cluster(
cluster_config=cluster_config,
server_version=server_version,
sync_gateway_version=sync_gateway_version,
sync_gateway_config=sg_config
)
yield {"cluster_config": cluster_config, "mode": mode}
log_info("Tearing down 'params_from_base_suite_setup' ...")
def params_from_base_suite_setup(request):
log_info("Setting up 'params_from_base_suite_setup' ...")
# pytest command line parameters
server_version = request.config.getoption("--server-version")
sync_gateway_version = request.config.getoption("--sync-gateway-version")
mode = request.config.getoption("--mode")
skip_provisioning = request.config.getoption("--skip-provisioning")
race_enabled = request.config.getoption("--race")
cbs_ssl = request.config.getoption("--server-ssl")
xattrs_enabled = request.config.getoption("--xattrs")
sg_lb = request.config.getoption("--sg-lb")
sg_ce = request.config.getoption("--sg-ce")
use_sequoia = request.config.getoption("--sequoia")
no_conflicts_enabled = request.config.getoption("--no-conflicts")
if xattrs_enabled and version_is_binary(sync_gateway_version):
check_xattr_support(server_version, sync_gateway_version)
log_info("server_version: {}".format(server_version))
log_info("sync_gateway_version: {}".format(sync_gateway_version))
log_info("mode: {}".format(mode))
log_info("skip_provisioning: {}".format(skip_provisioning))
log_info("race_enabled: {}".format(race_enabled))
log_info("cbs_ssl: {}".format(cbs_ssl))
log_info("xattrs_enabled: {}".format(xattrs_enabled))
log_info("sg_lb: {}".format(sg_lb))
log_info("sg_ce: {}".format(sg_ce))
log_info("no conflicts enabled {}".format(no_conflicts_enabled))
# sg-ce is invalid for di mode
if mode == "di" and sg_ce:
raise FeatureSupportedError(
"SGAccel is only available as an enterprise edition")
if no_conflicts_enabled and sync_gateway_version < "2.0":
raise FeatureSupportedError(
'No conflicts feature not available for sync-gateway version below 2.0, so skipping the test'
)
# Make sure mode for sync_gateway is supported ('cc' or 'di')
validate_sync_gateway_mode(mode)
# use load_balancer_cc cluster config if mode is "cc" or load_balancer_di cluster config if mode is "di"
cluster_config = "{}/load_balancer_{}".format(
keywords.constants.CLUSTER_CONFIGS_DIR, mode)
sg_config = sync_gateway_config_path_for_mode(
"sync_gateway_default_functional_tests", mode)
# Add load balancer prop and check if load balancer IP is available
if sg_lb:
persist_cluster_config_environment_prop(cluster_config,
'sg_lb_enabled', True)
log_info("Running tests with load balancer enabled: {}".format(
get_load_balancer_ip(cluster_config)))
else:
log_info("Running tests with load balancer disabled")
persist_cluster_config_environment_prop(cluster_config,
'sg_lb_enabled', False)
if cbs_ssl:
log_info("Running tests with cbs <-> sg ssl enabled")
# Enable ssl in cluster configs
persist_cluster_config_environment_prop(cluster_config,
'cbs_ssl_enabled', True)
else:
log_info("Running tests with cbs <-> sg ssl disabled")
# Disable ssl in cluster configs
persist_cluster_config_environment_prop(cluster_config,
'cbs_ssl_enabled', False)
if xattrs_enabled:
log_info("Running test with xattrs for sync meta storage")
persist_cluster_config_environment_prop(cluster_config,
'xattrs_enabled', True)
else:
log_info("Using document storage for sync meta data")
persist_cluster_config_environment_prop(cluster_config,
'xattrs_enabled', False)
try:
server_version
except NameError:
log_info("Server version is not provided")
persist_cluster_config_environment_prop(cluster_config,
'server_version', "")
else:
log_info("Running test with server version {}".format(server_version))
persist_cluster_config_environment_prop(cluster_config,
'server_version',
server_version)
try:
sync_gateway_version
except NameError:
log_info("Sync gateway version is not provided")
persist_cluster_config_environment_prop(cluster_config,
'sync_gateway_version', "")
else:
log_info("Running test with sync_gateway version {}".format(
sync_gateway_version))
persist_cluster_config_environment_prop(cluster_config,
'sync_gateway_version',
sync_gateway_version)
if no_conflicts_enabled:
log_info("Running with no conflicts")
persist_cluster_config_environment_prop(cluster_config,
'no_conflicts_enabled', True)
else:
log_info("Running with allow conflicts")
persist_cluster_config_environment_prop(cluster_config,
'no_conflicts_enabled', False)
if sync_gateway_version < "2.0.0" and no_conflicts_enabled:
pytest.skip(
"Test cannot run with no-conflicts with sg version < 2.0.0")
# Skip provisioning if user specifies '--skip-provisoning' or '--sequoia'
should_provision = True
if skip_provisioning or use_sequoia:
should_provision = False
cluster_utils = ClusterKeywords()
if should_provision:
try:
cluster_utils.provision_cluster(
cluster_config=cluster_config,
server_version=server_version,
sync_gateway_version=sync_gateway_version,
sync_gateway_config=sg_config,
race_enabled=race_enabled,
sg_ce=sg_ce)
except ProvisioningError:
logging_helper = Logging()
logging_helper.fetch_and_analyze_logs(
cluster_config=cluster_config, test_name=request.node.name)
raise
# Hit this intalled running services to verify the correct versions are installed
cluster_utils.verify_cluster_versions(
cluster_config,
expected_server_version=server_version,
expected_sync_gateway_version=sync_gateway_version)
yield {"cluster_config": cluster_config, "mode": mode}
log_info("Tearing down 'params_from_base_suite_setup' ...")
# Stop all sync_gateway and sg_accels as test finished
c = cluster.Cluster(cluster_config)
c.stop_sg_and_accel()
def setup_client_syncgateway_suite(request):
"""Suite setup fixture for client sync_gateway tests"""
log_info("Setting up client sync_gateway suite ...")
liteserv_platform = request.config.getoption("--liteserv-platform")
liteserv_version = request.config.getoption("--liteserv-version")
liteserv_host = request.config.getoption("--liteserv-host")
liteserv_port = request.config.getoption("--liteserv-port")
liteserv_storage_engine = request.config.getoption("--liteserv-storage-engine")
skip_provisioning = request.config.getoption("--skip-provisioning")
sync_gateway_version = request.config.getoption("--sync-gateway-version")
sync_gateway_mode = request.config.getoption("--sync-gateway-mode")
server_version = request.config.getoption("--server-version")
xattrs_enabled = request.config.getoption("--xattrs")
device_enabled = request.config.getoption("--device")
liteserv = LiteServFactory.create(platform=liteserv_platform,
version_build=liteserv_version,
host=liteserv_host,
port=liteserv_port,
storage_engine=liteserv_storage_engine)
if xattrs_enabled and version_is_binary(sync_gateway_version):
check_xattr_support(server_version, sync_gateway_version)
log_info("Downloading LiteServ ...")
# Download LiteServ
liteserv.download()
# Install LiteServ
if device_enabled and liteserv_platform == "ios":
liteserv.install_device()
else:
liteserv.install()
cluster_config = "{}/base_{}".format(CLUSTER_CONFIGS_DIR, sync_gateway_mode)
try:
server_version
except NameError:
log_info("Server version is not provided")
persist_cluster_config_environment_prop(cluster_config, 'server_version', "")
else:
log_info("Running test with server version {}".format(server_version))
persist_cluster_config_environment_prop(cluster_config, 'server_version', server_version)
try:
sync_gateway_version
except NameError:
log_info("Sync gateway version is not provided")
persist_cluster_config_environment_prop(cluster_config, 'sync_gateway_version', "")
else:
log_info("Running test with sync_gateway version {}".format(sync_gateway_version))
persist_cluster_config_environment_prop(cluster_config, 'sync_gateway_version', sync_gateway_version)
if xattrs_enabled:
log_info("Running test with xattrs for sync meta storage")
persist_cluster_config_environment_prop(cluster_config, 'xattrs_enabled', True)
else:
log_info("Using document storage for sync meta data")
persist_cluster_config_environment_prop(cluster_config, 'xattrs_enabled', False)
sg_config = sync_gateway_config_path_for_mode("listener_tests/listener_tests", sync_gateway_mode)
if not skip_provisioning:
log_info("Installing Sync Gateway + Couchbase Server + Accels ('di' only)")
cluster_utils = ClusterKeywords()
cluster_utils.provision_cluster(
cluster_config=cluster_config,
server_version=server_version,
sync_gateway_version=sync_gateway_version,
sync_gateway_config=sg_config
)
# Wait at the yeild until tests referencing this suite setup have run,
# Then execute the teardown
yield {
"liteserv": liteserv,
"cluster_config": cluster_config,
"sg_mode": sync_gateway_mode,
"xattrs_enabled": xattrs_enabled,
"device_enabled": device_enabled,
"liteserv_platform": liteserv_platform,
"liteserv_version": liteserv_version
}
log_info("Tearing down suite ...")
if not (device_enabled and liteserv_platform == "ios"):
liteserv.remove()
def params_from_base_suite_setup(request):
log_info("Setting up 'params_from_base_suite_setup' ...")
# pytest command line parameters
server_version = request.config.getoption("--server-version")
sync_gateway_version = request.config.getoption("--sync-gateway-version")
mode = request.config.getoption("--mode")
use_sequoia = request.config.getoption("--sequoia")
skip_provisioning = request.config.getoption("--skip-provisioning")
cbs_ssl = request.config.getoption("--server-ssl")
xattrs_enabled = request.config.getoption("--xattrs")
server_seed_docs = request.config.getoption("--server-seed-docs")
max_docs = request.config.getoption("--max-docs")
num_users = request.config.getoption("--num-users")
create_batch_size = request.config.getoption("--create-batch-size")
create_delay = request.config.getoption("--create-delay")
update_runtime_sec = request.config.getoption("--update-runtime-sec")
update_batch_size = request.config.getoption("--update-batch-size")
update_docs_percentage = request.config.getoption(
"--update-docs-percentage")
update_delay = request.config.getoption("--update-delay")
changes_delay = request.config.getoption("--changes-delay")
changes_limit = request.config.getoption("--changes-limit")
if xattrs_enabled and version_is_binary(sync_gateway_version):
check_xattr_support(server_version, sync_gateway_version)
log_info("server_version: {}".format(server_version))
log_info("sync_gateway_version: {}".format(sync_gateway_version))
log_info("mode: {}".format(mode))
log_info("skip_provisioning: {}".format(skip_provisioning))
log_info("cbs_ssl: {}".format(cbs_ssl))
log_info("xattrs_enabled: {}".format(xattrs_enabled))
# Make sure mode for sync_gateway is supported ('cc' or 'di')
validate_sync_gateway_mode(mode)
# use ci_lb_cc cluster config if mode is "cc" or ci_lb_di cluster config if more is "di"
log_info("Using 'ci_lb_{}' config!".format(mode))
cluster_config = "{}/ci_lb_{}".format(CLUSTER_CONFIGS_DIR, mode)
try:
server_version
except NameError:
log_info("Server version is not provided")
persist_cluster_config_environment_prop(cluster_config,
'server_version', "")
else:
log_info("Running test with server version {}".format(server_version))
persist_cluster_config_environment_prop(cluster_config,
'server_version',
server_version)
try:
sync_gateway_version
except NameError:
log_info("Sync gateway version is not provided")
persist_cluster_config_environment_prop(cluster_config,
'sync_gateway_version', "")
else:
log_info("Running test with sync_gateway version {}".format(
sync_gateway_version))
persist_cluster_config_environment_prop(cluster_config,
'sync_gateway_version',
sync_gateway_version)
# Only works with load balancer configs
persist_cluster_config_environment_prop(cluster_config, 'sg_lb_enabled',
True)
if cbs_ssl:
log_info("Running tests with cbs <-> sg ssl enabled")
# Enable ssl in cluster configs
persist_cluster_config_environment_prop(cluster_config,
'cbs_ssl_enabled', True)
else:
log_info("Running tests with cbs <-> sg ssl disabled")
# Disable ssl in cluster configs
persist_cluster_config_environment_prop(cluster_config,
'cbs_ssl_enabled', False)
if xattrs_enabled:
log_info("Running test with xattrs for sync meta storage")
persist_cluster_config_environment_prop(cluster_config,
'xattrs_enabled', True)
else:
log_info("Using document storage for sync meta data")
persist_cluster_config_environment_prop(cluster_config,
'xattrs_enabled', False)
sg_config = sync_gateway_config_path_for_mode(
"sync_gateway_default_functional_tests", mode)
# Skip provisioning if user specifies '--skip-provisoning' or '--sequoia'
should_provision = True
if skip_provisioning or use_sequoia:
should_provision = False
cluster_utils = ClusterKeywords()
if should_provision:
try:
cluster_utils.provision_cluster(
cluster_config=cluster_config,
server_version=server_version,
sync_gateway_version=sync_gateway_version,
sync_gateway_config=sg_config)
except ProvisioningError:
logging_helper = Logging()
logging_helper.fetch_and_analyze_logs(
cluster_config=cluster_config, test_name=request.node.name)
raise
# Hit this intalled running services to verify the correct versions are installed
cluster_utils.verify_cluster_versions(
cluster_config,
expected_server_version=server_version,
expected_sync_gateway_version=sync_gateway_version)
# Load topology as a dictionary
cluster_topology = cluster_utils.get_cluster_topology(cluster_config)
yield {
"cluster_config": cluster_config,
"cluster_topology": cluster_topology,
"mode": mode,
"xattrs_enabled": xattrs_enabled,
"server_seed_docs": server_seed_docs,
"max_docs": max_docs,
"num_users": num_users,
"create_batch_size": create_batch_size,
"create_delay": create_delay,
"update_runtime_sec": update_runtime_sec,
"update_batch_size": update_batch_size,
"update_docs_percentage": update_docs_percentage,
"update_delay": update_delay,
"changes_delay": changes_delay,
"changes_limit": changes_limit
}
log_info("Tearing down 'params_from_base_suite_setup' ...")
def params_from_base_suite_setup(request):
log_info("Setting up 'params_from_base_suite_setup' ...")
# pytest command line parameters
server_version = request.config.getoption("--server-version")
sync_gateway_version = request.config.getoption("--sync-gateway-version")
server_upgraded_version = request.config.getoption(
"--server-upgraded-version")
sync_gateway_upgraded_version = request.config.getoption(
"--sync-gateway-upgraded-version")
mode = request.config.getoption("--mode")
cluster_config = request.config.getoption("--cluster-config")
# use_sequoia = request.config.getoption("--sequoia")
skip_provisioning = request.config.getoption("--skip-provisioning")
cbs_ssl = request.config.getoption("--server-ssl")
xattrs_enabled = request.config.getoption("--xattrs")
liteserv_host = request.config.getoption("--liteserv-host")
liteserv_port = request.config.getoption("--liteserv-port")
liteserv_version = request.config.getoption("--liteserv-version")
liteserv_platform = request.config.getoption("--liteserv-platform")
liteserv_storage_engine = request.config.getoption(
"--liteserv-storage-engine")
num_docs = request.config.getoption("--num-docs")
cbs_platform = request.config.getoption("--cbs-platform")
cbs_toy_build = request.config.getoption("--cbs-upgrade-toybuild")
if xattrs_enabled and version_is_binary(sync_gateway_version):
check_xattr_support(server_upgraded_version,
sync_gateway_upgraded_version)
log_info("server_version: {}".format(server_version))
log_info("sync_gateway_version: {}".format(sync_gateway_version))
log_info("server_upgraded_version: {}".format(server_upgraded_version))
log_info("sync_gateway_upgraded_version: {}".format(
sync_gateway_upgraded_version))
log_info("mode: {}".format(mode))
log_info("skip_provisioning: {}".format(skip_provisioning))
log_info("cbs_ssl: {}".format(cbs_ssl))
log_info("xattrs_enabled: {}".format(xattrs_enabled))
log_info("liteserv_host: {}".format(liteserv_host))
log_info("liteserv_port: {}".format(liteserv_port))
log_info("liteserv_version: {}".format(liteserv_version))
log_info("liteserv_platform: {}".format(liteserv_platform))
log_info("liteserv_storage_engine: {}".format(liteserv_storage_engine))
log_info("num_docs: {}".format(num_docs))
log_info("cbs_platform: {}".format(cbs_platform))
log_info("cbs_toy_build: {}".format(cbs_toy_build))
# Make sure mode for sync_gateway is supported ('cc' or 'di')
validate_sync_gateway_mode(mode)
# use ci_lb_cc cluster config if mode is "cc" or ci_lb_di cluster config if more is "di"
# use base_(lb_)cc cluster config if mode is "cc" or base_(lb_)di cluster config if mode is "di"
cluster_config = "{}/{}_{}".format(CLUSTER_CONFIGS_DIR, cluster_config,
mode)
log_info("Using '{}' config!".format(cluster_config))
try:
server_version
except NameError:
log_info("Server version is not provided")
persist_cluster_config_environment_prop(cluster_config,
'server_version', "")
else:
log_info("Running test with server version {}".format(server_version))
persist_cluster_config_environment_prop(cluster_config,
'server_version',
server_version)
try:
sync_gateway_version
except NameError:
log_info("Sync gateway version is not provided")
persist_cluster_config_environment_prop(cluster_config,
'sync_gateway_version', "")
else:
log_info("Running test with sync_gateway version {}".format(
sync_gateway_version))
persist_cluster_config_environment_prop(cluster_config,
'sync_gateway_version',
sync_gateway_version)
# Only works with load balancer configs
persist_cluster_config_environment_prop(cluster_config, 'sg_lb_enabled',
True)
if cbs_ssl:
log_info("Running tests with cbs <-> sg ssl enabled")
# Enable ssl in cluster configs
persist_cluster_config_environment_prop(cluster_config,
'cbs_ssl_enabled', True)
else:
log_info("Running tests with cbs <-> sg ssl disabled")
# Disable ssl in cluster configs
persist_cluster_config_environment_prop(cluster_config,
'cbs_ssl_enabled', False)
sg_config = sync_gateway_config_path_for_mode(
"sync_gateway_default_functional_tests", mode)
liteserv = LiteServFactory.create(platform=liteserv_platform,
version_build=liteserv_version,
host=liteserv_host,
port=liteserv_port,
storage_engine=liteserv_storage_engine)
log_info("Downloading LiteServ ...")
# Download LiteServ
liteserv.download()
# Install LiteServ
liteserv.install()
# Skip provisioning if user specifies '--skip-provisoning' or '--sequoia'
should_provision = True
if skip_provisioning:
should_provision = False
cluster_utils = ClusterKeywords()
if should_provision:
try:
cluster_utils.provision_cluster(
cluster_config=cluster_config,
server_version=server_version,
sync_gateway_version=sync_gateway_version,
sync_gateway_config=sg_config,
cbs_platform=cbs_platform)
except ProvisioningError:
logging_helper = Logging()
logging_helper.fetch_and_analyze_logs(
cluster_config=cluster_config, test_name=request.node.name)
raise
# Hit this intalled running services to verify the correct versions are installed
cluster_utils.verify_cluster_versions(
cluster_config,
expected_server_version=server_version,
expected_sync_gateway_version=sync_gateway_version)
# Load topology as a dictionary
cluster_topology = cluster_utils.get_cluster_topology(cluster_config)
yield {
"cluster_config": cluster_config,
"cluster_topology": cluster_topology,
"mode": mode,
"xattrs_enabled": xattrs_enabled,
"server_version": server_version,
"sync_gateway_version": sync_gateway_version,
"server_upgraded_version": server_upgraded_version,
"sync_gateway_upgraded_version": sync_gateway_upgraded_version,
"liteserv_host": liteserv_host,
"liteserv_port": liteserv_port,
"liteserv_version": liteserv_version,
"liteserv_platform": liteserv_platform,
"liteserv_storage_engine": liteserv_storage_engine,
"liteserv": liteserv,
"num_docs": num_docs,
"cbs_platform": cbs_platform,
"cbs_toy_build": cbs_toy_build
}
log_info("Tearing down 'params_from_base_suite_setup' ...")