Produits Entr'ouvert » Authentic 2

::

            'meta': {'object_name': 'User',

must be rewritten like that:::

master_doc = 'index'

# General information about the project.

# The version info for the project you're documenting, acts as replacement for

# |version| and |release|, also used in various other places throughout the

# Grouping the document tree into LaTeX files. List of tuples

# (source start file, target name, title, author, documentclass [howto/manual]).

latex_documents = [

]

# The name of an image file (relative to this directory) to place at the top of

# One entry per manual page. List of tuples

# (source start file, name, description, authors, manual section).

# If true, show URL addresses after external links.

# man_show_urls = False

    (

        'index',

        'Authentic2',

        'Authentic2',

        'One line description of project.',

        'Miscellaneous',

        verbose_name_plural = _('role parenting relations')

    def __str__(self):

class RoleAttribute(models.Model):

                )

            except smtplib.SMTPException as e:

                logging.getLogger(__name__).error(

                )

        return instance

def profile_image_html_value(attribute, value):

    if value:

        return html.mark_safe(fragment)

    return ''

def only_digits(value):

def validate_lun(value):

        if field.name == 'ou':

            continue

        name = 'django_user_' + str(field.name)

        yield name, description

    for attribute in Attribute.objects.all():

        name = 'django_user_' + str(attribute.name)

        yield name, description

    group_label = User._meta.get_field('groups').verbose_name

    yield 'a2_role_slugs', _('Role slugs')

    yield 'a2_role_names', _('Role names')

    yield 'a2_role_uuids', _('Role UUIDs')

            names.append(service_role_attribute.name)

    names.sort()

    for name in names:

def get_dependencies(instance, ctx):

            if ldap_attribute in attributes:

                value = attributes[ldap_attribute][0]

            else:

            if getattr(user, legacy_attribute) != value:

                setattr(user, legacy_attribute, value)

                user._changed = True

        attribute_mappings = map_text(block['attribute_mappings'])

        mandatory_attributes_values = map_text(block['mandatory_attributes_values'])

        try:

        except ldap.LDAPError as e:

            log.error('unable to retrieve attributes of dn %r: %r', dn, e)

            return None

                    item_value = {}

                    for dn, attrs in results:

                        log.debug(

                            % (extra_attribute_name, item, dn, attrs)

                        )

                        for key in ldap_attributes_mapping:

            else:

                decoded.append((attribute, force_text(value)))

        filters = [filter_format(u'(%s=%s)', (a, b)) for a, b in decoded]

    def build_external_id(self, external_id_tuple, attributes):

        """Build the exernal id for the user, use attribute that eventually

        else:

            modlist = []

            if block['active_directory']:

                value = cls.ad_encoding(new_password)

                if old_password:

                    modlist = [

                else:

                    modlist = [(ldap.MOD_REPLACE, key, [value])]

            else:

                modlist = [(ldap.MOD_REPLACE, key, [new_password])]

            conn.modify_s(dn, modlist)

        log.debug('modified password for dn %r', dn)

                conn.simple_bind_s()

            return True, None

        except ldap.INVALID_CREDENTIALS:

        except ldap.INVALID_DN_SYNTAX:

        except ldap.CONNECT_ERROR:

            return False, 'connection error'

        except ldap.TIMEOUT:

                            results = self.normalize_ldap_results(results)

                            if not results:

                                log.warning(

                                )

                                continue

                            dn = results[0][0]

                    except ldap.LDAPError as e:

                        log.warning(

                        )

                        continue

                    return self._return_user(dn, None, conn, block)

def upn(username, realm):

    '''Build an UPN from a username and a realm'''

PROXY_USER_MODEL = None

                for message in error_list(messages):

                    errorlist.append(

                        format_lazy(

                        )

                    )

        raise ValidationError(errorlist)

            if kw not in self.kwargs:

                continue

            parts.append(u'%s-%s' % (str(kw), str(arg)))

class SimpleDictionnaryCacheMixin(object):

def error_page(request, message, logger):

    '''Customized disco service error page'''

    return base_error_page(request, message, logger)

        self.key_prefix = key_prefix

    def key(self, keys):

        key = key.encode('utf-8')

        return '%s%s' % (self.key_prefix or self.KEY_PREFIX, hashlib.md5(key).hexdigest())

    def __init__(self, *args, **kwargs):

        kwargs[

            'help_text'

    <span class="a2-password-check-equality-default">%(default)s</span>

    <span class="a2-password-check-equality-matched">%(match)s</span>

    <span class="a2-password-check-equality-unmatched">%(nomatch)s</span>

        help_text = self.help_text

        if not help_text:

        return mark_safe(

            self.render_template

        if attrs and app_settings.A2_PASSWORD_POLICY_SHOW_LAST_CHAR:

            _id = attrs.get('id')

            if _id:

        return output

        if attrs:

            _id = attrs.get('id')

            if _id:

        return output

            _id = attrs.get('id')

            if _id and _id.endswith('2'):

                other_id = _id[:-1] + '1'

                    json.dumps(other_id),

                    json.dumps(_id),

                )

    kwargs['entity_id'] = login.remoteProviderId

    kwargs['user'] = request.user

    logger.debug(

    )

    register_new_saml2_session(request, login)

    add_attributes(request, entity_id, assertion, provider, nid_format)

    """Build a session dump from a list of pairs

    (provider_id,assertion_content)"""

    session = [

    ]

    for liberty_session in liberty_sessions:

        session.append(

        )

        session.append(u'<saml:NameID Format="{0.name_id_format}" '.format(liberty_session))

        if liberty_session.name_id_qualifier:

                )

            except smtplib.SMTPException as e:

                logger.error(

                )

        return user

        raise NotImplementedError

    def render(self, value, object):

class UserResource(ModelResource):

    def get_search_form_kwargs(self):

        kwargs = super(UserRolesView, self).get_search_form_kwargs()

        kwargs['user'] = self.object

        kwargs['role_members_from_ou'] = app_settings.ROLE_MEMBERS_FROM_OU

        kwargs['show_all_ou'] = app_settings.SHOW_ALL_OU

        )

        ctx['help_columns'] = help_columns

        example_data = (

        )

        example_url = 'data:text/csv;base64,%s' % base64.b64encode(example_data.encode('utf-8')).decode(

            'ascii'

        if labels:

            labels.append(u' - ')

        labels.append(user.username)

@GlobalCache(timeout=10)

    def get_instance_name(self):

        if hasattr(self, 'get_object'):

            return str(self.get_object())

    def get_context_data(self, **kwargs):

        ctx = super(ModelNameMixin, self).get_context_data(**kwargs)

    def label_from_instance(self, obj):

        label = str(obj)

        if obj.ou and utils.get_ou_count() > 1:

        return label

    updated = models.DateTimeField(auto_now=True, verbose_name=_('last update date'))

    def __str__(self):

    def __repr__(self):

        return (

        try:

            provider.update_metadata()

        except ValidationError as e:

            messages.error(request, _('Updating SAML provider %(name)s failed: ' '%(error_msg)s') % params)

        else:

            count += 1

    def format(self, obj):

        name_id_format = obj.name_id_format

        if name_id_format > 15:

        return name_id_format

            yield (name, name_format, friendly_name, value)

    def __str__(self):

    def natural_key(self):

        if not hasattr(self.provider, 'natural_key'):

            else:

                url_params.appendlist(key, value)

    if url_params:

    if fragment:

    if absolute:

        if request:

            url = request.build_absolute_uri(url)

        **kwargs,

    )

    logger.info(

    )

    journal.record('user.password.reset.request', email=user.email, user=user)

        if not self.check_referrer():

            return HttpResponseForbidden()

        callback = request.GET.get('callback')

        return HttpResponse(content, content_type='application/json')

                url_validator(url)

            except ValidationError:

                raise ValidationError(_('%s is an invalid URL') % url)

    def match_service(self, service_url):

        '''Verify that this service match an URL'''

    enabled = models.BooleanField(verbose_name=_('enabled'), default=True)

    def __str__(self):

    class Meta:

        verbose_name = _('CAS attribute')

def clean_words(data):

    '''Clean and order a list of words'''

def url_domain(url):

        ct_ct = ContentType.objects.get_for_model(ContentType)

        if ct == ct_ct:

            target = ContentType.objects.get_for_id(self.target_id)

        else:

        if self.ou:

            s += _(u' (scope "{0}")').format(self.ou)

        return s

    coin = Role.objects.create(name='Coin', slug='coin')

    coin.get_admin_role()

    for role in Role.objects.filter(admin_scope_ct__isnull=False):

def test_admin_roles_update_slug(db):

    assert permissions[0] == {

        'operation': {'slug': 'add'},

        'ou': {'uuid': ou.uuid, 'slug': ou.slug, 'name': ou.name},

    }

    assert permissions[1] == {

        'operation': {'slug': 'add'},

        'ou': None,

        'target': {

            'service': None,

            'uuid': other_role.uuid,

        },

    }

    assert response.pyquery.find('.form-field-error #id_nom_de_naissance')

    form = response.form

    form.set('password1', '12345abcdA')

    form.set('password2', '12345abcdA')

    response = form.submit().follow()

    qs.delete()

    app.authorization = ('Basic', (admin.username, admin.username))

    payload = {

        'first_name': 'John',

        'last_name': 'Doe',

    }

    app.post_json('/api/users/', params=payload, status=201)

    qs.delete()

    user = User.objects.get()

    # verify user was not modified

    assert user.username == 'user'

    assert user.email == 'user@example.net'

    response = app.get(reverse('account_management'))

    with utils.check_log(caplog, 'revoked token from OIDC'):

@pytest.mark.parametrize(

)

def test_clean_unused_account_human_duration_format(simple_user, mailoutbox, deletion_delay, formatted):

    simple_user.ou.clean_unused_accounts_alert = deletion_delay - 1

def test_hmac_url():

    url = 'https://example.invalid/'

    assert crypto.check_hmac_url(key, url, crypto.hmac_url(key, url))

    assert crypto.check_hmac_url(key, url, crypto.hmac_url(key, url))

@pytest.mark.parametrize(

    'value',

    [

        b'\xc3\xa9',

        {1: 1, 2: 4, 3: 6, 4: 8, 5: 10},

        'Hello World',

    other_role_dict['permisison'] = {

        "operation": {"slug": "admin"},

        "ou": {"slug": "default", "name": "Collectivit\u00e9 par d\u00e9faut"},

        "target": {

            "slug": "role-deux",

            "ou": {"slug": "default", "name": "Collectivit\u00e9 par d\u00e9faut"},

        {

            'operation': {'slug': 'add'},

            'ou': None,

        }

    ]

        {

            "operation": {"slug": "admin"},

            "ou": {"slug": "perm-ou", "name": "perm-ou"},

            "target": {

                "slug": "perm-role",

                "ou": {"slug": "perm-ou", "name": "perm ou"},

pytestmark = pytest.mark.skipif(not has_slapd(), reason='slapd is not installed')

UID = 'etienne.michu'

CN = 'Étienne Michu'

DN = 'cn=%s,o=ôrga' % escape_dn_chars(CN)

PASS = 'passé'

EMAIL = 'etienne.michu@example.net'

CARLICENSE = '123445ABC'

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'attributes': ['jpegPhoto'],

        }

    assert force_bytes('Étienne Michu') in result.content

    assert User.objects.count() == 1

    user = User.objects.get()

    assert user.last_name == 'Michu'

    assert user.is_active is True

    assert user.is_superuser is False

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

        }

    ]

            'url': [slapd.ldap_url],

            'binddn': force_text(DN),

            'bindpw': PASS,

            'use_tls': False,

        }

    ]

    assert force_bytes('Étienne Michu') in result.content

    assert User.objects.count() == 1

    user = User.objects.get()

    assert user.last_name == 'Michu'

    assert user.is_active is True

    assert user.is_superuser is False

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'is_superuser': True,

            'is_staff': True,

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'is_superuser': True,

            'is_staff': True,

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'keep_password_in_session': True,

        }

    assert force_bytes('Étienne Michu') in result.content

    assert User.objects.count() == 1

    user = User.objects.get()

    assert user.last_name == 'Michu'

    assert user.ou == get_default_ou()

    assert not user.check_password(PASS)

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'keep_password': True,

        }

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'ou_slug': 'test',

        }

    assert force_bytes('Étienne Michu') in result.content

    assert User.objects.count() == 1

    user = User.objects.get()

    assert user.ou == ou

    assert not user.check_password(PASS)

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'ou_slug': 'test',

        }

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'create_group': True,

            'group_mapping': [

        '/login/', {'login-password-submit': '1', 'username': USERNAME, 'password': PASS}, follow=True

    )

    assert Group.objects.filter(name='Group1').count() == 1

    assert response.context['user'].groups.count() == 1

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'create_group': True,

            'group_mapping': [

        '/login/', {'login-password-submit': '1', 'username': USERNAME, 'password': PASS}, follow=True

    )

    assert Group.objects.filter(name='Group2').count() == 1

    assert response.context['user'].groups.count() == 1

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            # memberOf is not defined on OpenLDAP so we use street for storing DN like

            # memberOf values

    response = client.post(

        '/login/', {'login-password-submit': '1', 'username': USERNAME, 'password': PASS}, follow=True

    )

    assert set(response.context['user'].roles.values_list('name', flat=True)) == set(['Role1', 'Role2'])

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'group_to_role_mapping': [

                ['cn=group2,o=ôrga', ['Role2']],

    response = client.post(

        '/login/', {'login-password-submit': '1', 'username': USERNAME, 'password': PASS}, follow=True

    )

    assert response.context['user'].roles.count() == 1

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'group_to_role_mapping': [

                ['cn=group1,o=ôrga', ['Role3']],

        '/login/', {'login-password-submit': '1', 'username': USERNAME, 'password': PASS}, follow=True

    )

    assert Group.objects.count() == 0

    assert response.context['user'].is_superuser

    assert not response.context['user'].is_staff

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'groupstaff': [u'cn=group1,o=ôrga'],

        }

        '/login/', {'login-password-submit': '1', 'username': 'etienne.michu', 'password': PASS}, follow=True

    )

    assert Group.objects.count() == 0

    assert response.context['user'].is_staff

    assert not response.context['user'].is_superuser

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'create_group': True,

            'group_mapping': [

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'create_group': True,

            'group_mapping': [

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'create_group': True,

            'group_mapping': [

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'create_group': True,

            'group_mapping': [

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'create_group': True,

            'group_mapping': [

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'create_group': True,

            'group_mapping': [

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'create_group': True,

            'group_mapping': [

            'url': [slapd.ldap_url],

            'binddn': force_text(slapd.root_bind_dn),

            'bindpw': force_text(slapd.root_bind_password),

            'use_tls': False,

            'attributes': ['uid', 'carLicense'],

        }

            'url': [slapd.ldap_url],

            'binddn': force_text(slapd.root_bind_dn),

            'bindpw': force_text(slapd.root_bind_password),

            'use_tls': False,

            'user_can_change_password': False,

        }

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [tls_slapd.ldap_url],

            'use_tls': False,

        }

    ]

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [tls_slapd.ldap_url],

            'use_tls': True,

            'cacertfile': cert_file,

        }

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [tls_slapd.ldap_url],

            'use_tls': True,

            'cacertfile': cert_file,

            'certfile': cert_file,

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'user_attributes': [

                {

    client.post(

        '/login/', {'login-password-submit': '1', 'username': USERNAME, 'password': PASS}, follow=True

    )

    user = User.objects.get(username=username)

    client.session.flush()

    for i in range(5):

        client.post(

            '/login/',

            {

                'login-password-submit': '1',

                'password': PASS,

            },

            follow=True,

        )

        user = User.objects.get(username=username)

        client.session.flush()

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

        }

    ]

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd_ppolicy.ldap_url],

            'use_tls': False,

        }

    ]

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd_ppolicy.ldap_url],

            'use_tls': False,

        }

    ]

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd_ppolicy.ldap_url],

            'use_tls': False,

            'use_controls': False,

        }

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd_ppolicy.ldap_url],

            'use_tls': False,

        }

    ]

    user = authenticate(username=USERNAME, password=UPASS)

    assert user.check_password(UPASS)

    user.set_password(password)

    time.sleep(pwdMaxAge * 3)

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd_ppolicy.ldap_url],

            'use_tls': False,

        }

    ]

    user = authenticate(username=USERNAME, password=UPASS)

    assert user.check_password(UPASS)

    user.set_password(password)

    time.sleep(2)

            'url': [slapd_ppolicy.ldap_url],

            'binddn': force_text(slapd_ppolicy.root_bind_dn),

            'bindpw': force_text(slapd_ppolicy.root_bind_password),

            'use_tls': False,

            'attributes': ['carLicense'],

        }

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd_ppolicy.ldap_url],

            'use_tls': False,

        }

    ]

            'url': [slapd.ldap_url],

            'binddn': force_text(DN),

            'bindpw': PASS,

            'ou_slug': ou1.slug,

            'use_tls': False,

        }

            'url': [slapd.ldap_url],

            'binddn': force_text(DN),

            'bindpw': PASS,

            'use_tls': False,

        }

    ]

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'user_attributes': [

                {

    management.call_command('sync-ldap-users', verbosity=2)

    assert len(capsys.readouterr().out.splitlines()) == 7

    assert User.objects.count() == 6

    assert all(

        for user in User.objects.all()

    )

    assert all(

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'user_filter': '(&(objectClass=user)(sAMAccountName=*)',  # wrong

        }

    settings.LDAP_AUTH_SETTINGS = [

        {

            'url': [slapd.ldap_url],

            'use_tls': False,

            'attributes': ['uid', 'carLicense'],

        }

    # simulate LDAP down

    slapd.stop()

    assert user.get_attributes(object(), {}) == {

        'givenname': [u'\xc9tienne'],

        'mail': [u'etienne.michu@example.net'],

        'sn': [u'Michu'],

    ldif = [(ldap.MOD_REPLACE, 'sn', [b'Micho'])]

    conn.modify_s(DN, ldif)

    assert user.get_attributes(object(), {}) == {

        'givenname': [u'\xc9tienne'],

        'mail': [u'etienne.michu@example.net'],

        'sn': [u'Micho'],

            'url': [slapd.ldap_url],

            'binddn': force_text(slapd.root_bind_dn),

            'bindpw': force_text(slapd.root_bind_password),

            'use_tls': False,

            'attributes': ['carLicense'],

        }

    assert response.pyquery.find('select#id_ou')

    assert len(response.pyquery.find('select#id_ou optgroup')) == 0

    assert set([elt.text for elt in response.pyquery.find('select#id_ou option')]) == set(

    )

    # Check selector is required

    response.form.set('username', simple_user.username)

    assert response.pyquery.find('select#id_ou')

    assert len(response.pyquery.find('select#id_ou optgroup')) == 2

    assert set([elt.text for elt in response.pyquery.find('select#id_ou option')]) == set(

    )

    # Create a service

    service = models.Service.objects.create(name='Service', slug='service', ou=ou1)

    response = app.get('/login/')

    # service is specified but not access-control is defined, default for user is selected

    response = app.get('/login/?service=service')

    # service is specified, access control is defined but role is empty, default for user is selected

    service.authorized_roles.through.objects.create(service=service, role=role_ou1)

    response = app.get('/login/?service=service')

    # user is added to role_ou1, default for user is still selected

    user_ou1.roles.add(role_ou1)

    response = app.get('/login/?service=service')

    # Clear cookies, OU1 is selected

    app.cookiejar.clear()

    response = app.get('/login/?service=service')

    # if we change the user's ou, then default selected OU changes

    user_ou1.ou = ou2

    user_ou1.save()

    response = app.get('/login/?service=service')

def test_login_test_cookie(app, simple_user):

        assert 'search-ou' not in form.fields

        q = response.pyquery.remove_namespaces()

        assert len(q('table tbody tr')) == 1

        assert q('table tbody tr').attr('data-url') == '/manage/roles/%s/' % simple_role.pk

        form.set('search-internals', True)

        assert 'search-ou' not in response.form.fields

        q = response.pyquery.remove_namespaces()

        assert len(q('table tbody tr')) == 1

        response.form.set('search-internals', True)

        response = response.form.submit()

        q = response.pyquery.remove_namespaces()

        assert len(q('table tbody tr')) == 6

        for elt in q('table tbody td.name a'):

    test_user_listing(admin)

    app.session.flush()

            assert not checked or key == str(get_default_ou().pk)

        q = response.pyquery.remove_namespaces()

        assert len(q('table tbody tr')) == 1

        response.form.set('search-ou', 'all')

        response = response.form.submit()

        q = response.pyquery.remove_namespaces()

        assert len(q('table tbody tr')) == 2

        names = [elt.text for elt in q('table tbody td.name a')]

        response.form.set('search-ou', 'all')

        response.form.set('search-internals', True)

                'OU1' in elt.text

                or 'Default' in elt.text

                or 'Manager' in elt.text

            )

        response.form.set('search-ou', 'none')

    assert len(response.json['results']) == 3

    response = app.get(url, params={'field_id': field_id, 'term': 'Admin cass'})

    assert len(response.json['results']) == 1

    response = app.get(url, params={'field_id': field_id, 'term': force_str('Admin édou')})

    assert len(response.json['results']) == 1

def test_roles_for_change_widget(admin, app, db):

    response = app.get(reverse('account_management'))

    response = app.get(reverse('profile_edit'))

    assert 'profession' in response.form.fields

    response = response.follow()

def test_registration_email_blacklist(app, settings, db):

    response = app.post(reverse('registration_register'), params={'email': 'fred@0d..be'}, status=200)

    assert 'Enter a valid email address.' in response.context['form'].errors['email']

    assert 'Enter a valid email address.' in response.context['form'].errors['email']

    assert 'This field is required.' in response.context['form'].errors['email']

def test_manager_create_user_next(superuser_or_admin, app, ou1):

    login(app, superuser_or_admin, '/manage/')

    response = app.get(url)

    # cancel is not handled through form submission, it's a link

    assert response.pyquery.remove_namespaces()('a.cancel').attr('href') == '../..'

    assert response.pyquery.remove_namespaces()('input[name="next"]').attr('value') == next_url

    response = app.get(url)

    assert response.pyquery.remove_namespaces()('a.cancel').attr('href') == cancel_url

def test_manager_create_user_next_form_error(superuser_or_admin, app, ou1):

    login(app, superuser_or_admin, '/manage/')

    response = app.get(url)

    form = response.form

def test_manager_add_user_querystring(superuser_or_admin, app, ou1):

    login(app, superuser_or_admin, '/manage/')

    response = app.get(url)

def test_manager_edit_user_next(app, simple_user, superuser_or_admin):

    login(app, superuser_or_admin, '/manage/')

    response = app.get(url)

def test_manager_edit_user_next_form_error(superuser_or_admin, app, ou1, simple_user):

    login(app, superuser_or_admin, '/manage/')

    response = app.get(url)

    form = response.form

    some_ou = OU.objects.create(name=u'Some Ou', show_username=False)

    login(app, admin, '/manage/')

    response = app.get(url)

    q = response.pyquery.remove_namespaces()

    assert len(q('p[id="id_username_p"]')) == 0

    simple_user.email_verified = True

    simple_user.save()

    login(app, superuser_or_admin, '/manage/')

    user = User.objects.get(id=simple_user.id)

def test_manager_edit_user_address_autocomplete(app, simple_user, superuser_or_admin):

    login(app, superuser_or_admin, '/manage/')

    Attribute.objects.create(

def text_content(node):

    """Extract text content from node and all its children. Equivalent to

    xmlNodeGetContent from libxml."""

def assert_event(event_type_name, user=None, session=None, service=None, **data):