pyramid-fullauth 0.3.0__py2.7.egg

tests/tools.py

@@ -0,0 +1,54 @@
+"""Tools used for fullauth tests."""
+from pyramid.view import view_config
+from pyramid.compat import text_type
+
+DEFAULT_USER = {
+    'username': text_type('u1'),
+    'password': text_type('password1'),
+    'email': text_type('email@example.com'),
+    'address_ip': text_type('127.0.0.1')
+}
+
+
+def authenticate(app, email=DEFAULT_USER['email'],
+                 password=DEFAULT_USER['password'],
+                 remember=False,
+                 response_code=302):
+    """Authenticate user."""
+    res = app.get('/login')
+    form = res.form
+
+    form['email'] = email
+    form['password'] = password
+    if remember:
+        form['remember'] = 1
+
+    res = form.submit()
+
+    # We've been redirected after log in
+    assert res.status_code == response_code
+
+    return res
+
+
+def is_user_logged(app):
+    """Check for auth_tkt cookies beeing set to see if user is logged in."""
+    cookies = app.cookies
+    if 'auth_tkt' in cookies and cookies['auth_tkt']:
+
+        return True
+    return False
+
+# this below are additional views crafted for tests.
+
+
+def include_views(config):
+    """Dummy pyramid 'plugin' adding dummy secret view."""
+    config.add_route('secret', '/secret')
+    config.scan('tests.tools')
+
+
+@view_config(route_name="secret", permission="super_high", renderer='json')
+def secret_view(request):
+    """Dummy view with redirect to login."""
+    return {}

tests/unit/test_default_settings.py

@@ -0,0 +1,15 @@
+"""
+Test for recognizing default settings.
+
+Also helps to keeping them in line.
+"""
+
+
+def test_defaults(default_config):
+    """Load defaults config for fullauth."""
+    # Config should get created based on fullauth defaults
+    assert 'fullauth' in default_config.registry['config']
+    # csrf should be turned on by default
+    assert default_config.registry['config']['fullauth']['check_csrf'] is True
+    # also hashalg should be anything but not md5 by default.
+    assert default_config.registry['config']['fullauth']['AuthTkt']['hashalg'] is not 'md5'

tests/unit/test_groupfinder.py

@@ -0,0 +1,20 @@
+"""Test groupfinder."""
+import pytest
+
+from pyramid_fullauth.auth import groupfinder
+
+
+@pytest.mark.parametrize(['is_admin', 'is_active', 'groups'],
+                         [(True, True, ['s:superadmin', 's:user']),
+                         (True, False, ['s:superadmin', 's:inactive']),
+                         (False, True, ['s:user']),
+                         (False, False, ['s:inactive'])])
+def test_groupfinder(web_request, db_session, user, is_admin, is_active, groups):
+    """Return special group assigned for user."""
+    user = db_session.merge(user)
+    user.is_admin = is_admin
+    user.is_active = is_active
+
+    web_request.user = user
+    assigned_groups = groupfinder(user.id, web_request)
+    assert groups == assigned_groups

tests/unit/test_social_view.py

@@ -0,0 +1,65 @@
+"""Unittest for social login view."""
+import pytest
+import mock
+from velruse import AuthenticationComplete
+
+from pyramid_fullauth.views.social import SocialLoginViews
+
+
+@pytest.mark.parametrize('profile, email', [
+    (
+        {
+            'accounts': [{'domain': u'facebook.com', 'userid': u'2343'}],
+            'displayName': u'teddy',
+            'verifiedEmail': 'verified@email.co.uk',
+            'preferredUsername': u'teddy',
+            'emails': [{'value': u'aasd@bwwqwe.pl'}],
+            'name': u'ted'
+        },
+        'verified@email.co.uk'
+    ), (
+        {
+            'accounts': [{'domain': u'facebook.com', 'userid': u'2343'}],
+            'displayName': u'teddy',
+            'preferredUsername': u'teddy',
+            'emails': [{'value': u'aasd@bwwqwe.pl'}],
+            'name': u'ted'
+        },
+        'aasd@bwwqwe.pl'
+    ), (
+        {
+            'accounts': [{'domain': u'facebook.com', 'userid': u'2343'}],
+            'displayName': u'teddy',
+            'preferredUsername': u'teddy',
+            'emails': [{}],
+            'name': u'ted'
+        },
+        '2343@facebook.com'
+    ), (
+        {
+            'accounts': [{'domain': u'facebook.com', 'userid': u'2343'}],
+            'displayName': u'teddy',
+            'preferredUsername': u'teddy',
+            'emails': [],
+            'name': u'ted'
+        },
+        '2343@facebook.com'
+    ), (
+        {
+            'accounts': [{'domain': u'facebook.com', 'userid': u'2343'}],
+            'displayName': u'teddy',
+            'preferredUsername': u'teddy',
+            'name': u'ted'
+        },
+        '2343@facebook.com'
+    ),
+])
+def test_email_from_context(profile, email):
+    """Test email_from_context email getting method."""
+    context = AuthenticationComplete(
+        profile,
+        {'oauthAccessToken': '7897048593434'},
+        u'facebook',
+        u'facebook')
+    view = SocialLoginViews(mock.MagicMock())
+    assert view._email_from_context(context) == email

tests/unit/test_tools.py

@@ -0,0 +1,24 @@
+"""Test fullauth's tools."""
+import pytest
+
+from pyramid_fullauth.tools import validate_passsword, password_generator
+from pyramid_fullauth.exceptions import (
+    EmptyError, ShortPasswordError, PasswordConfirmMismatchError
+)
+
+
+@pytest.mark.parametrize(('password', 'exception'),
+                         [('', EmptyError),
+                         ('1234', ShortPasswordError),
+                         ('123456789', PasswordConfirmMismatchError)
+                          ])
+def test_raises_errors(web_request, password, exception):
+    """Test validate_passsword possible exceptions."""
+    with pytest.raises(exception):
+        validate_passsword(web_request, password)
+
+
+@pytest.mark.parametrize('length', [5, 6])
+def test_password_generator(length):
+    """Test password_generator generating proper length of a random password."""
+    assert len(password_generator(length)) == length

tests/unit/test_user_active.py

@@ -0,0 +1,31 @@
+"""User active method tests."""
+import pytest
+
+from pyramid_fullauth.models import User
+
+
+def test_is_active_error():
+    """is_active can only be modified on object in session."""
+    with pytest.raises(AttributeError):
+        user = User()
+        user.is_active = True
+
+
+def test_is_active(db_session, user):
+    """
+    Test is_active attribute.
+
+    Setting is_active to True, should result in change of activated_at date being set
+    Setting to false, should set deactivated_at.
+    """
+    user = db_session.merge(user)
+
+    assert not user.is_active
+    assert not user.activated_at
+    user.is_active = True
+    assert user.is_active
+    assert user.activated_at
+    assert not user.deactivated_at
+    user.is_active = False
+    assert not user.is_active
+    assert user.deactivated_at

tests/unit/test_user_admin.py

@@ -0,0 +1,61 @@
+"""Test admin related behaviour on user model."""
+import pytest
+import transaction
+from pyramid.compat import text_type
+
+from pyramid_fullauth.models import User
+from pyramid_fullauth.exceptions import DeleteException
+
+
+def test_regular_user_not_admin(db_session, user):
+    """Regular user is_admin flag test."""
+    user = db_session.merge(user)
+
+    # Default user should not be an admin
+    assert not user.is_admin
+
+
+def test_remove_last_admin(db_session, user):
+    """
+    Admin user is_admin flag test.
+
+    At least one admin needed.
+    """
+    user = db_session.merge(user)
+    user.is_admin = True
+    transaction.commit()
+    user = db_session.merge(user)
+
+    with pytest.raises(AttributeError):
+        user.is_admin = False
+
+
+def test_delete_admin(db_session, user):
+    """Admin user soft delete behaviour - more than one admins present."""
+    user = db_session.merge(user)
+    user2 = User(
+        email=text_type('test2@example.com'),
+        address_ip='127.0.0.1',
+        password='pass',
+        is_admin=True
+    )
+    db_session.add(user2)
+    user.is_admin = True
+    transaction.commit()
+    user = db_session.merge(user)
+
+    user.delete()
+
+    assert user.deleted_at
+
+
+def test_delete_last_admin(db_session, user):
+    """Admin user soft delete - only one admin, no deleting possible."""
+    user = db_session.merge(user)
+
+    user.is_admin = True
+    transaction.commit()
+    user = db_session.merge(user)
+
+    with pytest.raises(DeleteException):
+        user.delete()

tests/unit/test_user_email.py

@@ -0,0 +1,37 @@
+"""Test email related User methods."""
+from pyramid.compat import text_type
+from pyramid_fullauth.models import User
+
+NEW_EMAIL = text_type('new@example.com')
+
+
+def test_set_new_email():
+    """
+    Test User.set_new_email method.
+
+    setting new email should result in setting new_email field,
+    and key used to activate the change.
+    """
+    user = User()
+    assert user.email_change_key is None
+    assert user.new_email is None
+    user.set_new_email(NEW_EMAIL)
+
+    assert user.new_email == NEW_EMAIL
+    assert user.email_change_key
+
+
+def test_change_email():
+    """
+    Test User.change_email method.
+
+    Calling it should copy new email set by set_new_email method
+    into regular email field.
+    """
+    user = User()
+    assert not user.email
+    user.set_new_email(NEW_EMAIL)
+    user.change_email()
+
+    assert not user.email_change_key
+    assert user.email == NEW_EMAIL

tests/unit/test_user_password.py

@@ -0,0 +1,52 @@
+"""Password related user model behaviour."""
+import pytest
+from pyramid.compat import text_type
+import transaction
+
+from pyramid_fullauth.models import User
+from pyramid_fullauth.exceptions import EmptyError
+
+
+def test_hash_checkout(db_session, user):
+    """User.check_password correct one."""
+    user = db_session.merge(user)
+    assert user.check_password(text_type('password1')) is True
+
+
+def test_hash_checkout_bad(db_session, user):
+    """User.check_password() wrong password."""
+    user = db_session.merge(user)
+    assert user.check_password(text_type('password2')) is False
+
+
+@pytest.mark.parametrize('password', ['haselko', 'haselko' * 1000])
+def test_password_change(db_session, user, password):
+    """User password change."""
+    new_password = text_type(password)
+
+    user = db_session.merge(user)
+    old_password = user.password
+    old_salt = user._salt
+    user.password = new_password
+    transaction.commit()
+
+    user = db_session.query(User).filter(User.username == text_type('u1')).one()
+    assert not user.password == old_password
+    assert not user._salt == old_salt
+    assert user.check_password(new_password)
+
+
+def test_password_empty(db_session, user):
+    """User try to set empty password."""
+    user = db_session.merge(user)
+
+    with pytest.raises(EmptyError):
+        user.password = text_type('')
+
+
+def test_set_reset(db_session, user):
+    """User.set_reset - generates reset key for those who forgot their password. """
+    user = db_session.merge(user)
+    assert not user.reset_key
+    user.set_reset()
+    assert user.reset_key

tests/unit/test_user_providers.py

@@ -0,0 +1,24 @@
+"""Test provider related user methods."""
+from pyramid.compat import text_type
+import transaction
+
+from pyramid_fullauth.models import User
+from pyramid_fullauth.models import AuthenticationProvider
+
+
+def test_user_provider_id(db_session, user):
+    """User provider_id returns proper provider identification."""
+    user = db_session.merge(user)
+    email = user.email
+    # Provider does not exists yet
+    assert not user.provider_id('email')
+
+    provider = AuthenticationProvider()
+    provider.provider = text_type('email')
+    provider.provider_id = email
+    user.providers.append(provider)
+    transaction.commit()
+
+    user = db_session.query(User).filter(User.email == email).one()
+    # Provider exists
+    assert user.provider_id('email') == email

tests/unit/test_user_repr.py

@@ -0,0 +1,29 @@
+"""Test user representation."""
+from pyramid.compat import text_type
+
+from pyramid_fullauth.models import User
+
+
+def test_introduce_email():
+    """user gets introduced by e-mail only."""
+    user = User()
+    user.email = text_type('test@test.pl')
+    # To string should return concatenated email
+    assert str(user) == 'test@...'
+
+
+def test_introduce_username():
+    """user gets introduced by username."""
+    user = User()
+    # 'User not saved should be represented by \'None\'')
+    assert str(user) == 'None'
+    user.id = 1
+    # if id is set, user should be presented with it
+    assert str(user) == '1'
+
+    user.email = text_type('test@test.pl')
+    user.username = text_type('testowy')
+    # To string should return username
+    assert str(user) == 'testowy'
+    # User should be represented by "<User (\'1\', \'testowy\')>"
+    assert user.__repr__() == "<User ('1', 'testowy')>"

tests/unit/test_validators.py

@@ -0,0 +1,44 @@
+"""Test various validators present on User class."""
+import pytest
+import transaction
+from pyramid.compat import text_type
+
+from pyramid_fullauth.models import User
+from pyramid_fullauth.exceptions import EmptyError, EmailValidationError
+
+
+@pytest.mark.parametrize('email', [
+    text_type('very.common@example.com'),
+    text_type('a.little.lengthy.but.fine@dept.example.com'),
+    text_type('disposable.style.email.with+symbol@example.com'),
+    text_type('"very.unusual.@.unusual.com"@example.com'),
+    text_type('!#$%&\'*+-/=?^_`{}|~@example.org'),
+    text_type('""@example.org'),
+    text_type('"much.more unusual"@example.com'),
+    text_type('"()<>[]:,;@\\\"!#$%&\'*+-/=?^_`{}| ~  ? ^_`{}|~.a"@example.org'),
+])
+def test_email_valid_formats(db_session, user, email):
+    """Check all valid formats of Email (RFC 5321) can be set by user."""
+    user = db_session.merge(user)
+
+    user.email = email
+    transaction.commit()
+
+    user = db_session.query(User).filter(
+        User.username == text_type('u1')).one()
+    assert user.email == email
+
+
+def test_email_empty(user):
+    """Test reaction of email validator for empty email."""
+    with pytest.raises(EmptyError):
+        user.email = text_type('')
+
+
+def test_email_invalid_formats(db_session, user, invalid_email):
+    """Check all invalid formats of Email (RFC 5321) can not be set by user."""
+    user = db_session.merge(user)
+
+    with pytest.raises(EmailValidationError):
+        user.email = invalid_email
+        db_session.commit()

tests/views/__init__.py

@@ -0,0 +1 @@
+"""Makes easier keeping some tests config with tests."""

tests/views/conftest.py

@@ -0,0 +1,15 @@
+"""General view fixtures."""
+import pytest
+import transaction
+
+from pyramid_fullauth.models import AuthenticationProvider
+
+
+@pytest.fixture
+def facebook_user(active_user, db_session):
+    """Facebook user."""
+    active_user = db_session.merge(active_user)
+    active_user.providers.append(
+        AuthenticationProvider(provider='facebook', provider_id='1234'))
+    transaction.commit()
+    return db_session.merge(active_user)

tests/views/test_activation.py

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+"""Account activation related tests."""
+from urllib import quote
+
+import pytest
+import transaction
+
+from pyramid_fullauth.models import User
+from tests.tools import authenticate, is_user_logged
+
+
+def test_account_activation(user, db_session, default_app):
+    """Activate user."""
+    user = db_session.merge(user)
+
+    default_app.get('/register/activate/' + user.activate_key)
+    transaction.commit()
+    user = db_session.query(User).filter(User.email == user.email).one()
+
+    assert not user.activate_key
+    assert user.is_active
+    assert user.activated_at
+
+    authenticate(default_app)
+    assert is_user_logged(default_app) is True
+
+
+def test_account_activation_wrong_key(user, db_session, default_app):
+    """Activate user with wrong key."""
+    user = db_session.merge(user)
+    activate_key = user.activate_key
+    res = default_app.get('/register/activate/' + activate_key[:-5], status=200)
+    transaction.commit()
+
+    assert 'Invalid activation code' in res.body
+
+    user = db_session.query(User).filter(User.email == user.email).one()
+    assert user.activate_key == activate_key
+    assert user.activate_key is not None
+    assert not user.activated_at
+    # User should not have active account at this moment
+    assert not user.is_active
+
+
+def test_account_activation_key_with_trash_chars(user, db_session, default_app):
+    """Strange characters in activation key."""
+    if db_session.connection().dialect.name == 'mysql':
+        pytest.xfail("failing due mysql default character set being latin1 and collation latin1_swedish_ci")
+
+    user = db_session.merge(user)
+
+    activate_key = user.activate_key
+    res = default_app.get('/register/activate/' + quote(
+        u'ąśðłĸ곶→łęóħó³→←śðđ[]}³½ĸżćŋðń→↓ŧ¶ħ→ĸł¼²³↓←ħ@ĸđśðĸ@ł¼ęłśħđó[³²½łðśđħ'.encode('utf-8')),
+        status=200
+    )
+    transaction.commit()
+
+    assert 'Invalid activation code' in res.body
+    user = db_session.query(User).filter(User.email == user.email).one()
+
+    assert user.activate_key == activate_key
+    assert user.activate_key is not None
+    assert not user.activated_at
+    # User should not have active account at this moment
+    assert not user.is_active
+
+
+def test_account_activation_twice(user, db_session, default_app):
+    """Click activation link twice."""
+    user = db_session.merge(user)
+
+    activate_key = user.activate_key
+    res = default_app.get('/register/activate/' + activate_key)
+    transaction.commit()
+    user = db_session.query(User).filter(User.email == user.email).one()
+
+    assert not user.activate_key
+    assert user.is_active
+    assert user.activated_at
+
+    res = default_app.get('/register/activate/' + activate_key, status=200)
+    assert 'Invalid activation code' in res.body