def check_access_to_actions_launch(objects):
"""Check that superuser can run actions"""
for obj in objects:
with catch_failed(
(AccessIsDenied, NoSuchEndpointOrAccessIsDenied),
f'Superuser should has right to run action on {get_object_represent(obj)}',
):
obj.action(name='no_config').run().wait()
def test_accept_license_with_two_bundles_upload_at_once(
create_bundle_archives: List[str], page: BundleListPage):
"""Upload two bundles and accept license"""
with page.table.wait_rows_change():
page.upload_bundles(create_bundle_archives)
with catch_failed(ElementClickInterceptedException,
"License was not accepted by single button click"):
page.accept_licence(row_num=1)
def action_in_object_is_present(action: str, obj: AnyADCMObject):
"""Assert action in object is present"""
with allure.step(
f"Assert that action {action} is present in {get_object_represent(obj)}"
):
with catch_failed(ObjectNotFound,
f"Action {action} not found in object {obj}"):
obj.action(name=action)
def test_load_should_fail_on_wrong_dsl(sdk_client_fs: ADCMClient, entity,
case):
"""Test bundle load should fail on wrong states dsl"""
with allure.step(f"Upload {entity} bundle with {case}"):
bundle_path = utils.get_data_dir(__file__, "states", entity, case)
with catch_failed(Failed, "Bundle was loaded but should fail to load"):
with pytest.raises(coreapi.exceptions.ErrorMessage) as e:
sdk_client_fs.upload_from_fs(bundle_path)
with allure.step("Assert that error message is correct"):
err.INVALID_OBJECT_DEFINITION.equal(e)
def action_in_object_is_absent(action: str, obj: AnyADCMObject):
"""Assert action in object is absent"""
with allure.step(
f"Assert that action {action} is absent in {get_object_represent(obj)}"
):
with catch_failed(
Failed,
f"Action {action} is present in {get_object_represent(obj)}"):
with pytest.raises(ObjectNotFound):
obj.action(name=action)
def check_before_upgrade_state_equal_to(self,
expected_state: Optional[str],
inventory: dict):
"""Check that `state` key in inventory dictionary is equal to expected"""
with utils.catch_failed(
KeyError, "Structure of inventory.json file is unexpected"):
actual_state = inventory["all"]["children"]["CLUSTER"]["vars"][
"cluster"]["before_upgrade"]["state"]
assert (
actual_state == expected_state
), f'Before upgrade state should be "{expected_state}", but actual state is "{actual_state}"'
def is_allowed(base_object: Union[BaseAPIObject, ADCMClient],
business_role: Union[BusinessRole,
BusinessRoles], *args, **kwargs):
"""
Assert that role is allowed on object
"""
role: BusinessRole = business_role.value if isinstance(
business_role, BusinessRoles) else business_role
with allure.step(
f"Assert that {role.role_name} on {get_object_represent(base_object)} is allowed"
), catch_failed(
(AccessIsDenied, NoSuchEndpointOrAccessIsDenied),
f"{role.role_name} on {get_object_represent(base_object)} should be allowed",
):
return role.method_call(base_object, *args, **kwargs)
def check_business_roles_children(
client: ADCMClient, prototype: Prototype, actions: List[dict],
actions_role_names: List[str]
) -> Tuple[Set[RoleShortInfo], Set[RoleShortInfo]]:
"""
Checks that "action" business roles have all newly created roles as its children.
:returns: hidden and business roles as ShortRoleInfo set
"""
hidden_roles = set()
business_roles = set()
for action_display_name, hidden_role_name in zip(
key_values_from('display_name', actions), actions_role_names):
business_role_name = f'{prototype.type.capitalize()} Action: {action_display_name}'
with allure.step(
f'Check role "{hidden_role_name}" is a child of "{business_role_name}"'
):
with catch_failed(
ObjectNotFound,
f'There should be a hidden role with name "{hidden_role_name}"'
):
hidden_role = client.role(name=hidden_role_name,
type=RoleType.HIDDEN.value)
with catch_failed(
ObjectNotFound,
f'There should be a business role with name "{business_role_name}"'
):
business_role = client.role(name=business_role_name,
type=RoleType.BUSINESS.value)
is_in_collection(
hidden_role.id,
(child.id for child in business_role.child_list()),
f"Role wasn't found in children of '{hidden_role.name}'",
)
hidden_roles.add(extract_role_short_info(hidden_role))
business_roles.add(extract_role_short_info(business_role))
return hidden_roles, business_roles
def test_load_should_fail_on_wrong_states(sdk_client_fs: ADCMClient, entity,
state, case):
"""Test bundle load should fail on wrong states syntax"""
with allure.step(f"Upload {entity} bundle with {case}"):
bundle_path = utils.get_data_dir(__file__, "states", entity, state,
case)
with catch_failed(Failed, "Bundle was loaded but should fail to load"):
with pytest.raises(coreapi.exceptions.ErrorMessage) as e:
sdk_client_fs.upload_from_fs(bundle_path)
with allure.step("Assert that error message is correct"):
# validation messages in new DSL are a bit messy so we check only error code and type
if "new_dsl" in case:
err.INVALID_OBJECT_DEFINITION.equal(e)
else:
err.INVALID_OBJECT_DEFINITION.equal(e, state)
def policy_creation_should_succeeded(admin_client: ADCMClient, role: Role, adcm_object: AnyADCMObject, user: User):
"""Try to create policy based on give role and expect creation to succeed"""
with allure.step(f'Create policy based on role "{role.display_name}" and expect it to succeeded'):
policy_name = f'Test role {random_string(5)}'
with catch_failed(ErrorMessage, 'Policy should be created'):
admin_client.policy_create(name=policy_name, role=role, objects=[adcm_object], user=[user])
def _check_that_host_exists(cluster: Cluster, host: Host) -> None:
assert len(cluster.host_list()) == 1, "Only one host expected to be"
with catch_failed(ObjectNotFound, "Previously created host not found"):
cluster.host(fqdn=host.fqdn)
def _check_that_cluster_exists(sdk_client_fs: ADCMClient, cluster: Cluster) -> None:
assert len(sdk_client_fs.cluster_list()) == 1, "Only one cluster expected to be"
with catch_failed(ObjectNotFound, "Previously created cluster not found"):
sdk_client_fs.cluster(name=cluster.name)
