import asyncio

import threading

from asgiref.sync import async_to_sync

from django.contrib.admindocs.middleware import XViewMiddleware

from django.contrib.auth.middleware import (

    AuthenticationMiddleware,

    RemoteUserMiddleware,

)

from django.contrib.flatpages.middleware import FlatpageFallbackMiddleware

from django.contrib.messages.middleware import MessageMiddleware

from django.contrib.redirects.middleware import RedirectFallbackMiddleware

from django.contrib.sessions.middleware import SessionMiddleware

from django.contrib.sites.middleware import CurrentSiteMiddleware

from django.db import connection

from django.http.request import HttpRequest

from django.http.response import HttpResponse

from django.middleware.cache import (

    CacheMiddleware,

    FetchFromCacheMiddleware,

    UpdateCacheMiddleware,

)

from django.middleware.clickjacking import XFrameOptionsMiddleware

from django.middleware.common import BrokenLinkEmailsMiddleware, CommonMiddleware

from django.middleware.csrf import CsrfViewMiddleware

from django.middleware.gzip import GZipMiddleware

from django.middleware.http import ConditionalGetMiddleware

from django.middleware.locale import LocaleMiddleware

from django.middleware.security import SecurityMiddleware

from django.test import SimpleTestCase

from django.utils.deprecation import MiddlewareMixin

class MiddlewareMixinTests(SimpleTestCase):

    middlewares = [

        AuthenticationMiddleware,

        BrokenLinkEmailsMiddleware,

        CacheMiddleware,

        CommonMiddleware,

        ConditionalGetMiddleware,

        CsrfViewMiddleware,

        CurrentSiteMiddleware,

        FetchFromCacheMiddleware,

        FlatpageFallbackMiddleware,

        GZipMiddleware,

        LocaleMiddleware,

        MessageMiddleware,

        RedirectFallbackMiddleware,

        RemoteUserMiddleware,

        SecurityMiddleware,

        SessionMiddleware,

        UpdateCacheMiddleware,

        XFrameOptionsMiddleware,

        XViewMiddleware,

    ]

    def test_repr(self):

        class GetResponse:

            def __call__(self):

                return HttpResponse()

        def get_response():

            return HttpResponse()

        self.assertEqual(

            repr(MiddlewareMixin(GetResponse())),

            "<MiddlewareMixin get_response=GetResponse>",

        )

        self.assertEqual(

            repr(MiddlewareMixin(get_response)),

            "<MiddlewareMixin get_response="

            "MiddlewareMixinTests.test_repr.<locals>.get_response>",

        )

        self.assertEqual(

            repr(CsrfViewMiddleware(GetResponse())),

            "<CsrfViewMiddleware get_response=GetResponse>",

        )

        self.assertEqual(

            repr(CsrfViewMiddleware(get_response)),

            "<CsrfViewMiddleware get_response="

            "MiddlewareMixinTests.test_repr.<locals>.get_response>",

        )

    def test_passing_explicit_none(self):

        msg = "get_response must be provided."

        for middleware in self.middlewares:

            with self.subTest(middleware=middleware):

                with self.assertRaisesMessage(ValueError, msg):

                    middleware(None)

    def test_coroutine(self):

        async def async_get_response(request):

            return HttpResponse()

        def sync_get_response(request):

            return HttpResponse()

        for middleware in self.middlewares:

            with self.subTest(middleware=middleware.__qualname__):

                # Middleware appears as coroutine if get_function is

                # a coroutine.

                middleware_instance = middleware(async_get_response)

                self.assertIs(asyncio.iscoroutinefunction(middleware_instance), True)

                # Middleware doesn't appear as coroutine if get_function is not

                # a coroutine.

                middleware_instance = middleware(sync_get_response)

                self.assertIs(asyncio.iscoroutinefunction(middleware_instance), False)

    def test_sync_to_async_uses_base_thread_and_connection(self):

        """

        The process_request() and process_response() hooks must be called with

        the sync_to_async thread_sensitive flag enabled, so that database

        operations use the correct thread and connection.

        """

        def request_lifecycle():

            """Fake request_started/request_finished."""

            return (threading.get_ident(), id(connection))

        async def get_response(self):

            return HttpResponse()

        class SimpleMiddleWare(MiddlewareMixin):

            def process_request(self, request):

                request.thread_and_connection = request_lifecycle()

            def process_response(self, request, response):

                response.thread_and_connection = request_lifecycle()

                return response

        threads_and_connections = []

        threads_and_connections.append(request_lifecycle())

        request = HttpRequest()

        response = async_to_sync(SimpleMiddleWare(get_response))(request)

        threads_and_connections.append(request.thread_and_connection)

        threads_and_connections.append(response.thread_and_connection)

        threads_and_connections.append(request_lifecycle())

        self.assertEqual(len(threads_and_connections), 4)

        self.assertEqual(len(set(threads_and_connections)), 1)