def test_changed_variable_type(sdk_client_fs: ADCMClient):
"""Change config variable type for upgrade
:param sdk_client_fs:
:return:
"""
with allure.step(
'Create upgradable hostprovider with change variable type'):
bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'hostprovider'))
sdk_client_fs.upload_from_fs(
get_data_dir(__file__,
'upgradable_hostprovider_change_variable_type'))
hostprovider = bundle.provider_create("test")
host = create_host(hostprovider)
hostprovider_config_before = hostprovider.config()
host_config_before = host.config()
with allure.step(
'Upgrade hostprovider with changed config variable type for upgrade'
):
upgr = hostprovider.upgrade(name='upgrade to 2.0')
upgr.do()
with allure.step('Check changed config variable type'):
hostprovider.reread()
host.reread()
hostprovider_config_after = hostprovider.config()
host_config_after = host.config()
assert isinstance(hostprovider_config_after['required'], str)
assert isinstance(hostprovider_config_after['int_key'], str)
assert isinstance(host_config_after['str_param'], int)
assert int(hostprovider_config_after['required']
) == hostprovider_config_before['required']
assert host_config_after['str_param'] == int(
host_config_before['str_param'])
def test_decrase_config(sdk_client_fs: ADCMClient):
"""Upgrade cluster with config without old values in config. Deleted lines not presented
"""
with allure.step('Create upgradable hostprovider with decrase variables'):
bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'hostprovider'))
sdk_client_fs.upload_from_fs(
get_data_dir(__file__,
'upgradable_hostprovider_decrase_variables'))
hostprovider = bundle.provider_create("test")
host = create_host(hostprovider)
hostprovider_config_before = hostprovider.config()
host_config_before = host.config()
with allure.step(
'Upgrade hostprovider with config without old values in config'):
upgr = hostprovider.upgrade(name='upgrade to 2.0')
upgr.do()
with allure.step('Check that deleted lines not presented'):
hostprovider.reread()
host.reread()
hostprovider_config_after = hostprovider.config()
host_config_after = host.config()
assert len(hostprovider_config_after.keys()) == 1
assert len(host_config_after.keys()) == 1
for key in hostprovider_config_after:
assert hostprovider_config_before[
key] == hostprovider_config_after[key]
for key in host_config_after:
assert host_config_before[key] == host_config_after[key]
def test_delete_service_with_host(sdk_client_fs: ADCMClient):
"""Check that it is possible to delete service with host component binded to cluster
And HC map is automatically updated after service deletion"""
hostprovider_bundle = sdk_client_fs.upload_from_fs(
utils.get_data_dir(__file__, 'cluster_service_hostcomponent', 'hostprovider')
)
provider = hostprovider_bundle.provider_create("test")
host_1 = provider.host_create("test_host_1")
host_2 = provider.host_create("test_host_2")
bundle = sdk_client_fs.upload_from_fs(utils.get_data_dir(__file__, 'cluster_service_hostcomponent', 'cluster'))
cluster = bundle.cluster_create("test")
service_1 = cluster.service_add(name="zookeeper")
service_2 = cluster.service_add(name="second_service")
cluster.host_add(host_1)
cluster.host_add(host_2)
component_1 = service_1.component(name="ZOOKEEPER_SERVER")
component_2 = service_2.component(name="some_component")
cluster.hostcomponent_set((host_1, component_1), (host_2, component_1), (host_2, component_2))
assert len(cluster.service_list()) == 2, "It should be 2 services"
assert len(cluster.hostcomponent()) == 3, "HC map should contain 3 mappings"
task = service_1.action(name='remove_service').run()
task.wait()
with allure.step("Check that service has been deleted and HC map was cleaned"):
assert task.status == 'success', f"Current job status {task.status}. Expected: success"
assert len(cluster.service_list()) == 1, "It should be 1 service"
assert cluster.service_list()[0].name == "second_service", "It should be only second service left"
assert len(cluster.hostcomponent()) == 1, "HC map should contain 1 mapping"
with allure.step("Check that there is no issues on objects"):
cluster.reread()
assert not cluster.concerns(), "It should be no concerns on cluster"
host_1.reread()
assert not host_1.concerns(), "It should be no concerns on host"
host_2.reread()
assert not host_2.concerns(), "It should be no concerns on host"
def test_check_config(sdk_client_fs: ADCMClient):
"""Check default host and hostprovider config fields after upgrade
:return:
"""
with allure.step('Create hostprovider'):
bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'hostprovider'))
sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgradable_hostprovider'))
hostprovider = bundle.provider_create("test")
with allure.step('Create default host'):
host = hostprovider.host_create(fqdn="localhost")
hostprovider_config_before = hostprovider.config()
host_config_before = host.config()
with allure.step('Upgrade hostprovider with host to 2.0'):
upgr = hostprovider.upgrade(name='upgrade to 2.0')
upgr.do()
with allure.step(
'Check default host and hostprovider config fields after upgrade'):
hostprovider.reread()
host.reread()
hostprovider_config_after = hostprovider.config()
host_config_after = host.config()
assert hostprovider.prototype().version == '2.0'
assert host.prototype().version == '00.10'
for variable in hostprovider_config_before:
assert hostprovider_config_before[
variable] == hostprovider_config_after[variable]
for variable in host_config_before:
assert host_config_before[variable] == host_config_after[variable]
def old_cluster(self, sdk_client_fs) -> Cluster: # pylint: disable=no-self-use
"""Upload old and new version of cluster, create old one"""
old_bundle = sdk_client_fs.upload_from_fs(
utils.get_data_dir(__file__, "upgrade", "old"))
sdk_client_fs.upload_from_fs(
utils.get_data_dir(__file__, "upgrade", "new"))
return old_bundle.cluster_create(name="Test Cluster")
def test_full_upgrade_cluster_first(sdk_client_fs: ADCMClient):
"""Create cluster and hostprovider with host and components
and upgrade cluster and host with provider after that
and check that all was upgraded.
"""
bundle = sdk_client_fs.upload_from_fs(get_data_dir(__file__, 'cluster'))
sdk_client_fs.upload_from_fs(get_data_dir(__file__, 'upgradable_cluster'))
cluster = bundle.cluster_create("test")
service = cluster.service_add(name="zookeeper")
comp = service.component(name='master')
hp_bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'hostprovider'))
sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgradable_hostprovider'))
hostprovider = hp_bundle.provider_create("test")
host = hostprovider.host_create(fqdn="localhost")
cluster.host_add(host)
cluster.hostcomponent_set((host, comp))
upgr_cl = cluster.upgrade(name='upgrade to 1.6')
upgr_cl.do()
upgr_hp = hostprovider.upgrade(name='upgrade to 2.0')
upgr_hp.do()
cluster.reread()
service.reread()
hostprovider.reread()
host.reread()
with allure.step(
'Check cluster, service, hostprovider, host were upgraded'):
assert cluster.prototype().version == '1.6'
assert service.prototype().version == '3.4.11'
assert hostprovider.prototype().version == '2.0'
assert host.prototype().version == '00.10'
def test_change_config(sdk_client_fs: ADCMClient):
"""Upgrade cluster with other config
"""
with allure.step('Create upgradable cluster with new change values'):
bundle = sdk_client_fs.upload_from_fs(get_data_dir(
__file__, 'cluster'))
sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgradable_cluster_new_change_values'))
cluster = bundle.cluster_create("test")
service = cluster.service_add(name="zookeeper")
with allure.step('Set cluster and service config'):
cluster_config_before = cluster.config()
service_config_before = service.config()
cluster_config_before['required'] = 25
cluster_config_before['int_key'] = 245
cluster_config_before['str-key'] = "new_value"
service_config_before['required_service'] = 20
service_config_before['int_key_service'] = 333
cluster.config_set(cluster_config_before)
service.config_set(service_config_before)
with allure.step('Upgrade cluster with new change values to 1.6'):
upgr = cluster.upgrade(name='upgrade to 1.6')
upgr.do()
with allure.step('Check upgraded cluster and service'):
cluster.reread()
service.reread()
cluster_config_after = cluster.config()
service_config_after = service.config()
assert len(cluster_config_before.keys()) == len(
cluster_config_after.keys())
for key in cluster_config_before:
assert cluster_config_before[key] == cluster_config_after[key]
for key in service_config_before:
assert service_config_before[key] == service_config_after[key]
def test_changed_variable_type(sdk_client_fs: ADCMClient):
"""Change config variable type for upgrade
:param sdk_client_fs:
:return:
"""
with allure.step('Create upgradable cluster with change variable type'):
bundle = sdk_client_fs.upload_from_fs(get_data_dir(
__file__, 'cluster'))
sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgradable_cluster_change_variable_type'))
cluster = bundle.cluster_create("test")
service = cluster.service_add(name="zookeeper")
cluster_config_before = cluster.config()
service_config_before = service.config()
with allure.step('Upgrade cluster with change variable type to 1.6'):
upgr = cluster.upgrade(name='upgrade to 1.6')
upgr.do()
with allure.step('Check changed variable type'):
cluster.reread()
service.reread()
cluster_config_after = cluster.config()
service_config_after = service.config()
assert isinstance(cluster_config_after['required'], str)
assert isinstance(service_config_after['required_service'], str)
assert int(cluster_config_after['required']
) == cluster_config_before['required']
assert int(service_config_after['required_service']
) == service_config_before['required_service']
def test_upgrade_with_two_clusters(sdk_client_fs: ADCMClient):
"""Upgrade cluster when we have two created clusters from one bundle
Scenario:
1. Create two clusters from one bundle
2. Upload upgradable bundle
3. Upgrade first cluster
4. Check that only first cluster was upgraded
"""
with allure.step('Create two clusters from one bundle'):
bundle = sdk_client_fs.upload_from_fs(get_data_dir(
__file__, 'cluster'))
sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgradable_cluster'))
cluster_first = bundle.cluster_create("test")
cluster_second = bundle.cluster_create("test2")
service = cluster_first.service_add(name="zookeeper")
with allure.step('Upgrade first cluster'):
upgr_cl = cluster_first.upgrade(name='upgrade to 1.6')
upgr_cl.do()
with allure.step('Check that only first cluster was upgraded'):
cluster_first.reread()
service.reread()
cluster_second.reread()
assert cluster_first.prototype().version == '1.6'
assert service.prototype().version == '3.4.11'
assert cluster_second.prototype().version == '1.5'
def test_with_new_default_variables(sdk_client_fs: ADCMClient):
"""Upgrade cluster with new default fields. Old and new config variables should be presented
:return:
"""
with allure.step('Create upgradable cluster new default variables'):
bundle = sdk_client_fs.upload_from_fs(get_data_dir(
__file__, 'cluster'))
upgr_bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgradable_cluster_new_default_variables'))
upgr_cluster_prototype = upgr_bundle.cluster_prototype().config
upgr_service_prototype = upgr_bundle.service_prototype().config
cluster = bundle.cluster_create("test")
service = cluster.service_add(name="zookeeper")
with allure.step('Upgrade cluster with new default variables to 1.6'):
upgr = cluster.upgrade(name='upgrade to 1.6')
upgr.do()
with allure.step('Check old and new config'):
cluster.reread()
service.reread()
cluster_config_after = cluster.config()
service_config_after = service.config()
for variable in upgr_cluster_prototype:
assert variable['name'] in cluster_config_after.keys()
for variable in upgr_service_prototype:
assert variable['name'] in service_config_after.keys()
def test_check_config(sdk_client_fs: ADCMClient):
"""Check default service and cluster config fields after upgrade
:return:
"""
with allure.step('Create upgradable cluster'):
bundle = sdk_client_fs.upload_from_fs(get_data_dir(
__file__, 'cluster'))
sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgradable_cluster'))
cluster = bundle.cluster_create("test")
service = cluster.service_add(name="zookeeper")
cluster_config_before = cluster.config()
service_config_before = service.config()
with allure.step('Upgrade cluster to 1.6'):
upgr = cluster.upgrade(name='upgrade to 1.6')
upgr.do()
with allure.step('Check config'):
cluster.reread()
service.reread()
cluster_config_after = cluster.config()
service_config_after = service.config()
assert cluster.prototype().version == '1.6'
assert service.prototype().version == '3.4.11'
for variable in cluster_config_before:
assert cluster_config_before[variable] == cluster_config_after[
variable]
for variable in service_config_before:
assert service_config_before[variable] == service_config_after[
variable]
def test_incorrect_import_version(sdk_client_fs: ADCMClient, path):
"""Upgrade cluster with service incorrect version
Scenario:
1. Create cluster for upgrade with exports
2. Create upgradable cluster with import and incorrect version
3. Create service
4. Import service from cluster with export to cluster from step 2 (with import)
5. Upgrade cluster from step 1
6. Check that cluster was not upgraded because incorrect version for service
in cluster with import
"""
with allure.step(
'Create cluster for upgrade with exports and cluster with correct import'
):
bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgrade_cluster_with_export'))
sdk_client_fs.upload_from_fs(path)
bundle_import_correct = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'cluster_with_correct_import'))
cluster = bundle.cluster_create("test")
service = cluster.service_add(name="hadoop")
cluster_import = bundle_import_correct.cluster_create("cluster_import")
bind_service_and_cluster(cluster_import, service, cluster)
with allure.step('Upgrade cluster with import to 1.6 with error'):
upgr = cluster_import.upgrade(name='upgrade to 1.6')
with pytest.raises(coreapi.exceptions.ErrorMessage) as e:
upgr.do()
with allure.step('Check that cluster was not upgraded'):
err.UPGRADE_ERROR.equal(e)
def test_upgrade_cluster_with_config_groups(sdk_client_fs):
"""Test upgrade cluster config groups"""
with allure.step('Create cluster with different groups on config'):
bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'cluster_with_groups'))
sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgradable_cluster_with_groups'))
cluster = bundle.cluster_create("test")
service = cluster.service_add(name="zookeeper")
with allure.step('Upgrade cluster with new change values to 1.6'):
upgrade = cluster.upgrade(name='upgrade to 1.6')
upgrade.do()
with allure.step('Assert that configs save success after upgrade'):
cluster.config_set({
**cluster.config(),
"activatable_group_with_ro": {
"readonly-key": "value"
},
"activatable_group": {
"required": 10,
"writable-key": "value"
},
})
service.config_set({
**cluster.config(),
"activatable_group_with_ro": {
"readonly-key": "value"
},
"activatable_group": {
"required": 10,
"writable-key": "value"
},
})
def test_upgrade_cluster_with_new_configuration_variables(
sdk_client_fs: ADCMClient):
"""Upgrade to cluster with new configuration variables"""
with allure.step(
'Create cluster for upgrade with exports and cluster with import new config vars'
):
bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgrade_cluster_with_export'))
bundle_import = sdk_client_fs.upload_from_fs(
get_data_dir(__file__,
'upgradable_cluster_with_import_new_config_vars'))
cluster = bundle.cluster_create("test")
service = cluster.service_add(name="hadoop")
cluster_config_before = cluster.config()
service_config_before = service.config()
cluster_import = bundle_import.cluster_create("cluster_import")
bind_service_and_cluster(cluster_import, service, cluster)
with allure.step('Upgrade cluster with export'):
upgr = cluster.upgrade(name='upgrade to 1.6')
upgr.do()
with allure.step('Check upgraded cluster'):
cluster.reread()
service.reread()
cluster_config_after = cluster.config()
service_config_after = service.config()
assert cluster.prototype().version == '1.6'
assert service.prototype().version == '2.2'
assert len(cluster_config_after) == 4, cluster_config_after
assert len(service_config_after) == 3, service_config_after
for variable in cluster_config_before:
assert cluster_config_before[variable] == cluster_config_after[
variable]
for variable in service_config_before:
assert service_config_before[variable] == service_config_after[
variable]
def test_upgrade_cluster_without_service_config_in_import(
sdk_client_fs: ADCMClient):
"""Upgrade cluster with service when in new cluster when
we haven't some service configuration variables
Scenario:
1. Create cluster for upgrade with export
2. Create upgradable cluster with import and without config in import
3. Bind service from cluster with export to cluster with import
4. Upgrade cluster with export
5. Check upgrade error
"""
with allure.step(
'Create cluster for upgrade with exports and cluster without config in import'
):
bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgrade_cluster_with_export'))
bundle_import = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgradable_cluster_without_service'))
cluster = bundle.cluster_create("test")
service = cluster.service_add(name="hadoop")
cluster_import = bundle_import.cluster_create("cluster_import")
with allure.step(
'Bind service from cluster with export to cluster with import'):
cluster_import.bind(service)
cluster_import.bind(cluster)
with allure.step('Upgrade cluster with export'):
upgr = cluster.upgrade(name='upgrade to 1.6')
with pytest.raises(coreapi.exceptions.ErrorMessage) as e:
upgr.do()
with allure.step('Check upgrade error'):
err.UPGRADE_ERROR.equal(e)
def test_upgrade_cluster_with_export(sdk_client_fs: ADCMClient):
"""Scenario:
1. Create cluster for upgrade with export
2. Create cluster for upgrade with import
3. Load upgradable bundle with import
4. Bind service and cluster
5. Upgrade cluster with import
6. Check that cluster was upgraded
"""
with allure.step('Create cluster for upgrade with exports'):
bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'cluster_with_export'))
cluster = bundle.cluster_create("test")
service = cluster.service_add(name="hadoop")
with allure.step(
'Create cluster for upgrade with imports. Load upgradable bundle with import'
):
bundle_import = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgrade_cluster_with_import'))
sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgradable_cluster_with_import'))
cluster_import = bundle_import.cluster_create("cluster_import")
bind_service_and_cluster(cluster_import, service, cluster)
with allure.step('Upgrade cluster with import to 1.6'):
upgr = cluster_import.upgrade(name='upgrade to 1.6')
id_before = cluster_import.prototype_id
upgr.do()
with allure.step('Check that cluster was upgraded'):
cluster_import.reread()
assert cluster_import.prototype().version == '1.6'
assert cluster_import.prototype_id != id_before
def test_check_prototype(sdk_client_fs: ADCMClient):
"""Check prototype for provider and host after upgrade"""
with allure.step('Create upgradable hostprovider and get id'):
bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'hostprovider'))
sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgradable_hostprovider'))
hostprovider = bundle.provider_create("test")
host = hostprovider.host_create(fqdn="localhost")
hostprovider_proto_before = hostprovider.prototype()
hp_id_before = hostprovider.id
host_proto_before = host.prototype()
ht_id_before = host.id
with allure.step('Upgrade hostprovider to 2.0'):
upgr = hostprovider.upgrade(name='upgrade to 2.0')
upgr.do()
with allure.step('Check prototype for provider and host after upgrade'):
hostprovider.reread()
host.reread()
hostprovider_proto_after = hostprovider.prototype()
host_proto_after = host.prototype()
assert hp_id_before == hostprovider.id
assert ht_id_before == host.id
assert hostprovider_proto_before.id != hostprovider_proto_after.id
assert host_proto_before.id != host_proto_after.id
def test_change_config(sdk_client_fs: ADCMClient):
"""Upgrade hostprovider with other config"""
with allure.step('Create upgradable hostprovider with new change values'):
bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'hostprovider'))
sdk_client_fs.upload_from_fs(
get_data_dir(__file__,
'upgradable_hostprovider_new_change_values'))
hostprovider = bundle.provider_create("test")
host = create_host(hostprovider)
hostprovider_config_before = hostprovider.config()
host_config_before = host.config()
hostprovider_config_before['required'] = 25
hostprovider_config_before['str-key'] = "new_value"
host_config_before['str_param'] = "str_param_new"
with allure.step('Set config'):
hostprovider.config_set(hostprovider_config_before)
host.config_set(host_config_before)
with allure.step('Upgrade hostprovider with other config'):
upgr = hostprovider.upgrade(name='upgrade to 2.0')
upgr.do()
with allure.step('Check hostprovider config'):
hostprovider.reread()
host.reread()
hostprovider_config_after = hostprovider.config()
host_config_after = host.config()
assert len(hostprovider_config_before.keys()) == len(
hostprovider_config_after.keys())
for key in hostprovider_config_before:
assert hostprovider_config_before[
key] == hostprovider_config_after[key]
for key in host_config_before:
assert host_config_before[key] == host_config_after[key]
def test_upgrade_provider_with_group_configs(self, sdk_client_fs,
bundle_name,
update_func: Callable):
"""
Test upgrade provider with group configs enabled
- Upload provider bundle
- Create provider
- Create group config for provider
- Update provider to the new version with new parameter/default value or removed parameter in config
- Assert that new parameter/default value or removed parameter is presented/absent in group config
"""
with allure.step("Upload provider bundle"):
provider_bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, "provider_with_group_configs"))
with allure.step("Create provider"):
provider = provider_bundle.provider_create("test")
with allure.step("Create group config for provider"):
provider_group_config = provider.group_config_create(
name="provider_config_group")
provider_gc_ref_config_and_attr = _get_config_and_attr(
provider_group_config)
with allure.step(
"Upgrade provider to new version with new fields in config"):
sdk_client_fs.upload_from_fs(get_data_dir(__file__, bundle_name))
upgrade = provider.upgrade(name="upgrade to 1.6")
upgrade.do()
with allure.step("Assert that group configs have been updated"):
self._update_and_assert_config(
update_func=update_func,
ref_config_and_attr=provider_gc_ref_config_and_attr,
group_config=provider_group_config,
)
def test_check_prototype(sdk_client_fs: ADCMClient):
"""Check prototype for service and cluster after upgrade
:param sdk_client_fs:
:return:
"""
with allure.step('Create test cluster'):
bundle = sdk_client_fs.upload_from_fs(get_data_dir(
__file__, 'cluster'))
sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgradable_cluster'))
cluster = bundle.cluster_create("test")
cl_id_before = cluster.id
service = cluster.service_add(name="zookeeper")
serv_id_before = service.id
cluster_proto_before = cluster.prototype()
service_proto_before = service.prototype()
with allure.step('Upgrade test cluster to 1.6'):
upgr = cluster.upgrade(name='upgrade to 1.6')
upgr.do()
with allure.step('Check prototype'):
cluster.reread()
service.reread()
cluster_proto_after = cluster.prototype()
service_proto_after = service.prototype()
assert cl_id_before == cluster.id
assert serv_id_before == service.id
assert cluster_proto_before.id != cluster_proto_after.id
assert service_proto_before.id != service_proto_after.id
def test_decrase_config(sdk_client_fs: ADCMClient):
"""Upgrade cluster with config without old values in config. Deleted lines not presented
"""
with allure.step('Create upgradable cluster with decrase variables'):
bundle = sdk_client_fs.upload_from_fs(get_data_dir(
__file__, 'cluster'))
sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'upgradable_cluster_decrase_variables'))
cluster = bundle.cluster_create("test")
service = cluster.service_add(name="zookeeper")
cluster_config_before = cluster.config()
service_config_before = service.config()
with allure.step(
'Upgrade cluster with config without old values in config to 1.6'):
upgr = cluster.upgrade(name='upgrade to 1.6')
upgr.do()
with allure.step('Check that deleted lines not presented'):
cluster.reread()
service.reread()
cluster_config_after = cluster.config()
service_config_after = service.config()
assert len(cluster_config_after.keys()) == 1
assert len(service_config_after.keys()) == 1
for key in cluster_config_after:
assert cluster_config_before[key] == cluster_config_after[key]
for key in service_config_after:
assert service_config_before[key] == service_config_after[key]
def test_delete_host(sdk_client_fs: ADCMClient):
"""If host has NO component, than we can simple remove it from cluster."""
hostprovider_bundle = sdk_client_fs.upload_from_fs(get_data_dir(__file__, 'hostprovider'))
provider = hostprovider_bundle.provider_create("test")
host = provider.host_create("test_host")
bundle = sdk_client_fs.upload_from_fs(get_data_dir(__file__, 'cluster_bundle'))
cluster = bundle.cluster_create("test")
cluster.service_add(name="zookeeper")
cluster.host_add(host)
cluster.host_delete(host)
def cluster(sdk_client_fs: ADCMClient):
bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'cluster_export'))
bundle_import = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'cluster_import'))
cluster = bundle.cluster_create("test")
cluster_import = bundle_import.cluster_create("cluster_import")
service = cluster.service_add(name="hadoop")
cluster_import.bind(service)
return service
def test_upgrade_cluster_without_old_config(sdk_client_fs: ADCMClient):
"""Test upgrade cluster without old config"""
bundle = sdk_client_fs.upload_from_fs(utils.get_data_dir(__file__, 'cluster_without_old_config', 'old'))
cluster = bundle.cluster_create(utils.random_string())
sdk_client_fs.upload_from_fs(utils.get_data_dir(__file__, 'cluster_without_old_config', 'upgrade'))
upgrade = cluster.upgrade()
upgrade.do()
cluster.reread()
with allure.step('Check if version is 2-config'):
assert cluster.prototype().version == '2-config'
def test_upgrade_cluster_with_group_configs(self, sdk_client_fs,
bundle_name,
update_func: Callable):
"""
Test upgrade cluster with group configs enabled
- Upload cluster bundle
- Create cluster and add service
- Create group configs for cluster, service, and component
- Update cluster to the new version with new parameter/default value or removed parameter in config
- Assert that new parameter/default value or removed parameter is presented/absent in all group configs
"""
with allure.step("Upload cluster bundle"):
cluster_bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, "cluster_with_group_configs"))
with allure.step("Create cluster and add service"):
cluster = cluster_bundle.cluster_create("test")
service = cluster.service_add(name="test_service")
component = service.component(name="test_component")
with allure.step(
"Create group configs for cluster, service, and component"):
cluster_group_config = cluster.group_config_create(
name="cluster_config_group")
cluster_gc_ref_config_and_attr = _get_config_and_attr(
cluster_group_config)
service_group_config = service.group_config_create(
name="service_config_group")
service_gc_ref_config_and_attr = _get_config_and_attr(
service_group_config)
component_group_config = component.group_config_create(
name="component_config_group")
component_gc_ref_config_and_attr = _get_config_and_attr(
component_group_config)
with allure.step(
"Upgrade cluster to new version with new fields in config"):
sdk_client_fs.upload_from_fs(get_data_dir(__file__, bundle_name))
upgrade = cluster.upgrade(name="upgrade to 1.6")
upgrade.do()
with allure.step("Assert that group configs have been updated"):
self._update_and_assert_config(
update_func=update_func,
ref_config_and_attr=cluster_gc_ref_config_and_attr,
group_config=cluster_group_config,
)
self._update_and_assert_config(
update_func=update_func,
ref_config_and_attr=service_gc_ref_config_and_attr,
group_config=service_group_config,
)
self._update_and_assert_config(
update_func=update_func,
ref_config_and_attr=component_gc_ref_config_and_attr,
group_config=component_group_config,
)
def test_when_cluster_has_issue_than_upgrade_locked(sdk_client_fs: ADCMClient):
"""Test upgrade should not be run while cluster has an issue"""
with allure.step("Create cluster and upload new one bundle"):
old_bundle_path = utils.get_data_dir(__file__, "cluster")
new_bundle_path = utils.get_data_dir(__file__, "upgrade", "cluster")
old_bundle = sdk_client_fs.upload_from_fs(old_bundle_path)
cluster = old_bundle.cluster_create(name=utils.random_string())
sdk_client_fs.upload_from_fs(new_bundle_path)
with allure.step("Upgrade cluster"):
with pytest.raises(coreapi.exceptions.ErrorMessage) as e:
cluster.upgrade().do()
with allure.step("Check if cluster has issues"):
UPGRADE_ERROR.equal(e, "cluster ", " has blocking concerns ")
def cluster(sdk_client_fs: ADCMClient):
hostprovider_bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'hostprovider'))
provider = hostprovider_bundle.provider_create("test")
host = provider.host_create("test_host")
bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'cluster_bundle'))
cluster = bundle.cluster_create("test")
service = cluster.service_add(name="zookeeper")
cluster.host_add(host)
component = service.component(name="ZOOKEEPER_SERVER")
cluster.hostcomponent_set((host, component))
return cluster, host, service
def test_when_hostprovider_has_issue_than_upgrade_locked(client):
with allure.step('Create hostprovider'):
bundledir = utils.get_data_dir(__file__, "provider")
upgrade_bundle = utils.get_data_dir(__file__, "upgrade", "provider")
steps.upload_bundle(client, bundledir)
provider_id = steps.create_hostprovider(client)['id']
steps.upload_bundle(client, upgrade_bundle)
with allure.step('Upgrade provider'):
with pytest.raises(coreapi.exceptions.ErrorMessage) as e:
client.provider.upgrade.do.create(
provider_id=provider_id,
upgrade_id=client.provider.upgrade.list(provider_id=provider_id)[0]['id'])
with allure.step('Check if upgrade locked'):
UPGRADE_ERROR.equal(e)
def test_adding_host_to_cluster(self, sdk_client_fs: ADCMClient):
bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'cluster_simple'))
bundle_hp = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'hostprovider_bundle'))
cluster = bundle.cluster_create(utils.random_string())
hp = bundle_hp.provider_create(utils.random_string())
host = hp.host_create(utils.random_string())
actual = cluster.host_add(host)
with allure.step('Get cluster host info'):
expected = cluster.host_list()[0]
with allure.step('Check mapping'):
assert actual.fqdn == expected.fqdn
assert actual.id == expected.id
def test_host_along_to_cluster_shouldnt_deleted(self,
sdk_client_fs: ADCMClient):
bundle = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'cluster_simple'))
bundle_hp = sdk_client_fs.upload_from_fs(
get_data_dir(__file__, 'hostprovider_bundle'))
cluster = bundle.cluster_create(utils.random_string())
hp = bundle_hp.provider_create(utils.random_string())
host = hp.host_create(utils.random_string())
cluster.host_add(host)
with pytest.raises(coreapi.exceptions.ErrorMessage) as e:
host.delete()
with allure.step('Check error host belong to cluster'):
err.HOST_CONFLICT.equal(e, 'Host', 'belong to cluster')
