Planète AFPy

circus

$ sudo apt-get install libzmq-dev libevent python-virtualenv

$ virtualenv /tmp/circus
$ cd /tmp/circus
$ bin/pip install circus
$ bin/pip install circus-web
$ bin/pip install chaussette

$ bin/chaussette

[circus]
stats_endpoint = tcp://127.0.0.1:5557
httpd = 1

[watcher:webapp]
cmd = bin/chaussette --fd $(circus.sockets.web)
numprocesses = 3
use_sockets = True

[socket:web]
host = 127.0.0.1
port = 9999

$ bin/circusd --daemon circus.ini

$ bin/circusctl
circusctl 0.7.1
circusd-stats: active
circushttpd: active
webapp: active
(circusctl)

(circusctl) help

Documented commands (type help <topic>):
========================================
add     get            list         numprocesses  quit     rm      start   stop
decr    globaloptions  listen       numwatchers   reload   set     stats
dstats  incr           listsockets  options       restart  signal  status

Undocumented commands:
======================
EOF  help

(circusctl) list webapp
13712,13713,13714
(circusctl) incr webapp
4
(circusctl) list webapp
13712,13713,13714,13973

$ bin/circus-top

$ bin/circusctl quit
ok

import unittest
from loads import Session

class TestWebSite(unittest.TestCase):

    def setUp(self):
        self.session = Session()

    def test_something(self):
        res = self.session.get('http://blog.ziade.org')
        self.assertTrue('Tarek' in res.content)

$ bin/loads test_blog.TestWebSite.test_something -c 10 -n 10
[====================================================================================================]  100%

django.contrib.auth.User
get_profile()
AUTH_PROFILE_MODULE
from django.db import models
from django.contrib.auth.models import User

class RH2User(User):

    class Meta:
        proxy = True

    ...

class RH2UserProfile(models.Model):
    some_field = models.CharField(max_length=50)
    some_other_field = models.BooleanField()

    def some_method(self):
        ...

from django.db import models
from django.contrib.auth.models import AbstractUser

class RH2User(AbstractUser):
    some_field = models.CharField(max_length=50)
    some_other_field = models.BooleanField()

    def some_method(self):
        ...

save()
RH2UserProfile.last_login
RH2User.previous_last_login
auth.User
last_login
RH2UserProfile
get_profile()
rh2userprofile__
.user
AUTH_USER_MODEL
auth_user
auth_user_user_permissions
auth_user_groups
python
manage.py syncdb
RH2User
AUTH_USER_MODEL = 'account.RH2User'
account_rh2user
auth_user
auth_user
auth_user_user_permissions
auth_user_groups
auth_user
account_rh2user
auth_user
account_rh2user
0001_initial
$ python manage.py schemamigration account

account/migrations/0001_initial.py
auth_user
account_rh2user
auth_user
auth_user_user_permissions
auth_user_groups
0001_initial
auth_user
account_rh2user
account_rh2user
south_migrationhistory
$ python manage.py convert_to_south ....

db_table = 'auth_user'
RH2User
try:
    from setuptools import setup

    install_requires = ['gevent', 'requests']

    try:
        import argparse
    except ImportError:
        install_requires.append('argparse')

    kws = {'install_requires': install_requires}
except ImportError:
    from distutils.core import setup
    kws = {}

setup(name='yourproject', version='1.1', etc.., **kws)

gevent==0.13.8
requests==1.2.0
argparse==1.2.1

hg clone http://hg.afpy.org/blog

make install

hg add votre_fichier.py
hg commit -m "votre message" -u username
hg push

├── articles
│   ├── categorie1
│   │   └─ article.rst
│   └── categorie2
├── extras
│   ├─ 404.html
│   └─ robots.txt
├── images
│   ├── theme1
│   │   └─ image.png
│   ├── theme2
│   │   └─ image.png
│   └─ image.png
├── local_plugins
│   └─ plugin.py
├── pages
│   └─ page.rst
├── theme
│   ├── static
│   │   ├── css
│   │   └── images
│   └── templates
│       ├─ template1.html
│       └─ template2.html
├─ .gitignore
├─ Makefile
├─ nginx.conf
├─ pelicanconf.py
├─ publish.sh
├─ publishconf.py
└─ requirements.pip

pelicanconf.py
PATH = dirname(__file__)
OUTPUT_PATH = join(PATH, 'output')
ARTICLE_DIR = 'articles'
THEME = 'theme'
STATIC_PATHS = ("images", )
FILES_TO_COPY = (
    ('extras/robots.txt', 'robots.txt'),
)
PLUGINS = (
    'pelican.plugins.gzip_cache',
    'pelican.plugins.sitemap',
    'local_plugins.plugin'
)

theme/templates/myopenid.html
{% if MYOPENID_USERNAME %}
<link rel="openid.server" href="http://www.myopenid.com/server" />
<link rel="openid.delegate" href="http://{{MYOPENID_USERNAME}}.myopenid.com/" />
<link rel="openid2.local_id" href="http://{{MYOPENID_USERNAME}}.myopenid.com" />
<link rel="openid2.provider" href="http://www.myopenid.com/server" />
<meta http-equiv="X-XRDS-Location" content="http://www.myopenid.com/xrds?username={{MYOPENID_USERNAME}}.myopenid.com" />
{% endif %}

<head>
theme/templates/base.html
{% include 'myopenid.html' %}

publishconf.py
MYOPENID_USERNAME = 'me'

SITEURL
theme/templates/plusone.html
{% if PLUS_ONE and share_url %}
<span class="g-plusone" data-href="{{ share_url }}" data-size="medium"></span>
{% endif %}

theme/templates/twitter.html
{% if TWITTER_USERNAME and share_url and share_title %}
<a href="http://twitter.com/share" class="twitter-share-button" data-count="horizontal" data-via="{{TWITTER_USERNAME}}" data-related="{{TWITTER_USERNAME}}" data-url="{{share_url}}" data-text="{{share_title|striptags}}">Tweet</a>
{% endif %}

theme/templates/flattr.html
{% if FLATTR_USERNAME and share_url and share_title %}
<a class="FlattrButton" style="display:none;"
    title="{{share_title}}" href="{{share_url}}"
    data-flattr-uid="{{FLATTR_USERNAME}}"
    {% if article and article.tags %}data-flattr-tags="{{article.tags|join(',')}}"{% endif %}
    {% if FLATTR_LANG  %}data-flattr-language="{{FLATTR_LANG}}"{% endif %}
    data-flattr-button="compact"
    data-flattr-category="text">
    {{share_title}}
</a>
{% endif %}

theme/templates/plusone_script.html
{% if PLUS_ONE and SITEURL %}
<script type="text/javascript">
  window.___gcfg = {lang: '{{PLUS_ONE_LANG}}'};
  (function() {
    var po = document.createElement('script'); po.type = 'text/javascript'; po.async = true;
    po.src = 'https://apis.google.com/js/plusone.js';
    var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(po, s);
  })();
</script>
{% endif %}

theme/templates/twitter_script.html
{% if TWITTER_USERNAME and SITEURL %}
<script>!function(d,s,id){var js,fjs=d.getElementsByTagName(s)[0];if(!d.getElementById(id)){js=d.createElement(s);js.id=id;js.src="https://platform.twitter.com/widgets.js";fjs.parentNode.insertBefore(js,fjs);}}(document,"script","twitter-wjs");</script>
{% endif %}

theme/templates/flattr_script.html
{% if FLATTR_USERNAME and SITEURL %}
<script type="text/javascript">
(function() {
    var s = document.createElement('script');
    var t = document.getElementsByTagName('script')[0];
    s.type = 'text/javascript';
    s.async = true;
    s.src = '//api.flattr.com/js/0.6/load.js?mode=auto';
    t.parentNode.insertBefore(s, t);
})();
</script>
{% endif %}

{% if SITEURL %}
    {%- set share_url = [SITEURL, article.url]|join('/') -%}
    {%- set share_title = article.title -%}
    {% include 'twitter.html' %}
    {% include 'plusone.html' %}
    {% include 'flattr.html' %}
{% endif %}

share_url
share_title
theme/templates/base.html
<body>
{% if SITEURL %}
    {% include 'twitter_script.html' %}
    {% include 'plusone_script.html' %}
    {% include 'flattr_script.html' %}
{% endif %}

pelicanconf.py
TWITTER_USERNAME = 'me'

FLATTR_USERNAME = "me"
FLATTR_LANG = "fr_FR"

PLUS_ONE = True
PLUS_ONE_LANG = 'fr'

urlencode
pelicanconf.py
import urllib
from jinja2.utils import Markup

def urlencode_filter(s):
    if type(s) == 'Markup':
        s = s.unescape()
    s = s.encode('utf8')
    s = urllib.quote_plus(s)
    return Markup(s)

JINJA_FILTERS = {
    'urlencode': urlencode_filter,
}

theme/templates/base.html
active_page
{%- set active_page = active_page|default(None) -%}
<nav id="menu">
    <ul>
        <li {% if active_page == 'index' %}class="active"{% endif %}>
            <a href="{{ SITEURL }}/">Accueil</a>
        </li>
        <li {% if active_page == 'category' %}class="active"{% endif %}><a href="{{ SITEURL }}/categories">Catégories</a>
            <ul>
                {% for cat, null in categories %}
                <li><a href="{{ SITEURL }}/{{ cat.url }}">{{ cat }}</a></li>
                {% endfor %}
            </ul>
        </li>
        {% if DISPLAY_PAGES_ON_MENU %}
        {% for pag in PAGES %}
            <li {% if page == pag %}class="active"{% endif %}>
                <a href="{{ SITEURL }}/{{ pag.url }}">{{ pag.title }}</a>
            </li>
        {% endfor %}
        {% endif %}
    </ul>
</nav>

theme/templates/index.html
{% extends "base.html" %}
{% set active_page = 'index' -%}

theme/templates/categories.html
{% extends "base.html" %}
{% set active_page = "category" %}

theme/templates/category.html
{% extends "base.html" %}
{% set active_page = 'category' -%}

<meta>
META
pelicanconf.py
from pelican import __version__ as PELICAN_VERSION
METAS = {
    'author': u'Me',
    'description': u"My blog description",
    'keywords': u'some, keywords, for, seo',
    'generator': u'Pelican %s' % PELICAN_VERSION,
}

<head>
theme/templates/base.html
{% for name, content in METAS.iteritems() %}
<meta name="{{name}}" content="{{content}}" />
{% endfor %}

extras/404.html
{% extends "base.html" %}
{% block content_title %}Erreur 404{% endblock %}
{% block content %}
<section class="body page">
    <h1 class="page-title">Erreur 404</h1>
    La page que vous cherchez n'existe pas.
</section>
{% endblock content %}

pelicanconf.py
TEMPLATE_PAGES = {'extras/404.html': '404.html'}

server {
    # ...
    error_page 404 /404.html;
    # ...
}

sitemap.xml
nginx.conf
requirements.pip
virtualenv
blog.git/hooks/post-receive
#!/bin/sh

STAGING="/home/me/staging/blog"

GIT_WORK_TREE=$STAGING git checkout -f
cd $STAGING
./publish.sh

publish.sh
#!/bin/sh

VENV="venv"
PUBLIC="/path/to/your/public/blog"
SITEMAP=http://your.blog/sitemap.xml.gz

# Setup virtualenv
if [ ! -d "$VENV" ]; then
    virtualenv --distribute $VENV
fi
. $VENV/bin/activate
pip install -r requirements.pip --use-mirrors

# Deploy blog
pelican -v -o $PUBLIC -s publishconf.py
cp -f nginx.conf /etc/nginx/sites-available/your.blog
sudo service nginx reload

# Ping sitemap
GOOGLE=http://www.google.com/webmasters/tools/ping?sitemap=$SITEMAP
BING=http://www.bing.com/webmaster/ping.aspx?siteMap=$SITEMAP

for url in $GOOGLE $BING; do
    curl -s -w "%{http_code} %{url_effective}\\n" "$url" -o /dev/null
done

# Reload nginx command
Cmnd_Alias NGINX_RELOAD = /usr/sbin/service nginx reload

# User privilege specification
me  ALL=NGINX_RELOAD, NOPASSWD: NGINX_RELOAD

user_passes_test
login_required
PASSWORD_HASHER
# -*- coding: utf-8 -*-
from django.contrib.auth.hashers import BasePasswordHasher, mask_hash
from django.utils.datastructures import SortedDict

class PlainPasswordHasher(BasePasswordHasher):
    """
    The plain password hashing algorithm for test (DO NOT USE in production)
    """
    algorithm = "plain"

    def salt(self):
        return ''

    def encode(self, password, salt):
        return '%s$$%s' % (self.algorithm, password)

    def verify(self, password, encoded):
        algorithm, hash = encoded.split('$$', 1)
        assert algorithm == self.algorithm
        return password == hash

    def safe_summary(self, encoded):
        return SortedDict([
            ('algorithm', self.algorithm),
            ('hash', mask_hash(encoded, show=3)),
        ])

from myapp.settings import *
PASSWORD_HASHERS = (
    'myapp.hashers.PlainPasswordHasher',
),

from myapp.settings import *
PASSWORD_HASHERS = ['myapp.hashers.PlainPasswordHasher'] + list(PASSWORD_HASHERS)

UnsaltedMD5PasswordHasher
PlainTextPasswordHasher
UnsaltedMD5PasswordHasher
def moo(func):
    def decorated(*args, **kwargs):
        print 'moo'
        return func(*args, **kwargs)  # Run decorated function.
    return decorator

>>> @moo
... def i_am_a(kind):
...     print "I am a {kind}".format(kind=kind)
>>> i_am_a("duck")
'moo'
'I am a duck'

def speak(word='moo'):
    def decorator(func):
        def decorated(*args, **kwargs):
            print word
            return func(*args, **kwargs)
        return decorated
    return decorator

>>> @speak('quack')
... def i_am_a(kind):
...     print "I am a {kind}".format(kind=kind)
>>> i_am_a("duck")
'quack'
'I am a duck'

@speak
@moo
@speak()
class Greeter(Decorator):
    """Greet return value of decorated function."""
    def setup(self, greeting='hello'):
        self.greeting = greeting

    def run(self, *args, **kwargs):
        name = super(Greeter, self).run(*args, **kwargs)
        return '{greeting} {name}!'.format(greeting=self.greeting, name=name)

>>> @Greeter
... def world():
...     return 'world'
>>> world()
'hello world!'

>>> @Greeter()
... def world():
...     return 'world'
>>> world()
'hello world!'

greeting
>>> @Greeter(greeting='goodbye')
... def world():
...     return 'world'
>>> world()
'goodbye world!'

greeting
'hello'
>>> my_greeter = Greeter()
>>> my_greeter.greeting
'hello'

>>> my_greeter = Greeter(greeting='hi')
>>> @my_greeter
... def world():
...     return 'world'
>>> world()
'hi world!'

>>> my_greeter = Greeter()
>>> my_greeter.greeting = 'bonjour'
>>> @my_greeter
... def world():
...     return 'world'
>>> world()
'bonjour world!'

>>> @Greeter
... def name(value):
...     return value
>>> name('world')
'hello world!'

>>> @Greeter(greeting='goodbye')
... def names(*args):
...     return ' and '.join(args)
>>> names('Laurel', 'Hardy')
'goodbye Laurel and Hardy!'

import functools

class Chameleon(Decorator):
    """A Decorator that looks like decorated function.

    It uses ``functools.update_wrapper``.

    This is a base class which acts as a transparent proxy for the
    decorated function. Consider overriding the ``run()`` method.

    .. warning::

       Take care of what you pass in ``assigned`` or ``updated``: you could
       break the Chameleon itself. As an example, you should not pass "assigned",
       "run" or "__call__" in ``assigned``, except you know what you are doing.

    """
    def setup(self,
              assigned=functools.WRAPPER_ASSIGNMENTS,
              updated=functools.WRAPPER_UPDATES):
        self.assigned = assigned
        self.updated = updated

    def decorate(self, func):
        """Make self wrap the decorated function."""
        super(Chameleon, self).decorate(func)
        functools.update_wrapper(self, func,
                                 assigned=self.assigned,
                                 updated=self.updated)

>>> @Chameleon
... def documented():
...     '''Fake function with a docstring.'''
>>> documented.__doc__
'Fake function with a docstring.'

assigned
updated
functools.update_wrapper
functools.WRAPPER_ASSIGNMENTS
assigned
updated
>>> def hello():
...    '''Hello world!'''
>>> wrapped = Chameleon(hello)
>>> wrapped.assigned
('__module__', '__name__', '__doc__')
>>> wrapped.updated
('__dict__',)
>>> wrapped.__doc__ == hello.__doc__
True
>>> wrapped.__name__ == hello.__name__
True

>>> only_doc_wrapped = Chameleon(hello, assigned=['__doc__'])
>>> only_doc_wrapped.__doc__ == hello.__doc__
True
>>> only_doc_wrapped.__name__ == hello.__name__  # Doctest: +ELLIPSIS
Traceback (most recent call last):
    ...
AttributeError: 'Chameleon' object has no attribute '__name__'

>>> hello.__dict__ = {'some_attribute': 'some value'}  # Best on an object.
>>> attr_wrapped = Chameleon(hello, updated=['__dict__'])
>>> attr_wrapped.updated
['__dict__']
>>> attr_wrapped.some_attribute
'some value'

functools.wraps
from functools import wraps
from django.utils.decorators import available_attrs

def authenticated_user_passes_test(test_func,
                                   unauthorized=UnauthorizedView.as_view(),
                                   forbidden=ForbiddenView.as_view()):
    """Make sure user is authenticated and passes test."""
    def decorator(view_func):
        @wraps(view_func, assigned=available_attrs(view_func))
        def _wrapped_view(request, *args, **kwargs):
            if not request.user.is_authenticated():
                return unauthorized(request)
            if not test_func(request.user):
                return forbidden(request)
            return view_func(request, *args, **kwargs)

class authenticated_user_passes_test(Chameleon):
    """Make sure user is authenticated and passes test."""
    def setup(self, **kwargs):
        try:
            self.test_func = kwargs.pop('test_func')
        except KeyError:
            raise TypeError('decorator requires "test_func" keyword argument')
        self.unauthorized = kwargs.pop('unauthorized', UnauthorizedView.as_view())
        self.forbidden = kwargs.pop('forbidden', ForbiddenView.as_view())
        super(authenticated_user_passes_test, self).setup(**kwargs)

    def run(self, request, *args, **kwargs):
        if not request.user.is_authenticated():
            return self.unauthorized(request)
        if not self.test_func(request.user):
            return self.forbidden(request)
        return = super(authenticated_user_passes_test, self).run(request, *args, **kwargs)

test_func
class Decorator(object):
    """Base class to easily create convenient decorators.

    Override :py:meth:`setup`, :py:meth:`run` or :py:meth:`decorate` to create
    custom decorators.

    Decorator instances are callables. The :py:meth:`__call__` method has a
    special implementation in Decorator. Generally, consider overriding
    :py:meth:`run` instead of :py:meth:`__call__`.

    """
    def __init__(self, func=None, **kwargs):
        """Constructor.

        Accepts one optional positional argument: the function to decorate.

        Other arguments **must** be keyword arguments.

        And beware passing ``func`` as keyword argument: it would be used as
        the function to decorate.

        """
        self.setup(**kwargs)
        if func is not None:
            self.decorate(func)

    def decorate(self, func):
        """Remember the function to decorate."""
        self.decorated = func

    def setup(self, **kwargs):
        """Store decorator's options."""
        self.options = kwargs

    def __call__(self, *args, **kwargs):
        """Run decorated function if available, else decorate first arg."""
        try:
            self.decorated
        except AttributeError:
            func = args[0]
            self.decorate(func)
            return self
        else:
            return self.run(*args, **kwargs)

    def run(self, *args, **kwargs):
        """Actually run the decorator.

        This base implementation is a transparent proxy to the decorated
        function: it passes positional and keyword arguments as is, and returns
        result.

        """
        return self.decorated(*args, **kwargs)

>>> @Decorator
... def return_args(*args, **kwargs):
...    return (args, kwargs)
>>> return_args()
((), {})
>>> return_args(1, 2, three=3)
((1, 2), {'three': 3})

options
>>> @Decorator
... def nothing():
...    pass
>>> nothing.options
{}

>>> @Decorator()
... def nothing():
...    pass
>>> nothing.options
{}

>>> @Decorator(one=1)
... def nothing():
...    pass
>>> nothing.options
{'one': 1}

Decorator
setup()
run()
setup()
run()
tests.py
try:
    from unittest import mock
except ImportError:
    import mock

setup.py
# ...
requirements = []
try:
    from unittest import mock
except ImportError:
    requirements.append('mock')
# ...
setup(
    # ...
    install_requires(requirements),
    # ...
)

request = 'fake request'

request.user.is_authenticated()
request = mock.MagicMock()
request.user.is_authenticated = mock.MagicMock(return_value=True)

import unittest

class MockViewTestCase(unittest.TestCase):
    def test_stub(self):
        # Setup.
        request = 'fake request'
        view = mock.MagicMock(return_value='fake response')
        # Run.
        response = view(request)
        # Check.
        view.assert_called_once_with(request)
        self.assertEqual(response, view.return_value)

from django.http import HttpResponse

def hello_world(view_func):
    """Run the decorated view, but return "Hello world!"."""
    def decorated_view(request, *args, **kwargs):
        view_func(request, *args, **kwargs)
        return HttpResponse(u'Hello world!')
    return decorated_view

import unittest

class HelloWorldTestCase(unittest.TestCase):
    def test_hello_decorator(self):
        """hello_world decorator runs view and returns greetings."""
        # Setup.
        request = 'fake request'
        request_args = ('foo', )
        request_kwargs = {'bar': 'baz'}
        view = mock.MagicMock(return_value='fake response')
        # Run.
        decorated = hello_world(view)
        response = decorated(request, *request_args, **request_kwargs)
        # Check.
        # View was called.
        view.assert_called_once_with(request, *request_args, **request_kwargs)
        # But response is "Hello world!".
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.content, u"Hello world!")

unittest.TestCase
from functools import wraps

from django.utils.decorators import available_attrs

def authenticated_user_passes_test(test_func,
                                   unauthorized=UnauthorizedView.as_view(),
                                   forbidden=ForbiddenView.as_view()):
    """Make sure user is authenticated and passes test.

    This is an adaptation of
    ``django.contrib.auth.decorators.user_passes_test`` where:

    * if user is anonymous, the request is routed to ``unauthorized`` view.
      No additional tests are performed in that case.

    * if user is authenticated and doesn't pass ``test_func ``test, the
      request is routed to ``forbidden`` view.

    * else, request and arguments are passed to decorated view.

    Typical ``unauthorized`` view returns HTTP 401 status code and gives the
    user an opportunity to log in: access may be granted after
    authentication.

    Typical ``forbidden`` view returns HTTP 403 status code: with active
    user account, access is refused. As explained in rfc2616, 401 and 403
    status codes could be suitable.

    .. seealso::

       * http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.4
       * https://en.wikipedia.org/wiki/List_of_HTTP_status_codes

    """
    def decorator(view_func):
        @wraps(view_func, assigned=available_attrs(view_func))
        def _wrapped_view(request, *args, **kwargs):
            if not request.user.is_authenticated():
                return unauthorized(request)
            if not test_func(request.user):
                return forbidden(request)
            return view_func(request, *args, **kwargs)
        return _wrapped_view
    return decorator

from django.http import HttpResponse, HttpResponseForbidden
from django.views.generic import TemplateView

class HttpResponseUnauthorized(HttpResponse):
    status_code = 401

class UnauthorizedView(TemplateView):
    response_class = HttpResponseUnauthorized
    template_name = '401.html'

class ForbiddenView(TemplateView):
    response_class = HttpResponseForbidden
    template_name = '403.html'

request.user
test_func
unauthorized
forbidden
run_decorated_view
import unittest

class AuthenticatedUserPassesTestTestCase(unittest.TestCase):
    def setUp(self):
        """Common setup: fake request, stub views, stub user test function."""
        super(AuthenticatedUserPassesTestTestCase, self).setUp()
        # Fake request and its positional and keywords arguments.
        self.request = mock.MagicMock()
        self.request.user.is_authenticated = mock.MagicMock()
        self.request_args = ['fake_arg']
        self.request_kwargs = {'fake': 'kwarg'}
        # Mock user test function.
        self.test_func = mock.MagicMock()
        # Mock unauthorized and forbidden views.
        self.unauthorized_view = mock.MagicMock(
            return_value=u"401 - You may log in.")
        self.forbidden_view = mock.MagicMock(
            return_value=u"403 - Insufficient privileges.")
        # Mock the view to decorate.
        self.authorized_view = mock.MagicMock(
            return_value=u"200 - Greetings, Professor Falken.")

    def run_decorated_view(self, is_authenticated=True, user_passes_test=True):
        """Setup, decorate and call view, then return response."""
        # Custom setup.
        self.request.user.is_authenticated.return_value = is_authenticated
        self.test_func.return_value = user_passes_test
        # Get decorator.
        decorator = authenticated_user_passes_test(
            self.test_func,
            unauthorized=self.unauthorized_view,
            forbidden=self.forbidden_view)
        # Decorate view.
        decorated_view = decorator(self.authorized_view)
        # Return response.
        return decorated_view(self.request,
                              *self.request_args,
                              **self.request_kwargs)

    def test_unauthorized(self):
        """authenticated_user_passes_test first tests user authentication."""
        response = self.run_decorated_view(is_authenticated=False)
        # Check: unauthorized view was called with request as unique positional
        # argument.
        self.unauthorized_view.assert_called_once_with(self.request)
        self.assertEqual(response, self.unauthorized_view.return_value)
        # Test func was not called.
        self.assertFalse(self.test_func.called)
        # Of course, authorized and forbidden views were not called.
        self.assertFalse(self.authorized_view.called)
        self.assertFalse(self.forbidden_view.called)

    def test_test_func_args(self):
        """authenticated_user_passes_test passes user instance to test func."""
        self.run_decorated_view(is_authenticated=True)
        # Check: test_func was called with one argument: user instance.
        self.test_func.assert_called_once_with(self.request.user)

    def test_forbidden(self):
        """authenticated_user_passes_test runs forbidden view if user fails."""
        response = self.run_decorated_view(is_authenticated=True,
                                           user_passes_test=False)
        # Check: forbidden view was called with request as unique positional
        # argument.
        self.forbidden_view.assert_called_once_with(self.request)
        self.assertEqual(response, self.forbidden_view.return_value)
        # Of course, authorized and unauthorized views were not triggered.
        self.assertFalse(self.authorized_view.called)
        self.assertFalse(self.unauthorized_view.called)

    def test_authorized(self):
        """authenticated_user_passes_test runs view if user passes test."""
        response = self.run_decorated_view(is_authenticated=True,
                                           user_passes_test=True)
        # Check: decorated view has been called, request and other arguments
        # were proxied as is, response was not altered.
        self.authorized_view.assert_called_once_with(self.request,
                                                     *self.request_args,
                                                     **self.request_kwargs)
        self.assertEqual(response, self.authorized_view.return_value)
        # Of course, forbidden and unauthorized views were not triggered.
        self.assertFalse(self.forbidden_view.called)
        self.assertFalse(self.unauthorized_view.called)

authenticated_user_passes_test
self.client.get()
from django.http import Http404, HttpResponse

def hello(request, name):
    if name == u'Waldo'
        raise Http404("Where's Waldo?")
    return HttpResponse(u'Hello {name}!'.format(name=name))

import unittest

class HelloTestCase(unittest.TestCase):
    def test_get(self):
        """hello view actually tells 'Hello'."""
        # Setup.
        request = 'fake request'
        name = 'world'
        # Run.
        response = hello(request, name)
        # Check.
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.content, u'Hello world!')

    def test_waldo(self):
        """Cannot find Waldo to tell him 'Hello'."""
        # Setup.
        request = 'fake request'
        name = 'Waldo'
        # Run and check.
        self.assertRaises(Http404, hello, request, name)

from django.http import Http404, HttpResponse
from django.contrib.auth.decorators import login_required

@login_required
def hello(request, name):
    if name == u'Waldo'
        raise Http404("Where's Waldo?")
    return HttpResponse(u'Hello {name}!'.format(name=name))

hello()
login
hello
hello
login_required
login_required
hello
HttpRequest
dispatch()
from django.test import RequestFactory

request_factory = RequestFactory()
request = request_factory.post('/fake-path', data={'name': u'Waldo'})

path
request._messages
request.session
class HelloView(TemplateView):
    def get_context_data(self, **kwargs):
        kwargs = super(HelloView, self).get_context_data(**kwargs)
        kwargs.update('name', self.kwargs.get('name'))
        return kwargs

hello = HelloView.as_view(template_name='hello.html')
url(r'(?P<name>\w+)', hello)
as_view()
as_view()
RequestFactory
import unittest
from django.test import RequestFactory

class HelloViewTestCase(unittest.TestCase):
    def test_get(self):
        """HelloView.get() sets 'name' in response context."""
        # Setup name.
        name = 'peter'
        # Setup request and view.
        request = RequestFactory().get('/fake-path')
        view = HelloView.as_view(template_name='hello.html')
        # Run.
        response = view(request, name=name)
        # Check.
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.template_name[0], 'home.html')
        self.assertEqual(response.context_data['name'], name)

HelloView
get_context_data()
as_view()
as_view()
dispatch()
as_view()
as_view()
get_context_data()
as_view()
as_view()
def setup_view(view, request, *args, **kwargs):
    """Mimic as_view() returned callable, but returns view instance.

    args and kwargs are the same you would pass to ``reverse()``

    """
    view.request = request
    view.args = args
    view.kwargs = kwargs
    return view

import unittest
from django.test import RequestFactory

class HelloViewTestCase(unittest.TestCase):
    def test_context_data(self):
        """HelloView.get_context_data() sets 'name' in context."""
        # Setup name.
        name = 'django'
        # Setup request and view.
        request = RequestFactory().get('/fake-path')
        view = HelloView(template_name='hello.html')
        view = setup_view(view, request, name=name)
        # Run.
        context = view.get_context_data()
        # Check.
        self.assertEqual(context['name'], name)

get_context_data
TemplateView
TemplateView
as_view()
dispatch()
as_view()
request = RequestFactory().get('/fake-path')
view = HelloView.as_view(template_name='hello.html')
response = view(request, name='bob')

dispatch()
request = RequestFactory().get('/fake-path')
view = HelloView(template_name='hello.html')
view = setup_view(view, request, name='bob')
response = view.dispatch(view.request, *view.args, **view.kwargs)

dispatch()
TemplateView
get_context_data()
get_queryset()
Author.objects.all()
get_context_data()

Planète AFPy

Installation

Usage

Interaction

Next steps

Ce qui a bien marché

Ce qui pourrait être amélioré

Et la suite ?

Starting Loads

Contexte

La problématique

Création de account_rh2user et modification des migrations

Création de auth_user puis renommage

Conclusion

Nature of your project

Library & tools

End-user application

Flake8 plugins

Mailing list

Arborescence plate

Délégation d’authentification OpenID

Boutons Google +1, Twitter et Flattr

Filtre “urlencode” pour Jinja

Marquer la page active dans le menu

Balises META

Page d’erreur 404

Publication par git post-receive hook

Introduction

Connexion, views et tests

À un problème, une solution

Et en pratique ?

Conclusion

Références

Decorators are tricky to develop and use

Hello world example

Wrapping functions with functools

The Decorator class

Limitations

Benefits

See also

Use unittest.mock

Fake the request

Stub the decorated view

hello_world decorator

authenticated_user_passes_test decorator

References

Some issues...

Performance

Maintenance

Tests pass, deployment fail

Some clues...

A challenge

See also

self.client.get(): system tests for the unaware

Testing view functions

Use unittest or SimpleTestCase wherever you can

Don't decorate views in place

Use request factories

Testing class-based views

as_view() is not enough

Mimic as_view()

The fairy as_view() and the ugly dispatch()

What's next

References

`as_view()` is not enough

Mimic `as_view()`

The fairy `as_view()` and the ugly `dispatch()`