def test_create_access(self):
        access_data = {}
        access = MagicMock()
        process_data = {}
        process = MagicMock()

        with patch('audit_tools.audit.models.models_factory._access_factory', return_value=access) as af_mock, \
                patch('audit_tools.audit.models.models_factory.cache') as cache_mock:
            cache_mock.get_process.return_value = process
            result = create_access(access_data, process_data)

        self.assertIn('process', access_data)
        self.assertEqual(cache_mock.get_process.call_count, 1)
        self.assertEqual(af_mock.call_count, 1)
        self.assertEqual(result, access)
    def test_create_access(self):
        access_data = {}
        access = MagicMock()
        process_data = {}
        process = MagicMock()

        with patch('audit_tools.audit.models.models_factory._access_factory', return_value=access) as af_mock, \
                patch('audit_tools.audit.models.models_factory.cache') as cache_mock:
            cache_mock.get_process.return_value = process
            result = create_access(access_data, process_data)

        self.assertIn('process', access_data)
        self.assertEqual(cache_mock.get_process.call_count, 1)
        self.assertEqual(af_mock.call_count, 1)
        self.assertEqual(result, access)
Пример #3
0
    def process_view(self, request, view_func, view_args, view_kwargs):
        """Preprocess request.

        :param request: Http request.
        :type request: django.http.HttpRequest
        :param view_func: View.
        :type view_func: callable
        :param view_args: View arguments.
        :type view_args: list
        :param view_kwargs: View keyword arguments.
        :type view_kwargs: dict
        :return: None
        """
        self._disabled = getattr(view_func, 'disable_audit', False)

        if not self._disabled:
            try:
                view_data = self._extract_view_data(view_func, view_args, view_kwargs)

                self._blacklisted = self._check_blacklist(request.path, view_data['app'])

                msg = "<Process View> View:%s %s", view_data['full_name'], 'BlackList' if self._blacklisted else ''
                logger.debug(msg)

                if not self._blacklisted:
                    self._view = view_data
                    user = self._extract_user_data(request)

                    # Time
                    self._time = {
                        'request': datetime.datetime.now(),
                        'response': None
                    }

                    # Interlink ID
                    interlink_id = get_access_interlink_id()

                    # Create access
                    access = {
                        'interlink_id': interlink_id,
                        'request': request_to_dict(request),
                        'response': None,
                        'time': self._time,
                        'view': self._view,
                        'user': user,
                        'custom': None,
                    }

                    # Extract process data
                    self._process = extract_process_data()

                    # Save Access
                    self._access = create_access(access, self._process)
                    cache.set_last_access(self._access)

                    if not settings.RUN_ASYNC:
                        save_access(self._access)
                    else:
                        save_access.apply_async((self._access, ))
                    logger.info("<Process View> View:%s", self._view['full_name'])

                    logger.debug("View:%s", str(self._view))
            except Exception:
                logger.exception("<Process View>")

        return None