6945257754

Committed 21 Nov 2023 02:30PM UTC coverage: 75.286% (-2.1%) from 77.352%

Build # 6945257754

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #68 from thorgate/updates

Updates w.r.t. web-eid

Run Details

383 of 560 branches covered (0.0%)

Branch coverage included in aggregate %.

89 of 156 new or added lines in 15 files covered. (57.05%)

3 existing lines in 2 files now uncovered.

1588 of 2058 relevant lines covered (77.16%)

0.77 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

66.67

/esteid/authentication/views.py

import logging
from typing import Type, TYPE_CHECKING

from django.http import HttpRequest, JsonResponse

from esteid.exceptions import ActionInProgress
from esteid.mixins import DjangoRestCompatibilityMixin, SessionViewMixin

from .authenticator import Authenticator
from .types import AuthenticationResult


try:
    from rest_framework.exceptions import ValidationError as DRFValidationError
except ImportError:
    # If rest framework is not installed, create a stub class so the isinstance check is always false
    class DRFValidationError:
        pass


if TYPE_CHECKING:
    # Make type checkers aware of request.session attribute which is missing on the HttpRequest class
    from django.contrib.sessions import base_session

    class RequestType(HttpRequest):
        session: base_session.AbstractBaseSession
        data: dict


logger = logging.getLogger(__name__)


def get_origin(request):
    origin = f"{request.scheme}://{request.get_host()}"

    return origin


class AuthenticationViewMixin(SessionViewMixin):
    # these come from the `url()` definition as in `View.as_view(authentication_method='...')`, either one is enough
    authentication_method: str = None
    authenticator: Type[Authenticator] = None

    def on_auth_success(self, request, data: AuthenticationResult):
        """
        A hook to make use of the authentication data once the process is complete.

        May be used to store the data into session, authenticate a user etc.
        """
        pass

    def success_response(self, request, data: AuthenticationResult):
        """Customizable response on success"""
        return JsonResponse({**data, "status": self.Status.SUCCESS})

    def select_authenticator_class(self) -> Type["Authenticator"]:
        if self.authenticator is not None:
            return self.authenticator
        return Authenticator.select_authenticator(self.authentication_method)

    def start_session(self, request: "RequestType", *args, **kwargs):
        """
        Initiates an authentication session.
        """

        auth_class = self.select_authenticator_class()
        authenticator = auth_class.start_session(request.session, request.data, origin=get_origin(request))

        do_cleanup = True

        try:
            result = authenticator.authenticate()

        except ActionInProgress as e:
            do_cleanup = False
            # return SUCCESS to indicate that the upstream service successfully accepted the request
            return JsonResponse({"status": self.Status.SUCCESS, **e.data}, status=e.status)

        else:
            # Handle a theoretical case of immediate authentication
            self.on_auth_success(request, result)
            return JsonResponse({**result, "status": self.Status.SUCCESS})

        finally:
            if do_cleanup:
                authenticator.cleanup()

    def finish_session(self, request: "RequestType", *args, **kwargs):
        """
        Checks the status of an authentication session
        """
        authenticator_class = self.select_authenticator_class()
        authenticator = authenticator_class.load_session(request.session, origin=get_origin(request))

        do_cleanup = True

        try:
            result = authenticator.poll(request.data)

        except ActionInProgress as e:
            do_cleanup = False
            return JsonResponse({"status": self.Status.PENDING, **e.data}, status=e.status)

        else:
            self.on_auth_success(request, result)
            return self.success_response(request, result)

        finally:
            if do_cleanup:
                authenticator.cleanup()

    def handle_delete_request(self, request):
        authenticator_class = self.select_authenticator_class()
        authenticator = authenticator_class.load_session(request.session, origin=get_origin(request))

        authenticator.cleanup()


class AuthenticationViewRestMixin(AuthenticationViewMixin):
    """
    To be used with rest-framework's APIView.
    """

    def delete(self, request, *args, **kwargs):
        self.handle_delete_request(request)

        return JsonResponse({"status": self.Status.CANCELLED})


class AuthenticationViewDjangoMixin(DjangoRestCompatibilityMixin, AuthenticationViewMixin):
    """
    To be used with plain Django class-based views (No rest-framework).

    Adds `data` attribute to the request with the POST or JSON data.
    """

    def delete(self, request, *args, **kwargs):
        self.handle_delete_request(request)

        return JsonResponse({"status": self.Status.CANCELLED})

1	import logging	1✔
2	from typing import Type, TYPE_CHECKING	1✔
3
4	from django.http import HttpRequest, JsonResponse	1✔
5
6	from esteid.exceptions import ActionInProgress	1✔
7	from esteid.mixins import DjangoRestCompatibilityMixin, SessionViewMixin	1✔
8
9	from .authenticator import Authenticator	1✔
10	from .types import AuthenticationResult	1✔
11
12
13	try:	1✔
14	from rest_framework.exceptions import ValidationError as DRFValidationError	1✔
15	except ImportError:	×
16	# If rest framework is not installed, create a stub class so the isinstance check is always false
17	class DRFValidationError:	×
18	pass	×
19
20
21	if TYPE_CHECKING:	1!
22	# Make type checkers aware of request.session attribute which is missing on the HttpRequest class
23	from django.contrib.sessions import base_session	×
24
25	class RequestType(HttpRequest):	×
26	session: base_session.AbstractBaseSession	×
27	data: dict	×
28
29
30	logger = logging.getLogger(__name__)	1✔
31
32
33	def get_origin(request):	1✔
34	origin = f"{request.scheme}://{request.get_host()}"	1✔
35
36	return origin	1✔
37
38
39	class AuthenticationViewMixin(SessionViewMixin):	1✔
40	# these come from the `url()` definition as in `View.as_view(authentication_method='...')`, either one is enough
41	authentication_method: str = None	1✔
42	authenticator: Type[Authenticator] = None	1✔
43
44	def on_auth_success(self, request, data: AuthenticationResult):	1✔
45	"""
46	A hook to make use of the authentication data once the process is complete.
47
48	May be used to store the data into session, authenticate a user etc.
49	"""
50	pass	×
51
52	def success_response(self, request, data: AuthenticationResult):	1✔
53	"""Customizable response on success"""
54	return JsonResponse({**data, "status": self.Status.SUCCESS})	1✔
55
56	def select_authenticator_class(self) -> Type["Authenticator"]:	1✔
57	if self.authenticator is not None:	1!
58	return self.authenticator	1✔
59	return Authenticator.select_authenticator(self.authentication_method)	×
60
61	def start_session(self, request: "RequestType", args, *kwargs):	1✔
62	"""
63	Initiates an authentication session.
64	"""
65
66	auth_class = self.select_authenticator_class()	1✔
67	authenticator = auth_class.start_session(request.session, request.data, origin=get_origin(request))	1✔
68
69	do_cleanup = True	1✔
70
71	try:	1✔
72	result = authenticator.authenticate()	1✔
73
74	except ActionInProgress as e:	1✔
75	do_cleanup = False	1✔
76	# return SUCCESS to indicate that the upstream service successfully accepted the request
77	return JsonResponse({"status": self.Status.SUCCESS, **e.data}, status=e.status)	1✔
78
79	else:
80	# Handle a theoretical case of immediate authentication
81	self.on_auth_success(request, result)	×
82	return JsonResponse({**result, "status": self.Status.SUCCESS})	×
83
84	finally:
85	if do_cleanup:	1!
86	authenticator.cleanup()	×
87
88	def finish_session(self, request: "RequestType", args, *kwargs):	1✔
89	"""
90	Checks the status of an authentication session
91	"""
92	authenticator_class = self.select_authenticator_class()	1✔
93	authenticator = authenticator_class.load_session(request.session, origin=get_origin(request))	1✔
94
95	do_cleanup = True	1✔
96
97	try:	1✔
98	result = authenticator.poll(request.data)	1✔
99
100	except ActionInProgress as e:	×
101	do_cleanup = False	×
102	return JsonResponse({"status": self.Status.PENDING, **e.data}, status=e.status)	×
103
104	else:
105	self.on_auth_success(request, result)	1✔
106	return self.success_response(request, result)	1✔
107
108	finally:
109	if do_cleanup:	1!
110	authenticator.cleanup()	1✔
111
112	def handle_delete_request(self, request):	1✔
NEW 113	authenticator_class = self.select_authenticator_class()	×
NEW 114	authenticator = authenticator_class.load_session(request.session, origin=get_origin(request))	×
115
NEW 116	authenticator.cleanup()	×
117
118
119	class AuthenticationViewRestMixin(AuthenticationViewMixin):	1✔
120	"""
121	To be used with rest-framework's APIView.
122	"""
123
124	def delete(self, request, args, *kwargs):	1✔
NEW 125	self.handle_delete_request(request)	×
126
NEW 127	return JsonResponse({"status": self.Status.CANCELLED})	×
128
129
130	class AuthenticationViewDjangoMixin(DjangoRestCompatibilityMixin, AuthenticationViewMixin):	1✔
131	"""
132	To be used with plain Django class-based views (No rest-framework).
133
134	Adds `data` attribute to the request with the POST or JSON data.
135	"""
136
137	def delete(self, request, args, *kwargs):	1✔
NEW 138	self.handle_delete_request(request)	×
139
NEW 140	return JsonResponse({"status": self.Status.CANCELLED})	×

thorgate / django-esteid / 6945257754

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous