Unable to use urlresolvers (url,reverse ) feature in redirect argument of decorator user_passes_test

One other side effect of the issue describes above is that it breaks the url resolution for reverse, {%url%}, permalink and company. I have the case in one of my application where some views are protected by : """ @user_passes_test(lambda u: Group.objects.get(name='admin') in u.groups.all(), login_url=reverse("auth_login")) """ This lead to some nasty bugs in the url resolution of an other view.

I hope this description will help.

It looks like problem concerns not only user_passes_test. reverse() can't be used at all decorators of views. Since the decorators of your views are evaluated during parsing urls.py you have an 'chicken - egg' problem. The method reverse() can't be used since urls.py is not read.

The solution, I see, is to evaluate the reverse() lazy.

I do not know if this information can help. I have observed that @cache (decorator) does not trigger any error message.

I have this problem, too.

Here is my solution:

# file lazy.py
from django.core import urlresolvers

class lazy_string(object):
    def __init__(self, function, *args, **kwargs):
        self.function=function
        self.args=args
        self.kwargs=kwargs
        
    def __str__(self):
        if not hasattr(self, 'str'):
            self.str=self.function(*self.args, **self.kwargs)
        return self.str

def reverse(*args, **kwargs):
    return lazy_string(urlresolvers.reverse, *args, **kwargs)

Just use

from lazy import reverse

instead of

from django.core.urlresovlers import reverse

Should be possible to solve this using our existing django.utils.functional.lazy() function to create lazy_reverse. Reinventing that wheel is something to avoid. reverse() is a function that returns a unicode object (we should ensure that it does return unicode and not str). So there are a few things to do here: auditing existing reverse, hooking up reverse_lazy, documentation, tests, etc, but that sounds like a plan. At least in my head.

I think it is better to alter reverse() than to invent a new method lazy_reverse(). The recursive import error results in very strange Exceptions: Modules are missing methods/attributes that are in the source code. It took me some time to find out what's wrong, although I am using Python since seven years.

This urls.py works as expected (redirects from / to /comehere/), so django.utils.functional.lazy() seems to work as mtredinnick suggested:

from django.conf.urls.defaults import *
from django.core.urlresolvers import reverse
from django.utils.functional import lazy
from django.http import HttpResponse

reverse_lazy = lazy(reverse, unicode)

urlpatterns = patterns('',
    url(r'^comehere/', lambda request: HttpResponse('Welcome!'), name='comehere'),
    url(r'^$', 'django.views.generic.simple.redirect_to',
        {'url': reverse_lazy('comehere')}, name='root')
)

Patch provides a new reverse_lazy function (with documentation), and changes the user_passes_test decorator function to not use the login_url at runtime.

I'm not quite sure how you'd test this, since it'd require testing it before the URL names map is loaded.

PS: for anyone code reviewing, yes str is the right type instead of unicode, since reverse passes through iri_to_uri which converts it to a string type.

If anyone needs this functionality currently, here's a stand-alone object I created which works well enough:

from django.core.urlresolvers import reverse
from django.utils.functional import LazyObject


class ReverseLazy(LazyObject):
    """
    A lazily evaluated URL reversing object.

    Takes identical arguments to the ``reverse`` method in
    ``django.core.urlresolvers``.

    """

    def __init__(self, viewname, *args, **kwargs):
        self.__dict__['_reverse_args'] = (viewname,) + args
        self.__dict__['_reverse_kwargs'] = kwargs
        super(ReverseLazy, self).__init__()

    def _setup(self):
        self._wrapped = reverse(*self._reverse_args, **self._reverse_kwargs)

    def __nonzero__(self):
        """
        Always assuming a boolean check passes.

        This avoids one test in the ``user_passes_test`` decorator generator 
        in ``django.contrib.auth``.

        """
        return True

    def __str__(self):
        self._setup()
        return str(self._wrapped)