Coverage for requests_tracker/views.py: 100%

1from datetime import datetime 

2from typing import Dict, Optional, Tuple, Union 

3from uuid import UUID 

4 

5from django.conf import settings 

6from django.template.response import TemplateResponse 

7from django.views.debug import get_default_exception_reporter_filter 

8 

9from requests_tracker.main_request_collector import MainRequestCollector 

10from requests_tracker.middleware import RequestWithCollectors 

11 

12RequestsType = Dict[UUID, MainRequestCollector] 

13 

14 

15def is_htmx_request(request: RequestWithCollectors) -> bool: 

16 return request.headers.get("HX-Request", "").lower() == "true" 

17 

18 

19def is_htmx_search_or_sort_request(request: RequestWithCollectors) -> bool: 

20 return request.headers.get("HX-Target") == "request-list-search-results" 

21 

22 

23def sort_requests( 

24 requests: RequestsType, 

25 requests_sorter: str, 

26 requests_direction: str, 

27) -> RequestsType: 

28 def sort_func( 

29 item: Tuple[UUID, MainRequestCollector], 

30 ) -> Optional[Union[str, int, datetime]]: 

31 _, request = item 

32 if requests_sorter == "time": 

33 return request.start_time 

34 elif requests_sorter == "duration": 

35 return request.duration 

36 elif requests_sorter == "name": 

37 return str(request.request.path) 

38 elif requests_sorter == "view": 

39 return request.django_view 

40 elif requests_sorter == "query_count": 

41 return request.sql_collector.num_queries 

42 elif requests_sorter == "duplicate_query_count": 

43 return request.sql_collector.total_duplicate_queries 

44 elif requests_sorter == "similar_query_count": 

45 return request.sql_collector.total_similar_queries 

46 else: 

47 return request.start_time 

48 

49 reverse = requests_direction != "ascending" 

50 return dict( 

51 sorted(requests.items(), key=sort_func, reverse=reverse) # type: ignore 

52 ) 

53 

54 

55def index(request: RequestWithCollectors) -> TemplateResponse: 

56 requests_filter = request.GET.get("requests_filter", "") 

57 requests_sorter = request.GET.get("requests_sorter", "time") 

58 requests_direction = request.GET.get("requests_direction", "") 

59 

60 sorted_requests = sort_requests( 

61 request.request_collectors, 

62 requests_sorter, 

63 requests_direction, 

64 ) 

65 

66 requests = { 

67 request_id: request_collector.get_as_context() 

68 for request_id, request_collector in list(sorted_requests.items()) 

69 if not requests_filter 

70 or request_collector.matches_search_filter(requests_filter) 

71 } 

72 

73 template = "index.html" 

74 

75 if is_htmx_search_or_sort_request(request): 

76 template = "partials/request_list_only_partial.html" 

77 elif is_htmx_request(request): 

78 template = "partials/request_list_partial.html" 

79 

80 return TemplateResponse( 

81 request, 

82 template, 

83 context={ 

84 "requests": requests, 

85 "requests_filter": requests_filter, 

86 "requests_sorter": requests_sorter, 

87 "requests_direction": requests_direction, 

88 }, 

89 ) 

90 

91 

92def single_request_item( 

93 request: RequestWithCollectors, request_id: UUID 

94) -> TemplateResponse: 

95 return TemplateResponse( 

96 request, 

97 "partials/request_list_item.html", 

98 context={ 

99 "request": request.request_collectors[request_id], 

100 "request_id": request_id, 

101 }, 

102 ) 

103 

104 

105def clear_request_list(request: RequestWithCollectors) -> TemplateResponse: 

106 return index(request) 

107 

108 

109def request_details( 

110 request: RequestWithCollectors, 

111 request_id: Union[str, UUID], 

112) -> TemplateResponse: 

113 template = ( 

114 "partials/request_details_partial.html" 

115 if is_htmx_request(request) 

116 else "request_details.html" 

117 ) 

118 context = request.request_collectors[UUID(str(request_id))].get_as_context() 

119 

120 return TemplateResponse(request=request, template=template, context=context) 

121 

122 

123get_safe_settings = get_default_exception_reporter_filter().get_safe_settings 

124 

125 

126def django_settings(request: RequestWithCollectors) -> TemplateResponse: 

127 return TemplateResponse( 

128 request=request, 

129 template="django_settings.html", 

130 context={ 

131 "django_settings": dict(sorted(get_safe_settings().items())), 

132 "django_settings_module": settings.SETTINGS_MODULE, 

133 }, 

134 )