# Python standard library imports.

from types import FunctionType

# Python third-party library imports.

import mock

# Django imports.

from django.core.exceptions import PermissionDenied

from django.contrib.auth.models import User, Permission

from django.test import RequestFactory

def create_get_request(url="/fake-path/", user=None):

    """

    Helper function for generating a GET request that can be passed on to a

    view.

    Arguments:

        url - URL that should be used for the request. Default is "/fake-path/".

        user - Django user to be passed on into the request. Default is

        mock.Mock().

    """

    request = RequestFactory().get(url)

    # If user was not provided, construct one using mocking.

    if user is None:

        user = mock.Mock()

    request.user = user

    return request

def generate_get_response(view, request=None, *args, **kwargs):

    """

    Generates a get response, passing the request, positional and keyword

    arguments to it as well.

    Attributes:

        view - View function that should be called.

        request - Request object to pass into view. Default is to create a new

        request using the create_get_request() call.

        *args - Additional positional arguments that will be passed into view.

        *kwargs - Additional keyword arguments that will be passed into view.

    """

    # If no request was provided, construct it.

    if request is None:

        request = create_get_request()

    return view(request, *args, **kwargs)

class PermissionTestMixin(object):

    """

    Mixin class for testing if permission requirement is applied properly for

    accessing a view.

    In order to use this mixin, add it the left side of the class list the test

    is inheriting from, and configure it providing the following class options:

        view_class - Class used for the CBV that will be tested.

        view_function - View function that will be tested.

        sufficient_permissions - Permissions sufficient to gain access to view.

        permission_test_view_args - Positional arguments to pass to the view.

        permission_test_view_kwargs - Keyword arguments to pass to the view.

    """

    view_class = None

    view_function = None

    permission_test_view_args = ()

    permission_test_view_kwargs = {}

    sufficient_permissions = ()

    def __init__(self, *args, **kwargs):

        """

        Initialises the mixin. Takes care of some basic validation of passed

        configuration options.

        """

        super(PermissionTestMixin, self).__init__(*args, **kwargs)

        if self.view_class is None and self.view_function is None:

            raise ValueError("Permission test mixin configured improperly - no CBV class or function was supplied via parameters 'view_class' or 'view_function'.")

        if self.view_function is not None and type(self.view_function) is not FunctionType:

            raise ValueError("Permission test mixin configured improperly - provided 'view_function' is not function. Did you forget to wrap the function with staticmethod() perhaps?")

        if type(self.permission_test_view_kwargs) is not dict:

            raise ValueError("Permission text mixin configured improperly - parameter 'permission_test_view_kwargs' must be a dictionary.")

        if type(self.permission_test_view_args) is not tuple:

            raise ValueError("Permission text mixin configured improperly - parameter 'permission_test_view_args' must be a tuple.")

        if type(self.sufficient_permissions) is not tuple:

            raise ValueError("Permission text mixin configured improperly - parameter 'sufficient_permissions' must be a tuple.")

    def test_permission_granted(self):

        # Set-up a request from user with sufficient privileges.

        request = RequestFactory().get("/fake-path")

        user = User.objects.create(username="user", password="password")

        for permission in self.sufficient_permissions:

            user.user_permissions.add(Permission.objects.get(codename=permission))

        request.user = user

        # Get the view.

        if self.view_class is not None:

            view = self.view_class.as_view()

        elif self.view_function is not None:

            view = self.view_function

        # Verify that permission is granted

        args = self.permission_test_view_args

        kwargs = self.permission_test_view_kwargs

        try:

            response = view(request, *args, **kwargs)

        except PermissionDenied:

            self.fail("Failed to access view with user privileges: %s" % str(self.sufficient_permissions))

        self.assertEqual(response.status_code, 200)

    def test_permission_denied(self):

        # Set-up a request from user with insufficient privileges.

        request = RequestFactory().get("/fake-path")

        request.user = User.objects.create(username="user", password="password")

        # Get the view.

        if self.view_class:

            view = self.view_class.as_view()

        elif self.view_function:

            view = self.view_function

        # Verify that permission is denied.

        args = self.permission_test_view_args

        kwargs = self.permission_test_view_kwargs

        self.assertRaises(PermissionDenied, view, request, *args, **kwargs)

class FakeMessages(object):

    """

    Helper class for mocking the Django messages framework.

    """

    def __init__(self):

        """

        Initalises the message framework mocker.

        Set-ups the messages list prpoperty.

        """

        self.messages = []

    def add(self, level, message, extra_tags):

        """

        Adds a message.

        """

        self.messages.append(message)