django-cms-qe 3.4.2__py3-none-any.whl → 3.5.0__py3-none-any.whl

cms_qe/tests/test_errors.py

@@ -0,0 +1,61 @@
+from unittest.mock import patch
+
+from django.contrib.auth.models import AnonymousUser
+from django.test import RequestFactory, TestCase
+
+from cms_qe.views import handler500
+from cms_qe_test.cms import create_page
+
+
+def test_page_found(client):
+    create_page('Test page', page_params={'slug': 'test'})
+    html = client.get('/en/test/').content
+    assert b'<h1>Generic error</h1>' not in html
+    assert b'<title>Test page</title>' in html
+
+
+def test_page_not_found(client):
+    html = client.get('/en/non-existing-page/').content
+    assert b'<h1>Generic error</h1>' in html
+    assert b'error404' in html
+
+
+def test_page_not_found_custom_by_cms(client):
+    create_page('custom page not found', page_params={'slug': 'error404'})
+    response = client.get('/en/non-existing-page/')
+    assert response.status_code == 404
+    html = response.content
+    assert b'<h1>Generic error</h1>' not in html
+    assert b'<title>custom page not found</title>' in html
+
+
+def test_page_not_found_cached_custom_by_cms(client):
+    create_page('custom page not found', page_params={'slug': 'error404'})
+    # First request store page into the cache
+    response = client.get('/en/non-existing-page/')
+    assert response.status_code == 404
+    # Second request is taken from the cache.
+    response = client.get('/en/non-existing-page/')
+    assert response.get('QE-Status-Code') is None
+    assert response.status_code == 404
+
+
+class Handler500Test(TestCase):
+    def test_template_rendered(self):
+        request = RequestFactory().get("/500")
+        request.current_page = None
+        request.session = {}
+        request.user = AnonymousUser()
+        response = handler500(request)
+        self.assertContains(response, '<h1>Internal error</h1>', status_code=500)
+        self.assertContains(response, 'Something went very wrong. Please try again later.', status_code=500)
+
+    @patch('cms_qe.views.errors.render', side_effect=Exception("Fail!"))
+    def test_template_failure(self, render_mock):
+        request = RequestFactory().get("/500")
+        request.current_page = None
+        request.session = {}
+        request.user = AnonymousUser()
+        response = handler500(request)
+        self.assertContains(response, '<h1>Internal error</h1>', status_code=500)
+        self.assertContains(response, 'Something went very wrong. Please try again later.', status_code=500)

cms_qe/tests/test_export.py

@@ -0,0 +1,108 @@
+import csv
+import io
+import json
+from unittest.mock import patch
+
+import pytest
+from django.contrib.auth import get_user_model
+from pytest_data import use_data
+
+from ..export import export_data, export_file, get_supported_export_types
+
+
+class ModelAdmin:
+    list_display = ('foo',)
+
+    def foo(self, obj):
+        return 'foo property'
+
+
+class ExportDataAdmin(ModelAdmin):
+
+    def export_data(self, export_type, queryset):
+        return 'foo export_data'
+
+
+@pytest.mark.django_db
+@use_data(user_data={'username': 'test_export_data_as_csv'})
+def test_export_data_as_csv(user):
+    User = get_user_model()
+    queryset = User.objects.all()
+    data = export_data('csv', ModelAdmin(), queryset)
+    data = list(csv.reader(io.StringIO(data)))
+    assert len(data) == 2
+    assert 'test_export_data_as_csv' in data[1]
+    assert 'foo property' in data[1]
+
+
+@pytest.mark.django_db
+@use_data(user_data={'username': 'test_export_data_as_tsv'})
+def test_export_data_as_tsv(user):
+    User = get_user_model()
+    queryset = User.objects.all()
+    data = export_data('tsv', ModelAdmin(), queryset)
+    data = list(csv.reader(io.StringIO(data), delimiter='\t'))
+    assert len(data) == 2
+    assert 'test_export_data_as_tsv' in data[1]
+    assert 'foo property' in data[1]
+
+
+@pytest.mark.django_db
+@use_data(user_data={'username': 'test_export_data_as_json'})
+def test_export_data_as_json(user):
+    User = get_user_model()
+    queryset = User.objects.all()
+    data = export_data('json', ModelAdmin(), queryset)
+    data = json.loads(data)
+    assert len(data) == 1
+    assert data[0]['username'] == 'test_export_data_as_json'
+    assert data[0]['foo'] == 'foo property'
+
+
+@pytest.mark.django_db
+@use_data(user_data={'username': 'test_export_data_as_json'})
+def test_export_data_admin_function(user):
+    User = get_user_model()
+    queryset = User.objects.all()
+    data = export_data('foo', ExportDataAdmin(), queryset)
+    assert data == 'foo export_data'
+
+
+@pytest.mark.django_db
+@use_data(user_data={'username': 'test_export_data_as_json'})
+def test_export_file():
+    User = get_user_model()
+    queryset = User.objects.all()
+    response = export_file('csv', ModelAdmin(), queryset)
+    assert response['content-disposition'] == 'attachment; ' \
+        'filename="export.csv"'
+    assert response.content == b'ID,password,last login,superuser ' \
+        b'status,username,first name,last name,email address,staff ' \
+        b'status,active,date joined,groups,user permissions,foo\r\n'
+
+
+def test_get_supported_export_types():
+    with patch('cms_qe.export.getattr') as mock_getattr:
+        mock_getattr.side_effect = [
+            'csv', 'html', 'json', 'latex', 'ods', 'rst', 'tsv', 'xls',
+            'xlsx', 'yaml']
+        data = get_supported_export_types()
+    assert sorted(data.keys()) == [
+        'csv', 'html', 'json', 'latex', 'ods', 'rst', 'tsv', 'xls', 'xlsx',
+        'yaml']
+    assert data['csv'].mimetype == 'text/csv'
+    assert data['csv'].label == 'Export selected as CSV'
+
+
+def test_get_supported_export_types_import_error():
+    with patch('cms_qe.export.getattr') as mock_getattr:
+        mock_getattr.side_effect = ImportError()
+        data = get_supported_export_types()
+    assert data == {}
+
+
+def test_get_supported_export_types_attribute_error():
+    with patch('cms_qe.export.getattr') as mock_getattr:
+        mock_getattr.side_effect = AttributeError()
+        data = get_supported_export_types()
+    assert data == {}

cms_qe/tests/test_monitoring.py

@@ -0,0 +1,15 @@
+import json
+
+from cms_qe.views import get_monitoring_data
+
+
+def test_get_monitoring_data():
+    data = get_monitoring_data()
+    assert data['status']
+    assert 'cms_qe' in data['app_details']
+
+
+def test_monitoring_view(client):
+    result = client.get('/api/monitoring').content
+    data = json.loads(str(result, 'utf8'))
+    assert data['status']

cms_qe/tests/test_utils.py

@@ -0,0 +1,77 @@
+from unittest.mock import patch
+
+import pytest
+from django.test import override_settings
+from mailqueue.models import MailerMessage
+from pytest_data import use_data
+
+from cms_qe.utils import get_base_url, get_functions, get_module, get_modules
+
+
+@pytest.mark.parametrize('expect,module_name', [
+    (True, 'views'),
+    (True, 'views.monitoring'),
+    (False, 'no_module'),
+    (False, 'monitoring.get_status'),
+])
+def test_get_module(expect, module_name):
+    module = get_module('cms_qe', module_name)
+    assert module if expect else module is None
+
+
+def test_get_modules():
+    modules = get_modules('monitoring')
+    assert [module for app_name, module in modules if app_name == 'cms_qe']
+
+
+def test_get_functions():
+    functions = get_functions('monitoring', 'get_status')
+    assert [function for app_name, function in functions if app_name == 'cms_qe']
+
+
+def test_get_functions_existing_module_without_function():
+    functions = get_functions('monitoring', 'no_function')
+    assert not list(functions)
+
+
+@override_settings(META_SITE_PROTOCOL='https', )
+def test_get_absolute_url(post_request_empty):
+    request = post_request_empty
+    mock_url = 'test.com'
+    with patch('cms_qe.utils.get_current_site', return_value=mock_url):
+        base_url = get_base_url(request)
+    assert base_url == f'https://{mock_url}'
+
+
+def test_sending_email_synchronously(email, mailoutbox):
+    assert len(mailoutbox) == 0
+    email.save()
+    assert len(mailoutbox) == 1
+    sent_mail = mailoutbox[0]
+    assert 'Test content' in sent_mail.body
+    assert 'Test' in sent_mail.subject
+
+
+@override_settings(MAILQUEUE_QUEUE_UP=True)
+def test_sending_email_asynchronously(email, mailoutbox):
+    assert MailerMessage.objects.all().count() == 0
+    email.save()
+    assert len(mailoutbox) == 0
+    assert MailerMessage.objects.all().count() == 1
+    assert 'Test content' in MailerMessage.objects.all().first().content
+
+
+@use_data(email_data={'to': ['test1@examile.com', 'test2@examile.com']})
+def test_sending_email_synchronously_more_addressee(email, mailoutbox):
+    email.save()
+    assert len(mailoutbox) == 1
+    sent_mail = mailoutbox[0]
+    assert len(sent_mail.to) == 2
+
+
+@use_data(email_data={'to': ['test1@examile.com', 'test2@examile.com']})
+@override_settings(MAILQUEUE_QUEUE_UP=True)
+def test_sending_email_asynchronously_more_to_addressee(email, mailoutbox):
+    email.save()
+    assert MailerMessage.objects.all().count() == 1
+    assert MailerMessage.objects.all().first().to_address == 'test1@examile.com, test2@examile.com'

cms_qe/tests/test_views_security.py

@@ -0,0 +1,18 @@
+from constance import config
+from django.test import TestCase
+from django.urls import reverse
+
+
+class SecurityTxtViewTest(TestCase):
+
+    def test_not_content(self):
+        config.SECURITY_TXT_CONTENT = None
+        response = self.client.get(reverse('security-txt'))
+        self.assertRedirects(response, "/en/.well-known/security.txt/",
+                             status_code=302, target_status_code=404)
+
+    def test_content(self):
+        config.SECURITY_TXT_CONTENT = 'Contact: https://abuse.foo'
+        response = self.client.get(reverse('security-txt'))
+        self.assertContains(response, b'Contact: https://abuse.foo')
+        self.assertEqual(response['Content-Type'], 'text/plain')

cms_qe/views/maintenance.py

@@ -2,6 +2,7 @@ from django.conf import settings
 from django.contrib.sites.models import Site
 from django.core.cache import cache
 from django.http import HttpRequest, HttpResponse
+from django.utils.module_loading import import_string
 from django.views import View
 
 from cms_qe.signals import run_subprocess
@@ -21,6 +22,11 @@ class HealthCheckView(View):
         cache.set(key, 'OK', 2)
         if cache.get(key) != 'OK':
             raise RuntimeError('cache')
+        # More checks if defined in HEALTHCHECK_FUNCTIONS = ["path1.to.fnc, "path2.to.fnc"].
+        if hasattr(settings, "HEALTHCHECK_FUNCTIONS"):
+            for path in settings.HEALTHCHECK_FUNCTIONS:
+                fnc = import_string(path)
+                fnc(request, *args, **kwargs)
         return HttpResponse("OK", content_type="text/plain")
 
 

cms_qe_analytical/tests/settings.py

@@ -0,0 +1,24 @@
+"""
+django-analytical testing settings.
+"""
+
+DATABASES = {
+    'default': {
+        'ENGINE': 'django.db.backends.sqlite3',
+        'NAME': ':memory:',
+    }
+}
+
+INSTALLED_APPS = [
+    'django.contrib.sites',
+    'django.contrib.contenttypes',
+    'django.contrib.auth',
+    'analytical',
+]
+
+SECRET_KEY = 'testing'
+
+MIDDLEWARE_CLASSES = (
+    'django.middleware.common.CommonMiddleware',
+    'django.middleware.csrf.CsrfViewMiddleware',
+)

cms_qe_analytical/tests/templatetags/dummy.py

@@ -0,0 +1,37 @@
+"""
+Dummy testing template tags and filters.
+"""
+
+
+from analytical.templatetags.analytical import TAG_LOCATIONS
+from django.template import Library, Node, TemplateSyntaxError
+
+register = Library()
+
+
+def _location_node(location):
+    class DummyNode(Node):
+        def render(self, context):
+            return f"<!-- dummy_{location} -->"
+    return DummyNode
+
+
+_location_nodes = {loc: _location_node(loc) for loc in TAG_LOCATIONS}
+
+
+def _location_tag(location):
+    def dummy_tag(parser, token):
+        bits = token.split_contents()
+        if len(bits) > 1:
+            raise TemplateSyntaxError(f"'{bits[0]}' tag takes no arguments")
+        return _location_nodes[location]
+    return dummy_tag
+
+
+for loc in TAG_LOCATIONS:
+    register.tag(f'dummy_{loc}', _location_tag(loc))
+
+
+def contribute_to_analytical(add_node_cls):
+    for location in TAG_LOCATIONS:
+        add_node_cls(location, _location_nodes[location])

cms_qe_analytical/tests/test_tag_google_analytics.py

@@ -0,0 +1,178 @@
+"""
+Tests for the Google Analytics template tags and filters.
+"""
+
+from constance.test import override_config
+from django.http import HttpRequest
+from django.template import Context
+from django.test import override_settings
+
+from ..templatetags.google_analytics import (SCOPE_PAGE, SCOPE_SESSION, SCOPE_VISITOR, TRACK_MULTIPLE_DOMAINS,
+                                             TRACK_MULTIPLE_SUBDOMAINS, TRACK_SINGLE_DOMAIN, GoogleAnalyticsNode)
+from ..tests.utils import TagTestCase
+from ..utils import AnalyticalException
+
+
+@override_settings(GOOGLE_ANALYTICS_TRACKING_STYLE=TRACK_SINGLE_DOMAIN)
+@override_config(GOOGLE_ANALYTICS_PROPERTY_ID='UA-123456-7')
+class GoogleAnalyticsTagTestCase(TagTestCase):
+    """
+    Tests for the ``google_analytics`` template tag.
+    """
+
+    def test_tag(self):
+        r = self.render_tag('google_analytics', 'google_analytics')
+        self.assertTrue("_gaq.push(['_setAccount', 'UA-123456-7']);" in r, r)
+        self.assertTrue("_gaq.push(['_trackPageview']);" in r, r)
+
+    def test_node(self):
+        r = GoogleAnalyticsNode().render(Context())
+        self.assertTrue("_gaq.push(['_setAccount', 'UA-123456-7']);" in r, r)
+        self.assertTrue("_gaq.push(['_trackPageview']);" in r, r)
+
+    @override_config(GOOGLE_ANALYTICS_PROPERTY_ID='wrong')
+    def test_wrong_property_id(self):
+        self.assertEqual(GoogleAnalyticsNode().render({}), '')
+
+    @override_settings(
+        GOOGLE_ANALYTICS_TRACKING_STYLE=TRACK_MULTIPLE_SUBDOMAINS,
+        GOOGLE_ANALYTICS_DOMAIN='example.com')
+    def test_track_multiple_subdomains(self):
+        r = GoogleAnalyticsNode().render(Context())
+        self.assertTrue("_gaq.push(['_setDomainName', 'example.com']);" in r, r)
+        self.assertTrue("_gaq.push(['_setAllowHash', false]);" in r, r)
+
+    @override_settings(GOOGLE_ANALYTICS_TRACKING_STYLE=TRACK_MULTIPLE_DOMAINS,
+                       GOOGLE_ANALYTICS_DOMAIN='example.com')
+    def test_track_multiple_domains(self):
+        r = GoogleAnalyticsNode().render(Context())
+        self.assertTrue("_gaq.push(['_setDomainName', 'example.com']);" in r, r)
+        self.assertTrue("_gaq.push(['_setAllowHash', false]);" in r, r)
+        self.assertTrue("_gaq.push(['_setAllowLinker', true]);" in r, r)
+
+    def test_custom_vars(self):
+        context = Context({
+            'google_analytics_var1': ('test1', 'foo'),
+            'google_analytics_var2': ('test2', 'bar', SCOPE_VISITOR),
+            'google_analytics_var4': ('test4', 'baz', SCOPE_SESSION),
+            'google_analytics_var5': ('test5', 'qux', SCOPE_PAGE),
+        })
+        r = GoogleAnalyticsNode().render(context)
+        self.assertTrue("_gaq.push(['_setCustomVar', 1, 'test1', 'foo', 3]);"
+                        in r, r)
+        self.assertTrue("_gaq.push(['_setCustomVar', 2, 'test2', 'bar', 1]);"
+                        in r, r)
+        self.assertTrue("_gaq.push(['_setCustomVar', 4, 'test4', 'baz', 2]);"
+                        in r, r)
+        self.assertTrue("_gaq.push(['_setCustomVar', 5, 'test5', 'qux', 3]);"
+                        in r, r)
+
+    @override_config(GOOGLE_ANALYTICS_SITE_SPEED=True)
+    def test_track_page_load_time(self):
+        r = GoogleAnalyticsNode().render(Context())
+        self.assertTrue("_gaq.push(['_trackPageLoadTime']);" in r, r)
+
+    def test_display_advertising(self):
+        with override_config(GOOGLE_ANALYTICS_DISPLAY_ADVERTISING=False):
+            r = GoogleAnalyticsNode().render(Context())
+            self.assertTrue("google-analytics.com/ga.js" in r, r)
+        with override_config(GOOGLE_ANALYTICS_DISPLAY_ADVERTISING=True):
+            r = GoogleAnalyticsNode().render(Context())
+            self.assertTrue("stats.g.doubleclick.net/dc.js" in r, r)
+
+    @override_settings(ANALYTICAL_INTERNAL_IPS=['1.1.1.1'])
+    def test_render_internal_ip(self):
+        req = HttpRequest()
+        req.META['REMOTE_ADDR'] = '1.1.1.1'
+        context = Context({'request': req})
+        r = GoogleAnalyticsNode().render(context)
+        self.assertTrue(r.startswith(
+            '<!-- Google Analytics disabled on internal IP address'), r)
+        self.assertTrue(r.endswith('-->'), r)
+
+    @override_config(GOOGLE_ANALYTICS_ANONYMIZE_IP=True)
+    def test_anonymize_ip(self):
+        r = GoogleAnalyticsNode().render(Context())
+        self.assertTrue("_gaq.push (['_gat._anonymizeIp']);" in r, r)
+
+    @override_config(GOOGLE_ANALYTICS_ANONYMIZE_IP=False)
+    def test_anonymize_ip_not_present(self):
+        r = GoogleAnalyticsNode().render(Context())
+        self.assertFalse("_gaq.push (['_gat._anonymizeIp']);" in r, r)
+
+    @override_config(GOOGLE_ANALYTICS_SAMPLE_RATE=0.0)
+    def test_set_sample_rate_min(self):
+        r = GoogleAnalyticsNode().render(Context())
+        self.assertTrue("_gaq.push (['_setSampleRate', '0.00']);" in r, r)
+
+    @override_config(GOOGLE_ANALYTICS_SAMPLE_RATE='100.00')
+    def test_set_sample_rate_max(self):
+        r = GoogleAnalyticsNode().render(Context())
+        self.assertTrue("_gaq.push (['_setSampleRate', '100.00']);" in r, r)
+
+    #
+    @override_config(GOOGLE_ANALYTICS_SAMPLE_RATE=-1)
+    def test_exception_whenset_sample_rate_too_small(self):
+        context = Context()
+        self.assertRaises(AnalyticalException, GoogleAnalyticsNode().render,
+                          context)
+
+    @override_config(GOOGLE_ANALYTICS_SAMPLE_RATE=101)
+    def test_exception_when_set_sample_rate_too_large(self):
+        context = Context()
+        self.assertRaises(AnalyticalException, GoogleAnalyticsNode().render,
+                          context)
+
+    @override_config(GOOGLE_ANALYTICS_SITE_SPEED_SAMPLE_RATE=0.0)
+    def test_set_site_speed_sample_rate_min(self):
+        r = GoogleAnalyticsNode().render(Context())
+        self.assertTrue("_gaq.push (['_setSiteSpeedSampleRate', '0.00']);" in r, r)
+
+    @override_config(GOOGLE_ANALYTICS_SITE_SPEED_SAMPLE_RATE='100.00')
+    def test_set_site_speed_sample_rate_max(self):
+        r = GoogleAnalyticsNode().render(Context())
+        self.assertTrue("_gaq.push (['_setSiteSpeedSampleRate', '100.00']);" in r, r)
+
+    @override_config(GOOGLE_ANALYTICS_SITE_SPEED_SAMPLE_RATE=-1)
+    def test_exception_whenset_site_speed_sample_rate_too_small(self):
+        context = Context()
+        self.assertRaises(AnalyticalException, GoogleAnalyticsNode().render,
+                          context)
+
+    @override_config(GOOGLE_ANALYTICS_SITE_SPEED_SAMPLE_RATE=101)
+    def test_exception_when_set_site_speed_sample_rate_too_large(self):
+        context = Context()
+        self.assertRaises(AnalyticalException, GoogleAnalyticsNode().render,
+                          context)
+
+    @override_config(GOOGLE_ANALYTICS_SESSION_COOKIE_TIMEOUT=0)
+    def test_set_session_cookie_timeout_min(self):
+        r = GoogleAnalyticsNode().render(Context())
+        self.assertTrue("_gaq.push (['_setSessionCookieTimeout', '0']);" in r, r)
+
+    @override_config(GOOGLE_ANALYTICS_SESSION_COOKIE_TIMEOUT='10000')
+    def test_set_session_cookie_timeout_as_string(self):
+        r = GoogleAnalyticsNode().render(Context())
+        self.assertTrue("_gaq.push (['_setSessionCookieTimeout', '10000']);" in r, r)
+
+    @override_config(GOOGLE_ANALYTICS_SESSION_COOKIE_TIMEOUT=-1)
+    def test_exception_when_set_session_cookie_timeout_too_small(self):
+        context = Context()
+        self.assertRaises(AnalyticalException, GoogleAnalyticsNode().render,
+                          context)
+
+    @override_config(GOOGLE_ANALYTICS_VISITOR_COOKIE_TIMEOUT=0)
+    def test_set_visitor_cookie_timeout_min(self):
+        r = GoogleAnalyticsNode().render(Context())
+        self.assertTrue("_gaq.push (['_setVisitorCookieTimeout', '0']);" in r, r)
+
+    @override_config(GOOGLE_ANALYTICS_VISITOR_COOKIE_TIMEOUT='10000')
+    def test_set_visitor_cookie_timeout_as_string(self):
+        r = GoogleAnalyticsNode().render(Context())
+        self.assertTrue("_gaq.push (['_setVisitorCookieTimeout', '10000']);" in r, r)
+
+    @override_config(GOOGLE_ANALYTICS_VISITOR_COOKIE_TIMEOUT=-1)
+    def test_exception_when_set_visitor_cookie_timeout_too_small(self):
+        context = Context()
+        self.assertRaises(AnalyticalException, GoogleAnalyticsNode().render,
+                          context)