Produits Entr'ouvert » Authentic 2

    }

}

# Hey Entr'ouvert is in France !!

TIME_ZONE = 'Europe/Paris'

LANGUAGE_CODE = 'fr'

    Role.objects.create(name='Role4', service=service)

    # test failure when unlogged

    assert response.content == b'{}'

    # login

    client.login(request=None, username='john.doe', password='password')

    data = json.loads(force_str(response.content))

    assert isinstance(data, dict)

    assert set(data.keys()) == {

    assert response.json['user']['last_name'] == last_name

    assert check_password(password, response.json['user']['password'])

    assert response.json['token']

    assert User.objects.count() == 2

    user = User.objects.latest('id')

    assert user.ou == get_default_ou()

    assert response.json['user']['last_name'] == last_name

    assert check_password(password, response.json['user']['password'])

    assert response.json['token']

    assert User.objects.count() == 2

    user = User.objects.latest('id')

    assert user.username == username

    assert len(mailoutbox) == 1

    mail = mailoutbox[0]

    assert mail.to[0] == email

    assert_event('manager.user.password.reset.request', user=admin, api=True)

    mail = mailoutbox[0]

    assert mail.to[0] == new_email

def test_api_delete_role(app, admin_ou1, role_ou1):

    assert len(resp.json['data']) == 6

    login_stats = {

        'name': 'Login count by authentication type',

        'id': 'login',

        'filters': [

            {

    assert login_stats in resp.json['data']

    assert {

        'name': 'Login count by service',

        'id': 'service-login',

        'filters': [

            {

    @property

    def callback_url(self):

    def login_with_fc_fixed_params(self, app):

        if app.session:

        assert url.startswith('https://fcp.integ01.dev-franceconnect.fr/api/v1/logout')

        parsed_url = urllib.parse.urlparse(url)

        query = QueryDict(parsed_url.query)

        assert query['state']

        self.state = query['state']

        return app.get(reverse('fc-logout') + '?state=' + self.state)

    for body in (mailoutbox[0].body, mailoutbox[0].alternatives[0][0]):

        assert 'Hi AnonymousUser,' in body

        assert 'You have just created an account using FranceConnect.' in body

    assert user.verified_attributes.first_name == 'Ÿuñe'

    assert user.verified_attributes.last_name == 'Frédérique'

    content = response.json['franceconnect']

    assert isinstance(content, dict), 'franceconnect field is not a dict'

    assert content.get('linked') is True

    assert content.get('link_url').endswith('/callback/')

    assert content.get('unlink_url').endswith('/unlink/')

    unlink_url = '/api/users/%s/fc-unlink/' % simple_user.uuid

    try:

        def factory(hostname='testserver'):

        yield factory

    finally:

    else:

        def check_location(response, default_return):

    return check_location

    with open('tests/200x200.jpg', 'rb') as fd:

        simple_user.attributes.cityscape_image = File(fd)

    response = app.get(user_info_url, headers=bearer_authentication_headers(access_token))

    # check against a user without username

    simple_user.username = None

            src = iframes.attr('src')

            assert '?' in src

            src_qd = QueryDict(src.split('?', 1)[1])

            assert 'sid' in src_qd and src_qd['sid'] == get_session_id(

                mock.Mock(session=app.session), oidc_client

            )

TEMPLATES[0]['DIRS'].append('tests/templates')  # pylint: disable=undefined-variable

TEMPLATES[0]['OPTIONS']['debug'] = True  # pylint: disable=undefined-variable

A2_MAX_EMAILS_PER_IP = None

A2_MAX_EMAILS_FOR_ADDRESS = None

    response = app.get('/api/users/%s/' % john().uuid)

    assert (

        response.json['cityscape_image']

    )

    app.authorization = None

    assert query['response_type'] == 'code'

    assert query['client_id'] == str(oidc_provider.client_id)

    assert query['scope'] == 'openid'

    nonce = query['nonce']

    if oidc_provider.claims_parameter_supported:

    simple_user.save()

    call_command('clean-unused-accounts')

    mail = mailoutbox[0]

def test_clean_unused_account_with_no_email(simple_user, mailoutbox, caplog):

    assert importer.run()

    thomas = User.objects.get(email='tnoel@entrouvert.com')

    assert len(mail.outbox) == 1

    password = thomas.password

    del mail.outbox[0]

        self.base_url = 'https://sp.example.com'

        self.name = 'Test SP'

        self.slug = 'test-sp'

        self.default_name_id_format = 'email'

        self.accepted_name_id_format = ['email', 'persistent', 'transient', 'username']

        self.ou = OrganizationalUnit.objects.get()

            ),

            (

                "/saml:Assertion/saml:AttributeStatement/saml:Attribute[@Name='avatar']/saml:AttributeValue",

            ),

            (

                "/saml:Assertion/saml:AttributeStatement/saml:Attribute[@Name='verified_attributes']/@NameFormat",

        with mock.patch(

            'authentic2.idp.saml.saml2_endpoints.get_attributes', wraps=saml2_endpoints.get_attributes

        ) as get_attributes:

            request.user = None

            assertion = lasso.Saml2Assertion()

            provider = Service(ou=None)

        == '_' + hashlib.sha256(b'b' + b'https://sp.com/' + b'a').hexdigest().upper()

    )

    assert edpt is not None

    node = lasso.Node.newFromXmlNode(force_str(ET.tostring(edpt)))

    assert isinstance(node, lasso.Saml2NameID)

    assert force_str(node.content) == '_A485C0ACEEF43A6D39145F5CFE25D9D3B6F15DC6443F412263C76D81C72DA8D5'

    assert node.format == lasso.SAML2_NAME_IDENTIFIER_FORMAT_PERSISTENT

    assert node.spNameQualifier == 'https://sp.com/'

    assert isinstance(node, lasso.Saml2NameID)

    assert force_str(node.content) == '_A485C0ACEEF43A6D39145F5CFE25D9D3B6F15DC6443F412263C76D81C72DA8D5'

    assert node.format == lasso.SAML2_NAME_IDENTIFIER_FORMAT_PERSISTENT

    assert node.spNameQualifier == 'https://sp.com/'

    assert isinstance(node, lasso.Saml2NameID)

    assert force_str(node.content) == '_A485C0ACEEF43A6D39145F5CFE25D9D3B6F15DC6443F412263C76D81C72DA8D5'

    assert node.format == lasso.SAML2_NAME_IDENTIFIER_FORMAT_PERSISTENT

    assert node.spNameQualifier == 'https://sp.com/'

    assert q('table tbody tr td .icon-remove-sign')

    token = str(response.context['csrf_token'])

    params = {'action': 'remove', 'user_or_role': 'user-%s' % admin.pk, 'csrfmiddlewaretoken': token}

    assert simple_role not in admin.roles.all()

    # user can act on role inheritance

    response = app.get('/manage/roles/%s/children/' % simple_role.pk)

    token = str(response.context['csrf_token'])

    params = {'action': 'add', 'role': role.pk, 'csrfmiddlewaretoken': token}

    assert role in simple_role.children()

    params = {'action': 'remove', 'role': role.pk, 'csrfmiddlewaretoken': token}

    assert role not in simple_role.children()

    response = app.get('/manage/roles/%s/parents/' % role.pk)

    token = str(response.context['csrf_token'])

    params = {'action': 'add', 'role': simple_role.pk, 'csrfmiddlewaretoken': token}

    assert simple_role in role.parents()

    params = {'action': 'remove', 'role': simple_role.pk, 'csrfmiddlewaretoken': token}

    assert simple_role not in role.parents()

    # user can add role as a member through role members form

    assert q('table tbody tr td .icon-remove-sign')

    token = str(response.context['csrf_token'])

    params = {'action': 'remove', 'user_or_role': 'role-%s' % role.pk, 'csrfmiddlewaretoken': token}

    assert role not in simple_role.children()

    # try to add arbitrary role

    response = app.get('/manage/roles/%s/parents/' % role.pk)

    token = str(response.context['csrf_token'])

    params = {'action': 'add', 'role': admin_role.pk, 'csrfmiddlewaretoken': token}

    assert admin_role not in role.parents()

    # user roles view works

    token = str(response.context['csrf_token'])

    params = {'action': 'add', 'role': simple_role.pk, 'csrfmiddlewaretoken': token}

    assert simple_role in admin.roles.all()

    app.get('/manage/roles/add/', status=403)

        {

            'label': 'Identity management',

            'slug': 'identity-management',

            'sub': False,

        },

    ]

    response = login(app, admin)

    for body in (mail.body, mail.alternatives[0][0]):

        assert 'no account was found associated with this address' in body

        if settings.REGISTRATION_OPEN:

            # check next_url was preserved

            assert 'next=/whatever/' in body

        else:

def test_send_password_reset_email_disabled_account(app, simple_user, mailoutbox):

    url = reverse('password_reset')

    response = app.get(url, status=200)

    response = response.follow()

    assert len(mailoutbox) == 0

    assert 'Your password reset request has been refused' in response

    settings.DEFAULT_FROM_EMAIL = 'show only addr <noreply@example.net>'

    response = app.get(utils_misc.make_url('registration_register'))

    response = response.follow()

    assert len(mailoutbox) == 0

    assert 'Your registration request has been refused' in response

    # simulate click on Jôhn Dôe delete icon

    token = str(resp.context['csrf_token'])

    params = {'action': 'remove', 'user_or_role': 'user-%s' % simple_user.pk, 'csrfmiddlewaretoken': token}

    assert 'Jôhn Dôe' not in resp.text

    # simulate click on role_ou1 delete icon

    token = str(resp.context['csrf_token'])

    params = {'action': 'remove', 'user_or_role': 'role-%s' % role_ou1.pk, 'csrfmiddlewaretoken': token}

    assert 'role_ou1' not in resp.text

    # invalid choices are ignored

    # cannot click it's JS :/

    token = str(resp.context['csrf_token'])

    params = {'authorization': auth.pk, 'csrfmiddlewaretoken': token}

    assert OIDCAuthorization.objects.count() == 0

    resp = resp.follow()

    assert resp.html.find('td').text == 'This user has not granted profile data access to any service yet.'