pyramid-fullauth 0.4.0__py3.4.egg

tests/conftest.py

@@ -0,0 +1,201 @@
+"""Most of the fixtures needed."""
+import sys
+
+from mock import Mock
+import pytest
+
+import transaction
+from sqlalchemy import create_engine
+from sqlalchemy.orm import scoped_session, sessionmaker
+from sqlalchemy.pool import NullPool
+from zope.sqlalchemy import ZopeTransactionExtension
+
+from pyramid.compat import text_type
+from pytest_pyramid import factories
+import pyramid_basemodel
+
+py2only = pytest.mark.skipif(
+    sys.version_info.major > 2,
+    reason='oauth2-python and velruse does not support python3')
+
+
+@pytest.fixture
+def web_request():
+    """Mocked web request for views testing."""
+    request = Mock()
+    config = Mock()
+    config.configure_mock(
+        **{'fullauth.register.password':
+            {'length_min': 8, 'confirm': True},
+            'POST': {'confirm_password': '987654321'}
+           }
+    )
+
+    def _(message, *args, **kwargs):
+        return message
+    request._ = Mock(side_effect=_)
+    request.configure_mock(
+        **{'registry': {'config': config}}
+    )
+
+    return request
+
+if sys.version_info.major == 2:
+    databases = ['sqlite', 'mysql', 'postgresql']
+else:
+    databases = ['sqlite']
+
+
+@pytest.fixture(scope='function', params=databases)
+def db_session(request):
+    """SQLAlchemy session."""
+    from pyramid_fullauth.models import Base
+
+    if request.param == 'sqlite':
+        connection = 'sqlite:///fullauth.sqlite'
+    elif request.param == 'mysql':
+        request.getfuncargvalue('mysqldb')  # takes care of creating database
+        connection = 'mysql+mysqldb://root:@127.0.0.1:3307/tests?charset=utf8'
+    elif request.param == 'postgresql':
+        request.getfuncargvalue('postgresql')  # takes care of creating database
+        connection = 'postgresql+psycopg2://postgres:@127.0.0.1:5433/tests'
+
+    engine = create_engine(connection, echo=False, poolclass=NullPool)
+    pyramid_basemodel.Session = scoped_session(sessionmaker(extension=ZopeTransactionExtension()))
+    pyramid_basemodel.bind_engine(engine, pyramid_basemodel.Session, should_drop=True)
+
+    def destroy():
+        transaction.commit()
+        Base.metadata.drop_all(engine)
+
+    request.addfinalizer(destroy)
+
+    return pyramid_basemodel.Session
+
+
+@pytest.fixture
+def user(db_session):
+    """Default user."""
+    from pyramid_fullauth.models import User
+    from tests.tools import DEFAULT_USER
+    user = User(**DEFAULT_USER)
+    db_session.add(user)
+    transaction.commit()
+    return user
+
+
+@pytest.fixture
+def active_user(user, db_session):
+    """Active user."""
+    user = db_session.merge(user)
+    user.is_active = True
+    transaction.commit()
+    return user
+
+
+@pytest.fixture(params=[
+    # (an @ character must separate the local and domain parts)
+    text_type('Abc.example.com'),
+    # (character dot(.) is last in local part)
+    text_type('Abc.@example.com'),
+    # (character dot(.) is double)
+    text_type('Abc..123@example.com'),
+    # (only one @ is allowed outside quotation marks)
+    text_type('A@b@c@example.com'),
+    # (none of the special characters in this local part is allowed outside quotation marks)
+    text_type('a"b(c)d,e:f;g<h>i[j\k]l@example.com'),
+    # (quoted strings must be dot separated, or the only element making up the local-part)
+    text_type('just"not"right@example.com'),
+    # (spaces, quotes, and backslashes may only exist when within quoted strings and preceded by a backslash)
+    text_type('this is"not\allowed@example.com'),
+    # (even if escaped (preceded by a backslash), spaces, quotes, and backslashes must still be contained by quotes)
+    text_type('this\ still\"not\\allowed@example.com'),
+    text_type('bad-mail'),
+])
+def invalid_email(request):
+    """Parametrized fixture with all the incorrect emails."""
+    return request.param
+
+
+default_config = factories.pyramid_config({
+    'pyramid.includes': [
+        'pyramid_tm',
+        'pyramid_fullauth'
+    ]
+})
+
+
+extended_config = factories.pyramid_config({
+    'pyramid.includes': [
+        'pyramid_tm',
+        'pyramid_fullauth',
+        'tests.tools.include_views'
+    ]
+})
+
+
+short_config = factories.pyramid_config({
+    'yml.location': 'tests:config/short_memory.yaml',
+    'pyramid.includes': [
+        'pyramid_tm',
+        'tzf.pyramid_yml',
+        'pyramid_fullauth',
+        'tests.tools.include_views'
+    ]
+})
+
+
+social_config = factories.pyramid_config({
+    'yml.location': 'tests:config/social.yaml',
+    'pyramid.includes': [
+        'pyramid_tm',
+        'tzf.pyramid_yml',
+        'pyramid_fullauth',
+        'tests.tools.include_views'
+    ]
+})
+
+
+authable_config = factories.pyramid_config({
+    'yml.location': 'tests:config',
+    'env': 'login',
+    'pyramid.includes': [
+        'pyramid_tm',
+        'tzf.pyramid_yml',
+        'pyramid_fullauth',
+        'tests.tools.include_views'
+    ]
+})
+
+
+nopassconfirm_config = factories.pyramid_config({
+    'yml.location': 'tests:config/no_password_confirm.yaml',
+    'env': 'login',
+    'pyramid.includes': [
+        'pyramid_tm',
+        'tzf.pyramid_yml',
+        'pyramid_fullauth',
+        'tests.tools.include_views'
+    ]
+})
+
+
+nopassregister_config = factories.pyramid_config({
+    'yml.location': 'tests:config/no_password_register.yaml',
+    'env': 'login',
+    'pyramid.includes': [
+        'pyramid_tm',
+        'tzf.pyramid_yml',
+        'pyramid_fullauth',
+        'tests.tools.include_views'
+    ]
+})
+
+
+default_app = factories.pyramid_app('default_config')
+extended_app = factories.pyramid_app('extended_config')
+short_app = factories.pyramid_app('short_config')
+social_app = factories.pyramid_app('social_config')
+authable_app = factories.pyramid_app('authable_config')
+nopassconfirm_app = factories.pyramid_app('nopassconfirm_config')
+nopassregister_app = factories.pyramid_app('nopassregister_config')

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=303):
+    """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,69 @@
+"""Unittest for social login view."""
+import pytest
+import mock
+from pyramid.compat import text_type
+
+from pyramid_fullauth.views.social import SocialLoginViews
+from tests.conftest import py2only
+
+
+@py2only
+@pytest.mark.parametrize('profile, email', [
+    (
+        {
+            'accounts': [{'domain': text_type('facebook.com'), 'userid': text_type('2343')}],
+            'displayName': text_type('teddy'),
+            'verifiedEmail': text_type('verified@email.co.uk'),
+            'preferredUsername': text_type('teddy'),
+            'emails': [{'value': text_type('aasd@bwwqwe.pl')}],
+            'name': text_type('ted')
+        },
+        'verified@email.co.uk'
+    ), (
+        {
+            'accounts': [{'domain': text_type('facebook.com'), 'userid': text_type('2343')}],
+            'displayName': text_type('teddy'),
+            'preferredUsername': text_type('teddy'),
+            'emails': [{'value': text_type('aasd@bwwqwe.pl')}],
+            'name': text_type('ted')
+        },
+        'aasd@bwwqwe.pl'
+    ), (
+        {
+            'accounts': [{'domain': text_type('facebook.com'), 'userid': text_type('2343')}],
+            'displayName': text_type('teddy'),
+            'preferredUsername': text_type('teddy'),
+            'emails': [{}],
+            'name': text_type('ted')
+        },
+        '2343@facebook.com'
+    ), (
+        {
+            'accounts': [{'domain': text_type('facebook.com'), 'userid': text_type('2343')}],
+            'displayName': text_type('teddy'),
+            'preferredUsername': text_type('teddy'),
+            'emails': [],
+            'name': text_type('ted')
+        },
+        '2343@facebook.com'
+    ), (
+        {
+            'accounts': [{'domain': text_type('facebook.com'), 'userid': text_type('2343')}],
+            'displayName': text_type('teddy'),
+            'preferredUsername': text_type('teddy'),
+            'name': text_type('ted')
+        },
+        '2343@facebook.com'
+    ),
+])
+def test_email_from_context(profile, email):
+    """Test email_from_context email getting method."""
+    from velruse import AuthenticationComplete
+    context = AuthenticationComplete(
+        profile,
+        {'oauthAccessToken': '7897048593434'},
+        text_type('facebook'),
+        text_type('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\')>"
+    assert user.__repr__() == "<User ('1')>"