Planet Python francophone

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 ):
========================================
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 %}

{{MYOPENID_USERNAME}}.myopenid.com/" />
{{MYOPENID_USERNAME}}.myopenid.com" />

XRDS-Location" content="http://www.myopenid.com/xrds?username={{MYOPENID_USERNAME}}.myopenid.com" />
{% endif %}

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

publishconf.py
MYOPENID_USERNAME = 'me'

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

theme/templates/twitter.html
{% if TWITTER_USERNAME and share_url and share_title %}
{{TWITTER_USERNAME}}" data-related="{{TWITTER_USERNAME}}" data-url="{{share_url}}" data-text="{{share_title|striptags}}">Tweet
{% endif %}

theme/templates/flattr.html
{% if FLATTR_USERNAME and share_url and share_title %}

    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}}

{% endif %}

theme/templates/plusone_script.html
{% if PLUS_ONE and SITEURL %}

{% endif %}

theme/templates/twitter_script.html
{% if TWITTER_USERNAME and SITEURL %}

{% endif %}

theme/templates/flattr_script.html
{% if FLATTR_USERNAME and SITEURL %}

{% 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

{% 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) -%}

        {% if active_page == 'index' %}class="active"{% endif %}>
            {{ SITEURL }}/">Accueil

        {% if active_page == 'category' %}class="active"{% endif %}>{{ SITEURL }}/categories">Catégories

                {% for cat, null in categories %}
                {{ SITEURL }}/{{ cat.url }}">{{ cat }}
                {% endfor %}

        {% if DISPLAY_PAGES_ON_MENU %}
        {% for pag in PAGES %}
            {% if page == pag %}class="active"{% endif %}>
                {{ SITEURL }}/{{ pag.url }}">{{ pag.title }}

        {% endfor %}
        {% endif %}

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
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,
}

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

extras/404.html
{% extends "base.html" %}
{% block content_title %}Erreur 404{% endblock %}
{% block content %}

    Erreur 404
    La page que vous cherchez n'existe pas.

{% 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\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()

Planet Python francophone

[afpyro] AFPyro à Lyon - le 22 mai 2013

[afpy.org] Solution linux 2013 à Paris

[carlchenet] Vrac de mini-messages n°2

[tarek] A step-by-step introduction to Circus

Installation

Usage

Interaction

Next steps

[anybox] Python : compréhension des intensions en 1 minute

[Biologeek] Une quête de sens

Ce qui a bien marché

Ce qui pourrait être amélioré

Et la suite ?

[carlchenet] Les nouveautés de Python 3.3 (GLMF)

[anybox] Python : comprendre les docstrings en 1 minute

[tarek] FaitMain magazine #2

[sciunto] Et si github fermait ?

[afpyro] AFPyro à Bruxelles (BE) - vendredi 10 Mai

Horaire

[ascendances] Évolution du nombre de messages sur debian-l10n-fr et debian-users-fr avec pychart

[sciunto] Des logiciels pour être efficace

[afpyro] AFPyro à Toulouse le 30 avril 2013

[tarek] Thoughts on Load Testing

Starting Loads

[Biologeek] Des API et des hommes

[afpyro] AFPyro à Lyon - le 24 avril 2013

[afpyro] AFPyro à Paris - le 19 avril 2013

[Biologeek] Passage à l'échelle

[logilab] Pylint 10th years anniversary from June 17 to 19 in Toulouse

[logilab] Pylint development moving to BitBucket

[novapost] Django1.5 : passer au Configurable User Model

Contexte

La problématique

Création de account_rh2user et modification des migrations

Création de auth_user puis renommage

Conclusion

[ascendances] Cohabitation Jinja et AngularJS

[tshirtman] Kivy hackathon in paris

[Biologeek] Être geek

[tarek] Declaring dependencies in Python

Nature of your project

Library & tools

End-user application

[sciunto] Mat : supprimer les métadonnées de fichiers

[Biologeek] Manuel vs. jardin

[afpy.org] Le nouveau site de l'AFPy

[Biologeek] Propriéterre

[blog.afpy.org] Comment écrire un blog post ?

[logilab] PyLint 10th years anniversary, 1.0 sprint

[QuiSaura] Python et les boucles imbriquées via itertools.product

[Biologeek] Fondée sur des valeurs

[tarek] News from the Quality front

Flake8 plugins

Mailing list

[afpyro] AFPyro à Lyon - le 27 mars 2013

[noirbizarre] Huit recettes pour Pelican

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

Erreur 404

Publication par git post-receive hook

[Biologeek] Éduquer à la joie

[Biologeek] Accompagnement EMI

[novapost] Django : Comment booster ses tests en 1 minute

Introduction

Connexion, views et tests

À un problème, une solution

Et en pratique ?

Conclusion

Références

[Inspyration] Python.org : Visualisez le nouveau site

[novapost] Python decorators made easy

Decorators are tricky to develop and use

Hello world example

Wrapping functions with functools

`as_view()` is not enough

Mimic `as_view()`

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