def test_provider_add_with_bad_credentials(provider_crud):
    provider_crud.credentials = provider.get_credentials_from_config('bad_credentials')
    if isinstance(provider_crud, provider.VMwareProvider):
        with error.expected('Cannot complete login due to an incorrect user name or password.'):
            provider_crud.create(validate_credentials=True)
    elif isinstance(provider_crud, provider.RHEVMProvider):
        with error.expected('401 Unauthorized'):
            provider_crud.create(validate_credentials=True)

def test_delete_template(rest_api, template, multiple):
    if multiple:
        rest_api.collections.templates.action.delete(template)
        with error.expected("ActiveRecord::RecordNotFound"):
            rest_api.collections.templates.action.delete(template)
    else:
        template.action.delete()
        with error.expected("ActiveRecord::RecordNotFound"):
            template.action.delete()

 def test_delete_user(self, rest_api, users, multiple):
     if multiple:
         rest_api.collections.users.action.delete(*users)
         with error.expected("ActiveRecord::RecordNotFound"):
             rest_api.collections.users.action.delete(*users)
     else:
         user = users[0]
         user.action.delete()
         with error.expected("ActiveRecord::RecordNotFound"):
             user.action.delete()

 def test_delete_tags(self, rest_api, tags, multiple):
     if multiple:
         rest_api.collections.tags.action.delete(*tags)
         with error.expected("ActiveRecord::RecordNotFound"):
             rest_api.collections.tags.action.delete(*tags)
     else:
         tag = tags[0]
         tag.action.delete()
         with error.expected("ActiveRecord::RecordNotFound"):
             tag.action.delete()

 def test_delete_groups(self, rest_api, groups, multiple):
     if multiple:
         rest_api.collections.groups.action.delete(*groups)
         with error.expected("ActiveRecord::RecordNotFound"):
             rest_api.collections.groups.action.delete(*groups)
     else:
         group = groups[0]
         group.action.delete()
         with error.expected("ActiveRecord::RecordNotFound"):
             group.action.delete()

def test_delete_rates(rest_api, rates, multiple):
    if multiple:
        rest_api.collections.rates.action.delete(*rates)
        with error.expected("ActiveRecord::RecordNotFound"):
            rest_api.collections.rates.action.delete(*rates)
    else:
        rate = rates[0]
        rate.action.delete()
        with error.expected("ActiveRecord::RecordNotFound"):
            rate.action.delete()

 def test_delete_tenants(self, rest_api, tenants, multiple):
     if multiple:
         rest_api.collections.tenants.action.delete(*tenants)
         with error.expected("ActiveRecord::RecordNotFound"):
             rest_api.collections.tenants.action.delete(*tenants)
     else:
         tenant = tenants[0]
         tenant.action.delete()
         with error.expected("ActiveRecord::RecordNotFound"):
             tenant.action.delete()

 def test_delete_custom_attributes(self, rest_api, custom_attributes, from_detail):
     """Test deleting custom attributes using REST API."""
     if from_detail:
         for ent in custom_attributes:
             ent.action.delete()
             with error.expected("ActiveRecord::RecordNotFound"):
                 ent.action.delete()
     else:
         provider = rest_api.collections.providers[0]
         provider.custom_attributes.action.delete(*custom_attributes)
         with error.expected("ActiveRecord::RecordNotFound"):
             provider.custom_attributes.action.delete(*custom_attributes)

def test_provider_add_with_bad_credentials(provider):
    """Tests provider add with bad credentials

    Metadata:
        test_flag: crud
    """
    provider.credentials['default'] = get_credentials_from_config('bad_credentials')
    if isinstance(provider, VMwareProvider):
        with error.expected('Cannot complete login due to an incorrect user name or password.'):
            provider.create(validate_credentials=True)
    elif isinstance(provider, RHEVMProvider):
        with error.expected('401 Unauthorized'):
            provider.create(validate_credentials=True)

def test_delete_categories(rest_api, categories, multiple):
    if "delete" not in rest_api.collections.categories.action.all:
        pytest.skip("Delete categories action is not implemented in this version")

    if multiple:
        rest_api.collections.categories.action.delete(*categories)
        with error.expected("ActiveRecord::RecordNotFound"):
            rest_api.collections.categories.action.delete(*categories)
    else:
        ctg = categories[0]
        ctg.action.delete()
        with error.expected("ActiveRecord::RecordNotFound"):
            ctg.action.delete()

def test_region_required_validation(request, soft_assert):
    """Tests to validate the region while adding a provider"""
    prov = EC2Provider(
        name=fauxfactory.gen_alphanumeric(5),
        region=None)

    request.addfinalizer(prov.delete_if_exists)
    if version.current_version() < "5.5":
        with error.expected('Region is not included in the list'):
            prov.create()
    else:
        with error.expected(FlashMessageException):
            prov.create()
        soft_assert("ng-invalid-required" in properties_form.amazon_region_select.classes)

def test_name_required_validation(request):
    """Tests to validate the name while adding a provider"""
    prov = EC2Provider(
        name=None,
        region='us-east-1')

    request.addfinalizer(prov.delete_if_exists)
    if version.current_version() < "5.5":
        with error.expected("Name can't be blank"):
            prov.create()
    else:
        # It must raise an exception because it keeps on the form
        with error.expected(FlashMessageException):
            prov.create()
        assert prov.properties_form.name_text.angular_help_block == "Required"

def test_delete_roles(rest_api, roles):
    if "delete" not in rest_api.collections.roles.action.all:
        pytest.skip("Delete roles action is not implemented in this version")

    rest_api.collections.roles.action.delete(*roles)
    with error.expected("ActiveRecord::RecordNotFound"):
        rest_api.collections.roles.action.delete(*roles)

def test_permissions(appliance, role, allowed_actions, disallowed_actions):
    # create a user and role
    role = role()  # call function to get role
    role.create()
    group = new_group(role=role.name)
    group.create()
    user = new_user(group=group)
    user.create()
    fails = {}
    try:
        with user:
            appliance.server.login_admin()
            for name, action_thunk in allowed_actions.items():
                try:
                    action_thunk()
                except Exception:
                    fails[name] = "{}: {}".format(name, traceback.format_exc())
            for name, action_thunk in disallowed_actions.items():
                try:
                    with error.expected(Exception):
                        action_thunk()
                except error.UnexpectedSuccessException:
                    fails[name] = "{}: {}".format(name, traceback.format_exc())
            if fails:
                message = ''
                for failure in fails.values():
                    message = "{}\n\n{}".format(message, failure)
                raise Exception(message)
    finally:
        appliance.server.login_admin()

def test_tenant_unique_tenant_project_name_on_parent_level(request, object_type):
    """Tenant or Project has always unique name on parent level. Same name cannot be used twice.

    Prerequisities:
        * This test is not depending on any other test and can be executed against fresh appliance.

    Steps:
        * Create tenant or project
        * Create another tenant or project with the same name
        * Creation will fail because object with the same name exists
        * Delete created objects
    """

    name_of_tenant = object_type.__name__ + fauxfactory.gen_alphanumeric()
    tenant_description = object_type.__name__ + 'description'

    tenant = object_type(
        name=name_of_tenant,
        description=tenant_description)

    tenant2 = object_type(
        name=name_of_tenant,
        description=tenant_description)

    @request.addfinalizer
    def _delete_tenant():
        if tenant.exists:
            tenant.delete()
        if tenant2.exists:
            tenant2.delete()

    tenant.create()
    with error.expected("Validation failed: Name should be unique per parent"):
        tenant2.create()
    tenant.delete()

def test_name_required_error_validation():
    """
    Tests a System Image with no name.
    """
    sys_image_type = pxe.SystemImageType(name=None, provision_type="Vm")
    with error.expected("Name is required"):
        sys_image_type.create()

def test_delete_dialog_before_parent_item(appliance, catalog_item):
    service_dialog = DialogCollection(appliance)
    dialog = service_dialog.instantiate(label=catalog_item.dialog.label)
    error_message = ('Dialog \"{}\": Error during delete: Dialog cannot be'
        ' deleted because it is connected to other components.').format(catalog_item.dialog.label)
    with error.expected(error_message):
        dialog.delete()

def test_catalog_duplicate_name():
    cat = Catalog(name=fauxfactory.gen_alphanumeric(),
                  description="my catalog")
    cat.create()
    with error.expected("Name has already been taken"):
        cat.create()
    cat.delete()

def test_permission_edit(request, product_features, action):
    """
    Ensures that changes in permissions are enforced on next login
    """
    request.addfinalizer(login.login_admin)
    role_name = fauxfactory.gen_alphanumeric()
    role = ac.Role(name=role_name,
                  vm_restriction=None,
                  product_features=[(['Everything'], False)] +    # role_features
                                   [(k, True) for k in product_features])
    role.create()
    group = new_group(role=role.name)
    group.create()
    user = new_user(group=group)
    user.create()
    login.login(user.credential.principal, user.credential.secret)
    try:
        action()
    except Exception:
        pytest.fail('Incorrect permissions set')
    login.login_admin()
    role.update({'product_features': [(['Everything'], True)] +
                                     [(k, False) for k in product_features]
                 })
    login.login(user.credential.principal, user.credential.secret)
    try:
        with error.expected(Exception):
            action()
    except error.UnexpectedSuccessException:
        pytest.Fails('Permissions have not been updated')

def test_catalog_duplicate_name():
    cat = Catalog(name=rand.generate_random_string(),
                  description="my catalog")
    cat.create()
    with error.expected("Name has already been taken"):
        cat.create()
    cat.delete()